def test_6_two_trials(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, BeforePass(5)) sched.add_condition(B, AfterNCalls(A, 5)) sched.add_condition(C, AfterNCalls(B, 1)) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(2) termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 3) comp.run( inputs={A: [[0], [1], [2], [3], [4], [5]]}, scheduler_processing=sched, termination_processing=termination_conds ) output = sched.execution_list[comp.default_execution_id] expected_output = [ A, A, A, A, A, B, C, B, C, B, C, A, A, A, A, A, B, C, B, C, B, C ] # pprint.pprint(output) assert output == pytest.helpers.setify_expected_output(expected_output)
def test_composite_condition_multi(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A') B = TransferMechanism(function=Linear(intercept=4.0), name='B') C = TransferMechanism(function=Linear(intercept=1.5), name='C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, EveryNCalls(A, 2)) sched.add_condition(C, All( Any( AfterPass(6), AfterNCalls(B, 2) ), Any( AfterPass(2), AfterNCalls(B, 3) ) ) ) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 3) output = list(sched.run(termination_conds=termination_conds)) expected_output = [ A, A, B, A, A, B, C, A, C, A, B, C ] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_invtriangle_1(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, C) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, EveryNCalls(A, 2)) sched.add_condition(C, Any(AfterNCalls(A, 3), AfterNCalls(B, 3))) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 4, time_scale=TimeScale.TRIAL) output = list(sched.run(termination_conds=termination_conds)) expected_output = [ A, set([A, B]), A, C, set([A, B]), C, A, C, set([A, B]), C ] # pprint.pprint(output) assert output == pytest.helpers.setify_expected_output(expected_output)
def test_two_input_states_two_output_states(self): comp = Composition() A = TransferMechanism(name="A", default_variable=[[0.0], [0.0]], function=Linear(slope=2.0)) B = TransferMechanism(name="B", default_variable=[[0.0], [0.0]], function=Linear(slope=3.0)) comp.add_node(A) comp.add_node(B) comp.add_projection(MappingProjection(sender=A, receiver=B), A, B) comp.add_projection( MappingProjection(sender=A.output_states[1], receiver=B.input_states[1]), A, B) comp._analyze_graph() inputs_dict = { A: [[5.], [6.]], } sched = Scheduler(composition=comp) output = comp.run(inputs=inputs_dict, scheduler_processing=sched) assert np.allclose([[30.], [36.]], output)
def test_WhenFinishedAll_2(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A') A.is_finished_flag = False B = TransferMechanism(function=Linear(intercept=4.0), name='B') B.is_finished_flag = True C = TransferMechanism(function=Linear(intercept=1.5), name='C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, C) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, EveryNPasses(1)) sched.add_condition(C, WhenFinishedAll(A, B)) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(A, 5) output = list(sched.run(termination_conds=termination_conds)) expected_output = [ set([A, B]), set([A, B]), set([A, B]), set([A, B]), set([A, B]), ] assert output == pytest.helpers.setify_expected_output(expected_output)
def tests_for_projection_with_matrix_and_sender_mismatches_default(self): with pytest.raises(MechanismError) as error_text: m = TransferMechanism(size=2) p = MappingProjection(sender=m, matrix=[[0, 0, 0], [0, 0, 0]]) TransferMechanism(default_variable=[0, 0], input_states=[p]) assert mismatches_specified_default_variable_error_text in str( error_text.value) with pytest.raises(FunctionError) as error_text: m = TransferMechanism(size=3, output_states=[pnl.TRANSFER_OUTPUT.MEAN]) p = MappingProjection(sender=m, matrix=[[0, 0, 0], [0, 0, 0]]) T = TransferMechanism(input_states=[p]) assert 'Specification of matrix and/or default_variable for LinearMatrix Function-0 is not valid. ' \ 'The shapes of variable (1, 1) and matrix (2, 3) are not compatible for multiplication' \ in str(error_text.value) with pytest.raises(FunctionError) as error_text: m2 = TransferMechanism(size=2, output_states=[pnl.TRANSFER_OUTPUT.MEAN]) p2 = MappingProjection(sender=m2, matrix=[[1, 1, 1], [1, 1, 1]]) T2 = TransferMechanism(input_states=[p2]) assert 'Specification of matrix and/or default_variable for LinearMatrix Function-1 is not valid. ' \ 'The shapes of variable (1, 1) and matrix (2, 3) are not compatible for multiplication' \ in str(error_text.value)
def test_WhenFinishedAll_noargs(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A') B = TransferMechanism(function=Linear(intercept=4.0), name='B') C = TransferMechanism(function=Linear(intercept=1.5), name='C') for m in [A, B, C]: comp.add_node(m) m.is_finished_flag = False comp.add_projection(MappingProjection(), A, C) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, Always()) sched.add_condition(B, Always()) sched.add_condition(C, Always()) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = WhenFinishedAll() output = [] i = 0 for step in sched.run(termination_conds=termination_conds): if i == 3: A.is_finished_flag = True B.is_finished_flag = True if i == 4: C.is_finished_flag = True output.append(step) i += 1 expected_output = [ set([A, B]), C, set([A, B]), C, set([A, B]), ] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_triangle_4b(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), A, C) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, EveryNCalls(A, 2)) sched.add_condition(C, All(WhenFinished(A), AfterNCalls(B, 3))) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 1) output = [] i = 0 for step in sched.run(termination_conds=termination_conds): if i == 10: A._is_finished = True output.append(step) i += 1 expected_output = [A, A, B, A, A, B, A, A, B, A, A, set([B, C])] # pprint.pprint(output) assert output == pytest.helpers.setify_expected_output(expected_output)
def test_checkmark2_1(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C') D = TransferMechanism(function=Linear(intercept=.5), name='scheduler-pytests-D') for m in [A, B, C, D]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), A, D) comp.add_projection(MappingProjection(), B, D) comp.add_projection(MappingProjection(), C, D) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, EveryNCalls(A, 2)) sched.add_condition(C, EveryNCalls(A, 2)) sched.add_condition(D, All(EveryNCalls(B, 2), EveryNCalls(C, 2))) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(D, 1, time_scale=TimeScale.TRIAL) output = list(sched.run(termination_conds=termination_conds)) expected_output = [ A, set([A, C]), B, A, set([A, C]), B, D ] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_multisource_1(self): comp = Composition() A1 = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A1') A2 = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A2') B1 = TransferMechanism(function=Linear(intercept=4.0), name='B1') B2 = TransferMechanism(function=Linear(intercept=4.0), name='B2') B3 = TransferMechanism(function=Linear(intercept=4.0), name='B3') C1 = TransferMechanism(function=Linear(intercept=1.5), name='C1') C2 = TransferMechanism(function=Linear(intercept=.5), name='C2') for m in [A1, A2, B1, B2, B3, C1, C2]: comp.add_node(m) comp.add_projection(MappingProjection(), A1, B1) comp.add_projection(MappingProjection(), A1, B2) comp.add_projection(MappingProjection(), A2, B1) comp.add_projection(MappingProjection(), A2, B2) comp.add_projection(MappingProjection(), A2, B3) comp.add_projection(MappingProjection(), B1, C1) comp.add_projection(MappingProjection(), B2, C1) comp.add_projection(MappingProjection(), B1, C2) comp.add_projection(MappingProjection(), B3, C2) sched = Scheduler(composition=comp) for m in comp.nodes: sched.add_condition(m, Always()) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = All(AfterNCalls(C1, 1), AfterNCalls(C2, 1)) output = list(sched.run(termination_conds=termination_conds)) expected_output = [ set([A1, A2]), set([B1, B2, B3]), set([C1, C2]) ] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_termination_conditions_reset(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') for m in [A, B]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) sched = Scheduler(composition=comp) sched.add_condition(B, EveryNCalls(A, 2)) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(B, 2) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A, A, B, A, A, B] assert output == pytest.helpers.setify_expected_output(expected_output) # reset the RUN because schedulers run TRIALs sched.clock._increment_time(TimeScale.RUN) sched._reset_counts_total(TimeScale.RUN) output = list(sched.run()) expected_output = [A, A, B] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_9(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') for m in [A, B]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, WhenFinished(A)) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(B, 2) output = [] i = 0 A.is_finished_flag = False for step in sched.run(termination_conds=termination_conds): if i == 3: A.is_finished_flag = True output.append(step) i += 1 expected_output = [A, A, A, A, B, A, B] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_projection_with_sender_and_default(self): t = TransferMechanism(size=3) p = MappingProjection(sender=t) T = TransferMechanism(default_variable=[[0, 0]], input_ports=[p]) np.testing.assert_array_equal(T.defaults.variable, np.array([[0, 0]])) assert len(T.input_ports) == 1
def test_one_input_port_one_output_port(self): comp = Composition() A = TransferMechanism(name="A", function=Linear(slope=2.0)) B = TransferMechanism(name="B", function=Linear(slope=3.0)) comp.add_node(A) comp.add_node(B) comp.add_projection(MappingProjection(sender=A, receiver=B), A, B) inputs_dict = { A: [[5.]], } sched = Scheduler(composition=comp) output = comp.run( inputs=inputs_dict, scheduler=sched ) assert np.allclose([30], output)
def test_projection_with_matrix_and_sender(self): m = TransferMechanism(size=2) p = MappingProjection(sender=m, matrix=[[0, 0, 0], [0, 0, 0]]) T = TransferMechanism(input_ports=[p]) np.testing.assert_array_equal(T.defaults.variable, np.array([[0, 0, 0]])) assert len(T.input_ports) == 1
def _instantiate_learning_mechanism(self, learning_function, learning_rate, learned_projection, context=None): learning_mechanism = KohonenLearningMechanism( default_variable=[ self.learned_projection.sender.value, self.learned_projection.receiver.value ], matrix=self.matrix, function=learning_function, learning_rate=learning_rate, # learning_signals=[self.matrix], name="{} for {}".format(LearningMechanism.className, self.name)) # KDM 10/22/18: should below be aux_components? # FIX: 10/31/19 [JDC]: YES! # Instantiate Projection from learned_projection's sender to LearningMechanism MappingProjection( sender=self.learned_projection.sender, receiver=learning_mechanism.input_ports[ACTIVATION_INPUT], matrix=IDENTITY_MATRIX, name="Error Projection for {}".format(learning_mechanism.name)) # Instantiate Projection from the Mechanism's INPUT_PATTERN OutputPort # (which has the value of the learned_projection's receiver; i.e., the Mechanism's input) # to the LearningMechanism's ACTIVATION_OUTPUT InputPort. MappingProjection( sender=self.output_ports[INPUT_PATTERN], receiver=learning_mechanism.input_ports[ACTIVATION_OUTPUT], matrix=IDENTITY_MATRIX, name="Error Projection for {}".format(learning_mechanism.name)) # Instantiate Projection from LearningMechanism to learned_projection LearningProjection( sender=learning_mechanism.output_ports[LEARNING_SIGNAL], receiver=self.matrix, name="{} for {}".format(LearningProjection.className, self.learned_projection.name)) return learning_mechanism
def test_projection_list(self): R2 = TransferMechanism(size=3) P = MappingProjection(sender=R2) T = TransferMechanism(size=2, input_states=[P]) np.testing.assert_array_equal(T.defaults.variable, np.array([[0, 0]])) assert len(T.input_states) == 1 assert len( T.input_state.path_afferents[0].sender.defaults.variable) == 3 assert len(T.input_state.defaults.variable) == 2 T.execute()
def test_outputPort_(self): with pytest.raises(MechanismError) as error_text: p = MappingProjection() TransferMechanism(default_variable=[0, 0], input_ports=[{ VARIABLE: [0, 0, 0], PROJECTIONS: [p] }]) assert mismatches_specified_default_variable_error_text in str( error_text.value)
def test_projection_in_tuple(self): R2 = TransferMechanism(size=3) P = MappingProjection(sender=R2) T = TransferMechanism(size=2, input_ports=[(R2, None, None, P)]) np.testing.assert_array_equal(T.defaults.variable, np.array([[0, 0]])) assert len(T.input_ports) == 1 assert len( T.input_port.path_afferents[0].sender.defaults.variable) == 3 assert len(T.input_port.defaults.variable) == 2 T.execute()
def test_transfer_mech_process_matrix_change(self): from psyneulink.core.components.projections.pathway.mappingprojection import MappingProjection T1 = TransferMechanism( size=4, function=Linear) proj = MappingProjection(matrix=[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) T2 = TransferMechanism( size=4, function=Linear) p = Process(size=4, pathway=[T1, proj, T2]) p.run(inputs={T1: [[1, 2, 3, 4]]}) proj.matrix = [[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]] assert np.allclose(proj.matrix, [[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]]) # p.run(inputs={T1: [[1, 2, 3, 4]]}) T1.execute([[1, 2, 3, 4]]) proj.execute(context="EXECUTING testing projection") assert np.allclose(proj.matrix, np.array([[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]]))
def test_projection_no_args_dict_spec_mismatch_with_default(self): with pytest.raises(MechanismError) as error_text: p = MappingProjection() TransferMechanism(default_variable=[0, 0], input_states=[{ VARIABLE: [0, 0, 0], PROJECTIONS: [p] }]) assert mismatches_specified_default_variable_error_text in str( error_text.value)
def test_projection_no_args_dict_spec(self): p = MappingProjection() T = TransferMechanism(input_ports=[{ VARIABLE: [0, 0, 0], PROJECTIONS: [p] }]) np.testing.assert_array_equal(T.defaults.variable, np.array([[0, 0, 0]])) assert len(T.input_ports) == 1
def tests_for_projection_with_matrix_and_sender_mismatches_default(self): with pytest.raises(MechanismError) as error_text: m = TransferMechanism(size=2) p = MappingProjection(sender=m, matrix=[[0, 0, 0], [0, 0, 0]]) TransferMechanism(default_variable=[0, 0], input_ports=[p]) assert mismatches_specified_default_variable_error_text in str( error_text.value) with pytest.raises(FunctionError) as error_text: m = TransferMechanism(size=3, output_ports=[pnl.MEAN]) p = MappingProjection(sender=m, matrix=[[0, 0, 0], [0, 0, 0]]) T = TransferMechanism(input_ports=[p]) assert re.match(mismatches_specified_matrix_pattern, error_text.value.error_value) with pytest.raises(FunctionError) as error_text: m2 = TransferMechanism(size=2, output_ports=[pnl.MEAN]) p2 = MappingProjection(sender=m2, matrix=[[1, 1, 1], [1, 1, 1]]) T2 = TransferMechanism(input_ports=[p2]) assert re.match(mismatches_specified_matrix_pattern, error_text.value.error_value)
def test_input_specification_multiple_nested_compositions(self): # level_0 composition --------------------------------- innermost composition level_0 = Composition(name="level_0") A0 = TransferMechanism(name="A0", default_variable=[[0.], [0.]], function=Linear(slope=1.)) B0 = TransferMechanism(name="B0", function=Linear(slope=2.)) level_0.add_node(A0) level_0.add_node(B0) level_0.add_projection(MappingProjection(), A0, B0) level_0.add_projection( MappingProjection(sender=A0.output_ports[1], receiver=B0), A0, B0) # level_1 composition --------------------------------- level_1 = Composition(name="level_1") A1 = TransferMechanism(name="A1", function=Linear(slope=1.)) B1 = TransferMechanism(name="B1", function=Linear(slope=2.)) level_1.add_node(level_0) level_1.add_node(A1) level_1.add_node(B1) level_1.add_projection(MappingProjection(), level_0, B1) level_1.add_projection(MappingProjection(), A1, B1) # level_2 composition --------------------------------- outermost composition level_2 = Composition(name="level_2") A2 = TransferMechanism(name="A2", size=2, function=Linear(slope=1.)) B2 = TransferMechanism(name="B2", function=Linear(slope=2.)) level_2.add_node(level_1) level_2.add_node(A2) level_2.add_node(B2) level_2.add_projection(MappingProjection(), level_1, B2) level_2.add_projection(MappingProjection(), A2, B2) sched = Scheduler(composition=level_2) # FIX: order of InputPorts in each inner composition (level_0 and level_1) level_2.run(inputs={ A2: [[1.0, 2.0]], level_1: { A1: [[1.0]], level_0: { A0: [[1.0], [2.0]] } } }, scheduler=sched) # level_0 output = 2.0 * (1.0 + 2.0) = 6.0 assert np.allclose(level_0.get_output_values(level_2), [6.0]) # level_1 output = 2.0 * (1.0 + 6.0) = 14.0 assert np.allclose(level_1.get_output_values(level_2), [14.0]) # level_2 output = 2.0 * (1.0 + 2.0 + 14.0) = 34.0 assert np.allclose(level_2.get_output_values(level_2), [34.0])
def test_connect_compositions_with_complicated_states(self, mode): inner_composition_1 = Composition(name="comp1") A = TransferMechanism(name="A1", default_variable=[[0.0], [0.0]], function=Linear(slope=2.0)) B = TransferMechanism(name="B1", default_variable=[[0.0], [0.0]], function=Linear(slope=3.0)) inner_composition_1.add_node(A) inner_composition_1.add_node(B) inner_composition_1.add_projection(MappingProjection(sender=A, receiver=B), A, B) inner_composition_1.add_projection(MappingProjection(sender=A.output_ports[1], receiver=B.input_ports[1]), A, B) inner_composition_2 = Composition(name="comp2") A2 = TransferMechanism(name="A2", default_variable=[[0.0], [0.0]], function=Linear(slope=2.0)) B2 = TransferMechanism(name="B2", default_variable=[[0.0], [0.0]], function=Linear(slope=3.0)) inner_composition_2.add_node(A2) inner_composition_2.add_node(B2) inner_composition_2.add_projection(MappingProjection(sender=A2, receiver=B2), A2, B2) inner_composition_2.add_projection(MappingProjection(sender=A2.output_ports[1], receiver=B2.input_ports[1]), A2, B2) outer_composition = Composition(name="outer_composition") outer_composition.add_node(inner_composition_1) outer_composition.add_node(inner_composition_2) outer_composition.add_projection(projection=MappingProjection(), sender=inner_composition_1, receiver=inner_composition_2) outer_composition.add_projection( projection=MappingProjection(sender=inner_composition_1.output_CIM.output_ports[1], receiver=inner_composition_2.input_CIM.input_ports[1]), sender=inner_composition_1, receiver=inner_composition_2) sched = Scheduler(composition=outer_composition) output = outer_composition.run( inputs={inner_composition_1: [[[5.0], [50.0]]]}, scheduler=sched, bin_execute=mode ) assert np.allclose(output, [[[180.], [1800.]]]) if mode == 'Python': assert np.allclose(inner_composition_1.get_output_values(outer_composition), [[30.], [300.]]) assert np.allclose(inner_composition_2.get_output_values(outer_composition), [[180.], [1800.]]) assert np.allclose(outer_composition.get_output_values(outer_composition), [[180.], [1800.]])
def test_AtPass_underconstrained(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A') B = TransferMechanism(function=Linear(intercept=4.0), name='B') C = TransferMechanism(function=Linear(intercept=1.5), name='C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, AtPass(0)) sched.add_condition(B, Always()) sched.add_condition(C, Always()) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 2) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A, B, C, B, C] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_partial_override_composition(self): comp = Composition() A = TransferMechanism(name='scheduler-pytests-A') B = IntegratorMechanism(name='scheduler-pytests-B') for m in [A, B]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) termination_conds = {TimeScale.TRIAL: AfterNCalls(B, 2)} output = comp.run(inputs={A: 1}, termination_processing=termination_conds) # two executions of B assert output == [.75]
def test_linear_ABBCC(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, Any(AtPass(0), EveryNCalls(C, 2))) sched.add_condition(B, Any(JustRan(A), JustRan(B))) sched.add_condition(C, Any(EveryNCalls(B, 2), JustRan(C))) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 4, time_scale=TimeScale.TRIAL) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A, B, B, C, C, A, B, B, C, C] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_no_termination_conds(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B') C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C') for m in [A, B, C]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) comp.add_projection(MappingProjection(), B, C) sched = Scheduler(composition=comp) sched.add_condition(A, EveryNPasses(1)) sched.add_condition(B, EveryNCalls(A, 2)) sched.add_condition(C, EveryNCalls(B, 3)) output = list(sched.run()) expected_output = [ A, A, B, A, A, B, A, A, B, C, ] # pprint.pprint(output) assert output == pytest.helpers.setify_expected_output(expected_output)
def test_params_for_input_port_and_projection_variable_and_value(self): SAMPLE_INPUT = TransferMechanism() TARGET_INPUT = TransferMechanism() CM = ComparatorMechanism() P1 = MappingProjection(sender=SAMPLE_INPUT, receiver=CM.input_ports[SAMPLE], name='SAMPLE PROJECTION') P2 = MappingProjection(sender=TARGET_INPUT, receiver=CM.input_ports[TARGET], name='TARGET PROJECTION') C = Composition(nodes=[SAMPLE_INPUT, TARGET_INPUT, CM], projections=[P1,P2]) SAMPLE_INPUT.function.slope.base = 3 CM.input_ports[SAMPLE].function.scale.base = 2 TARGET_INPUT.input_port.function.scale.base = 4 CM.input_ports[TARGET].function.scale.base = 1.5 C.run(inputs={SAMPLE_INPUT: 2.0, TARGET_INPUT: 5.0}, runtime_params={ CM: { CM.input_ports[SAMPLE]: {'variable':(83,AtTrial(0))}, # InputPort object outside INPUT_PORT_PARAMS 'TARGET': {'value':(999, Any(AtTrial(1),AtTrial(2)))},# InputPort by name outsideINPUT_PORT_PARAMS INPUT_PORT_PARAMS: { 'scale': (15, AtTrial(2)), # all InputPorts MAPPING_PROJECTION_PARAMS:{'value':(20, Any(AtTrial(3), AtTrial(4))), # all MappingProjections 'SAMPLE PROJECTION': {'value':(42, AfterTrial(3))}, # By name P2:{'value':(156, AtTrial(5))}} # By Projection }}}, num_trials=6 ) assert np.allclose(C.results,[ # Conditions satisfied: CM calculates: TARGET-SAMPLE: np.array([[-136.0]]), # Trial 0: CM SAMPLE InputPort variable (5*4*2.5 - 83*2) np.array([[987]]), # Trial 1: CM TARGET InputPort value (999 - 2*3*2) np.array([[909]]), # Trial 2: CM TARGET InputPort value + CM Inputports SAMPLE fct scale: (999 - 2*3*15) np.array([[-10]]), # Trial 3: Both CM MappingProjections value, scale default (20*1.5 - 20*2) np.array([[-54]]), # Trial 4: Same as 3, but superceded by value for SAMPLE Projection (20*1.5 - 42*2) np.array([[150]]), # Trial 5: Same as 4, but superceded by value for TARGET Projection ((156*1.5-42*2)) ])