def test_LCA_length_2(self):
T = TransferMechanism(function=Linear(slope=1.0), size=2)
L = LCA(function=Linear(slope=2.0),
size=2,
self_excitation=3.0,
leak=0.5,
competition=1.0,
time_step_size=0.1)
P = Process(pathway=[T, L])
S = System(processes=[P])
# - - - - - - - Equations to be executed - - - - - - -
# new_transfer_input =
# previous_transfer_input
# + (leak * previous_transfer_input_1 + self_excitation * result1 + competition * result2 + outside_input1) * dt
# + noise
# result = new_transfer_input*2.0
# recurrent_matrix = [[3.0]]
# - - - - - - - - - - - - - - - - - - - - - - - - - -
results = []
def record_execution():
results.append(L.value[0])
S.run(inputs={T: [1.0, 2.0]},
num_trials=3,
call_after_trial=record_execution)
# - - - - - - - TRIAL 1 - - - - - - -
# new_transfer_input_1 = 0.0 + ( 0.5 * 0.0 + 3.0 * 0.0 - 1.0*0.0 + 1.0)*0.1 + 0.0 = 0.1
# f(new_transfer_input_1) = 0.1 * 2.0 = 0.2
# new_transfer_input_2 = 0.0 + ( 0.5 * 0.0 + 3.0 * 0.0 - 1.0*0.0 + 2.0)*0.1 + 0.0 = 0.2
# f(new_transfer_input_2) = 0.2 * 2.0 = 0.4
# - - - - - - - TRIAL 2 - - - - - - -
# new_transfer_input = 0.1 + ( 0.5 * 0.1 + 3.0 * 0.2 - 1.0*0.4 + 1.0)*0.1 + 0.0 = 0.225
# f(new_transfer_input) = 0.265 * 2.0 = 0.45
# new_transfer_input_2 = 0.2 + ( 0.5 * 0.2 + 3.0 * 0.4 - 1.0*0.2 + 2.0)*0.1 + 0.0 = 0.51
# f(new_transfer_input_2) = 0.1 * 2.0 = 1.02
# - - - - - - - TRIAL 3 - - - - - - -
# new_transfer_input = 0.225 + ( 0.5 * 0.225 + 3.0 * 0.45 - 1.0*1.02 + 1.0)*0.1 + 0.0 = 0.36925
# f(new_transfer_input) = 0.36925 * 2.0 = 0.7385
# new_transfer_input_2 = 0.51 + ( 0.5 * 0.51 + 3.0 * 1.02 - 1.0*0.45 + 2.0)*0.1 + 0.0 = 0.9965
# f(new_transfer_input_2) = 0.9965 * 2.0 = 1.463
assert np.allclose(results,
[[0.2, 0.4], [0.45, 1.02], [0.7385, 1.993]])
def test_initial_values_softmax(self):
T = TransferMechanism(default_variable=[[0.0, 0.0], [0.0, 0.0]],
function=SoftMax(),
integrator_mode=True,
integration_rate=0.5,
initial_value=[[1.0, 2.0], [3.0, 4.0]])
T2 = TransferMechanism()
P = Process(pathway=[T, T2])
S = System(processes=[P])
S.run(inputs={T: [[1.5, 2.5], [3.5, 4.5]]})
result = T.value
# Expected results
# integrator function:
# input = [[1.5, 2.5], [3.5, 4.5]] | output = [[1.25, 2.25]], [3.25, 4.25]]
integrator_fn = AdaptiveIntegrator(rate=0.5,
default_variable=[[0.0, 0.0], [0.0, 0.0]],
initializer=[[1.0, 2.0], [3.0, 4.0]])
expected_result_integrator = integrator_fn.function([[1.5, 2.5], [3.5, 4.5]])
S1 = SoftMax()
expected_result_s1 = S1.function([[1.25, 2.25]])
S2 = SoftMax()
expected_result_s2 = S2.function([[3.25, 4.25]])
assert np.allclose(expected_result_integrator, T.integrator_function_value)
assert np.allclose(expected_result_s1, result[0])
assert np.allclose(expected_result_s2, result[1])
def test_previous_value_stored(self):
G = LCA(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]
# - - - - - LCA 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 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_one_run_twice(self):
A = IntegratorMechanism(
name='A',
default_variable=[0],
function=SimpleIntegrator(
rate=.5,
)
)
p = Process(
default_variable=[0],
pathway=[A],
name='p'
)
s = System(
processes=[p],
name='s'
)
term_conds = {TimeScale.TRIAL: AfterNCalls(A, 2)}
stim_list = {A: [[1]]}
s.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.output_values[i])
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_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_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.output_values[i])
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].output_values[i])
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).function()
val_2 = NormalDist(mean=3.0).function()
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_not_all_output_state_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.output_labels)
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_kwta_average_k_1_ratio_0_8(self):
K = KWTA(
name='K',
size=4,
k_value=1,
threshold=0,
ratio=0.8,
function=Linear,
average_based=True
)
p = Process(pathway=[K], prefs=TestKWTAAverageBased.simple_prefs)
s = System(processes=[p], prefs=TestKWTAAverageBased.simple_prefs)
kwta_input = {K: [[1, 2, 3, 4]]}
s.run(inputs=kwta_input)
assert np.allclose(K.value, [[-1.4, -0.3999999999999999, 0.6000000000000001, 1.6]])
# class TestClip:
# def test_clip_float(self):
# K = KWTA(clip=[-2.0, 2.0],
# integrator_mode=False)
# assert np.allclose(K.execute(3.0), 2.0)
# assert np.allclose(K.execute(-3.0), -2.0)
#
# def test_clip_array(self):
# K = KWTA(default_variable=[[0.0, 0.0, 0.0]],
# clip=[-2.0, 2.0],
# integrator_mode=False)
# assert np.allclose(K.execute([3.0, 0.0, -3.0]), [2.0, 0.0, -2.0])
#
# def test_clip_2d_array(self):
# K = KWTA(default_variable=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
# clip=[-2.0, 2.0],
# integrator_mode=False)
# assert np.allclose(K.execute([[-5.0, -1.0, 5.0], [5.0, -5.0, 1.0], [1.0, 5.0, 5.0]]),
# [[-2.0, -1.0, 2.0], [2.0, -2.0, 1.0], [1.0, 2.0, 2.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.value)
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_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),
)
p = Process(default_variable=[0], pathway=[A, C, D], name='p')
q = Process(default_variable=[0], pathway=[B, C, E], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(E, 1)}
stim_list = {A: [[1]], B: [[2]]}
sched = Scheduler(system=s)
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))
s.scheduler_processing = sched
s.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].output_values[i])
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].mod_matrix)
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_default_lc_control_mechanism(self):
G = 1.0
k = 0.5
starting_value_LC = 2.0
user_specified_gain = 1.0
A = TransferMechanism(function=Logistic(gain=user_specified_gain))
B = TransferMechanism(function=Logistic(gain=user_specified_gain))
# B.output_states[0].value *= 0.0 # Reset after init | Doesn't matter here b/c default var = zero, no intercept
P = Process(pathway=[A, B])
LC = LCControlMechanism(modulated_mechanisms=[A, B],
base_level_gain=G,
scaling_factor_gain=k,
objective_mechanism=ObjectiveMechanism(
function=Linear,
monitored_output_states=[B],
name='LC ObjectiveMechanism'))
for output_state in LC.output_states:
output_state.value *= starting_value_LC
S = System(processes=[P])
gain_created_by_LC_output_state_1 = []
gain_created_by_LC_output_state_2 = []
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)
gain_created_by_LC_output_state_2.append(LC.output_states[1].value)
mod_gain_assigned_to_A.append(A.mod_gain[0])
mod_gain_assigned_to_B.append(B.mod_gain[0])
base_gain_assigned_to_A.append(A.function_object.gain)
base_gain_assigned_to_B.append(B.function_object.gain)
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])
assert np.allclose(mod_gain_assigned_to_B[1:],
gain_created_by_LC_output_state_2[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_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]))
def test_udf_system_origin(self):
def myFunction(variable, params, context):
return [variable[0][1], variable[0][0]]
myMech = ProcessingMechanism(function=myFunction, size=3, name='myMech')
T = TransferMechanism(size=2, function=Linear)
p = Process(pathway=[myMech, T])
s = System(processes=[p])
s.run(inputs = {myMech: [[1, 3, 5]]})
assert np.allclose(s.results[0][0], [3, 1])
def test_process(self):
a = TransferMechanism(name="a-sg", default_variable=[0, 0, 0])
b = TransferMechanism(name="b-sg")
p = Process(name="p", pathway=[a, b], learning=ENABLED)
s = System(name="s", processes=[p])
a_label = s._get_label(a, ALL)
b_label = s._get_label(b, 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
def test_heterogeneous_variables(self):
# from psyneulink.components.mechanisms.processing.objectivemechanism import ObjectiveMechanism
a = TransferMechanism(name='a', default_variable=[[0.0], [0.0, 0.0]])
p1 = Process(pathway=[a])
s = System(processes=[p1])
inputs = {a: [[[1.1], [2.1, 2.1]], [[1.2], [2.2, 2.2]]]}
s.run(inputs)
def test_kwta_threshold_float(self):
K = KWTA(
name='K',
size=4,
threshold=0.5
)
p = Process(pathway=[K], prefs=TestKWTARatio.simple_prefs)
s = System(processes=[p], prefs=TestKWTARatio.simple_prefs)
s.run(inputs={K: [1, 2, 3, 3]})
assert np.allclose(K.value, [[0.2689414213699951, 0.5, 0.7310585786300049, 0.7310585786300049]])
def test_kwta_k_value_empty_size_4(self):
K = KWTA(
name='K',
size=4
)
assert K.k_value == 0.5
p = Process(pathway=[K], prefs=TestKWTARatio.simple_prefs)
s = System(processes=[p], prefs=TestKWTARatio.simple_prefs)
s.run(inputs={K: [1, 2, 3, 4]})
assert np.allclose(K.value, [[0.18242552380635635, 0.3775406687981454, 0.6224593312018546, 0.8175744761936437]])
def test_kwta_threshold_int(self):
K = KWTA(
name='K',
size=4,
threshold=-1
)
p = Process(pathway=[K], prefs=TestKWTAThreshold.simple_prefs)
s = System(processes=[p], prefs=TestKWTAThreshold.simple_prefs)
s.run(inputs={K: [1, 2, 3, 4]})
assert np.allclose(K.value, [[0.07585818002124355, 0.18242552380635635, 0.3775406687981454, 0.6224593312018546]])
def test_is_finished_stops_system(self):
D = DDM(name='DDM', function=DriftDiffusionIntegrator(threshold=10.0))
P = Process(pathway=[D])
S = System(processes=[P])
S.run(inputs={D: 2.0},
termination_processing={TimeScale.TRIAL: WhenFinished(D)})
# decision variable's value should match threshold
assert D.value[0] == 10.0
# it should have taken 5 executions (and time_step_size = 1.0)
assert D.value[1] == 5.0
def test_LCA_length_1(self):
T = TransferMechanism(function=Linear(slope=1.0))
L = LCA(
function=Linear(slope=2.0),
self_excitation=3.0,
leak=0.5,
competition=
1.0, # competition does not matter because we only have one unit
time_step_size=0.1)
P = Process(pathway=[T, L])
S = System(processes=[P])
L.reinitialize_when = Never()
# - - - - - - - Equations to be executed - - - - - - -
# new_transfer_input =
# previous_transfer_input
# + (leak * previous_transfer_input_1 + self_excitation * result1 + competition * result2 + outside_input1) * dt
# + noise
# result = new_transfer_input*2.0
# recurrent_matrix = [[3.0]]
# - - - - - - - - - - - - - - - - - - - - - - - - - -
results = []
def record_execution():
results.append(L.value[0][0])
S.run(inputs={T: [1.0]},
num_trials=3,
call_after_trial=record_execution)
# - - - - - - - TRIAL 1 - - - - - - -
# new_transfer_input = 0.0 + ( 0.5 * 0.0 + 3.0 * 0.0 + 0.0 + 1.0)*0.1 + 0.0 = 0.1
# f(new_transfer_input) = 0.1 * 2.0 = 0.2
# - - - - - - - TRIAL 2 - - - - - - -
# new_transfer_input = 0.1 + ( 0.5 * 0.1 + 3.0 * 0.2 + 0.0 + 1.0)*0.1 + 0.0 = 0.265
# f(new_transfer_input) = 0.265 * 2.0 = 0.53
# - - - - - - - TRIAL 3 - - - - - - -
# new_transfer_input = 0.265 + ( 0.5 * 0.265 + 3.0 * 0.53 + 0.0 + 1.0)*0.1 + 0.0 = 0.53725
# f(new_transfer_input) = 0.53725 * 2.0 = 1.0745
assert np.allclose(results, [0.2, 0.53, 1.0745])
def test_kwta_average_k_1(self):
K = KWTA(
name='K',
size=4,
k_value=1,
threshold=0,
function=Linear,
average_based=True
)
p = Process(pathway=[K], prefs=TestKWTAAverageBased.simple_prefs)
s = System(processes=[p], prefs=TestKWTAAverageBased.simple_prefs)
kwta_input = {K: [[1, 2, 3, 4]]}
s.run(inputs=kwta_input)
assert np.allclose(K.value, [[-2, -1, 0, 1]])
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.input_labels)
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_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).function()
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 run_twice_in_system(mech, input1, input2=None):
if input2 is None:
input2 = input1
simple_prefs = {REPORT_OUTPUT_PREF: False, VERBOSE_PREF: False}
simple_process = Process(size=mech.size[0],
pathway=[mech],
name='simple_process')
simple_system = System(processes=[simple_process],
name='simple_system',
prefs=simple_prefs)
first_output = simple_system.run(inputs={mech: [input1]})
second_output = simple_system.run(inputs={mech: [input2]})
return second_output[1][0]
