def test_detection_of_illegal_arg_in_kwargs(self):
with pytest.raises(pnl.ComponentError) as error_text:
pnl.ProcessingMechanism(flim_flam=1)
assert "Unrecognized argument in constructor for ProcessingMechanism-0 (type: ProcessingMechanism): 'flim_flam'"
def test_detection_of_illegal_args_in_kwargs(self):
with pytest.raises(pnl.ComponentError) as error_text:
pnl.ProcessingMechanism(name='MY_MECH', flim_flam=1, grumblabble=2)
assert "Unrecognized arguments in constructor for MY_MECH (type: ProcessingMechanism): 'flim_flam, grumblabble'"
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')
r_step = pnl.ProcessingMechanism(size=10, function=step, name='REP_STEP')
p_step = pnl.ProcessingMechanism(size=12, function=step, name='PROP_STEP')
q_step = pnl.ProcessingMechanism(size=13, function=step, name='QUAL_STEP')
a_step = pnl.ProcessingMechanism(size=14, function=step, name='ACT_STEP')
#Processes that comprise the System:
# NOTE: this is one of several configuration of processes that can be used to construct the full network
# (see Test/learning/test_rumelhart_semantic_network.py for other configurations)
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,
v[0] = output of DDM: [probability of color naming, probability of word reading]
v[1] = reward: [color naming rewarded, word reading rewarded]
'''
prob_upper = v[0]
prob_lower = v[1]
reward_upper = v[2][0]
reward_lower = v[2][1]
return prob_upper * reward_upper + prob_lower * reward_lower
# return np.sum(v[0] * v[1])
color_stim = pnl.TransferMechanism(name='Color Stimulus', size=8)
word_stim = pnl.TransferMechanism(name='Word Stimulus', size=8)
color_task = pnl.TransferMechanism(name='Color Task')
word_task = pnl.ProcessingMechanism(name='Word Task', function=w_fct_UDF)
reward = pnl.TransferMechanism(name='Reward', size=2)
task_decision = pnl.DDM(
name='Task Decision',
# function=pnl.NavarroAndFuss,
output_states=[
pnl.DDM_OUTPUT.PROBABILITY_UPPER_THRESHOLD,
pnl.DDM_OUTPUT.PROBABILITY_LOWER_THRESHOLD
])
task_decision.set_log_conditions('func_drift_rate')
task_decision.set_log_conditions('mod_drift_rate')
task_decision.set_log_conditions('PROBABILITY_LOWER_THRESHOLD')
task_decision.set_log_conditions('PROBABILITY_UPPER_THRESHOLD')
import psyneulink as pnl
import psyneulink.core.components.functions.transferfunctions
# Construct the Mechanisms:
input_layer = pnl.ProcessingMechanism(name='InputLayer', size=5)
hidden_layer = pnl.ProcessingMechanism(size=2, function=pnl.Logistic)
output_layer = pnl.ProcessingMechanism(size=5, function=pnl.Logistic)
# Construct the Composition:
my_encoder = pnl.Composition()
my_encoder.add_linear_processing_pathway(
[input_layer, hidden_layer, output_layer])
print(my_encoder)
#my_encoder.show_graph(show_controller=True)
print(input_layer.json_summary)
print('Done!')
import psyneulink as pnl
A = pnl.ProcessingMechanism(name='A')
B = pnl.ProcessingMechanism(name='B')
C = pnl.ProcessingMechanism(name='C')
D = pnl.ProcessingMechanism(name='D')
E = pnl.ProcessingMechanism(name='E')
comp = pnl.Composition()
comp.add_backpropagation_learning_pathway(pathway=[A, D, E])
comp.add_backpropagation_learning_pathway(pathway=[A, B, C])
print_experiments(block, experiments)
# GENERATE MODEL INPUTS FROM EXPERIMENT SEQUENCE
colorInputSequence = np.multiply(np.asarray(experiments[0]["color coherence"]).astype(float), np.asarray(experiments[0]["correct color response"]).astype(float))
motionInputSequence = np.multiply(np.asarray(experiments[0]["motion coherence"]).astype(float), np.asarray(experiments[0]["correct motion response"]).astype(float))
# BUILD PSYNEULINK MODEL
print("SIMULATING EXPERIMENT WITH PSYNEULINK MODEL...")
optimal_color_control = 0.69
optimal_motion_control = 0.18
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,
def test_get_output_values_prop(self):
A = pnl.ProcessingMechanism()
c = pnl.Composition()
c.add_node(A)
result = c.run(inputs={A: [1]}, num_trials=2)
assert result == c.output_values == [np.array([1])]
import psyneulink as pnl
Stroop_model = pnl.Composition(name="Stroop_model")
color_input = pnl.ProcessingMechanism(
name="color_input",
function=pnl.Linear(default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
color_hidden = pnl.ProcessingMechanism(
name="color_hidden",
function=pnl.Logistic(bias=-4.0, default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
OUTPUT = pnl.ProcessingMechanism(
name="OUTPUT",
function=pnl.Logistic(default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
word_input = pnl.ProcessingMechanism(
name="word_input",
function=pnl.Linear(default_variable=[[0.0, 0.0]]),
default_variable=[[0.0, 0.0]],
)
word_hidden = pnl.ProcessingMechanism(
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",
import psyneulink as pnl
#my_encoder.show_graph(show_controller=True)
lin = pnl.Linear(slope=3)
lin.name='TripleTheNumber'
print (lin.json_summary)
print (dir(lin))
print(lin.execute(5))
adder = pnl.ProcessingMechanism(name='Tripler',size=2,function=lin)
print(adder)
print(adder.execute([1,2]))
#print (adder.json_summary)
print('Done!')
import psyneulink as pnl
import numpy as np
# CONSTRUCT THE MODEL ***********************************
# Construct the color naming pathway:
color_input = pnl.ProcessingMechanism(
name="color_input", size=2
) # Note: default function is Linear
color_input_to_hidden_wts = np.array([[2, -2], [-2, 2]])
color_hidden = pnl.ProcessingMechanism(
name="color_hidden", size=2, function=pnl.Logistic(bias=-4)
)
color_hidden_to_output_wts = np.array([[2, -2], [-2, 2]])
output = pnl.ProcessingMechanism(name="OUTPUT", size=2, function=pnl.Logistic)
color_pathway = [
color_input,
color_input_to_hidden_wts,
color_hidden,
color_hidden_to_output_wts,
output,
]
# Construct the word reading pathway (using the same output_layer)
word_input = pnl.ProcessingMechanism(name="word_input", size=2)
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 = [
def test_control_signal_default_allocation_specification(self):
m1 = pnl.ProcessingMechanism()
m2 = pnl.ProcessingMechanism()
m3 = pnl.ProcessingMechanism()
# default_allocation not specified in constructor of pnl.ControlMechanism,
# so should be set to defaultControlAllocation (=[1]) if not specified in pnl.ControlSignal constructor
c1 = pnl.ControlMechanism(
name='C1',
default_variable=[10],
control_signals=[
pnl.ControlSignal(modulates=(
pnl.SLOPE,
m1)), # test for assignment to defaultControlAllocation
pnl.ControlSignal(
default_allocation=2, # test for scalar assignment
modulates=(pnl.SLOPE, m2)),
pnl.ControlSignal(
default_allocation=[3], # test for array assignment
modulates=(pnl.SLOPE, m3))
])
comp = pnl.Composition()
comp.add_nodes([m1, m2, m3])
comp.add_controller(c1)
assert c1.control_signals[0].value == [
10
] # defaultControlAllocation should be assigned
# (as no default_allocation from pnl.ControlMechanism)
assert m1.parameter_ports[pnl.SLOPE].value == [1]
assert c1.control_signals[1].value == [
2
] # default_allocation from pnl.ControlSignal (converted scalar)
assert m2.parameter_ports[pnl.SLOPE].value == [1]
assert c1.control_signals[2].value == [
3
] # default_allocation from pnl.ControlSignal
assert m3.parameter_ports[pnl.SLOPE].value == [1]
result = comp.run(inputs={m1: [2], m2: [3], m3: [4]})
assert np.allclose(result, [[20.], [6.], [12.]])
assert c1.control_signals[0].value == [10]
assert m1.parameter_ports[pnl.SLOPE].value == [10]
assert c1.control_signals[1].value == [10]
assert m2.parameter_ports[pnl.SLOPE].value == [2]
assert c1.control_signals[2].value == [10]
assert m3.parameter_ports[pnl.SLOPE].value == [3]
result = comp.run(inputs={m1: [2], m2: [3], m3: [4]})
assert np.allclose(result, [[20.], [30.], [40.]])
assert c1.control_signals[0].value == [10]
assert m1.parameter_ports[pnl.SLOPE].value == [10]
assert c1.control_signals[1].value == [10]
assert m2.parameter_ports[pnl.SLOPE].value == [10]
assert c1.control_signals[2].value == [10]
assert m3.parameter_ports[pnl.SLOPE].value == [10]
# default_allocation *is* specified in constructor of pnl.ControlMechanism,
# so should be used unless specified in pnl.ControlSignal constructor
c2 = pnl.ControlMechanism(
name='C3',
default_variable=[10],
default_allocation=[4],
control_signals=[
pnl.ControlSignal(modulates=(
pnl.SLOPE,
m1)), # tests for assignment to default_allocation
pnl.ControlSignal(
default_allocation=
5, # tests for override of default_allocation
modulates=(pnl.SLOPE, m2)),
pnl.ControlSignal(
default_allocation=[6], # as above same but with array
modulates=(pnl.SLOPE, m3))
])
comp = pnl.Composition()
comp.add_nodes([m1, m2, m3])
comp.add_controller(c2)
assert c2.control_signals[0].value == [
4
] # default_allocation from pnl.ControlMechanism assigned
assert m1.parameter_ports[pnl.SLOPE].value == [
10
] # has not yet received pnl.ControlSignal value
assert c2.control_signals[1].value == [
5
] # default_allocation from pnl.ControlSignal assigned (converted scalar)
assert m2.parameter_ports[pnl.SLOPE].value == [10]
assert c2.control_signals[2].value == [
6
] # default_allocation from pnl.ControlSignal assigned
assert m3.parameter_ports[pnl.SLOPE].value == [10]
result = comp.run(inputs={m1: [2], m2: [3], m3: [4]})
assert np.allclose(result, [[8.], [15.], [24.]])
assert c2.control_signals[0].value == [10]
assert m1.parameter_ports[pnl.SLOPE].value == [4]
assert c2.control_signals[1].value == [10]
assert m2.parameter_ports[pnl.SLOPE].value == [5]
assert c2.control_signals[2].value == [10]
assert m3.parameter_ports[pnl.SLOPE].value == [6]
result = comp.run(inputs={m1: [2], m2: [3], m3: [4]})
assert np.allclose(result, [[20.], [30.], [40.]])
assert c2.control_signals[0].value == [10]
assert m1.parameter_ports[pnl.SLOPE].value == [10]
assert c2.control_signals[1].value == [10]
assert m2.parameter_ports[pnl.SLOPE].value == [10]
assert c2.control_signals[2].value == [10]
assert m3.parameter_ports[pnl.SLOPE].value == [10]
return (out)
# In[19]:
Step = pnl.UserDefinedFunction(custom_function=step,
default_variable=np.zeros(4))
# In[20]:
#we're on the part where we generalize this and apply it as the function for all the bins...
#we'd like to generalize this for size so we can consistently just call the one UDF, but specifying size, to remove
#redundancies and general clutter. lol
step_mech = pnl.ProcessingMechanism(function=pnl.UserDefinedFunction(
custom_function=step, default_variable=np.zeros(4)),
size=4,
name='step_mech')
# In[21]:
nouns_in = pnl.TransferMechanism(name="nouns_input",
default_variable=np.zeros(r_1))
rels_in = pnl.TransferMechanism(name="rels_input",
default_variable=np.zeros(r_2))
h1 = pnl.TransferMechanism(name="hidden_nouns", size=8, function=pnl.Logistic)
h2 = pnl.TransferMechanism(name="hidden_mixed", size=15, function=pnl.Logistic)
out_sig_I = pnl.TransferMechanism(name="sig_outs_I",
