def run_measurements_for_task0(custom_durations: bool = False):
args = parse_test_args()
if custom_durations:
curriculum_tuple = (
2000, -1
) # dev curriculum, 15 minutes of runtime (or your own duration)
else:
curriculum_tuple = (
0, -1) # evaluation curriculum, 2 hours 40 minutes of runtime
params = [{'curriculum': curriculum_tuple}]
# one expert topology
topology = SeT0BasicTopology
run_measurement_task0(topology.__name__,
params,
args,
topology_class=topology)
# narrow hierarchy
topology = SeT0NarrowHierarchy
run_measurement_task0(topology.__name__,
params,
args,
topology_class=topology)
# conv SP
topology = SeT0ConvSPTopology
run_measurement_task0(topology.__name__,
params,
args,
topology_class=topology)
def reward_hint(run_debug, run_gui, n_parallel_runs):
world_params = GridWorldParams(map_name='Friston', reward_switching=True)
c_n_ccs = 19
params = [{
'model': {
'c_n_ccs': c_n_ccs,
'c_seq_length': 4,
'c_seq_lookahead': 2,
'c_buffer_size': 7000,
'p_seq_length': 6,
'p_seq_lookahead': 4,
'p_n_ccs': 6,
'flock_size': n_parallel_runs
},
'params': {
'use_egocentric': True,
'n_parallel_runs': n_parallel_runs,
'world_params': world_params
},
}]
run_measurement(params,
parse_test_args(),
run_debug,
avg_reward_window_size=499,
run_gui=run_gui)
def three_rooms_tiny(run_debug, run_gui, n_parallel_runs):
world_params = GridWorldParams(map_name='MapThreeRoomTiny',
reset_strategy=ResetStrategy.ANYWHERE)
# 4 actions per each world state.
# c_n_ccs = world_params.get_n_unique_visible_egocentric_states() * 4
c_n_ccs = 44
params = [{
'model': {
'c_n_ccs': c_n_ccs,
'c_seq_length': 5,
'c_seq_lookahead': 3,
'c_buffer_size': 10000,
'p_seq_length': 7,
'p_seq_lookahead': 5,
'p_n_ccs': 5,
'flock_size': n_parallel_runs
},
'params': {
'use_egocentric': False,
'n_parallel_runs': n_parallel_runs,
'world_params': world_params
},
}]
run_measurement(params,
parse_test_args(),
run_debug,
avg_reward_window_size=499,
run_gui=run_gui)
def run_measurements_for_task1(custom_durations: bool = False):
args = parse_test_args()
if custom_durations:
curriculum_tuple = (
2001, -1
) # dev curriculum, 15 minutes of runtime (or your own duration)
else:
curriculum_tuple = (
10010, 1, -1
) # evaluation curriculum with pre-training, 6 hours 20 minutes of runtime
params = [{'curriculum': curriculum_tuple}]
# one expert topology
topology = SeT1Bt
run_measurement_task1(topology.__name__,
params,
args,
topology_class=topology)
run_measurement(name, params, args, max_steps)
def run_gui(args):
name = 'gui'
params = [
{
'num_cc': [400, 150, 150],
'lr': [0.5, 0.1, 0.1],
'batch_s': [3000, 1000, 700],
'label_scale': 0.1
},
]
if __name__ == '__main__':
arg = parse_test_args()
# num_steps = 100000
# num_steps = 800
# num_steps = 20000
# num_steps = 7000
num_steps = None
# run_debug(arg, num_steps)
run_learning_rate(arg, num_steps)
#run_multiplier(arg, num_steps)
#run_num_cc(arg, num_steps)
# run_num_cc_short(arg, num_steps)
#run_seq_len(arg, num_steps)
def run_measurements_for_task0(custom_durations: bool = False):
"""Runs just the SPFlock on SEDatasetNode."""
args = parse_test_args()
# curriculum = (0, -1) # we're using dataset 0
# *******************************************************
# stable data, different params (~ hyperparameter search)
# - class filter
# - location filter
# - number of cluster centers
# - buffer size
# - sampling strategy
lf = 1.0
ccs = 200
cf = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
default_params_a = [{'location_filter': lf, 'num_ccs': ccs}]
params_class_filter, run_labels_class_filter = extend_with_class_filter_params(
default_params_a)
extend_with_phase_information(params_class_filter)
default_params_b = [{'class_filter': cf, 'num_ccs': ccs}]
params_location_filter, run_labels_location_filter = extend_with_location_filter_params(
default_params_b)
extend_with_phase_information(params_location_filter)
default_params_c = [{
'class_filter': cf,
'location_filter': lf,
'sampling_method': SamplingMethod.BALANCED,
'buffer_size': 5000
}]
params_cluster_centers, run_labels_cluster_centers = extend_with_cluster_center_params(
default_params_c)
extend_with_phase_information(params_cluster_centers)
default_params_d = [{
'class_filter': cf,
'location_filter': lf,
'num_ccs': ccs
}]
params_buffer_size, run_labels_buffer_size = extend_with_buffer_size_params(
default_params_d)
extend_with_phase_information(params_buffer_size)
default_params_e = [{
'class_filter': cf,
'location_filter': lf,
'num_ccs': ccs
}]
params_sampling_method, run_labels_sampling_method = extend_with_sampling_method_params(
default_params_e)
extend_with_phase_information(params_sampling_method)
topology = SeT0BasicTopologyRT211Phased
run_measurement_task0("EXPERIMENT WITH CLASS FILTER", params_class_filter,
args, topology, run_labels_class_filter)
run_measurement_task0("EXPERIMENT WITH LOCATION FILTER",
params_location_filter, args, topology,
run_labels_location_filter)
run_measurement_task0("EXPERIMENT WITH NUMBER OF CLUSTER CENTERS",
params_cluster_centers, args, topology,
run_labels_cluster_centers)
run_measurement_task0("EXPERIMENT WITH BUFFER SIZE", params_buffer_size,
args, topology, run_labels_buffer_size)
run_measurement_task0("EXPERIMENT WITH BUFFER SAMPLING METHOD",
params_sampling_method, args, topology,
run_labels_sampling_method)
# ************************************************
# shifting data, different ways how the data shift
topology = SeT0BasicTopologyRT211Phased
# abrupt shift of data
cl_a = [6, 7, 8, 9, 10]
cl_b = [1, 2, 3, 4, 5]
cl_c = [11, 12, 13, 14, 15]
phase_param1 = SeObjectsTaskPhaseParams(class_filter=cl_a + cl_b,
is_training=True,
num_steps=TRAINING_PHASE_STEPS,
location_filter=1.0)
phase_param2 = SeObjectsTaskPhaseParams(class_filter=cl_a + cl_c,
is_training=True,
num_steps=TRAINING_PHASE_STEPS,
location_filter=1.0)
phase_test_a = SeObjectsTaskPhaseParams(class_filter=cl_b,
is_training=False,
num_steps=TESTING_PHASE_STEPS,
location_filter=1.0)
phase_test_b = SeObjectsTaskPhaseParams(class_filter=cl_c,
is_training=False,
num_steps=TESTING_PHASE_STEPS,
location_filter=1.0)
first_part = [phase_param1, phase_test_a]
second_part = [phase_param2, phase_test_a]
phase_params = first_part * NUM_TRAINING_PHASES_DIV_2 + second_part * NUM_TRAINING_PHASES_DIV_2
default_params_abrupt_a = [{'num_ccs': ccs, 'phase_params': phase_params}]
run_measurement_task0("EXPERIMENT WITH ABRUPT DISTRIBUTION CHANGE A",
default_params_abrupt_a, args, topology,
["abrupt distr. change, old data"])
first_part = [phase_param1, phase_test_b]
second_part = [phase_param2, phase_test_b]
phase_params = first_part * NUM_TRAINING_PHASES_DIV_2 + second_part * NUM_TRAINING_PHASES_DIV_2
default_params_abrupt_b = [{'num_ccs': ccs, 'phase_params': phase_params}]
run_measurement_task0("EXPERIMENT WITH ABRUPT DISTRIBUTION CHANGE B",
default_params_abrupt_b, args, topology,
["abrupt distr. change, new data"])
# gradual shift of data
cl_all = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
]
phase_params = []
for i in range(0, NUM_TRAINING_PHASES_DIV_2):
# train with narrow location data and measure
first_part = SeObjectsTaskPhaseParams(class_filter=cl_all,
is_training=True,
num_steps=TRAINING_PHASE_STEPS,
location_filter=0.2)
second_part = SeObjectsTaskPhaseParams(class_filter=cl_all,
is_training=False,
num_steps=TESTING_PHASE_STEPS,
location_filter=0.2)
phase_params.append(first_part)
phase_params.append(second_part)
for i in range(0, NUM_TRAINING_PHASES_DIV_2):
# then test re-learning with increasing range of location data
location_filter = round(
0.2 + (0.8 * (i + 1) / NUM_TRAINING_PHASES_DIV_2), 2)
first_part = SeObjectsTaskPhaseParams(class_filter=cl_all,
is_training=True,
num_steps=TRAINING_PHASE_STEPS,
location_filter=location_filter)
second_part = SeObjectsTaskPhaseParams(class_filter=cl_all,
is_training=False,
num_steps=TESTING_PHASE_STEPS,
location_filter=0.2)
phase_params.append(first_part)
phase_params.append(second_part)
default_params_gradual = [{'num_ccs': ccs, 'phase_params': phase_params}]
run_measurement_task0("EXPERIMENT WITH GRADUAL DISTRIBUTION CHANGE",
default_params_gradual, args, topology,
["gradual distr. change, locations"])
