def test_configure_learning(self):
o = pnl.TransferMechanism()
m = pnl.ContrastiveHebbianMechanism(input_size=2,
hidden_size=0,
target_size=2,
mode=pnl.SIMPLE_HEBBIAN,
separated=False,
matrix=[[0, -.5], [-.5, 0]])
with pytest.warns(UserWarning) as record:
m.learning_enabled = True
correct_message_found = False
for warning in record:
if ("Learning cannot be enabled" in str(warning.message)
and "because it has no LearningMechanism" in str(
warning.message)):
correct_message_found = True
break
assert correct_message_found
m.configure_learning()
m.reinitialize_when = pnl.Never()
s = pnl.sys(m, o)
ms = pnl.Scheduler(system=s)
ms.add_condition(o, pnl.WhenFinished(m))
s.scheduler_processing = ms
results = s.run(inputs=[2, 2], num_trials=4)
np.testing.assert_allclose(
results,
[[[2.671875]], [[2.84093837]], [[3.0510183]], [[3.35234623]]])
def test_configure_learning(self):
o = pnl.TransferMechanism()
m = pnl.ContrastiveHebbianMechanism(input_size=2,
hidden_size=0,
target_size=2,
mode=pnl.SIMPLE_HEBBIAN,
separated=False,
matrix=[[0, -.5], [-.5, 0]])
regexp = r"Learning cannot be enabled for .* because it has no LearningMechanism"
with pytest.warns(UserWarning, match=regexp):
m.learning_enabled = True
m.configure_learning()
m.reset_stateful_function_when = pnl.Never()
c = pnl.Composition()
c.add_linear_processing_pathway([m, o])
c.scheduler.add_condition(o, pnl.WhenFinished(m))
c.learn(inputs={m: [2, 2]}, num_trials=4)
results = c.parameters.results.get(c)
np.testing.assert_allclose(
results,
[[[2.671875]], [[2.84093837]], [[3.0510183]], [[3.35234623]]])
task_word_response_process_1 = pnl.Pathway(pathway=[
task_input_layer, task_layer, task_word_weights, words_hidden_layer
])
task_word_response_process_2 = pnl.Pathway(
pathway=[words_hidden_layer, word_task_weights, task_layer])
# Create Composition --------------------------------------------------------------------------------------------------
Bidirectional_Stroop = pnl.Composition(
pathways=[
color_response_process_1, word_response_process_1,
task_color_response_process_1, task_word_response_process_1,
color_response_process_2, word_response_process_2,
task_color_response_process_2, task_word_response_process_2
],
reinitialize_mechanisms_when=pnl.Never(),
name='Bidirectional Stroop Model')
input_dict = {
colors_input_layer: [0, 0, 0],
words_input_layer: [0, 0, 0],
task_input_layer: [0, 1]
}
print("\n\n\n\n")
print(Bidirectional_Stroop.run(inputs=input_dict))
for node in Bidirectional_Stroop.mechanisms:
print(node.name, " Value: ", node.get_output_values(Bidirectional_Stroop))
# # LOGGING:
colors_hidden_layer.set_log_conditions('value')
function=pnl.FitzHughNagumoIntegrator(
name='FitzHughNagumoIntegrator Function-0',
d_v=1,
initial_v=-1,
initializer=[[0]],
default_variable=[[0]]))
im = pnl.IntegratorMechanism(name='im',
function=pnl.AdaptiveIntegrator(
initializer=[[0]],
rate=0.5,
default_variable=[[0]]))
comp.add_node(fn)
comp.add_node(im)
comp.add_projection(projection=pnl.MappingProjection(
name='MappingProjection from fn[OutputPort-0] to im[InputPort-0]',
function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[-1.0])),
sender=fn,
receiver=im)
comp.scheduler.add_condition(fn, pnl.Always())
comp.scheduler.add_condition(
im, pnl.All(pnl.EveryNCalls(fn, 20.0), pnl.AfterNCalls(fn, 1600.0)))
comp.scheduler.termination_conds = {
pnl.TimeScale.RUN: pnl.Never(),
pnl.TimeScale.TRIAL: pnl.AfterNCalls(fn, 2000)
}
comp.show_graph()
fn = pnl.IntegratorMechanism(name="fn", function=fhn)
comp = pnl.Composition(name="comp")
im = pnl.IntegratorMechanism(name="im") # only used to demonstrate conditions
comp.add_linear_processing_pathway([fn, im])
comp.scheduler.add_condition_set({
fn:
pnl.TimeInterval(repeat=0.05, unit="ms"),
im:
pnl.TimeInterval(start=80, repeat=1, unit="ms"),
})
comp.termination_processing = {
pnl.TimeScale.RUN: pnl.Never(
), # default, "Never" for early termination - ends when all trials finished
pnl.TimeScale.TRIAL: pnl.TimeTermination(100, unit="ms"),
}
print("Running the SimpleFN model...")
comp.run(inputs={fn: 0},
log=True,
scheduling_mode=pnl.SchedulingMode.EXACT_TIME)
print("\n".join([
"{:~}: {}".format(
comp.scheduler.execution_timestamps[comp.default_execution_id]
[i].absolute,
{node.name
for node in time_step},
)
Stroop_model.add_projection(
projection=pnl.MappingProjection(
name="MappingProjection_from_TASK_RESULT__to_word_hidden_InputPort_0",
function=pnl.LinearMatrix(default_variable=[0.5, 0.5],
matrix=[[0.0, 0.0], [4.0, 4.0]]),
),
sender=TASK,
receiver=word_hidden,
)
Stroop_model.add_controller(CONTROL)
Stroop_model.scheduler.add_condition(word_hidden,
pnl.EveryNCalls(dependency=TASK, n=10))
Stroop_model.scheduler.add_condition(color_hidden,
pnl.EveryNCalls(dependency=TASK, n=10))
Stroop_model.scheduler.add_condition(
OUTPUT,
pnl.All(
pnl.EveryNCalls(dependency=color_hidden, n=1),
pnl.EveryNCalls(dependency=word_hidden, n=1),
),
)
Stroop_model.scheduler.add_condition(DECISION,
pnl.EveryNCalls(dependency=OUTPUT, n=1))
Stroop_model.scheduler.termination_conds = {
pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(),
pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AllHaveRun(),
}
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)
import psyneulink as pnl
comp = pnl.Composition(name='comp')
fn = pnl.IntegratorMechanism(name='fn', function=pnl.FitzHughNagumoIntegrator(name='FitzHughNagumoIntegrator Function-0', d_v=1, initial_v=-1, initializer=[1.0], default_variable=[[0]]))
comp.add_node(fn)
comp.scheduler.add_condition(fn, pnl.Always())
comp.scheduler.termination_conds = {pnl.TimeScale.RUN: pnl.Never(), pnl.TimeScale.TRIAL: pnl.AllHaveRun()}
comp.show_graph()
def test_default_lc_control_mechanism(self):
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,
monitor=[B],
name='LC ObjectiveMechanism'))
for output_state in LC.output_states:
output_state.value *= starting_value_LC
path = [A, B, LC]
S = pnl.Composition()
S.add_node(A, required_roles=pnl.NodeRole.INPUT)
S.add_linear_processing_pathway(pathway=path)
S.add_node(LC, required_roles=pnl.NodeRole.OUTPUT)
LC.reinitialize_when = pnl.Never()
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 = []
A_value = []
B_value = []
LC_value = []
def report_trial(system):
gain_created_by_LC_output_state_1.append(
LC.output_state.parameters.value.get(system)[0])
mod_gain_assigned_to_A.append(A.get_mod_gain(system))
mod_gain_assigned_to_B.append(B.get_mod_gain(system))
base_gain_assigned_to_A.append(A.function.parameters.gain.get())
base_gain_assigned_to_B.append(B.function.parameters.gain.get())
A_value.append(A.parameters.value.get(system))
B_value.append(B.parameters.value.get(system))
LC_value.append(LC.parameters.value.get(system))
result = S.run(inputs={A: [[1.0], [1.0], [1.0], [1.0], [1.0]]},
call_after_trial=functools.partial(report_trial, S))
# (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)
def test_lc_control_mechanism_as_controller(self, benchmark, mode):
G = 1.0
k = 0.5
starting_value_LC = 2.0
user_specified_gain = 1.0
A = pnl.TransferMechanism(
function=psyneulink.core.components.functions.transferfunctions.
Logistic(gain=user_specified_gain),
name='A')
B = pnl.TransferMechanism(
function=psyneulink.core.components.functions.transferfunctions.
Logistic(gain=user_specified_gain),
name='B')
C = pnl.Composition()
LC = pnl.LCControlMechanism(modulated_mechanisms=[A, B],
base_level_gain=G,
scaling_factor_gain=k,
objective_mechanism=pnl.ObjectiveMechanism(
function=psyneulink.core.components.
functions.transferfunctions.Linear,
monitor=[B],
name='LC ObjectiveMechanism'))
C.add_linear_processing_pathway([A, B])
C.add_controller(LC)
for output_port in LC.output_ports:
output_port.parameters.value.set(output_port.value *
starting_value_LC,
C,
override=True)
LC.reset_stateful_function_when = pnl.Never()
gain_created_by_LC_output_port_1 = []
mod_gain_assigned_to_A = []
base_gain_assigned_to_A = []
mod_gain_assigned_to_B = []
base_gain_assigned_to_B = []
def report_trial(composition):
from psyneulink import parse_context
context = parse_context(composition)
gain_created_by_LC_output_port_1.append(
LC.output_ports[0].parameters.value.get(context))
mod_gain_assigned_to_A.append([A.get_mod_gain(composition)])
mod_gain_assigned_to_B.append([B.get_mod_gain(composition)])
base_gain_assigned_to_A.append(A.function.gain)
base_gain_assigned_to_B.append(B.function.gain)
C._analyze_graph()
benchmark(C.run,
inputs={A: [[1.0], [1.0], [1.0], [1.0], [1.0]]},
call_after_trial=functools.partial(report_trial, C))
# (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_port_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)
fn,
pnl.TimeInterval(
repeat="50 microsecond",
start=None,
end=None,
unit="ms",
start_inclusive=True,
end_inclusive=True,
),
)
comp.scheduler.add_condition(
im,
pnl.TimeInterval(
repeat="1 millisecond",
start="80 millisecond",
end=None,
unit="ms",
start_inclusive=True,
end_inclusive=True,
),
)
comp.scheduler.termination_conds = {
pnl.TimeScale.ENVIRONMENT_SEQUENCE:
pnl.Never(),
pnl.TimeScale.ENVIRONMENT_STATE_UPDATE:
pnl.TimeTermination(t="100 millisecond",
inclusive=True,
unit="millisecond"),
}
