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_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_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_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_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_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_reinforcement_fixed_targets(): input_layer = TransferMechanism( size=2, name='Input Layer', ) action_selection = pnl.DDM(input_format=pnl.ARRAY, function=pnl.DriftDiffusionAnalytical(), output_states=[pnl.SELECTED_INPUT_ARRAY], name='DDM') p = Process(pathway=[input_layer, action_selection], learning=LearningProjection(learning_function=Reinforcement( learning_rate=0.05))) input_list = {input_layer: [[1, 1], [1, 1]]} s = System(processes=[p], # learning_rate=0.05, ) targets = [[10.], [10.]] # logged_mechanisms = [input_layer, action_selection] # for mech in s.learning_mechanisms: # logged_mechanisms.append(mech) # # for mech in logged_mechanisms: # mech.log.set_log_conditions(items=[pnl.VALUE]) results = s.run(inputs=input_list, targets=targets) assert np.allclose(action_selection.value, [[1.], [2.30401336], [0.97340301], [0.02659699], [2.30401336], \ [2.08614798], [1.85006765], [2.30401336], [2.08614798], [1.85006765]])
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_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_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_gating_signal_to_output_states(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_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_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_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_DDM_in_composition(benchmark, mode): M = pnl.DDM( name='DDM', function=pnl.DriftDiffusionIntegrator( rate=1, noise=0.0, offset=0.0, starting_point=0.0, time_step_size=0.1, ), ) C = pnl.Composition() C.add_linear_processing_pathway([M]) inputs = {M: [10]} val = C.run(inputs, num_trials=2, bin_execute=mode) # FIXME: Python version returns dtype=object val = np.asfarray(val) assert np.allclose(val[0], [2.0]) assert np.allclose(val[1], [0.2]) if benchmark.enabled: benchmark(C.run, inputs, num_trials=2, bin_execute=mode)
def test_rl(self): input_layer = pnl.TransferMechanism(size=2, name='Input Layer') input_layer.log.set_log_conditions(items=pnl.VALUE) action_selection = pnl.DDM(input_format=pnl.ARRAY, function=pnl.DriftDiffusionAnalytical(), output_states=[pnl.SELECTED_INPUT_ARRAY], name='DDM') action_selection.log.set_log_conditions(items=pnl.SELECTED_INPUT_ARRAY) comp = pnl.Composition(name='comp') learning_components = comp.add_reinforcement_learning_pathway( pathway=[input_layer, action_selection], learning_rate=0.05) learned_projection = learning_components[pnl.LEARNED_PROJECTION] learning_mechanism = learning_components[pnl.LEARNING_MECHANISM] target_mechanism = learning_components[pnl.TARGET_MECHANISM] comparator_mechanism = learning_components[pnl.COMPARATOR_MECHANISM] learned_projection.log.set_log_conditions( items=["matrix", "mod_matrix"]) inputs_dict = { input_layer: [[1., 1.], [1., 1.]], target_mechanism: [[10.], [10.]] } learning_mechanism.log.set_log_conditions(items=[pnl.VALUE]) comparator_mechanism.log.set_log_conditions(items=[pnl.VALUE]) target_mechanism.log.set_log_conditions(items=pnl.VALUE) comp.run(inputs=inputs_dict) assert np.allclose(learning_mechanism.value, [np.array([0.4275, 0.]), np.array([0.4275, 0.])]) assert np.allclose(action_selection.value, [[1.], [2.30401336], [0.97340301], [0.02659699], [2.30401336], \ [2.08614798], [1.85006765], [2.30401336], [2.08614798], [1.85006765]])
Distactor_Component = pnl.TransferMechanism(name='Distactor Component') Automatic_Component.set_log_conditions( 'value') #, log_condition=pnl.PROCESSING) # Decision Mechanisms Decision = pnl.DDM( function=pnl.DriftDiffusionAnalytical( # drift_rate=(0.1170), threshold=(thresh), noise=(c), starting_point=(x_0), t0=t0), name='Decision', output_ports=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, { pnl.NAME: 'OFFSET RT', pnl.VARIABLE: (pnl.OWNER_VALUE, 2), pnl.FUNCTION: pnl.Linear(0, slope=1.0, intercept=1) } ], ) #drift_rate=(1.0),threshold=(0.2645),noise=(0.5),starting_point=(0), t0=0.15 Decision.set_log_conditions('InputPort-0') #, log_condition=pnl.PROCESSING) Decision.set_log_conditions('PROBABILITY_UPPER_THRESHOLD') print(Decision.loggable_items) # Outcome Mechanisms: Reward = pnl.TransferMechanism(name='Reward')
NormalDist(mean=0, standard_deviation=unit_noise).function, integration_rate=processing_rate, name='WORDS HIDDEN') # OUTPUT LAYER r = pnl.TransferMechanism( size=2, function=psyneulink.core.components.functions.transferfunctions.Logistic, integrator_mode=False, noise=psyneulink.core.components.functions.distributionfunctions. NormalDist(mean=0, standard_deviation=unit_noise).function, integration_rate=processing_rate, name='RESPONSE') # DECISION LAYER d = pnl.DDM(input_format=pnl.ARRAY) l = pnl.LCAMechanism(size=2) # LOGGING ch.set_log_conditions('value') wh.set_log_conditions('value') r.set_log_conditions('value') # PROJECTIONS c_ih = pnl.MappingProjection(matrix=[[2.2, -2.2], [-2.2, 2.2]], name='COLOR INPUT TO HIDDEN') w_ih = pnl.MappingProjection(matrix=[[2.6, -2.6], [-2.6, 2.6]], name='WORD INPUT TO HIDDEN') c_hr = pnl.MappingProjection(matrix=[[1.3, -1.3], [-1.3, 1.3]], name='COLOR HIDDEN TO OUTPUT') w_hr = pnl.MappingProjection(matrix=[[2.5, -2.5], [-2.5, 2.5]],
# Processing Mechanism (Automatic) Automatic_Component = pnl.TransferMechanism(name='Automatic Component', function=pnl.Linear(slope=(1.0)), prefs=mechanism_prefs) # Decision Mechanisms Decision = pnl.DDM( function=pnl.BogaczEtAl(drift_rate=(1.0), threshold=(0.2645), noise=(0.5), starting_point=(0), t0=0.15), prefs=mechanism_prefs, name='Decision', output_states=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, { pnl.NAME: 'OFFSET RT', pnl.VARIABLE: (pnl.OWNER_VALUE, 2), pnl.FUNCTION: pnl.Linear(0, slope=0.3, intercept=1) } ], ) # Outcome Mechanisms: Reward = pnl.TransferMechanism(name='Reward') # Processes: TargetControlProcess = pnl.Process(default_variable=[0], pathway=[Target_Stim, Target_Rep, Decision],
return prob_upper * reward_upper + prob_lower * reward_lower # return np.sum(v[0] * v[1]) color_stim = pnl.TransferMechanism(name='Color Stimulus', size=8) word_stim = pnl.TransferMechanism(name='Word Stimulus', size=8) color_task = pnl.TransferMechanism(name='Color Task') word_task = pnl.ProcessingMechanism(name='Word Task', function=w_fct_UDF) reward = pnl.TransferMechanism(name='Reward', size=2) task_decision = pnl.DDM( name='Task Decision', # function=pnl.NavarroAndFuss, output_states=[ pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD, pnl.DDM_OUTPUT.PROBABILITY_LOWER_THRESHOLD ]) task_decision.set_log_conditions('func_drift_rate') task_decision.set_log_conditions('mod_drift_rate') task_decision.set_log_conditions('PROBABILITY_LOWER_THRESHOLD') task_decision.set_log_conditions('PROBABILITY_UPPER_THRESHOLD') color_task.set_log_conditions('value') word_task.set_log_conditions('value') c = pnl.Composition(name='Stroop XOR Model') c.add_node(color_stim) c.add_node(word_stim) c.add_node(color_task, required_roles=pnl.NodeRole.ORIGIN)
def get_stroop_model(unit_noise_std=.01, dec_noise_std=.1): # model params integration_rate = 1 hidden_func = pnl.Logistic(gain=1.0, x_0=4.0) # input layer, color and word reward = pnl.TransferMechanism(name='reward') punish = pnl.TransferMechanism(name='punish') inp_clr = pnl.TransferMechanism( size=N_UNITS, function=pnl.Linear, name='COLOR INPUT' ) inp_wrd = pnl.TransferMechanism( size=N_UNITS, function=pnl.Linear, name='WORD INPUT' ) # task layer, represent the task instruction; color naming / word reading inp_task = pnl.TransferMechanism( size=N_UNITS, function=pnl.Linear, name='TASK' ) # hidden layer for color and word hid_clr = pnl.TransferMechanism( size=N_UNITS, function=hidden_func, integrator_mode=True, integration_rate=integration_rate, # noise=pnl.NormalDist(standard_deviation=unit_noise_std).function, noise=pnl.NormalDist(standard_deviation=unit_noise_std), name='COLORS HIDDEN' ) hid_wrd = pnl.TransferMechanism( size=N_UNITS, function=hidden_func, integrator_mode=True, integration_rate=integration_rate, # noise=pnl.NormalDist(standard_deviation=unit_noise_std).function, noise=pnl.NormalDist(standard_deviation=unit_noise_std), name='WORDS HIDDEN' ) # output layer output = pnl.TransferMechanism( size=N_UNITS, function=pnl.Logistic, integrator_mode=True, integration_rate=integration_rate, # noise=pnl.NormalDist(standard_deviation=unit_noise_std).function, noise=pnl.NormalDist(standard_deviation=unit_noise_std), name='OUTPUT' ) # decision layer, some accumulator signalSearchRange = pnl.SampleSpec(start=0.05, stop=5, step=0.05) decision = pnl.DDM(name='Decision', input_format=pnl.ARRAY, function=pnl.DriftDiffusionAnalytical(drift_rate=1, threshold =1, noise=1, starting_point=0, t0=0.35), output_ports=[pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD] ) driftrate_control_signal = pnl.ControlSignal(projections=[(pnl.SLOPE, inp_clr)], variable=1.0, intensity_cost_function=pnl.Exponential(rate=1),#pnl.Exponential(rate=0.8),#pnl.Exponential(rate=1), allocation_samples=signalSearchRange) threshold_control_signal = pnl.ControlSignal(projections=[(pnl.THRESHOLD, decision)], variable=1.0, intensity_cost_function=pnl.Linear(slope=0), allocation_samples=signalSearchRange) reward_rate = pnl.ObjectiveMechanism(function=pnl.LinearCombination(operation=pnl.PRODUCT, exponents=[[1],[1],[-1]]), monitor=[reward, decision.output_ports[pnl.PROBABILITY_UPPER_THRESHOLD], decision.output_ports[pnl.RESPONSE_TIME]]) punish_rate = pnl.ObjectiveMechanism(function=pnl.LinearCombination(operation=pnl.PRODUCT, exponents=[[1],[1],[-1]]), monitor=[punish, decision.output_ports[pnl.PROBABILITY_LOWER_THRESHOLD], decision.output_ports[pnl.RESPONSE_TIME]]) objective_mech = pnl.ObjectiveMechanism(function=pnl.LinearCombination(operation=pnl.SUM, weights=[[1],[-1]]), monitor=[reward_rate, punish_rate]) # objective_mech = pnl.ObjectiveMechanism(function=object_function, # monitor=[reward, # punish, # decision.output_ports[pnl.PROBABILITY_UPPER_THRESHOLD], # decision.output_ports[pnl.PROBABILITY_LOWER_THRESHOLD], # (decision.output_ports[pnl.RESPONSE_TIME])]) # PROJECTIONS, weights copied from cohen et al (1990) wts_clr_ih = pnl.MappingProjection( matrix=[[2.2, -2.2], [-2.2, 2.2]], name='COLOR INPUT TO HIDDEN') wts_wrd_ih = pnl.MappingProjection( matrix=[[2.6, -2.6], [-2.6, 2.6]], name='WORD INPUT TO HIDDEN') wts_clr_ho = pnl.MappingProjection( matrix=[[1.3, -1.3], [-1.3, 1.3]], name='COLOR HIDDEN TO OUTPUT') wts_wrd_ho = pnl.MappingProjection( matrix=[[2.5, -2.5], [-2.5, 2.5]], name='WORD HIDDEN TO OUTPUT') wts_tc = pnl.MappingProjection( matrix=[[4.0, 4.0], [0, 0]], name='COLOR NAMING') wts_tw = pnl.MappingProjection( matrix=[[0, 0], [4.0, 4.0]], name='WORD READING') # build the model model = pnl.Composition(name='STROOP model') model.add_node(decision, required_roles=pnl.NodeRole.OUTPUT) model.add_node(reward, required_roles=pnl.NodeRole.OUTPUT) model.add_node(punish, required_roles=pnl.NodeRole.OUTPUT) model.add_linear_processing_pathway([inp_clr, wts_clr_ih, hid_clr]) model.add_linear_processing_pathway([inp_wrd, wts_wrd_ih, hid_wrd]) model.add_linear_processing_pathway([hid_clr, wts_clr_ho, output]) model.add_linear_processing_pathway([hid_wrd, wts_wrd_ho, output]) model.add_linear_processing_pathway([inp_task, wts_tc, hid_clr]) model.add_linear_processing_pathway([inp_task, wts_tw, hid_wrd]) model.add_linear_processing_pathway([output, pnl.IDENTITY_MATRIX, decision]) # 3/15/20 # model.add_linear_processing_pathway([output, [[1,-1]], (decision, pnl.NodeRole.OUTPUT)]) # 3/15/20 # model.add_linear_processing_pathway([output, [[1],[-1]], decision]) # 3/15/20 model.add_nodes([reward_rate, punish_rate]) controller = pnl.OptimizationControlMechanism(agent_rep=model, features=[inp_clr.input_port, inp_wrd.input_port, inp_task.input_port, reward.input_port, punish.input_port], feature_function=pnl.AdaptiveIntegrator(rate=0.1), objective_mechanism=objective_mech, function=pnl.GridSearch(), control_signals=[driftrate_control_signal, threshold_control_signal]) model.add_controller(controller=controller) # collect the node handles nodes = [inp_clr, inp_wrd, inp_task, hid_clr, hid_wrd, output, decision, reward, punish,controller] metadata = [integration_rate, dec_noise_std, unit_noise_std] return model, nodes, metadata
flanker_stim = pnl.TransferMechanism(name='Flanker Stimulus', function=pnl.Linear(slope=0.3545221843)) # Processing Mechanisms (Control) Target_Rep = pnl.TransferMechanism(name='Target Representation') Flanker_Rep = pnl.TransferMechanism(name='Flanker Representation') # Processing Mechanism (Automatic) Automatic_Component = pnl.TransferMechanism(name='Automatic Component') # Decision Mechanism Decision = pnl.DDM(name='Decision', function=pnl.DriftDiffusionAnalytical(drift_rate=(1.0), threshold=(0.2645), noise=(0.5), starting_point=(0), t0=0.15), output_ports=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD ]) # Outcome Mechanism reward = pnl.TransferMechanism(name='reward') # Pathways target_control_pathway = [target_stim, Target_Rep, Decision] flanker_control_pathway = [flanker_stim, Flanker_Rep, Decision] target_automatic_pathway = [target_stim, Automatic_Component, Decision] flanker_automatic_pathway = [flanker_stim, Automatic_Component, Decision] pathways = [ target_control_pathway, flanker_control_pathway, target_automatic_pathway,
function=psyneulink.core.components.functions.transferfunctions.Linear( slope=(1.0)), prefs=mechanism_prefs) # Decision Mechanisms Decision = pnl.DDM( function=psyneulink.core.components.functions.distributionfunctions. DriftDiffusionAnalytical(drift_rate=(1.0), threshold=(0.2645), noise=(0.5), starting_point=(0), t0=0.15), prefs=mechanism_prefs, name='Decision', output_ports=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, { pnl.NAME: 'OFFSET RT', pnl.VARIABLE: (pnl.OWNER_VALUE, 2), pnl.FUNCTION: psyneulink.core.components.functions.transferfunctions.Linear( 0, slope=0.3, intercept=1) } ], ) # Outcome Mechanisms: Reward = pnl.TransferMechanism(name='Reward') # Processes:
integrator_function=pnl.LeakyCompetingIntegrator( name="LeakyCompetingIntegrator_Function_0", initializer=[[0.5, 0.5]], rate=0.5, default_variable=[[0.0, 0.0]], ), output_ports=["RESULTS"], termination_comparison_op=">=", default_variable=[[0.0, 0.0]], ) DECISION = pnl.DDM( name="DECISION", function=pnl.DriftDiffusionAnalytical(default_variable=[[0.0]]), input_ports=[{ pnl.NAME: pnl.ARRAY, pnl.VARIABLE: [[0.0, 0.0]], pnl.FUNCTION: pnl.Reduce(default_variable=[[0.0, 0.0]], weights=[1, -1]), }], ) 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",
function=pnl.Linear(slope=optimal_color_control)) motion_input = pnl.ProcessingMechanism(name='Motion', function=pnl.Linear(slope=optimal_motion_control)) # decision = pnl.DDM(name='Decision', # function= pnl.DriftDiffusionAnalytical( # starting_point=0, # noise=0.5, # t0=0.2, # threshold=0.45), # output_states=[pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD, pnl.DDM_OUTPUT.RESPONSE_TIME], this seems to have been removed. # ) decision = pnl.DDM( function=pnl.DriftDiffusionAnalytical( starting_point=0, noise=0.5, t0=0.2, threshold=0.45 ), name='Decision' ) c = pnl.Composition(name='ColorMotion Task') c.add_linear_processing_pathway([color_input, decision]) c.add_linear_processing_pathway([motion_input, decision]) # c.show_graph(show_node_structure=ALL) stimuli = {color_input: colorInputSequence, motion_input: motionInputSequence} c.run(inputs=stimuli)
input_layer = pnl.TransferMechanism(size=2, name='Input Layer') # Takes sum of input layer elements as external component of drift rate # Notes: # - drift_rate parameter in constructor for DDM is the "internally modulated" component of the drift_rate; # - arguments to DDM's function (DriftDiffusionAnalytical) are specified as CONTROL, so their values are determined # by the OptimizationControlMechanism of the Composition to which the action_selection Mechanism is assigned # - the input_format argument specifies that the input to the DDM should be one-hot encoded two-element array # - the output_ports argument specifies use of the DECISION_VARIABLE_ARRAY OutputPort, which encodes the # response in the same format as the ARRAY input_format/. action_selection = pnl.DDM( input_format=pnl.ARRAY, function=psyneulink.core.components.functions.nonstateful. distributionfunctions.DriftDiffusionAnalytical( drift_rate=pnl.CONTROL, threshold=pnl.CONTROL, starting_point=pnl.CONTROL, noise=pnl.CONTROL, ), output_ports=[pnl.SELECTED_INPUT_ARRAY], name='DDM') # Construct Process # Notes: # The np.array specifies the matrix used as the Mapping Projection from input_layer to action_selection, # which insures the left element of the input favors the left action (positive value of DDM decision variable), # and the right element favors the right action (negative value of DDM decision variable) # The learning argument specifies Reinforcement as the learning function for the Projection comp = pnl.Composition() p = comp.add_reinforcement_learning_pathway(
import psyneulink.core.components.functions.nonstateful.transferfunctions myInputLayer = pnl.TransferMechanism( name='Input Layer', function=psyneulink.core.components.functions.nonstateful. transferfunctions.Linear(), default_variable=[0, 0]) myHiddenLayer = pnl.TransferMechanism( name='Hidden Layer 1', function=psyneulink.core.components.functions.nonstateful. transferfunctions.Logistic(gain=1.0, x_0=0), default_variable=np.zeros((5, ))) myDDM = pnl.DDM(name='My_DDM', function=psyneulink.core.components.functions.nonstateful. distributionfunctions.DriftDiffusionAnalytical( drift_rate=0.5, threshold=1, starting_point=0.0)) comp = pnl.Composition(name='Neural Network DDM Process', pathways=[[ myInputLayer, pnl.get_matrix(pnl.RANDOM_CONNECTIVITY_MATRIX, 2, 5), myHiddenLayer, pnl.FULL_CONNECTIVITY_MATRIX, myDDM ]]) comp.reportOutputPref = True myInputLayer.reportOutputPref = True myHiddenLayer.reportOutputPref = True myDDM.reportOutputPref = pnl.PreferenceEntry(True, pnl.PreferenceLevel.INSTANCE)
controlledElement.set_log_conditions([pnl.RESULT]) ddmCombination = pnl.TransferMechanism(size=1, function=pnl.Linear(slope=1, intercept=0), output_ports=[pnl.RESULT], name="DDM Integrator") ddmCombination.set_log_conditions([pnl.RESULT]) decisionMaker = pnl.DDM( function=pnl.DriftDiffusionAnalytical(drift_rate=DRIFT, starting_point=STARTING_POINT, threshold=THRESHOLD, noise=NOISE, t0=T0), output_ports=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD ], name='DDM') decisionMaker.set_log_conditions([ pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD, pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME ]) # decisionMaker.set_log_conditions([pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD]) ########### Composition
# Processing Mechanism (Automatic) Automatic_Component = pnl.TransferMechanism(name='Automatic Component', function=pnl.Linear) Automatic_Component.loggable_items Automatic_Component.set_log_conditions('value') # Decision Mechanisms Decision = pnl.DDM( function=pnl.BogaczEtAl( drift_rate=(0.5), threshold=(1.0), # noise=(0.8), starting_point=(0), t0=0.15), name='Decision', output_states=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, { pnl.NAME: 'OFFSET RT', pnl.INDEX: 2, pnl.ASSIGN: pnl.Linear(0, slope=1.0, intercept=1).function } ], ) #drift_rate=(1.0),threshold=(0.2645),noise=(0.5),starting_point=(0), t0=0.15 Decision.set_log_conditions('DECISION_VARIABLE') Decision.set_log_conditions('value') Decision.set_log_conditions('PROBABILITY_UPPER_THRESHOLD') Decision.set_log_conditions('InputState-0') Decision.loggable_items