def next_generation(self, population): selection = Selection(deepcopy(population), strategy=SelectionStrategy.TOURNAMENT.value) mating = Mating(selection) crossover = Crossover(mating) for i, individual in enumerate(crossover.mating.selection.population.individuals): mutation = Mutation(individual) crossover.mating.selection.population.individuals[i] = mutation.mutate() print(f'Individuals: {len(self.individuals)}') print(f'New generation: {len(crossover.new_generation)}') return crossover.mating.selection.population
# Select parents for offspring generation for ch in range(0, scored_population.__len__(), 1): # perform parent selection from scored population selection = Selection(population=scored_population) parents = selection.select() # perform crossover based on 50% probability crossover_prob = random.choice([True, False]) crossover = Crossover(parents, crossover_probability=crossover_prob) offspring = crossover.perform_crossover() # perform mutation based on 50% probability mutation_prob = random.choice([True, False]) mutation = Mutation(offspring, mutation_probability=mutation_prob) final_offspring = mutation.mutate() # add offspring to next generation next_gen_population.append(final_offspring) # Score next gen population scored_next_gen_population = [] for chromosome in next_gen_population: fitness = Fitness(chromosome=chromosome, fitness_goal=fitness_goal) scored_next_gen_chromosome = fitness.calculate_fitness() scored_next_gen_population.append(scored_next_gen_chromosome) # Get generation best scored_next_gen_population.sort(key=lambda x: x[1]) last_index = scored_next_gen_population.__len__() - 1 best_of_generations.append(scored_next_gen_population[last_index])
class GeneticAlgorithm(object): def __init__(self, population_size, sample_genotype, crossover_rate=0.6, mutation_rate=0.2, maximize=True): self.population_size = population_size self.genotype = sample_genotype self.crossover_rate = crossover_rate self.mutation_rate = mutation_rate self.selector = RankSelector(maximize) self.crossover = OnePointCrossover() self.mutation = Mutation() self.generations = [] self.maximize = maximize def evolve(self, fitness_obj=FitnessFunction, num_generations=10): # initialize population population = [] for _ in range(self.population_size): chromosome = self.genotype.create_random_instance() population.append(chromosome) # process each generation for _ in range(num_generations): # track generations self.generations.append(population) next_population = [] # calculate fitness for population for chromosome in population: chromosome.fitness = fitness_obj.evaluate(chromosome) # select parents for generation parents = self.selector.select_pairs(population=population) # perform crossover for parent in parents: do_crossover = random.random() < self.crossover_rate if do_crossover: child_1, child_2 = self.crossover.recombine( parent[0].genes, parent[1].genes ) chrom_child_1 = Chromosome(genes=child_1) chrom_child_2 = Chromosome(genes=child_2) # add new children to next population next_population.append(chrom_child_1) next_population.append(chrom_child_2) else: # no crossover, add parents as is next_population.append(parent[0]) next_population.append(parent[1]) # do mutation do_mutation = random.random() < self.mutation_rate if do_mutation: next_population = self.mutation.mutate(self.genotype, next_population) population = next_population # calculate fitness for last generation for chromosome in population: chromosome.fitness = fitness_obj.evaluate(chromosome) return population def best_individual(self, population): population.sort(key=lambda x: x.fitness, reverse=self.maximize) best_individual = population[0] fittest = dict() for i in range(len(best_individual.genes)): fittest[self.genotype.get_label_at(i)] = best_individual.genes[i] return fittest
class GeneticAlgorithm(object): def __init__(self, population_size, sample_genotype, crossover_rate=0.6, mutation_rate=0.2, maximize=True): self.population_size = population_size self.genotype = sample_genotype self.crossover_rate = crossover_rate self.mutation_rate = mutation_rate self.selector = RankSelector(maximize) self.crossover = OnePointCrossover() self.mutation = Mutation() self.generations = [] self.maximize = maximize def evolve(self, fitness_obj=FitnessFunction, num_generations=10): # initialize population population = [] for _ in range(self.population_size): chromosome = self.genotype.create_random_instance() population.append(chromosome) # process each generation for _ in range(num_generations): # track generations self.generations.append(population) next_population = [] # calculate fitness for population for chromosome in population: chromosome.fitness = fitness_obj.evaluate(chromosome) # select parents for generation parents = self.selector.select_pairs(population=population) # perform crossover for parent in parents: do_crossover = random.random() < self.crossover_rate if do_crossover: child_1, child_2 = self.crossover.recombine( parent[0].genes, parent[1].genes) chrom_child_1 = Chromosome(genes=child_1) chrom_child_2 = Chromosome(genes=child_2) # add new children to next population next_population.append(chrom_child_1) next_population.append(chrom_child_2) else: # no crossover, add parents as is next_population.append(parent[0]) next_population.append(parent[1]) # do mutation do_mutation = random.random() < self.mutation_rate if do_mutation: next_population = self.mutation.mutate(self.genotype, next_population) population = next_population # calculate fitness for last generation for chromosome in population: chromosome.fitness = fitness_obj.evaluate(chromosome) return population def best_individual(self, population): population.sort(key=lambda x: x.fitness, reverse=self.maximize) best_individual = population[0] fittest = dict() for i in range(len(best_individual.genes)): fittest[self.genotype.get_label_at(i)] = best_individual.genes[i] return fittest
class Helix: def __init__(self, starthgt=11, endhgt=-9, spins=3.5, radius=1, speed=SPD_DEFAULT, spawn_rate=1, pair_generator=random_pair): self.starthgt = starthgt self.endhgt = endhgt self.spins = spins self.maxhgt = self.starthgt - (math.pi)*self.spins self.radius = radius self._animas = 0 self._rungs = [] self._tba = [] self.speed = speed self.spdmod = 1 self._last_rung = None self._last_ends = [] self.spawn_rate = spawn_rate self.pair_generator = pair_generator self.mutation = Mutation() self.enter_callback = None self.exit_callback = None self.in_box = [] def mutate(self, amt): self.mutation.mutate(amt) self.spdmod += amt * SPD_MUT_RATIO ### DO NOT USE def make_rung(self, next=None): rung = Rung(self, self.pair_generator()) if next: rung.next = next self._last_rung.prev = rung self._rungs.append(rung) self._last_ends = rung self._last_rung = rung def obscure(self): map(Rung.obscure, self._rungs) def unobscure(self): map(Rung.unobscure, self._rungs) def register_callbacks(self, enter_callback, exit_callback): self.enter_callback = enter_callback self.exit_callback = exit_callback def update(self, dt): ## update the mutation self.mutation.update(dt) ## check to see if the last rung is far enough away for a new one if self._last_rung: if self._last_rung._hgt <= self.starthgt - self.spawn_rate: self.make_rung(self._last_rung) else: self.make_rung() ## compute the speed with mod -1.12 -> -1.3 speed = self.speed*self.spdmod #print "speed", speed ## update the mutation self.mutation.update(dt) ## check to see if the last rung is far enough away for a new one if self._last_rung: if self._last_rung._hgt <= self.starthgt - self.spawn_rate: self.make_rung(self._last_rung) else: self.make_rung() self.spdmod = max(self.spdmod - dt*SPD_DECAY, 1) ## compute the speed with mod -1.12 -> -1.3 speed = self.speed*self.spdmod for r in self._rungs: if r._hgt < -1.12 and r._hgt > -1.3: if not r.in_box: r.in_box=True if self.enter_callback: self.enter_callback(r) if r.in_box and r._hgt < -1.3: r.in_box = False if self.exit_callback: self.exit_callback(r) r.update(dt, speed) ## update and kill the rungs that have it coming :P dead = [] for entity in self._rungs: if entity.dead: dead.append(entity) for e in dead: self._rungs.remove(e)