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_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_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_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 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_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_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_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_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_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_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_simplified_greedy_agent_random(benchmark, mode): # These should probably be replaced by reference to ForagerEnv constants: obs_len = 2 action_len = 2 player_coord_idx = slice(0, 2) predator_coord_idx = slice(3, 5) prey_coord_idx = slice(6, 8) player_value_idx = 2 predator_value_idx = 5 prey_value_idx = 8 player_len = prey_len = predator_len = obs_len player = ProcessingMechanism(size=prey_len, function=GaussianDistort, name="PLAYER OBS") prey = ProcessingMechanism(size=prey_len, function=GaussianDistort, name="PREY OBS") # Use ComparatorMechanism to compute direction of action as difference of coordinates between player and prey: # note: unitization is done in main loop, to allow compilation of LinearCombination function) (TBI) greedy_action_mech = ComparatorMechanism(name='MOTOR OUTPUT', sample=player, target=prey) agent_comp = Composition(name='PREDATOR-PREY COMPOSITION') agent_comp.add_node(player) agent_comp.add_node(prey) agent_comp.add_node(greedy_action_mech) # Projections to greedy_action_mech were created by assignments of sample and target args in its constructor, # so just add them to the Composition). for projection in greedy_action_mech.projections: agent_comp.add_projection(projection) run_results = agent_comp.run(inputs={ player: [[619, 177]], prey: [[419, 69]] }, bin_execute=mode) # KDM 12/4/19: modified results due to global seed offset of # GaussianDistort assignment. # to produce old numbers, run get_global_seed once before creating # each Mechanism with GaussianDistort above assert np.allclose(run_results, [[-199.5484223217141, -107.79361870517444]]) if benchmark.enabled: benchmark( agent_comp.run, **{ 'inputs': { player: [[619, 177]], prey: [[419, 69]], }, 'bin_execute': mode })
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_simplified_greedy_agent_random(benchmark, mode): # These should probably be replaced by reference to ForagerEnv constants: obs_len = 2 action_len = 2 player_coord_idx = slice(0, 2) predator_coord_idx = slice(3, 5) prey_coord_idx = slice(6, 8) player_value_idx = 2 predator_value_idx = 5 prey_value_idx = 8 player_len = prey_len = predator_len = obs_len player = ProcessingMechanism(size=prey_len, function=GaussianDistort, name="PLAYER OBS") prey = ProcessingMechanism(size=prey_len, function=GaussianDistort, name="PREY OBS") # Use ComparatorMechanism to compute direction of action as difference of coordinates between player and prey: # note: unitization is done in main loop, to allow compilation of LinearCombination function) (TBI) greedy_action_mech = ComparatorMechanism(name='MOTOR OUTPUT', sample=player, target=prey) agent_comp = Composition(name='PREDATOR-PREY COMPOSITION') agent_comp.add_node(player) agent_comp.add_node(prey) agent_comp.add_node(greedy_action_mech) # Projections to greedy_action_mech were created by assignments of sample and target args in its constructor, # so just add them to the Composition). for projection in greedy_action_mech.projections: agent_comp.add_projection(projection) run_results = agent_comp.run(inputs={ player: [[619, 177]], prey: [[419, 69]] }, bin_execute=mode) assert np.allclose(run_results, [[-200.61352420749841, -109.9811418701135]]) benchmark( agent_comp.run, **{ 'inputs': { player: [[619, 177]], prey: [[419, 69]], }, 'bin_execute': mode })
def test_partial_override_scheduler(self): comp = Composition() A = TransferMechanism(name='scheduler-pytests-A') B = TransferMechanism(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 = {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)
def test_NWhen_AfterNCalls(self, n, expected_output): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A') B = TransferMechanism(function=Linear(intercept=4.0), name='B') for m in [A, B]: comp.add_node(m) comp.add_projection(MappingProjection(), A, B) sched = Scheduler(composition=comp) sched.add_condition(A, Always()) sched.add_condition(B, NWhen(AfterNCalls(A, 3), n)) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(A, 6) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A if x == 'A' else B for x in expected_output] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_linear_ABB(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, Any(AtPass(0), EveryNCalls(B, 2))) sched.add_condition(B, Any(EveryNCalls(A, 1), EveryNCalls(B, 1))) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AfterNCalls(B, 8, time_scale=TimeScale.TRIAL) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A, B, B, A, B, B, A, B, B, A, B, B] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_BeforeTimeStep_2(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A') B = TransferMechanism(name='B') comp.add_node(A) comp.add_node(B) comp.add_projection(MappingProjection(), A, B) sched = Scheduler(composition=comp) sched.add_condition(A, BeforeTimeStep(2)) sched.add_condition(B, Always()) termination_conds = {} termination_conds[TimeScale.RUN] = AfterNTrials(1) termination_conds[TimeScale.TRIAL] = AtPass(5) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A, B, B, B, B, B] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_9b(self): comp = Composition() A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A') A._is_finished = False 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] = AtPass(5) output = list(sched.run(termination_conds=termination_conds)) expected_output = [A, A, A, A, A] assert output == pytest.helpers.setify_expected_output(expected_output)
def test_connect_outer_composition_to_only_input_node_in_inner_comp_option2( self): inner1 = Composition(name="inner") A1 = TransferMechanism(name="A1", function=Linear(slope=2.0)) B1 = TransferMechanism(name="B1", function=Linear(slope=3.0)) inner1.add_linear_processing_pathway([A1, B1]) inner2 = Composition(name="inner2") A2 = TransferMechanism(name="A2", function=Linear(slope=2.0)) B2 = TransferMechanism(name="B2", function=Linear(slope=3.0)) inner2.add_linear_processing_pathway([A2, B2]) outer = Composition(name="outer") outer.add_nodes([inner1, inner2]) outer.add_projection(sender=inner1, receiver=A2) # CRASHING WITH: FIX 6/1/20 # subprocess.CalledProcessError: Command '['dot', '-Tpdf', '-O', 'outer']' returned non-zero exit status 1. # outer.show_graph(show_node_structure=True, # show_nested=True) # comp1: input = 5.0 | mechA: 2.0*5.0 = 10.0 | mechB: 3.0*10.0 = 30.0 | output = 30.0 # comp2: input = 30.0 | mechA2: 2.0*30.0 = 60.0 | mechB2: 3.0*60.0 = 180.0 | output = 180.0 # comp3: input = 5.0 | output = 180.0 res = outer.run(inputs={inner1: [[5.]]}) assert np.allclose(res, [[[180.0]]]) assert np.allclose(inner1.output_port.parameters.value.get(outer), [30.0]) assert np.allclose(inner2.output_port.parameters.value.get(outer), [180.0]) assert np.allclose(outer.output_port.parameters.value.get(outer), [180.0])
def test_connect_outer_composition_to_all_input_nodes_in_inner_comp(self): inner1 = Composition(name="inner") A1 = TransferMechanism(name="A1", function=Linear(slope=2.0)) B1 = TransferMechanism(name="B1", function=Linear(slope=3.0)) inner1.add_linear_processing_pathway([A1, B1]) inner2 = Composition(name="inner2") A2 = TransferMechanism(name="A2") B2 = TransferMechanism(name="B2") C2 = TransferMechanism(name="C2") inner2.add_nodes([A2, B2, C2]) outer1 = Composition(name="outer1") outer1.add_nodes([inner1, inner2]) # Spec 1: add projection *node in* inner1 --> inner 2 (implies first InputPort -- corresponding to A2) outer1.add_projection(sender=B1, receiver=inner2) # Spec 2: add projection *node in* inner1 --> *node in* inner2 outer1.add_projection(sender=B1, receiver=B2) # Spec 3: add projection inner1 --> *node in* inner2 outer1.add_projection(sender=inner1, receiver=C2) eid = "eid" outer1.run(inputs={inner1: [[1.]]}, context=eid) assert np.allclose(A1.parameters.value.get(eid), [[2.0]]) assert np.allclose(B1.parameters.value.get(eid), [[6.0]]) for node in [A2, B2, C2]: assert np.allclose(node.parameters.value.get(eid), [[6.0]])
def test_debug_comp(mode, debug_env): # save old debug env var old_env = os.environ.get("PNL_LLVM_DEBUG") if debug_env is not None: os.environ["PNL_LLVM_DEBUG"] = debug_env pnlvm.debug._update() comp = Composition() A = IntegratorMechanism(default_variable=1.0, function=Linear(slope=5.0)) B = TransferMechanism(function=Linear(slope=5.0), integrator_mode=True) comp.add_node(A) comp.add_node(B) comp.add_projection(MappingProjection(sender=A, receiver=B), A, B) sched = Scheduler(composition=comp) inputs_dict = {A: [5]} output1 = comp.run(inputs=inputs_dict, scheduler=sched, bin_execute=mode) output2 = comp.run(inputs=inputs_dict, scheduler=sched, bin_execute=mode) # restore old debug env var and cleanup the debug configuration if old_env is None: del os.environ["PNL_LLVM_DEBUG"] else: os.environ["PNL_LLVM_DEBUG"] = old_env pnlvm.debug._update() assert len(comp.results) == 2 if "const_input" in debug_env: expected1 = 87.5 expected2 = 131.25 else: expected1 = 62.5 expected2 = 93.75 if "const_state" in debug_env: expected2 = expected1 assert np.allclose(expected1, output1[0][0]) assert np.allclose(expected2, output2[0][0])
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_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_connect_outer_composition_to_only_input_node_in_inner_comp_option3( self): inner1 = Composition(name="inner") A1 = TransferMechanism(name="A1", function=Linear(slope=2.0)) B1 = TransferMechanism(name="B1", function=Linear(slope=3.0)) inner1.add_linear_processing_pathway([A1, B1]) inner2 = Composition(name="inner2") A2 = TransferMechanism(name="A2", function=Linear(slope=2.0)) B2 = TransferMechanism(name="B2", function=Linear(slope=3.0)) inner2.add_linear_processing_pathway([A2, B2]) outer = Composition(name="outer") outer.add_nodes([inner1, inner2]) outer.add_projection(sender=B1, receiver=A2) # comp1: input = 5.0 | mechA: 2.0*5.0 = 10.0 | mechB: 3.0*10.0 = 30.0 | output = 30.0 # comp2: input = 30.0 | mechA2: 2.0*30.0 = 60.0 | mechB2: 3.0*60.0 = 180.0 | output = 180.0 # comp3: input = 5.0 | output = 180.0 res = outer.run(inputs={inner1: [[5.]]}) assert np.allclose(res, [[[180.0]]]) assert np.allclose(inner1.output_port.parameters.value.get(outer), [30.0]) assert np.allclose(inner2.output_port.parameters.value.get(outer), [180.0]) assert np.allclose(outer.output_port.parameters.value.get(outer), [180.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_states[1], receiver=B.input_states[1]), A, B) inner_composition_1._analyze_graph() 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_states[1], receiver=B2.input_states[1]), A2, B2) inner_composition_2._analyze_graph() 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_states[1], receiver=inner_composition_2.input_CIM.input_states[1]), sender=inner_composition_1, receiver=inner_composition_2) sched = Scheduler(composition=outer_composition) outer_composition._analyze_graph() output = outer_composition.run( inputs={inner_composition_1: [[[5.0], [50.0]]]}, scheduler_processing=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_compositions_as_origin_nodes(self, mode): inner_composition_1 = Composition(name="inner_composition_1") A = TransferMechanism(name="A", function=Linear(slope=0.5)) B = TransferMechanism(name="B", function=Linear(slope=2.0)) C = TransferMechanism(name="C", function=Linear(slope=3.0)) inner_composition_1.add_node(A) inner_composition_1.add_node(B) inner_composition_1.add_node(C) inner_composition_1.add_projection(MappingProjection(), A, C) inner_composition_1.add_projection(MappingProjection(), B, C) inner_composition_1._analyze_graph() inner_composition_2 = Composition(name="inner_composition_2") A2 = TransferMechanism(name="A2", function=Linear(slope=0.25)) B2 = TransferMechanism(name="B2", function=Linear(slope=1.0)) inner_composition_2.add_node(A2) inner_composition_2.add_node(B2) inner_composition_2.add_projection(MappingProjection(), A2, B2) inner_composition_2._analyze_graph() mechanism_d = TransferMechanism(name="D", function=Linear(slope=3.0)) outer_composition = Composition(name="outer_composition") outer_composition.add_node(inner_composition_1) outer_composition.add_node(inner_composition_2) outer_composition.add_node(mechanism_d) outer_composition.add_projection(projection=MappingProjection(), sender=inner_composition_1, receiver=mechanism_d) outer_composition.add_projection(projection=MappingProjection(), sender=inner_composition_2, receiver=mechanism_d) sched = Scheduler(composition=outer_composition) outer_composition._analyze_graph() # FIX: order of InputStates on inner composition 1 is not stable output = outer_composition.run( inputs={ # inner_composition_1: [[2.0], [1.0]], inner_composition_1: { A: [2.0], B: [1.0] }, inner_composition_2: [[12.0]] }, scheduler_processing=sched, bin_execute=mode) assert np.allclose(output, [[[36.]]]) if mode == 'Python': assert np.allclose(A.get_output_values(outer_composition), [[1.0]]) assert np.allclose(B.get_output_values(outer_composition), [[2.0]]) assert np.allclose(C.get_output_values(outer_composition), [[9.0]]) assert np.allclose(A2.get_output_values(outer_composition), [[3.0]]) assert np.allclose(B2.get_output_values(outer_composition), [[3.0]]) assert np.allclose( inner_composition_1.get_output_values(outer_composition), [[9.0]]) assert np.allclose( inner_composition_2.get_output_values(outer_composition), [[3.0]]) assert np.allclose( mechanism_d.get_output_values(outer_composition), [[36.0]]) assert np.allclose( outer_composition.get_output_values(outer_composition), [[36.0]])
def test_compositions_as_origin_nodes_multiple_trials(self, mode): inner_composition_1 = Composition(name="inner_composition_1") A = TransferMechanism(name="A", function=Linear(slope=0.5)) B = TransferMechanism(name="B", function=Linear(slope=2.0)) C = TransferMechanism(name="C", function=Linear(slope=3.0)) inner_composition_1.add_node(A) inner_composition_1.add_node(B) inner_composition_1.add_node(C) inner_composition_1.add_projection(MappingProjection(), A, C) inner_composition_1.add_projection(MappingProjection(), B, C) inner_composition_1._analyze_graph() inner_composition_2 = Composition(name="inner_composition_2") A2 = TransferMechanism(name="A2", function=Linear(slope=0.25)) B2 = TransferMechanism(name="B2", function=Linear(slope=1.0)) inner_composition_2.add_node(A2) inner_composition_2.add_node(B2) inner_composition_2.add_projection(MappingProjection(), A2, B2) inner_composition_2._analyze_graph() mechanism_d = TransferMechanism(name="D", function=Linear(slope=3.0)) outer_composition = Composition(name="outer_composition") outer_composition.add_node(inner_composition_1) outer_composition.add_node(inner_composition_2) outer_composition.add_node(mechanism_d) outer_composition.add_projection(projection=MappingProjection(), sender=inner_composition_1, receiver=mechanism_d) outer_composition.add_projection(projection=MappingProjection(), sender=inner_composition_2, receiver=mechanism_d) sched = Scheduler(composition=outer_composition) outer_composition._analyze_graph() # FIX: order of InputStates on inner composition 1 is not stable output = outer_composition.run(inputs={ inner_composition_1: { A: [[2.0], [1.5], [2.5]], B: [[1.0], [1.5], [1.5]] }, inner_composition_2: [[12.0], [11.5], [12.5]] }, scheduler_processing=sched, bin_execute=mode) # trial 0: # inner composition 1 = (0.5*2.0 + 2.0*1.0) * 3.0 = 9.0 # inner composition 2 = 0.25*12.0 = 3.0 # outer composition = (3.0 + 9.0) * 3.0 = 36.0 # trial 1: # inner composition 1 = (0.5*1.5 + 2.0*1.5) * 3.0 = 11.25 # inner composition 2 = 0.25*11.5 = 2.875 # outer composition = (2.875 + 11.25) * 3.0 = 42.375 # trial 2: # inner composition 1 = (0.5*2.5 + 2.0*1.5) * 3.0 = 12.75 # inner composition 2 = 0.25*12.5 = 3.125 # outer composition = (3.125 + 12.75) * 3.0 = 47.625 assert np.allclose(output, np.array([47.625]))
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_states[1], receiver=B0), A0, B0) level_0._analyze_graph() # 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_1._analyze_graph() # 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) level_2._analyze_graph() sched = Scheduler(composition=level_2) # FIX: order of InputStates 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_processing=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])