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])
