def __init__(self,
problem,
run,
evaluator,
population_size=100,
sample_size=10,
**kwargs):
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
self.free_workers = self.evaluator.num_workers
print('population_size = ', population_size)
dhlogger.info(
jm(
type="start_infos",
alg="aging-evolution",
nworkers=self.evaluator.num_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
))
# Setup
self.pb_dict = self.problem.space
search_space = self.problem.build_search_space()
self.space_list = [(0, vnode.num_ops - 1)
for vnode in search_space.variable_nodes]
self.population_size = int(population_size)
self.sample_size = int(sample_size)
def __init__(self, problem, run, evaluator, **kwargs):
super().__init__(problem=problem, run=run, evaluator=evaluator, **kwargs)
seed(self.problem.seed)
if evaluator == "balsam":
balsam_launcher_nodes = int(os.environ.get("BALSAM_LAUNCHER_NODES", 1))
deephyper_workers_per_node = int(
os.environ.get("DEEPHYPER_WORKERS_PER_NODE", 1)
)
n_free_nodes = balsam_launcher_nodes - 1 # Number of free nodes
self.free_workers = (
n_free_nodes * deephyper_workers_per_node
) # Number of free workers
else:
self.free_workers = 1
dhlogger.info(
jm(
type="start_infos",
alg="rtg_pg",
nworkers=self.free_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
)
)
def __init__(self, problem, run, evaluator, **kwargs):
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
seed(self.problem.seed)
if evaluator == 'balsam':
balsam_launcher_nodes = int(
os.environ.get('BALSAM_LAUNCHER_NODES', 1))
deephyper_workers_per_node = int(
os.environ.get('DEEPHYPER_WORKERS_PER_NODE', 1))
n_free_nodes = balsam_launcher_nodes - 1 # Number of free nodes
self.free_workers = n_free_nodes * \
deephyper_workers_per_node # Number of free workers
else:
self.free_workers = 1
dhlogger.info(
jm(type='start_infos',
alg='random',
nworkers=self.free_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder)))
def __init__(
self,
problem,
run,
evaluator,
surrogate_model="RF",
acq_func="LCB",
kappa=1.96,
xi=0.001,
liar_strategy="cl_min",
n_jobs=1,
**kwargs,
):
super().__init__(problem, run, evaluator, **kwargs)
dhlogger.info("Initializing AMBNAS")
dhlogger.info(
jm(
type="start_infos",
alg="ambs",
nworkers=self.evaluator.num_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
)
)
dhlogger.info(f"kappa={kappa}, xi={xi}")
self.n_initial_points = self.evaluator.num_workers
self.liar_strategy = liar_strategy
# Building search space for SkOptimizer using ConfigSpace
search_space = self.problem.build_search_space()
# print('ambs.py .....................', self.problem)
skopt_space = cs.ConfigurationSpace(seed=self.problem.seed)
for i, vnode in enumerate(search_space.variable_nodes):
print(f'vnode{i}.num_ops ==== {vnode.num_ops}')
hp = csh.UniformIntegerHyperparameter(
name=f"vnode_{i:05d}", lower=0, upper=(vnode.num_ops - 1)
)
skopt_space.add_hyperparameter(hp)
# dhlogger.info(f'hyliu --------------------------- {skopt_space}')
self.opt = skopt.Optimizer(
dimensions=skopt_space,
base_estimator=self.get_surrogate_model(surrogate_model, n_jobs),
acq_func=acq_func,
acq_optimizer="sampling",
acq_func_kwargs={"xi": xi, "kappa": kappa},
n_initial_points=self.n_initial_points,
random_state=self.problem.seed,
)
def main(self):
# timer = util.DelayTimer(max_minutes=None, period=SERVICE_PERIOD)
# chkpoint_counter = 0
num_evals_done = 0
# Filling available nodes at start
dhlogger.info(f"Generating {self.evaluator.num_workers} initial points...")
self.evaluator.add_eval_batch(self.get_random_batch(size=self.n_initial_points))
dhlogger.info(f'max eval = {self.max_evals}')
print(self.problem.space)
# Main loop
while num_evals_done < self.max_evals:
# Collecting finished evaluations
new_results = list(self.evaluator.get_finished_evals())
if len(new_results) > 0:
stats = {"num_cache_used": self.evaluator.stats["num_cache_used"]}
dhlogger.info(jm(type="env_stats", **stats))
self.evaluator.dump_evals(saved_key="arch_seq")
num_received = len(new_results)
num_evals_done += num_received
# Transform configurations to list to fit optimizer
opt_X = []
opt_y = []
for cfg, obj_dict in new_results:
x = replace_nan(cfg["arch_seq"])
opt_X.append(x)
# assert('result' in obj_dict)
if type(obj_dict) is dict:
obj = obj_dict['result']
else:
obj = obj_dict
opt_y.append(-obj) #! maximizing
self.opt.tell(opt_X, opt_y) #! fit: costly
new_X = self.opt.ask(
n_points=len(new_results), strategy=self.liar_strategy
)
new_batch = []
for x in new_X:
new_cfg = self.to_dict(x)
new_batch.append(new_cfg)
# submit_childs
if len(new_results) > 0:
self.evaluator.add_eval_batch(new_batch)
def main(self):
num_evals_done = 0
# Filling available nodes at start
self.evaluator.add_eval_batch(
self.gen_random_batch(size=self.free_workers))
# Main loop
while num_evals_done < self.max_evals:
# Collecting finished evaluations
new_results = list(self.evaluator.get_finished_evals())
if len(new_results) > 0:
stats = {
"num_cache_used": self.evaluator.stats["num_cache_used"]
}
dhlogger.info(jm(type="env_stats", **stats))
self.evaluator.dump_evals(saved_keys=self.saved_keys)
num_received = len(new_results)
num_evals_done += num_received
# Transform configurations to list to fit optimizer
opt_X = []
opt_y = []
for cfg, obj in new_results:
h = [
cfg["hyperparameters"]["learning_rate"],
cfg["hyperparameters"]["batch_size"],
cfg["hyperparameters"]["ranks_per_node"],
]
h.extend(cfg["arch_seq"])
opt_X.append(h)
opt_y.append(-obj)
self.opt.tell(opt_X, opt_y) #! fit: costly
new_X = self.opt.ask(n_points=len(new_results))
new_batch = []
for x in new_X:
new_cfg = copy.deepcopy(self.pb_dict)
new_cfg["hyperparameters"]["learning_rate"] = x[0]
new_cfg["hyperparameters"]["batch_size"] = x[1]
new_cfg["hyperparameters"]["ranks_per_node"] = x[2]
new_cfg["arch_seq"] = x[self.size_ha:]
new_batch.append(new_cfg)
# submit_childs
if len(new_results) > 0:
self.evaluator.add_eval_batch(new_batch)
def main(self):
num_evals_done = 0
population = collections.deque(maxlen=self.population_size)
# Filling available nodes at start
self.evaluator.add_eval_batch(
self.gen_random_batch(size=self.free_workers))
# Main loop
while num_evals_done < self.max_evals:
# Collecting finished evaluations
new_results = list(self.evaluator.get_finished_evals())
if len(new_results) > 0:
population.extend(new_results)
stats = {
"num_cache_used": self.evaluator.stats["num_cache_used"]
}
dhlogger.info(jm(type="env_stats", **stats))
self.evaluator.dump_evals(saved_keys=self.saved_keys)
num_received = len(new_results)
num_evals_done += num_received
# If the population is big enough evolve the population
if len(population) == self.population_size:
children_batch = []
# For each new parent/result we create a child from it
for _ in range(len(new_results)):
# select_sample
indexes = np.random.choice(self.population_size,
self.sample_size,
replace=False)
sample = [population[i] for i in indexes]
# select_parent
parent = self.select_parent(sample)
# copy_mutate_parent
child = self.copy_mutate_arch(parent)
# add child to batch
children_batch.append(child)
# submit_childs
if len(new_results) > 0:
self.evaluator.add_eval_batch(children_batch)
else: # If the population is too small keep increasing it
new_batch = self.gen_random_batch(size=len(new_results))
self.evaluator.add_eval_batch(new_batch)
def __init__(self, problem, run, evaluator, **kwargs):
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
self.free_workers = self.evaluator.num_workers
dhlogger.info(
jm(
type="start_infos",
alg="bayesian-optimization-for-hpo-nas",
nworkers=self.evaluator.num_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
))
# Setup
self.pb_dict = self.problem.space
cs_kwargs = self.pb_dict["create_search_space"].get("kwargs")
if cs_kwargs is None:
search_space = self.pb_dict["create_search_space"]["func"]()
else:
search_space = self.pb_dict["create_search_space"]["func"](
**cs_kwargs)
self.space_list = [(0, vnode.num_ops - 1)
for vnode in search_space.variable_nodes]
# Initialize Hyperaparameter space
self.dimensions = []
self.size_ha = None # Number of algorithm hyperparameters in the dimension list
self.add_ha_dimensions()
self.add_hm_dimensions()
# Initialize opitmizer of hyperparameter space
# acq_func_kwargs = {"xi": 0.000001, "kappa": 0.001} # tiny exploration
acq_func_kwargs = {"xi": 0.000001, "kappa": 1.96} # tiny exploration
self.n_initial_points = self.free_workers
self.opt = SkOptimizer(
dimensions=self.dimensions,
base_estimator=RandomForestRegressor(n_jobs=32),
# base_estimator=RandomForestRegressor(n_jobs=4),
acq_func="LCB",
acq_optimizer="sampling",
acq_func_kwargs=acq_func_kwargs,
n_initial_points=self.n_initial_points,
# model_queue_size=100,
)
def main(self):
num_evals_done = 0
# Filling available nodes at start
dhlogger.info(
f"Generating {self.evaluator.num_workers} initial points...")
self.evaluator.add_eval_batch(
self.get_random_batch(size=self.n_initial_points))
# Main loop
while num_evals_done < self.max_evals:
# Collecting finished evaluations
new_results = list(self.evaluator.get_finished_evals())
if len(new_results) > 0:
stats = {
"num_cache_used": self.evaluator.stats["num_cache_used"]
}
dhlogger.info(jm(type="env_stats", **stats))
self.evaluator.dump_evals(saved_keys=self.saved_keys)
num_received = len(new_results)
num_evals_done += num_received
# Transform configurations to list to fit optimizer
opt_X = []
opt_y = []
for cfg, obj in new_results:
arch_seq = cfg["arch_seq"]
hp_val = self.problem.extract_hp_values(cfg)
x = replace_nan(hp_val + arch_seq)
opt_X.append(x)
opt_y.append(-obj) #! maximizing
self.opt.tell(opt_X, opt_y) #! fit: costly
new_X = self.opt.ask(n_points=len(new_results),
strategy=self.liar_strategy)
new_batch = []
for x in new_X:
new_cfg = self.problem.gen_config(x[self.hp_size:],
x[:self.hp_size])
new_batch.append(new_cfg)
# submit_childs
if len(new_results) > 0:
self.evaluator.add_eval_batch(new_batch)
def __init__(self, problem, run, evaluator, **kwargs):
super().__init__(problem=problem, run=run, evaluator=evaluator, **kwargs)
seed(self.problem.seed)
self.free_workers = self.evaluator.num_workers
dhlogger.info(
jm(
type="start_infos",
alg="random",
nworkers=self.evaluator.num_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
)
)
def step_wait(self):
obs = [
np.array([float(action_seq[-1])])
for action_seq in self.action_buffers
]
if len(self.action_buffers[0]) < self.num_actions_per_env:
# Results are already known here...
rews = [0 for _ in self.action_buffers]
dones = [False for _ in self.action_buffers]
infos = {}
else:
# Waiting results from balsam
results = self.evaluator.await_evals(
self.eval_uids) # Not blocking
rews = [rew for cfg, rew in results] # Blocking generator
self.stats["batch_computation"] = (time.time() -
self.stats["batch_computation"])
self.stats["num_cache_used"] = self.evaluator.stats[
"num_cache_used"]
self.stats["rank"] = MPI.COMM_WORLD.Get_rank(
) if MPI is not None else 0
dones = [True for _ in rews]
infos = [{
"episode": {
"r": r,
"l": self.num_actions_per_env
}
for r in rews
}] # TODO
self.stats["rewards"] = rews
self.stats["arch_seq"] = (np.array(self.action_buffers) /
self.structure.max_num_ops).tolist()
dhlogger.info(jm(type="env_stats", **self.stats))
self.reset()
return np.stack(obs), np.array(rews), np.array(dones), infos
def __init__(self,
problem,
run,
evaluator,
surrogate_model="RF",
liar_strategy="cl_max",
acq_func="gp_hedge",
n_jobs=-1,
**kwargs):
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
if evaluator == 'balsam':
balsam_launcher_nodes = int(
os.environ.get('BALSAM_LAUNCHER_NODES', 1))
deephyper_workers_per_node = int(
os.environ.get('DEEPHYPER_WORKERS_PER_NODE', 1))
n_free_nodes = balsam_launcher_nodes - 1 # Number of free nodes
self.free_workers = n_free_nodes * \
deephyper_workers_per_node # Number of free workers
else:
self.free_workers = 1
dhlogger.info(
jm(type='start_infos',
alg='ambs-nas',
nworkers=self.free_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder)))
dhlogger.info("Initializing AMBS")
self.optimizer = Optimizer(self.problem,
self.num_workers,
surrogate_model=surrogate_model,
liar_strategy=liar_strategy,
acq_func=acq_func,
n_jobs=n_jobs,
**kwargs)
def step_wait(self):
obs = [np.array([float(action_seq[-1])])
for action_seq in self.action_buffers]
if len(self.action_buffers[0]) < self.num_actions_per_env:
# Results are already known here...
rews = [0 for _ in self.action_buffers]
dones = [False for _ in self.action_buffers]
infos = {}
else:
# Waiting results from balsam
results = self.evaluator.await_evals(
self.eval_uids) # Not blocking
rews = [rew for cfg, rew in results] # Blocking generator
self.stats['batch_computation'] = time.time() - \
self.stats['batch_computation']
self.stats['num_cache_used'] = self.evaluator.stats['num_cache_used']
self.stats['rank'] = MPI.COMM_WORLD.Get_rank(
) if MPI is not None else 0
dones = [True for _ in rews]
infos = [{
'episode': {
'r': r,
'l': self.num_actions_per_env
} for r in rews}] # TODO
self.stats['rewards'] = rews
self.stats['arch_seq'] = self.action_buffers
dhlogger.info(jm(type='env_stats', **self.stats))
self.reset()
return np.stack(obs), np.array(rews), np.array(dones), infos
def __init__(self,
problem,
run,
evaluator,
population_size=100,
sample_size=10,
**kwargs):
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
self.free_workers = self.evaluator.num_workers
dhlogger.info(
jm(
type="start_infos",
alg="aging-evolution",
nworkers=self.evaluator.num_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
))
# Setup
self.pb_dict = self.problem.space
cs_kwargs = self.pb_dict["create_search_space"].get("kwargs")
if cs_kwargs is None:
search_space = self.pb_dict["create_search_space"]["func"]()
else:
search_space = self.pb_dict["create_search_space"]["func"](
**cs_kwargs)
self.space_list = [(0, vnode.num_ops - 1)
for vnode in search_space.variable_nodes]
self.population_size = population_size
self.sample_size = sample_size
def __init__(self, problem, run, evaluator,
population_size=100,
sample_size=10,
**kwargs):
if evaluator == 'balsam': # TODO: async is a kw
balsam_launcher_nodes = int(
os.environ.get('BALSAM_LAUNCHER_NODES', 1))
deephyper_workers_per_node = int(
os.environ.get('DEEPHYPER_WORKERS_PER_NODE', 1))
n_free_nodes = balsam_launcher_nodes - 1 # Number of free nodes
self.free_workers = n_free_nodes * \
deephyper_workers_per_node # Number of free workers
else:
self.free_workers = 1
super().__init__(problem=problem, run=run, evaluator=evaluator, **kwargs)
dhlogger.info(jm(
type='start_infos',
alg='aging-evolution',
nworkers=self.free_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder)
))
# Setup
self.pb_dict = self.problem.space
cs_kwargs = self.pb_dict['create_search_space'].get('kwargs')
if cs_kwargs is None:
search_space = self.pb_dict['create_search_space']['func']()
else:
search_space = self.pb_dict['create_search_space']['func'](**cs_kwargs)
self.space_list = [(0, vnode.num_ops-1) for vnode in search_space.variable_nodes]
self.population_size = population_size
self.sample_size = sample_size
def __init__(self, problem, run, evaluator, alg, network, num_envs,
**kwargs):
self.kwargs = kwargs
if evaluator == 'balsam':
balsam_launcher_nodes = int(
os.environ.get('BALSAM_LAUNCHER_NODES', 1))
deephyper_workers_per_node = int(
os.environ.get('DEEPHYPER_WORKERS_PER_NODE', 1))
nworkers = balsam_launcher_nodes * deephyper_workers_per_node
else:
nworkers = 1
if MPI is None:
self.rank = 0
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
dhlogger.info(
jm(type='start_infos',
seed=self.problem.seed,
alg=alg,
network=network,
num_envs_per_agent=num_envs,
nagents=1,
nworkers=nworkers,
encoded_space=json.dumps(self.problem.space, cls=Encoder)))
else:
self.rank = MPI.COMM_WORLD.Get_rank()
if self.rank == 0:
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
dhlogger.info(
jm(type='start_infos',
seed=self.problem.seed,
alg=alg,
network=network,
num_envs_per_agent=num_envs,
nagents=MPI.COMM_WORLD.Get_size(),
nworkers=nworkers,
encoded_space=json.dumps(self.problem.space,
cls=Encoder)))
MPI.COMM_WORLD.Barrier()
if self.rank != 0:
super().__init__(problem=problem,
run=run,
evaluator=evaluator,
**kwargs)
# set in super : self.problem, self.run_func, self.evaluator
if self.problem.seed is not None:
tf.random.set_random_seed(self.problem.seed)
self.num_evals = self.max_evals
if self.num_evals is None:
self.num_evals = math.inf
self.space = self.problem.space
dhlogger.info(f'evaluator: {type(self.evaluator)}')
dhlogger.info(f'rank: {self.rank}')
dhlogger.info(f'alg: {alg}')
dhlogger.info(f'network: {network}')
dhlogger.info(f'num_envs_per_agent: {num_envs}')
self.alg = alg
self.network = network
self.num_envs_per_agent = num_envs
def main(self):
num_evals_done = 0
population = collections.deque(maxlen=self.population_size)
# Filling available nodes at start
self.evaluator.add_eval_batch(
self.gen_random_batch(size=self.free_workers))
# Main loop
while num_evals_done < self.max_evals:
# Collecting finished evaluations
new_results = list(self.evaluator.get_finished_evals())
if len(new_results) > 0:
population.extend(new_results)
stats = {
"num_cache_used": self.evaluator.stats["num_cache_used"]
}
dhlogger.info(jm(type="env_stats", **stats))
self.evaluator.dump_evals(saved_keys=self.saved_keys)
num_received = len(new_results)
num_evals_done += num_received
hp_results_X, hp_results_y = [], []
# If the population is big enough evolve the population
if len(population) == self.population_size:
children_batch = []
# For each new parent/result we create a child from it
for new_i in range(len(new_results)):
# select_sample
indexes = np.random.choice(self.population_size,
self.sample_size,
replace=False)
sample = [population[i] for i in indexes]
# select_parent
parent = self.select_parent(sample)
# copy_mutate_parent
child = self.copy_mutate_arch(parent)
# add child to batch
children_batch.append(child)
# collect infos for hp optimization
new_i_hps = new_results[new_i][0]["hyperparameters"]
new_i_y = new_results[new_i][1]
hp_new_i = [
new_i_hps["learning_rate"],
new_i_hps["batch_size"],
new_i_hps["ranks_per_node"],
]
hp_results_X.append(hp_new_i)
hp_results_y.append(-new_i_y)
self.hp_opt.tell(hp_results_X,
hp_results_y) #! fit: costly
new_hps = self.hp_opt.ask(n_points=len(new_results))
for hps, child in zip(new_hps, children_batch):
child["hyperparameters"]["learning_rate"] = hps[0]
child["hyperparameters"]["batch_size"] = hps[1]
child["hyperparameters"]["ranks_per_node"] = hps[2]
# submit_childs
if len(new_results) > 0:
self.evaluator.add_eval_batch(children_batch)
else: # If the population is too small keep increasing it
# For each new parent/result we create a child from it
for new_i in range(len(new_results)):
new_i_hps = new_results[new_i][0]["hyperparameters"]
new_i_y = new_results[new_i][1]
hp_new_i = [
new_i_hps["learning_rate"],
new_i_hps["batch_size"],
new_i_hps["ranks_per_node"],
]
hp_results_X.append(hp_new_i)
hp_results_y.append(-new_i_y)
self.hp_opt.tell(hp_results_X,
hp_results_y) #! fit: costly
new_hps = self.hp_opt.ask(n_points=len(new_results))
new_batch = self.gen_random_batch(size=len(new_results),
hps=new_hps)
self.evaluator.add_eval_batch(new_batch)
def __init__(self, problem, run, evaluator, alg, network, env, **kwargs):
self.kwargs = kwargs
# It is assumed here that one agent is using one node
self.num_agents = 1 if MPI is None else MPI.COMM_WORLD.Get_size()
self.rank = 0 if MPI is None else MPI.COMM_WORLD.Get_rank()
if MPI is None or MPI.COMM_WORLD.Get_rank() == 0:
super().__init__(
problem=problem,
run=run,
evaluator=evaluator,
num_nodes_master=self.num_agents,
**kwargs,
) # create self.evaluator
MPI.COMM_WORLD.Barrier() # Creating the app first in rank 0 only
if self.rank != 0:
super().__init__(
problem=problem,
run=run,
evaluator=evaluator,
num_nodes_master=self.num_agents,
**kwargs,
)
# Set in super : self.problem, self.run_func, self.evaluator
# Number of parallel environments per agent
self.num_envs_per_agent = self.evaluator.num_workers // self.num_agents
if MPI is None or MPI.COMM_WORLD.Get_rank() == 0:
dhlogger.info(
jm(
type="start_infos",
seed=self.problem.seed,
alg=alg,
network=network,
num_envs_per_agent=self.num_envs_per_agent,
nagents=1,
nworkers=self.evaluator.num_workers,
encoded_space=json.dumps(self.problem.space, cls=Encoder),
)
)
if self.problem.seed is not None:
tf.random.set_random_seed(self.problem.seed)
self.num_evals = self.max_evals
if self.num_evals is None:
self.num_evals = math.inf
self.space = self.problem.space
dhlogger.info(f"evaluator: {type(self.evaluator)}")
dhlogger.info(f"rank: {self.rank}")
dhlogger.info(f"alg: {alg}")
dhlogger.info(f"network: {network}")
dhlogger.info(f"num_envs_per_agent: {self.num_envs_per_agent}")
self.alg = alg
self.network = network
self.env_class = get_env_class(env)
