def test_four_integrators_mixed(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=1))
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=1))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=1))
D = IntegratorMechanism(name='D',
default_variable=[0],
function=SimpleIntegrator(rate=1))
p = Process(default_variable=[0], pathway=[A, C], name='p')
p1 = Process(default_variable=[0], pathway=[A, D], name='p1')
q = Process(default_variable=[0], pathway=[B, C], name='q')
q1 = Process(default_variable=[0], pathway=[B, D], name='q1')
s = System(processes=[p, p1, q, q1], name='s')
term_conds = {
TimeScale.TRIAL: All(AfterNCalls(C, 1), AfterNCalls(D, 1))
}
stim_list = {A: [[1]], B: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(B, EveryNCalls(A, 2))
sched.add_condition(C, EveryNCalls(A, 1))
sched.add_condition(D, EveryNCalls(B, 1))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
mechs = [A, B, C, D]
expected_output = [
[
numpy.array([2.]),
],
[
numpy.array([1.]),
],
[
numpy.array([4.]),
],
[
numpy.array([3.]),
],
]
for m in range(len(mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(expected_output[m][i],
mechs[m].get_output_values(s)[i])
def test_reset_state_integrator_mechanism(self):
A = IntegratorMechanism(name='A', function=DriftDiffusionIntegrator())
# Execute A twice
# [0] saves decision variable only (not time)
original_output = [A.execute(1.0)[0], A.execute(1.0)[0]]
# SAVING STATE - - - - - - - - - - - - - - - - - - - - - - - - -
reinitialize_values = []
for attr in A.function.stateful_attributes:
reinitialize_values.append(getattr(A.function, attr))
# Execute A twice AFTER saving the state so that it continues accumulating.
# We expect the next two outputs to repeat once we reset the state b/c we will return it to the current state
output_after_saving_state = [A.execute(1.0)[0], A.execute(1.0)[0]]
# RESETTING STATE - - - - - - - - - - - - - - - - - - - - - - - -
A.reinitialize(*reinitialize_values)
# We expect these results to match the results from immediately after saving the state
output_after_reinitialization = [A.execute(1.0)[0], A.execute(1.0)[0]]
assert np.allclose(output_after_saving_state,
output_after_reinitialization)
assert np.allclose(
original_output,
[np.array([[1.0]]), np.array([[2.0]])])
assert np.allclose(
output_after_reinitialization,
[np.array([[3.0]]), np.array([[4.0]])])
def test_fitzHughNagumo_gilzenrat_figure_2(self):
# Isolate the FitzHughNagumo mechanism for testing and recreate figure 2 from the gilzenrat paper
initial_v = 0.2
initial_w = 0.0
F = IntegratorMechanism(name='IntegratorMech-FitzHughNagumoFunction',
function=FitzHughNagumoIntegrator(
initial_v=initial_v,
initial_w=initial_w,
time_step_size=0.01,
time_constant_w=1.0,
time_constant_v=0.01,
a_v=-1.0,
b_v=1.0,
c_v=1.0,
d_v=0.0,
e_v=-1.0,
f_v=1.0,
threshold=0.5,
mode=1.0,
uncorrelated_activity=0.0,
a_w=1.0,
b_w=-1.0,
c_w=0.0))
plot_v_list = [initial_v]
plot_w_list = [initial_w]
# found this stimulus by guess and check b/c one was not provided with Figure 2 params
stimulus = 0.073
# increase range to 200 to match Figure 2 in Gilzenrat
for i in range(10):
results = F.execute(stimulus)
plot_v_list.append(results[0][0][0])
plot_w_list.append(results[1][0][0])
# ** uncomment the lines below if you want to view the plot:
# from matplotlib import pyplot as plt
# plt.plot(plot_v_list)
# plt.plot(plot_w_list)
# plt.show()
np.testing.assert_allclose(plot_v_list, [
0.2, 0.22493312915681499, 0.24840327807265583, 0.27101619694032797,
0.29325863380332173, 0.31556552465130933, 0.33836727470568129,
0.36212868305470697, 0.38738542852040492, 0.41478016676749552,
0.44509530539552955
])
print(plot_w_list)
np.testing.assert_allclose(plot_w_list, [
0.0, 0.0019900332500000003, 0.0042083541185625045,
0.0066381342093118408, 0.009268739886338381, 0.012094486544132229,
0.015114073825358726, 0.018330496914962583, 0.021751346023501487,
0.025389465931011893, 0.029263968140538919
])
def test_four_integrators_mixed(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=1))
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=1))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=1))
D = IntegratorMechanism(name='D',
default_variable=[0],
function=SimpleIntegrator(rate=1))
c = Composition(pathways=[[A, C], [A, D], [B, C], [B, D]])
term_conds = {
TimeScale.TRIAL: All(AfterNCalls(C, 1), AfterNCalls(D, 1))
}
stim_list = {A: [[1]], B: [[1]]}
sched = Scheduler(composition=c)
sched.add_condition(B, EveryNCalls(A, 2))
sched.add_condition(C, EveryNCalls(A, 1))
sched.add_condition(D, EveryNCalls(B, 1))
c.scheduler = sched
c.run(inputs=stim_list, termination_processing=term_conds)
mechs = [A, B, C, D]
expected_output = [
[
numpy.array([2.]),
],
[
numpy.array([1.]),
],
[
numpy.array([4.]),
],
[
numpy.array([3.]),
],
]
for m in range(len(mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(expected_output[m][i],
mechs[m].get_output_values(c)[i])
def test_four_ABBCD(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
D = TransferMechanism(
name='D',
default_variable=[0],
function=Linear(slope=1.0),
)
p = Process(default_variable=[0], pathway=[A, B, D], name='p')
q = Process(default_variable=[0], pathway=[A, C, D], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(D, 1)}
stim_list = {A: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(B, EveryNCalls(A, 1))
sched.add_condition(C, EveryNCalls(A, 2))
sched.add_condition(D, Any(EveryNCalls(B, 3), EveryNCalls(C, 3)))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [D]
expected_output = [
[
numpy.array([4.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i],
terminal_mechs[m].get_output_values(s)[i])
def test_two_AAB(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
B = TransferMechanism(
name='B',
default_variable=[0],
function=Linear(slope=2.0),
)
c = Composition(pathways=[A, B])
term_conds = {TimeScale.TRIAL: AfterNCalls(B, 1)}
stim_list = {A: [[1]]}
sched = Scheduler(composition=c)
sched.add_condition(B, EveryNCalls(A, 2))
c.scheduler = sched
c.run(inputs=stim_list, termination_processing=term_conds)
terminal_mech = B
expected_output = [
numpy.array([2.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(
expected_output[i],
terminal_mech.get_output_values(c)[i])
def test_two_ABB(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
p = Process(default_variable=[0], pathway=[A, B], name='p')
s = System(processes=[p], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(B, 2)}
stim_list = {A: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(A, Any(AtPass(0), AfterNCalls(B, 2)))
sched.add_condition(B, Any(JustRan(A), JustRan(B)))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mech = B
expected_output = [
numpy.array([2.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(
expected_output[i],
terminal_mech.get_output_values(s)[i])
def test_five_ABABCDE(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = TransferMechanism(
name='B',
default_variable=[0],
function=Linear(slope=2.0),
)
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
D = TransferMechanism(
name='D',
default_variable=[0],
function=Linear(slope=1.0),
)
E = TransferMechanism(
name='E',
default_variable=[0],
function=Linear(slope=2.0),
)
c = Composition(pathways=[[A, C, D], [B, C, E]])
term_conds = {TimeScale.TRIAL: AfterNCalls(E, 1)}
stim_list = {A: [[1]], B: [[2]]}
sched = Scheduler(composition=c)
sched.add_condition(C, Any(EveryNCalls(A, 1), EveryNCalls(B, 1)))
sched.add_condition(D, EveryNCalls(C, 1))
sched.add_condition(E, EveryNCalls(C, 1))
c.scheduler = sched
c.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [D, E]
expected_output = [
[
numpy.array([3.]),
],
[
numpy.array([6.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i],
terminal_mechs[m].get_output_values(c)[i])
def test_partial_override_composition(self):
comp = Composition()
A = TransferMechanism(name='scheduler-pytests-A')
B = IntegratorMechanism(name='scheduler-pytests-B')
for m in [A, B]:
comp.add_node(m)
comp.add_projection(MappingProjection(), A, B)
termination_conds = {TimeScale.TRIAL: AfterNCalls(B, 2)}
output = comp.run(inputs={A: 1}, termination_processing=termination_conds)
# two executions of B
assert output == [.75]
def test_termination_conditions_reset(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
B = TransferMechanism(
name='B',
default_variable=[0],
function=Linear(slope=2.0),
)
p = Process(default_variable=[0], pathway=[A, B], name='p')
s = System(processes=[p],
name='s',
reinitialize_mechanisms_when=Never())
term_conds = {TimeScale.TRIAL: AfterNCalls(B, 2)}
stim_list = {A: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(B, EveryNCalls(A, 2))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
# A should run four times
terminal_mech = B
expected_output = [
numpy.array([4.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(
expected_output[i],
terminal_mech.get_output_values(s)[i])
s.run(inputs=stim_list, )
# A should run an additional two times
terminal_mech = B
expected_output = [
numpy.array([6.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(
expected_output[i],
terminal_mech.get_output_values(s)[i])
def test_three_ABAC_convenience(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
B = TransferMechanism(
name='B',
default_variable=[0],
function=Linear(slope=2.0),
)
C = TransferMechanism(
name='C',
default_variable=[0],
function=Linear(slope=2.0),
)
p = Process(default_variable=[0], pathway=[A, B], name='p')
q = Process(default_variable=[0], pathway=[A, C], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(C, 1)}
stim_list = {A: [[1]]}
s.scheduler_processing.add_condition(
B, Any(AtNCalls(A, 1), EveryNCalls(A, 2)))
s.scheduler_processing.add_condition(C, EveryNCalls(A, 2))
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [B, C]
expected_output = [
[
numpy.array([1.]),
],
[
numpy.array([2.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i],
terminal_mechs[m].get_output_values(s)[i])
def test_one_run_twice(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=.5, ))
c = Composition(pathways=[A])
term_conds = {TimeScale.TRIAL: AfterNCalls(A, 2)}
stim_list = {A: [[1]]}
c.run(inputs=stim_list, termination_processing=term_conds)
terminal_mech = A
expected_output = [
numpy.array([1.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(
expected_output[i],
terminal_mech.get_output_values(c)[i])
def test_debug_comp(mode, debug_env):
# save old debug env var
old_env = os.environ.get("PNL_LLVM_DEBUG")
if debug_env is not None:
os.environ["PNL_LLVM_DEBUG"] = debug_env
pnlvm.debug._update()
comp = Composition()
A = IntegratorMechanism(default_variable=1.0, function=Linear(slope=5.0))
B = TransferMechanism(function=Linear(slope=5.0), integrator_mode=True)
comp.add_linear_processing_pathway([A, B])
inputs_dict = {A: [5]}
output1 = comp.run(inputs=inputs_dict, execution_mode=mode)
output2 = comp.run(inputs=inputs_dict, execution_mode=mode)
# restore old debug env var and cleanup the debug configuration
if old_env is None:
del os.environ["PNL_LLVM_DEBUG"]
else:
os.environ["PNL_LLVM_DEBUG"] = old_env
pnlvm.debug._update()
assert len(comp.results) == 2
if "const_input=" in debug_env:
expected1 = 87.5
expected2 = 131.25
elif "const_input" in debug_env:
expected1 = 12.5
expected2 = 18.75
else:
expected1 = 62.5
expected2 = 93.75
if "const_state" in debug_env:
expected2 = expected1
assert np.allclose(expected1, output1[0][0])
assert np.allclose(expected2, output2[0][0])
def test_debug_comp(mode, debug_env):
# save old debug env var
old_env = os.environ.get("PNL_LLVM_DEBUG")
if debug_env is not None:
os.environ["PNL_LLVM_DEBUG"] = debug_env
pnlvm.debug._update()
comp = Composition()
A = IntegratorMechanism(default_variable=1.0, function=Linear(slope=5.0))
B = TransferMechanism(function=Linear(slope=5.0), integrator_mode=True)
comp.add_node(A)
comp.add_node(B)
comp.add_projection(MappingProjection(sender=A, receiver=B), A, B)
sched = Scheduler(composition=comp)
inputs_dict = {A: [5]}
output1 = comp.run(inputs=inputs_dict, scheduler=sched, bin_execute=mode)
output2 = comp.run(inputs=inputs_dict, scheduler=sched, bin_execute=mode)
# restore old debug env var and cleanup the debug configuration
if old_env is None:
del os.environ["PNL_LLVM_DEBUG"]
else:
os.environ["PNL_LLVM_DEBUG"] = old_env
pnlvm.debug._update()
assert len(comp.results) == 2
if "const_input" in debug_env:
expected1 = 87.5
expected2 = 131.25
else:
expected1 = 62.5
expected2 = 93.75
if "const_state" in debug_env:
expected2 = expected1
assert np.allclose(expected1, output1[0][0])
assert np.allclose(expected2, output2[0][0])
def test_six_integrators_threelayer_mixed(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=1))
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=1))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=1))
D = IntegratorMechanism(name='D',
default_variable=[0],
function=SimpleIntegrator(rate=1))
E = IntegratorMechanism(name='E',
default_variable=[0],
function=SimpleIntegrator(rate=1))
F = IntegratorMechanism(name='F',
default_variable=[0],
function=SimpleIntegrator(rate=1))
c = Composition(pathways=[[A, C, E], [A, C, F], [A, D, E], [A, D, F],
[B, C, E], [B, C, F], [B, D, E], [B, D, F]])
term_conds = {
TimeScale.TRIAL: All(AfterNCalls(E, 1), AfterNCalls(F, 1))
}
stim_list = {A: [[1]], B: [[1]]}
sched = Scheduler(composition=c)
sched.add_condition(B, EveryNCalls(A, 2))
sched.add_condition(C, EveryNCalls(A, 1))
sched.add_condition(D, EveryNCalls(B, 1))
sched.add_condition(E, EveryNCalls(C, 1))
sched.add_condition(F, EveryNCalls(D, 2))
c.scheduler = sched
c.run(inputs=stim_list, termination_processing=term_conds)
# Intermediate time steps
#
# 0 1 2 3
#
# A 1 2 3 4
# B 1 2
# C 1 4 8 14
# D 3 9
# E 1 8 19 42
# F 23
#
expected_output = {
A: [
numpy.array([4.]),
],
B: [
numpy.array([2.]),
],
C: [
numpy.array([14.]),
],
D: [
numpy.array([9.]),
],
E: [
numpy.array([42.]),
],
F: [
numpy.array([23.]),
],
}
for m in expected_output:
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(expected_output[m][i],
m.get_output_values(c)[i])
def test_save_state_before_simulations(self):
A = TransferMechanism(name='A',
integrator_mode=True,
integration_rate=0.2)
B = IntegratorMechanism(name='B',
function=DriftDiffusionIntegrator(rate=0.1))
C = TransferMechanism(name='C')
P = Process(pathway=[A, B, C])
S = System(processes=[P], reinitialize_mechanisms_when=Never())
S.run(inputs={A: [[1.0], [1.0]]})
run_1_values = [
A.parameters.value.get(S),
B.parameters.value.get(S)[0],
C.parameters.value.get(S)
]
# "Save state" code from EVCaux
# Get any values that need to be reinitialized for each run
reinitialization_values = {}
for mechanism in S.stateful_mechanisms:
# "save" the current state of each stateful mechanism by storing the values of each of its stateful
# attributes in the reinitialization_values dictionary; this gets passed into run and used to call
# the reinitialize method on each stateful mechanism.
reinitialization_value = []
if isinstance(mechanism.function, IntegratorFunction):
for attr in mechanism.function.stateful_attributes:
reinitialization_value.append(
getattr(mechanism.function.parameters, attr).get(S))
elif hasattr(mechanism, "integrator_function"):
if isinstance(mechanism.integrator_function,
IntegratorFunction):
for attr in mechanism.integrator_function.stateful_attributes:
reinitialization_value.append(
getattr(mechanism.integrator_function.parameters,
attr).get(S))
reinitialization_values[mechanism] = reinitialization_value
# Allow values to continue accumulating so that we can set them back to the saved state
S.run(inputs={A: [[1.0], [1.0]]})
run_2_values = [
A.parameters.value.get(S),
B.parameters.value.get(S)[0],
C.parameters.value.get(S)
]
S.run(inputs={A: [[1.0], [1.0]]},
reinitialize_values=reinitialization_values)
run_3_values = [
A.parameters.value.get(S),
B.parameters.value.get(S)[0],
C.parameters.value.get(S)
]
assert np.allclose(run_2_values, run_3_values)
assert np.allclose(
run_1_values,
[np.array([[0.36]]),
np.array([[0.056]]),
np.array([[0.056]])])
assert np.allclose(run_2_values, [
np.array([[0.5904]]),
np.array([[0.16384]]),
np.array([[0.16384]])
])