def reproduce(population):
"""Applies the evolutionary survival process to the population.
A few select elites with the best reward (fitness) is automatically part of the next generation.
From the population parents are selected to create offspring. The offspring will be part of
the next generation. The parents will cease to exist unless they were part of the elite.
Mutation is applied to the offspring, which has a chance of altering the chromosomes.
Args:
The population which is a list of the object Individual. The entire population just ran in
the simulation and their reward (fitness) was stored.
Returns:
A new population which is a list of the object Individual. The new population is the next generation
and consists of the elite from the previous population and offspring from the previous generation.
"""
# Sort the population by its reward (fitness)
population = sorted(population, key=lambda x: x.reward, reverse=True)
total_remove = 94
if judgement_day(population):
new_population = [population[0]]
for i in range(100 - len(new_population)):
new_population.append(random_neural_network())
return new_population
# Elitism
new_population = population[:(len(population) - total_remove)]
# Selection, may be replaced by tournament_selection method
parent_1, parent_2 = wheel_selection(total_remove, population)
for i in range(int(total_remove / 2)):
weight_1, weight_2 = uniform_crossover(parent_1[i].chromosome_1,
parent_2[i].chromosome_1)
bias_1, bias_2 = uniform_crossover(parent_1[i].chromosome_2,
parent_2[i].chromosome_2)
mutate(weight_1)
mutate(weight_2)
mutate(bias_1)
mutate(bias_2)
c1 = Individual()
c2 = Individual()
c1.chromosome_1 = weight_1
c1.chromosome_2 = bias_1
c2.chromosome_1 = weight_2
c2.chromosome_2 = bias_2
new_population.append(c1)
new_population.append(c2)
return new_population
def uniform_crossover_binary(p1, p2):
"""Translate the rules to binary and apply crossover.
Arguments:
p1: The chromosome of the first parent. Is a list of numbers.
p2: The chromosome of the second parent. Is a list of numbers.
Returns:
Two new rule sets in base 10 value. Is two lists of numbers.
"""
p1_binary = []
p2_binary = []
for rule_id in p1:
p1_binary.append(list(map(int, format(rule_id, "#010b")[2:])))
for rule_id in p2:
p2_binary.append(list(map(int, format(rule_id, "#010b")[2:])))
c1, c2 = uniform_crossover(p1_binary, p2_binary)
for i in range(len(c1)):
c1[i] = int("".join(str(x) for x in c1[i]), 2)
for j in range(len(c2)):
c2[j] = int("".join(str(x) for x in c2[j]), 2)
return c1, c2
def reproduce(population):
"""Applies the evolutionary survival process to the population.
A few select elites with the best reward (fitness) is automatically part of the next generation.
From the population parents are selected to create offspring. The offspring will be part of
the next generation. The parents will cease to exist unless they were part of the elite.
Mutation is applied to the offspring, which has a chance of altering the chromosomes.
Args:
The population which is a list of the object Individual. The entire population just ran in
the simulation and their reward (fitness) was stored.
Returns:
A new population which is a list of the object Individual. The new population is the next generation
and consists of the elite from the previous population and offspring from the previous generation.
"""
# Sort the population to find out which had the best performance
population = sorted(population, key=lambda x: x.reward, reverse=True)
total_remove = 94
# Elitism
new_population = population[:(len(population) - total_remove)]
parent_1, parent_2 = wheel_selection(total_remove, population)
for i in range(int(total_remove / 2)):
if random_offspring(parent_1[i], parent_2[i]):
individual_1, individual_2 = create_random_offspring()
else:
rule_1, rule_2 = uniform_crossover_binary(parent_1[i].chromosome_1,
parent_2[i].chromosome_1)
range_1, range_2 = uniform_crossover(parent_1[i].chromosome_2,
parent_2[i].chromosome_2)
mutate(rule_1)
mutate(rule_2)
ca_mutate(range_1)
ca_mutate(range_2)
individual_1 = Individual()
individual_2 = Individual()
individual_1.chromosome_1 = rule_1
individual_2.chromosome_1 = rule_2
individual_1.chromosome_2 = range_1
individual_2.chromosome_2 = range_2
new_population.append(individual_1)
new_population.append(individual_2)
return new_population
def michigan(population, N, p, trainingData):
'''
:param population: a fuzzy rule set
:param N: number of iteration
:param p: rate
:return:
'''
pc = p[0]
pm = p[1]
# sort population
population.rules.sort(key=lambda x: x.fitness, reverse=True)
# child_set = []
# for i in range(N):
# child_set.append(p1)
# P1 p2是rule
p1, p2 = selection.binary_tournament_selection(population.rules)
# c = copy.deepcopy(p1)
cp1_rule = p1.rule
cp2_rule = p2.rule
if random.random() < pc:
# crossover for rule
child_rule = crossover.uniform_crossover(cp1_rule, cp2_rule)
else:
child_rule = [cp1_rule, cp2_rule][random.random() < 0.5]
if random.random() < pm:
child_rule = mutation.rule_mutation(child_rule)
p1.rule = child_rule
p1.Cq, p1.CFq = p1.getCqCFq(child_rule, trainingData)
population.rules[-1] = p1
return population
def genetic_algorithm(k):
""" Function that actually runs the Genetic Algorithm.
Keyword arguments:
k -- number of iterations to run the algorithm for
Returns:
best_log and avg_log -- Both contain k lists, each containing
x integers, where x is the number of generations on that
iteration, that represent the best and average fitness
score for each generation, respectively
pop_size_log -- List containing k integers, each being the
size of the population on that iteration
"""
best_log = []
avg_log = []
pop_size_log = []
for iteration in range(0, k):
# Lists that will hold the
gen_best_log = []
gen_avg_log = []
# Defining number of generations and probabilities
gen_number = 25
crossover_probability = 0.75
mutation_probability = 0.0001
# Starting population
population, pop_size = utils.create_population(iteration)
pop_size_log.append(pop_size)
# Defining the size of the tournament's bracket
# the k in k-way tournament
tournament_bracket_size = round(pop_size/20)
# Iterating through all generations
for j in range(0, gen_number):
# Calculating the fitness score for every
# subject in the population and saving the
# best and the average score
pop_fitness, best, average = utils.calculate_pop_fitness(population)
gen_best_log.append(best)
gen_avg_log.append(average)
# Preventing the algorithm to go all the way through
# during the last iteration, since that population
# won't be recorded anyways
if j == gen_number - 1:
break
# Calling the tournament, crossover and mutation function
# and overwriting the current population with the new one
population = tournament.k_way_tournament(population, pop_size, pop_fitness, tournament_bracket_size)
population = crossover.uniform_crossover(population, pop_size, crossover_probability)
population = mutation.mutation(population, mutation_probability)
best_log.append(gen_best_log)
avg_log.append(gen_avg_log)
return best_log, avg_log, pop_size_log
import statistics_module
import crossover
import parents_selector
import mutation
initial_population=horse.Horse.generate_population(10)
my_hipodrome=hipodrome.Hipodrome(7,7,3,4)
list_fitness=calculate_population_fitness(initial_population,my_hipodrome)
current_population_statistics=[]
for i in range(len(initial_population)):
horse=initial_population[i]
horse_fitness=list_fitness[i]
my_horse=statistics_module.FitnessStatistics(horse,horse_fitness)
current_population_statistics.append(my_horse)
parents=parents_selector.select_candidates(current_population_statistics,2)
offspring=crossover.uniform_crossover(parents,10)
after_mutation_offsping=mutation.non_uniform_mutation(offspring)
second_population=horse.new_population_generator(after_mutation_offsping)
print(after_mutation_offsping)
print(second_population)