def test_control_signal_and_control_projection_names(self): D1 = pnl.DDM(name='D1') D2 = pnl.DDM(name='D2') # ControlSignal with one ControlProjection C1 = pnl.ControlMechanism(control_signals=[D1.parameter_states[ psyneulink.core.components.functions.distributionfunctions.DRIFT_RATE]]) assert C1.control_signals[0].name == 'D1[drift_rate] ControlSignal' assert C1.control_signals[0].efferents[0].name == 'ControlProjection for D1[drift_rate]' # ControlSignal with two ControlProjection to two parameters of same Mechanism C2 = pnl.ControlMechanism(control_signals=[{pnl.PROJECTIONS:[D1.parameter_states[ psyneulink.core.components.functions.distributionfunctions.DRIFT_RATE], D1.parameter_states[ psyneulink.core.components.functions.distributionfunctions.THRESHOLD]]}]) assert C2.control_signals[0].name == 'D1[drift_rate, threshold] ControlSignal' assert C2.control_signals[0].efferents[0].name == 'ControlProjection for D1[drift_rate]' assert C2.control_signals[0].efferents[1].name == 'ControlProjection for D1[threshold]' # ControlSignal with two ControlProjection to two parameters of different Mechanisms C3 = pnl.ControlMechanism(control_signals=[{pnl.PROJECTIONS:[D1.parameter_states[ psyneulink.core.components.functions.distributionfunctions.DRIFT_RATE], D2.parameter_states[ psyneulink.core.components.functions.distributionfunctions.DRIFT_RATE]]}]) assert C3.control_signals[0].name == 'ControlSignal-0 divergent ControlSignal' assert C3.control_signals[0].efferents[0].name == 'ControlProjection for D1[drift_rate]' assert C3.control_signals[0].efferents[1].name == 'ControlProjection for D2[drift_rate]'
def test_formats_for_control_specification_for_mechanism_and_function_params( self): control_spec_list = [ pnl.CONTROL, pnl.CONTROL_SIGNAL, pnl.CONTROL_PROJECTION, pnl.ControlSignal, pnl.ControlSignal(), pnl.ControlProjection, "CP_OBJECT", pnl.ControlMechanism, pnl.ControlMechanism(), (0.3, pnl.CONTROL), (0.3, pnl.CONTROL_SIGNAL), (0.3, pnl.CONTROL_PROJECTION), (0.3, pnl.ControlSignal), (0.3, pnl.ControlSignal()), (0.3, pnl.ControlProjection), (0.3, "CP_OBJECT"), (0.3, pnl.ControlMechanism), (0.3, pnl.ControlMechanism()) ] for i, ctl_tuple in enumerate( [j for j in zip(control_spec_list, reversed(control_spec_list))]): C1, C2 = ctl_tuple # This shenanigans is to avoid assigning the same instantiated ControlProjection more than once if C1 is 'CP_OBJECT': C1 = pnl.ControlProjection() elif isinstance(C1, tuple) and C1[1] is 'CP_OBJECT': C1 = (C1[0], pnl.ControlProjection()) if C2 is 'CP_OBJECT': C2 = pnl.ControlProjection() elif isinstance(C2, tuple) and C2[1] is 'CP_OBJECT': C2 = (C2[0], pnl.ControlProjection()) R = pnl.RecurrentTransferMechanism(noise=C1, function=pnl.Logistic(gain=C2)) assert R.parameter_states[pnl.NOISE].mod_afferents[0].name in \ 'ControlProjection for RecurrentTransferMechanism-{}[noise]'.format(i) assert R.parameter_states[pnl.GAIN].mod_afferents[0].name in \ 'ControlProjection for RecurrentTransferMechanism-{}[gain]'.format(i)
def test_2_item_tuple_from_control_signal_to_parameter_state(self): D = pnl.DDM(name='D') # Single name C = pnl.ControlMechanism(control_signals=[(pnl.DRIFT_RATE, D)]) assert C.control_signals[0].name == 'D[drift_rate] ControlSignal' assert C.control_signals[0].efferents[0].receiver.name == 'drift_rate' # List of names C = pnl.ControlMechanism(control_signals=[([pnl.DRIFT_RATE, pnl.THRESHOLD], D)]) assert C.control_signals[0].name == 'D[drift_rate, threshold] ControlSignal' assert C.control_signals[0].efferents[0].receiver.name == 'drift_rate' assert C.control_signals[0].efferents[1].receiver.name == 'threshold'
def test_multiple_modulatory_projections_with_mech_and_port_Name_specs( self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ pnl.MECHANISM: M, pnl.PARAMETER_PORTS: [ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE, psyneulink.core.globals.keywords.THRESHOLD ] }]) G = pnl.GatingMechanism(gating_signals=[{ pnl.MECHANISM: M, pnl.OUTPUT_PORTS: [pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME] }]) assert len(C.control_signals) == 1 assert len(C.control_signals[0].efferents) == 2 assert M.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0] == C.control_signals[0].efferents[0] assert M.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert len(G.gating_signals[0].efferents) == 2 assert M.output_ports[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_ports[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1]
def test_multiple_modulatory_projections_with_port_Name(self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ 'DECISION_CONTROL': [ M.parameter_ports[psyneulink.core.components.functions. distributionfunctions.DRIFT_RATE], M.parameter_ports[psyneulink.core.globals.keywords.THRESHOLD] ] }]) G = pnl.GatingMechanism(gating_signals=[{ 'DDM_OUTPUT_GATE': [ M.output_ports[pnl.DECISION_VARIABLE], M.output_ports[ pnl.RESPONSE_TIME] ] }]) assert len(C.control_signals) == 1 assert C.control_signals[0].name == 'DECISION_CONTROL' assert len(C.control_signals[0].efferents) == 2 assert M.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0] == C.control_signals[0].efferents[0] assert M.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert G.gating_signals[0].name == 'DDM_OUTPUT_GATE' assert len(G.gating_signals[0].efferents) == 2 assert M.output_ports[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_ports[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1]
def test_multiple_modulatory_projections_with_state_name(self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ 'DECISION_CONTROL': [ M.parameter_states[pnl.DRIFT_RATE], M.parameter_states[ pnl.THRESHOLD] ] }]) G = pnl.GatingMechanism(gating_signals=[{ 'DDM_OUTPUT_GATE': [ M.output_states[pnl.DECISION_VARIABLE], M.output_states[ pnl.RESPONSE_TIME] ] }]) assert len(C.control_signals) == 1 assert C.control_signals[0].name == 'DECISION_CONTROL' assert len(C.control_signals[0].efferents) == 2 assert M.parameter_states[pnl.DRIFT_RATE].mod_afferents[ 0] == C.control_signals[0].efferents[0] assert M.parameter_states[pnl.THRESHOLD].mod_afferents[ 0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert G.gating_signals[0].name == 'DDM_OUTPUT_GATE' assert len(G.gating_signals[0].efferents) == 2 assert M.output_states[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_states[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1]
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 test_multiple_modulatory_projection_specs(self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ pnl.PROJECTIONS: [ M.parameter_ports[ psyneulink.core.components.functions.nonstateful. distributionfunctions.DRIFT_RATE], M.parameter_ports[ psyneulink.core.globals.keywords.THRESHOLD] ] }]) G = pnl.GatingMechanism(gating_signals=[{ pnl.PROJECTIONS: [ M.output_ports[pnl.DECISION_VARIABLE], M.output_ports[ pnl.RESPONSE_TIME] ] }]) assert len(C.control_signals) == 1 assert len(C.control_signals[0].efferents) == 2 assert M.parameter_ports[ psyneulink.core.components.functions.nonstateful. distributionfunctions. DRIFT_RATE].mod_afferents[0] == C.control_signals[0].efferents[0] assert M.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert len(G.gating_signals[0].efferents) == 2 assert M.output_ports[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_ports[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1]
def test_multiple_modulatory_projection_specs(self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ pnl.PROJECTIONS: [ M.parameter_states[pnl.DRIFT_RATE], M.parameter_states[ pnl.THRESHOLD] ] }]) G = pnl.GatingMechanism(gating_signals=[{ pnl.PROJECTIONS: [ M.output_states[pnl.DECISION_VARIABLE], M.output_states[ pnl.RESPONSE_TIME] ] }]) assert len(C.control_signals) == 1 assert len(C.control_signals[0].efferents) == 2 assert M.parameter_states[pnl.DRIFT_RATE].mod_afferents[ 0] == C.control_signals[0].efferents[0] assert M.parameter_states[pnl.THRESHOLD].mod_afferents[ 0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert len(G.gating_signals[0].efferents) == 2 assert M.output_states[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_states[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1]
def test_multiple_modulatory_projections_with_mech_and_state_name_specs( self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ pnl.MECHANISM: M, pnl.PARAMETER_STATES: [pnl.DRIFT_RATE, pnl.THRESHOLD] }]) G = pnl.GatingMechanism(gating_signals=[{ pnl.MECHANISM: M, pnl.OUTPUT_STATES: [pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME] }]) assert len(C.control_signals) == 1 assert len(C.control_signals[0].efferents) == 2 assert M.parameter_states[pnl.DRIFT_RATE].mod_afferents[ 0] == C.control_signals[0].efferents[0] assert M.parameter_states[pnl.THRESHOLD].mod_afferents[ 0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert len(G.gating_signals[0].efferents) == 2 assert M.output_states[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_states[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1]
def test_2_item_tuple_from_parameter_state_to_control_signals(self): C = pnl.ControlMechanism(control_signals=['a','b']) D = pnl.DDM(name='D3', function=pnl.BogaczEtAl(drift_rate=(3,C), threshold=(2,C.control_signals['b'])) ) assert D.parameter_states[pnl.DRIFT_RATE].mod_afferents[0].sender==C.control_signals[0] assert D.parameter_states[pnl.THRESHOLD].mod_afferents[0].sender==C.control_signals[1]
def test_2_item_tuple_from_control_signal_to_parameter_port(self): D = pnl.DDM(name='D') # Single name C = pnl.ControlMechanism( control_signals=[(psyneulink.core.components.functions. distributionfunctions.DRIFT_RATE, D)]) assert C.control_signals[0].name == 'D[drift_rate] ControlSignal' assert C.control_signals[0].efferents[0].receiver.name == 'drift_rate' # List of names C = pnl.ControlMechanism(control_signals=[([ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE, psyneulink.core.globals.keywords.THRESHOLD ], D)]) assert C.control_signals[ 0].name == 'D[drift_rate, threshold] ControlSignal' assert C.control_signals[0].efferents[0].receiver.name == 'drift_rate' assert C.control_signals[0].efferents[1].receiver.name == 'threshold'
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_2_item_tuple_from_parameter_port_to_control_signals(self): C = pnl.ControlMechanism(control_signals=['a', 'b']) D = pnl.DDM(name='D3', function=psyneulink.core.components.functions. distributionfunctions.DriftDiffusionAnalytical( drift_rate=(3, C), threshold=(2, C.control_signals['b']))) assert D.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0].sender == C.control_signals[0] assert D.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0].sender == C.control_signals[1]
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.]]]
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, control_signals=pnl.ControlSignal(modulation=pnl.OVERRIDE, projections=(pnl.SLOPE,Tz))) P1=pnl.Process(pathway=[Tx,Tz]) P2=pnl.Process(pathway=[Ty, C]) S=pnl.System(processes=[P1, P2]) assert Tz.parameter_states[pnl.SLOPE].mod_afferents[0].sender.owner == C result = S.run(inputs={Tx:[1,1], Ty:[4,4]}) assert result == [[[4.], [4.]], [[4.], [4.]]]
def test_control_of_all_output_ports(self): mech = pnl.ProcessingMechanism(output_ports=[{ pnl.VARIABLE: (pnl.OWNER_VALUE, 0) }, { pnl.VARIABLE: (pnl.OWNER_VALUE, 0) }, { pnl.VARIABLE: (pnl.OWNER_VALUE, 0) }], ) control_mech = pnl.ControlMechanism(control=mech.output_ports) comp = pnl.Composition() comp.add_nodes([(mech, pnl.NodeRole.INPUT), (control_mech, pnl.NodeRole.INPUT)]) results = comp.run(inputs={ mech: [[2]], control_mech: [3] }, num_trials=2) np.allclose(results, [[6], [6], [6]])
}], ) Conflict_Monitor = pnl.ObjectiveMechanism( name="Conflict_Monitor", function=pnl.Energy(matrix=[[0, -2.5], [-2.5, 0]], default_variable=[[0.0, 0.0]]), monitor=[OUTPUT], default_variable=[[0.0, 0.0]], ) CONTROL = pnl.ControlMechanism( name="CONTROL", default_allocation=[0.5], function=pnl.DefaultAllocationFunction(default_variable=[[1.0]]), monitor_for_control=[], objective_mechanism=Conflict_Monitor, control=[{ pnl.NAME: pnl.GAIN, pnl.MECHANISM: TASK }], ) Stroop_model.add_node(color_input) Stroop_model.add_node(color_hidden) Stroop_model.add_node(OUTPUT) Stroop_model.add_node(word_input) Stroop_model.add_node(word_hidden) Stroop_model.add_node(task_input) Stroop_model.add_node(TASK) Stroop_model.add_node(DECISION) Stroop_model.add_node(Conflict_Monitor, pnl.NodeRole.CONTROLLER_OBJECTIVE)
default_variable=[[0.0, 0.0]], weights=[1, -1] ), pnl.NAME: pnl.ARRAY, pnl.VARIABLE: [[0.0, 0.0]], } ], ) CONTROL = pnl.ControlMechanism( name="CONTROL", default_allocation=[0.5], function=pnl.DefaultAllocationFunction(default_variable=[[1.0]]), monitor_for_control=[], objective_mechanism=pnl.ObjectiveMechanism( name="Conflict Monitor", function=pnl.Energy( matrix=[[0, -2.5], [-2.5, 0]], default_variable=[[0.0, 0.0]] ), monitor=[OUTPUT], default_variable=[[0.0, 0.0]], ), control=[{pnl.MECHANISM: TASK, pnl.NAME: pnl.GAIN}], ) Stroop_model.add_node(color_input) Stroop_model.add_node(color_hidden) Stroop_model.add_node(OUTPUT) Stroop_model.add_node(word_input) Stroop_model.add_node(word_hidden) Stroop_model.add_node(task_input) Stroop_model.add_node(TASK)
def test_identicalness_of_control_and_gating(self): """Tests same configuration as gating in tests/mechansims/test_gating_mechanism""" Input_Layer = pnl.TransferMechanism(name='Input Layer', function=pnl.Logistic, size=2) Hidden_Layer_1 = pnl.TransferMechanism(name='Hidden Layer_1', function=pnl.Logistic, size=5) Hidden_Layer_2 = pnl.TransferMechanism(name='Hidden Layer_2', function=pnl.Logistic, size=4) Output_Layer = pnl.TransferMechanism(name='Output Layer', function=pnl.Logistic, size=3) Control_Mechanism = pnl.ControlMechanism(size=[1], control=[ Hidden_Layer_1.input_port, Hidden_Layer_2.input_port, Output_Layer.input_port ]) Input_Weights_matrix = (np.arange(2 * 5).reshape((2, 5)) + 1) / (2 * 5) Middle_Weights_matrix = (np.arange(5 * 4).reshape( (5, 4)) + 1) / (5 * 4) Output_Weights_matrix = (np.arange(4 * 3).reshape( (4, 3)) + 1) / (4 * 3) # This projection is specified in add_backpropagation_learning_pathway method below Input_Weights = pnl.MappingProjection(name='Input Weights', matrix=Input_Weights_matrix) # This projection is "discovered" by add_backpropagation_learning_pathway method below Middle_Weights = pnl.MappingProjection(name='Middle Weights', sender=Hidden_Layer_1, receiver=Hidden_Layer_2, matrix={ pnl.VALUE: Middle_Weights_matrix, pnl.FUNCTION: pnl.AccumulatorIntegrator, pnl.FUNCTION_PARAMS: { pnl.DEFAULT_VARIABLE: Middle_Weights_matrix, pnl.INITIALIZER: Middle_Weights_matrix, pnl.RATE: Middle_Weights_matrix }, }) Output_Weights = pnl.MappingProjection(sender=Hidden_Layer_2, receiver=Output_Layer, matrix=Output_Weights_matrix) pathway = [ Input_Layer, Input_Weights, Hidden_Layer_1, Hidden_Layer_2, Output_Layer ] comp = pnl.Composition() backprop_pathway = comp.add_backpropagation_learning_pathway( pathway=pathway, loss_function=None, ) # c.add_linear_processing_pathway(pathway=z) comp.add_node(Control_Mechanism) stim_list = { Input_Layer: [[-1, 30]], Control_Mechanism: [1.0], backprop_pathway.target: [[0, 0, 1]] } comp.learn(num_trials=3, inputs=stim_list) expected_results = [[[0.81493513, 0.85129046, 0.88154205]], [[0.81331773, 0.85008207, 0.88157851]], [[0.81168332, 0.84886047, 0.88161468]]] assert np.allclose(comp.results, expected_results) stim_list[Control_Mechanism] = [0.0] results = comp.learn(num_trials=1, inputs=stim_list) expected_results = [[[0.5, 0.5, 0.5]]] assert np.allclose(results, expected_results) stim_list[Control_Mechanism] = [2.0] results = comp.learn(num_trials=1, inputs=stim_list) expected_results = [[0.96941429, 0.9837254, 0.99217549]] assert np.allclose(results, expected_results)
def test_control_signal_default_allocation_specification(self): m1 = pnl.ProcessingMechanism() m2 = pnl.ProcessingMechanism() m3 = pnl.ProcessingMechanism() # default_allocation not specified in constructor of pnl.ControlMechanism, # so should be set to defaultControlAllocation (=[1]) if not specified in pnl.ControlSignal constructor c1 = pnl.ControlMechanism( name='C1', default_variable=[10], control_signals=[ pnl.ControlSignal(modulates=( pnl.SLOPE, m1)), # test for assignment to defaultControlAllocation pnl.ControlSignal( default_allocation=2, # test for scalar assignment modulates=(pnl.SLOPE, m2)), pnl.ControlSignal( default_allocation=[3], # test for array assignment modulates=(pnl.SLOPE, m3)) ]) comp = pnl.Composition() comp.add_nodes([m1, m2, m3]) comp.add_controller(c1) assert c1.control_signals[0].value == [ 10 ] # defaultControlAllocation should be assigned # (as no default_allocation from pnl.ControlMechanism) assert m1.parameter_ports[pnl.SLOPE].value == [1] assert c1.control_signals[1].value == [ 2 ] # default_allocation from pnl.ControlSignal (converted scalar) assert m2.parameter_ports[pnl.SLOPE].value == [1] assert c1.control_signals[2].value == [ 3 ] # default_allocation from pnl.ControlSignal assert m3.parameter_ports[pnl.SLOPE].value == [1] result = comp.run(inputs={m1: [2], m2: [3], m3: [4]}) assert np.allclose(result, [[20.], [6.], [12.]]) assert c1.control_signals[0].value == [10] assert m1.parameter_ports[pnl.SLOPE].value == [10] assert c1.control_signals[1].value == [10] assert m2.parameter_ports[pnl.SLOPE].value == [2] assert c1.control_signals[2].value == [10] assert m3.parameter_ports[pnl.SLOPE].value == [3] result = comp.run(inputs={m1: [2], m2: [3], m3: [4]}) assert np.allclose(result, [[20.], [30.], [40.]]) assert c1.control_signals[0].value == [10] assert m1.parameter_ports[pnl.SLOPE].value == [10] assert c1.control_signals[1].value == [10] assert m2.parameter_ports[pnl.SLOPE].value == [10] assert c1.control_signals[2].value == [10] assert m3.parameter_ports[pnl.SLOPE].value == [10] # default_allocation *is* specified in constructor of pnl.ControlMechanism, # so should be used unless specified in pnl.ControlSignal constructor c2 = pnl.ControlMechanism( name='C3', default_variable=[10], default_allocation=[4], control_signals=[ pnl.ControlSignal(modulates=( pnl.SLOPE, m1)), # tests for assignment to default_allocation pnl.ControlSignal( default_allocation= 5, # tests for override of default_allocation modulates=(pnl.SLOPE, m2)), pnl.ControlSignal( default_allocation=[6], # as above same but with array modulates=(pnl.SLOPE, m3)) ]) comp = pnl.Composition() comp.add_nodes([m1, m2, m3]) comp.add_controller(c2) assert c2.control_signals[0].value == [ 4 ] # default_allocation from pnl.ControlMechanism assigned assert m1.parameter_ports[pnl.SLOPE].value == [ 10 ] # has not yet received pnl.ControlSignal value assert c2.control_signals[1].value == [ 5 ] # default_allocation from pnl.ControlSignal assigned (converted scalar) assert m2.parameter_ports[pnl.SLOPE].value == [10] assert c2.control_signals[2].value == [ 6 ] # default_allocation from pnl.ControlSignal assigned assert m3.parameter_ports[pnl.SLOPE].value == [10] result = comp.run(inputs={m1: [2], m2: [3], m3: [4]}) assert np.allclose(result, [[8.], [15.], [24.]]) assert c2.control_signals[0].value == [10] assert m1.parameter_ports[pnl.SLOPE].value == [4] assert c2.control_signals[1].value == [10] assert m2.parameter_ports[pnl.SLOPE].value == [5] assert c2.control_signals[2].value == [10] assert m3.parameter_ports[pnl.SLOPE].value == [6] result = comp.run(inputs={m1: [2], m2: [3], m3: [4]}) assert np.allclose(result, [[20.], [30.], [40.]]) assert c2.control_signals[0].value == [10] assert m1.parameter_ports[pnl.SLOPE].value == [10] assert c2.control_signals[1].value == [10] assert m2.parameter_ports[pnl.SLOPE].value == [10] assert c2.control_signals[2].value == [10] assert m3.parameter_ports[pnl.SLOPE].value == [10]
class TestProjectionSpecificationFormats: 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_multiple_modulatory_projection_specs(self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ pnl.PROJECTIONS: [ M.parameter_ports[psyneulink.core.components.functions. distributionfunctions.DRIFT_RATE], M.parameter_ports[psyneulink.core.globals.keywords.THRESHOLD] ] }]) G = pnl.GatingMechanism(gating_signals=[{ pnl.PROJECTIONS: [ M.output_ports[pnl.DECISION_VARIABLE], M.output_ports[ pnl.RESPONSE_TIME] ] }]) assert len(C.control_signals) == 1 assert len(C.control_signals[0].efferents) == 2 assert M.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0] == C.control_signals[0].efferents[0] assert M.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert len(G.gating_signals[0].efferents) == 2 assert M.output_ports[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_ports[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1] def test_multiple_modulatory_projections_with_port_Name(self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ 'DECISION_CONTROL': [ M.parameter_ports[psyneulink.core.components.functions. distributionfunctions.DRIFT_RATE], M.parameter_ports[psyneulink.core.globals.keywords.THRESHOLD] ] }]) G = pnl.GatingMechanism(gating_signals=[{ 'DDM_OUTPUT_GATE': [ M.output_ports[pnl.DECISION_VARIABLE], M.output_ports[ pnl.RESPONSE_TIME] ] }]) assert len(C.control_signals) == 1 assert C.control_signals[0].name == 'DECISION_CONTROL' assert len(C.control_signals[0].efferents) == 2 assert M.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0] == C.control_signals[0].efferents[0] assert M.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert G.gating_signals[0].name == 'DDM_OUTPUT_GATE' assert len(G.gating_signals[0].efferents) == 2 assert M.output_ports[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_ports[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1] def test_multiple_modulatory_projections_with_mech_and_port_Name_specs( self): M = pnl.DDM(name='MY DDM') C = pnl.ControlMechanism(control_signals=[{ pnl.MECHANISM: M, pnl.PARAMETER_PORTS: [ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE, psyneulink.core.globals.keywords.THRESHOLD ] }]) G = pnl.GatingMechanism(gating_signals=[{ pnl.MECHANISM: M, pnl.OUTPUT_PORTS: [pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME] }]) assert len(C.control_signals) == 1 assert len(C.control_signals[0].efferents) == 2 assert M.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0] == C.control_signals[0].efferents[0] assert M.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0] == C.control_signals[0].efferents[1] assert len(G.gating_signals) == 1 assert len(G.gating_signals[0].efferents) == 2 assert M.output_ports[pnl.DECISION_VARIABLE].mod_afferents[ 0] == G.gating_signals[0].efferents[0] assert M.output_ports[pnl.RESPONSE_TIME].mod_afferents[ 0] == G.gating_signals[0].efferents[1] def test_mapping_projection_with_mech_and_port_Name_specs(self): R1 = pnl.TransferMechanism(output_ports=['OUTPUT_1', 'OUTPUT_2']) R2 = pnl.TransferMechanism(default_variable=[[0], [0]], input_ports=['INPUT_1', 'INPUT_2']) T = pnl.TransferMechanism(input_ports=[{ pnl.MECHANISM: R1, pnl.OUTPUT_PORTS: ['OUTPUT_1', 'OUTPUT_2'] }], output_ports=[{ pnl.MECHANISM: R2, pnl.INPUT_PORTS: ['INPUT_1', 'INPUT_2'] }]) assert len(R1.output_ports) == 2 assert len(R2.input_ports) == 2 assert len(T.input_ports) == 1 for input_port in T.input_ports: for projection in input_port.path_afferents: assert projection.sender.owner is R1 assert len(T.output_ports) == 1 for output_port in T.output_ports: for projection in output_port.efferents: assert projection.receiver.owner is R2 def test_mapping_projection_using_2_item_tuple_with_list_of_port_Names( self): T1 = pnl.TransferMechanism(name='T1', input_ports=[[0, 0], [0, 0, 0]]) T2 = pnl.TransferMechanism(name='T2', output_ports=[ (['InputPort-0', 'InputPort-1'], T1) ]) assert len(T2.output_ports) == 1 assert T2.output_ports[0].efferents[0].receiver.name == 'InputPort-0' assert T2.output_ports[0].efferents[0].matrix.base.shape == (1, 2) assert T2.output_ports[0].efferents[1].receiver.name == 'InputPort-1' assert T2.output_ports[0].efferents[1].matrix.base.shape == (1, 3) def test_mapping_projection_using_2_item_tuple_and_3_item_tuples_with_index_specs( self): T1 = pnl.TransferMechanism(name='T1', input_ports=[[0, 0], [0, 0, 0]]) T2 = pnl.TransferMechanism(name='T2', input_ports=['a', 'b', 'c'], output_ports=[ (['InputPort-0', 'InputPort-1'], T1), ('InputPort-0', (pnl.OWNER_VALUE, 2), T1), (['InputPort-0', 'InputPort-1'], 1, T1) ]) assert len(T2.output_ports) == 3 assert T2.output_ports[0].efferents[0].receiver.name == 'InputPort-0' assert T2.output_ports[0].efferents[0].matrix.base.shape == (1, 2) assert T2.output_ports[0].efferents[1].receiver.name == 'InputPort-1' assert T2.output_ports[0].efferents[1].matrix.base.shape == (1, 3) assert T2.output_ports[1].owner_value_index == 2 assert T2.output_ports[2].owner_value_index == 1 def test_2_item_tuple_from_control_signal_to_parameter_port(self): D = pnl.DDM(name='D') # Single name C = pnl.ControlMechanism( control_signals=[(psyneulink.core.components.functions. distributionfunctions.DRIFT_RATE, D)]) assert C.control_signals[0].name == 'D[drift_rate] ControlSignal' assert C.control_signals[0].efferents[0].receiver.name == 'drift_rate' # List of names C = pnl.ControlMechanism(control_signals=[([ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE, psyneulink.core.globals.keywords.THRESHOLD ], D)]) assert C.control_signals[ 0].name == 'D[drift_rate, threshold] ControlSignal' assert C.control_signals[0].efferents[0].receiver.name == 'drift_rate' assert C.control_signals[0].efferents[1].receiver.name == 'threshold' def test_2_item_tuple_from_parameter_port_to_control_signals(self): C = pnl.ControlMechanism(control_signals=['a', 'b']) D = pnl.DDM(name='D3', function=psyneulink.core.components.functions. distributionfunctions.DriftDiffusionAnalytical( drift_rate=(3, C), threshold=(2, C.control_signals['b']))) assert D.parameter_ports[ psyneulink.core.components.functions.distributionfunctions. DRIFT_RATE].mod_afferents[0].sender == C.control_signals[0] assert D.parameter_ports[ psyneulink.core.globals.keywords. THRESHOLD].mod_afferents[0].sender == C.control_signals[1] def test_2_item_tuple_from_gating_signal_to_output_ports(self): D4 = pnl.DDM(name='D4') # Single name G = pnl.GatingMechanism(gating_signals=[(pnl.DECISION_VARIABLE, D4)]) assert G.gating_signals[0].name == 'D4[DECISION_VARIABLE] GatingSignal' assert G.gating_signals[0].efferents[ 0].receiver.name == 'DECISION_VARIABLE' # List of names G = pnl.GatingMechanism( gating_signals=[([pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME], D4)]) assert G.gating_signals[ 0].name == 'D4[DECISION_VARIABLE, RESPONSE_TIME] GatingSignal' assert G.gating_signals[0].efferents[ 0].receiver.name == 'DECISION_VARIABLE' assert G.gating_signals[0].efferents[ 1].receiver.name == 'RESPONSE_TIME' def test_2_item_tuple_from_input_and_output_ports_to_gating_signals(self): G = pnl.GatingMechanism(gating_signals=['a', 'b']) T = pnl.TransferMechanism(name='T', input_ports=[(3, G)], output_ports=[(2, G.gating_signals['b'])]) assert T.input_ports[0].mod_afferents[0].sender == G.gating_signals[0] assert T.output_ports[0].mod_afferents[0].sender == G.gating_signals[1] control_spec_list = [ pnl.CONTROL, pnl.CONTROL_SIGNAL, pnl.CONTROL_PROJECTION, pnl.ControlSignal, pnl.ControlSignal(), pnl.ControlProjection, "CP_OBJECT", pnl.ControlMechanism, pnl.ControlMechanism(), pnl.ControlMechanism, (0.3, pnl.CONTROL), (0.3, pnl.CONTROL_SIGNAL), (0.3, pnl.CONTROL_PROJECTION), (0.3, pnl.ControlSignal), (0.3, pnl.ControlSignal()), (0.3, pnl.ControlProjection), (0.3, "CP_OBJECT"), (0.3, pnl.ControlMechanism), (0.3, pnl.ControlMechanism()), (0.3, pnl.ControlMechanism) ] @pytest.mark.parametrize( 'noise, gain', [(noise, gain) for noise, gain in [j for j in zip(control_spec_list, reversed(control_spec_list))]]) def test_formats_for_control_specification_for_mechanism_and_function_params( self, noise, gain): # This shenanigans is to avoid assigning the same instantiated ControlProjection more than once if noise == 'CP_OBJECT': noise = pnl.ControlProjection() elif isinstance(noise, tuple) and noise[1] == 'CP_OBJECT': noise = (noise[0], pnl.ControlProjection()) if gain == 'CP_OBJECT': gain = pnl.ControlProjection() elif isinstance(gain, tuple) and gain[1] == 'CP_OBJECT': gain = (gain[0], pnl.ControlProjection()) R = pnl.RecurrentTransferMechanism( # NOTE: fixed name prevents failures due to registry naming # for parallel test runs name='R-CONTROL', noise=noise, function=psyneulink.core.components.functions.transferfunctions. Logistic(gain=gain)) assert R.parameter_ports[pnl.NOISE].mod_afferents[0].name in \ 'ControlProjection for R-CONTROL[noise]' assert R.parameter_ports[pnl.GAIN].mod_afferents[0].name in \ 'ControlProjection for R-CONTROL[gain]' gating_spec_list = [ pnl.GATING, pnl.CONTROL, pnl.GATING_SIGNAL, pnl.CONTROL_SIGNAL, pnl.GATING_PROJECTION, pnl.CONTROL_PROJECTION, pnl.GatingSignal, pnl.ControlSignal, pnl.GatingSignal(), pnl.ControlSignal(), pnl.GatingProjection, "GP_OBJECT", pnl.GatingMechanism, pnl.ControlMechanism, pnl.GatingMechanism(), pnl.ControlMechanism(), (0.3, pnl.GATING), (0.3, pnl.CONTROL), (0.3, pnl.GATING_SIGNAL), (0.3, pnl.CONTROL_SIGNAL), (0.3, pnl.GATING_PROJECTION), (0.3, pnl.CONTROL_PROJECTION), (0.3, pnl.GatingSignal), (0.3, pnl.ControlSignal), (0.3, pnl.GatingSignal()), (0.3, pnl.ControlSignal()), (0.3, pnl.GatingProjection), (0.3, pnl.ControlProjection), (0.3, "GP_OBJECT"), (0.3, pnl.GatingMechanism), (0.3, pnl.ControlMechanism), (0.3, pnl.GatingMechanism()), (0.3, pnl.ControlMechanism()) ] @pytest.mark.parametrize( 'input_port, output_port', [(inp, outp) for inp, outp in [j for j in zip(gating_spec_list, reversed(gating_spec_list))]]) def test_formats_for_gating_specification_of_input_and_output_ports( self, input_port, output_port): G_IN, G_OUT = input_port, output_port # This shenanigans is to avoid assigning the same instantiated ControlProjection more than once if G_IN == 'GP_OBJECT': G_IN = pnl.GatingProjection() elif isinstance(G_IN, tuple) and G_IN[1] == 'GP_OBJECT': G_IN = (G_IN[0], pnl.GatingProjection()) if G_OUT == 'GP_OBJECT': G_OUT = pnl.GatingProjection() elif isinstance(G_OUT, tuple) and G_OUT[1] == 'GP_OBJECT': G_OUT = (G_OUT[0], pnl.GatingProjection()) if isinstance(G_IN, tuple): IN_NAME = G_IN[1] else: IN_NAME = G_IN IN_CONTROL = pnl.CONTROL in repr(IN_NAME).split(".")[-1].upper() if isinstance(G_OUT, tuple): OUT_NAME = G_OUT[1] else: OUT_NAME = G_OUT OUT_CONTROL = pnl.CONTROL in repr(OUT_NAME).split(".")[-1].upper() T = pnl.TransferMechanism(name='T-GATING', input_ports=[G_IN], output_ports=[G_OUT]) if IN_CONTROL: assert T.input_ports[0].mod_afferents[0].name in \ 'ControlProjection for T-GATING[InputPort-0]' else: assert T.input_ports[0].mod_afferents[0].name in \ 'GatingProjection for T-GATING[InputPort-0]' if OUT_CONTROL: assert T.output_ports[0].mod_afferents[0].name in \ 'ControlProjection for T-GATING[OutputPort-0]' else: assert T.output_ports[0].mod_afferents[0].name in \ 'GatingProjection for T-GATING[OutputPort-0]' # with pytest.raises(pnl.ProjectionError) as error_text: # T1 = pnl.ProcessingMechanism(name='T1', input_ports=[pnl.ControlMechanism()]) # assert 'Primary OutputPort of ControlMechanism-0 (ControlSignal-0) ' \ # 'cannot be used as a sender of a Projection to InputPort of T1' in error_text.value.args[0] # # with pytest.raises(pnl.ProjectionError) as error_text: # T2 = pnl.ProcessingMechanism(name='T2', output_ports=[pnl.ControlMechanism()]) # assert 'Primary OutputPort of ControlMechanism-1 (ControlSignal-0) ' \ # 'cannot be used as a sender of a Projection to OutputPort of T2' in error_text.value.args[0] 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 # KDM: this is a good candidate for pytest.parametrize 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_masked_mapping_projection_mask_conficts_with_matrix(self): with pytest.raises(pnl.MaskedMappingProjectionError) as error_text: t1 = pnl.TransferMechanism(size=2) t2 = pnl.TransferMechanism(size=2) pnl.MaskedMappingProjection(sender=t1, receiver=t2, mask=[[1, 2, 3], [4, 5, 6]], mask_operation=pnl.MULTIPLY) assert "Shape of the 'mask'" in str(error_text.value) assert "((2, 3)) must be the same as its 'matrix' ((2, 2))" in str( error_text.value) # FIX 7/22/15 [JDC] - REPLACE WITH MORE ELABORATE TESTS OF DUPLICATE PROJECTIONS: # SAME FROM OutputPort; SAME TO InputPort # TEST ERROR MESSAGES GENERATED BY VARIOUS _check_for_duplicates METHODS # def test_duplicate_projection_detection_and_warning(self): # # with pytest.warns(UserWarning) as record: # T1 = pnl.TransferMechanism(name='T1') # T2 = pnl.TransferMechanism(name='T2') # T3 = pnl.TransferMechanism(name='T3') # T4 = pnl.TransferMechanism(name='T4') # # MP1 = pnl.MappingProjection(sender=T1,receiver=T2,name='MP1') # MP2 = pnl.MappingProjection(sender=T1,receiver=T2,name='MP2') # pnl.proc(T1,MP1,T2,T3) # pnl.proc(T1,MP2,T2,T4) # # # hack to find a specific warning (other warnings may be generated by the Process construction) # correct_message_found = False # for warning in record: # if "that already has an identical Projection" in str(warning.message): # correct_message_found = True # break # # assert len(T2.afferents)==1 # assert correct_message_found def test_duplicate_projection_creation_error(self): from psyneulink.core.components.projections.projection import DuplicateProjectionError with pytest.raises(DuplicateProjectionError) as record: T1 = pnl.TransferMechanism(name='T1') T2 = pnl.TransferMechanism(name='T2') pnl.MappingProjection(sender=T1, receiver=T2, name='MP1') pnl.MappingProjection(sender=T1, receiver=T2, name='MP2') assert 'Attempt to assign Projection to InputPort-0 of T2 that already has an identical Projection.' \ in record.value.args[0]
task = pnl.LCAMechanism(name="TASK", size=2, initial_value=[0.5, 0.5]) task_color_wts = np.array([[4, 4], [0, 0]]) task_word_wts = np.array([[0, 0], [4, 4]]) task_color_pathway = [task_input, task, task_color_wts, color_hidden] task_word_pathway = [task_input, task, task_word_wts, word_hidden] # Construct the decision pathway: decision = pnl.DDM(name="DECISION", input_format=pnl.ARRAY) decision_pathway = [output, decision] # Construct control mechanism control = pnl.ControlMechanism( name="CONTROL", objective_mechanism=pnl.ObjectiveMechanism( name="Conflict Monitor", function=pnl.Energy(size=2, matrix=[[0, -2.5], [-2.5, 0]]), monitor=output, ), default_allocation=[0.5], control_signals=[(pnl.GAIN, task)], ) # Construct the Composition: Stroop_model = pnl.Composition(name="Stroop_model") Stroop_model.add_linear_processing_pathway(color_pathway) Stroop_model.add_linear_processing_pathway(word_pathway) Stroop_model.add_linear_processing_pathway(task_color_pathway) Stroop_model.add_linear_processing_pathway(task_word_pathway) Stroop_model.add_linear_processing_pathway(decision_pathway) Stroop_model.add_controller(control) # Assign conditions:
size=2, function=pnl.Logistic(gain=1), leak=.5, competition=2, noise=0, time_step_size=.1, termination_measure=pnl.TimeScale.TRIAL, termination_threshold=3, name='Task Activations [Act 1, Act 2]') # response = pnl.ProcessingMechanism() # Create controller csiController = pnl.ControlMechanism(monitor_for_control=cueInterval, control_signals=[ (pnl.TERMINATION_THRESHOLD, activation) ], modulation=pnl.OVERRIDE) comp = pnl.Composition( # controller_mode=pnl.BEFORE ) comp.add_linear_processing_pathway(pathway=[taskLayer, activation]) comp.add_node(cueInterval) comp.add_node(csiController) # csiController.control_signals[0].set_log_conditions([pnl.VALUE]) # comp.show_graph() cueInterval.set_log_conditions([pnl.VALUE]) activation.set_log_conditions([pnl.RESULT, 'mod_termination_threshold'])
e_v_FitzHughNagumo=-1.0, f_v_FitzHughNagumo=1.0, time_constant_v_FitzHughNagumo=tau_v, a_w_FitzHughNagumo=1.0, b_w_FitzHughNagumo=-1.0, c_w_FitzHughNagumo=0.0, threshold_FitzHughNagumo=a, time_constant_w_FitzHughNagumo=tau_u, mode_FitzHughNagumo=C, uncorrelated_activity_FitzHughNagumo=d, base_level_gain=G, scaling_factor_gain=k, name='LC-NE') updateC = pnl.ControlMechanism(objective_mechanism=pnl.ObjectiveMechanism( monitor_for_control=[action_selection.output_states[1], conflicts.output_state]), control_signals=[LC_NE.parameter_states[35]], name='C Update') update_process = pnl.Process(pathway=[LC_NE], name='UPDATE PROCESS') actions = ['left', 'right'] reward_values = np.array([1, 0]) first_reward = 0 action_selection.output_state.value = [0, 1] def reward(): print(reward_values, action_selection.output_state.value)