def change_termination_processing():
if S.termination_processing is None:
S.scheduler_processing.termination_conds = {TimeScale.TRIAL: WhenFinished(D)}
S.termination_processing = {TimeScale.TRIAL: WhenFinished(D)}
elif isinstance(S.termination_processing[TimeScale.TRIAL], AllHaveRun):
S.scheduler_processing.termination_conds = {TimeScale.TRIAL: WhenFinished(D)}
S.termination_processing = {TimeScale.TRIAL: WhenFinished(D)}
else:
S.scheduler_processing.termination_conds = {TimeScale.TRIAL: AllHaveRun()}
S.termination_processing = {TimeScale.TRIAL: AllHaveRun()}
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_equivalance_of_threshold_and_when_finished_condition(self):
# Note: This tests the equivalence of results when:
# execute_until_finished is True for the LCAMechanism (by default)
# and the call to execution loops until it reaches threshold (1st test)
# vs. when execute_until_finished is False and a condition is added to the scheduler
# that causes the LCAMechanism it to execute until it reaches threshold (2nd test).
# loop Mechanism's call to execute
lca_until_thresh = LCAMechanism(
size=2, leak=0.5,
threshold=0.7) # Note: , execute_to_threshold=True by default
response = ProcessingMechanism(size=2)
comp = Composition()
comp.add_linear_processing_pathway([lca_until_thresh, response])
result1 = comp.run(inputs={lca_until_thresh: [1, 0]})
# loop Composition's call to Mechanism
lca_single_step = LCAMechanism(size=2,
leak=0.5,
threshold=0.7,
execute_until_finished=False)
comp2 = Composition()
response2 = ProcessingMechanism(size=2)
comp2.add_linear_processing_pathway([lca_single_step, response2])
comp2.scheduler.add_condition(response2, WhenFinished(lca_single_step))
result2 = comp2.run(inputs={lca_single_step: [1, 0]})
assert np.allclose(result1, result2)
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_is_finished_stops_composition(self):
D = DDM(name='DDM', function=DriftDiffusionIntegrator(threshold=10.0))
C = Composition(pathways=[D], reset_stateful_function_when=Never())
C.run(inputs={D: 2.0},
termination_processing={TimeScale.TRIAL: WhenFinished(D)})
# decision variable's value should match threshold
assert D.parameters.value.get(C)[0] == 10.0
# it should have taken 5 executions (and time_step_size = 1.0)
assert D.parameters.value.get(C)[1] == 5.0
def test_is_finished_stops_system(self):
D = DDM(name='DDM', function=DriftDiffusionIntegrator(threshold=10.0))
P = Process(pathway=[D])
S = System(processes=[P], reinitialize_mechanisms_when=Never())
S.run(inputs={D: 2.0},
termination_processing={TimeScale.TRIAL: WhenFinished(D)})
# decision variable's value should match threshold
assert D.parameters.value.get(S)[0] == 10.0
# it should have taken 5 executions (and time_step_size = 1.0)
assert D.parameters.value.get(S)[1] == 5.0
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_WhenFinished_DDM_Analytical():
D = DDM(function=DriftDiffusionAnalytical)
c = WhenFinished(D)
c.is_satisfied()
def test_invalid_input_WhenFinishedAll_2(self):
with pytest.raises(ConditionError):
WhenFinished({None}).is_satisfied()
def test_invalid_input_WhenFinishedAny_1(self):
with pytest.raises(ConditionError):
WhenFinished(None).is_satisfied()