def test_update_offsets(self):
"""use the double of the old offsets to check the updated offsets.
"""
sys.stdout.write(
'BipartiteGraph -> Performing update_offsets test ...')
sys.stdout.flush()
bpgraph = BipartiteGraph(number_visibles=2,
number_hiddens=3,
initial_visible_offsets=1.0,
initial_hidden_offsets=1.0)
old_ov = copy.deepcopy(bpgraph.ov)
old_oh = copy.deepcopy(bpgraph.oh)
old_bv = copy.deepcopy(bpgraph.bv)
old_bh = copy.deepcopy(bpgraph.bh)
offset_ratio = 0.1
bpgraph.update_offsets(new_visible_offsets=2 * old_ov,
new_hidden_offsets=2 * old_oh,
update_visible_offsets=offset_ratio,
update_hidden_offsets=offset_ratio)
assert numx.all(bpgraph.ov == (1 + offset_ratio) * old_ov)
assert numx.all(bpgraph.oh == (1 + offset_ratio) * old_oh)
assert numx.all(bpgraph.bv == \
old_bv + numx.dot(old_oh, bpgraph.w.T) * offset_ratio)
assert numx.all(bpgraph.bh == \
old_bh + numx.dot(old_ov, bpgraph.w) * offset_ratio)
print(' successfully passed!')
sys.stdout.flush()
def test___init__(self):
sys.stdout.write(
'StackOfBipartiteGraphs -> Performing initialzation and property test ...'
)
sys.stdout.flush()
# Check init scalar
number_visibles1 = 2
number_hiddens1 = 4
number_visibles2 = 4
number_hiddens2 = 3
number_visibles3 = 3
number_hiddens3 = 2
numx.random.seed(42)
model1 = BipartiteGraph(number_visibles=number_visibles1,
number_hiddens=number_hiddens1,
data=None,
initial_weights=1,
initial_visible_bias=1,
initial_hidden_bias=1,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
model2 = BipartiteGraph(number_visibles=number_visibles2,
number_hiddens=number_hiddens2,
data=None,
initial_weights=2,
initial_visible_bias=2,
initial_hidden_bias=2,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
model3 = BipartiteGraph(number_visibles=number_visibles3,
number_hiddens=number_hiddens3,
data=None,
initial_weights=3,
initial_visible_bias=3,
initial_hidden_bias=3,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
stack = StackOfBipartiteGraphs([model1, model2, model3])
assert numx.all(stack.input_dim == number_visibles1)
assert numx.all(stack.output_dim == number_hiddens3)
assert numx.all(stack.num_layers == 3)
assert numx.all(stack.depth == 4)
assert numx.all(stack[1].dtype == numx.float64)
print(' successfully passed!')
sys.stdout.flush()
def test_get_parameters(self):
"""check whether the return of the function is iterable
"""
print('BipartiteGraph -> Performing get_parameters test ...')
sys.stdout.flush()
bpgraph = BipartiteGraph(number_visibles=2, number_hiddens=3)
parameter_list = bpgraph.get_parameters()
# provide more error information here
# check whether the parameter actually exisit in the instance?
assert isinstance(parameter_list, Iterable)
print('successfully passed!')
sys.stdout.flush()
def test__remove_visible_units(self):
print('BipartiteGraph -> Performing remove_visible_units test ...')
sys.stdout.flush()
bpgraph = BipartiteGraph(number_visibles=4, number_hiddens=3)
bpgraph_old = copy.deepcopy(bpgraph)
indices = (0, 1, 3)
bpgraph._remove_visible_units(indices)
compare_BipartiteGraph_after_removing(bpgraph,
bpgraph_old,
indices,
unit_type='vis')
print('successfully passed!')
sys.stdout.flush()
def test_hidden_activation(self):
"""use the double of the old offsets to check the updated offsets.
"""
print('BipartiteGraph -> Performing hidden_activation test ...')
sys.stdout.flush()
bpgraph = BipartiteGraph(number_visibles=2,
number_hiddens=3,
initial_visible_offsets=1.0,
initial_hidden_offsets=1.0)
hidact = bpgraph.hidden_activation_function.f(
numx.dot(numx.ones((1, 2)) - bpgraph.ov, bpgraph.w) + bpgraph.bh)
hidact_test = bpgraph.hidden_activation(numx.ones((1, 2)))
assert numx.all(hidact == hidact_test)
print('successfully passed!')
sys.stdout.flush()
def test__add_visible_units(self):
sys.stdout.write(
'BipartiteGraph -> Performing add_visible_units test ...')
sys.stdout.flush()
num_vis = 4
pos = num_vis / 2
init_value = 3.0
check_list = ['AUTO', init_value, 'non-scalar']
for each_case in check_list:
bpgraph = BipartiteGraph(number_visibles=num_vis, number_hiddens=3)
bpgraph_old = copy.deepcopy(bpgraph)
if each_case is 'non-scalar':
bpgraph._add_visible_units(num_new_visibles=num_vis,
position=pos,
initial_weights=bpgraph_old.w,
initial_bias=bpgraph_old.bv,
initial_offsets=bpgraph_old.ov)
check_newpart = True
else:
bpgraph._add_visible_units(num_new_visibles=num_vis,
position=pos,
initial_weights=each_case,
initial_bias=each_case,
initial_offsets=each_case)
check_newpart = False
compare_BipartiteGraph_after_adding(bpgraph, bpgraph_old, pos,
num_vis, 'vis', check_newpart)
print(' successfully passed!')
sys.stdout.flush()
def test_update_parameters(self):
"""use the old parameters to check the updated parameters
"""
print('BipartiteGraph -> Performing update_parameters test ...')
sys.stdout.flush()
bpgraph = BipartiteGraph(number_visibles=2, number_hiddens=3)
old_param = copy.deepcopy(bpgraph.get_parameters())
bpgraph.update_parameters(old_param)
for each_new_param, each_old_param in \
zip(bpgraph.get_parameters(), old_param):
assert numx.all(each_new_param == 2 * each_old_param)
print('successfully passed!')
sys.stdout.flush()
def test_forward_backward_reconstruct(self):
sys.stdout.write(
'StackOfBipartiteGraphs -> Performing forward, backward, and reconstruct test ...'
)
sys.stdout.flush()
# Check init scalar
number_visibles1 = 2
number_hiddens1 = 4
number_visibles2 = 4
number_hiddens2 = 3
number_visibles3 = 3
number_hiddens3 = 2
numx.random.seed(42)
model1 = BipartiteGraph(number_visibles=number_visibles1,
number_hiddens=number_hiddens1,
data=None,
initial_weights=1,
initial_visible_bias=1,
initial_hidden_bias=1,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
model2 = BipartiteGraph(number_visibles=number_visibles2,
number_hiddens=number_hiddens2,
data=None,
initial_weights=2,
initial_visible_bias=2,
initial_hidden_bias=2,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
model3 = BipartiteGraph(number_visibles=number_visibles3,
number_hiddens=number_hiddens3,
data=None,
initial_weights=3,
initial_visible_bias=3,
initial_hidden_bias=3,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
stack = StackOfBipartiteGraphs([model1, model2, model3])
forward_target = numx.array([[0.97356463, 0.64265444],
[0.974248, 0.64951497]])
backward_target = numx.array([[0.89076868, 0.78815199],
[0.93154994, 0.82386556]])
rec_target = numx.array([[0.85960142, 0.74341554],
[0.86000094, 0.74392953]])
assert numx.sum(
numx.abs(
stack.forward_propagate(numx.array([[1, 2], [3, 4]])) -
forward_target) < 0.000001)
assert numx.sum(
numx.abs(
stack.backward_propagate(numx.array([[1, 2], [3, 4]])) -
backward_target) < 0.000001)
assert numx.sum(
numx.abs(
stack.backward_propagate(
stack.forward_propagate(numx.array([[1, 2], [3, 4]]))) -
rec_target) < 0.000001)
assert numx.sum(
numx.abs(
stack.reconstruct(numx.array([[1, 2], [3, 4]])) -
rec_target) < 0.000001)
print(' successfully passed!')
sys.stdout.flush()
def test_append_pop(self):
sys.stdout.write(
'StackOfBipartiteGraphs -> Performing pop and append test ...')
sys.stdout.flush()
# Check init scalar
number_visibles1 = 2
number_hiddens1 = 4
number_visibles2 = 4
number_hiddens2 = 3
number_visibles3 = 3
number_hiddens3 = 2
numx.random.seed(42)
model1 = BipartiteGraph(number_visibles=number_visibles1,
number_hiddens=number_hiddens1,
data=None,
initial_weights=1,
initial_visible_bias=1,
initial_hidden_bias=1,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
model2 = BipartiteGraph(number_visibles=number_visibles2,
number_hiddens=number_hiddens2,
data=None,
initial_weights=2,
initial_visible_bias=2,
initial_hidden_bias=2,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
model3 = BipartiteGraph(number_visibles=number_visibles3,
number_hiddens=number_hiddens3,
data=None,
initial_weights=3,
initial_visible_bias=3,
initial_hidden_bias=3,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.float64)
stack = StackOfBipartiteGraphs([model1, model2])
assert numx.all(stack.input_dim == number_visibles1)
assert numx.all(stack.output_dim == number_hiddens2)
assert numx.all(stack.num_layers == 2)
assert numx.all(stack.depth == 3)
stack.append_layer(model3)
assert numx.all(stack.input_dim == number_visibles1)
assert numx.all(stack.output_dim == number_hiddens3)
assert numx.all(stack.num_layers == 3)
assert numx.all(stack.depth == 4)
assert numx.all(stack[1].dtype == numx.float64)
model2_new = BipartiteGraph(number_visibles=number_visibles2,
number_hiddens=number_hiddens2,
data=None,
initial_weights=2,
initial_visible_bias=2,
initial_hidden_bias=2,
initial_visible_offsets=0,
initial_hidden_offsets=0,
dtype=numx.int32)
stack[1] = model2_new
assert numx.all(stack[1].dtype == numx.int32)
stack.pop_last_layer()
assert numx.all(stack.input_dim == number_visibles1)
assert numx.all(stack.output_dim == number_hiddens2)
assert numx.all(stack.num_layers == 2)
assert numx.all(stack.depth == 3)
stack.append_layer(model3)
assert numx.all(stack.depth == 4)
assert numx.all(stack.output_dim == number_hiddens3)
stack.pop_last_layer()
assert numx.all(stack.input_dim == number_visibles1)
assert numx.all(stack.output_dim == number_hiddens2)
assert numx.all(stack.num_layers == 2)
assert numx.all(stack.depth == 3)
stack.pop_last_layer()
assert numx.all(stack.input_dim == number_visibles1)
assert numx.all(stack.output_dim == number_hiddens1)
assert numx.all(stack.num_layers == 1)
assert numx.all(stack.depth == 2)
stack.pop_last_layer()
assert numx.all(stack.input_dim == None)
assert numx.all(stack.output_dim == None)
assert numx.all(stack.num_layers == 0)
assert numx.all(stack.depth == 1)
stack.pop_last_layer()
assert numx.all(stack.input_dim == None)
assert numx.all(stack.output_dim == None)
assert numx.all(stack.num_layers == 0)
assert numx.all(stack.depth == 1)
print(' successfully passed!')
sys.stdout.flush()
def test___init__(self):
sys.stdout.write(
'BipartiteGraph -> Performing BipartiteGraph initialzation test ...'
)
sys.stdout.flush()
# Check init scalar
number_visibles = 3
number_hiddens = 2
numx.random.seed(42)
model = BipartiteGraph(number_visibles=number_visibles,
number_hiddens=number_hiddens,
data=None,
initial_weights=numx.random.randn(),
initial_visible_bias=numx.random.randn(),
initial_hidden_bias=numx.random.randn(),
initial_visible_offsets=numx.random.randn(),
initial_hidden_offsets=numx.random.randn())
numx.random.seed(42)
initial_weights = numx.random.randn()
initial_visible_bias = numx.random.randn() * numx.ones(
(1, number_visibles))
initial_hidden_bias = numx.random.randn() * numx.ones(
(1, number_hiddens))
initial_visible_offsets = numx.random.randn() * numx.ones(
(1, number_visibles))
initial_hidden_offsets = numx.random.randn() * numx.ones(
(1, number_hiddens))
initial_weights = numx.random.randn(number_visibles,
number_hiddens) * initial_weights
assert numx.all(model.input_dim == number_visibles)
assert numx.all(model.output_dim == number_hiddens)
assert numx.all(model.w == initial_weights)
assert numx.all(model.bv == initial_visible_bias)
assert numx.all(model.bh == initial_hidden_bias)
assert numx.all(model.ov == initial_visible_offsets)
assert numx.all(model.oh == initial_hidden_offsets)
# Check init arrays
numx.random.seed(42)
initial_weights = numx.random.randn(number_visibles, number_hiddens)
initial_visible_bias = numx.random.randn(1, number_visibles)
initial_hidden_bias = numx.random.randn(1, number_hiddens)
initial_visible_offsets = numx.random.randn(1, number_visibles)
initial_hidden_offsets = numx.random.randn(1, number_hiddens)
numx.random.seed(42)
model = BipartiteGraph(number_visibles=number_visibles,
number_hiddens=number_hiddens,
data=None,
initial_weights=initial_weights,
initial_visible_bias=initial_visible_bias,
initial_hidden_bias=initial_hidden_bias,
initial_visible_offsets=initial_visible_offsets,
initial_hidden_offsets=initial_hidden_offsets)
numx.random.seed(42)
assert numx.all(model.w == initial_weights)
assert numx.all(model.bv == initial_visible_bias)
assert numx.all(model.bh == initial_hidden_bias)
assert numx.all(model.ov == initial_visible_offsets)
assert numx.all(model.oh == initial_hidden_offsets)
# Check AUTO init without data
numx.random.seed(42)
initial_weights = (
2.0 * numx.random.rand(number_visibles, number_hiddens) -
1.0) * (4.0 * numx.sqrt(6.0 / (number_visibles + number_hiddens)))
initial_visible_bias = 'AUTO'
initial_hidden_bias = 'AUTO'
initial_visible_offsets = 'AUTO'
initial_hidden_offsets = 'AUTO'
numx.random.seed(42)
model = BipartiteGraph(number_visibles=number_visibles,
number_hiddens=number_hiddens,
data=None,
initial_weights='AUTO',
initial_visible_bias='AUTO',
initial_hidden_bias='AUTO',
initial_visible_offsets='AUTO',
initial_hidden_offsets='AUTO')
assert numx.all(model.w == initial_weights)
assert numx.all(model.bv == 0.0)
assert numx.all(model.bh == 0.0)
assert numx.all(model.ov == 0.5)
assert numx.all(model.oh == 0.5)
# Check AUTO init with data
test_data = numx.random.randn(100, number_visibles)
test_data_mean = test_data.mean(axis=0).reshape(1, test_data.shape[1])
numx.random.seed(42)
# All weight combination checked already
initial_visible_bias = Sigmoid().g(
numx.clip(test_data_mean, 0.001, 0.9999)).reshape(model.ov.shape)
initial_hidden_bias = 0.0
initial_visible_offsets = test_data_mean
initial_hidden_offsets = 0.5
numx.random.seed(42)
model = BipartiteGraph(number_visibles=number_visibles,
number_hiddens=number_hiddens,
data=test_data,
initial_weights='AUTO',
initial_visible_bias='AUTO',
initial_hidden_bias='AUTO',
initial_visible_offsets='AUTO',
initial_hidden_offsets='AUTO')
assert numx.all(model.bv == initial_visible_bias)
assert numx.all(model.bh == initial_hidden_bias)
assert numx.all(model.ov == initial_visible_offsets)
assert numx.all(model.oh == initial_hidden_offsets)
# Check AUTO init with INVERSE SIGMOID
test_data = numx.random.randn(100, number_visibles)
test_data_mean = test_data.mean(axis=0).reshape(1, test_data.shape[1])
numx.random.seed(42)
# All weight combination checked already
initial_visible_offsets = numx.random.randn() * numx.ones(
(1, number_visibles))
initial_hidden_offsets = numx.random.randn() * numx.ones(
(1, number_hiddens))
initial_visible_bias = numx.array(Sigmoid().g(numx.clip( \
initial_visible_offsets, 0.001, 0.9999))
).reshape(1, number_visibles)
initial_hidden_bias = numx.array(Sigmoid().g(numx.clip( \
initial_hidden_offsets, 0.001, 0.9999))
).reshape(1, number_hiddens)
numx.random.seed(42)
model = BipartiteGraph(
number_visibles=number_visibles,
number_hiddens=number_hiddens,
data=test_data,
initial_weights='AUTO',
initial_visible_bias='INVERSE_SIGMOID',
initial_hidden_bias='INVERSE_SIGMOID',
initial_visible_offsets=numx.random.randn() * numx.ones(
(1, number_visibles)),
initial_hidden_offsets=numx.random.randn() * numx.ones(
(1, number_hiddens)))
assert numx.all(model.bv == initial_visible_bias)
assert numx.all(model.bh == initial_hidden_bias)
assert numx.all(model.ov == initial_visible_offsets)
assert numx.all(model.oh == initial_hidden_offsets)
print(' successfully passed!')
sys.stdout.flush()
