def init_params(params_file, comm):
param_factories = ga_utils.create_parameters(params_file, True)
params = [{}]
for i in range(comm.Get_size() - 1):
hyper_parameter_map = {}
for p in param_factories:
hyper_parameter_map[p.name] = p.randomDraw()
params.append(hyper_parameter_map)
return params
def run():
"""
:param num_iter: number of generations
:param num_pop: size of population
:param seed: random seed
:param strategy: one of 'simple', 'mu_plus_lambda'
:param ga parameters file name: ga parameters file name (e.g., "ga_params.json")
:param param_file: name of file containing initial parameters
"""
eqpy.OUT_put("Params")
params = eqpy.IN_get()
# parse params
printf("Parameters: {}".format(params))
(num_iter, num_pop, seed, strategy, mut_prob, ga_params_file, param_file,
classifer_path, scaler_path) = eval('{}'.format(params))
random.seed(seed)
ga_params = ga_utils.create_parameters(ga_params_file)
create_transformer(ga_params, classifer_path, scaler_path)
creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual,
make_random_params)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", obj_func)
toolbox.register("mate", cxUniform, indpb=0.5)
mutate_indpb = mut_prob
toolbox.register("mutate", custom_mutate, indpb=mutate_indpb)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("map", queue_map)
pop = toolbox.population(n=num_pop)
if param_file != "":
update_init_pop(pop, param_file)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", sts.mean)
stats.register("std", sts.std)
stats.register("min", sts.min)
stats.register("max", sts.max)
stats.register("ts", timestamp)
# num_iter-1 generations since the initial population is evaluated once first
mutpb = mut_prob
start_time = time.time()
if strategy == 'simple':
pop, log = algorithms.eaSimple(pop,
toolbox,
cxpb=0.5,
mutpb=mutpb,
ngen=num_iter - 1,
stats=stats,
halloffame=hof,
verbose=True)
elif strategy == 'mu_plus_lambda':
mu = int(math.floor(float(num_pop) * 0.5))
lam = int(math.floor(float(num_pop) * 0.5))
if mu + lam < num_pop:
mu += num_pop - (mu + lam)
pop, log = algorithms.eaMuPlusLambda(pop,
toolbox,
mu=mu,
lambda_=lam,
cxpb=0.5,
mutpb=mutpb,
ngen=num_iter - 1,
stats=stats,
halloffame=hof,
verbose=True)
else:
raise NameError('invalid strategy: {}'.format(strategy))
end_time = time.time()
fitnesses = [str(p.fitness.values[0]) for p in pop]
eqpy.OUT_put("DONE")
# return the final population
eqpy.OUT_put("{}\n{}\n{}\n{}\n{}".format(create_list_of_json_strings(pop),
';'.join(fitnesses), start_time,
log, end_time))
def run():
"""
:param num_iterations: number of generations
:param seed: random seed
:param ga parameters file name: ga parameters file name (e.g., "ga_params.json")
:param num_population population of ga algorithm
"""
eqpy.OUT_put("Params")
parameters = eqpy.IN_get()
# parse params
printf("Parameters: {}".format(parameters))
(num_iterations, num_population, seed,
ga_parameters_file) = eval('{}'.format(parameters))
random.seed(seed)
ga_parameters = ga_utils.create_parameters(ga_parameters_file)
global transformer
transformer = Transformer(ga_parameters)
# deap class creators
creator.create("FitnessMin", base.Fitness, weights=(-1.0, ))
creator.create("Individual", list, fitness=creator.FitnessMin)
# deap method definitions
toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, creator.Individual,
make_random_parameters)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", obj_func)
toolbox.register("mate", cxUniform, indpb=0.5)
toolbox.register("mutate", custom_mutate, indpb=0.2)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("map", queue_map)
pop = toolbox.population(n=num_population)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", np.mean)
stats.register("std", np.std)
stats.register("min", np.min)
stats.register("max", np.max)
stats.register("ts", timestamp)
# num_iter-1 generations since the initial population is evaluated once first
start_time = time.time()
pop, log = algorithms.eaSimple(pop,
toolbox,
cxpb=0.5,
mutpb=0.2,
ngen=num_iterations - 1,
stats=stats,
halloffame=hof,
verbose=True)
end_time = time.time()
fitnesses = [str(p.fitness.values[0]) for p in pop]
eqpy.OUT_put("DONE")
# return the final population
eqpy.OUT_put("{}\n{}\n{}\n{}\n{}".format(create_list_of_json_strings(pop),
';'.join(fitnesses), start_time,
log, end_time))