paulin/EasyGA
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Changed implementation framework

Browse Source 
Instead of a nested approach, selection/crossover/mutation are all called separately and directly by the GA. selection_impl was also separated into parent_selection_impl and survivor_selection_impl, as both are needed separately.
This commit is contained in:
RyleyGG
2020-10-04 17:59:59 -04:00
parent c18a531034
commit e05aa7f62b
5 changed files with 102 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/EasyGA.py
View File

@ -16,17 +16,17 @@ class GA:
"""Initialize the GA.""" """Initialize the GA."""
# Initilization variables # Initilization variables
self.chromosome_length = 10 self.chromosome_length = 10
self.population_size = 100 self.population_size = 150
self.chromosome_impl = None self.chromosome_impl = None
self.gene_impl = None self.gene_impl = None
self.population = None self.population = None
# Termination varibles # Termination varibles
self.current_generation = 0 self.current_generation = 0
self.current_fitness = 0 self.current_fitness = 0
self.generation_goal = 50 self.generation_goal = 100
self.fitness_goal = 3 self.fitness_goal = 3
# Mutation variables # Mutation variables
self.mutation_rate = 0.05 self.mutation_rate = 0.10
# Rerun already computed fitness # Rerun already computed fitness
self.update_fitness = True self.update_fitness = True
@ -34,8 +34,9 @@ class GA:
# Defualt EastGA implimentation structure # Defualt EastGA implimentation structure
self.initialization_impl = Initialization_Types().random_initialization self.initialization_impl = Initialization_Types().random_initialization
self.fitness_function_impl = Fitness_Examples().is_it_5 self.fitness_function_impl = Fitness_Examples().is_it_5
self.mutation_impl = Mutation_Types().random_mutation self.mutation_impl = Mutation_Types().per_gene_mutation
self.selection_impl = Selection_Types().Tournament().with_replacement self.parent_selection_impl = Selection_Types().Parent_Selection().Tournament().with_replacement
self.survivor_selection_impl = Selection_Types().Survivor_Selection().repeated_crossover
self.crossover_impl = Crossover_Types().single_point_crossover self.crossover_impl = Crossover_Types().single_point_crossover
self.termination_impl = Termination_Types().generation_based self.termination_impl = Termination_Types().generation_based
@ -70,7 +71,11 @@ class GA:
self.initialize_population() self.initialize_population()
self.set_all_fitness(self.population.chromosomes) self.set_all_fitness(self.population.chromosomes)
next_population = self.selection_impl(self) self.parent_selection_impl(self)
next_population = self.crossover_impl(self)
next_population = self.survivor_selection_impl(self, next_population)
next_population.set_all_chromosomes(self.mutation_impl(self, next_population.get_all_chromosomes()))
self.population = next_population self.population = next_population
self.set_all_fitness(self.population.chromosomes) self.set_all_fitness(self.population.chromosomes)

6
src/initialization/population_structure/population.py
View File

@ -30,8 +30,10 @@ class Population:
def set_all_chromosomes(self, chromosomes): def set_all_chromosomes(self, chromosomes):
self.chromosomes = chromosomes self.chromosomes = chromosomes
def set_chromosome(self, chromosomes, index): def set_chromosome(self, chromosome, index = -1):
self.chromosome[index] = chromosome if index == -1:
index = len(self.chromosomes)-1
self.chromosomes[index] = chromosome
def set_fitness(self, fitness): def set_fitness(self, fitness):
self.fitness = fitness self.fitness = fitness

23
src/mutation/mutation_types.py
View File

@ -8,7 +8,7 @@ class Mutation_Types:
def random_mutation(self, ga, chromosome_set = None): def random_mutation(self, ga, chromosome_set = None):
if chromosome_set == None: if chromosome_set == None:
chromosome_set = ga.population chromosome_set = ga.population.get_all_chromosomes()
chromosome_mutate_num = int(len(chromosome_set)*ga.mutation_rate) chromosome_mutate_num = int(len(chromosome_set)*ga.mutation_rate)
temp_population = ga.initialization_impl(ga) temp_population = ga.initialization_impl(ga)
@ -19,3 +19,24 @@ class Mutation_Types:
return chromosome_set return chromosome_set
def per_gene_mutation(self, ga, chromosome_set = None, gene_mutate_count = 1):
gene_mutate_count_static = int(gene_mutate_count)
if chromosome_set == None:
chromosome_set = ga.population.get_all_chromosomes()
for i in range(len(chromosome_set)):
random_num = random.uniform(0,1)
if (random_num <= ga.mutation_rate):
while gene_mutate_count > 0:
dummy_population = ga.initialization_impl(ga) #Really inefficient, but works for now
random_index = random.randint(0, ga.chromosome_length-1)
chromosome_set[i].get_genes()[random_index] = dummy_population.get_all_chromosomes()[random.randint(0,ga.population_size-1)].get_genes()[random_index]
gene_mutate_count -= 1
gene_mutate_count = int(gene_mutate_count_static)
return chromosome_set

5
src/run_testing.py
View File

@ -5,7 +5,10 @@ import random
# Create the Genetic algorithm # Create the Genetic algorithm
ga = EasyGA.GA() ga = EasyGA.GA()
ga.gene_impl = [random.randrange,1,25] #def random_parent_selection(population):
#while ()
ga.gene_impl = [random.randrange,1,100]
# Run Everything # Run Everything
ga.evolve() ga.evolve()

165
src/selection/selection_types.py
View File

@ -9,113 +9,67 @@ class Selection_Types:
def __init__(self): def __init__(self):
pass pass
class Tournament: class Parent_Selection:
def with_replacement(self, ga): class Tournament:
tournament_size = int(len(ga.population.get_all_chromosomes())/10) #currently hard-coded for purposes of the example. def with_replacement(self, ga):
if tournament_size < 3: tournament_size = int(len(ga.population.get_all_chromosomes())/10) #currently hard-coded for purposes of the example.
tournament_size = int(len(ga.population.get_all_chromosomes())/3) if tournament_size < 3:
tournament_size = int(len(ga.population.get_all_chromosomes())/3)
parent_ratio = 0.25
#selection_probability is the likelihood that a chromosome will be selected. #selection_probability is the likelihood that a chromosome will be selected.
#best chromosome in a tournament is given a selection probablity of selection_probability #best chromosome in a tournament is given a selection probablity of selection_probability
#2nd best is given probability of selection_probability*(1-selection_probability) #2nd best is given probability of selection_probability*(1-selection_probability)
#3rd best is given probability of selection_probability*(1-selection_probability)**2 #3rd best is given probability of selection_probability*(1-selection_probability)**2
selection_probability = 0.95 selection_probability = 0.95
total_selected = 0 #Total Chromosomes selected total_selected = 0 #Total Chromosomes selected
while (total_selected <= ga.population_size*2): while (total_selected < parent_ratio*ga.population_size):
#create & gather tournament group #create & gather tournament group
tournament_group = [] tournament_group = []
for i in range(tournament_size): for i in range(tournament_size):
tournament_group.append(random.choice(ga.population.get_all_chromosomes())) tournament_group.append(random.choice(ga.population.get_all_chromosomes()))
total_selected = self.selection(tournament_group, tournament_size, total_selected, selection_probability)[0]
new_population = self.create_new_population(ga) #Sort the tournament contenders based on their fitness
return new_population #currently hard-coded to only consider higher fitness = better; can be changed once this impl is agreed on
#also currently uses bubble sort because its easy
tournament_group_temp = tournament_group
not_sorted_check = 0
while (not_sorted_check != len(tournament_group_temp)):
not_sorted_check = 0
for i in range(len(tournament_group_temp)):
if ((i + 1 < len(tournament_group_temp)) and (tournament_group_temp[i + 1].fitness > tournament_group_temp[i].fitness)):
temp = tournament_group[i]
tournament_group_temp[i] = tournament_group[i + 1]
tournament_group_temp[i + 1] = temp
else:
not_sorted_check += 1
def without_replacement(self, ga): tournament_group = tournament_group_temp
tournament_size = int(len(ga.population.get_all_chromosomes())/10) #currently hard-coded for purposes of the example.
if tournament_size < 3:
tournament_size = int(len(ga.population.get_all_chromosomes())/3)
#selection_probability is the likelihood that a chromosome will be selected. #After sorting by fitness, randomly select a chromosome based on selection_probability
#best chromosome in a tournament is given a selection probablity of selection_probability selected_chromosome_tournament_index = 0
#2nd best is given probability of selection_probability*(1-selection_probability) for i in range(tournament_size):
#3rd best is given probability of selection_probability*(1-selection_probability)**2 random_num = random.uniform(0,1)
selection_probability = 0.95
total_selected = 0 #Total Chromosomes selected
available_chromosome_indices = []
for i in range(len(ga.population.get_all_chromosomes())):
available_chromosome_indices.append(i)
continue_selecting = True #ugly implementation but its functional
if i == 0:
if random_num <= selection_probability:
tournament_group[i].selected = True
total_selected += 1
selected_chromosome_tournament_index = i
break
else:
if random_num <= selection_probability*((1-selection_probability)**(i-1)):
tournament_group[i].selected = True
total_selected += 1
selected_chromosome_tournament_index = i
break
while (continue_selecting): class Survivor_Selection:
#create & gather tournament group def repeated_crossover(self, ga, next_population):
tournament_group = [] while len(next_population.chromosomes) < ga.population_size:
for i in range(tournament_size):
selected_chromosome_index = random.choice(available_chromosome_indices)
tournament_group.append(ga.population.get_all_chromosomes()[selected_chromosome_index])
winning_chromosome_index = self.selection(tournament_group, tournament_size, total_selected, selection_probability)[1]
for i in range(len(available_chromosome_indices)):
if tournament_group[winning_chromosome_index].selected:
del available_chromosome_indices[i]
break
#print(winning_chromosome_index)
#print(available_chromosome_indices)
if len(available_chromosome_indices) < 1:
continue_selecting = False
new_population = self.create_new_population(ga)
return new_population
def selection(self, tournament_group, tournament_size, total_selected, selection_probability):
#Sort the tournament contenders based on their fitness
#currently hard-coded to only consider higher fitness = better; can be changed once this impl is agreed on
#also currently uses bubble sort because its easy
tournament_group_temp = tournament_group
not_sorted_check = 0
while (not_sorted_check != len(tournament_group_temp)):
not_sorted_check = 0
for i in range(len(tournament_group_temp)):
if ((i + 1 < len(tournament_group_temp)) and (tournament_group_temp[i + 1].fitness > tournament_group_temp[i].fitness)):
temp = tournament_group[i]
tournament_group_temp[i] = tournament_group[i + 1]
tournament_group_temp[i + 1] = temp
else:
not_sorted_check += 1
tournament_group = tournament_group_temp
#After sorting by fitness, randomly select a chromosome based on selection_probability
selected_chromosome_tournament_index = 0
for i in range(tournament_size):
random_num = random.uniform(0,1)
#ugly implementation but its functional
if i == 0:
if random_num <= selection_probability:
tournament_group[i].selected = True
total_selected += 1
selected_chromosome_tournament_index = i
break
else:
if random_num <= selection_probability*((1-selection_probability)**(i-1)):
tournament_group[i].selected = True
total_selected += 1
selected_chromosome_tournament_index = i
break
return total_selected,selected_chromosome_tournament_index
def create_new_population(self, ga):
new_population = ga.crossover_impl(ga)
#If the crossover doesn't create enough chromosomes (ugly right now pls no judgerino, can be changed)
#Just does single-point crossover at random indices
while len(new_population.chromosomes) < ga.population_size:
crossover_pool = [] crossover_pool = []
for i in range(ga.population_size): for i in range(ga.population_size):
if ga.population.get_all_chromosomes()[i].selected: if ga.population.get_all_chromosomes()[i].selected:
@ -130,18 +84,15 @@ class Selection_Types:
parent_two = crossover_pool[i+1].get_genes() parent_two = crossover_pool[i+1].get_genes()
new_gene_set.extend(parent_one[0:split_point]) new_gene_set.extend(parent_one[0:split_point])
new_gene_set.extend(parent_two[split_point:]) new_gene_set.extend(parent_two[split_point:])
new_chromosome = Chromosome(new_gene_set) new_chromosome = create_chromosome(new_gene_set)
chromosome_list.append(new_chromosome) chromosome_list.append(new_chromosome)
for i in range(len(chromosome_list)): for i in range(len(chromosome_list)):
new_population.add_chromosome(chromosome_list[i]) next_population.add_chromosome(chromosome_list[i])
if len(new_population.chromosomes) >= ga.population_size: if len(next_population.chromosomes) >= ga.population_size:
break break
return next_population
new_chromosome_set = ga.mutation_impl(ga, new_population.get_all_chromosomes())
new_population.set_all_chromosomes(new_chromosome_set)
return new_population
def roulette_selection(self, ga): def roulette_selection(self, ga):
"""Roulette selection works based off of how strong the fitness is of the """Roulette selection works based off of how strong the fitness is of the