def test_equal_population():
np.random.seed(42)
size = 1000
ind_size = 20
pop1 = pg.make_integer_population(size, ind_size)
pop2 = pop1.clone()
pop3 = pg.make_integer_population(size, ind_size)
assert pop1.equal(pop2) is True
assert pop1.equal(pop3) is False
def test_generational():
np.random.seed(42)
size = 1000
ind_size = 20
pop1 = pg.make_integer_population(size, ind_size)
pop1_clone = pop1.clone()
pop2 = pg.make_integer_population(size, ind_size)
pop1 = pg.generational_replacement(pop1, pop2)
assert pop1.equal(pop2) is True
assert pop1.equal(pop1_clone) is False
def test_worst_individual():
np.random.seed(42)
pop = pg.make_integer_population(10, 5)
pop = pg.evaluate_population(pop, lambda x: 1. / (1. + pg.onemax(x)))
worst = pg.worst_individual(pop)
assert np.array_equal(worst.genotype, np.array([0, 1, 0, 0, 0]))
assert worst.fitness.value == 0.5
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 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 test_steady_state():
np.random.seed(42)
size1 = 10
ind_size = 20
pop1 = pg.make_integer_population(size1, ind_size)
pop1_clone = pop1.clone()
size2 = 2
pop2 = pg.make_integer_population(size2, ind_size)
pop1 = pg.steady_state_replacement(pop1, pop2)
found1 = False
found2 = False
for ind in pop1.individuals:
if ind.equal(pop2.individuals[0]) is True:
found1 = True
if ind.equal(pop2.individuals[1]) is True:
found2 = True
if found1 and found2:
break
assert found1 and found2 is True
def test_make_binary_population():
size = 1000
ind_size = 20
pop = pg.make_integer_population(size, ind_size)
assert type(pop) is pg.Population
assert pop.size == size
assert pop.individuals.size == size
for i in range(size):
assert type(pop.individuals[i]) is pg.Individual
assert pop.individuals[i].genotype.size == ind_size
for g in range(ind_size):
assert pop.individuals[i].genotype[g] >= 0 and pop.individuals[
i].genotype[g] <= 1
def test_apply_crossover1():
np.random.seed(42)
size = 1000
ind_size = 100
rate = 1.0
operator = pg.uniform_crossover
pop = pg.make_integer_population(size, ind_size)
original_pop = pop.clone()
pop = pg.apply_crossover(pop, rate, operator)
for i in range(pop.size):
assert pop.individuals[i].run_eval is True
assert np.array_equal(pop.individuals[i].genotype,
original_pop.individuals[i].genotype) is not True
def test_apply_mutation2():
np.random.seed(42)
size = 1000
ind_size = 100
rate = 0.0
operator = pg.flip_mutation
pop = pg.make_integer_population(size, ind_size)
original_pop = pop.clone()
pop = pg.apply_mutation(pop, rate, operator, gene_rate=rate)
for i in range(pop.size):
assert pop.individuals[i].run_eval is True
assert np.array_equal(pop.individuals[i].genotype,
original_pop.individuals[i].genotype)
def test_make_permutation_population():
size = 1000
ind_size = 20
pop = pg.make_integer_population(size, ind_size, low=None, high=None)
assert type(pop) is pg.Population
assert pop.size == size
assert pop.individuals.size == size
for i in range(size):
assert type(pop.individuals[i]) is pg.Individual
assert pop.individuals[i].genotype.size == ind_size
for g in range(ind_size):
assert pop.individuals[i].genotype[g] >= 0 and pop.individuals[
i].genotype[g] < ind_size
assert np.array_equal(np.sort(pop.individuals[i].genotype),
np.array([g for g in range(ind_size)]))
def test_make_integer_population():
size = 1000
ind_size = 20
low = 0
high = 19
pop = pg.make_integer_population(size, ind_size, low=low, high=high)
assert type(pop) is pg.Population
assert pop.size == size
assert pop.individuals.size == size
for i in range(size):
assert type(pop.individuals[i]) is pg.Individual
assert pop.individuals[i].genotype.size == ind_size
for g in range(ind_size):
assert pop.individuals[i].genotype[g] >= low and pop.individuals[
i].genotype[g] <= high
def test_select_population():
np.random.seed(42)
pop = pg.make_integer_population(10, 5)
pop = pg.evaluate_population(pop, lambda x: 1. / (1. + pg.onemax(x)))
diff = 0
for i in range(pop.size):
if not np.array_equal(pop.individuals[i].genotype,
pop.individuals[i].genotype):
diff += 1
assert diff == 0
original_pop = pop.clone()
pop = pg.select_population(pop, pg.tournament_selection)
for i in range(pop.size):
if not np.array_equal(pop.individuals[i].genotype,
original_pop.individuals[i].genotype):
diff += 1
assert diff != 0
