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)