def default_config():
default_config = ad.core.Explorer.default_config()
default_config.stop_conditions = 200
default_config.num_of_random_initialization = 10
default_config.run_parameters = []
# representation
default_config.goal_space_representation = ad.Config()
default_config.goal_space_representation.type = None # either: 'pytorchnnrepresentation'
# online_training params
default_config.online_training = ad.Config()
default_config.online_training.output_representation_folder = './trained_representation'
default_config.online_training.n_runs_between_train_steps = 100
default_config.online_training.n_epochs_per_train_steps = 40
default_config.online_training.train_batch_size = 64
default_config.online_training.importance_sampling_new_vs_old = 0.5
default_config.online_training.dataset_constraints = []
# goal selection
default_config.goal_selection = ad.Config()
default_config.goal_selection.type = None # either: 'random', 'specific', 'function'
default_config.source_policy_selection = ad.Config()
default_config.source_policy_selection.type = 'optimal' # either: 'optimal', 'random'
default_config.source_policy_selection.constraints = []
return default_config
def default_config():
default_config = ad.core.Explorer.default_config()
default_config.stop_conditions = 200
default_config.num_of_random_initialization = 10
default_config.run_parameters = []
# representation object
default_config.goal_space_representation = None
default_config.source_parameter_selection = ad.Config()
default_config.source_parameter_selection.type = 'optimal' # either: 'optimal', 'random'
default_config.source_parameter_selection.constraints = [
] # addition constraints on the source parameters such as specific classes
default_config.source_parameter_selection.goal_space_constraints = [
] # defines constraints on the goal space for each dimension with (min, max)
# density selection parameters
default_config.source_parameter_selection.n_neighbors = 10
# control over the mutation rates for the source parameters
default_config.source_parameter_mutation = ad.Config()
default_config.source_parameter_mutation.type = 'adaptive' # either: 'adaptive', 'fixed'
default_config.source_parameter_mutation.target_mutation_distance = 0.1
default_config.source_parameter_mutation.mutation_factor_learnrate = 1
default_config.source_parameter_mutation.is_adaptive_target_mutation_distance = True
default_config.source_parameter_mutation.mutation_distance_learnrate = 0.1
return default_config
def test_statistic_goalspace():
# use lenia as test system
system = ad.systems.Lenia()
config = ad.explorers.GoalSpaceExplorer.default_config()
config.seed = 1
config.num_of_random_initialization = 2
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 2,
'max': 20
}
config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 1,
'max': 20
}
config.run_parameters.append(parameter)
# which statistics are used as a goal space
config.goal_space_representation.type = 'statistics'
config.goal_space_representation.config = ad.representations.static.StatisticRepresentation.default_config(
)
config.goal_space_representation.config.statistics = [
'activation_mass_mean', 'activation_mass_std'
]
# how are goals sampled
config.goal_selection.type = 'random'
config.goal_selection.sampling = [(0, 1), (0, 0.4)]
explorer = ad.explorers.GoalSpaceExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.shape(explorer.statistics.reached_initial_goals) == (
2, 2) # no statistics should have been computed
assert np.shape(explorer.statistics.target_goals) == (
3, 2) # no statistics should have been computed
assert np.shape(explorer.statistics.reached_goals) == (
3, 2) # no statistics should have been computed
def test_cppn_evolution():
# use lenia as test system
system = ad.systems.Lenia()
config = GoalSpaceDensityExplorer.default_config()
config.seed = 1
config.num_of_random_initialization = 2
parameter = ad.Config()
parameter.name = 'init_state'
parameter.type = 'cppn_evolution'
parameter.init = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.init.neat_config_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'test_neat_single.cfg')
parameter.init.n_generations = 1
parameter.init.best_genome_of_last_generation = True
parameter.mutate = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.mutate.neat_config_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'test_neat_single.cfg')
parameter.mutate.n_generations = 2
parameter.mutate.best_genome_of_last_generation = True
config.run_parameters.append(parameter)
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 2, 'max': 20}
config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 1, 'max': 20}
config.run_parameters.append(parameter)
# which statistics are used as a goal space
statistic_representation_config = ad.representations.static.StatisticRepresentation.default_config()
statistic_representation_config.statistics = ['activation_mass_mean',
'activation_mass_std']
config.goal_space_representation = ad.representations.static.StatisticRepresentation(config=statistic_representation_config)
# how are goals sampled
config.source_parameter_selection.type = 'random'
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
def default_config():
default_config = ad.core.Representation.default_config()
default_config.initialization = ad.Config()
default_config.initialization.type = None # either: 'random_weight', 'load_pretrained_model'
default_config.save_automatic = True
default_config.distance_function = None
default_config.preprocess_observation = ad.Config()
default_config.preprocess_observation.type = None # either: None, 'function'
return default_config
def default_gui_config():
gui_config = ad.Config()
gui_config.dialog = ad.Config()
gui_config.dialog.title = 'GUIElement'
gui_config.dialog.is_transient = False
gui_config.dialog.geometry = None
gui_config['frame'] = ad.Config()
return gui_config
def get_default_gui_config():
default_config = ad.Config()
default_config.box_layout = ad.Config()
default_config.box_layout.display = 'stretch'
default_config.box_layout.align_items = 'stretch'
default_config.experiment_selection = ad.Config()
default_config.experiment_selection.description = 'Experiment:'
default_config.experiment_selection.layout = ad.Config()
default_config.experiment_selection.layout.flex = '1 1 0%'
default_config.experiment_selection.layout.width = 'auto'
default_config.repetition_selection = ad.Config()
default_config.repetition_selection.description = 'Repetition:'
default_config.repetition_selection.layout = ad.Config()
default_config.repetition_selection.layout.flex = '1 1 0%'
default_config.repetition_selection.layout.width = 'auto'
default_config.load_button = ad.Config()
default_config.load_button.layout = ad.Config()
default_config.load_button.layout.width = '150px'
default_config.load_button.description = 'Load'
default_config.load_button.disabled = False
default_config.load_button.button_style = '' # 'success', 'info', 'warning', 'danger' or ''
default_config.load_button.tooltip = 'Load the data for the selected experiment and repetition.'
return default_config
def default_gui_config():
def_config = ad.gui.BaseFrame.default_gui_config()
def_config.dialog.title = 'Exploration Parameters'
def_config.show_system_parameters = True
def_config.show_run_parameters = True
def_config.system_parameters_config = [{'type': 'table', 'parameters': 'all'}]
def_config.run_parameters_config = [{'type': 'table', 'parameters': 'all'}]
def_config.system_parameter_label = ad.Config({'text': 'System Parameters:'})
def_config.run_parameter_label = ad.Config({'text': 'Run Parameters:'})
return def_config
def load_explorer(experiment_directory):
# load the full explorer without observations and add its config
sys.path.append(experiment_directory)
explorer = ad.explorers.GoalSpaceExplorer.load_explorer(
os.path.join(experiment_directory, 'results'),
run_ids=[],
map_location='cpu',
load_observations=False,
verbose=False)
explorer.data.config.load_observations = True
explorer.data.config.memory_size_observations = 1
spec = importlib.util.spec_from_file_location(
'experiment_config',
os.path.join(experiment_directory, 'experiment_config.py'))
experiment_config_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(experiment_config_module)
explorer.config = experiment_config_module.get_explorer_config()
# load test datasets
global test_datasets
test_datasets = []
test_dataset_config = ad.Config()
test_dataset_config.data_root = "/gpfswork/rech/zaj/ucf28eq/data/lenia_datasets/data_005/"
test_dataset_config.split = "train"
test_dataset_autodisc = LENIADataset(config=test_dataset_config)
test_datasets.append(test_dataset_autodisc)
return explorer
def default_gui_config():
def_config = DictTableGUI.default_gui_config()
def_config.dialog.title = 'Statistics'
def_config.statistics = ad.Config()
return def_config
def get_default_gui_config():
default_config = ad.Config()
# general box layout config
default_config.box_layout = ad.Config()
default_config.box_layout.flex_flow = 'column'
default_config.box_layout.display = 'flex'
default_config.box_layout.align_items = 'stretch'
# Row 0: Experiment/Repetition selection widget
default_config.exp_rep_selection_widget = ad.gui.jupyter.ExperimentRepetitionLoaderWidget.get_default_gui_config(
)
# Row 1: Latent Space viewer widget
default_config.latent_space_viewer_widget = ad.gui.jupyter.plotrepresentationspacewidget.LatentSpaceViewerWidget.get_default_gui_config(
)
return default_config
def default_config():
default_config = ad.core.Explorer.default_config()
default_config.stop_conditions = 200
default_config.num_of_random_initialization = 10
default_config.run_parameters = []
# TODO: allow the definition of arbitrary representation spaces
default_config.goal_space_representation = ad.Config()
default_config.goal_space_representation.type = None # either: 'pytorchnnrepresentation' or 'statisticsrepresentation' or 'functionrepresentation'
default_config.goal_selection = ad.Config()
default_config.goal_selection.type = None # either: 'random', 'specific', 'function'
default_config.source_policy_selection = ad.Config()
default_config.source_policy_selection.type = 'optimal' # either: 'optimal', 'random'
default_config.source_policy_selection.constraints = []
return default_config
def test_config():
config = ad.Config()
config['a'] = 1
config.b = 2
assert config.a == 1
assert config['a'] == 1
assert config.b == 2
assert config['b'] == 2
def test_statistic_goalspace():
# use lenia as test system
system = ad.systems.Lenia()
config = GoalSpaceDensityExplorer.default_config()
config.seed = 1
config.num_of_random_initialization = 2
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 2, 'max': 20}
config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 1, 'max': 20}
config.run_parameters.append(parameter)
# which statistics are used as a goal space
statistic_representation_config = ad.representations.static.StatisticRepresentation.default_config()
statistic_representation_config.statistics = ['activation_mass_mean',
'activation_mass_std']
config.goal_space_representation = ad.representations.static.StatisticRepresentation(config=statistic_representation_config)
# how are goals sampled
config.source_parameter_selection.type = 'random'
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.shape(explorer.reached_goal_library) == (5, 2)
def test_set_default_config():
# Simple
default_val = {'x': 1, 'y': -1}
config1 = ad.Config()
config1.y = 2
config1 = ad.config.set_default_config(config1, default_val)
assert config1.x == 1
assert config1.y == 2
# Nested
default_val = {'x': 1, 'y': {'z': 2}}
config2 = ad.Config()
config2.y = ad.Config()
config2.y.w = 3
config2 = ad.config.set_default_config(config2, default_val)
assert config2.x == 1
assert config2.y.z == 2
assert config2.y.w == 3
# several config:
default_val1 = {'x': 1, 'y': {'z': 2}}
default_val2 = {'y': {'z': 3}}
config3 = ad.Config()
config3.y = ad.Config()
config3.y.w = 4
config3 = ad.config.set_default_config(config3, default_val2, default_val1)
assert config3.x == 1
assert config3.y.z == 3
assert config3.y.w == 4
def test_set_default_values():
# Simple
default_val = {'x': 1}
config1 = ad.Config()
config1.y = 2
config1.set_default_values(default_val)
assert config1.x == 1
assert config1.y == 2
# Nested
default_val = {'x': 1, 'y': {'z': 2}}
config2 = ad.Config()
config2.y = ad.Config()
config2.y.w = 3
config2.set_default_values(default_val)
assert config2.x == 1
assert config2.y.z == 2
assert config2.y.w == 3
def get_default_gui_config():
default_config = ad.Config()
default_config.box_layout = ad.Config()
default_config.box_layout.flex_flow = 'column'
default_config.box_layout.display = 'flex'
default_config.box_layout.align_items = 'stretch'
default_config.experiment_repetition_loader = ad.gui.jupyter.ExperimentRepetitionLoaderWidget.get_default_gui_config(
)
default_config.filter_selection = ad.Config()
default_config.filter_selection.description = 'Filter:'
default_config.filter_selection.layout = ad.Config()
default_config.filter_selection.layout.flex = '1 1 0%'
default_config.filter_selection.layout.width = 'auto'
default_config.color_map = np.array([
[255, 255, 255], [119, 255, 255], [23, 223, 252], [0, 190, 250],
[0, 158, 249], [0, 142, 249], [81, 125, 248], [150, 109, 248],
[192, 77, 247], [232, 47, 247], [255, 9, 247], [200, 0, 84]
]) / 255 * 8
return default_config
def default_config():
def_config = ad.Config()
def_config.neat_config_file = 'neat.cfg'
def_config.matrix_size = (100, 100)
def_config.cppn_input_borders = ((-2, 2), (-2, 2))
def_config.recurrent_net_repetitions = 4 # number of iterations a recurrent nerual network is executed
def_config.n_generations = 1
def_config.is_verbose = False
def_config.is_extra_fitness_data = False # does the fitness function returns extra data that should be saved
def_config.is_pytorch = True
def_config.keep_results = 'none' # 'none', 'all_gen', 'last_gen'
def_config.fitness_function = lambda matrix, genome: 0
def_config.fitness_function_param = None
return def_config
def default_config():
default_config = ad.Config()
default_config.db_type = 'file_repetition' # 'file_repetition', 'memory'
default_config.save_automatic = False # if true it saves in the db_increment, otherwise a number of runs can be given
default_config.save_observations = True
default_config.keep_saved_runs_in_memory = True
default_config.keep_saved_observations_in_memory = True
default_config.memory_size_run_data = None # number of runs that are kept in memory: 'infinity', None - no limit, int - number of capacity, 'db_increments'
default_config.load_run_data_incremental = False
default_config.load_observations = True # should observations automatically loaded?
default_config.memory_size_observations = None # in case that observations should be loaded
default_config.load_observations_incremental = False
return default_config
def default_config():
default_config = ad.Config()
default_config.id = None
default_config.descr = None
default_config.seed = None
return default_config
def test_function_goalspace():
# use lenia as test system
system = ad.systems.Lenia()
config = GoalSpaceDensityExplorer.default_config()
config.seed = 1
config.num_of_random_initialization = 2
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 2, 'max': 20}
config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 1, 'max': 20}
config.run_parameters.append(parameter)
# which statistics are used as a goal space
goal_space_config = ad.representations.FunctionRepresentation.default_config()
goal_space_config.function = goal_space_func_without_config
config.goal_space_representation = ad.representations.FunctionRepresentation(config=goal_space_config)
# how are goals sampled
config.source_parameter_selection.type = 'random'
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.all(explorer.reached_goal_library == [[10, 20, 30], [10, 20, 30], [10, 20, 30], [10, 20, 30], [10, 20, 30]])
del explorer
#########################################################
# with config
config.goal_space_representation.config.function = goal_space_func_with_config
config.goal_space_representation.config.config = 'test'
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.all(explorer.reached_goal_library == [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]])
del explorer
#########################################################
# function as string
config.goal_space_representation.config.function = 'autodisc.test.explorers.test_goalspaceexplorer.goal_space_func_with_config'
config.goal_space_representation.config.config = 'test'
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.all(explorer.reached_goal_library == [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]])
del explorer
def test_constraint_source_policy_selection():
# use lenia as test system
system = ad.systems.Lenia()
config = GoalSpaceDensityExplorer.default_config()
config.seed = 1
config.num_of_random_initialization = 2
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 2, 'max': 20}
config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 1, 'max': 20}
config.run_parameters.append(parameter)
# which statistics are used as a goal space
statistic_representation_config = ad.representations.static.StatisticRepresentation.default_config()
statistic_representation_config.statistics = ['activation_mass_mean',
'activation_mass_std']
config.goal_space_representation = ad.representations.static.StatisticRepresentation(config=statistic_representation_config)
# how are goals sampled
config.source_parameter_selection.type = 'optimal'
#########################################################################################
# simple constraint
# how source policies are selected
config.source_parameter_selection.constraints = [('id', '==', 1)]
config.source_parameter_selection.goal_space_constraints = [(0, 1), (0, 40)]
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert explorer.data[2].source_parameter_idx == 1
assert explorer.data[3].source_parameter_idx == 1
assert explorer.data[4].source_parameter_idx == 1
#########################################################################################
# active settings TRUE / FALSE
# how source policies are selected
config.source_parameter_selection.constraints = [dict(active = False,
filter = ('id', '==', 1)),
dict(active=True,
filter=('id', '==', 0))
]
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert explorer.data[2].source_parameter_idx == 0
assert explorer.data[3].source_parameter_idx == 0
assert explorer.data[4].source_parameter_idx == 0
#########################################################################################
# active settings as constraint
# how source policies are selected
config.source_parameter_selection.constraints = [dict(active = (('max', 'id'), '<', 3),
filter = ('id', '==', 1)),
dict(active = (('max', 'id'), '>=', 3),
filter=('id', '==', 0))
]
explorer = GoalSpaceDensityExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert explorer.data[2].source_parameter_idx == 1
assert explorer.data[3].source_parameter_idx == 1
assert explorer.data[4].source_parameter_idx == 0
for node_idx in range(len(all_nodes_outputs)):
cur_node_path = all_nodes_outputs[node_idx][0][0]
cur_node_outputs = all_nodes_outputs[node_idx][1]
cur_z = cur_node_outputs['z'].squeeze().detach().cpu().numpy()
data[cur_node_path].append(cur_z)
for node_path in model.network.get_node_pathes():
data[node_path] = np.stack(data[node_path], axis=0)
return data
if __name__ == '__main__':
# Load external dataset of 3000 images (half SLP and half TLP)
test_dataset_config = ad.Config()
test_dataset_config.data_root = "/gpfswork/rech/zaj/ucf28eq/data/lenia_datasets/data_005/"
test_dataset_config.split = "test"
test_dataset = LENIADataset(config=test_dataset_config)
# uncomment following lines for debugging
# test_dataset.n_images = 20
# test_dataset.labels = torch.cat([test_dataset.labels[:10], test_dataset.labels[-10:]])
# test_dataset.images = torch.cat([test_dataset.images[:10], test_dataset.images[-10:]])
# Load checkpoints per training stage
checkpoint_filepath = "training/checkpoints/*.pth"
checkpoint_matches = glob(checkpoint_filepath)
staged_models = {}
for match in checkpoint_matches:
if "stage_" not in match:
def test_function_goalspace():
# use lenia as test system
system = ad.systems.Lenia()
config = ad.explorers.GoalSpaceExplorer.default_config()
config.seed = 1
config.num_of_random_initialization = 2
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 2,
'max': 20
}
config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 1,
'max': 20
}
config.run_parameters.append(parameter)
# which statistics are used as a goal space
config.goal_space_representation.type = 'function'
config.goal_space_representation.config = ad.representations.FunctionRepresentation.default_config(
)
config.goal_space_representation.config.function = goal_space_func_without_config
# how are goals sampled
config.goal_selection.type = 'random'
config.goal_selection.sampling = [(0, 1), (0, 0.4), (0, 0.5)]
explorer = ad.explorers.GoalSpaceExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.shape(explorer.statistics.reached_initial_goals) == (
2, 3) # no statistics should have been computed
assert np.shape(explorer.statistics.target_goals) == (
3, 3) # no statistics should have been computed
assert np.shape(explorer.statistics.reached_goals) == (
3, 3) # no statistics should have been computed
assert np.all(explorer.statistics.reached_goals ==
[[10, 20, 30], [10, 20, 30], [10, 20, 30]])
del explorer
#########################################################
# with config
config.goal_space_representation.config.function = goal_space_func_with_config
config.goal_space_representation.config.config = 'test'
explorer = ad.explorers.GoalSpaceExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.shape(explorer.statistics.reached_initial_goals) == (
2, 3) # no statistics should have been computed
assert np.shape(explorer.statistics.target_goals) == (
3, 3) # no statistics should have been computed
assert np.shape(explorer.statistics.reached_goals) == (
3, 3) # no statistics should have been computed
assert np.all(
explorer.statistics.reached_goals == [[1, 2, 3], [1, 2, 3], [1, 2, 3]])
del explorer
#########################################################
# function as string
config.goal_space_representation.config.function = 'autodisc.test.explorers.test_goalspaceexplorer.goal_space_func_with_config'
config.goal_space_representation.config.config = 'test'
explorer = ad.explorers.GoalSpaceExplorer(system=system, config=config)
explorer.run(5, verbose=False)
assert len(explorer.data) == 5
assert np.shape(explorer.statistics.reached_initial_goals) == (
2, 3) # no statistics should have been computed
assert np.shape(explorer.statistics.target_goals) == (
3, 3) # no statistics should have been computed
assert np.shape(explorer.statistics.reached_goals) == (
3, 3) # no statistics should have been computed
assert np.all(
explorer.statistics.reached_goals == [[1, 2, 3], [1, 2, 3], [1, 2, 3]])
del explorer
def get_explorer_config():
explorer_config = ad.explorers.GoalSpaceExplorer.default_config()
explorer_config.seed = 0
explorer_config.num_of_random_initialization = 1000
explorer_config.run_parameters = []
# Parameter 1: init state
parameter = ad.Config()
parameter.name = 'init_state'
parameter.type = 'cppn_evolution'
parameter.init = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.init.neat_config_file = 'neat_config.cfg'
parameter.init.n_generations = 1
parameter.init.best_genome_of_last_generation = True
parameter.mutate = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.mutate.neat_config_file = 'neat_config.cfg'
parameter.mutate.n_generations = 2
parameter.mutate.best_genome_of_last_generation = True
explorer_config.run_parameters.append(parameter)
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 2,
'max': 20
}
explorer_config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 1,
'max': 20
}
explorer_config.run_parameters.append(parameter)
# Parameter 4: b
parameter = ad.Config()
parameter.name = 'b'
parameter.type = 'sampling'
parameter.init = ('function', ad.helper.sampling.sample_vector,
(('discrete', 1, 3), (0, 1)))
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.05,
'min': 0,
'max': 1
}
explorer_config.run_parameters.append(parameter)
# Parameter 5: m
parameter = ad.Config()
parameter.name = 'm'
parameter.type = 'sampling'
parameter.init = ('continuous', 0, 1)
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.05,
'min': 0,
'max': 1
}
explorer_config.run_parameters.append(parameter)
# Parameter 6: s
parameter = ad.Config()
parameter.name = 's'
parameter.type = 'sampling'
parameter.init = ('continuous', 0.001, 0.3)
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.01,
'min': 0.001,
'max': 0.3
}
explorer_config.run_parameters.append(parameter)
# which statistics are used as a goal space
explorer_config.goal_space_representation.type = 'pytorchnnrepresentation'
explorer_config.goal_space_representation.config = ad.representations.static.PytorchNNRepresentation.default_config(
)
explorer_config.goal_space_representation.config.initialization = ad.Config(
)
explorer_config.goal_space_representation.config.initialization.type = 'load_pretrained_model'
explorer_config.goal_space_representation.config.initialization.load_from_model_path = '../../../../pre_train_imgep_pgl_goalspace/experiments/experiment_000018/training/models/best_weight_model.pth'
# how are goals sampled
explorer_config.goal_selection.type = 'random'
explorer_config.goal_selection.sampling = [(-3, 3)] * 8
# how are the source policies for a mutation are selected
explorer_config.source_policy_selection.type = 'optimal'
return explorer_config
def get_explorer_config():
explorer_config = ad.explorers.GoalSpaceExplorer.default_config()
explorer_config.seed = 5
explorer_config.num_of_random_initialization = 1000
explorer_config.run_parameters = []
# Parameter 1: init state
parameter = ad.Config()
parameter.name = 'init_state'
parameter.type = 'cppn_evolution'
parameter.init = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.init.neat_config_file = 'neat_config.cfg'
parameter.init.n_generations = 1
parameter.init.best_genome_of_last_generation = True
parameter.mutate = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.mutate.neat_config_file = 'neat_config.cfg'
parameter.mutate.n_generations = 2
parameter.mutate.best_genome_of_last_generation = True
explorer_config.run_parameters.append(parameter)
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 2,
'max': 20
}
explorer_config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 1,
'max': 20
}
explorer_config.run_parameters.append(parameter)
# Parameter 4: b
parameter = ad.Config()
parameter.name = 'b'
parameter.type = 'sampling'
parameter.init = ('function', ad.helper.sampling.sample_vector,
(('discrete', 1, 3), (0, 1)))
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.05,
'min': 0,
'max': 1
}
explorer_config.run_parameters.append(parameter)
# Parameter 5: m
parameter = ad.Config()
parameter.name = 'm'
parameter.type = 'sampling'
parameter.init = ('continuous', 0, 1)
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.05,
'min': 0,
'max': 1
}
explorer_config.run_parameters.append(parameter)
# Parameter 6: s
parameter = ad.Config()
parameter.name = 's'
parameter.type = 'sampling'
parameter.init = ('continuous', 0.001, 0.3)
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.01,
'min': 0.001,
'max': 0.3
}
explorer_config.run_parameters.append(parameter)
# which statistics are used as a goal space
explorer_config.goal_space_representation.type = 'statisticsrepresentation'
explorer_config.goal_space_representation.config = ad.representations.static.StatisticRepresentation.default_config(
)
explorer_config.goal_space_representation.config.statistics = [
'activation_mass[-1]', 'activation_volume[-1]',
'activation_mass_distribution[-1]'
]
explorer_config.goal_space_representation.config.distance_function = ad.systems.lenia.LeniaStatistics.calc_goalspace_distance
# how are goals sampled
explorer_config.goal_selection.type = 'random'
explorer_config.goal_selection.sampling = [(0, 1), (0, 1), (0, 1)]
# how are the source policies for a mutation are selected
explorer_config.source_policy_selection.type = 'optimal'
return explorer_config
def get_explorer_config():
explorer_config = ad.explorers.OnlineLearningGoalExplorer.default_config()
explorer_config.seed = 3
explorer_config.num_of_random_initialization = 1000
explorer_config.run_parameters = []
# Parameter 1: init state
parameter = ad.Config()
parameter.name = 'init_state'
parameter.type = 'cppn_evolution'
parameter.init = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.init.neat_config_file = 'neat_config.cfg'
parameter.init.n_generations = 1
parameter.init.best_genome_of_last_generation = True
parameter.mutate = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.mutate.neat_config_file = 'neat_config.cfg'
parameter.mutate.n_generations = 2
parameter.mutate.best_genome_of_last_generation = True
explorer_config.run_parameters.append(parameter)
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 2,
'max': 20
}
explorer_config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {
'type': 'discrete',
'distribution': 'gauss',
'sigma': 0.5,
'min': 1,
'max': 20
}
explorer_config.run_parameters.append(parameter)
# Parameter 4: b
parameter = ad.Config()
parameter.name = 'b'
parameter.type = 'sampling'
parameter.init = ('function', ad.helper.sampling.sample_vector,
(('discrete', 1, 3), (0, 1)))
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.05,
'min': 0,
'max': 1
}
explorer_config.run_parameters.append(parameter)
# Parameter 5: m
parameter = ad.Config()
parameter.name = 'm'
parameter.type = 'sampling'
parameter.init = ('continuous', 0, 1)
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.05,
'min': 0,
'max': 1
}
explorer_config.run_parameters.append(parameter)
# Parameter 6: s
parameter = ad.Config()
parameter.name = 's'
parameter.type = 'sampling'
parameter.init = ('continuous', 0.001, 0.3)
parameter.mutate = {
'type': 'continuous',
'distribution': 'gauss',
'sigma': 0.01,
'min': 0.001,
'max': 0.3
}
explorer_config.run_parameters.append(parameter)
# which statistics are used as a goal space
explorer_config.goal_space_representation.type = 'pytorchnnrepresentation'
explorer_config.goal_space_representation.config = ad.representations.static.PytorchNNRepresentation.default_config(
)
explorer_config.goal_space_representation.config.initialization = ad.Config(
)
explorer_config.goal_space_representation.config.initialization.type = 'random_weight'
explorer_config.goal_space_representation.config.initialization.load_from_model_path = ''
explorer_config.goal_space_representation.config.initialization.model_type = 'BetaVAE'
system_params = get_system_parameters()
explorer_config.goal_space_representation.config.initialization.model_init_params = {
'n_latents': 8,
'beta': 5.0,
'add_var_to_KLD_loss': True,
'input_size': (system_params.size_y, system_params.size_x),
'num_classes': 3
}
#online training parameters
explorer_config.online_training.output_representation_folder = './trained_representation'
explorer_config.online_training.n_runs_between_train_steps = 100
explorer_config.online_training.n_epochs_per_train_steps = 40
explorer_config.online_training.train_batch_size = 64
explorer_config.online_training.importance_sampling_new_vs_old = 0.5
explorer_config.online_training.dataset_constraints = [
dict(active=True, filter=('statistics.is_dead', '==', False))
]
# how are goals sampled
explorer_config.goal_selection.type = 'random'
explorer_config.goal_selection.sampling = [
(-3, 3)
] * explorer_config.goal_space_representation.config.initialization.model_init_params[
'n_latents']
# how are the source policies for a mutation are selected
explorer_config.source_policy_selection.type = 'optimal'
return explorer_config
def default_system_parameters():
return ad.Config()
def get_explorer_config():
explorer_config = ad.explorers.ProgressiveExplorer.default_config()
explorer_config.seed = 4
explorer_config.num_of_random_initialization = 1000
explorer_config.run_parameters = []
# Parameter 1: init state
parameter = ad.Config()
parameter.name = 'init_state'
parameter.type = 'cppn_evolution'
parameter.init = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.init.neat_config_file = 'neat_config.cfg'
parameter.init.n_generations = 1
parameter.init.best_genome_of_last_generation = True
parameter.mutate = ad.cppn.TwoDMatrixCCPNNEATEvolution.default_config()
parameter.mutate.neat_config_file = 'neat_config.cfg'
parameter.mutate.n_generations = 2
parameter.mutate.best_genome_of_last_generation = True
explorer_config.run_parameters.append(parameter)
# Parameter 2: R
parameter = ad.Config()
parameter.name = 'R'
parameter.type = 'sampling'
parameter.init = ('discrete', 2, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 2, 'max': 20}
explorer_config.run_parameters.append(parameter)
# Parameter 3: T
parameter = ad.Config()
parameter.name = 'T'
parameter.type = 'sampling'
parameter.init = ('discrete', 1, 20)
parameter.mutate = {'type': 'discrete', 'distribution': 'gauss', 'sigma': 0.5, 'min': 1, 'max': 20}
explorer_config.run_parameters.append(parameter)
# Parameter 4: b
parameter = ad.Config()
parameter.name = 'b'
parameter.type = 'sampling'
parameter.init = ('function', ad.helper.sampling.sample_vector, (('discrete', 1, 3), (0, 1)))
parameter.mutate = {'type': 'continuous', 'distribution': 'gauss', 'sigma': 0.1, 'min': 0, 'max': 1}
explorer_config.run_parameters.append(parameter)
# Parameter 5: m
parameter = ad.Config()
parameter.name = 'm'
parameter.type = 'sampling'
parameter.init = ('continuous', 0, 1)
parameter.mutate = {'type': 'continuous', 'distribution': 'gauss', 'sigma': 0.1, 'min': 0, 'max': 1}
explorer_config.run_parameters.append(parameter)
# Parameter 6: s
parameter = ad.Config()
parameter.name = 's'
parameter.type = 'sampling'
parameter.init = ('continuous', 0.001, 0.3)
parameter.mutate = {'type': 'continuous', 'distribution': 'gauss', 'sigma': 0.05, 'min': 0.001, 'max': 0.3}
explorer_config.run_parameters.append(parameter)
# visual representation
explorer_config.visual_representation = gr.representations.SingleModelRepresentation.default_config()
explorer_config.visual_representation.seed = 4
explorer_config.visual_representation.training.output_folder = "./training"
explorer_config.visual_representation.model.name = "ProgressiveTree"
explorer_config.visual_representation.model.config = get_model_config(explorer_config.visual_representation.model.name)
# goal space selection
explorer_config.goal_space_selection.type = 'random'
if explorer_config.goal_space_selection.type in ['probability_distribution']:
explorer_config.goal_space_selection.distribution = None
elif explorer_config.goal_space_selection.type in ['adaptive']:
explorer_config.goal_space_selection.measure = ad.Config()
explorer_config.goal_space_selection.measure.type = 'None'
explorer_config.goal_space_selection.measure.n_steps = None
if None is not None and None is not None:
raise ValueError('Only explorer_config.goal_space_selection.measure.n_bins_per_dimension or explorer_config.goal_space_selection.measure.n_bins can be defined!')
if None is not None:
explorer_config.goal_space_selection.measure.diversity = ad.Config()
explorer_config.goal_space_selection.measure.diversity.type = 'NBinDiversityNBinPerDim'
explorer_config.goal_space_selection.measure.diversity.n_bins_per_dimension = None
elif None is not None:
explorer_config.goal_space_selection.measure.diversity = ad.Config()
explorer_config.goal_space_selection.measure.diversity.type = 'NBinDiversityNBins'
explorer_config.goal_space_selection.measure.diversity.n_bins = None
# add constraint to the diversity measure
explorer_config.goal_space_selection.measure.update_constraints = dict( active = False)
explorer_config.goal_space_selection.selection_algo = ad.Config()
explorer_config.goal_space_selection.selection_algo.type = 'None'
if explorer_config.goal_space_selection.selection_algo.type in ['epsilon_greedy']:
explorer_config.goal_space_selection.selection_algo.epsilon = None
elif explorer_config.goal_space_selection.selection_algo.type in ['softmax']:
explorer_config.goal_space_selection.selection_algo.beta = None
elif explorer_config.goal_space_selection.selection_algo.type in ['epsilon_softmax']:
explorer_config.goal_space_selection.selection_algo.epsilon = None
explorer_config.goal_space_selection.selection_algo.beta = None
# goal selection
explorer_config.goal_selection.type = 'random'
explorer_config.goal_selection.sampling_from_reached_boundaries = ad.Config()
explorer_config.goal_selection.sampling_from_reached_boundaries.margin_min = 0
explorer_config.goal_selection.sampling_from_reached_boundaries.margin_max = 0
# progressive growing parameters
explorer_config.progressive_growing.split_trigger = ad.Config(dict(active = False))
explorer_config.progressive_growing.split_trigger.boundary_config = {}
# progressive training parameters
explorer_config.progressive_training.dataset_constraints = [dict( active = True, filter = ('statistics.is_dead', '==', False))]
explorer_config.progressive_training.dataset_augment = True
explorer_config.progressive_training.n_runs_between_stages = 100
explorer_config.progressive_training.n_epochs_per_stage = 100
explorer_config.progressive_training.train_batch_size = 128
explorer_config.progressive_training.importance_sampling_new_vs_old = 0.3
explorer_config.progressive_training.alternated_backward = {"active": False}
# how are the source policies for a mutation are selected
explorer_config.source_policy_selection.type = 'optimal'
explorer_config.source_policy_selection.constraints = []
return explorer_config
def default_config():
return ad.Config()
