def test_function_params_with_different_but_overlapping_conditions(self):
T = TransferMechanism()
C = Composition()
C.add_node(T)
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
# run with runtime param used for slope only on trial 1 and after 2 (i.e., 3 and 4)
C.run(inputs={T: 2.0},
runtime_params={T: {"slope": (10.0, Any(AtTrial(1), AfterTrial(2))),
"intercept": (1.0, AfterTrial(1))}},
num_trials=4)
# slope restored to default
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
assert T.function.intercept.base == 0.0
assert T.parameter_ports['intercept'].value == 0.0
# run again to insure restored default for slope after last run
C.run(inputs={T: 2.0})
# results reflect runtime_param used for slope only on trials 1, 3 and 4
assert np.allclose(C.results,[np.array([[2.]]), # Trial 0 - neither condition met
np.array([[20.]]), # Trial 1 - slope condition met, intercept not met
np.array([[3.]]), # Trial 2 - slope condition not met, intercept met
np.array([[21.]]), # Trial 3 - both conditions met
np.array([[2.]])]) # New run (runtime param no longer applies)
def test_composition_run_with_sticky_condition(self):
# Construction
T = TransferMechanism()
C = Composition()
C.add_node(T)
assert T.noise == 0.0
assert T.parameter_ports['noise'].value == 0.0
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
C.run(inputs={T: 2.0},
runtime_params={T: {
"noise": (10.0, AfterTrial(1))
}},
num_trials=4)
# Runtime param NOT used for noise
C.run(inputs={T: 2.0})
assert np.allclose(
C.results,
[
np.array([[2.]]), # Trial 0 - condition not satisfied yet
np.array([[2.]]), # Trial 1 - condition not satisfied yet
np.array([[12.]]), # Trial 2 - condition satisfied
np.array([[12.]]), # Trial 3 - condition satisfied (sticky)
np.array([[2.]])
]) # New run (runtime param no longer applies)
def test_composition_run_with_combined_condition(self):
# Construction
T = TransferMechanism()
C = Composition()
C.add_node(T)
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
C.run(inputs={T: 2.0},
runtime_params={
T: {
"noise": (10.0, Any(AtTrial(1), AfterTrial(2)))
}
},
num_trials=5)
# Runtime param NOT used for noise
C.run(inputs={T: 2.0})
assert np.allclose(
C.results,
[
np.array([[2.]]), # Trial 0 - NOT condition 0, NOT condition 1
np.array([[12.]]), # Trial 1 - condition 0, NOT condition 1
np.array([[2.]]), # Trial 2 - NOT condition 0, NOT condition 1
np.array([[12.]]), # Trial 3 - NOT condition 0, condition 1
np.array([[12.]]), # Trial 4 - NOT condition 0, condition 1
np.array([[2.]])
]) # New run (runtime param no longer applies)
def test_function_param_with_combined_condition(self):
T = TransferMechanism()
C = Composition()
C.add_node(T)
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
# run with runtime param used for slope only on trial 1 and after 2 (i.e., 3 and 4)
C.run(inputs={T: 2.0},
runtime_params={T: {"slope": (10.0, Any(AtTrial(1), AfterTrial(2)))}},
num_trials=5)
# slope restored to default
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
# run again to insure restored default for slope after last run
C.run(inputs={T: 2.0})
# results reflect runtime_param used for slope only on trials 1, 3 and 4
assert np.allclose(C.results,[np.array([[2.]]), # Trial 0 - NOT condition 0, NOT condition 1
np.array([[20.]]), # Trial 1 - condition 0, NOT condition 1
np.array([[2.]]), # Trial 2 - NOT condition 0, NOT condition 1
np.array([[20.]]), # Trial 3 - NOT condition 0, condition 1
np.array([[20.]]), # Trial 4 - NOT condition 0, condition 1
np.array([[2.]])]) # New run (runtime param no longer applies)
def test_mechanism_param_with_AfterTrial_condition(self):
T = TransferMechanism()
C = Composition()
C.add_node(T)
assert T.noise.base == 0.0
assert T.parameter_ports['noise'].value == 0.0
# run with runtime param used for noise after trial 1 (i.e., trials 2 and 3)
C.run(inputs={T: 2.0},
runtime_params={T: {"noise": (10.0, AfterTrial(1))}},
num_trials=4)
# noise restored to default
assert T.noise.base == 0.0
assert T.parameter_ports['noise'].parameters.value.get(C) == 0.0
# run again to insure restored default for noise after last run
C.run(inputs={T: 2.0})
# results reflect runtime_param used for noise only on trials 2 and 3
assert np.allclose(C.results, [np.array([[2.]]), # Trial 0 - condition not satisfied yet
np.array([[2.]]), # Trial 1 - condition not satisfied yet
np.array([[12.]]), # Trial 2 - condition satisfied
np.array([[12.]]), # Trial 3 - condition satisfied (sticky)
np.array([[2.]])]) # New run (runtime param no longer applies)
def test_system_run_with_combined_condition(self):
# Construction
T = TransferMechanism()
P = Process(pathway=[T])
S = System(processes=[P])
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
S.run(inputs={T: 2.0},
runtime_params={
T: {
"noise": (10.0, Any(AtTrial(1), AfterTrial(2)))
}
},
num_trials=5)
# Runtime param NOT used for noise
S.run(inputs={T: 2.0})
assert np.allclose(
S.results,
[
[np.array([2.])], # Trial 0 - NOT condition 0, NOT condition 1
[np.array([12.])], # Trial 1 - condition 0, NOT condition 1
[np.array([2.])], # Trial 2 - NOT condition 0, NOT condition 1
[np.array([12.])], # Trial 3 - NOT condition 0, condition 1
[np.array([12.])], # Trial 4 - NOT condition 0, condition 1
[np.array([2.])]
]) # New run (runtime param no longer applies)
def test_system_run_with_sticky_condition(self):
# Construction
T = TransferMechanism()
P = Process(pathway=[T])
S = System(processes=[P])
assert T.noise == 0.0
assert T.parameter_states['noise'].value == 0.0
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
S.run(inputs={T: 2.0},
runtime_params={T: {
"noise": (10.0, AfterTrial(1))
}},
num_trials=4)
# Runtime param NOT used for noise
S.run(inputs={T: 2.0})
assert np.allclose(
S.results,
[
[np.array([2.])], # Trial 0 - condition not satisfied yet
[np.array([2.])], # Trial 1 - condition not satisfied yet
[np.array([12.])], # Trial 2 - condition satisfied
[np.array([12.])], # Trial 3 - condition satisfied (sticky)
[np.array([2.])]
]) # New run (runtime param no longer applies)
def test_AfterTrial(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, Always())
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterTrial(4)
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, A]
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))
])