def test_setup(self):
optimizer_parameters = EvolutionStrategiesParameters(
learning_rate=0.1,
noise_std=1.0,
mirrored_sampling_enabled=True,
fitness_shaping_enabled=True,
pop_size=1,
n_iteration=1,
stop_criterion=np.Inf,
seed=1)
optimizer = EvolutionStrategiesOptimizer(
self.trajectory,
optimizee_create_individual=self.optimizee.create_individual,
optimizee_fitness_weights=(-1.,),
parameters=optimizer_parameters,
optimizee_bounding_func=self.optimizee.bounding_func)
self.assertIsNotNone(optimizer.parameters)
self.assertIsNotNone(self.experiment)
try:
self.experiment.run_experiment(optimizee=self.optimizee,
optimizee_parameters=self.optimizee_parameters,
optimizer=optimizer,
optimizer_parameters=optimizer_parameters)
except Exception as e:
self.fail(e.__name__)
best = self.experiment.optimizer.best_individual['coords']
self.assertEqual(best[0], 0.7945654106889819)
self.assertEqual(best[1], 1.5914885207715055)
self.experiment.end_experiment(optimizer)
def run_experiment():
experiment = Experiment("../results/")
name = 'L2L-FUN-ES'
trajectory_name = 'mirroring-and-fitness-shaping'
traj, all_jube_params = experiment.prepare_experiment(
name=name, trajectory_name=trajectory_name, log_stdout=True)
## Benchmark function
function_id = 14
bench_functs = BenchmarkedFunctions()
(benchmark_name, benchmark_function), benchmark_parameters = \
bench_functs.get_function_by_index(function_id, noise=True)
optimizee_seed = 200
## Innerloop simulator
optimizee = FunctionGeneratorOptimizee(traj,
benchmark_function,
seed=optimizee_seed)
## Outerloop optimizer initialization
optimizer_seed = 1234
parameters = EvolutionStrategiesParameters(learning_rate=0.1,
noise_std=1.0,
mirrored_sampling_enabled=True,
fitness_shaping_enabled=True,
pop_size=20,
n_iteration=1000,
stop_criterion=np.Inf,
seed=optimizer_seed)
optimizer = EvolutionStrategiesOptimizer(
traj,
optimizee_create_individual=optimizee.create_individual,
optimizee_fitness_weights=(-1., ),
parameters=parameters,
optimizee_bounding_func=optimizee.bounding_func)
# Run experiment
experiment.run_experiment(optimizer=optimizer,
optimizee=optimizee,
optimizer_parameters=parameters)
# End experiment
experiment.end_experiment(optimizer)
def run_experiment():
name = 'L2L-MNIST-ES'
trajectory_name = 'mirroring-and-fitness-shaping'
experiment = Experiment("../results/")
traj, all_jube_params = experiment.prepare_experiment(name=name,
trajectory_name=trajectory_name,
log_stdout=True)
optimizee_seed = 200
optimizee_parameters = MNISTOptimizeeParameters(n_hidden=10, seed=optimizee_seed, use_small_mnist=True)
## Innerloop simulator
optimizee = MNISTOptimizee(traj, optimizee_parameters)
## Outerloop optimizer initialization
optimizer_seed = 1234
optimizer_parameters = EvolutionStrategiesParameters(
learning_rate=0.1,
noise_std=0.1,
mirrored_sampling_enabled=True,
fitness_shaping_enabled=True,
pop_size=20,
n_iteration=2000,
stop_criterion=np.Inf,
seed=optimizer_seed)
optimizer = EvolutionStrategiesOptimizer(
traj,
optimizee_create_individual=optimizee.create_individual,
optimizee_fitness_weights=(1.,),
parameters=optimizer_parameters,
optimizee_bounding_func=optimizee.bounding_func)
# Run experiment
experiment.run_experiment(optimizer=optimizer, optimizee=optimizee,
optimizer_parameters=optimizer_parameters,
optimizee_parameters=optimizee_parameters)
# End experiment
experiment.end_experiment(optimizer)
def run_experiment():
name = 'L2L-MNIST-ES'
try:
with open('bin/path.conf') as f:
root_dir_path = f.read().strip()
except FileNotFoundError:
raise FileNotFoundError(
"You have not set the root path to store your results."
" Write the path to a path.conf text file in the bin directory"
" before running the simulation")
trajectory_name = 'small-mnist-full-monty-100-hidden'
paths = Paths(name,
dict(run_num='test'),
root_dir_path=root_dir_path,
suffix="-" + trajectory_name)
print("All output logs can be found in directory ", paths.logs_path)
# Create an environment that handles running our simulation
# This initializes an environment
env = Environment(
trajectory=trajectory_name,
filename=paths.output_dir_path,
file_title='{} data'.format(name),
comment='{} data'.format(name),
add_time=True,
automatic_storing=True,
log_stdout=False, # Sends stdout to logs
)
create_shared_logger_data(logger_names=['bin', 'optimizers'],
log_levels=['INFO', 'INFO'],
log_to_consoles=[True, True],
sim_name=name,
log_directory=paths.logs_path)
configure_loggers()
# Get the trajectory from the environment
traj = env.trajectory
optimizee_seed = 200
optimizee_parameters = MNISTOptimizeeParameters(n_hidden=10,
seed=optimizee_seed,
use_small_mnist=True)
## Innerloop simulator
optimizee = MNISTOptimizee(traj, optimizee_parameters)
logger.info("Optimizee parameters: %s", optimizee_parameters)
## Outerloop optimizer initialization
optimizer_seed = 1234
optimizer_parameters = EvolutionStrategiesParameters(
learning_rate=0.1,
noise_std=0.1,
mirrored_sampling_enabled=True,
fitness_shaping_enabled=True,
pop_size=20,
n_iteration=2000,
stop_criterion=np.Inf,
seed=optimizer_seed)
logger.info("Optimizer parameters: %s", optimizer_parameters)
optimizer = EvolutionStrategiesOptimizer(
traj,
optimizee_create_individual=optimizee.create_individual,
optimizee_fitness_weights=(1., ),
parameters=optimizer_parameters,
optimizee_bounding_func=optimizee.bounding_func)
# Add post processing
env.add_postprocessing(optimizer.post_process)
# Run the simulation with all parameter combinations
env.run(optimizee.simulate)
# Finally disable logging and close all log-files
env.disable_logging()
return traj.v_storage_service.filename, traj.v_name, paths
def run_experiment():
name = 'L2L-FUN-ES'
try:
with open('bin/path.conf') as f:
root_dir_path = f.read().strip()
except FileNotFoundError:
raise FileNotFoundError(
"You have not set the root path to store your results."
" Write the path to a path.conf text file in the bin directory"
" before running the simulation")
trajectory_name = 'mirroring-and-fitness-shaping'
paths = Paths(name,
dict(run_num='test'),
root_dir_path=root_dir_path,
suffix="-" + trajectory_name)
print("All output logs can be found in directory ", paths.logs_path)
# Create an environment that handles running our simulation
# This initializes an environment
env = Environment(
trajectory=trajectory_name,
filename=paths.output_dir_path,
file_title='{} data'.format(name),
comment='{} data'.format(name),
add_time=True,
automatic_storing=True,
log_stdout=False, # Sends stdout to logs
)
create_shared_logger_data(logger_names=['bin', 'optimizers'],
log_levels=['INFO', 'INFO'],
log_to_consoles=[True, True],
sim_name=name,
log_directory=paths.logs_path)
configure_loggers()
# Get the trajectory from the environment
traj = env.trajectory
# Set JUBE params
traj.f_add_parameter_group("JUBE_params", "Contains JUBE parameters")
traj.f_add_parameter_to_group(
"JUBE_params", "exec", "python " +
os.path.join(paths.simulation_path, "run_files/run_optimizee.py"))
# Paths
traj.f_add_parameter_to_group("JUBE_params", "paths", paths)
## Benchmark function
function_id = 14
bench_functs = BenchmarkedFunctions()
(benchmark_name, benchmark_function), benchmark_parameters = \
bench_functs.get_function_by_index(function_id, noise=True)
optimizee_seed = 200
random_state = np.random.RandomState(seed=optimizee_seed)
function_tools.plot(benchmark_function, random_state)
## Innerloop simulator
optimizee = FunctionGeneratorOptimizee(traj,
benchmark_function,
seed=optimizee_seed)
# Prepare optimizee for jube runs
jube.prepare_optimizee(optimizee, paths.simulation_path)
## Outerloop optimizer initialization
optimizer_seed = 1234
parameters = EvolutionStrategiesParameters(learning_rate=0.1,
noise_std=1.0,
mirrored_sampling_enabled=True,
fitness_shaping_enabled=True,
pop_size=20,
n_iteration=1000,
stop_criterion=np.Inf,
seed=optimizer_seed)
optimizer = EvolutionStrategiesOptimizer(
traj,
optimizee_create_individual=optimizee.create_individual,
optimizee_fitness_weights=(-1., ),
parameters=parameters,
optimizee_bounding_func=optimizee.bounding_func)
# Add post processing
env.add_postprocessing(optimizer.post_process)
# Run the simulation with all parameter combinations
env.run(optimizee.simulate)
## Outerloop optimizer end
optimizer.end(traj)
# Finally disable logging and close all log-files
env.disable_logging()
return traj.v_storage_service.filename, traj.v_name, paths
def run_experiment():
name = 'L2L-FUN-ES'
try:
with open('bin/path.conf') as f:
root_dir_path = f.read().strip()
except FileNotFoundError:
raise FileNotFoundError(
"You have not set the root path to store your results."
" Write the path to a path.conf text file in the bin directory"
" before running the simulation")
trajectory_name = 'mirroring-and-fitness-shaping'
paths = Paths(name,
dict(run_num='test'),
root_dir_path=root_dir_path,
suffix="-" + trajectory_name)
print("All output logs can be found in directory ", paths.logs_path)
# Create an environment that handles running our simulation
# This initializes an environment
env = Environment(
trajectory=trajectory_name,
filename=paths.output_dir_path,
file_title='{} data'.format(name),
comment='{} data'.format(name),
add_time=True,
automatic_storing=True,
log_stdout=False, # Sends stdout to logs
)
create_shared_logger_data(logger_names=['bin', 'optimizers'],
log_levels=['INFO', 'INFO'],
log_to_consoles=[True, True],
sim_name=name,
log_directory=paths.logs_path)
configure_loggers()
# Get the trajectory from the environment
traj = env.trajectory
# Set JUBE params
traj.f_add_parameter_group("JUBE_params", "Contains JUBE parameters")
# Scheduler parameters
# Name of the scheduler
# traj.f_add_parameter_to_group("JUBE_params", "scheduler", "Slurm")
# Command to submit jobs to the schedulers
traj.f_add_parameter_to_group("JUBE_params", "submit_cmd", "sbatch")
# Template file for the particular scheduler
traj.f_add_parameter_to_group("JUBE_params", "job_file", "job.run")
# Number of nodes to request for each run
traj.f_add_parameter_to_group("JUBE_params", "nodes", "1")
# Requested time for the compute resources
traj.f_add_parameter_to_group("JUBE_params", "walltime", "00:01:00")
# MPI Processes per node
traj.f_add_parameter_to_group("JUBE_params", "ppn", "1")
# CPU cores per MPI process
traj.f_add_parameter_to_group("JUBE_params", "cpu_pp", "1")
# Threads per process
traj.f_add_parameter_to_group("JUBE_params", "threads_pp", "1")
# Type of emails to be sent from the scheduler
traj.f_add_parameter_to_group("JUBE_params", "mail_mode", "ALL")
# Email to notify events from the scheduler
traj.f_add_parameter_to_group("JUBE_params", "mail_address",
"*****@*****.**")
# Error file for the job
traj.f_add_parameter_to_group("JUBE_params", "err_file", "stderr")
# Output file for the job
traj.f_add_parameter_to_group("JUBE_params", "out_file", "stdout")
# JUBE parameters for multiprocessing. Relevant even without scheduler.
# MPI Processes per job
traj.f_add_parameter_to_group("JUBE_params", "tasks_per_job", "1")
# The execution command
traj.f_add_parameter_to_group(
"JUBE_params", "exec", "python " +
os.path.join(paths.root_dir_path, "run_files/run_optimizee.py"))
# Ready file for a generation
traj.f_add_parameter_to_group(
"JUBE_params", "ready_file",
os.path.join(paths.root_dir_path, "ready_files/ready_w_"))
# Path where the job will be executed
traj.f_add_parameter_to_group("JUBE_params", "work_path",
paths.root_dir_path)
### Maybe we should pass the Paths object to avoid defining paths here and there
traj.f_add_parameter_to_group("JUBE_params", "paths_obj", paths)
## Benchmark function
function_id = 14
bench_functs = BenchmarkedFunctions()
(benchmark_name, benchmark_function), benchmark_parameters = \
bench_functs.get_function_by_index(function_id, noise=True)
optimizee_seed = 200
random_state = np.random.RandomState(seed=optimizee_seed)
function_tools.plot(benchmark_function, random_state)
## Innerloop simulator
optimizee = FunctionGeneratorOptimizee(traj,
benchmark_function,
seed=optimizee_seed)
# Prepare optimizee for jube runs
jube.prepare_optimizee(optimizee, paths.root_dir_path)
## Outerloop optimizer initialization
optimizer_seed = 1234
parameters = EvolutionStrategiesParameters(learning_rate=0.1,
noise_std=1.0,
mirrored_sampling_enabled=True,
fitness_shaping_enabled=True,
pop_size=20,
n_iteration=1000,
stop_criterion=np.Inf,
seed=optimizer_seed)
optimizer = EvolutionStrategiesOptimizer(
traj,
optimizee_create_individual=optimizee.create_individual,
optimizee_fitness_weights=(-1., ),
parameters=parameters,
optimizee_bounding_func=optimizee.bounding_func)
# Add post processing
env.add_postprocessing(optimizer.post_process)
# Run the simulation with all parameter combinations
env.run(optimizee.simulate)
## Outerloop optimizer end
optimizer.end(traj)
# Finally disable logging and close all log-files
env.disable_logging()
return traj.v_storage_service.filename, traj.v_name, paths