def test_transfer_mech_mismatched_shape_noise_2(self):
with pytest.raises(MechanismError) as error_text:
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0],
function=Linear(),
noise=[5.0, 5.0],
integration_rate=0.1,
integrator_mode=True
)
T.execute()
assert 'Noise parameter' in str(error_text.value) and "does not match default variable" in str(error_text.value)
def test_transfer_mech_array_var_normal_len_1_noise(self):
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0, 0],
function=Linear(),
noise=NormalDist(),
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = T.execute([0, 0, 0, 0])
assert np.allclose(val, [[0.41059850193837233, 0.144043571160878, 1.454273506962975, 0.7610377251469934]])
def test_transfer_mech_array_var_normal_array_noise2(self, benchmark):
T = TransferMechanism(
name='T',
default_variable=[0 for i in range(VECTOR_SIZE)],
function=Linear(),
noise=[5.0 for i in range(VECTOR_SIZE)],
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = benchmark(T.execute, [0 for i in range(VECTOR_SIZE)])
assert np.allclose(val, [[5.0 for i in range(VECTOR_SIZE)]])
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_default_variable_override_mech_list(self):
R2 = TransferMechanism(size=3)
# default_variable override of OutputState.value
T = TransferMechanism(
default_variable=[[0, 0]],
input_states=[R2]
)
np.testing.assert_array_equal(T.instance_defaults.variable, np.array([[0, 0]]))
assert len(T.input_states) == 1
assert len(T.input_state.path_afferents[0].sender.instance_defaults.variable) == 3
assert len(T.input_state.instance_defaults.variable) == 2
T.execute()
def test_transfer_mech_integration_rate_2(self):
with pytest.raises(TransferError) as error_text:
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0, 0],
function=Linear(),
integration_rate=2,
integrator_mode=True
)
T.execute([1, 1, 1, 1])
assert (
"integration_rate parameter" in str(error_text.value)
and "must be a float between 0 and 1" in str(error_text.value)
)
def test_transfer_mech_integration_rate_0_8_initial_0_5(self):
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0, 0],
function=Linear(),
integration_rate=0.8,
initial_value=np.array([[.5, .5, .5, .5]]),
integrator_mode=True
)
val = T.execute([1, 1, 1, 1])
assert np.allclose(val, [[0.9, 0.9, 0.9, 0.9]])
T.noise = 10
val = T.execute([1, 2, -3, 0])
assert np.allclose(val, [[10.98, 11.78, 7.779999999999999, 10.18]]) # testing noise changes to an integrator
def test_dict_target_spec_length2(self):
A = TransferMechanism(name="multilayer-mech-A")
B = TransferMechanism(name="multilayer-mech-B")
C = TransferMechanism(name="multilayer-mech-C",
default_variable=[[0.0, 0.0]])
P = Process(name="multilayer-process",
pathway=[A, B, C],
learning=ENABLED)
S = System(name="learning-system", processes=[P])
S.run(inputs={A: 1.0}, targets={C: [2.0, 3.0]})
S.run(inputs={A: 1.0}, targets={C: [[2.0, 3.0]]})
def test_input_not_provided_to_run(self):
T = TransferMechanism(name='T',
default_variable=[[1.0, 2.0], [3.0, 4.0],
[5.0, 6.0]])
T2 = TransferMechanism(name='T2',
function=Linear(slope=2.0),
default_variable=[[0.0, 0.0]])
P = Process(pathway=[T, T2])
S = System(processes=[P])
run_result = S.run()
assert np.allclose(T.value, [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
assert np.allclose(run_result, [[np.array([2.0, 4.0])]])
def test_four_ABBCD(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
D = TransferMechanism(
name='D',
default_variable=[0],
function=Linear(slope=1.0),
)
p = Process(default_variable=[0], pathway=[A, B, D], name='p')
q = Process(default_variable=[0], pathway=[A, C, D], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(D, 1)}
stim_list = {A: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(B, EveryNCalls(A, 1))
sched.add_condition(C, EveryNCalls(A, 2))
sched.add_condition(D, Any(EveryNCalls(B, 3), EveryNCalls(C, 3)))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [D]
expected_output = [
[
numpy.array([4.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i], terminal_mechs[m].output_values[i])
def test_transfer_mech_array_var_normal_array_noise(self):
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0, 0],
function=Linear(),
noise=[NormalDist(), NormalDist(), NormalDist(), NormalDist()],
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = T.execute([0, 0, 0, 0])
expected = [0.7610377251469934, 0.12167501649282841, 0.44386323274542566, 0.33367432737426683]
for i in range(len(val[0])):
assert val[0][i] == expected[i]
def test_function_target_spec(self):
A = TransferMechanism(name="multilayer-mech-A")
B = TransferMechanism(name="multilayer-mech-B")
C = TransferMechanism(name="multilayer-mech-C")
P = Process(name="multilayer-process",
pathway=[A, B, C],
learning=ENABLED)
S = System(name="learning-system", processes=[P])
def target_function():
val_1 = NormalDist(mean=3.0).function()
return val_1
S.run(inputs={A: 1.0}, targets={C: target_function})
def test_converging_pathways(self):
a = TransferMechanism(name="a", default_variable=[0, 0, 0])
b = TransferMechanism(name="b")
c = TransferMechanism(name="c", default_variable=[0, 0, 0, 0, 0])
p = Process(name="p", pathway=[a, c], learning=ENABLED)
p2 = Process(name="p2", pathway=[b, c], learning=ENABLED)
s = System(name="s", processes=[p, p2])
a_label = s._get_label(a, ALL)
b_label = s._get_label(b, ALL)
c_label = s._get_label(c, ALL)
assert "out (3)" in a_label and "in (3)" in a_label
assert "out (1)" in b_label and "in (1)" in b_label
assert "out (5)" in c_label and "in (5)" in c_label
def test_list_target_spec_length2(self):
A = TransferMechanism(name="learning-process-mech-A")
B = TransferMechanism(name="learning-process-mech-B",
default_variable=[[0.0, 0.0]])
LP = Process(name="learning-process", pathway=[A, B], learning=ENABLED)
S = System(
name="learning-system",
processes=[LP],
)
S.run(inputs={A: 1.0}, targets=[2.0, 3.0])
S.run(inputs={A: 1.0}, targets=[[2.0, 3.0]])
def test_dict_with_variable_mismatches_size(self):
with pytest.raises(MechanismError) as error_text:
TransferMechanism(
size=1,
input_states=[{NAME: 'FIRST', VARIABLE: [0, 0]}]
)
assert mismatches_size_error_text in str(error_text.value)
def test_dict_with_variable_matches_size(self):
T = TransferMechanism(
size=2,
input_states=[{NAME: 'FIRST', VARIABLE: [0, 0]}]
)
np.testing.assert_array_equal(T.instance_defaults.variable, np.array([[0, 0]]))
assert len(T.input_states) == 1
def test_transfer_mech_size_var_incompatible2(self):
T = TransferMechanism(
name='T',
size=[2, 2],
default_variable=[[1, 2], [3, 4, 5]]
)
assert (T.instance_defaults.variable[0] == [1, 2]).all() and (T.instance_defaults.variable[1] == [3, 4, 5]).all() and len(T.instance_defaults.variable) == 2
def test_transfer_mech_size_2d(self):
T = TransferMechanism(
name='T',
size=[[2]],
)
assert len(T.instance_defaults.variable) == 1 and len(T.instance_defaults.variable[0]) == 2
assert len(T.size) == 1 and T.size[0] == 2 and len(T.params['size']) == 1 and T.params['size'][0] == 2
def test_two_ABB(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
p = Process(default_variable=[0], pathway=[A, B], name='p')
s = System(processes=[p], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(B, 2)}
stim_list = {A: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(A, Any(AtPass(0), AfterNCalls(B, 2)))
sched.add_condition(B, Any(JustRan(A), JustRan(B)))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mech = B
expected_output = [
numpy.array([2.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(expected_output[i],
terminal_mech.output_values[i])
def test_two_compositions_one_scheduler(self):
comp1 = Composition()
comp2 = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0),
name='scheduler-pytests-A')
comp1.add_mechanism(A)
comp2.add_mechanism(A)
sched = Scheduler(composition=comp1)
sched.add_condition(A, BeforeNCalls(A, 5, time_scale=TimeScale.LIFE))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(6)
termination_conds[TimeScale.TRIAL] = AfterNPasses(1)
comp1.run(inputs={A: [[0], [1], [2], [3], [4], [5]]},
scheduler_processing=sched,
termination_processing=termination_conds)
output = sched.execution_list[comp1._execution_id]
expected_output = [A, A, A, A, A, set()]
# pprint.pprint(output)
assert output == pytest.helpers.setify_expected_output(expected_output)
comp2.run(inputs={A: [[0], [1], [2], [3], [4], [5]]},
scheduler_processing=sched,
termination_processing=termination_conds)
output = sched.execution_list[comp2._execution_id]
expected_output = [A, A, A, A, A, set()]
# pprint.pprint(output)
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_inputstate_class_with_variable(self):
T = TransferMechanism(default_variable=[0, 0],
input_states=[InputState])
np.testing.assert_array_equal(T.instance_defaults.variable,
np.array([[0, 0]]))
assert len(T.input_states) == 1
def test_projection_in_specification_dict(self):
R1 = TransferMechanism(output_states=['FIRST', 'SECOND'])
T = TransferMechanism(input_states=[{
NAME:
'My InputState with Two Projections',
PROJECTIONS:
[R1.output_states['FIRST'], R1.output_states['SECOND']]
}])
np.testing.assert_array_equal(T.instance_defaults.variable,
np.array([[0]]))
assert len(T.input_states) == 1
assert T.input_state.name == 'My InputState with Two Projections'
for input_state in T.input_states:
for projection in input_state.path_afferents:
assert projection.sender.owner is R1
T.execute()
def test_output_state_spec_list_two_items(self):
R1 = TransferMechanism(output_states=['FIRST', 'SECOND'])
T = TransferMechanism(default_variable=[[0], [0]],
input_states=[
R1.output_states['FIRST'],
R1.output_states['SECOND']
])
np.testing.assert_array_equal(T.instance_defaults.variable,
np.array([[0], [0]]))
assert len(T.input_states) == 2
assert T.input_states.names[0] == 'InputState-0'
assert T.input_states.names[1] == 'InputState-1'
for input_state in T.input_states:
for projection in input_state.path_afferents:
assert projection.sender.owner is R1
T.execute()
def test_3_targets_4_inputs(self):
A = TransferMechanism(name="learning-process-mech-A")
B = TransferMechanism(name="learning-process-mech-B")
LP = Process(name="learning-process", pathway=[A, B], learning=ENABLED)
S = System(
name="learning-system",
processes=[LP],
)
with pytest.raises(RunError) as error_text:
S.run(inputs={A: [[[1.0]], [[2.0]], [[3.0]], [[4.0]]]},
targets={B: [[1.0], [2.0], [3.0]]})
assert 'Number of target values specified (3) for each learning sequence' in str(error_text.value) and \
'must equal the number of input values specified (4)' in str(error_text.value)
def test_LCA_length_2(self):
T = TransferMechanism(function=Linear(slope=1.0), size=2)
L = LCA(function=Linear(slope=2.0),
size=2,
self_excitation=3.0,
leak=0.5,
competition=1.0,
time_step_size=0.1)
P = Process(pathway=[T, L])
S = System(processes=[P])
# - - - - - - - Equations to be executed - - - - - - -
# new_transfer_input =
# previous_transfer_input
# + (leak * previous_transfer_input_1 + self_excitation * result1 + competition * result2 + outside_input1) * dt
# + noise
# result = new_transfer_input*2.0
# recurrent_matrix = [[3.0]]
# - - - - - - - - - - - - - - - - - - - - - - - - - -
results = []
def record_execution():
results.append(L.value[0])
S.run(inputs={T: [1.0, 2.0]},
num_trials=3,
call_after_trial=record_execution)
# - - - - - - - TRIAL 1 - - - - - - -
# new_transfer_input_1 = 0.0 + ( 0.5 * 0.0 + 3.0 * 0.0 - 1.0*0.0 + 1.0)*0.1 + 0.0 = 0.1
# f(new_transfer_input_1) = 0.1 * 2.0 = 0.2
# new_transfer_input_2 = 0.0 + ( 0.5 * 0.0 + 3.0 * 0.0 - 1.0*0.0 + 2.0)*0.1 + 0.0 = 0.2
# f(new_transfer_input_2) = 0.2 * 2.0 = 0.4
# - - - - - - - TRIAL 2 - - - - - - -
# new_transfer_input = 0.1 + ( 0.5 * 0.1 + 3.0 * 0.2 - 1.0*0.4 + 1.0)*0.1 + 0.0 = 0.225
# f(new_transfer_input) = 0.265 * 2.0 = 0.45
# new_transfer_input_2 = 0.2 + ( 0.5 * 0.2 + 3.0 * 0.4 - 1.0*0.2 + 2.0)*0.1 + 0.0 = 0.51
# f(new_transfer_input_2) = 0.1 * 2.0 = 1.02
# - - - - - - - TRIAL 3 - - - - - - -
# new_transfer_input = 0.225 + ( 0.5 * 0.225 + 3.0 * 0.45 - 1.0*1.02 + 1.0)*0.1 + 0.0 = 0.36925
# f(new_transfer_input) = 0.36925 * 2.0 = 0.7385
# new_transfer_input_2 = 0.51 + ( 0.5 * 0.51 + 3.0 * 1.02 - 1.0*0.45 + 2.0)*0.1 + 0.0 = 0.9965
# f(new_transfer_input_2) = 0.9965 * 2.0 = 1.463
assert np.allclose(results,
[[0.2, 0.4], [0.45, 1.02], [0.7385, 1.993]])
def test_3_input_states_2_label_dicts(self):
input_labels_dict = {
0: {
"red": [1, 0],
"green": [0, 1]
},
2: {
"red": [0, 1],
"green": [1, 0]
}
}
M = TransferMechanism(default_variable=[[0, 0], [0, 0], [0, 0]],
params={INPUT_LABELS_DICT: input_labels_dict})
P = Process(pathway=[M])
S = System(processes=[P])
S.run(inputs=[['red', [0, 0], 'green'], ['green', [1, 1], 'red'],
['green', [2, 2], 'green']])
assert np.allclose(S.results,
[[[1, 0], [0, 0], [1, 0]], [[0, 1], [1, 1], [0, 1]],
[[0, 1], [2, 2], [1, 0]]])
S.run(inputs=[['red', [0, 0], [1, 0]], ['green', [1, 1], 'red'],
[[0, 1], [2, 2], 'green']])
assert np.allclose(
S.results, [[[1, 0], [0, 0], [1, 0]], [[0, 1], [1, 1], [0, 1]],
[[0, 1], [2, 2], [1, 0]], [[1, 0], [0, 0], [1, 0]],
[[0, 1], [1, 1], [0, 1]], [[0, 1], [2, 2], [1, 0]]])
def test_params_override(self):
T = TransferMechanism(
input_states=[[0], [0]],
params={INPUT_STATES: [[0, 0], [0]]}
)
assert T.instance_defaults.variable.shape == np.array([[0, 0], [0]]).shape
assert len(T.input_states) == 2
def test_projection_no_args_projection_spec_with_default(self):
p = MappingProjection()
T = TransferMechanism(default_variable=[0, 0], input_states=[p])
np.testing.assert_array_equal(T.instance_defaults.variable,
np.array([[0, 0]]))
assert len(T.input_states) == 1
def test_transfer_mech_size_negative_one(self):
with pytest.raises(ComponentError) as error_text:
T = TransferMechanism(
name='T',
size=-1.0,
)
assert "is not a positive number" in str(error_text.value)
def test_dict_with_variable_mismatches_default(self):
with pytest.raises(MechanismError) as error_text:
TransferMechanism(
default_variable=[[0]],
input_states=[{NAME: 'FIRST', VARIABLE: [0, 0]}]
)
assert mismatches_specified_default_variable_error_text in str(error_text.value)
