def test_alias_duplicate_base_access_fails(self):
mech = pnl.LCAMechanism(function=pnl.ReLU)
with pytest.raises(
pnl.ParameterPortError,
match='Did you want leak-function or rate'
):
mech.parameter_ports['leak']
def test_alias_duplicate(self):
mech = pnl.LCAMechanism(function=pnl.ReLU)
assert mech.parameter_ports[
'leak-function'].source is mech.function.parameters.leak
assert mech.parameter_ports[
'leak-integrator_function'] is mech.parameter_ports[
'integration_rate']
assert mech.parameter_ports[
'leak-integrator_function'].source is mech.integrator_function.parameters.rate
def test_log_multi_calls_single_timestep(self, scheduler_conditions, multi_run):
con_with_rpc_pipeline = pnl.Context(rpc_pipeline=Queue())
pipeline = con_with_rpc_pipeline.rpc_pipeline
lca = pnl.LCAMechanism(
size=2,
leak=0.5,
threshold=0.515,
reset_stateful_function_when=pnl.AtTrialStart()
)
lca.set_delivery_conditions(pnl.VALUE)
m0 = pnl.ProcessingMechanism(
size=2
)
comp = pnl.Composition()
comp.add_linear_processing_pathway([m0, lca])
if scheduler_conditions:
comp.scheduler.add_condition(lca, pnl.AfterNCalls(m0, 2))
comp.run(inputs={m0: [[1, 0], [1, 0], [1, 0]]}, context=con_with_rpc_pipeline)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
integration_end_dict = {i.time: i for i in actual}
if scheduler_conditions:
expected_times = ['0:0:1:1', '0:1:1:1', '0:2:1:1']
else:
expected_times = ['0:0:0:1', '0:1:0:1', '0:2:0:1']
assert list(integration_end_dict.keys()) == expected_times
vals = [i.value.data for i in integration_end_dict.values()]
# floats in value, so use np.allclose
assert np.allclose(vals, [[[0.52466739, 0.47533261]] * 3])
if multi_run:
comp.run(inputs={m0: [[1, 0], [1, 0], [1, 0]]}, context=con_with_rpc_pipeline)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
integration_end_dict.update({i.time: i for i in actual})
if scheduler_conditions:
expected_times = ['0:0:1:1', '0:1:1:1', '0:2:1:1', '1:0:1:1', '1:1:1:1', '1:2:1:1']
else:
expected_times = ['0:0:0:1', '0:1:0:1', '0:2:0:1', '1:0:0:1', '1:1:0:1', '1:2:0:1']
assert list(integration_end_dict.keys()) == expected_times
vals = [i.value.data for i in integration_end_dict.values()]
# floats in value, so use np.allclose
assert np.allclose(vals, [[[0.52466739, 0.47533261]] * 6])
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]],
name='WORD HIDDEN TO OUTPUT')
size=1,
function=pnl.Linear(slope=1, intercept=0),
output_ports=[pnl.RESULT],
name='Cue-Stimulus Interval')
taskLayer = pnl.TransferMechanism(default_variable=[[0.0, 0.0]],
size=2,
function=pnl.Linear(slope=1, intercept=0),
output_ports=[pnl.RESULT],
name='Task Input [I1, I2]')
activation = pnl.LCAMechanism(default_variable=[[0.0, 0.0]],
size=2,
function=pnl.Logistic(gain=1),
leak=.5,
competition=2,
noise=0,
time_step_size=.1,
termination_measure=pnl.TimeScale.TRIAL,
termination_threshold=3,
name='Task Activations [Act 1, Act 2]')
# response = pnl.ProcessingMechanism()
# Create controller
csiController = pnl.ControlMechanism(monitor_for_control=cueInterval,
control_signals=[
(pnl.TERMINATION_THRESHOLD,
activation)
],
modulation=pnl.OVERRIDE)
def get_trained_network(bipartite_graph, num_features=3, num_hidden=200, epochs=10, learning_rate=20, attach_LCA=True, competition=0.2, self_excitation=0.2, leak=0.4, threshold=1e-4):
# Get all tasks from bipartite graph (edges) and strip 'i/o' suffix
all_tasks = get_all_tasks(bipartite_graph)
# Analyze bipartite graph for network properties
onodes = [ n for n, d in bipartite_graph.nodes(data=True) if d['bipartite'] == 0 ]
inodes = [ n for n, d in bipartite_graph.nodes(data=True) if d['bipartite'] == 1 ]
input_dims = len(inodes)
output_dims = len(onodes)
num_tasks = len(all_tasks)
# Start building network as PsyNeuLink object
# Layer parameters
nh = num_hidden
D_i = num_features * input_dims
D_c = num_tasks
D_h = nh
D_o = num_features * output_dims
# Weight matrices (defaults provided by Dillon)
wih = np.random.rand(D_i, D_h) * 0.02 - 0.01
wch = np.random.rand(D_c, D_h) * 0.02 - 0.01
wco = np.random.rand(D_c, D_o) * 0.02 - 0.01
who = np.random.rand(D_h, D_o) * 0.02 - 0.01
# Training params (defaults provided by Dillon)
patience = 10
min_delt = 0.00001
lr = learning_rate
# Instantiate layers and projections
il = pnl.TransferMechanism(size=D_i, name='input')
cl = pnl.TransferMechanism(size=D_c, name='control')
hl = pnl.TransferMechanism(size=D_h, name='hidden',
function=pnl.Logistic(bias=-2))
ol = pnl.TransferMechanism(size=D_o, name='output',
function=pnl.Logistic(bias=-2))
pih = pnl.MappingProjection(matrix=wih)
pch = pnl.MappingProjection(matrix=wch)
pco = pnl.MappingProjection(matrix=wco)
pho = pnl.MappingProjection(matrix=who)
# Create training data for network
# We train across all possible inputs, one task at a time
input_examples, output_examples, control_examples = generate_training_data(all_tasks, num_features, input_dims, output_dims)
# Training parameter set
input_set = {
'inputs': {
il: input_examples.tolist(),
cl: control_examples.tolist()
},
'targets': {
ol: output_examples.tolist()
},
'epochs': epochs
}
mnet = pnl.AutodiffComposition(learning_rate=learning_rate,
name='mnet')
mnet.output_CIM.parameters.value._set_history_max_length(100000)
mnet.add_node(il)
mnet.add_node(cl)
mnet.add_node(hl)
mnet.add_node(ol)
mnet.add_projection(projection=pih, sender=il, receiver=hl)
mnet.add_projection(projection=pch, sender=cl, receiver=hl)
mnet.add_projection(projection=pco, sender=cl, receiver=ol)
mnet.add_projection(projection=pho, sender=hl, receiver=ol)
# Train network
print("training 1")
t1 = time.time()
mnet.learn(
inputs=input_set,
minibatch_size=1,
bin_execute=MNET_BIN_EXECUTE,
patience=patience,
min_delta=min_delt,
)
t2 = time.time()
print("training 1:", MNET_BIN_EXECUTE, t2-t1)
# Apply LCA transform (values from Sebastian's code -- supposedly taken from the original LCA paper from Marius & Jay)
if attach_LCA:
lca = pnl.LCAMechanism(size=D_o,
leak=leak,
competition=competition,
self_excitation=self_excitation,
time_step_size=0.01,
threshold=threshold,
threshold_criterion=pnl.CONVERGENCE,
reset_stateful_function_when=pnl.AtTrialStart(),
name='lca')
# Wrapper composition used to pass values between mnet (AutodiffComposition) and lca (LCAMechanism)
wrapper_composition = pnl.Composition()
# Add mnet and lca to outer_composition
wrapper_composition.add_linear_processing_pathway([mnet, lca])
return wrapper_composition
return mnet
def test_alias_unique(self):
mech = pnl.LCAMechanism()
assert mech.parameter_ports['leak'] is mech.parameter_ports[
'integration_rate']
# Input Layer --- [ Target 1, Target 2, Distractor ]
# First, we create the 3 layers of the behavioral network, i.e. INPUT LAYER, DECISION LAYER, and RESPONSE LAYER.
input_layer = pnl.TransferMechanism(
size=3, # Number of units in input layer
initial_value=[[0.0, 0.0, 0.0]], # Initial input values
name='INPUT LAYER' # Define the name of the layer; this is optional,
) # but will help you to overview your model later on
# Create Decision Layer --- [ Target 1, Target 2, Distractor ]
decision_layer = pnl.LCAMechanism(
size=3, # Number of units in input layer
initial_value=[[0.0, 0.0, 0.0]], # Initial input values
time_step_size=dt, # Integration step size
leak=-1.0, # Sets off diagonals to negative values
self_excitation=selfdwt, # Set diagonals to self excitate
competition=inhwt, # Set off diagonals to inhibit
function=psyneulink.core.components.functions.transferfunctions.Logistic(x_0=decbias), # Set the Logistic function with bias = decbias
# noise=pnl.UniformToNormalDist(standard_deviation = SD).function, # The UniformToNormalDist function will
integrator_mode=True, # set the noise with a seed generator that is compatible with
name='DECISION LAYER' # MATLAB random seed generator 22 (rsg=22)
)
# decision_layer.set_log_conditions('RESULT') # Log RESULT of the decision layer
decision_layer.set_log_conditions('value') # Log value of the decision layer
for output_state in decision_layer.output_states:
output_state.value *= 0.0 # Set initial output values for decision layer to 0
# Create Response Layer --- [ Target1, Target2 ]
response_layer = pnl.LCAMechanism(
size=2, # Number of units in input layer
# Create mechanisms ---------------------------------------------------------------------------------------------------
# Input Layer --- [ Target, Distractor ]
input_layer = pnl.TransferMechanism(size=2,
initial_value=np.array([[0.0, 0.0]]),
name='INPUT LAYER')
# Create Decision Layer --- [ Target, Distractor ]
decision_layer = pnl.LCAMechanism(
size=2,
time_step_size=dt,
leak=-1.0,
self_excitation=w_XiXi,
competition=w_XiXj,
# Recurrent matrix: [ w_XiXi -w_XiXj ]
# [ -w_XiXj w_XiXi ]
function=psyneulink.core.components.functions.transferfunctions.Logistic(
x_0=b_decision),
noise=psyneulink.core.components.functions.distributionfunctions.
NormalDist(standard_deviation=SD).function,
integrator_mode=True,
name='DECISION LAYER')
# Create Response Layer --- [ Target ]
response_layer = pnl.LCAMechanism(
size=1,
time_step_size=dt,
leak=-1.0,
self_excitation=w_X3X3,
# Recurrent matrix: [w_X3X3]
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)
)
decision_process = pnl.Process(pathway=[input_layer, decision_layer])
optimization_system = pnl.System(processes=[decision_process],
monitor_for_control=[decision_layer.output_states[pnl.RESULT]])
# ADD COMPARATOR MECHANISM FOR ACCURACY DETERMINATION
# EVC PARAMS:
# - number of simulations to run per LCAMechanism
# - which inputs to provide (i.e., *NOT* using typical PredictionMechanisms)
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()
def get_stroop_model(unit_noise_std=.01, dec_noise_std=.1):
# model params
# TODO bad practice, to be moved
hidden_func = pnl.Logistic(gain=1.0, x_0=4.0)
integration_rate = .2
leak = 0
competition = 1
# input layer, color and word
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,
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,
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,
name='OUTPUT')
# decision layer, some accumulator
decision = pnl.LCAMechanism(
size=N_UNITS,
leak=leak,
competition=competition,
# MAX_VS_NEXT=lca_mvn,
noise=pnl.UniformToNormalDist(
standard_deviation=dec_noise_std).function,
name='DECISION')
# 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(inp_clr)
model.add_node(inp_wrd)
model.add_node(hid_clr)
model.add_node(hid_wrd)
model.add_node(inp_task)
model.add_node(output)
model.add_node(decision)
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])
# # LOGGING
# hid_clr.set_log_conditions('value')
# hid_wrd.set_log_conditions('value')
# output.set_log_conditions('value')
# collect the node handles
nodes = [inp_clr, inp_wrd, inp_task, hid_clr, hid_wrd, output, decision]
metadata = [integration_rate, dec_noise_std, unit_noise_std]
return model, nodes, metadata
name="word_hidden",
function=pnl.Logistic(bias=-4.0, default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
task_input = pnl.ProcessingMechanism(
name="task_input",
function=pnl.Linear(default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
TASK = pnl.LCAMechanism(
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]),
word_input_to_hidden_wts = np.array([[3, -3], [-3, 3]])
word_hidden = pnl.ProcessingMechanism(
name="word_hidden", size=2, function=pnl.Logistic(bias=-4)
)
word_hidden_to_output_wts = np.array([[3, -3], [-3, 3]])
word_pathway = [
word_input,
word_input_to_hidden_wts,
word_hidden,
word_hidden_to_output_wts,
output,
]
# Construct the task specification pathways
task_input = pnl.ProcessingMechanism(name="task_input", size=2)
task = pnl.LCAMechanism(name="TASK", size=2, initial_value=[0.5, 0.5])
task_color_wts = np.array([[4, 4], [0, 0]])
task_word_wts = np.array([[0, 0], [4, 4]])
task_color_pathway = [task_input, task, task_color_wts, color_hidden]
task_word_pathway = [task_input, task, task_word_wts, word_hidden]
# Construct the decision pathway:
decision = pnl.DDM(name="DECISION", input_format=pnl.ARRAY)
decision_pathway = [output, decision]
# Construct control mechanism
control = pnl.ControlMechanism(
name="CONTROL",
objective_mechanism=pnl.ObjectiveMechanism(
name="Conflict Monitor",
function=pnl.Energy(size=2, matrix=[[0, -2.5], [-2.5, 0]]),
default_variable=[[0.0, 0.0]],
)
word_hidden = pnl.ProcessingMechanism(
name="word_hidden",
function=pnl.Logistic(bias=-4, default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
task_input = pnl.ProcessingMechanism(
name="task_input",
function=pnl.Linear(default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
TASK = pnl.LCAMechanism(
name="TASK",
function=pnl.Logistic(default_variable=[[0.0, 0.0]]),
initial_value=[[0.5, 0.5]],
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.FUNCTION: pnl.Reduce(
default_variable=[[0.0, 0.0]], weights=[1, -1]
),
pnl.NAME: pnl.ARRAY,
pnl.VARIABLE: [[0.0, 0.0]],
}
],
