def test_leabra_runtime_alone(self):
n_input = 4
n_output = 3
n_hidden = 2
hidden_sizes = None
inputs = [[.1, .2, .3, .4], [.4, .5, .6, .7], [-.6, -.7, -.8, -.9]]
train_input = [1, 0, -1]
random.seed(10)
L1 = LeabraMechanism(input_size=n_input, output_size=n_output, hidden_layers=n_hidden,
hidden_sizes=None, training_flag=False) # training flag is false
random.seed(10)
L2 = LeabraMechanism(input_size=n_input, output_size=n_output, hidden_layers=n_hidden,
hidden_sizes=None, training_flag=True) # training flag is true
random.seed(10)
net = build_leabra_network(n_input, n_output, n_hidden, hidden_sizes, False)
pnl_output1_1 = L1.execute(input=[inputs[0], train_input], runtime_params={"training_flag": False})
pnl_output2_1 = L2.execute(input=[inputs[0], train_input], runtime_params={"training_flag": False})
net_output_1 = run_leabra_network(net, input_pattern=inputs[0])
np.testing.assert_allclose(pnl_output1_1[0], net_output_1, atol=1e-08)
np.testing.assert_allclose(pnl_output2_1[0], net_output_1, atol=1e-08)
pnl_output1_2 = L1.execute(input=[inputs[1], train_input], runtime_params={"training_flag": True})
pnl_output2_2 = L2.execute(input=[inputs[1], train_input], runtime_params={"training_flag": True})
net_output_2 = train_leabra_network(net, input_pattern=inputs[1], output_pattern=train_input)
np.testing.assert_allclose(pnl_output1_2[0], net_output_2, atol=1e-08)
np.testing.assert_allclose(pnl_output2_2[0], net_output_2, atol=1e-08)
pnl_output1_3 = L1.execute(input=[inputs[2], train_input], runtime_params={"training_flag": False})
pnl_output2_3 = L2.execute(input=[inputs[2], train_input], runtime_params={"training_flag": False})
net_output_3 = run_leabra_network(net, input_pattern=inputs[2])
np.testing.assert_allclose(pnl_output1_3[0], net_output_3, atol=1e-08)
np.testing.assert_allclose(pnl_output2_3[0], net_output_3, atol=1e-08)
def test_leabra_prec_with_train(self):
in_size = 4
out_size = 4
num_hidden = 1
num_trials = 4
train = True
inputs = [[0, 1, .5, -.2]] * num_trials
train_data = [[.2, .5, 1, -.5]] * num_trials
precision = 0.000000001 # how far we accept error between PNL and Leabra output
random_seed = 2 # because Leabra network initializes with small random weights
random.seed(random_seed)
L_spec = LeabraMechanism(input_size=in_size, output_size=out_size, hidden_layers=num_hidden,
training_flag=train)
random.seed(random_seed)
leabra_net = build_leabra_network(in_size, out_size, num_hidden, None, train)
leabra_net2 = copy.deepcopy(leabra_net)
L_net = LeabraMechanism(leabra_net2)
# leabra_net should be identical to the network inside L_net
T1_spec = TransferMechanism(name='T1', size=in_size, function=Linear)
T2_spec = TransferMechanism(name='T2', size=out_size, function=Linear)
T1_net = TransferMechanism(name='T1', size=in_size, function=Linear)
T2_net = TransferMechanism(name='T2', size=out_size, function=Linear)
p1_spec = Process(pathway=[T1_spec, L_spec])
proj_spec = MappingProjection(sender=T2_spec, receiver=L_spec.input_states[1])
p2_spec = Process(pathway=[T2_spec, proj_spec, L_spec])
s_spec = System(processes=[p1_spec, p2_spec])
p1_net = Process(pathway=[T1_net, L_net])
proj_net = MappingProjection(sender=T2_net, receiver=L_net.input_states[1])
p2_net = Process(pathway=[T2_net, proj_net, L_net])
s_net = System(processes=[p1_net, p2_net])
for i in range(num_trials):
out_spec = s_spec.run(inputs={T1_spec: inputs[i], T2_spec: train_data[i]})
pnl_output_spec = out_spec[-1][0]
leabra_output = train_leabra_network(leabra_net, inputs[i], train_data[i])
diffs_spec = np.abs(np.array(pnl_output_spec) - np.array(leabra_output))
out_net = s_net.run(inputs={T1_net: inputs[i], T2_net: train_data[i]})
pnl_output_net = out_net[-1][0]
diffs_net = np.abs(np.array(pnl_output_net) - np.array(leabra_output))
assert all(diffs_spec < precision) and all(diffs_net < precision)
out_spec = s_spec.run(inputs={T1_spec: inputs, T2_spec: train_data})
pnl_output_spec = np.array(out_spec[-1][0])
for i in range(len(inputs)):
leabra_output = np.array(train_leabra_network(leabra_net, inputs[i], train_data[i]))
diffs_spec = np.abs(pnl_output_spec - leabra_output)
out_net = s_net.run(inputs={T1_net: inputs, T2_net: train_data})
pnl_output_net = np.array(out_net[-1][0])
diffs_net = np.abs(pnl_output_net - leabra_output)
assert all(diffs_spec < precision) and all(diffs_net < precision)
def test_leabra_prec_half_train(self):
in_size = 4
out_size = 4
num_hidden = 1
num_trials = 2
train = True
inputs = [[0, 1, .5, -.2]] * num_trials
train_data = [[.2, .5, 1, -.5]] * num_trials
precision = 0.000000001 # how far we accept error between PNL and Leabra output
random_seed = 3 # because Leabra network initializes with small random weights
random.seed(random_seed)
L_spec = LeabraMechanism(input_size=in_size, output_size=out_size, hidden_layers=num_hidden, training_flag=train)
random.seed(random_seed)
leabra_net = build_leabra_network(in_size, out_size, num_hidden, None, train)
leabra_net2 = copy.deepcopy(leabra_net)
L_net = LeabraMechanism(leabra_net2)
# leabra_net should be identical to the network inside L_net
T1_spec = TransferMechanism(name='T1', size=in_size, function=Linear)
T2_spec = TransferMechanism(name='T2', size=out_size, function=Linear)
T1_net = TransferMechanism(name='T1', size=in_size, function=Linear)
T2_net = TransferMechanism(name='T2', size=out_size, function=Linear)
p1_spec = Process(pathway=[T1_spec, L_spec])
proj_spec = MappingProjection(sender=T2_spec, receiver=L_spec.input_states[1])
p2_spec = Process(pathway=[T2_spec, proj_spec, L_spec])
s_spec = System(processes=[p1_spec, p2_spec])
p1_net = Process(pathway=[T1_net, L_net])
proj_net = MappingProjection(sender=T2_net, receiver=L_net.input_states[1])
p2_net = Process(pathway=[T2_net, proj_net, L_net])
s_net = System(processes=[p1_net, p2_net])
for i in range(num_trials): # training round
out_spec = s_spec.run(inputs={T1_spec: inputs[i], T2_spec: train_data[i]})
pnl_output_spec = out_spec[-1][0]
leabra_output = train_leabra_network(leabra_net, inputs[i], train_data[i])
diffs_spec = np.abs(np.array(pnl_output_spec) - np.array(leabra_output))
out_net = s_net.run(inputs={T1_net: inputs[i], T2_net: train_data[i]})
pnl_output_net = out_net[-1][0]
diffs_net = np.abs(np.array(pnl_output_net) - np.array(leabra_output))
assert all(diffs_spec < precision) and all(diffs_net < precision)
# assert np.sum(np.abs(pnl_output_spec - np.array(train_data[0]))) < 0.1
# assert np.sum(np.abs(pnl_output_net - np.array(train_data[0]))) < 0.1
# set all learning rules false
for conn in leabra_net.connections:
conn.spec.lrule = None
L_net.training_flag = False
L_spec.training_flag = False
for i in range(num_trials): # non-training round
out_spec = s_spec.run(inputs={T1_spec: inputs[i], T2_spec: train_data[i]})
pnl_output_spec = out_spec[-1][0]
leabra_output = run_leabra_network(leabra_net, inputs[i])
diffs_spec = np.abs(np.array(pnl_output_spec) - np.array(leabra_output))
out_net = s_net.run(inputs={T1_net: inputs[i], T2_net: train_data[i]})
pnl_output_net = out_net[-1][0]
diffs_net = np.abs(np.array(pnl_output_net) - np.array(leabra_output))
assert all(diffs_spec < precision) and all(diffs_net < precision)
# class TestLeabraMechInSystem:
#
# def test_leabra_mech_learning(self):
# T1 = TransferMechanism(size=5, function=Linear)
# T2 = TransferMechanism(size=3, function=Linear)
# L = LeabraMechanism(input_size=5, output_size=3, hidden_layers=2, hidden_sizes=[4, 4])
# train_data_proj = MappingProjection(sender=T2, receiver=L.input_states[1])
# out = TransferMechanism(size=3, function=Logistic(bias=2))
# p1 = Process(pathway=[T1, L, out], learning=LEARNING, learning_rate=1.0, target=[0, .1, .8])
# p2 = Process(pathway=[T2, train_data_proj, L, out])
# s = System(processes=[p1, p2])
# s.run(inputs = {T1: [1, 2, 3, 4, 5], T2: [0, .5, 1]})