def cyclic_extended_loop(self):
a = TransferMechanism(name='a', default_variable=[0, 0])
b = TransferMechanism(name='b')
c = TransferMechanism(name='c')
d = TransferMechanism(name='d')
e = TransferMechanism(name='e', default_variable=[0])
f = TransferMechanism(name='f')
p1 = Process(pathway=[a, b, c, d], name='p1')
p2 = Process(pathway=[e, c, f, b, d], name='p2')
s = System(
processes=[p1, p2],
name='Cyclic System with Extended Loop',
initial_values={a: [1, 1]},
)
inputs = {a: [2, 2], e: [0]}
s.run(inputs=inputs)
assert set([a, c]) == set(s.origin_mechanisms.mechanisms)
assert [d] == s.terminal_mechanisms.mechanisms
assert a.systems[s] == ORIGIN
assert b.systems[s] == CYCLE
assert c.systems[s] == INTERNAL
assert d.systems[s] == TERMINAL
assert e.systems[s] == ORIGIN
assert f.systems[s] == INITIALIZE_CYCLE
def test_2_target_mechanisms_fn_spec(self):
A = TransferMechanism(name="learning-process-mech-A")
B = TransferMechanism(name="learning-process-mech-B")
C = TransferMechanism(name="learning-process-mech-C")
LP = Process(name="learning-process", pathway=[A, B], learning=ENABLED)
LP2 = Process(name="learning-process2",
pathway=[A, C],
learning=ENABLED)
S = System(
name="learning-system",
processes=[LP, LP2],
)
def target_function():
val_1 = NormalDist(mean=3.0)()
val_2 = NormalDist(mean=3.0)()
return [val_1, val_2]
with pytest.raises(RunError) as error_text:
S.run(inputs={A: [[[1.0]]]}, targets=target_function)
assert 'Target values for' in str(error_text.value) and \
'must be specified in a dictionary' in str(error_text.value)
def test_converging_pathways(self):
a = TransferMechanism(name="a",
default_variable=[0, 0, 0])
b = TransferMechanism(name="b")
c = TransferMechanism(name="c",
default_variable=[0, 0, 0, 0, 0])
LC = LCControlMechanism(modulated_mechanisms=[a,b],
objective_mechanism=ObjectiveMechanism(function=Linear,
monitor=[b],
name='lc_om'),
name="lc"
)
p = Process(name="p",
pathway=[a, c])
p2 = Process(name="p2",
pathway=[b, c])
s = System(name="s",
processes=[p, p2])
a_label = s._get_label(a, ALL)
b_label = s._get_label(b, ALL)
c_label = s._get_label(c, ALL)
assert "out (3)" in a_label and "in (3)" in a_label
assert "out (1)" in b_label and "in (1)" in b_label
assert "out (5)" in c_label and "in (5)" in c_label
def test_dict_list_and_function(self):
A = TransferMechanism(name="diverging-learning-pathways-mech-A")
B = TransferMechanism(name="diverging-learning-pathways-mech-B")
C = TransferMechanism(name="diverging-learning-pathways-mech-C")
D = TransferMechanism(name="diverging-learning-pathways-mech-D")
E = TransferMechanism(name="diverging-learning-pathways-mech-E")
P1 = Process(name="learning-pathway-1",
pathway=[A, B, C],
learning=ENABLED)
P2 = Process(name="learning-pathway-2",
pathway=[A, D, E],
learning=ENABLED)
S = System(name="learning-system", processes=[P1, P2])
def target_function():
val_1 = NormalDist(mean=3.0)()
return val_1
S.run(inputs={A: 1.0}, targets={C: 2.0, E: target_function})
S.run(inputs={A: 1.0}, targets={C: [2.0], E: target_function})
S.run(inputs={A: 1.0}, targets={C: [[2.0]], E: target_function})
def test_bypass(self):
a = TransferMechanism(name='a', default_variable=[0, 0])
b = TransferMechanism(name='b', default_variable=[0, 0])
c = TransferMechanism(name='c')
d = TransferMechanism(name='d')
p1 = Process(pathway=[a, b, c, d], name='p1')
p2 = Process(pathway=[a, b, d], name='p2')
s = System(
processes=[p1, p2],
name='Bypass System',
initial_values={a: [1, 1]},
)
inputs = {a: [[2, 2], [0, 0]]}
s.run(inputs=inputs)
assert [a] == s.origin_mechanisms.mechanisms
assert [d] == s.terminal_mechanisms.mechanisms
assert a.systems[s] == ORIGIN
assert b.systems[s] == INTERNAL
assert c.systems[s] == INTERNAL
assert d.systems[s] == TERMINAL
def test_convergent(self):
a = TransferMechanism(name='a', default_variable=[0, 0])
b = TransferMechanism(name='b')
c = TransferMechanism(name='c')
c = TransferMechanism(name='c', default_variable=[0])
d = TransferMechanism(name='d')
e = TransferMechanism(name='e')
p1 = Process(pathway=[a, b, e], name='p1')
p2 = Process(pathway=[c, d, e], name='p2')
s = System(
processes=[p1, p2],
name='Convergent System',
initial_values={a: [1, 1]},
)
inputs = {a: [[2, 2]], c: [[0]]}
s.run(inputs=inputs)
assert set([a, c]) == set(s.origin_mechanisms.mechanisms)
assert [e] == s.terminal_mechanisms.mechanisms
assert a.systems[s] == ORIGIN
assert b.systems[s] == INTERNAL
assert c.systems[s] == ORIGIN
assert d.systems[s] == INTERNAL
assert e.systems[s] == TERMINAL
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_DDM():
myMechanism = DDM(
function=DriftDiffusionAnalytical(
drift_rate=(1.0),
threshold=(10.0),
starting_point=0.0,
),
name='My_DDM',
)
myMechanism_2 = DDM(function=DriftDiffusionAnalytical(drift_rate=2.0,
threshold=20.0),
name='My_DDM_2')
myMechanism_3 = DDM(
function=DriftDiffusionAnalytical(drift_rate=3.0, threshold=30.0),
name='My_DDM_3',
)
z = Process(
default_variable=[[30], [10]],
pathway=[
myMechanism, (IDENTITY_MATRIX), myMechanism_2,
(FULL_CONNECTIVITY_MATRIX), myMechanism_3
],
)
result = z.execute([[30], [10]])
expected_output = [
(myMechanism.input_states[0].parameters.value.get(z), np.array([40.])),
(myMechanism.output_states[0].parameters.value.get(z), np.array([10.
])),
(myMechanism_2.input_states[0].parameters.value.get(z), np.array([10.
])),
(myMechanism_2.output_states[0].parameters.value.get(z),
np.array([20.])),
(myMechanism_3.input_states[0].parameters.value.get(z), np.array([20.
])),
(myMechanism_3.output_states[0].parameters.value.get(z),
np.array([30.])),
(result, np.array([30.])),
]
for i in range(len(expected_output)):
val, expected = expected_output[i]
# setting absolute tolerance to be in accordance with reference_output precision
# if you do not specify, assert_allcose will use a relative tolerance of 1e-07,
# which WILL FAIL unless you gather higher precision values to use as reference
np.testing.assert_allclose(
val,
expected,
atol=1e-08,
err_msg='Failed on expected_output[{0}]'.format(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_change_termination_condition(self):
D = DDM(function=DriftDiffusionIntegrator(threshold=10))
P = Process(pathway=[D])
S = System(processes=[P])
D.set_log_conditions(VALUE)
def change_termination_processing():
if S.termination_processing is None:
S.scheduler_processing.termination_conds = {TimeScale.TRIAL: WhenFinished(D)}
S.termination_processing = {TimeScale.TRIAL: WhenFinished(D)}
elif isinstance(S.termination_processing[TimeScale.TRIAL], AllHaveRun):
S.scheduler_processing.termination_conds = {TimeScale.TRIAL: WhenFinished(D)}
S.termination_processing = {TimeScale.TRIAL: WhenFinished(D)}
else:
S.scheduler_processing.termination_conds = {TimeScale.TRIAL: AllHaveRun()}
S.termination_processing = {TimeScale.TRIAL: AllHaveRun()}
change_termination_processing()
S.run(inputs={D: [[1.0], [2.0]]},
# termination_processing={TimeScale.TRIAL: WhenFinished(D)},
call_after_trial=change_termination_processing,
num_trials=4)
# Trial 0:
# input = 1.0, termination condition = WhenFinished
# 10 passes (value = 1.0, 2.0 ... 9.0, 10.0)
# Trial 1:
# input = 2.0, termination condition = AllHaveRun
# 1 pass (value = 2.0)
expected_results = [[np.array([[10.]]), np.array([[10.]])],
[np.array([[2.]]), np.array([[1.]])],
[np.array([[10.]]), np.array([[10.]])],
[np.array([[2.]]), np.array([[1.]])]]
assert np.allclose(expected_results, S.results)
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_not_all_output_port_values_have_label(self):
input_labels_dict = {
"red": [1.0, 0.0],
"green": [0.0, 1.0],
"blue": [2.0, 2.0]
}
output_labels_dict = {"red": [1.0, 0.0], "green": [0.0, 1.0]}
M = ProcessingMechanism(size=2,
params={
INPUT_LABELS_DICT: input_labels_dict,
OUTPUT_LABELS_DICT: output_labels_dict
})
P = Process(pathway=[M])
S = System(processes=[P])
store_output_labels = []
def call_after_trial():
store_output_labels.append(M.get_output_labels(S))
S.run(inputs=['red', 'blue', 'green', 'blue'],
call_after_trial=call_after_trial)
assert np.allclose(
S.results,
[[[1.0, 0.0]], [[2.0, 2.0]], [[0.0, 1.0]], [[2.0, 2.0]]])
assert store_output_labels[0] == ['red']
assert np.allclose(store_output_labels[1], [[2.0, 2.0]])
assert store_output_labels[2] == ['green']
assert np.allclose(store_output_labels[3], [[2.0, 2.0]])
def test_dict_of_arrays(self):
input_labels_dict = {
"red": [1, 0, 0],
"green": [0, 1, 0],
"blue": [0, 0, 1]
}
M = ProcessingMechanism(default_variable=[[0, 0, 0]],
params={INPUT_LABELS_DICT: input_labels_dict})
P = Process(pathway=[M])
S = System(processes=[P])
store_input_labels = []
def call_after_trial():
store_input_labels.append(M.get_input_labels(S))
S.run(inputs=['red', 'green', 'blue', 'red'],
call_after_trial=call_after_trial)
assert np.allclose(
S.results, [[[1, 0, 0]], [[0, 1, 0]], [[0, 0, 1]], [[1, 0, 0]]])
assert store_input_labels == [['red'], ['green'], ['blue'], ['red']]
S.run(inputs='red')
assert np.allclose(
S.results,
[[[1, 0, 0]], [[0, 1, 0]], [[0, 0, 1]], [[1, 0, 0]], [[1, 0, 0]]])
S.run(inputs=['red'])
assert np.allclose(S.results, [[[1, 0, 0]], [[0, 1, 0]], [[0, 0, 1]],
[[1, 0, 0]], [[1, 0, 0]], [[1, 0, 0]]])
def test_dict_of_arrays(self):
input_labels_dict = {"red": [1.0, 0.0], "green": [0.0, 1.0]}
output_labels_dict = {"red": [1.0, 0.0], "green": [0.0, 1.0]}
M = ProcessingMechanism(size=2,
params={
INPUT_LABELS_DICT: input_labels_dict,
OUTPUT_LABELS_DICT: output_labels_dict
})
P = Process(pathway=[M])
S = System(processes=[P])
store_output_labels = []
def call_after_trial():
store_output_labels.append(M.get_output_labels(S))
S.run(inputs=['red', 'green', 'green', 'red'],
call_after_trial=call_after_trial)
assert np.allclose(
S.results,
[[[1.0, 0.0]], [[0.0, 1.0]], [[0.0, 1.0]], [[1.0, 0.0]]])
assert store_output_labels == [['red'], ['green'], ['green'], ['red']]
store_output_labels = []
S.run(inputs=[[1.0, 0.0], 'green', [0.0, 1.0], 'red'],
call_after_trial=call_after_trial)
assert np.allclose(
S.results,
[[[1.0, 0.0]], [[0.0, 1.0]], [[0.0, 1.0]], [[1.0, 0.0]],
[[1.0, 0.0]], [[0.0, 1.0]], [[0.0, 1.0]], [[1.0, 0.0]]])
assert store_output_labels == [['red'], ['green'], ['green'], ['red']]
def test_dict_of_subdicts(self):
input_labels_dict_M1 = {"red": [1, 1], "green": [0, 0]}
output_labels_dict_M2 = {0: {"red": [0, 0], "green": [1, 1]}}
M1 = ProcessingMechanism(
size=2, params={INPUT_LABELS_DICT: input_labels_dict_M1})
M2 = ProcessingMechanism(
size=2, params={OUTPUT_LABELS_DICT: output_labels_dict_M2})
P = Process(pathway=[M1, M2], learning=ENABLED, learning_rate=0.25)
S = System(processes=[P])
learned_matrix = []
count = []
def record_matrix_after_trial():
learned_matrix.append(M2.path_afferents[0].get_mod_matrix(S))
count.append(1)
S.run(inputs=['red', 'green', 'green', 'red'],
targets=['red', 'green', 'green', 'red'],
call_after_trial=record_matrix_after_trial)
assert np.allclose(S.results,
[[[1, 1]], [[0., 0.]], [[0., 0.]], [[0.5, 0.5]]])
assert np.allclose(learned_matrix, [
np.array([[0.75, -0.25], [-0.25, 0.75]]),
np.array([[0.75, -0.25], [-0.25, 0.75]]),
np.array([[0.75, -0.25], [-0.25, 0.75]]),
np.array([[0.625, -0.375], [-0.375, 0.625]])
])
def test_recurrent_transfer_origin(self):
R = RecurrentTransferMechanism(has_recurrent_input_state=True)
P = Process(pathway=[R])
S = System(processes=[P])
S.run(inputs={R: [[1.0], [2.0], [3.0]]})
print(S.results)
def test_reinitialize_one_mechanism_at_trial_2_condition(self):
A = TransferMechanism(name='A')
B = TransferMechanism(name='B',
integrator_mode=True,
integration_rate=0.5)
C = TransferMechanism(name='C')
abc_process = Process(pathway=[A, B, C])
abc_system = System(processes=[abc_process])
# Set reinitialization condition
B.reinitialize_when = AtTrial(2)
C.log.set_log_conditions('value')
abc_system.run(inputs={A: [1.0]},
reinitialize_values={B: [0.]},
num_trials=5)
# Trial 0: 0.5, Trial 1: 0.75, Trial 2: 0.5, Trial 3: 0.75. Trial 4: 0.875
assert np.allclose(
C.log.nparray_dictionary('value')[
abc_system.default_execution_id]['value'],
[[np.array([0.5])], [np.array([0.75])], [np.array([0.5])],
[np.array([0.75])], [np.array([0.875])]])
def test_reinforcement_fixed_targets():
input_layer = TransferMechanism(
size=2,
name='Input Layer',
)
action_selection = pnl.DDM(input_format=pnl.ARRAY,
function=pnl.DriftDiffusionAnalytical(),
output_states=[pnl.SELECTED_INPUT_ARRAY],
name='DDM')
p = Process(pathway=[input_layer, action_selection],
learning=LearningProjection(learning_function=Reinforcement(
learning_rate=0.05)))
input_list = {input_layer: [[1, 1], [1, 1]]}
s = System(processes=[p],
# learning_rate=0.05,
)
targets = [[10.], [10.]]
# logged_mechanisms = [input_layer, action_selection]
# for mech in s.learning_mechanisms:
# logged_mechanisms.append(mech)
#
# for mech in logged_mechanisms:
# mech.log.set_log_conditions(items=[pnl.VALUE])
results = s.run(inputs=input_list, targets=targets)
assert np.allclose(action_selection.value, [[1.], [2.30401336], [0.97340301], [0.02659699], [2.30401336], \
[2.08614798], [1.85006765], [2.30401336], [2.08614798], [1.85006765]])
def test_some_inputs_not_provided_to_run(self):
Origin1 = TransferMechanism(name='Origin1',
default_variable=[[1.0, 2.0]])
Origin2 = TransferMechanism(name='Origin2',
default_variable=[[3.0, 4.0]])
Terminal = TransferMechanism(name='Terminal')
P1 = Process(pathway=[Origin1, Terminal])
P2 = Process(pathway=[Origin2, Terminal])
S = System(processes=[P1, P2])
run_result = S.run(inputs={Origin1: [[5.0, 6.0]]})
# inputs={Origin1: [[5.0, 6.0], [7.0, 8.0]]}) # NOT currently allowed because inputs would be different lengths
assert np.allclose(Origin1.parameters.value.get(S), [[5.0, 6.0]])
assert np.allclose(Origin2.parameters.value.get(S), [[3.0, 4.0]])
assert np.allclose(run_result, [[np.array([18.0])]])
def test_3_input_ports_2_label_dicts(self):
input_labels_dict = {
0: {
"red": [1, 0],
"green": [0, 1]
},
2: {
"red": [0, 1],
"green": [1, 0]
}
}
M = TransferMechanism(default_variable=[[0, 0], [0, 0], [0, 0]],
params={INPUT_LABELS_DICT: input_labels_dict})
P = Process(pathway=[M])
S = System(processes=[P])
S.run(inputs=[['red', [0, 0], 'green'], ['green', [1, 1], 'red'],
['green', [2, 2], 'green']])
assert np.allclose(S.results,
[[[1, 0], [0, 0], [1, 0]], [[0, 1], [1, 1], [0, 1]],
[[0, 1], [2, 2], [1, 0]]])
S.run(inputs=[['red', [0, 0], [1, 0]], ['green', [1, 1], 'red'],
[[0, 1], [2, 2], 'green']])
assert np.allclose(
S.results, [[[1, 0], [0, 0], [1, 0]], [[0, 1], [1, 1], [0, 1]],
[[0, 1], [2, 2], [1, 0]], [[1, 0], [0, 0], [1, 0]],
[[0, 1], [1, 1], [0, 1]], [[0, 1], [2, 2], [1, 0]]])
def test_buffer_as_function_of_origin_mech_in_system(self):
P = ProcessingMechanism(function=Buffer(default_variable=[[0.0]],
initializer=[[0.0]],
history=3))
process = Process(pathway=[P])
system = System(processes=[process])
P.reinitialize_when = Never()
full_result = []
def assemble_full_result():
full_result.append(P.parameters.value.get(system))
result = system.run(inputs={P: [[1.0], [2.0], [3.0], [4.0], [5.0]]},
call_after_trial=assemble_full_result)
# only returns index 0 item of the deque on each trial (output state value)
assert np.allclose(result, [[[0.0]], [[0.0]], [[1.0]], [[2.0]], [[3.0]]])
# stores full mechanism value (full deque) on each trial
expected_full_result = [np.array([[0.], [1.]]),
np.array([[0.], [1.], [2.]]),
np.array([[1.], [2.], [3.]]), # Shape change
np.array([[2.], [3.], [4.]]),
np.array([[3.], [4.], [5.]])]
for i in range(5):
assert np.allclose(expected_full_result[i], full_result[i])
def test_previous_value_stored(self):
G = LCAMechanism(integrator_mode=True,
leak=-1.0,
noise=0.0,
time_step_size=0.02,
function=Linear(slope=2.0),
self_excitation=1.0,
competition=-1.0,
initial_value=np.array([[1.0]]))
P = Process(pathway=[G])
S = System(processes=[P])
G.output_state.value = [0.0]
# - - - - - LCAMechanism integrator functions - - - - -
# X = previous_value + (rate * previous_value + variable) * self.time_step_size + noise
# f(X) = 2.0*X + 0
# - - - - - starting values - - - - -
# variable = G.output_state.value + stimulus = 0.0 + 1.0 = 1.0
# previous_value = initial_value = 1.0
# single_run = S.execute([[1.0]])
# np.testing.assert_allclose(single_run, np.array([[2.0]]))
np.testing.assert_allclose(S.execute([[1.0]]), np.array([[2.0]]))
# X = 1.0 + (-1.0 + 1.0)*0.02 + 0.0
# X = 1.0 + 0.0 + 0.0 = 1.0 <--- previous value 1.0
# f(X) = 2.0*1.0 <--- return 2.0, recurrent projection 2.0
np.testing.assert_allclose(S.execute([[1.0]]), np.array([[2.08]]))
# X = 1.0 + (-1.0 + 3.0)*0.02 + 0.0
# X = 1.0 + 0.04 = 1.04 <--- previous value 1.04
# f(X) = 2.0*1.04 <--- return 2.08
np.testing.assert_allclose(S.execute([[1.0]]), np.array([[2.1616]]))
def test_recurrent_mech_change_learning_rate(self):
R = RecurrentTransferMechanism(size=4,
function=Linear,
enable_learning=True,
learning_rate=0.1
)
p = Process(pathway=[R])
s = System(processes=[p])
assert R.learning_rate == 0.1
assert R.learning_mechanism.learning_rate == 0.1
# assert R.learning_mechanism.function.learning_rate == 0.1
s.run(inputs=[[1.0, 1.0, 1.0, 1.0]])
matrix_1 = [[0., 1.1, 1.1, 1.1],
[1.1, 0., 1.1, 1.1],
[1.1, 1.1, 0., 1.1],
[1.1, 1.1, 1.1, 0.]]
assert np.allclose(R.recurrent_projection.mod_matrix, matrix_1)
print(R.recurrent_projection.mod_matrix)
R.learning_rate = 0.9
assert R.learning_rate == 0.9
assert R.learning_mechanism.learning_rate == 0.9
# assert R.learning_mechanism.function.learning_rate == 0.9
s.run(inputs=[[1.0, 1.0, 1.0, 1.0]])
matrix_2 = [[0., 1.911125, 1.911125, 1.911125],
[1.911125, 0., 1.911125, 1.911125],
[1.911125, 1.911125, 0., 1.911125],
[1.911125, 1.911125, 1.911125, 0.]]
# assert np.allclose(R.recurrent_projection.mod_matrix, matrix_2)
print(R.recurrent_projection.mod_matrix)
def test_system_run_with_combined_condition(self):
# Construction
T = TransferMechanism()
P = Process(pathway=[T])
S = System(processes=[P])
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
S.run(inputs={T: 2.0},
runtime_params={
T: {
"noise": (10.0, Any(AtTrial(1), AfterTrial(2)))
}
},
num_trials=5)
# Runtime param NOT used for noise
S.run(inputs={T: 2.0})
assert np.allclose(
S.results,
[
[np.array([2.])], # Trial 0 - NOT condition 0, NOT condition 1
[np.array([12.])], # Trial 1 - condition 0, NOT condition 1
[np.array([2.])], # Trial 2 - NOT condition 0, NOT condition 1
[np.array([12.])], # Trial 3 - NOT condition 0, condition 1
[np.array([12.])], # Trial 4 - NOT condition 0, condition 1
[np.array([2.])]
]) # New run (runtime param no longer applies)
def test_kwta_size_10_k_3_threshold_1(self):
K = KWTAMechanism(
name='K',
size=10,
k_value=3,
threshold=1,
)
p = Process(pathway=[K], prefs=TestKWTALongTerm.simple_prefs)
s = System(processes=[p], prefs=TestKWTALongTerm.simple_prefs)
kwta_input = {K: [[-1, -.5, 0, 0, 0, 1, 1, 2, 3, 3]]}
print("")
for i in range(20):
s.run(inputs=kwta_input)
print('\ntrial number', i)
print('K.parameters.value.get(s): ', K.parameters.value.get(s))
assert np.allclose(K.parameters.value.get(s), [[0.012938850123312412, 0.022127587008877226, 0.039010157367582114,
0.039010157367582114, 0.039010157367582114, 0.19055156271846602,
0.19055156271846602, 0.969124504436019, 0.9895271824560731, 0.9895271824560731]])
kwta_input2 = {K: [0] * 10}
print('\n\nturning to zero-inputs now:')
for i in range(20):
s.run(inputs=kwta_input2)
print('\ntrial number', i)
print('K.parameters.value.get(s): ', K.parameters.value.get(s))
assert np.allclose(K.parameters.value.get(s), [[0.13127237999481228, 0.13130057846907178, 0.1313653354768465, 0.1313653354768465,
0.1313653354768465, 0.5863768938723602, 0.5863768938723602, 0.8390251365605804,
0.8390251603214743, 0.8390251603214743]])
def test_system_run_with_sticky_condition(self):
# Construction
T = TransferMechanism()
P = Process(pathway=[T])
S = System(processes=[P])
assert T.noise == 0.0
assert T.parameter_states['noise'].value == 0.0
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
S.run(inputs={T: 2.0},
runtime_params={T: {
"noise": (10.0, AfterTrial(1))
}},
num_trials=4)
# Runtime param NOT used for noise
S.run(inputs={T: 2.0})
assert np.allclose(
S.results,
[
[np.array([2.])], # Trial 0 - condition not satisfied yet
[np.array([2.])], # Trial 1 - condition not satisfied yet
[np.array([12.])], # Trial 2 - condition satisfied
[np.array([12.])], # Trial 3 - condition satisfied (sticky)
[np.array([2.])]
]) # New run (runtime param no longer applies)
def test_initialize_mechanisms(self):
A = TransferMechanism(name='A')
B = TransferMechanism(name='B')
C = RecurrentTransferMechanism(name='C', auto=1.0)
abc_process = Process(pathway=[A, B, C])
abc_system = System(processes=[abc_process])
C.log.set_log_conditions('value')
abc_system.run(inputs={A: [1.0, 2.0, 3.0]},
initial_values={
A: 1.0,
B: 1.5,
C: 2.0
},
initialize=True)
abc_system.run(inputs={A: [1.0, 2.0, 3.0]},
initial_values={
A: 1.0,
B: 1.5,
C: 2.0
},
initialize=False)
# Run 1 --> Execution 1: 1 + 2 = 3 | Execution 2: 3 + 2 = 5 | Execution 3: 5 + 3 = 8
# Run 2 --> Execution 1: 8 + 1 = 9 | Execution 2: 9 + 2 = 11 | Execution 3: 11 + 3 = 14
assert np.allclose(
C.log.nparray_dictionary('value')[abc_system.default_execution_id]
['value'], [[[3]], [[5]], [[8]], [[9]], [[11]], [[14]]])
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_reinitialize_run(self):
L = LCAMechanism(name="L",
function=Linear,
initial_value=0.5,
integrator_mode=True,
leak=0.1,
competition=0,
self_excitation=1.0,
time_step_size=1.0,
noise=0.0)
P = Process(name="P", pathway=[L])
S = System(name="S", processes=[P])
L.reinitialize_when = Never()
assert np.allclose(L.integrator_function.previous_value, 0.5)
assert np.allclose(L.initial_value, 0.5)
assert np.allclose(L.integrator_function.initializer, 0.5)
S.run(inputs={L: 1.0},
num_trials=2,
initialize=True,
initial_values={L: 0.0})
# IntegratorFunction fn: previous_value + (rate*previous_value + new_value)*time_step_size + noise*(time_step_size**0.5)
# Trial 1 | variable = 1.0 + 0.0
# integration: 0.5 + (0.1*0.5 + 1.0)*1.0 + 0.0 = 1.55
# linear fn: 1.55*1.0 = 1.55
# Trial 2 | variable = 1.0 + 1.55
# integration: 1.55 + (0.1*1.55 + 2.55)*1.0 + 0.0 = 4.255
# linear fn: 4.255*1.0 = 4.255
assert np.allclose(
L.integrator_function.parameters.previous_value.get(S), 4.255)
L.integrator_function.reinitialize(0.9, execution_context=S)
assert np.allclose(
L.integrator_function.parameters.previous_value.get(S), 0.9)
assert np.allclose(L.parameters.value.get(S), 4.255)
L.reinitialize(0.5, execution_context=S)
assert np.allclose(
L.integrator_function.parameters.previous_value.get(S), 0.5)
assert np.allclose(L.parameters.value.get(S), 0.5)
S.run(inputs={L: 1.0}, num_trials=2)
# Trial 3 | variable = 1.0 + 0.5
# integration: 0.5 + (0.1*0.5 + 1.5)*1.0 + 0.0 = 2.05
# linear fn: 2.05*1.0 = 2.05
# Trial 4 | variable = 1.0 + 2.05
# integration: 2.05 + (0.1*2.05 + 3.05)*1.0 + 0.0 = 5.305
# linear fn: 5.305*1.0 = 5.305
assert np.allclose(
L.integrator_function.parameters.previous_value.get(S), 5.305)
assert np.allclose(L.initial_value, 0.5)
assert np.allclose(L.integrator_function.initializer, 0.5)
def test_udf_system_terminal(self):
def myFunction(variable, params, context):
return [variable[0][2], variable[0][0]]
myMech = ProcessingMechanism(function=myFunction, size=3, name='myMech')
T2 = TransferMechanism(size=3, function=Linear)
p2 = Process(pathway=[T2, myMech])
s2 = System(processes=[p2])
s2.run(inputs = {T2: [[1, 2, 3]]})
assert(np.allclose(s2.results[0][0], [3, 1]))
