def __init__(self,
all_possible_genes,
retain=0.15,
random_select=0.1,
mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genome parameters
retain (float): Percentage of population to retain after
each generation
random_select (float): Probability of a rejected genome
remaining in the population
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
def __init__(self,
all_possible_genes,
retain=0.15,
random_select=0.1,
mutate_chance=0.3,
opt_for_highest=True):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genome parameters
retain (float): Percentage of population to retain after each generation
random_select (float): Probability of a rejected genome remaining in the population
mutate_chance (float): Probability a genome will be randomly mutated
opt_for_highest (bool): If False, will optimize for lowest value (e.g. loss),
if True then for highest value (e.g. accuracy)
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
self.opt_for_highest = opt_for_highest
# Genome store
self.master = None
# set the ID gen
self.ids = IDgen()
def __init__(self,
all_possible_genes,
retain=0.15,
random_select=0.1,
mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genes (i.e., network
hyperparameters)
retain (float): Proportion of top-performing genomes to
retain for the next generation
random_select (float): Probabilty of a non-top-performing
genome to retain for the next generation
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
def __init__(self, all_possible_genes, retain=0.15, random_select=0.1, mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genome parameters
retain (float): Percentage of population to retain after
each generation
random_select (float): Probability of a rejected genome
remaining in the population
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
class Evolver():
"""Class that implements genetic algorithm."""
def __init__(self,
all_possible_genes,
retain=0.15,
random_select=0.1,
mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genome parameters
retain (float): Percentage of population to retain after
each generation
random_select (float): Probability of a rejected genome
remaining in the population
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
def create_population(self, count):
"""Create a population of random networks.
Args:
count (int): Number of networks to generate, aka the
size of the population
Returns:
(list): Population of network objects
"""
pop = []
i = 0
while i < count:
# Initialize a new genome.
genome = Genome(self.all_possible_genes, {},
self.ids.get_next_ID(), 0, 0, self.ids.get_Gen())
# Set it to random parameters.
genome.set_genes_random()
if i == 0:
#this is where we will store all genomes
self.master = AllGenomes(genome)
else:
# Make sure it is unique....
while self.master.is_duplicate(genome):
genome.mutate_one_gene()
# Add the genome to our population.
pop.append(genome)
# and add to the master list
if i > 0:
self.master.add_genome(genome)
i += 1
#self.master.print_all_genomes()
#exit()
return pop
@staticmethod
def fitness(genome):
"""Return the accuracy, which is our fitness function."""
return genome.accuracy
def grade(self, pop):
"""Find average fitness for a population.
Args:
pop (list): The population of networks/genome
Returns:
(float): The average accuracy of the population
"""
summed = reduce(add, (self.fitness(genome) for genome in pop))
return summed / float((len(pop)))
def breed(self, mom, dad):
"""Make two children from parental genes.
Args:
mother (dict): genome parameters
father (dict): genome parameters
Returns:
(list): Two network objects
"""
children = []
#where do we recombine? 0, 1, 2, 3, 4... N?
#with four genes, there are three choices for the recombination
# ___ * ___ * ___ * ___
#0 -> no recombination, and N == length of dictionary -> no recombination
#0 and 4 just (re)create more copies of the parents
#so the range is always 1 to len(all_possible_genes) - 1
pcl = len(self.all_possible_genes)
recomb_loc = random.randint(1, pcl - 1)
#for _ in range(2): #make _two_ children - could also make more
child1 = {}
child2 = {}
#enforce defined genome order using list
#keys = ['nb_neurons', 'nb_layers', 'activation', 'optimizer']
keys = list(self.all_possible_genes)
keys = sorted(
keys
) #paranoia - just to make sure we do not add unintentional randomization
#*** CORE RECOMBINATION CODE ****
for x in range(0, pcl):
if x < recomb_loc:
child1[keys[x]] = mom.geneparam[keys[x]]
child2[keys[x]] = dad.geneparam[keys[x]]
else:
child1[keys[x]] = dad.geneparam[keys[x]]
child2[keys[x]] = mom.geneparam[keys[x]]
# Initialize a new genome
# Set its parameters to those just determined
# they both have the same mom and dad
genome1 = Genome(self.all_possible_genes, child1,
self.ids.get_next_ID(), mom.u_ID, dad.u_ID,
self.ids.get_Gen())
genome2 = Genome(self.all_possible_genes, child2,
self.ids.get_next_ID(), mom.u_ID, dad.u_ID,
self.ids.get_Gen())
#at this point, there is zero guarantee that the genome is actually unique
# Randomly mutate one gene
if self.mutate_chance > random.random():
genome1.mutate_one_gene()
if self.mutate_chance > random.random():
genome2.mutate_one_gene()
#do we have a unique child or are we just retraining one we already have anyway?
while self.master.is_duplicate(genome1):
genome1.mutate_one_gene()
self.master.add_genome(genome1)
while self.master.is_duplicate(genome2):
genome2.mutate_one_gene()
self.master.add_genome(genome2)
children.append(genome1)
children.append(genome2)
return children
def evolve(self, pop):
"""Evolve a population of genomes.
Args:
pop (list): A list of genome parameters
Returns:
(list): The evolved population of networks
"""
#increase generation
self.ids.increase_Gen()
# Get scores for each genome
graded = [(self.fitness(genome), genome) for genome in pop]
#and use those scores to fill in the master list
for genome in pop:
self.master.set_accuracy(genome)
# Sort on the scores.
graded = [
x[1] for x in sorted(graded, key=lambda x: x[0], reverse=True)
]
# Get the number we want to keep unchanged for the next cycle.
retain_length = int(len(graded) * self.retain)
# In this first step, we keep the 'top' X percent (as defined in self.retain)
# We will not change them, except we will update the generation
new_generation = graded[:retain_length]
# For the lower scoring ones, randomly keep some anyway.
# This is wasteful, since we _know_ these are bad, so why keep rescoring them without modification?
# At least we should mutate them
for genome in graded[retain_length:]:
if self.random_select > random.random():
gtc = copy.deepcopy(genome)
while self.master.is_duplicate(gtc):
gtc.mutate_one_gene()
gtc.set_generation(self.ids.get_Gen())
new_generation.append(gtc)
self.master.add_genome(gtc)
# Now find out how many spots we have left to fill.
ng_length = len(new_generation)
desired_length = len(pop) - ng_length
children = []
# Add children, which are bred from pairs of remaining (i.e. very high or lower scoring) genomes.
while len(children) < desired_length:
# Get a random mom and dad, but, need to make sure they are distinct
parents = random.sample(range(ng_length - 1), k=2)
i_male = parents[0]
i_female = parents[1]
male = new_generation[i_male]
female = new_generation[i_female]
# Recombine and mutate
babies = self.breed(male, female)
# the babies are guaranteed to be novel
# Add the children one at a time.
for baby in babies:
# Don't grow larger than desired length.
#if len(children) < desired_length:
children.append(baby)
new_generation.extend(children)
return new_generation
class Evolver():
"""Class that implements genetic algorithm."""
def __init__(self,
all_possible_genes,
retain=0.15,
random_select=0.1,
mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genes (i.e., network
hyperparameters)
retain (float): Proportion of top-performing genomes to
retain for the next generation
random_select (float): Probabilty of a non-top-performing
genome to retain for the next generation
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
def create_population(self, count):
"""Create a population of random genomes.
Args:
count (int): Number of genomes to generate, aka the
size of the population
Returns:
(list): Population of genome objects
"""
pop = []
i = 0
while i < count:
#initialize a new genome
genome = Genome(self.all_possible_genes, {},
self.ids.get_next_ID(), 0, 0, self.ids.get_Gen())
#set it to random parameters
genome.set_genes_random()
if i == 0:
#this is where we will store all genomes
self.master = AllGenomes(genome)
else:
#make sure it is unique....
while self.master.is_duplicate(genome):
genome.mutate_one_gene()
#add the genome to our population
pop.append(genome)
#and add to the master list
if i > 0:
self.master.add_genome(genome)
i += 1
return pop
@staticmethod
def fitness(genome):
"""Return the accuracy, which is our fitness function."""
return genome.accuracy
def grade(self, pop):
"""Find average fitness for a population.
Args:
pop (list): The population of genomes
Returns:
(float): The average accuracy of the population
"""
summed = reduce(add, (self.fitness(genome) for genome in pop))
return summed / float((len(pop)))
def breed(self, mom, dad):
"""Make two children from parental genes.
Args:
mother (dict): genome parameters
father (dict): genome parameters
Returns:
(list): Two genome objects
"""
children = []
nr_genes = len(self.all_possible_genes)
#get a gene location for single-point crossover
crossover_loc = random.randint(1, nr_genes - 1)
child1 = {}
child2 = {}
#enforce defined genome order using list
keys = list(self.all_possible_genes)
keys = sorted(keys)
#perform single-point crossover
for x in range(0, nr_genes):
if x < crossover_loc:
child1[keys[x]] = mom.geneparam[keys[x]]
child2[keys[x]] = dad.geneparam[keys[x]]
else:
child1[keys[x]] = dad.geneparam[keys[x]]
child2[keys[x]] = mom.geneparam[keys[x]]
#initialize a new genome
#set its parameters to those just determined
#they both have the same mom and dad
genome1 = Genome(self.all_possible_genes, child1,
self.ids.get_next_ID(), mom.u_ID, dad.u_ID,
self.ids.get_Gen())
genome2 = Genome(self.all_possible_genes, child2,
self.ids.get_next_ID(), mom.u_ID, dad.u_ID,
self.ids.get_Gen())
#randomly mutate one gene
if self.mutate_chance > random.random():
genome1.mutate_one_gene()
if self.mutate_chance > random.random():
genome2.mutate_one_gene()
#if child is a duplicate within the new generation, mutate a gene
while self.master.is_duplicate(genome1):
genome1.mutate_one_gene()
self.master.add_genome(genome1)
while self.master.is_duplicate(genome2):
genome2.mutate_one_gene()
self.master.add_genome(genome2)
children.append(genome1)
children.append(genome2)
return children
def evolve(self, pop):
"""Evolve a population of genomes.
Args:
pop (list): A list of genome parameters
Returns:
(list): The evolved population of genomes
"""
#increase generation
self.ids.increase_Gen()
#get scores for each genome
graded = [(self.fitness(genome), genome) for genome in pop]
#and use those scores to fill in the master list
for genome in pop:
self.master.set_accuracy(genome)
#sort on the scores
graded = [
x[1] for x in sorted(graded, key=lambda x: x[0], reverse=True)
]
#get the number we want to keep unchanged for the next cycle
retain_length = int(len(graded) * self.retain)
#in this first step, we keep the 'top' X percent (as defined in self.retain)
#we will not change them, except we will update the generation
new_generation = graded[:retain_length]
#for the lower scoring ones, randomly keep some anyway
for genome in graded[retain_length:]:
if self.random_select > random.random():
randomgenome = copy.deepcopy(genome)
while self.master.is_duplicate(randomgenome):
randomgenome.mutate_one_gene()
randomgenome.set_generation(self.ids.get_Gen())
new_generation.append(randomgenome)
self.master.add_genome(randomgenome)
#now find out how many spots we have left to fill in the new generation
ng_length = len(new_generation)
desired_length = len(pop) - ng_length
children = []
#add children, which are bred from pairs of genomes in the new generation (i.e. retained and randomly selected genomes)
while len(children) < desired_length:
#get a random mom and dad, but, need to make sure they are distinct
parents = random.sample(range(ng_length - 1), k=2)
i_male = parents[0]
i_female = parents[1]
male = new_generation[i_male]
female = new_generation[i_female]
#do crossover and mutation
babies = self.breed(male, female)
#the babies are guaranteed to be novel
#add the children one at a time
for baby in babies:
children.append(baby)
new_generation.extend(children)
return new_generation
class Evolver():
"""Class that implements genetic algorithm."""
def __init__(self, all_possible_genes, retain=0.15, random_select=0.1, mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genome parameters
retain (float): Percentage of population to retain after
each generation
random_select (float): Probability of a rejected genome
remaining in the population
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
def create_population(self, count):
"""Create a population of random networks.
Args:
count (int): Number of networks to generate, aka the
size of the population
Returns:
(list): Population of network objects
"""
pop = []
i = 0
while i < count:
# Initialize a new genome.
genome = Genome( self.all_possible_genes, {}, self.ids.get_next_ID(), 0, 0, self.ids.get_Gen() )
# Set it to random parameters.
genome.set_genes_random()
if i == 0:
#this is where we will store all genomes
self.master = AllGenomes( genome )
else:
# Make sure it is unique....
while self.master.is_duplicate( genome ):
genome.mutate_one_gene()
# Add the genome to our population.
pop.append(genome)
# and add to the master list
if i > 0:
self.master.add_genome(genome)
i += 1
#self.master.print_all_genomes()
#exit()
return pop
@staticmethod
def fitness(genome):
"""Return the accuracy, which is our fitness function."""
return genome.accuracy
def grade(self, pop):
"""Find average fitness for a population.
Args:
pop (list): The population of networks/genome
Returns:
(float): The average accuracy of the population
"""
summed = reduce(add, (self.fitness(genome) for genome in pop))
return summed / float((len(pop)))
def breed(self, mom, dad):
"""Make two children from parental genes.
Args:
mother (dict): genome parameters
father (dict): genome parameters
Returns:
(list): Two network objects
"""
children = []
#where do we recombine? 0, 1, 2, 3, 4... N?
#with four genes, there are three choices for the recombination
# ___ * ___ * ___ * ___
#0 -> no recombination, and N == length of dictionary -> no recombination
#0 and 4 just (re)create more copies of the parents
#so the range is always 1 to len(all_possible_genes) - 1
pcl = len(self.all_possible_genes)
recomb_loc = random.randint(1,pcl - 1)
#for _ in range(2): #make _two_ children - could also make more
child1 = {}
child2 = {}
#enforce defined genome order using list
#keys = ['nb_neurons', 'nb_layers', 'activation', 'optimizer']
keys = list(self.all_possible_genes)
keys = sorted(keys) #paranoia - just to make sure we do not add unintentional randomization
#*** CORE RECOMBINATION CODE ****
for x in range(0, pcl):
if x < recomb_loc:
child1[keys[x]] = mom.geneparam[keys[x]]
child2[keys[x]] = dad.geneparam[keys[x]]
else:
child1[keys[x]] = dad.geneparam[keys[x]]
child2[keys[x]] = mom.geneparam[keys[x]]
# Initialize a new genome
# Set its parameters to those just determined
# they both have the same mom and dad
genome1 = Genome( self.all_possible_genes, child1, self.ids.get_next_ID(), mom.u_ID, dad.u_ID, self.ids.get_Gen() )
genome2 = Genome( self.all_possible_genes, child2, self.ids.get_next_ID(), mom.u_ID, dad.u_ID, self.ids.get_Gen() )
#at this point, there is zero guarantee that the genome is actually unique
# Randomly mutate one gene
if self.mutate_chance > random.random():
genome1.mutate_one_gene()
if self.mutate_chance > random.random():
genome2.mutate_one_gene()
#do we have a unique child or are we just retraining one we already have anyway?
while self.master.is_duplicate(genome1):
genome1.mutate_one_gene()
self.master.add_genome(genome1)
while self.master.is_duplicate(genome2):
genome2.mutate_one_gene()
self.master.add_genome(genome2)
children.append(genome1)
children.append(genome2)
return children
def evolve(self, pop):
"""Evolve a population of genomes.
Args:
pop (list): A list of genome parameters
Returns:
(list): The evolved population of networks
"""
#increase generation
self.ids.increase_Gen()
# Get scores for each genome
graded = [(self.fitness(genome), genome) for genome in pop]
#and use those scores to fill in the master list
for genome in pop:
self.master.set_accuracy(genome)
# Sort on the scores.
graded = [x[1] for x in sorted(graded, key=lambda x: x[0], reverse=True)]
# Get the number we want to keep unchanged for the next cycle.
retain_length = int(len(graded)*self.retain)
# In this first step, we keep the 'top' X percent (as defined in self.retain)
# We will not change them, except we will update the generation
new_generation = graded[:retain_length]
# For the lower scoring ones, randomly keep some anyway.
# This is wasteful, since we _know_ these are bad, so why keep rescoring them without modification?
# At least we should mutate them
for genome in graded[retain_length:]:
if self.random_select > random.random():
gtc = copy.deepcopy(genome)
while self.master.is_duplicate(gtc):
gtc.mutate_one_gene()
gtc.set_generation( self.ids.get_Gen() )
new_generation.append(gtc)
self.master.add_genome(gtc)
# Now find out how many spots we have left to fill.
ng_length = len(new_generation)
desired_length = len(pop) - ng_length
children = []
# Add children, which are bred from pairs of remaining (i.e. very high or lower scoring) genomes.
while len(children) < desired_length:
# Get a random mom and dad, but, need to make sure they are distinct
parents = random.sample(range(ng_length-1), k=2)
i_male = parents[0]
i_female = parents[1]
male = new_generation[i_male]
female = new_generation[i_female]
# Recombine and mutate
babies = self.breed(male, female)
# the babies are guaranteed to be novel
# Add the children one at a time.
for baby in babies:
# Don't grow larger than desired length.
#if len(children) < desired_length:
children.append(baby)
new_generation.extend(children)
return new_generation
class Evolver():
"""Class that implements genetic algorithm."""
def __init__(self,
all_possible_genes,
retain=0.2,
random_select=0.1,
mutate_chance=0.3):
"""Create an optimizer.
Args:
all_possible_genes (dict): Possible genome parameters
retain (float): Percentage of population to retain after
each generation
random_select (float): Probability of a rejected genome
remaining in the population
mutate_chance (float): Probability a genome will be
randomly mutated
"""
self.all_possible_genes = all_possible_genes
self.retain = retain
self.random_select = random_select
self.mutate_chance = mutate_chance
#set the ID gen
self.ids = IDgen()
def create_population(self, count):
"""Create a population of random networks.
Args:
count (int): Number of networks to generate, aka the
size of the population
Returns:
(list): Population of network objects
"""
pop = []
i = 0
while i < count:
# Initialize a new genome.
genome = Genome(self.all_possible_genes, {},
self.ids.get_next_ID(), 0, 0, self.ids.get_Gen())
# Set it to random parameters.
genome.set_genes_random()
if i == 0:
#this is where we will store all genomes
self.master = AllGenomes(genome)
else:
# Make sure it is unique....
while self.master.is_duplicate(genome):
genome.mutate_one_gene()
# Add the genome to our population.
pop.append(genome)
# and add to the master list
if i > 0:
self.master.add_genome(genome)
i += 1
#self.master.print_all_genomes()
#exit()
return pop
@staticmethod
def fitness(genome):
"""Return the accuracy, which is our fitness function."""
return genome.accuracy
def grade(self, pop):
"""Find average fitness for a population.
Args:
pop (list): The population of networks/genome
Returns:
(float): The average accuracy of the population
"""
summed = reduce(add, (self.fitness(genome) for genome in pop))
return summed / float((len(pop)))
def breed(self, mom, dad):
"""
Make a child from two parent genes
:param mom: A genome parameter
:param dad: A genome parameter
:return: A child gene
"""
child_gene = {}
mom_gene = mom.geneparam
dad_gene = dad.geneparam
# Choose the optimizer
child_gene['optimizer'] = random.choice(
[mom_gene['optimizer'], dad_gene['optimizer']])
# Combine the layers
max_len = max(len(mom_gene['layers']), len(dad_gene['layers']))
child_layers = []
for pos in range(max_len):
from_mom = bool(random.getrandbits(1))
# Add the layer from the correct parent IF it exists. Otherwise add nothing
if from_mom and len(mom_gene['layers']) > pos:
child_layers.append(mom_gene['layers'][pos])
elif not from_mom and len(dad_gene['layers']) > pos:
child_layers.append(dad_gene['layers'][pos])
child_gene['layers'] = child_layers
child = Genome(self.all_possible_genes, child_gene,
self.ids.get_next_ID(), mom.u_ID, dad.u_ID,
self.ids.get_Gen())
#at this point, there is zero guarantee that the genome is actually unique
# Randomly mutate one gene
if self.mutate_chance > random.random():
child.mutate_one_gene()
#do we have a unique child or are we just retraining one we already have anyway?
while self.master.is_duplicate(child):
child.mutate_one_gene()
self.master.add_genome(child)
return child
def evolve(self, pop):
"""Evolve a population of genomes.
Args:
pop (list): A list of genome parameters
Returns:
(list): The evolved population of networks
"""
#increase generation
self.ids.increase_Gen()
# Get scores for each genome
graded = [(self.fitness(genome), genome) for genome in pop]
#and use those scores to fill in the master list
for genome in pop:
self.master.set_accuracy(genome)
# Sort on the scores.
graded = [
x[1] for x in sorted(graded, key=lambda x: x[0], reverse=True)
]
# Get the number we want to keep unchanged for the next cycle.
retain_length = int(len(graded) * self.retain)
# In this first step, we keep the 'top' X percent (as defined in self.retain)
# We will not change them, except we will update the generation
new_generation = graded[:retain_length]
# For the lower scoring ones, randomly keep some anyway.
# This is wasteful, since we _know_ these are bad, so why keep rescoring them without modification?
# At least we should mutate them
for genome in graded[retain_length:]:
if self.random_select > random.random():
gtc = copy.deepcopy(genome)
while self.master.is_duplicate(gtc):
gtc.mutate_one_gene()
gtc.set_generation(self.ids.get_Gen())
new_generation.append(gtc)
self.master.add_genome(gtc)
# Now find out how many spots we have left to fill.
ng_length = len(new_generation)
print(str(ng_length))
desired_length = len(pop) - ng_length
children = []
# Add children, which are bred from pairs of remaining (i.e. very high or lower scoring) genomes.
while len(children) < desired_length:
# Get a random mom and dad, but, need to make sure they are distinct
parents = random.sample(range(ng_length - 1), k=2)
i_male = parents[0]
i_female = parents[1]
male = new_generation[i_male]
female = new_generation[i_female]
baby = self.breed(male, female)
children.append(baby)
new_generation.extend(children)
return new_generation