def test_log_csv_multiple_contexts(self):
pipeline = Queue()
con_X = pnl.Context(execution_id='comp X', rpc_pipeline=pipeline)
con_Y = pnl.Context(execution_id='comp Y', rpc_pipeline=pipeline)
A = pnl.TransferMechanism(name='A')
B = pnl.TransferMechanism(name='B')
C = pnl.TransferMechanism(name='C')
C.set_delivery_conditions(pnl.VALUE)
X = pnl.Composition(name='comp X')
Y = pnl.Composition(name='comp Y')
X.add_linear_processing_pathway([A, C])
Y.add_linear_processing_pathway([B, C])
# running with manual contexts for consistent output
# because output is sorted by context
X.run(inputs={A: 1}, context=con_X)
Y.run(inputs={B: 2}, context=con_Y)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
assert actual[0].context == 'comp X'
assert actual[0].time == '0:0:0:1'
assert actual[0].value.data == [1]
assert actual[1].context == 'comp Y'
assert actual[1].time == '0:0:0:1'
assert actual[1].value.data == [2]
def test_composition_default_names_2(self):
T = pnl.TransferMechanism(name='T0')
C1 = pnl.Composition(name='MY COMPOSITION', pathways=[T])
C2 = pnl.Composition(name='MY COMPOSITION', pathways=[T])
assert C1.name == 'MY COMPOSITION'
assert C2.name == 'MY COMPOSITION-1'
def test_composition_names(self):
T = pnl.TransferMechanism()
C1 = pnl.Composition(pathways=[T])
C2 = pnl.Composition(pathway=[T])
assert C1.name == 'Composition-0'
assert C2.name == 'Composition-1'
def test_masked_mapping_projection(self):
t1 = pnl.TransferMechanism(size=2)
t2 = pnl.TransferMechanism(size=2)
proj = pnl.MaskedMappingProjection(sender=t1,
receiver=t2,
matrix=[[1, 2], [3, 4]],
mask=[[1, 0], [0, 1]],
mask_operation=pnl.ADD)
c = pnl.Composition(pathways=[[t1, proj, t2]])
val = c.execute(inputs={t1: [1, 2]})
assert np.allclose(val, [[8, 12]])
t1 = pnl.TransferMechanism(size=2)
t2 = pnl.TransferMechanism(size=2)
proj = pnl.MaskedMappingProjection(sender=t1,
receiver=t2,
matrix=[[1, 2], [3, 4]],
mask=[[1, 0], [0, 1]],
mask_operation=pnl.MULTIPLY)
c = pnl.Composition(pathways=[[t1, proj, t2]])
val = c.execute(inputs={t1: [1, 2]})
assert np.allclose(val, [[1, 8]])
t1 = pnl.TransferMechanism(size=2)
t2 = pnl.TransferMechanism(size=2)
proj = pnl.MaskedMappingProjection(sender=t1,
receiver=t2,
mask=[[1, 2], [3, 4]],
mask_operation=pnl.MULTIPLY)
c = pnl.Composition(pathways=[[t1, proj, t2]])
val = c.execute(inputs={t1: [1, 2]})
assert np.allclose(val, [[1, 8]])
def test_composition_names(self):
C1 = pnl.Composition()
C2 = pnl.Composition()
C3 = pnl.Composition()
assert C1.name == 'Composition-0'
assert C2.name == 'Composition-1'
assert C3.name == 'Composition-2'
def test_add_pathway_methods_return_pathway(self):
c = pnl.Composition()
p = c.add_linear_processing_pathway(
pathway=[pnl.ProcessingMechanism(),
pnl.ProcessingMechanism()])
assert isinstance(p, pnl.Pathway)
c = pnl.Composition()
p = c.add_linear_learning_pathway(
pathway=[pnl.ProcessingMechanism(),
pnl.ProcessingMechanism()],
learning_function=pnl.BackPropagation)
assert isinstance(p, pnl.Pathway)
def test_model_based_ocm_no_simulations(self):
A = pnl.ProcessingMechanism(name='A')
B = pnl.ProcessingMechanism(name='B',
function=pnl.SimpleIntegrator(rate=1))
comp = pnl.Composition(name='comp')
comp.add_linear_processing_pathway([A, B])
control_signal = pnl.ControlSignal(
projections=[(pnl.SLOPE, A)],
function=pnl.Linear,
variable=1.0,
allocation_samples=[1, 2, 3],
intensity_cost_function=pnl.Linear(slope=0.))
objective_mech = pnl.ObjectiveMechanism(monitor=[B])
ocm = pnl.OptimizationControlMechanism(
agent_rep=comp,
features=[A.input_state],
objective_mechanism=objective_mech,
function=pnl.GridSearch(),
num_estimates=1,
control_signals=[control_signal],
search_statefulness=False,
)
comp.add_controller(ocm)
inputs = {A: [[[1.0]]]}
comp.run(inputs=inputs, num_trials=1)
# initial 1 + each allocation sample (1, 2, 3) integrated
assert B.parameters.value.get(comp) == 7
def test_configure_learning(self):
o = pnl.TransferMechanism()
m = pnl.ContrastiveHebbianMechanism(input_size=2,
hidden_size=0,
target_size=2,
mode=pnl.SIMPLE_HEBBIAN,
separated=False,
matrix=[[0, -.5], [-.5, 0]])
regexp = r"Learning cannot be enabled for .* because it has no LearningMechanism"
with pytest.warns(UserWarning, match=regexp):
m.learning_enabled = True
m.configure_learning()
m.reset_stateful_function_when = pnl.Never()
c = pnl.Composition()
c.add_linear_processing_pathway([m, o])
c.scheduler.add_condition(o, pnl.WhenFinished(m))
c.learn(inputs={m: [2, 2]}, num_trials=4)
results = c.parameters.results.get(c)
np.testing.assert_allclose(
results,
[[[2.671875]], [[2.84093837]], [[3.0510183]], [[3.35234623]]])
def test_lvoc_features_function(self):
m1 = pnl.TransferMechanism(
input_states=["InputState A", "InputState B"])
m2 = pnl.TransferMechanism()
c = pnl.Composition()
c.add_node(m1, required_roles=pnl.NodeRole.INPUT)
c.add_node(m2, required_roles=pnl.NodeRole.INPUT)
c._analyze_graph()
lvoc = pnl.OptimizationControlMechanism(
agent_rep=pnl.RegressionCFA,
features=[
m1.input_states[0], m1.input_states[1], m2.input_state, m2
],
feature_function=pnl.LinearCombination(offset=10.0),
objective_mechanism=pnl.ObjectiveMechanism(monitor=[m1, m2]),
function=pnl.GradientOptimization(max_iterations=1),
control_signals=[(pnl.SLOPE, m1), (pnl.SLOPE, m2)])
c.add_node(lvoc)
input_dict = {m1: [[1], [1]], m2: [1]}
c.run(inputs=input_dict)
assert len(lvoc.input_states) == 5
for i in range(1, 5):
assert lvoc.input_states[i].function.offset == 10.0
def test_DDM_threshold_modulation(mode):
M = pnl.DDM(
name='DDM',
function=pnl.DriftDiffusionAnalytical(
threshold=20.0,
),
)
monitor = pnl.TransferMechanism(default_variable=[[0.0]],
size=1,
function=pnl.Linear(slope=1, intercept=0),
output_ports=[pnl.RESULT],
name='monitor')
control = pnl.ControlMechanism(
monitor_for_control=monitor,
control_signals=[(pnl.THRESHOLD, M)])
C = pnl.Composition()
C.add_node(M, required_roles=[pnl.NodeRole.ORIGIN, pnl.NodeRole.TERMINAL])
C.add_node(monitor)
C.add_node(control)
inputs = {M:[1], monitor:[3]}
val = C.run(inputs, num_trials=1, bin_execute=mode)
# FIXME: Python version returns dtype=object
val = np.asfarray(val)
assert np.allclose(val[0], [60.0])
assert np.allclose(val[1], [60.2])
def figure_5a():
"""
This creates the plot for figure 5A in the Montague paper. Figure 5A is
a 'plot of ∂(t) over time for three trials during training (1, 30, and 50).'
"""
# Create Processing Components
sample_mechanism = pnl.TransferMechanism(default_variable=np.zeros(60),
name=pnl.SAMPLE)
action_selection = pnl.TransferMechanism(default_variable=np.zeros(60),
function=pnl.Linear(slope=1.0,
intercept=0.01),
name='Action Selection')
sample_to_action_selection = pnl.MappingProjection(sender=sample_mechanism,
receiver=action_selection,
matrix=np.zeros((60, 60)))
# Create Composition
composition_name = 'TD_Learning_Figure_5A'
comp = pnl.Composition(name=composition_name)
# Add Processing Components to the Composition
pathway = [sample_mechanism, sample_to_action_selection, action_selection]
# Add Learning Components to the Composition
learning_related_components = comp.add_td_learning_pathway(pathway, learning_rate=0.3).learning_components
# Unpack Relevant Learning Components
prediction_error_mechanism = learning_related_components[pnl.OBJECTIVE_MECHANISM]
target_mechanism = learning_related_components[pnl.TARGET_MECHANISM]
# Create Log
prediction_error_mechanism.log.set_log_conditions(pnl.VALUE)
# Create Stimulus Dictionary
no_reward_trials = {14, 29, 44, 59, 74, 89}
inputs = build_stimulus_dictionary(sample_mechanism, target_mechanism, no_reward_trials)
# Run Composition
comp.learn(inputs=inputs)
if args.enable_plot:
# Get Delta Values from Log
delta_vals = prediction_error_mechanism.log.nparray_dictionary()[composition_name][pnl.VALUE]
# Plot Delta Values form trials 1, 30, and 50
with plt.style.context('seaborn'):
plt.plot(delta_vals[0][0], "-o", label="Trial 1")
plt.plot(delta_vals[29][0], "-s", label="Trial 30")
plt.plot(delta_vals[49][0], "-o", label="Trial 50")
plt.title("Montague et. al. (1996) -- Figure 5A")
plt.xlabel("Timestep")
plt.ylabel("∂")
plt.legend()
plt.xlim(xmin=35)
plt.xticks()
plt.show(block=not pnl._called_from_pytest)
return comp
def test_simple_hebbian(self):
Hebb_C = pnl.Composition()
size = 9
Hebb2 = pnl.RecurrentTransferMechanism(
size=size,
function=pnl.Linear,
enable_learning=True,
hetero=0.,
auto=0.,
name='Hebb2',
)
Hebb_C.add_node(Hebb2)
src = [1, 0, 0, 1, 0, 0, 1, 0, 0]
inputs_dict = {Hebb2: np.array(src)}
Hebb_C.run(num_trials=5, inputs=inputs_dict)
activity = Hebb2.value
assert np.allclose(
activity,
[[1.86643089, 0., 0., 1.86643089, 0., 0., 1.86643089, 0., 0.]])
def test_DDM(self):
myMechanism = pnl.DDM(
function=psyneulink.core.components.functions.nonstateful.
distributionfunctions.DriftDiffusionAnalytical(
drift_rate=(1.0),
threshold=(10.0),
starting_point=0.0,
),
name='My_DDM',
)
myMechanism_2 = pnl.DDM(
function=psyneulink.core.components.functions.nonstateful.
distributionfunctions.DriftDiffusionAnalytical(drift_rate=2.0,
threshold=20.0),
name='My_DDM_2')
myMechanism_3 = pnl.DDM(
function=psyneulink.core.components.functions.nonstateful.
distributionfunctions.DriftDiffusionAnalytical(drift_rate=3.0,
threshold=30.0),
name='My_DDM_3',
)
z = pnl.Composition()
z.add_linear_processing_pathway([
myMechanism,
pnl.MappingProjection(matrix=pnl.IDENTITY_MATRIX), myMechanism_2,
pnl.MappingProjection(matrix=pnl.FULL_CONNECTIVITY_MATRIX),
myMechanism_3
])
result = z.run(inputs={myMechanism: [[40]]})[0][0]
expected_output = [
(myMechanism.input_ports[0].parameters.value.get(z),
np.array([40.])),
(myMechanism.output_ports[0].parameters.value.get(z),
np.array([10.])),
(myMechanism_2.input_ports[0].parameters.value.get(z),
np.array([10.])),
(myMechanism_2.output_ports[0].parameters.value.get(z),
np.array([20.])),
(myMechanism_3.input_ports[0].parameters.value.get(z),
np.array([20.])),
(myMechanism_3.output_ports[0].parameters.value.get(z),
np.array([30.])),
(result, np.array([30.])),
]
for i in range(len(expected_output)):
val, expected = expected_output[i]
# setting absolute tolerance to be in accordance with reference_output precision
# if you do not specify, assert_allcose will use a relative tolerance of 1e-07,
# which WILL FAIL unless you gather higher precision values to use as reference
np.testing.assert_allclose(
val,
expected,
atol=1e-08,
err_msg='Failed on expected_output[{0}]'.format(i))
def test_scheduled_contrastive_hebbian(self):
o = pnl.TransferMechanism()
m = pnl.ContrastiveHebbianMechanism(
input_size=2,
hidden_size=0,
target_size=2,
separated=False,
mode=pnl.SIMPLE_HEBBIAN,
integrator_mode=True,
enable_learning=False,
matrix=[[0, -1], [-1, 0]],
# auto=0,
# hetero=-1,
)
# set max passes to ensure failure if no convergence instead of infinite loop
m.max_passes = 1000
c = pnl.Composition()
c.add_linear_processing_pathway([m, o])
c.scheduler.add_condition(o, pnl.WhenFinished(m))
c._analyze_graph()
print('matrix:\n', m.afferents[1].matrix)
c.run(inputs={m: [2, 2]}, num_trials=4)
results = c.results
print(results)
np.testing.assert_allclose(results,
[[np.array([2.])], [np.array([2.])],
[np.array([2.])], [np.array([2.])]])
def test_output_port_variable_spec(self):
# Test specification of OutputPort's variable
udf = pnl.UserDefinedFunction(
custom_function=lambda x: np.array([[1], [2], [3]]))
mech = pnl.ProcessingMechanism(
function=udf,
name='MyMech',
output_ports=[
pnl.OutputPort(name='z', variable=(pnl.OWNER_VALUE, 2)),
pnl.OutputPort(name='y', variable=(pnl.OWNER_VALUE, 1)),
pnl.OutputPort(name='x', variable=(pnl.OWNER_VALUE, 0)),
pnl.OutputPort(name='all', variable=(pnl.OWNER_VALUE)),
pnl.OutputPort(name='execution count',
variable=(pnl.OWNER_EXECUTION_COUNT))
])
expected = [[3.], [2.], [1.], [[1.], [2.], [3.]], [0]]
for i, e in zip(mech.output_values, expected):
assert np.array_equal(i, e)
mech.execute([0])
expected = [[3.], [2.], [1.], [[1.], [2.], [3.]], [1]]
for i, e in zip(mech.output_values, expected):
assert np.array_equal(i, e)
# OutputPort mech.output_ports['all'] has a different dimensionality than the other OutputPorts;
# as a consequence, when added as a terminal node, the Composition can't construct an IDENTITY_MATRIX
# from the mech's OutputPorts to the Composition's output_CIM.
# FIX: Remove the following line and correct assertions below once above condition is resolved
mech.remove_ports(ports=mech.output_ports['all'])
C = pnl.Composition(name='MyComp')
C.add_node(node=mech)
outs = C.run(inputs={mech: np.array([[0]])})
assert np.array_equal(outs, np.array([[3], [2], [1], [2]]))
outs = C.run(inputs={mech: np.array([[0]])})
assert np.array_equal(outs, np.array([[3], [2], [1], [3]]))
def test_run_resets(self):
con_with_rpc_pipeline = pnl.Context(rpc_pipeline=Queue())
pipeline = con_with_rpc_pipeline.rpc_pipeline
T1 = pnl.TransferMechanism(name='log_test_T1',
size=2)
T2 = pnl.TransferMechanism(name='log_test_T2',
size=2)
COMP = pnl.Composition(name='COMP', pathways=[T1, T2])
T1.set_delivery_conditions('mod_slope')
T2.set_delivery_conditions('value')
COMP.run(inputs={T1: [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]},
context=con_with_rpc_pipeline)
pipeline = con_with_rpc_pipeline.rpc_pipeline
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
assert all([i.context == 'COMP' for i in actual])
assert np.allclose([
np.ndarray(shape=np.array(actual[1].value.shape), buffer=np.array(actual[1].value.data)),
np.ndarray(shape=np.array(actual[3].value.shape), buffer=np.array(actual[3].value.data)),
np.ndarray(shape=np.array(actual[5].value.shape), buffer=np.array(actual[5].value.data)),
], [[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]])
COMP.run(inputs={T1: [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]},
context=con_with_rpc_pipeline)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
assert np.allclose([
np.ndarray(shape=np.array(actual[1].value.shape), buffer=np.array(actual[1].value.data)),
np.ndarray(shape=np.array(actual[3].value.shape), buffer=np.array(actual[3].value.data)),
np.ndarray(shape=np.array(actual[5].value.shape), buffer=np.array(actual[5].value.data)),
], [[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]])
def test_component_execution_counts_for_mechanisms_in_composition(self):
T1 = pnl.TransferMechanism()
T2 = pnl.TransferMechanism()
c = pnl.Composition()
c.add_node(T1)
c.add_node(T2)
c.add_projection(sender=T1, receiver=T2)
input_dict = {T1: [[0]]}
c.run(input_dict)
assert T2.execution_count == 1
assert T2.input_port.execution_count == 1
assert T2.parameter_ports[pnl.SLOPE].execution_count == 0
assert T2.output_port.execution_count == 0
c.run(input_dict)
assert T2.execution_count == 2
assert T2.input_port.execution_count == 2
assert T2.parameter_ports[pnl.SLOPE].execution_count == 0
assert T2.output_port.execution_count == 0
c.run(input_dict)
assert T2.execution_count == 3
assert T2.input_port.execution_count == 3
assert T2.parameter_ports[pnl.SLOPE].execution_count == 0
assert T2.output_port.execution_count == 0
def test_configure_learning(self):
o = pnl.TransferMechanism()
m = pnl.ContrastiveHebbianMechanism(input_size=2,
hidden_size=0,
target_size=2,
mode=pnl.SIMPLE_HEBBIAN,
separated=False,
matrix=[[0, -.5], [-.5, 0]])
with pytest.warns(UserWarning) as record:
m.learning_enabled = True
correct_message_found = False
for warning in record:
if ("Learning cannot be enabled" in str(warning.message)
and "because it has no LearningMechanism" in str(
warning.message)):
correct_message_found = True
break
assert correct_message_found
m.configure_learning()
m.reinitialize_when = pnl.Never()
c = pnl.Composition()
c.add_linear_processing_pathway([m, o])
c.scheduler.add_condition(o, pnl.WhenFinished(m))
c.run(inputs={m: [2, 2]}, num_trials=4)
results = c.parameters.results.get(c)
np.testing.assert_allclose(
results,
[[[2.671875]], [[2.84093837]], [[3.0510183]], [[3.35234623]]])
def three_node_linear_composition():
A = pnl.TransferMechanism(name='A')
B = pnl.TransferMechanism(name='B')
C = pnl.TransferMechanism(name='C')
comp = pnl.Composition()
comp.add_linear_processing_pathway([A, B, C])
return comp.nodes, comp
def test_combine_param_alone(self):
t1 = pnl.TransferMechanism(size=2)
t2 = pnl.TransferMechanism(size=2)
t3 = pnl.TransferMechanism(
size=2, input_ports=pnl.InputPort(combine=pnl.PRODUCT))
c = pnl.Composition(pathways=[[t1, t3], [t2, t3]])
input_dict = {t1: [1, 2], t2: [3, 4]}
val = c.run(inputs=input_dict)
assert np.allclose(val, [[3, 8]])
def test_model_based_ocm_with_buffer(self):
A = pnl.ProcessingMechanism(name='A')
B = pnl.ProcessingMechanism(name='B')
comp = pnl.Composition(name='comp', controller_mode=pnl.BEFORE)
comp.add_linear_processing_pathway([A, B])
search_range = pnl.SampleSpec(start=0.25, stop=0.75, step=0.25)
control_signal = pnl.ControlSignal(
projections=[(pnl.SLOPE, A)],
function=pnl.Linear,
variable=1.0,
allocation_samples=search_range,
intensity_cost_function=pnl.Linear(slope=0.))
objective_mech = pnl.ObjectiveMechanism(monitor=[B])
ocm = pnl.OptimizationControlMechanism(
agent_rep=comp,
features=[A.input_state],
feature_function=pnl.Buffer(history=2),
objective_mechanism=objective_mech,
function=pnl.GridSearch(),
control_signals=[control_signal])
objective_mech.log.set_log_conditions(pnl.OUTCOME)
comp.add_controller(ocm)
inputs = {A: [[[1.0]], [[2.0]], [[3.0]]]}
for i in range(1, len(ocm.input_states)):
ocm.input_states[i].function.reinitialize()
comp.run(inputs=inputs, retain_old_simulation_data=True)
log = objective_mech.log.nparray_dictionary()
# "outer" composition
assert np.allclose(log["comp"][pnl.OUTCOME], [[0.75], [1.5], [2.25]])
# preprocess to ignore control allocations
log_parsed = {}
for key, value in log.items():
cleaned_key = re.sub(r'comp-sim-(\d).*', r'\1', key)
log_parsed[cleaned_key] = value
# First round of simulations is only one trial.
# (Even though the feature fn is a Buffer, there is no history yet)
for i in range(0, 3):
assert len(log_parsed[str(i)]["Trial"]) == 1
# Second and third rounds of simulations are two trials.
# (The buffer has history = 2)
for i in range(3, 9):
assert len(log_parsed[str(i)]["Trial"]) == 2
def test_dot_notation():
c = pnl.Composition()
d = pnl.Composition()
t = pnl.TransferMechanism()
c.add_node(t)
d.add_node(t)
t.execute(1)
assert t.value == 1
c.run({t: 5})
assert t.value == 5
d.run({t: 10})
assert t.value == 10
c.run({t: 20}, context='custom execution id')
assert t.value == 20
# context None
assert t.parameters.value.get() == 1
assert t.parameters.value.get(c) == 5
assert t.parameters.value.get(d) == 10
assert t.parameters.value.get('custom execution id') == 20
def test_composition_level_stateful_function_resets(self):
A = pnl.TransferMechanism(name='A',
integrator_mode=True,
integration_rate=0.5)
B = pnl.TransferMechanism(name='B',
integrator_mode=True,
integration_rate=0.5)
C = pnl.TransferMechanism(name='C')
comp = pnl.Composition(pathways=[[A, C], [B, C]])
A.log.set_log_conditions('value')
B.log.set_log_conditions('value')
comp.run(inputs={
A: [1.0],
B: [1.0]
},
reset_stateful_functions_when={
A: pnl.AtTrial(3),
B: pnl.AtTrial(4)
},
reset_stateful_functions_to={
A: 0.5,
B: 0.5
},
num_trials=5)
# Mechanism A - resets to 0.5 at the beginning of Trial 3. Its value at the end of Trial 3 will
# be exactly one step of integration forward from 0.5.
# Trial 0: 0.5, Trial 1: 0.75, Trial 2: 0.875, Trial 3: 0.75, Trial 4: 0.875
assert np.allclose(
A.log.nparray_dictionary('value')[
comp.default_execution_id]['value'],
[[np.array([0.5])], [np.array([0.75])], [np.array([0.875])],
[np.array([0.75])], [np.array([0.875])]])
# Mechanism B - resets to 0.5 at the beginning of Trial 4. Its value at the end of Trial 4 will
# be exactly one step of integration forward from 0.5.
# Trial 0: 0.5, Trial 1: 0.75, Trial 2: 0.875, Trial 3: 0.9375. Trial 4: 0.75
assert np.allclose(
B.log.nparray_dictionary('value')[
comp.default_execution_id]['value'],
[[np.array([0.5])], [np.array([0.75])], [np.array([0.875])],
[np.array([0.9375])], [np.array([0.75])]])
comp.reset()
comp.run(inputs={A: [1.0], B: [1.0]})
# Mechanisms A and B should have been reset, so verify that their new values are equal to their values at the
# end of trial 0
assert A.parameters.value.get(comp) == B.parameters.value.get(
comp) == [[0.5]]
def test_control_of_all_input_ports(self):
mech = pnl.ProcessingMechanism(input_ports=['A', 'B', 'C'])
control_mech = pnl.ControlMechanism(control=mech.input_ports)
comp = pnl.Composition()
comp.add_nodes([(mech, pnl.NodeRole.INPUT),
(control_mech, pnl.NodeRole.INPUT)])
results = comp.run(inputs={
mech: [[2], [2], [2]],
control_mech: [2]
},
num_trials=2)
np.allclose(results, [[4], [4], [4]])
def test_combine_param_redundant_fct_constructor_spec(self):
t1 = pnl.TransferMechanism(size=2)
t2 = pnl.TransferMechanism(size=2)
t3 = pnl.TransferMechanism(
size=2,
input_ports=pnl.InputPort(
function=psyneulink.core.components.functions.nonstateful.
combinationfunctions.LinearCombination(operation=pnl.PRODUCT),
combine=pnl.PRODUCT))
c = pnl.Composition(pathways=[[t1, t3], [t2, t3]])
input_dict = {t1: [1, 2], t2: [3, 4]}
val = c.run(inputs=input_dict)
assert np.allclose(val, [[3, 8]])
def test_no_warning_when_matrix_specified(self):
with pytest.warns(None) as w:
c = pnl.Composition()
m0 = pnl.ProcessingMechanism(default_variable=[0, 0, 0, 0])
p0 = pnl.MappingProjection(matrix=[[0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0], [0, 0, 0, 0]])
m1 = pnl.TransferMechanism(default_variable=[0, 0, 0, 0])
c.add_linear_processing_pathway([m0, p0, m1])
for warn in w:
if r'elementwise comparison failed; returning scalar instead' in warn.message.args[
0]:
raise
def test_transfer_mech(self):
T_1 = pnl.TransferMechanism(name='log_test_T_1', size=2)
T_2 = pnl.TransferMechanism(name='log_test_T_2', size=2)
con_with_rpc_pipeline = pnl.Context(rpc_pipeline=Queue())
PS = pnl.Composition(name='log_test_PS', pathways=[T_1, T_2])
T_1.set_log_conditions('mod_noise')
T_1.set_log_conditions(pnl.RESULT)
T_1.set_delivery_conditions('mod_noise')
T_1.set_delivery_conditions(pnl.RESULT)
PS.run(inputs={T_1: [0, 0]}, context=con_with_rpc_pipeline)
PS.run(inputs={T_1: [1, 2]}, context=con_with_rpc_pipeline)
PS.run(inputs={T_1: [3, 4]}, context=con_with_rpc_pipeline)
# assert T_1.log.print_entries() ==
# test_log.py::TestLog::test_log
# Log for log_test_T_1:
# Logged Item: Time Context Value
# 'RESULT' 0:0:0:0 'PROCESSING, COMPOSI... [0. 0.]
# 'RESULT' 1:0:0:0 'PROCESSING, COMPOSI... [1. 2.]
# 'RESULT' 2:0:0:0 'PROCESSING, COMPOSI... [3. 4.]
# 'mod_noise' 0:0:0:0 'PROCESSING, COMPOSI... [0.]
# 'mod_noise' 1:0:0:0 'PROCESSING, COMPOSI... [0.]
# 'mod_noise' 2:0:0:0 'PROCESSING, COMPOSI... [0.]
expected = [
[[0], [1], [2]],
[[0.], [0.], [0.]],
[[0.], [0.], [0.]],
[[0.], [0.], [0.]],
[[0.0], [0.0], [0.0]],
[[0., 0.], [1., 2.], [3., 4.]],
]
actual = []
pipeline = con_with_rpc_pipeline.rpc_pipeline
while not pipeline.empty():
actual.append(pipeline.get())
t_1_entries = [i for i in actual if i.componentName == 'log_test_T_1']
noise = [i for i in t_1_entries if i.parameterName == 'noise']
results = [i for i in t_1_entries if i.parameterName == 'RESULT']
assert all([
noise[0].time == '0:0:0:0', noise[0].value.data == [0],results[0].value.data == [0.0, 0.0],
noise[1].time == '1:0:0:0', noise[1].value.data == [0],results[1].value.data == [1.0, 2.0],
noise[2].time == '2:0:0:0', noise[2].value.data == [0],results[2].value.data == [3.0, 4.0],
])
def test_projection_specification_formats(self):
"""Test various matrix and Projection specifications
Also tests assignment of Projections to pathay of Composition using add_linear_processing_pathway:
- Projection explicitly specified in sequence (M1_M2_proj)
- Projection pre-constructed and assigned to Mechanisms, but not specified in pathway(M2_M3_proj)
- Projection specified in pathway that is duplicate one preconstructed and assigned to Mechanisms (M3_M4_proj)
(currently it should be ignored; in the future, if/when Projections between the same sender and receiver
in different Compositions are allowed, then it should be used)
"""
M1 = pnl.ProcessingMechanism(size=2)
M2 = pnl.ProcessingMechanism(size=5)
M3 = pnl.ProcessingMechanism(size=4)
M4 = pnl.ProcessingMechanism(size=3)
M1_M2_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5)
M2_M3_matrix = (np.arange(5 * 4).reshape((5, 4)) + 1) / (5 * 4)
M3_M4_matrix_A = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 5)
M3_M4_matrix_B = (np.arange(4 * 3).reshape((4, 3)) + 1) / (4 * 3)
M1_M2_proj = pnl.MappingProjection(matrix=M1_M2_matrix)
M2_M3_proj = pnl.MappingProjection(sender=M2,
receiver=M3,
matrix={
pnl.VALUE: M2_M3_matrix,
pnl.FUNCTION:
pnl.AccumulatorIntegrator,
pnl.FUNCTION_PARAMS: {
pnl.DEFAULT_VARIABLE:
M2_M3_matrix,
pnl.INITIALIZER:
M2_M3_matrix
}
})
M3_M4_proj_A = pnl.MappingProjection(sender=M3,
receiver=M4,
matrix=M3_M4_matrix_A)
c = pnl.Composition()
c.add_linear_processing_pathway(
pathway=[M1, M1_M2_proj, M2, M3, M3_M4_matrix_B, M4])
assert np.allclose(M2_M3_proj.matrix.base, M2_M3_matrix)
assert M2.efferents[0] is M2_M3_proj
assert np.allclose(M3.efferents[0].matrix.base, M3_M4_matrix_A)
# This is if different Projections are allowed between the same sender and receiver in different Compositions:
# assert np.allclose(M3.efferents[1].matrix, M3_M4_matrix_B)
c.run(inputs={M1: [2, -30]})
# assert np.allclose(c.results, [[-130.19166667, -152.53333333, -174.875]])
assert np.allclose(c.results, [[-78.115, -91.52, -104.925]])
def test_delivery_initialization(self):
con_with_rpc_pipeline = pnl.Context(rpc_pipeline=Queue())
pipeline = con_with_rpc_pipeline.rpc_pipeline
T = pnl.TransferMechanism(
prefs={pnl.DELIVERY_PREF: pnl.PreferenceEntry(pnl.LogCondition.EXECUTION, pnl.PreferenceLevel.INSTANCE)}
)
comp = pnl.Composition(name='comp', nodes=[T])
comp.run([1], context=con_with_rpc_pipeline)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
assert all([
len(actual) == 1,
actual[0].time == '0:0:0:0',
actual[0].value.shape == [1, 1],
actual[0].value.data == [1.0]
])
def test_control_modulation(self):
Tx = pnl.TransferMechanism(name='Tx')
Ty = pnl.TransferMechanism(name='Ty')
Tz = pnl.TransferMechanism(name='Tz')
C = pnl.ControlMechanism(
# function=pnl.Linear,
default_variable=[1],
monitor_for_control=Ty,
objective_mechanism=True,
control_signals=pnl.ControlSignal(modulation=pnl.OVERRIDE,
modulates=(pnl.SLOPE, Tz)))
comp = pnl.Composition(pathways=[[Tx, Tz], [Ty, C]])
# comp.show_graph()
assert Tz.parameter_ports[pnl.SLOPE].mod_afferents[0].sender.owner == C
result = comp.run(inputs={Tx: [1, 1], Ty: [4, 4]})
assert comp.results == [[[4.], [4.]], [[4.], [4.]]]
