def tournament_with_mutation(competitors): choosen = competitors[0] for i in range(1, len(competitors)): if Individual.compare(choosen, competitors[i]) == -1: choosen = competitors[i] ''' Se hacen copias temporales para reemplazar luego a los perdedores del torneo ''' winner = choosen.clone() ''' Se realizan la macro y micro mutación según probabilidades ''' try: if Util.random_flip_coin(Parameters.p_macro_mutation): winner = macro_mutation(winner) Individual.check_destination_register(winner) if not check_out_register(winner): print "La macro mató" except: print "La macro matOOOó" try: if Util.random_flip_coin(Parameters.p_micro_mutation): winner = micro_mutation(winner) Individual.check_destination_register(winner) if not check_out_register(winner): print "La miiicro mató" except: print "La miiicro mató" return list([winner, choosen])
def evolve(self, goal): for child in self.individuals: parent1 = FC.getFittest(self.selectForBreeding(), goal, self.fitnessCalc) parent2 = FC.getFittest(self.selectForBreeding(), goal, self.fitnessCalc) if (parent1 is not parent2): Individual.breed2(parent1, parent2, child) self.mutate()
def run_family1(self): self.setup2() # 3.1 Test family #1 family1 = FamilyTree() family1.set_family_name('The Incredibles') family1.add_individual(self.girl) family1.add_individual(self.boy) family1.add_individual(self.mom) family1.add_individual(self.dad) family1.add_individual( Individual(first='Jack-Jack', last='Parr', gender='male', dob='2005-09-10')) self.boy2 = family1.individual('Jack-Jack') if self.boy2: # this is false is boy2==tuple(), true if boy2 contains Individual objects self.boy2[0].add_parent(self.mom) self.boy2[0].add_parent(self.dad) print(family1) family1.tree_print()
def initPopulation(self): """ Creating random individuals in the population """ for i in range(0, self.popSize): individual = Individual(self.genSize, self.data) individual.computeFitness() self.population.append(individual) # print("Parent{}:{}\nFitness:{}\n".format(i+1,individual.genes[:],individual.fitness)) self.best = self.population[0].copy() for ind_i in self.population: if self.best.getFitness() > ind_i.getFitness(): self.best = ind_i.copy() print("Best initial sol: ", self.best.getFitness())
def apply(self, anEA): self.use_count += 1 # Select the parents from the population parent1_index = parent2_index = anEA.selection_operator.select( anEA.current_solution_set) # Make sure parent 1 is different from parent2 i = 0 while parent2_index == parent1_index and i < 10: parent2_index = anEA.selection_operator.select( anEA.current_solution_set) i += 1 # Perform the crossover child_gene = [] for p1_gene, p2_gene in zip( anEA.current_solution_set[parent1_index].parameter_set, anEA.current_solution_set[parent2_index].parameter_set): alpha = self.system_random.uniform(0.0, 1.0) child_gene.append(alpha * p1_gene + (1.0 - alpha) * p2_gene) child = IND.Individual( anEA.current_solution_set[parent1_index].objective_function, child_gene) # Mutate the child if self.mutation_operator != None: self.mutation_operator.mutate(child) return child
def initPopulation(self): """ Creating random individuals in the population """ for i in range(0, self.popSize): individual = Individual( self.genSize, self.data, self.choice ) # Passing choice as paramter to choose between Random/Heurostic individual.computeFitness() self.population.append(individual) self.best = self.population[0].copy() for ind_i in self.population: if self.best.getFitness() > ind_i.getFitness(): self.best = ind_i.copy() print("Best initial sol: ", self.best.getFitness())
def run_with_crossover(self, number_of_generation, mut_probs, mut_bp, nbjobs): #tuple of all parallel python servers to connect with ppservers = () job_server = pp.Server(nbjobs, ppservers=ppservers) tasks = range(nbjobs) result = numpy.array([Individual.Individual("", "", 0, 0)]) #Parallel evolution for every lamda value print "Start running jog" jobs = [(task, job_server.submit(self.EA_with_crossover, ( number_of_generation, mut_probs, task, mut_bp, ), ( self.fitness_proportion_selection, self.mutateAll, self.mutateOne, self.crossover, ), ("numpy", "Individual", "RNA", "random", "Logger", "pandas", "os", "Initializer", "Landscape"))) for task in tasks] for task, job in jobs: gen = job() result = numpy.insert(result, 0, numpy.array(gen)[:10]) print "End of jobs" return result
def initPopulation(self): """ Creating random individuals in the population """ for i in range(0, self.popSize): individual = Individual(self.genSize, self.data) individual.computeFitness() print("fitness>>",individual.fitness) print("chromosome>>",individual.genes) self.population.append(individual) self.best = self.population[0].copy() #print("best>", self.best.__dict__) for ind_i in self.population: if self.best.getFitness() > ind_i.getFitness(): self.best = ind_i.copy()
def mutateOne(self, individual, mut_p, mut_bp): base_paire = ["AU", "UA", "GU", "GC", "UG", "CG"] nucluotides = ["A", "G", "U", "C"] RNA_seq = [] for i in range(len(individual.RNA_seq)): r = random.uniform(0, 1) if r < mut_p[i]: selct = numpy.random.choice(nucluotides, size=1) RNA_seq.append(selct[0]) else: RNA_seq.append(individual.RNA_seq[i]) pos = individual.get_bp_position(self.initializer.target_structure) for bp_cord in pos: r = random.uniform(0, 1) if r < mut_bp: bp = numpy.random.choice(base_paire, 1, p=[0.1, 0.2, 0.2, 0.2, 0.2, 0.1]) RNA_seq[bp_cord[0]] = bp[0][0] RNA_seq[bp_cord[1]] = bp[0][1] (RNA_strc, mef) = RNA.fold(''.join(RNA_seq)) return Individual.Individual(''.join(RNA_seq), RNA_strc, self.fitness(RNA_strc), mef)
def apply(self, anEA): self.use_count += 1; # Select the parents from the population parent1_index = parent2_index = anEA.selection_operator.select(anEA.current_solution_set) # Make sure parent 1 is different from parent2 while parent2_index == parent1_index: parent2_index = anEA.selection_operator.select(anEA.current_solution_set); # Perform the crossover child_gene = []; for p1_gene, p2_gene in zip(anEA.current_solution_set[parent1_index].genes, anEA.current_solution_set[parent2_index].genes): alpha = self.system_random.uniform(0.0, 1.0); child_gene.append(alpha * p1_gene + (1.0 - alpha) * p2_gene); child = IND.Individual( len(child_gene), anEA.current_solution_set[parent1_index].boundary_set, anEA.current_solution_set[parent1_index].fitness_function, child_gene ); # Mutate the child if self.mutation_operator != None: self.mutation_operator.mutate(child) return child;
def __init__(self, populationSize): """ Population constructor """ self.population = [] for i in range(populationSize): self.population.append(Individual())
def apply(self, anEA): self.use_count += 1 # Return a new individual whose genes are randomly # generated using a uniform distribution return (IND.Individual(anEA.objective_function, anEA.objective_function.initialRandomGuess()))
def calc_obj_value(pop): obj_value = [] for individual in pop: solution = IDV.individual_to_solution(individual) X = solution[0] Y = solution[1] obj_value.append(lsq.calc_area(Y, X)) return obj_value
def best_training(self): best = self.internal_pop[0] for i in range(1, self.pop_size): if (Individual.compare(self.internal_pop[i], best) == 1): best = self.internal_pop[i] return best
def getIndividuals(population_size, log_file): population = [] dataFrame = pandas.read_csv(log_file, sep=",") for ind in (dataFrame.values)[:population_size + 1, 1:]: population.append(Individual.Individual(ind[0], ind[1], ind[3], ind[2])) return population
def apply(self, anEA): self.use_count += 1 # Return a new individual whose genes are randomly # generated using a uniform distribution return (IND.Individual(anEA.objective_function.number_of_dimensions, anEA.objective_function.boundary_set, anEA.objective_function))
def main(): numberOfFolds = 10 numberOfOutputRegisters = 2 ArithmeticRegisterRatio = 0.5 ps = 1000 # population size ips = 20 # initial population length op = ['add', 'sub', 'mul', 'div', 'if'] # avaliable operations ts = 1000 # tournament size ft = 'acc' # fitness type pc = 0.5 #crossover probability pm = 0.2 #mutation probability ng = 6000 #number of generation dm = ['max', 'ave', 'min'] # ---- Process ---- df = pd.read_csv('spambase.csv') data_feature = df.iloc[:, :len(df.columns) - 1] data_label = df.iloc[:, len(df.columns) - 1] # ---- split train ---- foldSize = int(len(data_label) / numberOfFolds) selector = [False] * foldSize selector = selector + [True] * (len(data_label) - foldSize) random.shuffle(selector) data_feature_test = data_feature[selector] data_label_test = data_label[selector] data_feature_train = data_feature[[not i for i in selector]] data_label_train = data_label[[not i for i in selector]] # ---- preperation ---- r_out = ['R_O_' + str(i) for i in range(numberOfOutputRegisters)] r_fea = ['R_F_' + str(i) for i in range(len(data_feature.columns))] r_ari = [ 'R_A_' + str(i) for i in range(int(len(r_fea) * ArithmeticRegisterRatio)) ] # ---- call algorithm ---- opt_program = Algorithms.AlgTwoPointOne(PopulationSize=ps, InitialProgramLength=ips, Reg_output=r_out, Reg_arit=r_ari, Reg_feat=r_fea, operations=op, TournamentSize=ts, fitnessType=ft, numOfGenerations=ng, Prob_cross=pc, Prob_mutation=pm, dtf=data_feature_train, dtl=data_label_train, dvf=data_feature_test, dvl=data_label_test, resultDisplay=dm) print(id.printProgram(opt_program))
def crossover(self, genotype1, genotype2, number_of_bit=1): vect1 = map(str, genotype1.RNA_seq) vect2 = map(str, genotype2.RNA_seq) r = numpy.random.randint(0, len(vect1)) swap = vect1[:r] vect1[:r] = vect2[:r] vect2[:r] = swap (child1_structure, mef_child1) = RNA.fold(''.join(vect1)) (child2_structure, mef_child2) = RNA.fold(''.join(vect2)) child1 = Individual.Individual( ''.join(vect1), child1_structure, self.landscape.fitness(child1_structure), mef_child1) child2 = Individual.Individual( ''.join(vect2), child2_structure, self.landscape.fitness(child2_structure), mef_child2) return child1, child2
def initPop(self): for i in range(self.popSize): newInd = Individual.Individual(self.networkStructure, self.classification) newInd.setFitness(self.trainSet, self.trainClass) # find best fit if newInd.fitness > self.bestIndivdiualFitness: self.bestIndivdiual = copy.deepcopy(newInd) self.bestIndivdiualFitness = newInd.fitness # add individual to population self.population.append(newInd)
def setup_matrix_and_initialize_positions_of_individuals(self, matrix, free_space_size): self.matrix = matrix self.free_space_size = free_space_size self.individuals = [] for _ in range(int(NUMBER_OF_INDIVIDUALS)): matrix = (copy.deepcopy(self.matrix)) self.individuals.append(Individual.Individual(matrix, self.free_space_size)) for individual in self.individuals: individual.initialize_cargo_list_with_random_positions(warehouse.CARGO_LIST)
def generation_change(self, Bear_N, Kill_N): DNAs, parents_address = self.Bear(Bear_N) empty_address = self.Kill(Kill_N) born_space = self.manhattan_squeeze(parents_address, empty_address) Avg, Std = self.Get_Wealth_Statistics() self.Agent_List.extend([ Individual.Individual(born_space[i], DNAs[i], Avg, Std) for i in range(Bear_N) ]) """
def Reset(self, name, mapside, Avg, Std): self.Name = name self.Size = mapside**2 #self.ID_Map = [[x + x*y for x in range(mapside)] for y in range(mapside)] # 看怎麼定義比較好,目前是用二維的,裡面放每個Individual的ID #self.Agent_List = [Individual.Individual(i, random.gauss(Avg, Std)) for i in range(self.Size)] # 第n格表示ID為n的Individual self.Agent_List = [ Individual.Individual([i // mapside, i % mapside], random.gauss(Avg, Std)) for i in range(self.Size) ]
def resetPopulation(self, aParameterSet): self.current_solution_set = []; for i in range(int(len(aParameterSet) / self.objective_function.number_of_dimensions)): gene_set = []; for j in range(self.objective_function.number_of_dimensions): gene_set.append(aParameterSet[i * self.objective_function.number_of_dimensions + j]); self.current_solution_set.append(IND.Individual(self.objective_function, gene_set)); self.evaluateGlobalFitness(True);
def __init__(self, size, length): """ count: the number of individuals in the population length: the number of values per individual vmin: the minimum possible value vmax: the maximum possible value """ self.__size = size self.__pop = [ Individual(Problem.generateIndividual(length)) for x in range(size) ]
def __init__(self): self.individuals = [] for i in range(PopulationSize): self.individuals.append(Individual()) self.tempIndividuals = [] self.solitaryIndexList = list(range(PopulationSize)) self.pairedIndexList = [] self._nbOfSolitaryIndividuals = PopulationSize self._nbOfPairedIndividuals = 0 self._nbOfEncounters = 0 self._nbOfInteractions = 0 self._rateOfAcceptation = 0
def initPopulation(self): """ Creating random/heuristic individuals in the population self.initialSolution == 0 implies the initial population is generated using Random selection Approach self.initialSolution == 1 implies the initial population is generated using Heuristic Approach """ for i in range(0, self.popSize): individual = Individual(self.genSize, self.data, self.initialSolution) individual.computeFitness() self.population.append(individual) self.best = self.population[0].copy() for ind_i in self.population: if self.best.getFitness() > ind_i.getFitness(): self.best = ind_i.copy() print("Best initial sol: ", self.best.getFitness()) # Writing the details into a file. file.write(f'Best initial sol: {self.best.getFitness()}') file.write('\n')
def initialize(self): """ randomly generate NP individuals with value ranges xMin xMax """ pop = list() for i in range(self.NP): pop.append( Individual( np.random.rand(self.xMin.size) * (self.xMax - self.xMin) + self.xMin, self.problem)) if not all([Problem.validate(individual) for individual in pop]): raise ValueError("No valid initialization of population!") return pop
def crossOver2(ref_strc, ind1, ind2, cross_prob): child1 = [] child2 = [] for i in range(len(ind1.RNA_seq)): child1.append(ind1.RNA_seq[i]) child2.append(ind2.RNA_seq[i]) if random.uniform(0, 1) < cross_prob: single_point = random.randint(1, len(ind1.RNA_seq) - 1) cross_part = child1[single_point:] child1[single_point:] = child2[single_point:] child2[single_point:] = cross_part (child1_strc, child1_mef) = RNA.fold(''.join(child1)) (child2_strc, child2_mef) = RNA.fold(''.join(child2)) new_ind1 = Individual(''.join(child1), child1_strc, RNAEvolution.fitness(ref_strc, child1_strc)) new_ind2 = Individual(''.join(child2), child2_strc, RNAEvolution.fitness(ref_strc, child2_strc)) return new_ind1, new_ind2
def introduce_new_individuals(self): for i in range(0, int(NUMBER_OF_INDIVIDUALS/2)): k = int(NUMBER_OF_INDIVIDUALS/2) + i self.individuals[k] = Individual.Individual(copy.copy(self.matrix), self.free_space_size) # znajdzmy matke i ojca dla osobnika father_index = random.randrange(0, 50, 1) mother_index = random.randrange(0, 50, 1) while father_index == mother_index: mother_index = random.randrange(0, 50, 1) self.cross_mother_and_father(self.individuals[father_index], self.individuals[mother_index], self.individuals[k]) self.individuals[k].calculate_coverage() self.mutate()
def best_validation(self): ''' Se establece el atributo validation error de los individuos de la población ''' for i in self.internal_pop: i.eval_validation() best = self.internal_pop[0] ''' Se busca el de menor error ''' for i in range(1, self.pop_size): if (Individual.compare_validation_error(self.internal_pop[i], best) == -1): best = self.internal_pop[i] return best
def mitosis(self, aMutationOperator, anUpdateIndividualLocalFitnessFlag): # Duplicate the population for i in range(self.getNumberOfIndividuals()): self.current_solution_set.append(aMutationOperator.mutate(IND.Individual(self.objective_function, self.current_solution_set[i].parameter_set))); self.number_created_children += 1; # Update the global and local fitness values if self.global_fitness_function != 0 and self.global_fitness_function != None: # Evaluate the global fitness self.evaluateGlobalFitness(anUpdateIndividualLocalFitnessFlag); # Store the best individual else: self.saveBestIndividual();
def __init__(self, limits, size, eliminate, mate, probmutate, vsize): 'seeds the population' 'limits is a tuple holding the lower and upper limits of the cofs' 'size is the size of the seed population' self.populous = [] self.eliminate = eliminate self.size = size self.mate = mate self.probmutate = probmutate self.fitness = [] # Seeds = [np.linspace(a[0], a[1], a[2]) for a in limits] # for cofs in itertools.product(*Seeds): # self.populous.append(Individual.Individual(cofs)) for i in range(size): SeedCofs = [random.uniform(a[0], a[1]) for a in limits] self.populous.append(Individual.Individual(SeedCofs))
def initPopulation(self): """ Creating random individuals in the population """ for i in range(0, self.popSize): individual = Individual(self.genSize, self.data, self.initialSolutionType) self.population.append(individual) """ Setting the initial best solution to first individual in the population """ self.best = self.population[0].copy() """ converting the population to priority queue. First element has always the smallest fitness """ heapq.heapify(self.population) print ("Best initial sol: ", self.best.getFitness())
def stochasticUniversalSampling(self, ind): """ Your stochastic universal sampling Selection Implementation """ self.selectedchildren = [] individuals = [] for i in range(0, len(ind)): individual = Individual(self.genSize, self.data) individual.setGene(ind[i]) individual.computeFitness() individuals.append(individual) print("individuals>>>", individuals[i].fitness) #F is the sum of the fitness values of all chromosomes in the population F = 0 # N is the number of parents to select N = self.popSize #P is the distance between successive points P = 0 Pointers = [] Ruler = [] point = 0 pickedpop = [] fractionOfTotal = 0 #calculate total fitness of the population for i in range(0,len(individuals)): F = F + individuals[i].fitness Ruler.append(fractionOfTotal) for i in range(0, len(individuals)): fractionOfTotal = fractionOfTotal + individuals[i].fitness/F Ruler.append(fractionOfTotal) print("ruler", Ruler) P = 1/N print("P___",P) point = random.uniform(0,P) for i in range(0, N): for j in range(0, len(Ruler)): if point >= Ruler[j] and point <= Ruler[j+1]: self.selectedchildren.append(individuals[j].genes) point = point + P print("point>>>",point) print("picked pop>", self.selectedchildren)
def macro_mutation(genome): """Agrega o quita instrucciones -- Alg. 6.1 -- p_ins > p_del """ insertion = Util.random_flip_coin(Parameters.p_ins) mutation_point = random.randint(0, genome.height - 2) if genome.height < Parameters.num_max_instructions and \ (insertion or genome.height == Parameters.num_min_instructions): ''' Si no supera la max. cant. de instrucciones y es insercion o tiene el numero minimo de instrucciones''' new_instruction = Individual.create_new_instruction() reg_eff, to_mutate = genome.get_effective_registers(mutation_point) while not reg_eff: """ se da en el caso de que el punto de mutación esté por debajo de la última instrucción efectiva y ésta sea unaria con un operando constante """ #cambiar el registro constante del operador unario por uno variable genome.genomeList[to_mutate][3] = random.randint(Parameters.var_min, Parameters.var_max) reg_eff, to_mutate = genome.get_effective_registers(mutation_point) new_instruction[1] = random.choice(reg_eff) genome.genomeList.insert(mutation_point, new_instruction) genome.height += 1 elif genome.height > Parameters.num_min_instructions and \ (not insertion or genome.height == Parameters.num_max_instructions): ''' Si es mayor a la min. cant. de instrucciones y no es insercion o tiene el numero maximo de instrucciones''' del genome.genomeList[mutation_point] genome.height -= 1 genome.set_altered() if genome.height > Parameters.num_max_instructions: print "superado el número maximo de instrucciones MACRO" print genome.height > Parameters.num_max_instructions return genome
def micro_mutation(genome): """ Muta las instrucciones efectivas internamente p_regmut = probabilidad de mutar un registro p_opermut = probabilidad de mutar una operación p_constmut = probabilidad de mutar una constante efectiva """ eff, indices = genome.get_effective_instructions_with_indices() index = random.randint(0, len(indices) - 1) instruction = eff[index] mutation_point = indices[index] type = select_micro_mutacion_type(random.random()) if (type == "constantes"): constants_indices = genome.get_effective_constant_indices() if constants_indices: ins_with_constant_index = random.choice(constants_indices) register_mutation_index = genome.genomeList[ins_with_constant_index][3] genome.r_all[register_mutation_index] += ((-1)**(random.randint(0, 1)) * random.uniform(0, Parameters.step_size_const)) else: #no hay instrucciones efectivas con registros constantes variables type = select_micro_mutacion_type(random.random()) #si vuelve a salir constante, se elige mutación de registro o operaciones con igual probabilidad if (type == "constantes"): type = "registros" if Util.random_flip_coin(0.5) else "operaciones" if (type == "registros"): if len(eff) == 1: #una sola instrucción efectiva, no se puede cambiar r[0] if (instruction[0] < 5): pos_to_replace = random.randint(2, 3) else: #operación unaria, cambiar el segundo operando pos_to_replace = 3 else: if (instruction[0] < 5): pos_to_replace = random.randint(1, 3) else: #operación unaria, cambiar el segundo operando o el destino pos_to_replace = 1 if Util.random_flip_coin(0.5) else 3 if pos_to_replace == 1: #si no es el último índice, la última if (index + 1) < len(indices): ''' Se obtiene la lista de registros efectivos en esa posición, para reemplazar en la instrucción y permitir que siga siendo efectiva ''' reg_eff, to_mutate = genome.get_effective_registers(indices[index + 1]) if reg_eff: reg_eff.remove(instruction[1]) #remover el registro destino de los registros efectivos op, pos_to_replace = Individual.get_random_register(pos_to_replace, reg_eff, instruction) else: #el punto de mutación es la última instrucción con el r[0] if (instruction[0] < 5): pos_to_replace = random.randint(2, 3) else: #operación unaria, cambiar el segundo operando pos_to_replace = 3 op, pos_to_replace = Individual.get_random_register(pos_to_replace) else: #para los casos de operandos 1 y 2 op, pos_to_replace = Individual.get_random_register(pos_to_replace) instruction[pos_to_replace] = op genome.genomeList[mutation_point] = instruction if (type == "operaciones"): diff_op = random.randint(Parameters.op_min, Parameters.op_max) while instruction[0] == diff_op: diff_op = random.randint(Parameters.op_min, Parameters.op_max) instruction[0] = diff_op genome.genomeList[mutation_point] = instruction genome.set_altered() return genome
def deme_evolve(population): """Se reinician los indices, para hacer coincidir cada individuo.index con su posicion en internal_pop""" population = resetIndex(population) for gen in range(Parameters.gen_to_migrate): to_tournament = [] """Se seleccionan pool_size*2 diferentes posiciones en la poblacion para el torneo""" selected_indices = population.indices_selection(Parameters.pool_size * 2) to_tournament_indices = [] to_tournament_indices.append(selected_indices[: Parameters.pool_size]) to_tournament_indices.append(selected_indices[Parameters.pool_size :]) to_tournament.append(population.selection_from_indices(to_tournament_indices[0])) to_tournament.append(population.selection_from_indices(to_tournament_indices[1])) # iter_result = population.pool.imap(Population.tournament_with_mutation, to_tournament, Parameters.chunk_size) winners = [] """ ********************************* MUTACION *********************************""" for i in range(2): """ Se retorna una lista de la siguiente forma: [modificado, no_modificado] """ result = Population.tournament_with_mutation(to_tournament[i]) winners.append(result) # winners.append(iter_result.next()) """ ********************************* CROSSOVER *********************************""" if Util.random_flip_coin(Parameters.p_crossover): sister, brother = Population.crossover(winners[0][0], winners[1][0]) Individual.check_destination_register(sister) Individual.check_destination_register(brother) if not sister.index == winners[0][0].index: winners[0][0] = brother winners[1][0] = sister if not Population.check_out_register(winners[0][0]) or not Population.check_out_register(winners[1][0]): print "ERROR: [LgpMain.deme_evolve]: El crossover dejo individuos sin registros de salida." for i in range(2): """ Se elimina de la lista de participantes del torneo al ganador, para remplazar a los perdedores""" try: del to_tournament_indices[i][to_tournament[i].index(winners[i][1])] except: print "ERROR: [LgpMain.deme_evolve]: Error al eliminar el indice del ganador del torneo " + str(i) """ best_replace = index_of_best([modificado, no_modificado])""" best_replace = 0 if Individual.compare(winners[i][0], winners[i][1]) == 1 else 1 worst_replace = 1 if best_replace == 0 else 0 """ Se remplaza los perdedores por el mejor entre (ganador modificado, ganador NO modificado) y se actualizan los indices dentro de la población """ for l in to_tournament_indices[i]: indice = population.internal_pop[l].index population.internal_pop[l] = winners[i][best_replace].clone() population.internal_pop[l].index = indice """ Como ya se remplazo a los perdedores por el mejor, se remplaza al ganador por el peor. Hay mas copias del mejor. """ population.internal_pop[winners[i][0].index] = ( winners[i][worst_replace].clone().set_index(winners[i][0].index) ) """Se ordena la población de mayor a menor, según el error promedio o la desviación típica según una cierta probabilidad""" if Util.random_flip_coin(Parameters.p_migration_criteria): (population.internal_pop).sort(cmp=Individual.compare_error_prom, reverse=True) else: (population.internal_pop).sort(cmp=Individual.compare_deviation_in_error, reverse=True) for i in population.internal_pop: if not i.evaluated: print "ERROR: METODO DE ORDENACION FALLO." return population