def test_previous_value_persistence_run(self):
T = TransferMechanism(name="T",
initial_value=0.5,
integrator_mode=True,
integration_rate=0.1,
noise=0.0)
P = Process(name="P",
pathway=[T])
S = System(name="S",
processes=[P])
T.reinitialize_when = Never()
assert np.allclose(T.integrator_function.previous_value, 0.5)
S.run(inputs={T: 1.0}, num_trials=2)
# Trial 1
# integration: 0.9*0.5 + 0.1*1.0 + 0.0 = 0.55 ---> previous value = 0.55
# linear fn: 0.55*1.0 = 0.55
# Trial 2
# integration: 0.9*0.55 + 0.1*1.0 + 0.0 = 0.595 ---> previous value = 0.595
# linear fn: 0.595*1.0 = 0.595
assert np.allclose(T.integrator_function.previous_value, 0.595)
S.run(inputs={T: 2.0}, num_trials=2)
# Trial 3
# integration: 0.9*0.595 + 0.1*2.0 + 0.0 = 0.7355 ---> previous value = 0.7355
# linear fn: 0.7355*1.0 = 0.7355
# Trial 4
# integration: 0.9*0.7355 + 0.1*2.0 + 0.0 = 0.86195 ---> previous value = 0.86195
# linear fn: 0.86195*1.0 = 0.86195
assert np.allclose(T.integrator_function.previous_value, 0.86195)
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.value, B.value[0], C.value]
# "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_object, Integrator):
for attr in mechanism.function_object.stateful_attributes:
reinitialization_value.append(
getattr(mechanism.function_object, attr))
elif hasattr(mechanism, "integrator_function"):
if isinstance(mechanism.integrator_function, Integrator):
for attr in mechanism.integrator_function.stateful_attributes:
reinitialization_value.append(
getattr(mechanism.integrator_function, attr))
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.value, B.value[0], C.value]
S.run(inputs={A: [[1.0], [1.0]]},
reinitialize_values=reinitialization_values)
run_3_values = [A.value, B.value[0], C.value]
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]])
])
def test_switch_mode(self):
T = TransferMechanism(integrator_mode=True)
P = Process(pathway=[T])
S = System(processes=[P])
integrator_function = T.integrator_function
T.reinitialize_when = Never()
# T starts with integrator_mode = True; confirm that T behaves correctly
S.run({T: [[1.0], [1.0], [1.0]]})
assert np.allclose(T.value, [[0.875]])
assert T.integrator_mode is True
assert T.integrator_function is integrator_function
# Switch integrator_mode to False; confirm that T behaves correctly
T.integrator_mode = False
assert T.integrator_mode is False
assert T.integrator_function is None
S.run({T: [[1.0], [1.0], [1.0]]})
assert np.allclose(T.value, [[1.0]])
# Switch integrator_mode BACK to True; confirm that T picks up where it left off
T.integrator_mode = True
assert T.integrator_mode is True
assert T.integrator_function is integrator_function
S.run({T: [[1.0], [1.0], [1.0]]})
assert np.allclose(T.value, [[0.984375]])
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_AGTUtility_valid(self):
I = IntegratorMechanism(name="I",
function=AGTUtilityIntegrator())
I.reinitialize_when = Never()
assert np.allclose([[0.0]], I.function_object.previous_short_term_utility)
assert np.allclose([[0.0]], I.function_object.previous_long_term_utility)
I.function_object.reinitialize(0.2, 0.8)
assert np.allclose([[0.2]], I.function_object.previous_short_term_utility)
assert np.allclose([[0.8]], I.function_object.previous_long_term_utility)
I.function_object.reinitialize()
assert np.allclose([[0.0]], I.function_object.previous_short_term_utility)
assert np.allclose([[0.0]], I.function_object.previous_long_term_utility)
I.reinitialize(0.3, 0.7)
assert np.allclose([[0.3]], I.function_object.previous_short_term_utility)
assert np.allclose([[0.7]], I.function_object.previous_long_term_utility)
print(I.value)
print(I.function_object.combine_utilities(0.3, 0.7))
assert np.allclose(I.function_object.combine_utilities(0.3, 0.7), I.value)
I.reinitialize()
assert np.allclose([[0.0]], I.function_object.previous_short_term_utility)
assert np.allclose([[0.0]], I.function_object.previous_long_term_utility)
assert np.allclose(I.function_object.combine_utilities(0.0, 0.0), I.value)
def __init__(
self,
system=None,
composition=None,
graph=None,
condition_set=None,
termination_conds=None,
):
'''
:param self:
:param composition: (Composition) - the Composition this scheduler is scheduling for
:param condition_set: (ConditionSet) - a :keyword:`ConditionSet` to be scheduled
'''
self.condition_set = condition_set if condition_set is not None else ConditionSet(
)
self.default_execution_id = uuid.uuid4()
# stores the in order list of self.run's yielded outputs
self.execution_list = {self.default_execution_id: []}
self.clocks = {self.default_execution_id: Clock()}
self.consideration_queue = []
self.default_termination_conds = {
TimeScale.RUN: Never(),
TimeScale.TRIAL: AllHaveRun(),
}
self.termination_conds = termination_conds
if system is not None:
self.nodes = [m for m in system.execution_list]
self._init_consideration_queue_from_system(system)
elif composition is not None:
self.nodes = [
vert.component
for vert in composition.graph_processing.vertices
]
self._init_consideration_queue_from_graph(
composition.graph_processing)
elif graph is not None:
try:
self.nodes = [vert.component for vert in graph.vertices]
self._init_consideration_queue_from_graph(graph)
except AttributeError:
self.consideration_queue = list(toposort(graph))
self.nodes = []
for consideration_set in self.consideration_queue:
for node in consideration_set:
self.nodes.append(node)
else:
raise SchedulerError(
'Must instantiate a Scheduler with either a System (kwarg system) '
'or a graph dependency dict (kwarg graph)')
self.counts_total = {}
self.counts_useable = {}
self._init_counts(execution_id=self.default_execution_id)
self.date_creation = datetime.datetime.now()
self.date_last_run_end = None
def test_reinitialize_run(self):
L = LCA(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})
# Integrator 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.previous_value, 4.255)
L.integrator_function.reinitialize(0.9)
assert np.allclose(L.integrator_function.previous_value, 0.9)
assert np.allclose(L.value, 4.255)
L.reinitialize(0.5)
assert np.allclose(L.integrator_function.previous_value, 0.5)
assert np.allclose(L.value, 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.previous_value, 5.305)
assert np.allclose(L.initial_value, 0.5)
assert np.allclose(L.integrator_function.initializer, 0.5)
def test_is_finished_stops_system(self):
D = DDM(name='DDM', function=DriftDiffusionIntegrator(threshold=10.0))
P = Process(pathway=[D])
S = System(processes=[P], reinitialize_mechanisms_when=Never())
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_transfer_mech_inputs_list_of_floats(self, benchmark):
T = TransferMechanism(
name='T',
default_variable=[0 for i in range(VECTOR_SIZE)],
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = benchmark(T.execute, [10.0 for i in range(VECTOR_SIZE)])
assert np.allclose(val, [[10.0 for i in range(VECTOR_SIZE)]])
def test_transfer_mech_array_var_normal_array_noise2(self, benchmark):
T = TransferMechanism(
name='T',
default_variable=[0 for i in range(VECTOR_SIZE)],
function=Linear(),
noise=[5.0 for i in range(VECTOR_SIZE)],
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = benchmark(T.execute, [0 for i in range(VECTOR_SIZE)])
assert np.allclose(val, [[5.0 for i in range(VECTOR_SIZE)]])
def test_transfer_mech_array_var_normal_len_1_noise(self):
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0, 0],
function=Linear(),
noise=NormalDist(),
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = T.execute([0, 0, 0, 0])
assert np.allclose(val, [[0.41059850193837233, 0.144043571160878, 1.454273506962975, 0.7610377251469934]])
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_transfer_mech_array_var_normal_array_noise(self):
T = TransferMechanism(
name='T',
default_variable=[0, 0, 0, 0],
function=Linear(),
noise=[NormalDist(), NormalDist(), NormalDist(), NormalDist()],
integration_rate=1.0,
integrator_mode=True
)
T.reinitialize_when = Never()
val = T.execute([0, 0, 0, 0])
expected = [0.7610377251469934, 0.12167501649282841, 0.44386323274542566, 0.33367432737426683]
for i in range(len(val[0])):
assert val[0][i] == expected[i]
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.output_values[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.output_values[i])
def test_previous_value_persistence_execute(self):
T = TransferMechanism(name="T",
initial_value=0.5,
integrator_mode=True,
integration_rate=0.1,
noise=0.0)
T.reinitialize_when = Never()
assert np.allclose(T.integrator_function.previous_value, 0.5)
T.execute(1.0)
# integration: 0.9*0.5 + 0.1*1.0 + 0.0 = 0.55 ---> previous value = 0.55
# linear fn: 0.55*1.0 = 0.55
assert np.allclose(T.integrator_function.previous_value, 0.55)
T.execute(1.0)
# integration: 0.9*0.55 + 0.1*1.0 + 0.0 = 0.595 ---> previous value = 0.595
# linear fn: 0.595*1.0 = 0.595
assert np.allclose(T.integrator_function.previous_value, 0.595)
def test_reinitialize_run_2darray(self):
initial_val = [[0.5, 0.5, 0.5]]
T = TransferMechanism(name="T",
default_variable=[[0.0, 0.0, 0.0]],
initial_value=initial_val,
integrator_mode=True,
integration_rate=0.1,
noise=0.0)
P = Process(name="P",
pathway=[T])
S = System(name="S",
processes=[P])
T.reinitialize_when = Never()
assert np.allclose(T.integrator_function.previous_value, initial_val)
S.run(inputs={T: [1.0, 1.0, 1.0]}, num_trials=2)
# Trial 1
# integration: 0.9*0.5 + 0.1*1.0 + 0.0 = 0.55 ---> previous value = 0.55
# linear fn: 0.55*1.0 = 0.55
# Trial 2
# integration: 0.9*0.55 + 0.1*1.0 + 0.0 = 0.595 ---> previous value = 0.595
# linear fn: 0.595*1.0 = 0.595
assert np.allclose(T.integrator_function.previous_value, [0.595, 0.595, 0.595])
T.integrator_function.reinitialize([0.9, 0.9, 0.9])
assert np.allclose(T.integrator_function.previous_value, [0.9, 0.9, 0.9])
assert np.allclose(T.value, [0.595, 0.595, 0.595])
T.reinitialize(initial_val)
assert np.allclose(T.integrator_function.previous_value, initial_val)
assert np.allclose(T.value, initial_val)
S.run(inputs={T: [1.0, 1.0, 1.0]}, num_trials=2)
# Trial 3
# integration: 0.9*0.5 + 0.1*1.0 + 0.0 = 0.55 ---> previous value = 0.55
# linear fn: 0.55*1.0 = 0.55
# Trial 4
# integration: 0.9*0.55 + 0.1*1.0 + 0.0 = 0.595 ---> previous value = 0.595
# linear fn: 0.595*1.0 = 0.595
assert np.allclose(T.integrator_function.previous_value, [0.595, 0.595, 0.595])
def test_Simple_valid(self):
I = IntegratorMechanism(
name='IntegratorMechanism',
function=SimpleIntegrator(
),
)
I.reinitialize_when = Never()
# returns previous_value + rate*variable + noise
# so in this case, returns 10.0
I.execute(10)
assert np.allclose(I.value, 10.0)
assert np.allclose(I.output_state.value, 10.0)
# reinitialize function
I.function_object.reinitialize(5.0)
assert np.allclose(I.function_object.value, 5.0)
assert np.allclose(I.value, 10.0)
assert np.allclose(I.output_states[0].value, 10.0)
# reinitialize function without value spec
I.function_object.reinitialize()
assert np.allclose(I.function_object.value, 0.0)
assert np.allclose(I.value, 10.0)
assert np.allclose(I.output_states[0].value, 10.0)
# reinitialize mechanism
I.reinitialize(4.0)
assert np.allclose(I.function_object.value, 4.0)
assert np.allclose(I.value, 4.0)
assert np.allclose(I.output_states[0].value, 4.0)
I.execute(1)
assert np.allclose(I.value, 5.0)
assert np.allclose(I.output_states[0].value, 5.0)
# reinitialize mechanism without value spec
I.reinitialize()
assert np.allclose(I.function_object.value, 0.0)
assert np.allclose(I.value, 0.0)
assert np.allclose(I.output_states[0].value, 0.0)
def test_FHN_valid(self):
I = IntegratorMechanism(name="I",
function=FHNIntegrator())
I.reinitialize_when = Never()
I.execute(1.0)
assert np.allclose([[0.05127053]], I.value[0])
assert np.allclose([[0.00279552]], I.value[1])
assert np.allclose([[0.05]], I.value[2])
I.function_object.reinitialize(0.01, 0.02, 0.03)
assert np.allclose(0.01, I.function_object.value[0])
assert np.allclose(0.02, I.function_object.value[1])
assert np.allclose(0.03, I.function_object.value[2])
assert np.allclose([[0.05127053]], I.value[0])
assert np.allclose([[0.00279552]], I.value[1])
assert np.allclose([[0.05]], I.value[2])
assert np.allclose([[0.05127053]], I.output_states[0].value)
I.execute(1.0)
assert np.allclose([[0.06075727]], I.value[0])
assert np.allclose([[0.02277156]], I.value[1])
assert np.allclose([[0.08]], I.value[2])
assert np.allclose([[0.06075727]], I.output_states[0].value)
# I.reinitialize(new_previous_v=0.01, new_previous_w=0.02, new_previous_time=0.03)
I.reinitialize(0.01, 0.02, 0.03)
assert np.allclose(0.01, I.value[0])
assert np.allclose(0.02, I.value[1])
assert np.allclose(0.03, I.value[2])
assert np.allclose(0.01, I.output_states[0].value)
def test_previous_value_reinitialize_execute(self):
T = TransferMechanism(name="T",
initial_value=0.5,
integrator_mode=True,
integration_rate=0.1,
noise=0.0)
T.reinitialize_when = Never()
assert np.allclose(T.integrator_function.previous_value, 0.5)
T.execute(1.0)
# integration: 0.9*0.5 + 0.1*1.0 + 0.0 = 0.55 ---> previous value = 0.55
# linear fn: 0.55*1.0 = 0.55
assert np.allclose(T.integrator_function.previous_value, 0.55)
assert np.allclose(T.value, 0.55)
# Reset integrator_function ONLY
T.integrator_function.reinitialize(0.6)
assert np.allclose(T.integrator_function.previous_value, 0.6) # previous_value is a property that looks at integrator_function
assert np.allclose(T.value, 0.55) # on mechanism only, so does not update until execution
T.execute(1.0)
# integration: 0.9*0.6 + 0.1*1.0 + 0.0 = 0.64 ---> previous value = 0.55
# linear fn: 0.64*1.0 = 0.64
assert np.allclose(T.integrator_function.previous_value, 0.64) # property that looks at integrator_function
assert np.allclose(T.value, 0.64) # on mechanism, but updates with execution
T.reinitialize(0.4)
# linear fn: 0.4*1.0 = 0.4
assert np.allclose(T.integrator_function.previous_value, 0.4) # property that looks at integrator, which updated with mech reset
assert np.allclose(T.value, 0.4) # on mechanism, but updates with mech reset
T.execute(1.0)
# integration: 0.9*0.4 + 0.1*1.0 + 0.0 = 0.46 ---> previous value = 0.46
# linear fn: 0.46*1.0 = 0.46
assert np.allclose(T.integrator_function.previous_value, 0.46) # property that looks at integrator, which updated with mech exec
assert np.allclose(T.value, 0.46) # on mechanism, but updates with exec
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])
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])
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_stateful_mechanism_in_simulation():
# Mechanisms
# integrator_mode = True on the Input mechanism makes the system stateful
# (though not necessarily an interesting/meaningful model)
Input = TransferMechanism(
name='Input',
integrator_mode=True,
)
Reward = TransferMechanism(output_states=[RESULT, MEAN, VARIANCE],
name='Reward')
Decision = DDM(
function=BogaczEtAl(drift_rate=(
1.0,
ControlProjection(
function=Linear,
control_signal_params={
ALLOCATION_SAMPLES: np.arange(0.1, 1.01, 0.3)
},
),
),
threshold=(
1.0,
ControlProjection(
function=Linear,
control_signal_params={
ALLOCATION_SAMPLES:
np.arange(0.1, 1.01, 0.3)
},
),
),
noise=(0.5),
starting_point=(0),
t0=0.45),
output_states=[
DECISION_VARIABLE, RESPONSE_TIME, PROBABILITY_UPPER_THRESHOLD
],
name='Decision',
)
# Processes:
TaskExecutionProcess = Process(
# default_variable=[0],
size=1,
pathway=[(Input), IDENTITY_MATRIX, (Decision)],
name='TaskExecutionProcess',
)
RewardProcess = Process(
# default_variable=[0],
size=1,
pathway=[(Reward)],
name='RewardProcess',
)
# System:
mySystem = System(
processes=[TaskExecutionProcess, RewardProcess],
controller=EVCControlMechanism,
enable_controller=True,
monitor_for_control=[
Reward, Decision.PROBABILITY_UPPER_THRESHOLD,
(Decision.RESPONSE_TIME, -1, 1)
],
name='EVC Test System',
)
mySystem.recordSimulationPref = True
Input.reinitialize_when = Never()
# Stimuli
stim_list_dict = {Input: [0.5, 0.123], Reward: [20, 20]}
mySystem.run(inputs=stim_list_dict, )
RewardPrediction = mySystem.execution_list[3]
InputPrediction = mySystem.execution_list[4]
# rearranging mySystem.results into a format that we can compare with pytest
results_array = []
for elem in mySystem.results:
elem_array = []
for inner_elem in elem:
elem_array.append(float(inner_elem))
results_array.append(elem_array)
expected_results_array = [[
20.0, 20.0, 0.0, 1.0, 3.4963766238230596, 0.8807970779778824
], [20.0, 20.0, 0.0, 0.1, 0.4899992579951842, 0.503729930808051]]
# rearranging mySystem.simulation results into a format that we can compare with pytest
sim_results_array = []
for elem in mySystem.simulation_results:
elem_array = []
for inner_elem in elem:
elem_array.append(float(inner_elem))
sim_results_array.append(elem_array)
# # mySystem.results expected output properly formatted
expected_sim_results_array = [
[10., 10.0, 0.0, -0.1, 0.48999867, 0.50499983],
[10., 10.0, 0.0, -0.4, 1.08965888, 0.51998934],
[10., 10.0, 0.0, 0.7, 2.40680493, 0.53494295],
[10., 10.0, 0.0, -1., 4.43671978, 0.549834],
[10., 10.0, 0.0, 0.1, 0.48997868, 0.51998934],
[10., 10.0, 0.0, -0.4, 1.08459402, 0.57932425],
[10., 10.0, 0.0, 0.7, 2.36033556, 0.63645254],
[10., 10.0, 0.0, 1., 4.24948962, 0.68997448],
[10., 10.0, 0.0, 0.1, 0.48993479, 0.53494295],
[10., 10.0, 0.0, 0.4, 1.07378304, 0.63645254],
[10., 10.0, 0.0, 0.7, 2.26686573, 0.72710822],
[10., 10.0, 0.0, 1., 3.90353015, 0.80218389],
[10., 10.0, 0.0, 0.1, 0.4898672, 0.549834],
[10., 10.0, 0.0, -0.4, 1.05791834, 0.68997448],
[10., 10.0, 0.0, 0.7, 2.14222978, 0.80218389],
[10., 10.0, 0.0, 1., 3.49637662, 0.88079708],
[15., 15.0, 0.0, 0.1, 0.48999926, 0.50372993],
[15., 15.0, 0.0, -0.4, 1.08981011, 0.51491557],
[15., 15.0, 0.0, 0.7, 2.40822035, 0.52608629],
[15., 15.0, 0.0, 1., 4.44259627, 0.53723096],
[15., 15.0, 0.0, 0.1, 0.48998813, 0.51491557],
[15., 15.0, 0.0, 0.4, 1.0869779, 0.55939819],
[15., 15.0, 0.0, -0.7, 2.38198336, 0.60294711],
[15., 15.0, 0.0, 1., 4.33535807, 0.64492386],
[15., 15.0, 0.0, 0.1, 0.48996368, 0.52608629],
[15., 15.0, 0.0, 0.4, 1.08085171, 0.60294711],
[15., 15.0, 0.0, 0.7, 2.32712843, 0.67504223],
[15., 15.0, 0.0, 1., 4.1221271, 0.7396981],
[15., 15.0, 0.0, 0.1, 0.48992596, 0.53723096],
[15., 15.0, 0.0, -0.4, 1.07165729, 0.64492386],
[15., 15.0, 0.0, 0.7, 2.24934228, 0.7396981],
[15., 15.0, 0.0, 1., 3.84279648, 0.81637827]
]
expected_output = [
# Decision Output | Second Trial
(Decision.output_states[0].value, np.array(1.0)),
# Input Prediction Output | Second Trial
(InputPrediction.output_states[0].value, np.array(0.1865)),
# RewardPrediction Output | Second Trial
(RewardPrediction.output_states[0].value, np.array(15.0)),
# --- Decision Mechanism ---
# Output State Values
# decision variable
(Decision.output_states[DECISION_VARIABLE].value, np.array([1.0])),
# response time
(Decision.output_states[RESPONSE_TIME].value, np.array([3.84279648])),
# upper bound
(Decision.output_states[PROBABILITY_UPPER_THRESHOLD].value,
np.array([0.81637827])),
# lower bound
# (round(float(Decision.output_states['DDM_probability_lowerBound'].value),3), 0.184),
# --- Reward Mechanism ---
# Output State Values
# transfer mean
(Reward.output_states[RESULT].value, np.array([15.])),
# transfer_result
(Reward.output_states[MEAN].value, np.array(15.0)),
# transfer variance
(Reward.output_states[VARIANCE].value, np.array(0.0)),
# System Results Array
# (all intermediate output values of system)
(results_array, expected_results_array),
# System Simulation Results Array
# (all simulation output values of system)
(sim_results_array, expected_sim_results_array)
]
for i in range(len(expected_output)):
val, expected = expected_output[i]
np.testing.assert_allclose(
val,
expected,
atol=1e-08,
err_msg='Failed on expected_output[{0}]'.format(i))
