def test_best_individual():
np.random.seed(42)
pop = pg.make_integer_population(10, 5)
pop = pg.evaluate_population(pop, lambda x: 1. / (1. + pg.onemax(x)))
best = pg.best_individual(pop)
assert np.array_equal(best.genotype, np.array([1, 1, 1, 1, 1]))
assert best.fitness.value == 0.16666666666666666
def genetic_algorithm_binary(fitness_fn,
chr_size,
pop_size=100,
total_generations=20,
cx_rate=0.7,
ind_mt_rate=1.0,
op_mt_rate=0.01,
elitism=False):
# initial population
pop = pg.make_integer_population(pop_size, chr_size)
pop = pg.evaluate_population(pop, fitness_fn)
pg.evolution_progress(0, pop)
# evolutionary loop
for i in range(1, total_generations):
pop = pg.select_population(pop, pg.tournament_selection)
offsprings = pg.apply_crossover(pop, cx_rate, pg.uniform_crossover)
offsprings = pg.apply_mutation(offsprings,
ind_mt_rate,
pg.flip_mutation,
gene_rate=op_mt_rate)
if elitism:
pop = pg.elite_strategy(
pg.generational_replacement(pop, offsprings),
pg.best_individual(pop))
else:
pop = pg.generational_replacement(pop, offsprings)
pop = pg.evaluate_population(pop, fitness_fn)
pg.evolution_progress(i, pop)
return pop
def es_mu_plus_lambda_n_step():
np.random.seed(42)
pop = pg.evolutionary_strategy(fitness_fn, sphere_model_size, -5.0, 5.0,
replace_pop=pg.mu_plus_lambda_replacement,
mt=pg.uncorrelated_n_steps_mutation, pop_size=100, pool_size=500)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def generational_no_elitism():
np.random.seed(42)
pop = pg.genetic_algorithm_permutation(sorted_permutation,
permutation_size,
total_generations=25)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def steady_state_no_elitism():
np.random.seed(42)
pop = pg.genetic_algorithm_binary(fitness_fn,
onemax_size,
generational=False,
total_generations=200)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def es_mu_plus_lambda_one_step():
np.random.seed(42)
pop = pg.evolutionary_strategy_adaptive(
fitness_fn,
sphere_model_size,
-5.0,
5.0,
replace_pop=pg.mu_plus_lambda_replacement)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def generational_with_elitism():
np.random.seed(42)
pop = pg.genetic_algorithm_permutation(fitness_fn,
nqueens_size,
elitism=True,
total_generations=200,
cx_rate=0.5,
ind_mt_rate=0.2,
op_mt_rate=3.0 / nqueens_size)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def generational_with_elitism():
np.random.seed(42)
pop = pg.genetic_algorithm(fitness_fn,
sphere_model_size,
-5.0,
5.0,
elitism=True,
mt=pg.uniform_mutation,
total_generations=200)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def es_mu_comma_lambda_n_step():
np.random.seed(42)
pop = pg.evolutionary_strategy_adaptive(
fitness_fn,
sphere_model_size,
-5.0,
5.0,
mt=pg.uncorrelated_n_steps_mutation_adaptive,
pop_size=100,
pool_size=500)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def stgp_with_elitism_ephemeral():
np.random.seed(42)
init_max_depth = 6
max_tree_depth = 8
pset = setup_primitive_set()
num_fitness_cases = 10
fitness_fn = pg.make_fitness_regression(pset, fn, num_fitness_cases)
pop = pg.genetic_programming(fitness_fn, pset, init_max_depth, max_tree_depth,
elitism=True, total_generations=20, pop_size=1000, cx_rate=0.9, op_mt_rate=0.25)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def test_elite_strategy():
np.random.seed(42)
size = 10
ind_size = 20
pop = pg.make_integer_population(size, ind_size)
fitness_function = lambda x: 1. / pg.onemax(x)
pop = pg.make_integer_population(size, ind_size)
pop = pg.evaluate_population(pop, fitness_function)
best = pg.best_individual(pop)
pop = pg.elite_strategy(pop, best)
found = False
for ind in pop.individuals:
if ind.equal(best) is True:
found = True
break
assert found is True
def ge_with_elitism(grammar='ge_symbolic_regression_grammar.txt'):
np.random.seed(42)
ind_size = 100
low = 0
high = 255
wrap = True
grammar = pg.Grammar(filename=grammar)
num_fitness_cases = 10
fitness_fn = make_single_regression(grammar, fn, num_fitness_cases)
pop = pg.grammatical_evolution(grammar,
fitness_fn,
ind_size,
low,
high,
elitism=True,
total_generations=20,
pop_size=100)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def generational_with_elitism():
np.random.seed(42)
pop = pg.genetic_algorithm_binary(fitness_fn, onemax_size, elitism=True)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))
def es_mu_comma_lambda_one_step():
np.random.seed(42)
pop = pg.evolutionary_strategy(fitness_fn, sphere_model_size, -5.0, 5.0)
best = pg.best_individual(pop)
print('fitness: %s\tgenotype: %s' % (best.fitness.value, best.genotype))