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_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_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_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_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_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_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_composition_two_contexts(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A')
comp.add_node(A)
sched = Scheduler(composition=comp)
sched.add_condition(A, BeforeNCalls(A, 5, time_scale=TimeScale.LIFE))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(6)
termination_conds[TimeScale.TRIAL] = AfterNPasses(1)
eid = uuid.uuid4()
comp.run(
inputs={A: [[0], [1], [2], [3], [4], [5]]},
scheduler_processing=sched,
termination_processing=termination_conds,
execution_id=eid,
)
output = sched.execution_list[eid]
expected_output = [
A, A, A, A, A, set()
]
# pprint.pprint(output)
assert output == pytest.helpers.setify_expected_output(expected_output)
comp.run(
inputs={A: [[0], [1], [2], [3], [4], [5]]},
scheduler_processing=sched,
termination_processing=termination_conds,
execution_id=eid,
)
output = sched.execution_list[eid]
expected_output = [
A, A, A, A, A, set(), set(), set(), set(), set(), set(), set()
]
# pprint.pprint(output)
assert output == pytest.helpers.setify_expected_output(expected_output)
eid2 = uuid.uuid4()
comp.run(
inputs={A: [[0], [1], [2], [3], [4], [5]]},
scheduler_processing=sched,
termination_processing=termination_conds,
execution_id=eid2,
)
output = sched.execution_list[eid2]
expected_output = [
A, A, A, A, A, set()
]
# pprint.pprint(output)
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_WhileNot_AtPass_in_middle(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A')
comp.add_node(A)
sched = Scheduler(composition=comp)
sched.add_condition(A, WhileNot(lambda sched: sched.clock.get_total_times_relative(TimeScale.PASS, TimeScale.TRIAL) == 2, sched))
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, set(), A, A]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_BeforeNCalls(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A')
comp.add_node(A)
sched = Scheduler(composition=comp)
sched.add_condition(A, BeforeNCalls(A, 3))
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, set(), set()]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_All_end_after_one_finished(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A')
for m in [A]:
comp.add_node(m)
sched = Scheduler(composition=comp)
sched.add_condition(A, EveryNPasses(1))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = Any(AfterNCalls(A, 5), AtPass(10))
output = list(sched.run(termination_conds=termination_conds))
expected_output = [A for _ in range(5)]
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_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_BeforeTrial(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A')
comp.add_node(A)
sched = Scheduler(composition=comp)
sched.add_condition(A, BeforeTrial(4))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(5)
termination_conds[TimeScale.TRIAL] = AtPass(1)
comp.run(
inputs={A: range(6)},
scheduler=sched,
termination_processing=termination_conds
)
output = sched.execution_list[comp.default_execution_id]
expected_output = [A, A, A, A, set()]
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_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)
