def evolution_search():
for exp_type in config_dict()['exp_order']:
save_dir = f'{os.path.dirname(os.path.abspath(__file__))}/search-{args.save}-{exp_type}-{dataset}-{time.strftime("%Y%m%d-%H%M%S")}'
utils.create_exp_dir(save_dir)
fh = logging.FileHandler(os.path.join(save_dir, 'log.txt'))
fh.setFormatter(logging.Formatter(log_format))
logging.getLogger().addHandler(fh)
np.random.seed(args.seed)
logging.info("args = %s", args)
# setup NAS search problem
if exp_type == 'micro': # NASNet search space
n_var, lb, ub = set_micro_exp(args)
elif exp_type == 'macro': # modified GeneticCNN search space
n_var, lb, ub = set_macro_exp(args)
elif exp_type == 'micromacro' or exp_type == 'micro_garbage' or exp_type == 'macro_garbage': # modified GeneticCNN search space
n_var_mac, lb_mac, ub_mac = set_macro_exp(args)
n_var_mic, lb_mic, ub_mic = set_micro_exp(args)
n_var = n_var_mic + n_var_mac
lb = np.array([*lb_mac, *lb_mic])
ub = np.array([*ub_mac, *ub_mic])
else:
raise NameError('Unknown search space type')
problem = NAS(n_var=n_var, search_space=exp_type,
n_obj=2, n_constr=0, lb=lb, ub=ub,
init_channels=args.init_channels, layers=args.layers,
epochs=args.epochs, save_dir=save_dir, batch_size=args.batch_size)
# configure the nsga-net method
method = engine.nsganet(pop_size=args.pop_size,
n_offsprings=args.n_offspring,
eliminate_duplicates=True)
if args.termination == 'ngens':
termination = ('n_gen', args.n_gens)
elif args.termination == 'time':
termination = TimeTermination(time.time(), args.max_time)
res = minimize(problem,
method,
callback=do_every_generations,
termination=termination)
val_accs = res.pop.get('F')[:, 0]
if exp_type == 'microtomacro' or exp_type == 'micro':
best_idx = np.where(val_accs == np.min(val_accs))[0][0]
best_genome = res.pop[best_idx].X
with open(f'{save_dir}/best_genome.pkl', 'wb') as pkl_file:
pickle.dump(best_genome, pkl_file)
if exp_type == 'microtomacro':
set_config('micro_creator', make_micro_creator(best_genome))
return (100 - np.min(val_accs)) / 100
def main():
np.random.seed(args.seed)
logging.info("args = %s", args)
# setup NAS search problem
if args.search_space == 'micro': # NASNet search space
n_var = int(4 * args.n_blocks * 2)
lb = np.zeros(n_var)
ub = np.ones(n_var)
h = 1
for b in range(0, n_var // 2, 4):
ub[b] = args.n_ops - 1
ub[b + 1] = h
ub[b + 2] = args.n_ops - 1
ub[b + 3] = h
h += 1
ub[n_var // 2:] = ub[:n_var // 2]
elif args.search_space == 'macro': # modified GeneticCNN search space
n_var = int(((args.n_nodes - 1) * args.n_nodes / 2 + 1) * 3)
lb = np.zeros(n_var)
ub = np.ones(n_var)
else:
raise NameError('Unknown search space type')
problem = NAS(n_var=n_var,
search_space=args.search_space,
n_obj=2,
n_constr=0,
lb=lb,
ub=ub,
init_channels=args.init_channels,
layers=args.layers,
epochs=args.epochs,
save_dir=args.save,
data_path=args.data_path,
dataset=args.dataset)
# configure the nsga-net method
method = engine.nsganet(pop_size=args.pop_size,
n_offsprings=args.n_offspring,
eliminate_duplicates=True)
res = minimize(problem,
method,
callback=do_every_generations,
termination=('n_gen', args.n_gens))
return
def main():
np.random.seed(args.seed)
logging.info("args = %s", args)
# setup NAS search problem
'''
# for either problem setting, lb and ub is [0,1]
# macro is the one allowing different phase type
# micro is the one using identical block and repeat itself
'''
if args.search_space == 'micro': # NASNet search space
n_var = int(4 * args.n_blocks * 2)
lb = np.zeros(n_var)
ub = np.ones(n_var)
h = 1
for b in range(0, n_var // 2, 4):
ub[b] = args.n_ops - 1
ub[b + 1] = h
ub[b + 2] = args.n_ops - 1
ub[b + 3] = h
h += 1
ub[n_var // 2:] = ub[:n_var // 2]
elif args.search_space == 'macro': # modified GeneticCNN search space
n_var = int(((args.n_nodes - 1) * args.n_nodes / 2 + 1) * 3)
lb = np.zeros(n_var)
ub = np.ones(n_var)
else:
raise NameError('Unknown search space type')
problem = NAS(n_var=n_var,
search_space=args.search_space,
n_obj=2,
n_constr=0,
lb=lb,
ub=ub,
init_channels=args.init_channels,
layers=args.layers,
epochs=args.epochs,
save_dir=args.save)
# configure the nsga-net method
method = engine.nsganet(pop_size=args.pop_size,
n_offsprings=args.n_offspring,
eliminate_duplicates=True)
'''
optimise a PROBLEM by using the METHOD, call CALLBACK func on every iter
terminate on TERMINATION iter
1. call `problem._evaluate` to get evaluated
2. call `GeneticAlgorithm.survival._do` to get survivors.
NonDominatedSorting and calc_crowding_distance
(`RankAndCrowdingSurvival` in this, CHANGED)
3. call callback function (`do_every_generations` in this)
4. call `GeneticAlgorithm.selection` to make selection.
func_comp serve as a compare function
(`binary_tournament` in this, same as NSGA-II)
go back
'''
res = minimize(problem,
method,
callback=do_every_generations,
termination=('n_gen', args.n_gens))
return
args.local_search_on_knee):
logfile.write(f'# Local Search on n-points: {args.n_points}\n')
logfile.write(
f'# Local Search followed by Bosman ver: {bool(args.followed_bosman_paper)}\n\n'
)
logfile.write('*' * 50)
logfile.write('\n\n')
else:
sub_path = root_path
# ==============================================================================================================
# configure the nsga-net method
method = engine.nsganet(
pop_size=args.pop_size,
benchmark=args.benchmark_name,
local_search_on_pf=args.local_search_on_pf,
local_search_on_knee=args.local_search_on_knee,
followed_bosman_paper=args.followed_bosman_paper,
n_points=args.n_points,
path=sub_path)
res = minimize(problem,
method,
callback=do_every_generations,
termination=('n_eval', args.n_eval))
problem._n_evaluated = 0
print(f'--> Run {i_run} - Done')
print(f'Run {args.number_of_runs} - Done\n')
if args.save == 1:
print('All files are saved on ' + root_path)