def test_clear_log(self):
# Create System
T_1 = pnl.TransferMechanism(name='log_test_T_1', size=2)
T_2 = pnl.TransferMechanism(name='log_test_T_2', size=2)
PS = pnl.Process(name='log_test_PS', pathway=[T_1, T_2])
PJ = T_2.path_afferents[0]
SYS = pnl.System(name="log_test_SYS", processes=[PS])
# Set log conditions on each component
T_1.set_log_conditions(pnl.NOISE)
T_1.set_log_conditions(pnl.RESULTS)
T_2.set_log_conditions(pnl.SLOPE)
T_2.set_log_conditions(pnl.RESULTS)
PJ.set_log_conditions(pnl.MATRIX)
# Run system
SYS.run(inputs={T_1: [1.0, 1.0]})
# Create log dict for each component
log_dict_T_1 = T_1.log.nparray_dictionary()
log_dict_T_2 = T_2.log.nparray_dictionary()
log_dict_PJ = PJ.log.nparray_dictionary()
# Confirm that values were logged correctly
assert np.allclose(log_dict_T_1['RESULTS'], np.array([[1.0, 1.0]])) and \
np.allclose(log_dict_T_1['noise'], np.array([[0.0]]))
assert np.allclose(log_dict_T_2['RESULTS'], np.array([[1.0, 1.0]])) and \
np.allclose(log_dict_T_2['slope'], np.array([[1.0]]))
assert np.allclose(log_dict_PJ['matrix'],
np.array([[1.0, 0.0], [0.0, 1.0]]))
# Clear T_1s log and delete entries
T_1.log.clear_entries(delete_entry=False)
# Clear T_2s log and DO NOT delete entries
T_2.log.clear_entries(delete_entry=True)
# Create new log dict for each component
log_dict_T_1 = T_1.log.nparray_dictionary()
log_dict_T_2 = T_2.log.nparray_dictionary()
log_dict_PJ = PJ.log.nparray_dictionary()
# Confirm that T_1 log values were removed
assert np.allclose(log_dict_T_1['RESULTS'], np.array([])) and \
np.allclose(log_dict_T_1['noise'], np.array([]))
# Confirm that T_2 log values were removed and dictionary entries were destroyed
assert log_dict_T_2 == OrderedDict()
# Confirm that PJ log values were not affected by changes to T_1 and T_2's logs
assert np.allclose(log_dict_PJ['matrix'],
np.array([[1.0, 0.0], [0.0, 1.0]]))
# Run system again
SYS.run(inputs={T_1: [2.0, 2.0]})
# Create new log dict for each component
log_dict_T_1 = T_1.log.nparray_dictionary()
log_dict_T_2 = T_2.log.nparray_dictionary()
log_dict_PJ = PJ.log.nparray_dictionary()
# Confirm that T_1 log values only include most recent run
assert np.allclose(log_dict_T_1['RESULTS'], np.array([[2.0, 2.0]])) and \
np.allclose(log_dict_T_1['noise'], np.array([[0.0]]))
# NOTE: "Run" value still incremented, but only the most recent one is returned (# runs does not reset to zero)
assert np.allclose(log_dict_T_1['Run'], np.array([[1]]))
# Confirm that T_2 log values only include most recent run
assert np.allclose(log_dict_T_2['RESULTS'], np.array([[2.0, 2.0]])) and \
np.allclose(log_dict_T_2['slope'], np.array([[1.0]]))
assert np.allclose(log_dict_T_2['Run'], np.array([[1]]))
# Confirm that PJ log values include all runs
assert np.allclose(log_dict_PJ['matrix'], np.array([[[1.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]]])) and \
np.allclose(log_dict_PJ['Run'], np.array([[0], [1]]))
RewardProcess = pnl.Process(default_variable=[0],
pathway=[Reward, test_mech],
name='RewardProcess')
# System:
mySystem = pnl.System(
processes=[
TargetControlProcess, FlankerControlProcess, TargetAutomaticProcess,
FlankerAutomaticProcess, RewardProcess
],
controller=pnl.EVCControlMechanism(
prefs={
pnl.LOG_PREF:
pnl.PreferenceEntry(pnl.LogCondition.INITIALIZATION,
pnl.PreferenceLevel.INSTANCE)
}),
enable_controller=True,
monitor_for_control=[
# (None, None, np.ones((1,1))),
Reward,
Decision.PROBABILITY_UPPER_THRESHOLD,
('OFFSET_RT', 1, -1),
],
name='EVC Markus System')
# Show characteristics of system:
mySystem.show()
# mySystem.controller.show()
# Show graph of system
name='WORDS_RESPONSE_PROCESS')
task_color_response_process = pnl.Process(pathway=[
task_input_layer, task_input_weights, task_layer, task_color_weights,
colors_hidden_layer, color_task_weights, task_layer
])
task_word_response_process = pnl.Process(pathway=[
task_input_layer, task_layer, task_word_weights, words_hidden_layer,
word_task_weights, task_layer
])
# Create system -------------------------------------------------------------------------------------------------------
Bidirectional_Stroop = pnl.System(processes=[
color_response_process, word_response_process, task_color_response_process,
task_word_response_process
],
reinitialize_mechanisms_when=pnl.Never(),
name='FEEDFORWARD_STROOP_SYSTEM')
# LOGGING:
colors_hidden_layer.set_log_conditions('value')
words_hidden_layer.set_log_conditions('value')
Bidirectional_Stroop.show()
# Bidirectional_Stroop.show_graph(show_dimensions=pnl.ALL)#,show_mechanism_structure=pnl.VALUES) # Uncomment to show graph of the system
# Create threshold function -------------------------------------------------------------------------------------------
# execution_context is automatically passed into Conditions, and references the execution context in which they are being run,
# which in this case is simply the Bidirectional_Stroop system
p21 = pnl.Process(pathway=[h2, map_h2_I, out_sig_I], learning=pnl.LEARNING)
p22 = pnl.Process(pathway=[h2, map_h2_is, out_sig_is], learning=pnl.LEARNING)
p23 = pnl.Process(pathway=[h2, map_h2_has, out_sig_has], learning=pnl.LEARNING)
p24 = pnl.Process(pathway=[h2, map_h2_can, out_sig_can], learning=pnl.LEARNING)
############################# THIS IS WHERE WE BUILD OUT THE SYSTEM ###################################
rumel_sys = pnl.System(processes=[
p11,
p12,
p21,
p22,
p23,
p24,
],
learning_rate=.5)
rumel_sys.show_graph(output_fmt='jupyter')
############################## THIS IS WHERE WE SETUP THE LOOP VARIABLES #########################################
# THESE ARRAYS STORE THE ERROR VALUES FROM THE SIG OUTPUT AND BIN OUTPUT
delta_bin_array = []
delta_sig_array = []
# SET NUMBER OF EPOCHS:
epochs = 1000
hidden_layers=n_hidden,
hidden_sizes=None,
training_flag=True,
quarter_size=20)
### building the PsyNeuLink network
T_input = pnl.TransferMechanism(size=n_input)
T_target = pnl.TransferMechanism(size=n_output)
# target_projection connects T_target to the TARGET InputPort of Leab
target_projection = pnl.MappingProjection(sender=T_target,
receiver=Leab.input_ports[1])
p_input = pnl.Process(pathway=[T_input, Leab])
p_target = pnl.Process(pathway=[T_target, target_projection, Leab])
sys = pnl.System(processes=[p_input, p_target])
### building the learning data
n = 1000
inputs = [None] * n
targets = [None] * n
print("here's what the inputs/targets will look like:")
for i in range(n):
nums = np.random.randint(0, 7, size=2) * 0.4
a = nums[0]
b = nums[1]
inputs[i] = [a, a, b, b]
if a > b:
targets[i] = [1, 0]
elif b > a:
targets[i] = [0, 1]
# In[7]:
proc_ECin_DG = pnl.Process(pathway=[ECin, ECin_to_DG, DG], learning=pnl.ENABLED, learning_rate=0.2)
proc_ECin_CA3 = pnl.Process(pathway=[ECin, ECin_to_CA3, CA3], learning=pnl.ENABLED, learning_rate=0.2)
proc_DG_CA3 = pnl.Process(pathway=[DG, DG_to_CA3, CA3], learning=pnl.ENABLED, learning_rate=0)
proc_CA3_CA1 = pnl.Process(pathway=[CA3, CA3_to_CA1, CA1], learning=pnl.ENABLED, learning_rate=0.05)
proc_CA1_ECout = pnl.Process(pathway=[CA1, ECout], learning=pnl.ENABLED, learning_rate=0.02)
proc_ECin_CA1 = pnl.Process(pathway=[ECin, CA1], learning_rate=0.02)
# In[8]:
TSP = pnl.System(processes=[proc_ECin_DG, proc_ECin_CA3, proc_DG_CA3, proc_CA3_CA1, proc_CA1_ECout])
# MSP = pnl.System(processes=[proc_ECin_CA1, proc_CA1_ECout])
# In[9]:
TSP.show_graph()
assert True
# In[10]:
## Method for making input
def statistical():
chars = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
def print_header(system):
print(
"\n\n**** TRIAL: ", system.scheduler_processing.times[
pnl.TimeScale.RUN][pnl.TimeScale.TRIAL])
def show_weights():
print('Reward prediction weights: \n',
action_selection.input_state.path_afferents[0].matrix)
print('\nAction selected: {}; predicted reward: {}'.format(
np.nonzero(action_selection.output_state.value)[0][0],
action_selection.output_state.value[np.nonzero(
action_selection.output_state.value)][0]))
p.run(num_trials=10,
inputs=[[[1, 1, 1]]],
targets=reward,
call_after_trial=show_weights)
input_list = {input_layer: [[1, 1, 1]]}
s = pnl.System(processes=[p], targets=[0])
s.run(num_trials=10,
inputs=input_list,
targets=reward,
call_before_trial=functools.partial(print_header, s),
call_after_trial=show_weights)
b_w_FHN=-1.0,
c_w_FHN=0.0,
t_0_FHN=0.0,
initial_v_FHN=initial_v,
initial_w_FHN=initial_u,
objective_mechanism=pnl.ObjectiveMechanism(function=pnl.Linear,
monitored_output_states=[
(decision_layer, None, None,
np.array([[w_vX1], [0.0]]))
],
name='LC ObjectiveMechanism'),
modulated_mechanisms=[decision_layer, response_layer
], # Modulate gain of decision & response layers
name='LC')
task = pnl.System(processes=[decision_process])
# This displays a diagram of the System
task.show_graph(show_dimensions=True)
# Create Stimulus -----------------------------------------------------------------------------------------------------
# number of trials
trials = 1000
# assign inputs to input_layer (Origin Mechanism) for each trial
stimulus_dictionary = {
input_layer: np.repeat(np.array([[0.0, 0.0], [1.0, 0.0]]), 500, axis=0)
}
# First 500 trials: target receives input of 0.0, distractor receives input of 0.0
# Second 500 trials: target receives input of 1.0, distractor receives input of 0.0
import psyneulink as pnl
import psyneulink.core.components.functions.transferfunctions
ci = pnl.TransferMechanism(size=2, name='COLORS INPUT')
wi = pnl.TransferMechanism(size=2, name='WORDS INPUT')
ch = pnl.TransferMechanism(
size=2,
function=psyneulink.core.components.functions.transferfunctions.Logistic,
name='COLORS HIDDEN')
wh = pnl.TransferMechanism(
size=2,
function=psyneulink.core.components.functions.transferfunctions.Logistic,
name='WORDS HIDDEN')
tl = pnl.TransferMechanism(
size=2,
function=psyneulink.core.components.functions.transferfunctions.Logistic(
gain=pnl.CONTROL),
name='TASK CONTROL')
rl = pnl.LCAMechanism(
size=2,
function=psyneulink.core.components.functions.transferfunctions.Logistic,
name='RESPONSE')
cp = pnl.Process(pathway=[ci, ch, rl])
wp = pnl.Process(pathway=[wi, wh, rl])
tc = pnl.Process(pathway=[tl, ch])
tw = pnl.Process(pathway=[tl, wh])
s = pnl.System(processes=[tc, tw, cp, wp],
controller=pnl.EVCControlMechanism(name='EVC Mechanimsm'),
monitor_for_control=[rl])
s.show_graph()
respond_red_process = pnl.Process(pathway=[
response_layer, respond_red_differencing_weights, respond_red_accumulator
],
name='RESPOND_RED_PROCESS')
respond_green_process = pnl.Process(pathway=[
response_layer, respond_green_differencing_weights,
respond_green_accumulator
],
name='RESPOND_GREEN_PROCESS')
# In[ ]:
# CREATE SYSTEM
my_Stroop = pnl.System(processes=[
colors_process, words_process, task_CN_process, task_WR_process,
respond_red_process, respond_green_process
],
name='FEEDFORWARD_STROOP_SYSTEM')
# In[ ]:
# test inputs
# no color, no word, no task
notask_noinput_trial_input = {
colors_input_layer: [0, 0],
words_input_layer: [0, 0],
task_layer: [0, 0]
}
# color 'red', word 'RED', task none
def test_lauras_cohen_1990_model():
# INPUT UNITS
# colors: ('red', 'green'), words: ('RED','GREEN')
colors_input_layer = pnl.TransferMechanism(size=2,
function=pnl.Linear,
name='COLORS_INPUT')
words_input_layer = pnl.TransferMechanism(size=2,
function=pnl.Linear,
name='WORDS_INPUT')
# Task layer, tasks: ('name the color', 'read the word')
task_layer = pnl.TransferMechanism(size=2,
function=pnl.Linear,
name='TASK')
# HIDDEN LAYER UNITS
# colors_hidden: ('red','green')
# Logistic activation function, Gain = 1.0, Bias = -4.0 (in PNL bias is subtracted so enter +4.0 to get negative bias)
# randomly distributed noise to the net input
# time averaging = integration_rate = 0.1
unit_noise = 0.005
colors_hidden_layer = pnl.TransferMechanism(
size=2,
function=pnl.Logistic(gain=1.0, bias=4.0),
# should be able to get same result with offset = -4.0
integrator_mode=True,
noise=pnl.NormalDist(mean=0, standard_dev=unit_noise).function,
integration_rate=0.1,
name='COLORS HIDDEN')
# words_hidden: ('RED','GREEN')
words_hidden_layer = pnl.TransferMechanism(
size=2,
function=pnl.Logistic(gain=1.0, bias=4.0),
integrator_mode=True,
noise=pnl.NormalDist(mean=0, standard_dev=unit_noise).function,
integration_rate=0.1,
name='WORDS HIDDEN')
# OUTPUT UNITS
# Response layer, provide input to accumulator, responses: ('red', 'green')
# time averaging = tau = 0.1
# randomly distributed noise to the net input
response_layer = pnl.TransferMechanism(
size=2,
function=pnl.Logistic,
name='RESPONSE',
integrator_mode=True,
noise=pnl.NormalDist(mean=0, standard_dev=unit_noise).function,
integration_rate=0.1)
# Respond red accumulator
# alpha = rate of evidence accumlation = 0.1
# sigma = noise = 0.1
# noise will be: squareroot(time_step_size * noise) * a random sample from a normal distribution
accumulator_noise = 0.1
respond_red_accumulator = pnl.IntegratorMechanism(
function=pnl.SimpleIntegrator(noise=pnl.NormalDist(
mean=0, standard_dev=accumulator_noise).function,
rate=0.1),
name='respond_red_accumulator')
# Respond green accumulator
respond_green_accumulator = pnl.IntegratorMechanism(
function=pnl.SimpleIntegrator(noise=pnl.NormalDist(
mean=0, standard_dev=accumulator_noise).function,
rate=0.1),
name='respond_green_accumulator')
# LOGGING
colors_hidden_layer.set_log_conditions('value')
words_hidden_layer.set_log_conditions('value')
response_layer.set_log_conditions('value')
respond_red_accumulator.set_log_conditions('value')
respond_green_accumulator.set_log_conditions('value')
# SET UP CONNECTIONS
# rows correspond to sender
# columns correspond to: weighting of the contribution that a given sender makes to the receiver
# INPUT TO HIDDEN
# row 0: input_'red' to hidden_'red', hidden_'green'
# row 1: input_'green' to hidden_'red', hidden_'green'
color_weights = pnl.MappingProjection(matrix=np.matrix([[2.2, -2.2],
[-2.2, 2.2]]),
name='COLOR_WEIGHTS')
# row 0: input_'RED' to hidden_'RED', hidden_'GREEN'
# row 1: input_'GREEN' to hidden_'RED', hidden_'GREEN'
word_weights = pnl.MappingProjection(matrix=np.matrix([[2.6, -2.6],
[-2.6, 2.6]]),
name='WORD_WEIGHTS')
# HIDDEN TO RESPONSE
# row 0: hidden_'red' to response_'red', response_'green'
# row 1: hidden_'green' to response_'red', response_'green'
color_response_weights = pnl.MappingProjection(
matrix=np.matrix([[1.3, -1.3], [-1.3, 1.3]]),
name='COLOR_RESPONSE_WEIGHTS')
# row 0: hidden_'RED' to response_'red', response_'green'
# row 1: hidden_'GREEN' to response_'red', response_'green'
word_response_weights = pnl.MappingProjection(matrix=np.matrix(
[[2.5, -2.5], [-2.5, 2.5]]),
name='WORD_RESPONSE_WEIGHTS')
# TASK TO HIDDEN LAYER
# row 0: task_CN to hidden_'red', hidden_'green'
# row 1: task_WR to hidden_'red', hidden_'green'
task_CN_weights = pnl.MappingProjection(matrix=np.matrix([[4.0, 4.0],
[0, 0]]),
name='TASK_CN_WEIGHTS')
# row 0: task_CN to hidden_'RED', hidden_'GREEN'
# row 1: task_WR to hidden_'RED', hidden_'GREEN'
task_WR_weights = pnl.MappingProjection(matrix=np.matrix([[0, 0],
[4.0, 4.0]]),
name='TASK_WR_WEIGHTS')
# RESPONSE UNITS TO ACCUMULATORS
# row 0: response_'red' to respond_red_accumulator
# row 1: response_'green' to respond_red_accumulator
respond_red_differencing_weights = pnl.MappingProjection(
matrix=np.matrix([[1.0], [-1.0]]), name='RESPOND_RED_WEIGHTS')
# row 0: response_'red' to respond_green_accumulator
# row 1: response_'green' to respond_green_accumulator
respond_green_differencing_weights = pnl.MappingProjection(
matrix=np.matrix([[-1.0], [1.0]]), name='RESPOND_GREEN_WEIGHTS')
# CREATE PATHWAYS
# Words pathway
words_process = pnl.Process(pathway=[
words_input_layer, word_weights, words_hidden_layer,
word_response_weights, response_layer
],
name='WORDS_PROCESS')
# Colors pathway
colors_process = pnl.Process(pathway=[
colors_input_layer, color_weights, colors_hidden_layer,
color_response_weights, response_layer
],
name='COLORS_PROCESS')
# Task representation pathway
task_CN_process = pnl.Process(
pathway=[task_layer, task_CN_weights, colors_hidden_layer],
name='TASK_CN_PROCESS')
task_WR_process = pnl.Process(
pathway=[task_layer, task_WR_weights, words_hidden_layer],
name='TASK_WR_PROCESS')
# Evidence accumulation pathway
respond_red_process = pnl.Process(pathway=[
response_layer, respond_red_differencing_weights,
respond_red_accumulator
],
name='RESPOND_RED_PROCESS')
respond_green_process = pnl.Process(pathway=[
response_layer, respond_green_differencing_weights,
respond_green_accumulator
],
name='RESPOND_GREEN_PROCESS')
# CREATE SYSTEM
my_Stroop = pnl.System(processes=[
colors_process, words_process, task_CN_process, task_WR_process,
respond_red_process, respond_green_process
],
name='FEEDFORWARD_STROOP_SYSTEM')
# my_Stroop.show()
# my_Stroop.show_graph(show_dimensions=pnl.ALL)
# Function to create test trials
# a RED word input is [1,0] to words_input_layer and GREEN word is [0,1]
# a red color input is [1,0] to colors_input_layer and green color is [0,1]
# a color-naming trial is [1,0] to task_layer and a word-reading trial is [0,1]
def trial_dict(red_color, green_color, red_word, green_word, CN, WR):
trialdict = {
colors_input_layer: [red_color, green_color],
words_input_layer: [red_word, green_word],
task_layer: [CN, WR]
}
return trialdict
# CREATE THRESHOLD FUNCTION
# first value of DDM's value is DECISION_VARIABLE
def pass_threshold(mech1, mech2, thresh):
results1 = mech1.output_states[0].value
results2 = mech2.output_states[0].value
for val in results1:
if val >= thresh:
return True
for val in results2:
if val >= thresh:
return True
return False
accumulator_threshold = 1.0
mechanisms_to_update = [
colors_hidden_layer, words_hidden_layer, response_layer
]
def switch_integrator_mode(mechanisms, mode):
for mechanism in mechanisms:
mechanism.integrator_mode = mode
def switch_noise(mechanisms, noise):
for mechanism in mechanisms:
mechanism.noise = noise
def switch_to_initialization_trial(mechanisms):
# Turn off accumulation
switch_integrator_mode(mechanisms, False)
# Turn off noise
switch_noise(mechanisms, 0)
# Execute once per trial
my_Stroop.termination_processing = {
pnl.TimeScale.TRIAL: pnl.AllHaveRun()
}
def switch_to_processing_trial(mechanisms):
# Turn on accumulation
switch_integrator_mode(mechanisms, True)
# Turn on noise
switch_noise(mechanisms,
pnl.NormalDist(mean=0, standard_dev=unit_noise).function)
# Execute until one of the accumulators crosses the threshold
my_Stroop.termination_processing = {
pnl.TimeScale.TRIAL:
pnl.While(pass_threshold, respond_red_accumulator,
respond_green_accumulator, accumulator_threshold)
}
def switch_trial_type():
# Next trial will be a processing trial
if isinstance(my_Stroop.termination_processing[pnl.TimeScale.TRIAL],
pnl.AllHaveRun):
switch_to_processing_trial(mechanisms_to_update)
# Next trial will be an initialization trial
else:
switch_to_initialization_trial(mechanisms_to_update)
CN_trial_initialize_input = trial_dict(0, 0, 0, 0, 1, 0)
WR_trial_initialize_input = trial_dict(0, 0, 0, 0, 0, 1)
# Start with an initialization trial
switch_to_initialization_trial(mechanisms_to_update)
my_Stroop.run(
inputs=trial_dict(0, 1, 1, 0, 1, 0),
# termination_processing=change_termination_processing,
num_trials=6,
call_after_trial=switch_trial_type)
# respond_red_accumulator.log.print_entries()
respond_green_accumulator.log.print_entries()
output_layer = pnl.TransferMechanism(
size=1,
function=psyneulink.core.components.functions.transferfunctions.Logistic,
name="output layer")
#bias_h=pnl.Process(pathway=[bias_mech_h,p_b,hidden_layer],learning=pnl.ENABLED)
#bias_out=pnl.Process(pathway=[bias_mech_out,p_b_o,output_layer],learning=pnl.ENABLED)
net3l = pnl.Process(
pathway=[input_layer, proj, hidden_layer, proj_h, output_layer],
learning=pnl.ENABLED)
sys3l = pnl.System(
processes=[
#bias_h,
#bias_out,
net3l
],
learning_rate=8)
#### AFTER THIS PART IS FINE #####
sys3l.show_graph(output_fmt='jupyter')
trials = 4000
X = np.array([[1, 1], [1, 0], [0, 1], [0, 0]])
#X=[[1,1,1],[1,0,1],[0,1,1],[0,0,1]]
b_h_ins = [[1, 1], [1, 1], [1, 1], [1, 1]]
b_o_ins = [[1], [1], [1], [1]]
AND_labels_pnl = [[1], [0], [0], [0]]
OR_labels_pnl = [[1], [1], [1], [0]]
XOR_labels_pnl = [[0], [1], [1], [0]]
def test_default_lc_control_mechanism(self, benchmark, mode):
G = 1.0
k = 0.5
starting_value_LC = 2.0
user_specified_gain = 1.0
A = pnl.TransferMechanism(function=pnl.Logistic(gain=user_specified_gain), name='A')
B = pnl.TransferMechanism(function=pnl.Logistic(gain=user_specified_gain), name='B')
# B.output_states[0].value *= 0.0 # Reset after init | Doesn't matter here b/c default var = zero, no intercept
LC = pnl.LCControlMechanism(
modulated_mechanisms=[A, B],
base_level_gain=G,
scaling_factor_gain=k,
objective_mechanism=pnl.ObjectiveMechanism(
function=pnl.Linear,
monitored_output_states=[B],
name='LC ObjectiveMechanism'
)
)
for output_state in LC.output_states:
output_state.value *= starting_value_LC
P = pnl.Process(pathway=[A, B, LC])
S = pnl.System(processes=[P])
LC.reinitialize_when = pnl.Never()
# THIS CURRENTLY DOES NOT WORK:
# P = pnl.Process(pathway=[A, B])
# P2 = pnl.Process(pathway=[LC])
# S = pnl.System(processes=[P, P2])
# S.show_graph()
gain_created_by_LC_output_state_1 = []
mod_gain_assigned_to_A = []
base_gain_assigned_to_A = []
mod_gain_assigned_to_B = []
base_gain_assigned_to_B = []
def report_trial():
gain_created_by_LC_output_state_1.append(LC.output_states[0].value[0])
mod_gain_assigned_to_A.append(A.mod_gain)
mod_gain_assigned_to_B.append(B.mod_gain)
base_gain_assigned_to_A.append(A.function_object.gain)
base_gain_assigned_to_B.append(B.function_object.gain)
benchmark(S.run, inputs={A: [[1.0], [1.0], [1.0], [1.0], [1.0]]},
call_after_trial=report_trial)
# (1) First value of gain in mechanisms A and B must be whatever we hardcoded for LC starting value
assert mod_gain_assigned_to_A[0] == starting_value_LC
# (2) _gain should always be set to user-specified value
for i in range(5):
assert base_gain_assigned_to_A[i] == user_specified_gain
assert base_gain_assigned_to_B[i] == user_specified_gain
# (3) LC output on trial n becomes gain of A and B on trial n + 1
assert np.allclose(mod_gain_assigned_to_A[1:], gain_created_by_LC_output_state_1[0:-1])
# (4) mechanisms A and B should always have the same gain values (b/c they are identical)
assert np.allclose(mod_gain_assigned_to_A, mod_gain_assigned_to_B)
# projection that takes the signal from the hidden layer and transforms it to get an input for
# the output layer (the xor_out mechanism)
out_map = pnl.MappingProjection(name='hidden_to_output',
matrix=np.random.randn(10, 1) * 0.1,
sender=xor_hid,
receiver=xor_out)
# Put together the mechanisms and projections to get the System representing the XOR model:
# the order of mechanisms and projections is specified at the process level
xor_process = pnl.Process(pathway=[xor_in, hid_map, xor_hid, out_map, xor_out],
learning=pnl.LEARNING)
# the learning_rate parameter determines the size of learning updates during training for the System.
xor_sys = pnl.System(processes=[xor_process], learning_rate=learning_rate)
# The comparator mechanism for computing loss and the learning mechanisms/projections for doing
# backpropagation/the learning update during training are set up for the System automatically.
# Train the System representing the XOR model by calling run.
# The 4 learning steps are performed by the run method behind the scenes - as stated in the design doc,
# the loss measurement computed by the system's comparator mechanism defaults to MSE loss, and the learning
# update carried out by learning mechanisms/projections defaults to basic stochastic gradient descent (sgd).
results_sys = xor_sys.run(inputs={xor_in: xor_inputs},
targets={xor_out: xor_targets},
num_trials=(len(xor_inputs) * num_epochs + 1))
system_total_time = time.time() - system_start_time
def test_gating_with_UDF():
def my_linear_fct(x,
m=2.0,
b=0.0,
params={
pnl.ADDITIVE_PARAM: 'b',
pnl.MULTIPLICATIVE_PARAM: 'm'
}):
return m * x + b
def my_simple_linear_fct(x, m=1.0, b=0.0):
return m * x + b
def my_exp_fct(
x,
r=1.0,
# b=pnl.CONTROL,
b=0.0,
params={
pnl.ADDITIVE_PARAM: 'b',
pnl.MULTIPLICATIVE_PARAM: 'r'
}):
return x**r + b
def my_sinusoidal_fct(input,
phase=0,
amplitude=1,
params={
pnl.ADDITIVE_PARAM: 'phase',
pnl.MULTIPLICATIVE_PARAM: 'amplitude'
}):
frequency = input[0]
t = input[1]
return amplitude * np.sin(2 * np.pi * frequency * t + phase)
Input_Layer = pnl.TransferMechanism(name='Input_Layer',
default_variable=np.zeros((2, )),
function=psyneulink.core.components.
functions.transferfunctions.Logistic)
Output_Layer = pnl.TransferMechanism(
name='Output_Layer',
default_variable=[0, 0, 0],
function=psyneulink.core.components.functions.transferfunctions.Linear,
# function=pnl.Logistic,
# output_states={pnl.NAME: 'RESULTS USING UDF',
# pnl.VARIABLE: [(pnl.OWNER_VALUE,0), pnl.TIME_STEP],
# pnl.FUNCTION: my_sinusoidal_fct}
output_states={
pnl.NAME:
'RESULTS USING UDF',
# pnl.VARIABLE: (pnl.OWNER_VALUE, 0),
pnl.FUNCTION:
psyneulink.core.components.functions.transferfunctions.Linear(
slope=pnl.GATING)
# pnl.FUNCTION: pnl.Logistic(gain=pnl.GATING)
# pnl.FUNCTION: my_linear_fct
# pnl.FUNCTION: my_exp_fct
# pnl.FUNCTION:pnl.UserDefinedFunction(custom_function=my_simple_linear_fct,
# params={pnl.ADDITIVE_PARAM:'b',
# pnl.MULTIPLICATIVE_PARAM:'m',
# },
# m=pnl.GATING,
# b=2.0
# )
})
Gating_Mechanism = pnl.GatingMechanism(
# default_gating_allocation=0.0,
size=[1],
gating_signals=[
# Output_Layer
Output_Layer.output_state,
])
p = pnl.Process(size=2,
pathway=[Input_Layer, Output_Layer],
prefs={
pnl.VERBOSE_PREF: False,
pnl.REPORT_OUTPUT_PREF: False
})
g = pnl.Process(default_variable=[1.0], pathway=[Gating_Mechanism])
stim_list = {
Input_Layer: [[-1, 30], [-1, 30], [-1, 30], [-1, 30]],
Gating_Mechanism: [[0.0], [0.5], [1.0], [2.0]]
}
mySystem = pnl.System(processes=[p, g])
mySystem.reportOutputPref = False
results = mySystem.run(
num_trials=4,
inputs=stim_list,
)
expected_results = [[np.array([0., 0., 0.])],
[np.array([0.63447071, 0.63447071, 0.63447071])],
[np.array([1.26894142, 1.26894142, 1.26894142])],
[np.array([2.53788284, 2.53788284, 2.53788284])]]
np.testing.assert_allclose(results, expected_results)
decision_process.run(num_trials=10,
inputs=[[1, 1]],
targets=reward
)
# inputs = np.tile(np.repeat(np.array([[1., 0.], [0., 0.], [0., 1.], [0., 0.]]), 20, axis=0), (4, 1))
# input_dict = {input_layer: inputs}
input_dict = {input_layer: [1, 0]}
DA_sys = pnl.System(
processes=[decision_process, conflict_process,
update_process],
controller=updateC,
targets=[0],
name='NE-DA System'
)
DA_sys.show_graph(show_learning=pnl.ALL,
show_control=pnl.ALL,
show_dimensions=True,
show_mechanism_structure=pnl.ALL)
DA_sys.run(
num_trials=10,
inputs=input_dict,
targets=reward,
call_after_trial=functools.partial(show_weights, DA_sys)
)
def show_target(system):
i = system.input
t = system.target_input_states[0].value
print('\nOLD WEIGHTS: \n')
print('- Input Weights: \n', Input_Weights.matrix)
print('- Middle Weights: \n', Middle_Weights.matrix)
print('- Output Weights: \n', Output_Weights.matrix)
print('\nSTIMULI:\n\n- Input: {}\n- Target: {}\n'.format(i, t))
print('ACTIVITY FROM OLD WEIGHTS: \n')
print('- Middle 1: \n', Hidden_Layer_1.value)
print('- Middle 2: \n', Hidden_Layer_2.value)
print('- Output:\n', Output_Layer.value)
mySystem = pnl.System(processes=[z], targets=[0, 0, 1], learning_rate=2.0)
mySystem.reportOutputPref = True
# Shows graph will full information:
# mySystem.show_graph(show_learning=pnl.ALL, show_dimensions=pnl.ALL)
# Shows minimal graph:
mySystem.show_graph()
stim_list = {Input_Layer: [[-1, 30]]}
target_list = {Output_Layer: [[0, 0, 1]]}
mySystem.run(num_trials=10,
inputs=stim_list,
targets=target_list,
call_before_trial=functools.partial(print_header, mySystem),
call_after_trial=functools.partial(show_target, mySystem),
pathway=[Reward],
name='RewardProcess'
)
# System:
mySystem = pnl.System(processes=[TargetControlProcess,
FlankerControlProcess,
TargetAutomaticProcess,
FlankerAutomaticProcess,
RewardProcess],
controller=pnl.EVCControlMechanism(
control_signals=pnl.ControlSignal(projections=[(pnl.SLOPE, Target_Rep),
(pnl.SLOPE, Distractor_Rep)
],
function=psyneulink.core.components.functions.transferfunctions.Logistic,
cost_options=[pnl.ControlSignalCosts.INTENSITY,
pnl.ControlSignalCosts.ADJUSTMENT],
allocation_samples=signalSearchRange
)),
enable_controller=True,
monitor_for_control=[
# (None, None, np.ones((2,1))), # what the **** is this for? Markus October 25 2018
Reward,
Decision.PROBABILITY_UPPER_THRESHOLD,
('OFFSET RT', 1, -1),
],
name='EVC Markus System')
# log controller
mySystem.loggable_items
def test_rumelhart_semantic_network_sequential(self):
rep_in = pnl.TransferMechanism(size=10, name='REP_IN')
rel_in = pnl.TransferMechanism(size=11, name='REL_IN')
rep_hidden = pnl.TransferMechanism(size=4,
function=pnl.Logistic,
name='REP_HIDDEN')
rel_hidden = pnl.TransferMechanism(size=5,
function=pnl.Logistic,
name='REL_HIDDEN')
rep_out = pnl.TransferMechanism(size=10,
function=pnl.Logistic,
name='REP_OUT')
prop_out = pnl.TransferMechanism(size=12,
function=pnl.Logistic,
name='PROP_OUT')
qual_out = pnl.TransferMechanism(size=13,
function=pnl.Logistic,
name='QUAL_OUT')
act_out = pnl.TransferMechanism(size=14,
function=pnl.Logistic,
name='ACT_OUT')
rep_hidden_proc = pnl.Process(pathway=[rep_in, rep_hidden, rel_hidden],
learning=pnl.LEARNING,
name='REP_HIDDEN_PROC')
rel_hidden_proc = pnl.Process(pathway=[rel_in, rel_hidden],
learning=pnl.LEARNING,
name='REL_HIDDEN_PROC')
rel_rep_proc = pnl.Process(pathway=[rel_hidden, rep_out],
learning=pnl.LEARNING,
name='REL_REP_PROC')
rel_prop_proc = pnl.Process(pathway=[rel_hidden, prop_out],
learning=pnl.LEARNING,
name='REL_PROP_PROC')
rel_qual_proc = pnl.Process(pathway=[rel_hidden, qual_out],
learning=pnl.LEARNING,
name='REL_QUAL_PROC')
rel_act_proc = pnl.Process(pathway=[rel_hidden, act_out],
learning=pnl.LEARNING,
name='REL_ACT_PROC')
S = pnl.System(processes=[
rep_hidden_proc, rel_hidden_proc, rel_rep_proc, rel_prop_proc,
rel_qual_proc, rel_act_proc
])
# S.show_graph(show_learning=pnl.ALL, show_dimensions=True)
validate_learning_mechs(S)
print(S.origin_mechanisms)
print(S.terminal_mechanisms)
S.run(
inputs={
rel_in:
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
rep_in: [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
},
# targets={rep_out: [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]],
# prop_out: [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]],
# qual_out: [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]],
# act_out: [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]]}
)
target=[2, 2],
name='Color Naming',
prefs=process_prefs)
word_reading_process = pnl.Process(default_variable=[.5, 3],
pathway=[words, WH_Weights, hidden],
name='Word Reading',
learning=pnl.LEARNING,
target=[3, 3],
prefs=process_prefs)
# color_naming_process.execute()
# word_reading_process.execute()
mySystem = pnl.System(processes=[color_naming_process, word_reading_process],
targets=[20, 20],
name='Stroop Model',
prefs=system_prefs)
mySystem.show_graph(
# show_learning=True
)
def print_header(system):
print(
"\n\n**** TRIAL: ", system.scheduler_processing.times[
pnl.TimeScale.RUN][pnl.TimeScale.TRIAL])
def show_target():
print('\nColor Naming\n\tInput: {}\n\tTarget: {}'.format(
modulated_mechanisms=[decision_layer, response_layer], # Modulate gain of decision & response layers
name='LC'
)
# Log value of LC
LC.set_log_conditions('value')
# Set initial gain to G + k*initial_w, when the System runs the very first time,
# since the decison layer executes before the LC and hence needs one initial gain value to start with.
for output_state in LC.output_states:
output_state.value *= G + k * initial_w
LC_process = pnl.Process(pathway=[LC])
# Now, we specify the processes of the System, which in this case is just the decision_process
task = pnl.System(processes=[decision_process, LC_process],
reinitialize_mechanisms_when=pnl.Never(),)
# Create Stimulus -----------------------------------------------------------------------------------------------------
# In the paper, each period has 100 time steps, so we will create 11 time periods.
# As described in the paper in figure 3, during the first 3 time periods input to distractor units is fixed to 1.
# Then T1 gets turned on during time period 4 with an input of 1.
# T2 gets turns on with some lag from T1 onset on, in this example we turn T2 on with Lag 2 and an input of 1
# Between T1 and T2 and after T2 the distractor unit is on.
# We create one array with 3 numbers, one for each input unit and repeat this array 100 times for one time period
# We do this 11 times. T1 is on for time4, T2 is on for time7 to model Lag3
num_time_steps = 100 # Each stimulus is presented for two units of time which is equivalent to 100 time steps
stimulus_T1 = np.repeat(np.array([[0, 0, 1]]), num_time_steps, axis=0)
stimulus_T2 = np.repeat(np.array([[0, 0, 1]]), num_time_steps, axis=0)
stimulus_T3 = np.repeat(np.array([[0, 0, 1]]), num_time_steps, axis=0)
stimulus_T4 = np.repeat(np.array([[1, 0, 0]]), num_time_steps, axis=0) # Turn T1 on
def model_training():
"""
This creates the plot for figure 5A in the Montague paper. Figure 5A is
a 'plot of ∂(t) over time for three trials during training (1, 30, and 50).'
"""
sample = pnl.TransferMechanism(default_variable=np.zeros(60),
name=pnl.SAMPLE)
action_selection = pnl.TransferMechanism(default_variable=np.zeros(60),
function=pnl.Linear(
slope=1.0, intercept=0.01),
name='Action Selection')
stimulus_onset = 41
reward_delivery = 54
samples = np.zeros(60)
samples[stimulus_onset:] = 1
samples = np.tile(samples, (120, 1))
targets = np.zeros(60)
targets[reward_delivery] = 1
targets = np.tile(targets, (120, 1))
# no reward given every 15 trials to simulate a wrong response
targets[14][reward_delivery] = 0
targets[29][reward_delivery] = 0
targets[44][reward_delivery] = 0
targets[59][reward_delivery] = 0
targets[74][reward_delivery] = 0
targets[89][reward_delivery] = 0
pnl.MappingProjection(sender=sample,
receiver=action_selection,
matrix=np.full((60, 60), 0.0))
learning_projection = pnl.LearningProjection(
learning_function=pnl.TDLearning(learning_rate=0.3))
p = pnl.Process(default_variable=np.zeros(60),
pathway=[sample, action_selection],
learning=learning_projection,
size=60,
target=np.zeros(60))
trial = 0
def print_header():
nonlocal trial
print("\n\n*** EPISODE: {}".format(trial))
def store_delta_vals():
nonlocal trial
delta_vals[trial] = s.mechanisms[2].value
trial += 1
print('Delta values: \n{0}'.format(s.mechanisms[2].value))
input_list = {sample: samples}
target_list = {action_selection: targets}
s = pnl.System(processes=[p])
delta_vals = np.zeros((120, 60))
s.run(num_trials=120,
inputs=input_list,
targets=target_list,
learning=True,
call_before_trial=print_header,
call_after_trial=store_delta_vals)
with plt.style.context('seaborn'):
plt.plot(delta_vals[0], "-o", label="Trial 1")
plt.plot(delta_vals[29], "-s", label="Trial 30")
plt.plot(delta_vals[49], "-o", label="Trial 50")
plt.title("Montague et. al. (1996) -- Figure 5A")
plt.xlabel("Timestep")
plt.ylabel("∂")
plt.legend()
plt.xlim(xmin=35)
plt.xticks()
plt.show()
pathway=[task_layer, task_CN_weights, colors_hidden_layer],
name='TASK_CN_PROCESS')
task_WR_process = pnl.Process(
pathway=[task_layer, task_WR_weights, words_hidden_layer],
name='TASK_WR_PROCESS')
# CREATE SYSTEM
my_Stroop = pnl.System(
processes=[
colors_process, words_process, task_CN_process, task_WR_process
],
controller=pnl.ControlMechanism,
monitor_for_control=[response_layer],
enable_controller=True,
# objective_mechanism =pnl.ObjectiveMechanism(default_variable=[0.0, 0.0],
# monitored_output_ports=[response_layer.output_ports[0]],
# function=pnl.Linear(default_variable= [0.0, 0.0]),
# name="Objective Mechanism"),
# monitor_for_control=
# function=pnl.LinearCombination(operation=pnl.ENERGY))
# respond_red_process,
# respond_green_process],
name='FEEDFORWARD_STROOP_SYSTEM')
# my_Stroop.controller.set_log_conditions('TASK[gain] ControlSignal')
# my_Stroop.controller.loggable_items
# CREATE THRESHOLD FUNCTION
# first value of DDM's value is DECISION_VARIABLE
def pass_threshold(mech1, thresh):
def model_training_response_extinction():
"""
This creates the plot for Figure 5C in the Montague paper. Figure 5C shows
'extinction of response to the sensory cue.' The setup is the same as
Figure 5A, except that reward delivery stops at trial 70
"""
sample = pnl.TransferMechanism(default_variable=np.zeros(60),
name=pnl.SAMPLE)
action_selection = pnl.TransferMechanism(default_variable=np.zeros(60),
function=pnl.Linear(
slope=1.0, intercept=1.0),
name='Action Selection')
stimulus_onset = 42
reward_delivery = 54
samples = np.zeros(60)
samples[stimulus_onset:] = 1
samples = np.tile(samples, (150, 1))
targets = np.zeros(60)
targets[reward_delivery] = 1
targets = np.tile(targets, (150, 1))
# stop delivering reward after trial 70
for i in range(71, 150):
targets[i][reward_delivery] = 0
pnl.MappingProjection(sender=sample,
receiver=action_selection,
matrix=np.zeros((60, 60)))
learning_projection = pnl.LearningProjection(
learning_function=pnl.TDLearning(learning_rate=0.3))
p = pnl.Process(default_variable=np.zeros(60),
pathway=[sample, action_selection],
learning=learning_projection,
size=60,
target=np.zeros(60))
trial = 0
def print_header():
nonlocal trial
print("\n\n*** EPISODE: {}".format(trial))
input_list = {sample: samples}
target_list = {action_selection: targets}
s = pnl.System(processes=[p])
delta_vals = np.zeros((150, 60))
trial = 0
def store_delta_vals():
nonlocal trial
delta_vals[trial] = s.mechanisms[2].value
trial += 1
s.run(num_trials=150,
inputs=input_list,
targets=target_list,
learning=True,
call_before_trial=print_header,
call_after_trial=store_delta_vals)
with plt.style.context('seaborn'):
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x_vals, y_vals = np.meshgrid(np.arange(150), np.arange(40, 60, step=1))
ax.plot_surface(x_vals, y_vals, delta_vals[:, 40:60].transpose())
ax.invert_yaxis()
ax.set_xlabel("Trial")
ax.set_ylabel("Timestep")
ax.set_zlabel("∂")
ax.set_title("Montague et. al. (1996) -- Figure 5C")
plt.show()
rep_hidden_proc = pnl.Process(pathway=[rep_in, rep_hidden, rel_hidden],
learning=pnl.LEARNING,
name='REP_HIDDEN_PROC')
rel_hidden_proc = pnl.Process(pathway=[rel_in, rel_hidden],
learning=pnl.LEARNING,
name='REL_HIDDEN_PROC')
rel_rep_proc = pnl.Process(pathway=[rel_hidden, rep_out],
learning=pnl.LEARNING,
name='REL_REP_PROC')
rel_prop_proc = pnl.Process(pathway=[rel_hidden, prop_out],
learning=pnl.LEARNING,
name='REL_PROP_PROC')
rel_qual_proc = pnl.Process(pathway=[rel_hidden, qual_out],
learning=pnl.LEARNING,
name='REL_QUAL_PROC')
rel_act_proc = pnl.Process(pathway=[rel_hidden, act_out],
learning=pnl.LEARNING,
name='REL_ACT_PROC')
# The System:
S = pnl.System(processes=[
rep_hidden_proc, rel_hidden_proc, rel_rep_proc, rel_prop_proc,
rel_qual_proc, rel_act_proc
])
# Shows just the processing network:
# S.show_graph(show_dimensions=True)
# Shows all of the learning components:
S.show_graph(show_learning=pnl.ALL)
def model_training_full_experiment():
"""
This creates the plot for figure 5B in the Montague paper. Figure 5B shows
the 'entire time course of model responses (trials 1-150).' The setup is
the same as in Figure 5A, except that training begins at trial 10.
"""
sample = pnl.TransferMechanism(default_variable=np.zeros(60),
name=pnl.SAMPLE)
action_selection = pnl.TransferMechanism(default_variable=np.zeros(60),
function=pnl.Linear(
slope=1.0, intercept=1.0),
name='Action Selection')
stimulus_onset = 41
reward_delivery = 54
samples = np.zeros(60)
samples[stimulus_onset:] = 1
samples = np.tile(samples, (120, 1))
targets = np.zeros(60)
targets[reward_delivery] = 1
targets = np.tile(targets, (120, 1))
# training begins at trial 11
# no reward given every 15 trials to simulate a wrong response
no_reward_trials = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14, 29, 44, 59, 74, 89, 104, 119
]
for t in no_reward_trials:
targets[t][reward_delivery] = 0
pnl.MappingProjection(sender=sample,
receiver=action_selection,
matrix=np.zeros((60, 60)))
learning_projection = pnl.LearningProjection(
learning_function=pnl.TDLearning(learning_rate=0.3))
p = pnl.Process(default_variable=np.zeros(60),
pathway=[sample, action_selection],
learning=learning_projection,
size=60,
target=np.zeros(60))
trial = 0
def print_header():
nonlocal trial
print("\n\n*** EPISODE: {}".format(trial))
def store_delta_vals():
nonlocal trial
delta_vals[trial] = s.mechanisms[2].value
trial += 1
input_list = {sample: samples}
target_list = {action_selection: targets}
s = pnl.System(processes=[p])
delta_vals = np.zeros((120, 60))
s.run(num_trials=120,
inputs=input_list,
targets=target_list,
learning=True,
call_before_trial=print_header,
call_after_trial=store_delta_vals)
with plt.style.context('seaborn'):
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x_vals, y_vals = np.meshgrid(np.arange(120), np.arange(40, 60, step=1))
ax.plot_surface(x_vals, y_vals, delta_vals[:, 40:60].transpose())
ax.invert_yaxis()
ax.set_xlabel("Trial")
ax.set_ylabel("Timestep")
ax.set_zlabel("∂")
ax.set_title("Montague et. al. (1996) -- Figure 5B")
plt.show()
name='Flanker1 Automatic Process')
# RewardProcess = pnl.Process(
# default_variable=[0],
# pathway=[Reward, test_mech],
# name='RewardProcess'
# )
# System:
mySystem = pnl.System(
processes=[
TargetControlProcess, FlankerControlProcess, TargetAutomaticProcess,
FlankerAutomaticProcess
],
controller=pnl.EVCControlMechanism,
enable_controller=True,
monitor_for_control=[
# (None, None, np.ones((2,1))),
# Reward,
Decision.PROBABILITY_UPPER_THRESHOLD,
('OFFSET RT', 1, -1),
],
name='EVC Markus System')
# Show characteristics of system:
mySystem.show()
# mySystem.controller.show()
# Show graph of system
# mySystem.show_graph(show_control=True)# show_control=True,show_dimensions=True)
#Markus: incongruent trial weights:
import psyneulink as pnl
import psyneulink.core.components.functions.transferfunctions
stimulus_layer = pnl.TransferMechanism(size=4)
task_layer = pnl.TransferMechanism(size=4)
hidden_layer = pnl.TransferMechanism(size=4, function=psyneulink.core.components.functions.transferfunctions.Logistic)
output_layer = pnl.TransferMechanism(size=4, function=psyneulink.core.components.functions.transferfunctions.Logistic)
network_process = pnl.Process(pathway=[stimulus_layer, hidden_layer, output_layer])
hidden_control_process = pnl.Process(pathway=[task_layer, hidden_layer])
output_control_process = pnl.Process(pathway=[task_layer, output_layer])
multitasking_system = pnl.System(processes=[network_process, hidden_control_process, output_control_process])
# WEIGHTS TO COME FROM SEBASTIAN
example_stimulus_inputs = [[1,0,0,1],[1,0,1,0]]
example_task_inputs = [[0,0,0,1],[1,0,0,0]]
example_training_pattern = [[0,0,0,1],[1,0,0,0]]
# RUN THIS TO GET SPACE OF INPUTS ON WHICH TO OPTIMIZE LCAMechanism PARAMS:
inputs_to_LCA = multitasking_system.run(inputs={stimulus_layer:example_stimulus_inputs,
task_layer:example_task_inputs})
# SOME PYTHON ALGORITHM HERE THAT SELECTS THE 2-UNIT SUBVECTOR FROM inputs_to_LCA CORRESPONDING TO THE RELEVANT TASK
# AS INPUT TO optimization_system BELOW, AND THEN RUN THE SYSTEM FOR EACH INPUT, USING EVC TO OPTIMIZE LCAMechanism PARAMETERS
# FOR EACH, BASED CONTROL PARAMETERS AND OBJECTIVE FUNCTION
input_layer = pnl.TransferMechanism(size=2)
decision_layer = pnl.LCAMechanism(size=2,
# INCLUDE TERMINATION CONDITION USING THREHSOLD = ControlSignal)
prefs=process_prefs,
name='Flanker1 Automatic Process')
RewardProcess = pnl.Process(default_variable=[0],
pathway=[Reward],
prefs=process_prefs,
name='RewardProcess')
# System:
mySystem = pnl.System(
processes=[
TargetControlProcess, FlankerControlProcess, TargetAutomaticProcess,
FlankerAutomaticProcess, RewardProcess
],
controller=pnl.EVCControlMechanism(name='Task Controller', ),
enable_controller=True,
monitor_for_control=[
Reward,
Decision.PROBABILITY_UPPER_THRESHOLD,
('OFFSET RT', 1, -1),
],
# monitor_for_control=[Reward, DDM_PROBABILITY_UPPER_THRESHOLD, (DDM_RESPONSE_TIME, -1, 1)],
name='EVC Gratton System')
# Show characteristics of system:
mySystem.show()
mySystem.controller.show()
# Show graph of system (with control components)
# mySystem.show_graph()
# mySystem.show_graph(show_dimensions=pnl.ALL, show_projection_labels=True)
# mySystem.show_graph(show_control=True, show_projection_labels=False)
def test_log_array_with_scheduler(self):
T1 = pnl.TransferMechanism(name='log_test_T1',
integrator_mode=True,
integration_rate=0.5)
T2 = pnl.TransferMechanism(name='log_test_T2',
function=pnl.Linear(slope=6.0))
PS = pnl.Process(name='log_test_PS', pathway=[T1, T2])
SYS = pnl.System(name='log_test_SYS', processes=[PS])
def pass_threshold(mech, thresh):
results = mech.output_states[0].value
for val in results:
if abs(val) >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, T2, 5.0)
}
T1.set_log_conditions(pnl.VALUE)
T1.set_log_conditions(pnl.SLOPE)
T1.set_log_conditions(pnl.RESULTS)
T2.set_log_conditions(pnl.VALUE)
T2.set_log_conditions(pnl.SLOPE)
SYS.run(inputs={T1: [[1.0]]}, termination_processing=terminate_trial)
log_array_T1 = T1.log.nparray(entries=['RESULTS', 'slope', 'value'])
log_array_T2 = T2.log.nparray(entries=['value', 'slope'])
# Check values
run_results = [["Run"], [0], [0], [0]]
trial_results = [["Trial"], [0], [0], [0]]
pass_results = [["Pass"], [0], [1], [2]]
time_step_results = [["Time_step"], [0], [0], [0]]
results_results = ["RESULTS", [0.5], [0.75], [0.875]]
slope_results = ["slope", [1], [1], [1]]
value_results = ["value", [[0.5]], [[0.75]], [[0.875]]]
for i in range(4):
assert log_array_T1[0][i] == run_results[i]
assert log_array_T1[1][i] == trial_results[i]
assert log_array_T1[2][i] == pass_results[i]
assert log_array_T1[3][i] == time_step_results[i]
assert log_array_T1[4][i] == results_results[i]
assert log_array_T1[5][i] == slope_results[i]
assert log_array_T1[6][i] == value_results[i]
# Check values
run_results = [["Run"], [0], [0], [0]]
trial_results = [["Trial"], [0], [0], [0]]
pass_results = [["Pass"], [0], [1], [2]]
time_step_results = [["Time_step"], [1], [1], [1]]
value_results = ["value", [[3]], [[4.5]], [[5.25]]]
slope_results = ["slope", [6], [6], [6]]
for i in range(4):
assert log_array_T2[0][i] == run_results[i]
assert log_array_T2[1][i] == trial_results[i]
assert log_array_T2[2][i] == pass_results[i]
assert log_array_T2[3][i] == time_step_results[i]
assert log_array_T2[4][i] == value_results[i]
assert log_array_T2[5][i] == slope_results[i]
