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