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_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_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]])
function=pnl.Linear(slope=0.3324)) 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]
Distractor_Rep.set_log_conditions( 'mod_slope') #, log_condition=pnl.PROCESSING) # Processing Mechanism (Automatic) Automatic_Component = pnl.TransferMechanism(name='Automatic Component') 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')
output_ports=[pnl.RESULT], name='Stimulus Info * Activity') 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])
color_input = pnl.ProcessingMechanism(name='Color', 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)
name="TASK", combination_function=pnl.LinearCombination(default_variable=[[0.0, 0.0]]), function=pnl.Logistic(default_variable=[[0.0, 0.0]]), 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]], )
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
from math import e return e**(.25 * np.abs(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, function=pnl.DriftDiffusionAnalytical(threshold=2.27, noise=0.4, t0=.4), output_ports=[ pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD, pnl.RESPONSE_TIME ]) # print("Task decision loggable: ", task_decision.loggable_items) task_decision.set_log_conditions('InputPort-0') # 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') control_signal_range = (0, 1)
Input = pnl.TransferMechanism(name='Input', ) Reward = pnl.TransferMechanism( output_ports=[pnl.RESULT, pnl.MEAN, pnl.VARIANCE], name='Reward') Decision = pnl.DDM( function=pnl.DriftDiffusionAnalytical(drift_rate=( 1.0, pnl.ControlProjection( function=pnl.Linear, control_signal_params={ pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3) }, ), ), threshold=( 1.0, pnl.ControlProjection( function=pnl.Linear, control_signal_params={ pnl.ALLOCATION_SAMPLES: np.arange( 0.1, 1.01, 0.3) }, ), ), noise=(0.5), starting_point=(0), t0=0.45), output_ports=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD ],
def test_stability_flexibility_susan_and_sebastian(self): # computeAccuracy(trialInformation) # Inputs: trialInformation[0, 1, 2, 3] # trialInformation[0] - Task Dimension : [0, 1] or [1, 0] # trialInformation[1] - Stimulus Dimension: Congruent {[1, 1] or [-1, -1]} // Incongruent {[-1, 1] or [1, -1]} # trialInformation[2] - Upper Threshold: Probability of DDM choosing upper bound # trialInformation[3] - Lower Threshold: Probability of DDM choosing lower bound def computeAccuracy(trialInformation): # Unload contents of trialInformation # Origin Node Inputs taskInputs = trialInformation[0] stimulusInputs = trialInformation[1] # DDM Outputs upperThreshold = trialInformation[2] lowerThreshold = trialInformation[3] # Keep Track of Accuracy accuracy = [] # Beginning of Accuracy Calculation colorTrial = (taskInputs[0] == 1) motionTrial = (taskInputs[1] == 1) # Based on the task dimension information, decide which response is "correct" # Obtain accuracy probability from DDM thresholds in "correct" direction if colorTrial: if stimulusInputs[0] == 1: accuracy.append(upperThreshold) elif stimulusInputs[0] == -1: accuracy.append(lowerThreshold) if motionTrial: if stimulusInputs[1] == 1: accuracy.append(upperThreshold) elif stimulusInputs[1] == -1: accuracy.append(lowerThreshold) # Accounts for initialization runs that have no variable input if len(accuracy) == 0: accuracy = [0] # print("Accuracy: ", accuracy[0]) # print() return [accuracy] # BEGIN: Composition Construction # Constants as defined in Musslick et al. 2018 tau = 0.9 # Time Constant DRIFT = 1 # Drift Rate STARTING_POINT = 0.0 # Starting Point THRESHOLD = 0.0475 # Threshold NOISE = 0.04 # Noise T0 = 0.2 # T0 # Task Layer: [Color, Motion] {0, 1} Mutually Exclusive # Origin Node taskLayer = pnl.TransferMechanism(default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=1, intercept=0), output_states=[pnl.RESULT], name='Task Input [I1, I2]') # Stimulus Layer: [Color Stimulus, Motion Stimulus] # Origin Node stimulusInfo = pnl.TransferMechanism(default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=1, intercept=0), output_states=[pnl.RESULT], name="Stimulus Input [S1, S2]") # Activation Layer: [Color Activation, Motion Activation] # Recurrent: Self Excitation, Mutual Inhibition # Controlled: Gain Parameter activation = pnl.RecurrentTransferMechanism( default_variable=[[0.0, 0.0]], function=pnl.Logistic(gain=1.0), matrix=[[1.0, -1.0], [-1.0, 1.0]], integrator_mode=True, integrator_function=pnl.AdaptiveIntegrator(rate=(tau)), initial_value=np.array([[0.0, 0.0]]), output_states=[pnl.RESULT], name='Task Activations [Act 1, Act 2]') # Hadamard product of Activation and Stimulus Information nonAutomaticComponent = pnl.TransferMechanism( default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=1, intercept=0), input_states=pnl.InputState(combine=pnl.PRODUCT), output_states=[pnl.RESULT], name='Non-Automatic Component [S1*Activity1, S2*Activity2]') # Summation of nonAutomatic and Automatic Components ddmCombination = pnl.TransferMechanism( size=1, function=pnl.Linear(slope=1, intercept=0), input_states=pnl.InputState(combine=pnl.SUM), output_states=[pnl.RESULT], name="Drift = (S1 + S2) + (S1*Activity1 + S2*Activity2)") decisionMaker = pnl.DDM(function=pnl.DriftDiffusionAnalytical( drift_rate=DRIFT, starting_point=STARTING_POINT, threshold=THRESHOLD, noise=NOISE, t0=T0), output_states=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD ], name='DDM') taskLayer.set_log_conditions([pnl.RESULT]) stimulusInfo.set_log_conditions([pnl.RESULT]) activation.set_log_conditions([pnl.RESULT, "mod_gain"]) nonAutomaticComponent.set_log_conditions([pnl.RESULT]) ddmCombination.set_log_conditions([pnl.RESULT]) decisionMaker.set_log_conditions([ pnl.PROBABILITY_UPPER_THRESHOLD, pnl.PROBABILITY_LOWER_THRESHOLD, pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME ]) # Composition Creation stabilityFlexibility = pnl.Composition(controller_mode=pnl.BEFORE) # Node Creation stabilityFlexibility.add_node(taskLayer) stabilityFlexibility.add_node(activation) stabilityFlexibility.add_node(nonAutomaticComponent) stabilityFlexibility.add_node(stimulusInfo) stabilityFlexibility.add_node(ddmCombination) stabilityFlexibility.add_node(decisionMaker) # Projection Creation stabilityFlexibility.add_projection(sender=taskLayer, receiver=activation) stabilityFlexibility.add_projection(sender=activation, receiver=nonAutomaticComponent) stabilityFlexibility.add_projection(sender=stimulusInfo, receiver=nonAutomaticComponent) stabilityFlexibility.add_projection(sender=stimulusInfo, receiver=ddmCombination) stabilityFlexibility.add_projection(sender=nonAutomaticComponent, receiver=ddmCombination) stabilityFlexibility.add_projection(sender=ddmCombination, receiver=decisionMaker) # Beginning of Controller # Grid Search Range searchRange = pnl.SampleSpec(start=1.0, stop=1.9, num=10) # Modulate the GAIN parameter from activation layer # Initalize cost function as 0 signal = pnl.ControlSignal( projections=[(pnl.GAIN, activation)], function=pnl.Linear, variable=1.0, intensity_cost_function=pnl.Linear(slope=0.0), allocation_samples=searchRange) # Use the computeAccuracy function to obtain selection values # Pass in 4 arguments whenever computeRewardRate is called objectiveMechanism = pnl.ObjectiveMechanism( monitor=[ taskLayer, stimulusInfo, (pnl.PROBABILITY_UPPER_THRESHOLD, decisionMaker), (pnl.PROBABILITY_LOWER_THRESHOLD, decisionMaker) ], function=computeAccuracy, name="Controller Objective Mechanism") # Sets trial history for simulations over specified signal search parameters metaController = pnl.OptimizationControlMechanism( agent_rep=stabilityFlexibility, features=[taskLayer.input_state, stimulusInfo.input_state], feature_function=pnl.Buffer(history=10), name="Controller", objective_mechanism=objectiveMechanism, function=pnl.GridSearch(), control_signals=[signal]) stabilityFlexibility.add_controller(metaController) stabilityFlexibility.enable_controller = True # stabilityFlexibility.model_based_optimizer_mode = pnl.BEFORE for i in range(1, len(stabilityFlexibility.controller.input_states)): stabilityFlexibility.controller.input_states[ i].function.reinitialize() # Origin Node Inputs taskTrain = [[1, 0], [0, 1], [1, 0], [0, 1]] stimulusTrain = [[1, -1], [-1, 1], [1, -1], [-1, 1]] inputs = {taskLayer: taskTrain, stimulusInfo: stimulusTrain} stabilityFlexibility.run(inputs)
def test_evc_gratton(self): # Stimulus Mechanisms target_stim = pnl.TransferMechanism(name='Target Stimulus', function=pnl.Linear(slope=0.3324)) 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_states=[ 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, flanker_automatic_pathway ] # Composition evc_gratton = pnl.Composition(name="EVCGratton") evc_gratton.add_node(Decision, required_roles=pnl.NodeRole.OUTPUT) for path in pathways: evc_gratton.add_linear_processing_pathway(path) evc_gratton.add_node(reward, required_roles=pnl.NodeRole.OUTPUT) # Control Signals signalSearchRange = pnl.SampleSpec(start=1.0, stop=1.8, step=0.2) target_rep_control_signal = pnl.ControlSignal( projections=[(pnl.SLOPE, Target_Rep)], function=pnl.Linear, variable=1.0, intensity_cost_function=pnl.Exponential(rate=0.8046), allocation_samples=signalSearchRange) flanker_rep_control_signal = pnl.ControlSignal( projections=[(pnl.SLOPE, Flanker_Rep)], function=pnl.Linear, variable=1.0, intensity_cost_function=pnl.Exponential(rate=0.8046), allocation_samples=signalSearchRange) objective_mech = pnl.ObjectiveMechanism( function=pnl.LinearCombination(operation=pnl.PRODUCT), monitor=[ reward, (Decision.output_states[pnl.PROBABILITY_UPPER_THRESHOLD], 1, -1) ]) # Model Based OCM (formerly controller) evc_gratton.add_controller(controller=pnl.OptimizationControlMechanism( agent_rep=evc_gratton, features=[ target_stim.input_state, flanker_stim.input_state, reward.input_state ], feature_function=pnl.AdaptiveIntegrator(rate=1.0), objective_mechanism=objective_mech, function=pnl.GridSearch(), control_signals=[ target_rep_control_signal, flanker_rep_control_signal ])) evc_gratton.enable_controller = True targetFeatures = [1, 1, 1] flankerFeatures = [1, -1, 1] rewardValues = [100, 100, 100] stim_list_dict = { target_stim: targetFeatures, flanker_stim: flankerFeatures, reward: rewardValues } evc_gratton.run(inputs=stim_list_dict) expected_results_array = [[[0.32257752863413636], [0.9481940753514433], [100.]], [[0.42963678062444666], [0.47661180945923376], [100.]], [[0.300291026852769], [0.97089165101931], [100.]]] expected_sim_results_array = [ [[0.32257753], [0.94819408], [100.]], [[0.31663196], [0.95508757], [100.]], [[0.31093566], [0.96110142], [100.]], [[0.30548947], [0.96633839], [100.]], [[0.30029103], [0.97089165], [100.]], [[0.3169957], [0.95468427], [100.]], [[0.31128378], [0.9607499], [100.]], [[0.30582202], [0.96603252], [100.]], [[0.30060824], [0.9706259], [100.]], [[0.29563774], [0.97461444], [100.]], [[0.31163288], [0.96039533], [100.]], [[0.30615555], [0.96572397], [100.]], [[0.30092641], [0.97035779], [100.]], [[0.2959409], [0.97438178], [100.]], [[0.29119255], [0.97787196], [100.]], [[0.30649004], [0.96541272], [100.]], [[0.30124552], [0.97008732], [100.]], [[0.29624499], [0.97414704], [100.]], [[0.29148205], [0.97766847], [100.]], [[0.28694892], [0.98071974], [100.]], [[0.30156558], [0.96981445], [100.]], [[0.29654999], [0.97391021], [100.]], [[0.29177245], [0.97746315], [100.]], [[0.28722523], [0.98054192], [100.]], [[0.28289958], [0.98320731], [100.]], [[0.42963678], [0.47661181], [100.]], [[0.42846471], [0.43938586], [100.]], [[0.42628176], [0.40282965], [100.]], [[0.42314468], [0.36732207], [100.]], [[0.41913221], [0.333198], [100.]], [[0.42978939], [0.51176048], [100.]], [[0.42959394], [0.47427693], [100.]], [[0.4283576], [0.43708106], [100.]], [[0.4261132], [0.40057958], [100.]], [[0.422919], [0.36514906], [100.]], [[0.42902209], [0.54679323], [100.]], [[0.42980788], [0.50942101], [100.]], [[0.42954704], [0.47194318], [100.]], [[0.42824656], [0.43477897], [100.]], [[0.42594094], [0.3983337], [100.]], [[0.42735293], [0.58136855], [100.]], [[0.42910149], [0.54447221], [100.]], [[0.42982229], [0.50708112], [100.]], [[0.42949608], [0.46961065], [100.]], [[0.42813159], [0.43247968], [100.]], [[0.42482049], [0.61516258], [100.]], [[0.42749136], [0.57908829], [100.]], [[0.42917687], [0.54214925], [100.]], [[0.42983261], [0.50474093], [100.]], [[0.42944107], [0.46727945], [100.]], [[0.32257753], [0.94819408], [100.]], [[0.31663196], [0.95508757], [100.]], [[0.31093566], [0.96110142], [100.]], [[0.30548947], [0.96633839], [100.]], [[0.30029103], [0.97089165], [100.]], [[0.3169957], [0.95468427], [100.]], [[0.31128378], [0.9607499], [100.]], [[0.30582202], [0.96603252], [100.]], [[0.30060824], [0.9706259], [100.]], [[0.29563774], [0.97461444], [100.]], [[0.31163288], [0.96039533], [100.]], [[0.30615555], [0.96572397], [100.]], [[0.30092641], [0.97035779], [100.]], [[0.2959409], [0.97438178], [100.]], [[0.29119255], [0.97787196], [100.]], [[0.30649004], [0.96541272], [100.]], [[0.30124552], [0.97008732], [100.]], [[0.29624499], [0.97414704], [100.]], [[0.29148205], [0.97766847], [100.]], [[0.28694892], [0.98071974], [100.]], [[0.30156558], [0.96981445], [100.]], [[0.29654999], [0.97391021], [100.]], [[0.29177245], [0.97746315], [100.]], [[0.28722523], [0.98054192], [100.]], [[0.28289958], [0.98320731], [100.]], ] for trial in range(len(evc_gratton.results)): assert np.allclose( expected_results_array[trial], # Note: Skip decision variable OutputState evc_gratton.results[trial][1:]) for simulation in range(len(evc_gratton.simulation_results)): assert np.allclose( expected_sim_results_array[simulation], # Note: Skip decision variable OutputState evc_gratton.simulation_results[simulation][1:])
def test_evc(self): # Mechanisms Input = pnl.TransferMechanism(name='Input') reward = pnl.TransferMechanism( output_states=[pnl.RESULT, pnl.OUTPUT_MEAN, pnl.OUTPUT_VARIANCE], name='reward') Decision = pnl.DDM(function=pnl.DriftDiffusionAnalytical( drift_rate=(1.0, pnl.ControlProjection(function=pnl.Linear, control_signal_params={ pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3) })), threshold=(1.0, pnl.ControlProjection(function=pnl.Linear, control_signal_params={ pnl.ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3) })), noise=0.5, starting_point=0, t0=0.45), output_states=[ pnl.DECISION_VARIABLE, pnl.RESPONSE_TIME, pnl.PROBABILITY_UPPER_THRESHOLD ], name='Decision') comp = pnl.Composition(name="evc") comp.add_node(reward, required_roles=[pnl.NodeRole.OUTPUT]) comp.add_node(Decision, required_roles=[pnl.NodeRole.OUTPUT]) task_execution_pathway = [Input, pnl.IDENTITY_MATRIX, Decision] comp.add_linear_processing_pathway(task_execution_pathway) comp.add_controller(controller=pnl.OptimizationControlMechanism( agent_rep=comp, features=[Input.input_state, reward.input_state], feature_function=pnl.AdaptiveIntegrator(rate=0.5), objective_mechanism=pnl.ObjectiveMechanism( function=pnl.LinearCombination(operation=pnl.PRODUCT), monitor=[ reward, Decision.output_states[ pnl.PROBABILITY_UPPER_THRESHOLD], (Decision.output_states[pnl.RESPONSE_TIME], -1, 1) ]), function=pnl.GridSearch(), control_signals=[("drift_rate", Decision), ("threshold", Decision)])) comp.enable_controller = True comp._analyze_graph() stim_list_dict = {Input: [0.5, 0.123], reward: [20, 20]} comp.run(inputs=stim_list_dict, retain_old_simulation_data=True) # Note: Removed decision variable OutputState from simulation results because sign is chosen randomly expected_sim_results_array = [[[10.], [10.0], [0.0], [0.48999867], [0.50499983]], [[10.], [10.0], [0.0], [1.08965888], [0.51998934]], [[10.], [10.0], [0.0], [2.40680493], [0.53494295]], [[10.], [10.0], [0.0], [4.43671978], [0.549834]], [[10.], [10.0], [0.0], [0.48997868], [0.51998934]], [[10.], [10.0], [0.0], [1.08459402], [0.57932425]], [[10.], [10.0], [0.0], [2.36033556], [0.63645254]], [[10.], [10.0], [0.0], [4.24948962], [0.68997448]], [[10.], [10.0], [0.0], [0.48993479], [0.53494295]], [[10.], [10.0], [0.0], [1.07378304], [0.63645254]], [[10.], [10.0], [0.0], [2.26686573], [0.72710822]], [[10.], [10.0], [0.0], [3.90353015], [0.80218389]], [[10.], [10.0], [0.0], [0.4898672], [0.549834]], [[10.], [10.0], [0.0], [1.05791834], [0.68997448]], [[10.], [10.0], [0.0], [2.14222978], [0.80218389]], [[10.], [10.0], [0.0], [3.49637662], [0.88079708]], [[15.], [15.0], [0.0], [0.48999926], [0.50372993]], [[15.], [15.0], [0.0], [1.08981011], [0.51491557]], [[15.], [15.0], [0.0], [2.40822035], [0.52608629]], [[15.], [15.0], [0.0], [4.44259627], [0.53723096]], [[15.], [15.0], [0.0], [0.48998813], [0.51491557]], [[15.], [15.0], [0.0], [1.0869779], [0.55939819]], [[15.], [15.0], [0.0], [2.38198336], [0.60294711]], [[15.], [15.0], [0.0], [4.33535807], [0.64492386]], [[15.], [15.0], [0.0], [0.48996368], [0.52608629]], [[15.], [15.0], [0.0], [1.08085171], [0.60294711]], [[15.], [15.0], [0.0], [2.32712843], [0.67504223]], [[15.], [15.0], [0.0], [4.1221271], [0.7396981]], [[15.], [15.0], [0.0], [0.48992596], [0.53723096]], [[15.], [15.0], [0.0], [1.07165729], [0.64492386]], [[15.], [15.0], [0.0], [2.24934228], [0.7396981]], [[15.], [15.0], [0.0], [3.84279648], [0.81637827]]] for simulation in range(len(expected_sim_results_array)): assert np.allclose( expected_sim_results_array[simulation], # Note: Skip decision variable OutputState comp.simulation_results[simulation][0:3] + comp.simulation_results[simulation][4:6]) expected_results_array = [[[20.0], [20.0], [0.0], [1.0], [2.378055160151634], [0.9820137900379085]], [[20.0], [20.0], [0.0], [0.1], [0.48999967725112503], [0.5024599801509442]]] for trial in range(len(expected_results_array)): np.testing.assert_allclose( comp.results[trial], expected_results_array[trial], atol=1e-08, err_msg='Failed on expected_output[{0}]'.format(trial))
def runStabilityFlexibility(tasks, stimuli, gain): integrationConstant = 0.8 # time constant DRIFT = 0.25 # Drift Rate STARTING_POINT = 0.0 # Starting Point THRESHOLD = 0.05 # Threshold NOISE = 0.1 # Noise T0 = 0.2 # T0 wa = 0.2 g = gain # first element is color task attendance, second element is motion task attendance inputLayer = pnl.TransferMechanism( #default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=1, intercept=0), output_states=[pnl.RESULT], name='Input') inputLayer.set_log_conditions([pnl.RESULT]) # Recurrent Transfer Mechanism that models the recurrence in the activation between the two stimulus and action # dimensions. Positive self excitation and negative opposite inhibition with an integrator rate = tau # Modulated variable in simulations is the GAIN variable of this mechanism activation = pnl.RecurrentTransferMechanism( default_variable=[[0.0, 0.0]], function=pnl.Logistic(gain=g), matrix=[[1.0, -1.0], [-1.0, 1.0]], integrator_mode=True, integrator_function=pnl.AdaptiveIntegrator(rate=integrationConstant), initial_value=np.array([[0.0, 0.0]]), output_states=[pnl.RESULT], name='Activity') activation.set_log_conditions([pnl.RESULT, "mod_gain"]) stimulusInfo = pnl.TransferMechanism(default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=1, intercept=0), output_states=[pnl.RESULT], name="Stimulus Info") stimulusInfo.set_log_conditions([pnl.RESULT]) congruenceWeighting = pnl.TransferMechanism( default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=wa, intercept=0), name='Congruence * Automatic Component') controlledElement = pnl.TransferMechanism( default_variable=[[0.0, 0.0]], size=2, function=pnl.Linear(slope=1, intercept=0), input_states=pnl.InputState(combine=pnl.PRODUCT), output_states=[pnl.RESULT], name='Stimulus Info * Activity') controlledElement.set_log_conditions([pnl.RESULT]) ddmCombination = pnl.TransferMechanism(size=1, function=pnl.Linear(slope=1, intercept=0), output_states=[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_states=[ 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 ]) ########### Composition stabilityFlexibility = pnl.Composition() ### NODE CREATION stabilityFlexibility.add_node(inputLayer) stabilityFlexibility.add_node(activation) stabilityFlexibility.add_node(congruenceWeighting) stabilityFlexibility.add_node(controlledElement) stabilityFlexibility.add_node(stimulusInfo) stabilityFlexibility.add_node(ddmCombination) stabilityFlexibility.add_node(decisionMaker) stabilityFlexibility.add_projection(sender=inputLayer, receiver=activation) stabilityFlexibility.add_projection(sender=activation, receiver=controlledElement) stabilityFlexibility.add_projection(sender=stimulusInfo, receiver=congruenceWeighting) stabilityFlexibility.add_projection(sender=stimulusInfo, receiver=controlledElement) stabilityFlexibility.add_projection(sender=congruenceWeighting, receiver=ddmCombination) stabilityFlexibility.add_projection(sender=controlledElement, receiver=ddmCombination) stabilityFlexibility.add_projection(sender=ddmCombination, receiver=decisionMaker) runs = len(tasks) inputs = {inputLayer: tasks, stimulusInfo: stimuli} stabilityFlexibility.run(inputs) decisions = decisionMaker.log.nparray() upper, lower = extractValues(decisions) modelResults = [tasks, stimuli, upper, lower] accuracies = computeAccuracy(modelResults) activations = activation.log.nparray() activity1 = [] activity2 = [] for i in range(0, runs): activity1.append(activations[1][1][4][i + 1][0]) activity2.append(activations[1][1][4][i + 1][1]) return accuracies, activity1, activity2
def test_rl_learning_enabled_false(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]]) # Pause learning -- values are the same as the previous trial (because we pass in the same inputs) comp.learning_enabled = False inputs_dict = {input_layer: [[1., 1.], [1., 1.]]} 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]]) # Resume learning comp.learning_enabled = True inputs_dict = { input_layer: [[1., 1.], [1., 1.]], target_mechanism: [[10.], [10.]] } comp.run(inputs=inputs_dict) assert np.allclose( learning_mechanism.value, [np.array([0.38581875, 0.]), np.array([0.38581875, 0.])]) assert np.allclose(action_selection.value, [[1.], [0.978989672], [0.99996], [0.0000346908466], [0.978989672], \ [0.118109771], [1.32123733], [0.978989672], [0.118109771], [1.32123733]])