def crossover(self, parent_1, parent_2): children = [] # 1-point crossover max_string = len(parent_1.chrom_a) pcross_a = random.randint(0, max_string) pcross_b = random.randint(0, max_string) # Chromosomes for child 1 chrom_1a = parent_1.chrom_a[:pcross_a] + parent_2.chrom_a[pcross_a:] chrom_1b = parent_1.chrom_b[:pcross_b] + parent_2.chrom_b[pcross_b:] chrom_2a = parent_2.chrom_a[:pcross_a] + parent_1.chrom_a[pcross_a:] chrom_2b = parent_2.chrom_b[:pcross_b] + parent_1.chrom_b[pcross_b:] child_1 = ind.Individual(chrom_1a, chrom_1b) child_2 = ind.Individual(chrom_2a, chrom_2b) child_1.mutate() child_2.mutate() children.append(child_1) children.append(child_2) return children
def crossover(self, ratio): # crossover_point = np.random.randint(50, 100) crossover_point = ratio % self.amount new = self.amount // 10 son = individual.Individual(self.start) son.gene_phi = self.pops.individuals[0].gene_phi.copy( )[:crossover_point] + self.pops.individuals[1].gene_phi.copy( )[crossover_point:] daughter = individual.Individual(self.start) daughter.genes = self.pops.individuals[1].gene_phi.copy( )[:crossover_point] + self.pops.individuals[0].gene_phi.copy( )[crossover_point:] self.pops.individuals.append(son) self.pops.individuals.append(daughter) for i in range((self.amount - self.survival) - new - 2): pos_dad = np.random.randint(0, self.survival) pos_mom = np.random.randint(0, self.survival) offspring = individual.Individual(self.start) offspring.gene_phi = self.pops.individuals[pos_dad].gene_phi.copy( )[:crossover_point] + self.pops.individuals[pos_mom].gene_phi.copy( )[crossover_point:] self.pops.individuals.append(offspring)
def test_domination(self): g = genotype.Genotype(data_manager.dm.city_ids) i1 = individual.Individual(g) i2 = individual.Individual(g) i1.tour_distance = 500 i2.tour_distance = 450 i1.calculate_tour_cost = 40 i2.calculate_tour_cost = 35 self.assertTrue(i2.dominates(i1)) self.assertFalse(i1.dominates(i2))
def test_crossover_has_all_cities(self): g_1 = genotype.Genotype.get_random_genotype() parent_1 = individual.Individual(g_1) g_2 = genotype.Genotype.get_random_genotype() parent_2 = individual.Individual(g_2) new_g = parent_1.genotype.crossover(parent_2.genotype) print new_g for i in range(len(new_g)): print i self.assertTrue(i in new_g)
def Crossover(self, parent1, parent2): childList = [] a = r.randint(0, self.pop_dimension) gen_child1 = parent1.chromosome[:a] gen_child1.extend(parent2.chromosome[a:]) gen_child2 = parent2.chromosome[:a] gen_child2.extend(parent1.chromosome[a:]) child1 = idv.Individual(gen_child1, len(self.listTask)) child2 = idv.Individual(gen_child2, len(self.listTask)) # phân vân giữa chọn hay không chọn các yếu tố childList.append(child1) childList.append(child2) return childList
def test_calculate_all_crowding_distances_edge_case(self): g1 = genotype.Genotype.get_random_genotype() i1 = individual.Individual(g1) i2 = individual.Individual(g1.clone()) i3 = individual.Individual(g1.clone()) p = population.Population(population_size=2, crossover_rate=0.5, mutation_rate=0.5, individuals=[i1, i2, i3]) fronts = p.fast_non_dominated_sort() for rank in fronts: front = fronts[rank] population.Population.calculate_all_crowding_distances(front)
def crossOver(self, a, b): children = [] factorial_rank = [] for i in range(len(self.tasks)): factorial_rank.append(self.population.nIndi + 1) child_a = [] child_b = [] t = r.randint(0, len(a.chromosome)) child_a.extend(a.chromosome[0:t]) child_b.extend(b.chromosome[0:t]) for gen in a.chromosome: if gen not in child_b: child_b.append(gen) for gen in b.chromosome: if gen not in child_a: child_a.append(gen) ind_a = indi.Individual(child_a, []) if r.random() > 0.5: ind_a.skillFactor = a.skillFactor else: ind_a.skillFactor = b.skillFactor fitnessTa = [0 for x in range(len(self.tasks))] for i in range(len(self.tasks)): if i != ind_a.skillFactor: fitnessTa[i] = 100000000 else: fitnessTa[i] = self.tasks[i].computeFitness(ind_a.chromosome) ind_a.fitnessTask = fitnessTa ind_a.factorialRank = factorial_rank children.append(ind_a) ind_b = indi.Individual(child_b, []) if r.random() > 0.5: ind_b.skillFactor = a.skillFactor else: ind_b.skillFactor = b.skillFactor fitnessTa = [0 for x in range(len(self.tasks))] for i in range(len(self.tasks)): if i != ind_b.skillFactor: fitnessTa[i] = 100000000 else: fitnessTa[i] = self.tasks[i].computeFitness(ind_b.chromosome) ind_b.fitnessTask = fitnessTa ind_b.factorialRank = factorial_rank children.append(ind_b) return children
def test_crossover_no_double_elements(self): g_1 = genotype.Genotype.get_random_genotype() parent_1 = individual.Individual(g_1) g_2 = genotype.Genotype.get_random_genotype() parent_2 = individual.Individual(g_2) new_g = parent_1.genotype.crossover(parent_2.genotype) for i in range(len(new_g)): count = 0 for j in range(len(new_g)): if j != i and new_g[j] == new_g[i]: if new_g[j] is not None: count += 1 self.assertTrue(count == 0)
def main(): result_list = np.zeros(cf.get_iteration()) for trial in range(cf.get_trial()): np.random.seed(trial) pos_list = [] v_list = [] pbest_list = [] gbest = None """Generate Initial Population""" gbest = id.Individual() for p in range(cf.get_population_size()): pbest_list.append(id.Individual()) pos_list.append(id.Individual()) v_list.append(id.Individual()) """ Main Loop """ for iteration in range(cf.get_iteration()): """ Update Partical position """ for i in range(cf.get_population_size()): # move to new position v_list[i].get_velocity(pos_list[i], pbest_list[i], gbest) pos_list[i].get_newPos(v_list[i]) # update fitness fitness = fn.calculation(pos_list[i].get_position(), 0) pos_list[i].set_fitness(fitness) # update pbest & gbest if pos_list[i].get_fitness() < pbest_list[i].get_fitness(): pbest_list[i].set_position(pos_list[i].get_position()) pbest_list[i].set_fitness(pos_list[i].get_fitness()) if pos_list[i].get_fitness() < gbest.get_fitness(): gbest.set_position(pos_list[i].get_position()) gbest.set_fitness(pos_list[i].get_fitness()) # print([x.get_fitness() for x in pbest_list]) # print(gbest.get_fitness()) # sys.stdout.write("\r Trial:%3d , Iteration:%7d, BestFitness:%.10f" % (trial , iteration, gbest.get_fitness())) result_list[iteration] += gbest.get_fitness() """ export avg result""" result_list /= cf.get_trial() for iteration in range(cf.get_iteration()): result.write('{} {}\n'.format(iteration, result_list[iteration]))
def get_highest_fitness(fed_population): highest = individual.Individual() for ind in fed_population: if ind.fitness > highest.fitness: highest = ind return highest.fitness
def crossoverPopulation(self, pop): # Create new population newpop = population.Population(pop.size()) # Loop over current population by fitness for popIndex in range(pop.size()): parent1 = pop.getFittest(popIndex) # Apply crossover to this individual? if self.crossoverRate > random.random( ): # and popIndex >= self.elitismCount: # Initialize offspring offspring = individual.Individual( parent1.getChromosomeLength()) # Find second parent parent2 = self.selectParent(pop) # Loop over genome for geneIndex in range(parent1.getChromosomeLength()): # Use half of parent1's genes and half of parent2's genes if 0.5 > random.random(): offspring.setGene(geneIndex, parent1.getGene(geneIndex)) else: offspring.setGene(geneIndex, parent2.getGene(geneIndex)) # Add offspring to new population newpop.setIndividual(popIndex, offspring) else: # Add individual to new population without applying crossover newpop.setIndividual(popIndex, parent1) return newpop
def __init__(self, population_size, elitism=True, elitismFraction=0.10, deathFraction=0.10, mutationProb=0.001): self.population_size = population_size self.elitism = elitism self.mutationProb = mutationProb self.elistismFraction = elitismFraction self.infantMortality = deathFraction file = open("boxes.txt") fileinput = file.readlines() file.close() rawboxes = [] for index in range(len(fileinput)): rawboxes.append(fileinput[index].replace("\n", "").split("\t")) for index2 in range(len(rawboxes[index])): rawboxes[index][index2] = int(rawboxes[index][index2]) objectBoxes = [] for item in rawboxes: placing_box = box.Box(item[0], item[1], item[2], item[3], item[4]) objectBoxes.append(placing_box) self.population = [] for iteration in range(self.population_size): self.population.append(individual.Individual( "random", objectBoxes))
def test_crossover_distinct_count(self): g_1 = genotype.Genotype.get_random_genotype() parent_1 = individual.Individual(g_1) g_2 = genotype.Genotype.get_random_genotype() parent_2 = individual.Individual(g_2) new_g = parent_1.genotype.crossover(parent_2.genotype) key_map = {} for i in range(len(new_g)): if new_g[i] not in key_map: key_map[new_g[i]] = 1 else: key_map[new_g[i]] += 1 for k, v in key_map.iteritems(): self.assertTrue(v == 1)
def __init__(self, n, t): self.population = n #群中の個体数 self.individual_array = [] #個体を入れる配列 for i in range(n): #各個体の挿入 self.individual_array.append(individual.Individual(dim, t)) self.individual_array.sort(key=operator.attrgetter('fitness')) self.best_fitness = self.individual_array[0].fitness #群の中の最大評価値 self.best_fitness_position = self.individual_array[0].position
def selection(population): offspring = [] while len(offspring) < individual.population_number: new_offspring = individual.Individual() winner = tournament_selection(population) for gene in winner.genes: new_offspring.genes.append(gene) offspring.append(new_offspring) return offspring
def main(): for trial in range(cf.get_trial()): np.random.seed(trial) results_list = [] # fitness list de_list = [] """Generate Initial Population""" for p in range(cf.get_population_size()): de_list.append(id.Individual()) """Sort Array""" de_list = sorted(de_list, key=lambda ID: ID.get_fitness()) """Find Initial Best""" BestPosition = de_list[0].get_position() # Best Solution BestFitness = fn.calculation(BestPosition, 0) """↓↓↓Main Loop↓↓↓""" for iteration in range(cf.get_iteration()): """list copy""" candidate_de_list = copy.deepcopy(de_list) """Generate New Solutions""" for i in range(len(de_list)): candidate = copy.deepcopy(de_list[i]) """select three points (a, b, c)""" a = np.random.randint(0, cf.get_population_size()) while (a == i): a = np.random.randint(0, cf.get_population_size()) b = np.random.randint(0, cf.get_population_size()) while (b == i or a == b): b = np.random.randint(0, cf.get_population_size()) c = np.random.randint(0, cf.get_population_size()) while (c == i or c == a or c == b): c = np.random.randint(0, cf.get_population_size()) """Select Random Index (R)""" R = np.random.randint(0, cf.get_dimension()) candidate.generate(a=de_list[a], b=de_list[b], c=de_list[c], R=R) candidate.set_fitness( fn.calculation(candidate.get_position(), iteration)) if candidate.get_fitness() < de_list[i].get_fitness(): candidate_de_list[i] = copy.deepcopy(candidate) """Sort Array""" de_list = sorted(candidate_de_list, key=lambda ID: ID.get_fitness()) """Rank and Find the Current Best""" if de_list[0].get_fitness() < BestFitness: BestPosition = de_list[0].get_position() BestFitness = fn.calculation(BestPosition, iteration) sys.stdout.write("\r Trial:%3d , Iteration:%7d, BestFitness:%.4f" % (trial, iteration, BestFitness)) results_list.append(str(BestFitness)) results_writer.writerow(results_list)
def __init__(self, populationSize, initialise): self.individuals = [None] * populationSize self.__populationSize = populationSize if initialise: for i in range(self.size()): newIndividual = individual.Individual() newIndividual.generateIndividual() self.saveIndividual(i, newIndividual)
def initpop(): a = [] for i in range(Config.get_population_num()): tmp = [ np.random.randint(50, 200), np.random.randint(1, 50), np.random.randint(50, 200) ] a.append(individual.Individual(tmp)) return a
def main(): result_list = np.zeros(cf.get_iteration()) for trial in range(cf.get_trial()): # np.random.seed(trial) np.random.seed() cs_list = [] """Generate Initial Population""" for p in range(cf.get_population_size()): cs_list.append(id.Individual()) """Sort List""" cs_list = sorted(cs_list, key=lambda ID: ID.get_fitness()) """Find Initial Best""" BestPosition = cs_list[0].get_position() BestFitness = fn.calculation(cs_list[0].get_position(), 0) """↓↓↓Main Loop↓↓↓""" for iteration in range(cf.get_iteration()): """Generate New Solutions""" for i in range(len(cs_list)): cs_list[i].get_cuckoo_dynamic_adaptive(iteration) cs_list[i].set_fitness( fn.calculation(cs_list[i].get_position(), iteration)) """random choice (say j)""" j = np.random.randint(low=0, high=cf.get_population_size()) while j == i: #random id[say j] ≠ i j = np.random.randint(0, cf.get_population_size()) # for minimize problem if (cs_list[i].get_fitness() < cs_list[j].get_fitness()): cs_list[j].set_position(cs_list[i].get_position()) cs_list[j].set_fitness(cs_list[i].get_fitness()) """Sort (to Keep Best)""" cs_list = sorted(cs_list, key=lambda ID: ID.get_fitness()) """Abandon Solutions (exclude the best)""" for a in range(1, len(cs_list)): r = np.random.rand() if (r < cf.get_Pa()): cs_list[a].abandon_dynamic(iteration) cs_list[a].set_fitness( fn.calculation(cs_list[a].get_position(), iteration)) """Sort to Find the Best""" cs_list = sorted(cs_list, key=lambda ID: ID.get_fitness()) if cs_list[0].get_fitness() < BestFitness: BestFitness = cs_list[0].get_fitness() BestPosition = cs_list[0].get_position() sys.stdout.write( "\r Trial:%3d , Iteration:%7d, BestFitness:%.10f" % (trial, iteration, BestFitness)) result_list[iteration] += BestFitness """ export avg result""" result_list /= cf.get_trial() for iteration in range(cf.get_iteration()): result.write('{} {}\n'.format(iteration, result_list[iteration]))
def newPopulation(offspring, ori_data, m, shape, ori_full_table, obj, weight, size): candidates = [] for syn_data in offspring: candidates.append( individual.Individual(syn_data, ori_data, m, shape, ori_full_table, obj, weight)) new_population = population.Population(ori_data, size, candidates) new_population.populationFitness() return new_population
def crossover(self, parent1, parent2, to): ran = rd.randint(1, 100) childChromosome = [] childChromosome.extend(parent1.chromosome[:ran]) childChromosome.extend(parent2.chromosome[ran:]) sum_gen = 0 for i in childChromosome: sum_gen += i x = [gen / sum_gen for gen in childChromosome] child = indi.Individual(x, self.bestWay, to) return child
def init_pop( self, set_of_city): #set of city là tập các thành phố có thể làm gen for i in range(self.nIndividual): set_of_gens = r.sample(set_of_city, self.pop_dimension) indi = idv.Individual(set_of_gens, self.nTask) a = [] for j in self.listTask: a.append(j.fitness(indi)) indi.setFactorialCost(a) self.pop.append(indi)
def crossover(individual1, individual2): newSol = individual.Individual() for i in range(individual1.size()): if random.random() <= Algorithm._uniformRate: newSol.setGene(i, individual1.getGene(i)) else: newSol.setGene(i, individual2.getGene(i)) return newSol
def mutation(self, parent, to): ran = rd.randint(1, 99) ranVal = rd.random() childChromosome = [] childChromosome.extend(parent.chromosome) childChromosome[ran] = ranVal sum_gen = 0 for i in childChromosome: sum_gen += i x = [gen / sum_gen for gen in childChromosome] child = indi.Individual(x, self.bestWay, to) return child
def initialise(lambda_, h): logging.debug('Initialise population with lambda=%s, h=%s', lambda_, h) population = np.empty(lambda_, dtype=object) for i in range(lambda_): logging.debug('Individual %s', i) population[i] = individual.Individual(_random_strategy(h)) logging.debug('Generated pop:\n%s\n', population) assert population.size == lambda_ return population
def main(): for trial in range(cf.get_trial()): np.random.seed(trial) results_list = [] # fitness list cs_list = [] """Generate Initial Population""" for p in range(cf.get_population_size()): cs_list.append(id.Individual()) """Sort List""" cs_list = sorted(cs_list, key=lambda ID: ID.get_fitness()) """Find Initial Best""" BestPosition = cs_list[0].get_position() BestFitness = fn.calculation(cs_list[0].get_position(), 0) """↓↓↓Main Loop↓↓↓""" for iteration in range(cf.get_iteration()): """Generate New Solutions""" for i in range(len(cs_list)): cs_list[i].get_cuckoo() cs_list[i].set_fitness( fn.calculation(cs_list[i].get_position(), iteration)) """random choice (say j)""" j = np.random.randint(low=0, high=cf.get_population_size()) while j == i: # random id[say j] ≠ i j = np.random.randint(0, cf.get_population_size()) # for minimize problem if cs_list[i].get_fitness() < cs_list[j].get_fitness(): cs_list[j].set_position(cs_list[i].get_position()) cs_list[j].set_fitness(cs_list[i].get_fitness()) """Sort (to Keep Best)""" cs_list = sorted(cs_list, key=lambda ID: ID.get_fitness()) """Abandon Solutions (exclude the best)""" for a in range(1, len(cs_list)): r = np.random.rand() if r < cf.get_Pa(): cs_list[a].abandon() cs_list[a].set_fitness( fn.calculation(cs_list[a].get_position(), iteration)) """Sort to Find the Best""" cs_list = sorted(cs_list, key=lambda ID: ID.get_fitness()) if cs_list[0].get_fitness() < BestFitness: BestFitness = cs_list[0].get_fitness() BestPosition = cs_list[0].get_position() sys.stdout.write("\r Trial:%3d , Iteration:%7d, BestFitness:%.4f" % (trial, iteration, BestFitness)) results_list.append(str(BestFitness)) results_writer.writerow(results_list)
def initial(self): individuals=[] for i in range(self.nIndi): new_chromosome=[r.random() for i in range(self.lenGen)] new_indi=indiv.Individual(new_chromosome,[]) fitnessTa=[] for task in self.tasks: fitnessTa.append(task.computeFitness(new_indi)) new_indi.fitnessTask=fitnessTa individuals.append(new_indi) self.individuals=individuals self.updateRankPopulation()
def test_fitness(self): drums = sound_file.SoundFile('drums.wav') synth = sound_file.SoundFile('synth.wav') ind1 = individual.Individual(genotype=None, neural_mode=None, effect=None) ind1.set_output_sound(drums) ind2 = individual.Individual(genotype=None, neural_mode=None, effect=None) ind2.set_output_sound(synth) # make sure sound files are analyzed project.Project([ind1.output_sound, ind2.output_sound]) # mock ind1.set_fitness = lambda x: None ind2.set_fitness = lambda x: None fitness_evaluator = fitness.LocalSimilarityFitness(target_sound=drums) fitness_evaluator.evaluate_multiple([ind1, ind2])
def initial(self, set_of_city): individuals = [] for i in range(self.nIndi): new_chromosome = r.sample(set_of_city, self.lenGen) fitnessTa = [] for task in self.tasks: fitnessTa.append(task.computeFitness(new_chromosome)) new_indi = indiv.Individual(new_chromosome, fitnessTa) individuals.append(new_indi) self.individuals = individuals self.updateRankPopulation()
def gen_population(size=POP_SIZE): half_size = int(size / 2) population = [] #Gen first half: GROW method for i in range(0, half_size): new_ind = individual.Individual(max_depth=INDIVIDUAL_MAX_DEPTH, min_depth=INDIVIDUAL_MIN_DEPTH, size_vars=NUM_VARS) population.append(new_ind) if size % 2 != 0: half_size += 1 #Gen second half: FULL method for i in range(0, half_size): new_ind = individual.Individual(max_depth=INDIVIDUAL_MAX_DEPTH, size_vars=NUM_VARS, full=True) population.append(new_ind) return population