def run_experiment(differential_op,
max_gen,
pop_size,
exp_id=EXP_ID,
silent=False):
# use `functool.partial` to create fix some arguments of the functions
# and create functions with required signatures
for fit_gen, fit_name in zip(fit_generators, fit_names):
fit = fit_gen(DIMENSION)
for run in range(REPEATS):
pub_vars.fit_func = fit
# initialize the log structure
log = utils.Log(OUT_DIR,
exp_id + '.' + fit_name,
run,
write_immediately=True,
print_frequency=5,
silent=silent)
# create population
pop = create_pop(pop_size, cr_ind)
pop = differential_evolution(pop,
max_gen,
differential_op,
log=log)
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, exp_id + '.' + fit_name)
def run_experiment(exp_id='default', data_input='inputs/tsp_std.in', repeats=10, mut_max_len=10, mut_prob=0.2, cx_prob=0.8, max_gen=500, pop_size=100, fitness=fitness, create_ind=None, cross=order_cross, mutate=swap_mutate, print_frequency=5, progress_callback=None):
# read the locations from input
locations = read_locations(data_input)
# use `functool.partial` to create fix some arguments of the functions
# and create functions with required signatures
cr_ind = functools.partial(create_ind, ind_len=len(locations))
globals()['cities'] = locations
fit = functools.partial(fitness, cities=locations)
xover = functools.partial(crossover, cross=cross, cx_prob=cx_prob)
mut = functools.partial(mutation, mut_prob=mut_prob,
mutate=functools.partial(mutate, max_len=mut_max_len))
# run the algorithm `REPEATS` times and remember the best solutions from
# last generations
best_inds = []
best_objective = 100000000
for run in range(repeats):
# initialize the log structure
log = utils.Log(OUT_DIR, exp_id, run,
write_immediately=True, print_frequency=print_frequency)
# create population
pop = create_pop(pop_size, cr_ind)
# run evolution - notice we use the pool.map as the map_fn
pop = evolutionary_algorithm(pop, pop_size, max_gen, fit, [xover, mut], tournament_selection, map_fn=map, log=log, progress_callback=progress_callback)
# remember the best individual from last generation, save it to file
bi = max(pop, key=fit)
best_objective = min(best_objective, fit(bi).objective)
best_inds.append(bi)
best_template = '{individual}'
with open('resources/kmltemplate.kml') as f:
best_template = f.read()
with open(f'{OUT_DIR}/{exp_id}_{run}.best', 'w') as f:
f.write(str(bi))
with open(f'{OUT_DIR}/{exp_id}_{run}.best.kml', 'w') as f:
bi_kml = [f'{locations[i][1]},{locations[i][0]},5000' for i in bi]
bi_kml.append(f'{locations[bi[0]][1]},{locations[bi[0]][0]},5000')
f.write(best_template.format(individual='\n'.join(bi_kml)))
# if we used write_immediately = False, we would need to save the
# files now
# log.write_files()
# print an overview of the best individuals from each run
for i, bi in enumerate(best_inds):
print(f'Run {i}: difference = {fit(bi).objective}')
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, exp_id)
return best_objective
def run_experiment(max_gen=MAX_GEN, mutation_op=Mutation(step_size=MUT_STEP), cross=one_pt_cross, cx_prob=CX_PROB, exp_id=EXP_ID, silent=True):
# use `functool.partial` to create fix some arguments of the functions
# and create functions with required signatures
for fit_gen, fit_name in zip(fit_generators, fit_names):
fit = fit_gen(DIMENSION)
xover = functools.partial(crossover, cross=cross, cx_prob=cx_prob)
mut = functools.partial(
mutation, mut_prob=MUT_PROB, mutate=mutation_op)
# run the algorithm `REPEATS` times and remember the best solutions from
# last generations
best_inds = []
for run in range(REPEATS):
# initialize the log structure
log = utils.Log(OUT_DIR, exp_id + '.' + fit_name, run,
write_immediately=True, print_frequency=5, silent=silent)
# create population
pop = create_pop(POP_SIZE, cr_ind)
# run evolution - notice we use the pool.map as the map_fn
pop = evolutionary_algorithm(pop, max_gen, fit, [
xover, mut], tournament_selection, mutation_op, map_fn=map, log=log)
# remember the best individual from last generation, save it to file
bi = max(pop, key=fit)
best_inds.append(bi)
# if we used write_immediately = False, we would need to save the
# files now
# log.write_files()
# print an overview of the best individuals from each run
for i, bi in enumerate(best_inds):
if not silent:
print(f'Run {i}: objective = {fit(bi).objective}')
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, EXP_ID + '.' + fit_name)
with open(f'{OUT_DIR}/{EXP_ID}_{run}.best', 'w') as f:
for w, b in zip(weights, bi):
f.write(f'{w} {b}\n')
# if we used write_immediately = False, we would need to save the
# files now
# log.write_files()
# print an overview of the best individuals from each run
for i, bi in enumerate(best_inds):
print(
f'Run {i}: difference = {fit(bi).objective}, bin weights = {bin_weights(weights, bi)}'
)
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, EXP_ID)
# read the summary log and plot the experiment
evals, lower, mean, upper = utils.get_plot_data(OUT_DIR, EXP_ID)
plt.figure(figsize=(12, 8))
utils.plot_experiment(evals,
lower,
mean,
upper,
legend_name='Default settings')
plt.legend()
plt.show()
# you can also plot mutiple experiments at the same time using
# utils.plot_experiments, e.g. if you have two experiments 'default' and
# 'tuned' both in the 'partition' directory, you can call
# initialize the log structure
log = utils.Log(OUT_DIR,
EXP_ID + '.' + fit_name,
run,
write_immediately=True,
print_frequency=5)
# create population
pop = create_pop(POP_SIZE, cr_ind)
# run evolution - notice we use the pool.map as the map_fn
pop = evolutionary_algorithm(pop,
MAX_GEN,
fit,
tournament_selection,
mutate_ind,
map_fn=map,
log=log)
# remember the best individual from last generation, save it to file
bi = max(pop, key=fit)
best_inds.append(bi)
# if we used write_immediately = False, we would need to save the
# files now
# log.write_files()
# print an overview of the best individuals from each run
for i, bi in enumerate(best_inds):
print(f'Run {i}: objective = {fit(bi).objective}')
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, EXP_ID + '.' + fit_name)
def run_experiment(exp_id,
pop_size=250,
max_gen=500,
cx_prob=0.5,
mut_prob=1,
mut_flip_prob=0.05,
elitism=True,
repeats=10,
fitness=basic_fitness,
selection=roulette_wheel_selection,
input_weights='inputs/partition-easy.txt',
print_every=500):
# read the weights from input
weights = read_weights(input_weights)
# use `functool.partial` to create fix some arguments of the functions
# and create functions with required signatures
cr_ind = functools.partial(create_ind, ind_len=len(weights))
fit = functools.partial(fitness, weights=weights)
xover = functools.partial(crossover, cross=one_pt_cross, cx_prob=cx_prob)
mut = functools.partial(mutation,
mut_prob=mut_prob,
mutate=functools.partial(flip_mutate,
prob=mut_flip_prob,
upper=K))
# we can use multiprocessing to evaluate fitness in parallel
import multiprocessing
pool = multiprocessing.Pool()
# run the algorithm `REPEATS` times and remember the best solutions from
# last generations
best_inds = []
for run in range(repeats):
# initialize the log structure
log = utils.Log(OUT_DIR,
exp_id,
run,
write_immediately=True,
print_frequency=print_every)
# create population
pop = create_pop(pop_size, cr_ind)
# run evolution - notice we use the pool.map as the map_fn
pop = evolutionary_algorithm(pop,
max_gen,
fit, [xover, mut],
selection,
map_fn=pool.map,
log=log,
elitism=elitism)
# remember the best individual from last generation, save it to file
best_ind = max(pop, key=fit)
best_inds.append(best_ind)
with open(f'{OUT_DIR}/{exp_id}_{run}.best', 'w') as f:
for w, b in zip(weights, best_ind):
f.write(f'{w} {b}\n')
# if we used write_immediately = False, we would need to save the
# files now
# log.write_files
# print an overview of the best individuals from each run
for i, best_ind in enumerate(best_inds):
print(
f'Run {i}: difference = {fit(best_ind).objective}, bin weights = {bin_weights(weights, best_ind)}'
)
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, exp_id)
def run_experiment(exp_id="default",
input_file="iris.csv",
repeats=10,
pop_size=100,
max_gen=50,
cx_prob=0.8,
max_rules=10,
mut_cls_prob=0.2,
mut_cls_prob_change=0.1,
mut_cond_prob=0.2,
mut_cond_sigma=0.3,
mut_prio_sigma=0.3,
elitism=1,
batch_size=10000,
cond_dist=[(LessThen, 0.25), (GreaterThen, 0.25),
(Any, 0.5)],
priority=False,
most_frequent_init=False,
print_frequency=1,
map_fn=None):
train_data, test_data, num_attrs, num_classes, lb, ub = train_test_split(
input_file)
cr_ind = functools.partial(
create_ind,
max_rules=max_rules,
num_attrs=num_attrs,
num_classes=num_classes,
lb=lb,
ub=ub,
cond_dist=cond_dist,
priority=priority,
most_frequent_cls=(-1 if most_frequent_init == False else np.argmax(
np.bincount(train_data[1]))))
xover = functools.partial(crossover, cross=cross, cx_prob=cx_prob)
cls_mut_ind = functools.partial(cls_mutate,
num_classes=num_classes,
mut_cls_prob_change=mut_cls_prob_change)
mut_cls = functools.partial(mutation,
mutate=cls_mut_ind,
mut_prob=mut_cls_prob)
mut_cond = functools.partial(mutation,
mutate=functools.partial(
cond_mutate,
mut_cond_sigma=mut_cond_sigma),
mut_prob=mut_cond_prob)
mut_priority = functools.partial(mutation,
mutate=functools.partial(
priority_mutate,
mut_prio_sigma=mut_prio_sigma),
mut_prob=mut_cond_prob if priority else 0)
# run the algorithm `REPEATS` times and remember the best solutions from
# last generations
import multiprocessing
if map_fn is None:
pool = multiprocessing.Pool(8)
map_fn = pool.map
# fitness computed from the whole dataset
full_fitness = functools.partial(fitness,
train_data=train_data,
test_data=test_data)
best_inds = []
for run in range(repeats):
# initialize the log structure
log = utils.Log(OUT_DIR,
exp_id,
run,
write_immediately=True,
print_frequency=print_frequency)
# create population
pop = create_pop(pop_size, cr_ind)
# run evolution - notice we use the pool.map as the map_fn
pop = evolutionary_algorithm(pop,
max_gen,
fitness,
train_data,
test_data,
[xover, mut_cls, mut_cond, mut_priority],
tournament_selection,
map_fn=map_fn,
log=log,
elitism=elitism,
batch_size=batch_size)
# remember the best individual from last generation, save it to file
bi = max(pop, key=full_fitness)
best_inds.append(bi)
# if we used write_immediately = False, we would need to save the
# files now
# log.write_files()
# print an overview of the best individuals from each run
for i, bi in enumerate(best_inds):
print(f'Run {i}: objective = {full_fitness(bi).objective}')
# write summary logs for the whole experiment
utils.summarize_experiment(OUT_DIR, exp_id)
