def test_log_dictionary_with_scheduler_many_time_step_increments(self):
T1 = pnl.TransferMechanism(name='log_test_T1',
integrator_mode=True,
integration_rate=0.05)
PS = pnl.Process(name='log_test_PS', pathway=[T1])
SYS = pnl.System(name='log_test_SYS', processes=[PS])
def pass_threshold(mech, thresh):
results = mech.output_states[0].value
for val in results:
if abs(val) >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, T1, 0.95)
}
T1.set_log_conditions(pnl.VALUE)
SYS.run(inputs={T1: [[1.0]]}, termination_processing=terminate_trial)
log_dict_T1 = T1.log.nparray_dictionary(entries=['value'])
# Check order of keys (must match order of specification)
assert list(log_dict_T1.keys()) == [
'Run', 'Trial', 'Pass', 'Time_step', 'value'
]
# # Check values T1
assert len(log_dict_T1["Run"]) == 59
assert np.allclose(log_dict_T1["Pass"][30], 30)
assert np.allclose(log_dict_T1["Time_step"][30], 0)
assert abs(log_dict_T1["value"][58]) >= 0.95
assert abs(log_dict_T1["value"][57]) < 0.95
def test_log_dictionary_with_scheduler(self):
T1 = pnl.TransferMechanism(name='log_test_T1',
integrator_mode=True,
integration_rate=0.5)
T2 = pnl.TransferMechanism(name='log_test_T2',
function=pnl.Linear(slope=6.0))
PS = pnl.Process(name='log_test_PS', pathway=[T1, T2])
SYS = pnl.System(name='log_test_SYS', processes=[PS])
def pass_threshold(mech, thresh):
results = mech.output_states[0].value
for val in results:
if abs(val) >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, T2, 5.0)
}
T1.set_log_conditions(pnl.VALUE)
T1.set_log_conditions(pnl.SLOPE)
T1.set_log_conditions(pnl.RESULTS)
T2.set_log_conditions(pnl.VALUE)
T2.set_log_conditions(pnl.SLOPE)
SYS.run(inputs={T1: [[1.0]]}, termination_processing=terminate_trial)
log_dict_T1 = T1.log.nparray_dictionary(
entries=['RESULTS', 'slope', 'value'])
log_dict_T2 = T2.log.nparray_dictionary(entries=['value', 'slope'])
# Check order of keys (must match order of specification)
assert list(log_dict_T1.keys()) == [
'Run', 'Trial', 'Pass', 'Time_step', 'RESULTS', 'slope', 'value'
]
assert list(log_dict_T2.keys()) == [
'Run', 'Trial', 'Pass', 'Time_step', 'value', 'slope'
]
# Check values T1
assert np.allclose(log_dict_T1["Run"], [[0], [0], [0]])
assert np.allclose(log_dict_T1["Trial"], [[0], [0], [0]])
assert np.allclose(log_dict_T1["Time_step"], [[0], [0], [0]])
assert np.allclose(log_dict_T1["RESULTS"], [[0.5], [0.75], [0.875]])
assert np.allclose(log_dict_T1["value"],
[[[0.5]], [[0.75]], [[0.875]]])
assert np.allclose(log_dict_T1["slope"], [[1], [1], [1]])
# Check values T2
assert np.allclose(log_dict_T2["Run"], [[0], [0], [0]])
assert np.allclose(log_dict_T2["Trial"], [[0], [0], [0]])
assert np.allclose(log_dict_T2["Time_step"], [[1], [1], [1]])
assert np.allclose(log_dict_T2["value"], [[[3]], [[4.5]], [[5.25]]])
assert np.allclose(log_dict_T2["slope"], [[6], [6], [6]])
def _switch_to_integration_trial(self):
def pass_threshold(first_mechanism, second_mechanism, threshold):
if np.any(first_mechanism.output_states[0].value >= threshold) or \
np.any(second_mechanism.output_states[0].value >= threshold):
return True
return False
self._switch_trial_settings(True, self._generate_noise_function(),
pnl.While(pass_threshold, self.first_accumulator,
self.second_accumulator, self.accumulator_threshold), True)
def switch_to_processing_trial(mechanisms):
# Turn on accumulation
switch_integrator_mode(mechanisms, True)
# Turn on noise
switch_noise(mechanisms,
pnl.NormalDist(mean=0, standard_dev=unit_noise).function)
# Execute until one of the accumulators crosses the threshold
my_Stroop.termination_processing = {
pnl.TimeScale.TRIAL:
pnl.While(pass_threshold, respond_red_accumulator,
respond_green_accumulator, accumulator_threshold)
}
def test_log_dictionary_with_scheduler_many_time_step_increments(self):
con_with_rpc_pipeline = pnl.Context(rpc_pipeline=Queue())
pipeline = con_with_rpc_pipeline.rpc_pipeline
T1 = pnl.TransferMechanism(name='log_test_T1',
integrator_mode=True,
integration_rate=0.05)
COMP = pnl.Composition(name='log_test_COMP', pathways=[T1])
def pass_threshold(mech, thresh):
results = mech.output_ports[0].parameters.value.get(COMP)
for val in results:
if abs(val) >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, T1, 0.95)
}
T1.set_delivery_conditions(pnl.VALUE)
COMP.run(inputs={T1: [[1.0]]}, termination_processing=terminate_trial, context=con_with_rpc_pipeline)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
assert all([True if i.context == COMP.default_execution_id else False for i in actual])
t1_value_entries = [i for i in actual if i.parameterName == pnl.VALUE and i.componentName == 'log_test_T1']
t1_value_values = [np.ndarray(shape=np.array(i.value.shape), buffer=np.array(i.value.data)) for i in
t1_value_entries]
# Check values T1
assert len(actual) == 59
assert actual[30].time == '0:0:30:0'
assert t1_value_values[58] >= 0.95
assert t1_value_values[57] < 0.95
# Create threshold function -------------------------------------------------------------------------------------------
def pass_threshold(response_layer, thresh):
results1 = response_layer.get_output_values(Bidirectional_Stroop)[0][
0] # red response
results2 = response_layer.get_output_values(Bidirectional_Stroop)[0][
1] # green response
if results1 >= thresh or results2 >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, response_layer, threshold)
}
# Create test trials function -----------------------------------------------------------------------------------------
# a BLUE word input is [1,0] to words_input_layer and GREEN word is [0,1]
# a blue color input is [1,0] to colors_input_layer and green color is [0,1]
# a color-naming trial is [1,0] to task_layer and a word-reading trial is [0,1]
def trial_dict(red_color, green_color, neutral_color, red_word, green_word,
neutral_word, CN, WR):
trialdict = {
colors_input_layer: [red_color, green_color, neutral_color],
words_input_layer: [red_word, green_word, neutral_word],
task_input_layer: [CN, WR]
results1 = mech1.output_states[0].value
results2 = mech2.output_states[0].value
for val in results1:
if val >= thresh:
return True
for val in results2:
if val >= thresh:
return True
return False
accumulator_threshold = 1.0
terminate_trial = {
pnl.TimeScale.TRIAL:
pnl.While(pass_threshold, respond_red_accumulator,
respond_green_accumulator, accumulator_threshold)
}
# CREATE INITIAL CONDITION FUNCTION *** NOT WORKING
# want colors_hidden_layer to have low activity if WR is the task
# or want words_hidden_layer to have low activity if CN is the task
# in 1990 paper we want 0.01 in non-task relevant pathway hidden units, 0.5 in task relevant pathway hidden units
# and 0.5 for all of the response units
# point of clarification: when we initialize, and then present test pattern does the task input stay on?
# option to set these units to the values you want to reach, initial_value
#want to test this with
# colors_hidden_layer.log.nparray()
# colors_hidden_layer.log.print_entries()
# In[ ]:
results1 = response_layer.get_output_values(execution_context)[0][
0] #red response
results2 = response_layer.get_output_values(execution_context)[0][
1] #green response
length = response_layer.log.nparray_dictionary(
)[execution_context]['value'].shape[0]
if results1 >= thresh or results2 >= thresh:
return True
if length == terminate:
return True
return False
# Create different terminate trial conditions --------------------------------------------------------------------------
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, response_layer, threshold)
}
terminate_trial2 = {
pnl.TimeScale.TRIAL:
pnl.While(pass_threshold2, response_layer, threshold, terminate2)
}
terminate_trial3 = {
pnl.TimeScale.TRIAL:
pnl.While(pass_threshold2, response_layer, threshold, terminate3)
}
terminate_trial4 = {
pnl.TimeScale.TRIAL:
pnl.While(pass_threshold2, response_layer, threshold, terminate4)
}
terminate_trial5 = {
pnl.TimeScale.TRIAL:
def test_log_dictionary_with_scheduler(self):
con_with_rpc_pipeline = pnl.Context(rpc_pipeline=Queue())
pipeline = con_with_rpc_pipeline.rpc_pipeline
T1 = pnl.TransferMechanism(name='log_test_T1',
integrator_mode=True,
integration_rate=0.5)
T2 = pnl.TransferMechanism(name='log_test_T2',
function=pnl.Linear(slope=6.0))
COMP = pnl.Composition(name='log_test_COMP', pathways=[T1, T2])
def pass_threshold(mech, thresh):
results = mech.output_ports[0].parameters.value.get(COMP)
for val in results:
if abs(val) >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, T2, 5.0)
}
T1.set_delivery_conditions(pnl.VALUE)
T1.set_delivery_conditions('mod_slope')
T1.set_delivery_conditions(pnl.RESULT)
T2.set_delivery_conditions(pnl.VALUE)
T2.set_delivery_conditions('mod_slope')
COMP.run(inputs={T1: [[1.0]]}, termination_processing=terminate_trial,
context=con_with_rpc_pipeline)
actual = []
while not pipeline.empty():
actual.append(pipeline.get())
assert all([True if i.context == COMP.default_execution_id else False for i in actual])
t1_slope_entries = [i for i in actual if i.parameterName == pnl.SLOPE and i.componentName == 'log_test_T1']
t1_slope_values = [np.ndarray(shape=np.array(i.value.shape), buffer=np.array(i.value.data)) for i in t1_slope_entries]
t1_slope_times = [i.time for i in t1_slope_entries]
t2_slope_entries = [i for i in actual if i.parameterName == pnl.SLOPE and i.componentName == 'log_test_T2']
t2_slope_values = [np.ndarray(shape=np.array(i.value.shape), buffer=np.array(i.value.data)) for i in t2_slope_entries]
t2_slope_times = [i.time for i in t2_slope_entries]
t1_result_entries = [i for i in actual if i.parameterName == pnl.RESULT and i.componentName == 'log_test_T1']
t1_result_values = [np.ndarray(shape=np.array(i.value.shape), buffer=np.array(i.value.data)) for i in t1_result_entries]
t1_result_times = [i.time for i in t1_result_entries]
t1_value_entries = [i for i in actual if i.parameterName == pnl.VALUE and i.componentName == 'log_test_T1']
t1_value_values = [np.ndarray(shape=np.array(i.value.shape), buffer=np.array(i.value.data)) for i in t1_value_entries]
t1_value_times = [i.time for i in t1_value_entries]
t2_value_entries = [i for i in actual if i.parameterName == pnl.VALUE and i.componentName == 'log_test_T2']
t2_value_values = [np.ndarray(shape=np.array(i.value.shape), buffer=np.array(i.value.data)) for i in t2_value_entries]
t2_value_times = [i.time for i in t2_value_entries]
# Check values T1
expected_times_T1 = ['0:0:0:0', '0:0:1:0', '0:0:2:0']
expected_results_T1 = [[0.5], [0.75], [0.875]]
expected_values_T1 = [[[0.5]], [[0.75]], [[0.875]]]
expected_slopes_T1 = [[1], [1], [1]]
assert expected_times_T1 == t1_result_times == t1_slope_times == t1_value_times
assert np.allclose(expected_values_T1, t1_value_values)
assert np.allclose(expected_results_T1, t1_result_values)
assert np.allclose(expected_slopes_T1, t1_slope_values)
# Check values T2
expected_times_T2 = ['0:0:0:1', '0:0:1:1', '0:0:2:1']
expected_values_T2 = [[[3]], [[4.5]], [[5.25]]]
expected_slopes_T2 = [[6], [6], [6]]
assert expected_times_T2 == t2_slope_times == t2_value_times
assert np.allclose(expected_values_T2, t2_value_values)
assert np.allclose(expected_slopes_T2, t2_slope_values)
def test_log_array_with_scheduler(self):
T1 = pnl.TransferMechanism(name='log_test_T1',
integrator_mode=True,
integration_rate=0.5)
T2 = pnl.TransferMechanism(name='log_test_T2',
function=pnl.Linear(slope=6.0))
PS = pnl.Process(name='log_test_PS', pathway=[T1, T2])
SYS = pnl.System(name='log_test_SYS', processes=[PS])
def pass_threshold(mech, thresh):
results = mech.output_states[0].value
for val in results:
if abs(val) >= thresh:
return True
return False
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, T2, 5.0)
}
T1.set_log_conditions(pnl.VALUE)
T1.set_log_conditions(pnl.SLOPE)
T1.set_log_conditions(pnl.RESULTS)
T2.set_log_conditions(pnl.VALUE)
T2.set_log_conditions(pnl.SLOPE)
SYS.run(inputs={T1: [[1.0]]}, termination_processing=terminate_trial)
log_array_T1 = T1.log.nparray(entries=['RESULTS', 'slope', 'value'])
log_array_T2 = T2.log.nparray(entries=['value', 'slope'])
# Check values
run_results = [["Run"], [0], [0], [0]]
trial_results = [["Trial"], [0], [0], [0]]
pass_results = [["Pass"], [0], [1], [2]]
time_step_results = [["Time_step"], [0], [0], [0]]
results_results = ["RESULTS", [0.5], [0.75], [0.875]]
slope_results = ["slope", [1], [1], [1]]
value_results = ["value", [[0.5]], [[0.75]], [[0.875]]]
for i in range(4):
assert log_array_T1[0][i] == run_results[i]
assert log_array_T1[1][i] == trial_results[i]
assert log_array_T1[2][i] == pass_results[i]
assert log_array_T1[3][i] == time_step_results[i]
assert log_array_T1[4][i] == results_results[i]
assert log_array_T1[5][i] == slope_results[i]
assert log_array_T1[6][i] == value_results[i]
# Check values
run_results = [["Run"], [0], [0], [0]]
trial_results = [["Trial"], [0], [0], [0]]
pass_results = [["Pass"], [0], [1], [2]]
time_step_results = [["Time_step"], [1], [1], [1]]
value_results = ["value", [[3]], [[4.5]], [[5.25]]]
slope_results = ["slope", [6], [6], [6]]
for i in range(4):
assert log_array_T2[0][i] == run_results[i]
assert log_array_T2[1][i] == trial_results[i]
assert log_array_T2[2][i] == pass_results[i]
assert log_array_T2[3][i] == time_step_results[i]
assert log_array_T2[4][i] == value_results[i]
assert log_array_T2[5][i] == slope_results[i]
# CREATE THRESHOLD FUNCTION
# first value of DDM's value is DECISION_VARIABLE
def pass_threshold(mech1, mech2, thresh):
results1 = mech1.output_states[0].value
results2 = mech2.output_states[0].value
for val in results1:
if val >= thresh:
return True
for val in results2:
if val >= thresh:
return True
return False
accumulator_threshold = 1.0
terminate_trial = {
pnl.TimeScale.TRIAL: pnl.While(pass_threshold, respond_red_accumulator, respond_green_accumulator, accumulator_threshold)
}
# CREATE INITIAL CONDITION FUNCTION *** NOT WORKING
# want colors_hidden_layer to have low activity if WR is the task
# or want words_hidden_layer to have low activity if CN is the task
# in 1990 paper we want 0.01 in non-task relevant pathway hidden units, 0.5 in task relevant pathway hidden units
# and 0.5 for all of the response units
# point of clarification: when we initialize, and then present test pattern does the task input stay on?
# option to set these units to the values you want to reach, initial_value
#want to test this with
# colors_hidden_layer.log.nparray()
# colors_hidden_layer.log.print_entries()
