def crossoverAndMutation(problem, individuals): # Format a population data structure usable by DEAP's package dIndividuals = deap_format(problem, individuals) # Crossover for ind1, ind2 in zip(dIndividuals[::2], dIndividuals[1::2]): if random.random() <= 0.9: #crossover rate tools.cxUniform(ind1, ind2, indpb=1.0 / len(problem.decisions)) # Mutation for ind in dIndividuals: tools.mutPolynomialBounded(ind, eta=1.0, low=[dec.low for dec in problem.decisions], up=[dec.up for dec in problem.decisions], indpb=0.1) del ind.fitness.values # Update beginning population data structure for individual, dIndividual in zip(individuals, dIndividuals): for i in range(len(individual.decisionValues)): individual.decisionValues[i] = dIndividual[i] individual.fitness = None return individuals, 0
def mateNN(ind1, ind2): gen = ind1.gen genotype(ind1) genotype(ind2) tools.cxUniform(ind1, ind2, params["xoi"]) phenotype(ind1) phenotype(ind2) ind1.gen = gen ind2.gen = gen return (ind1, ind2)
def cx(ind1, ind2): new_wealth = ((ind1.wealth + ind2.wealth) / 2 if use_inheritance else initial_wealth) parents = (ind1.id, ind2.id) tools.cxUniform(ind1, ind2, 0.5) # tools.cxTwoPoint ind1.wealth = ind2.wealth = new_wealth ind1.connections_ids = [] ind2.connections_ids = [] ind1.parents = ind2.parents = parents return ind1, ind2
def cxTwo_Uniform(ind1, ind2): x = tools.cxTwoPoint(ind1, ind2) y = tools.cxUniform(ind1, ind2, indpb=0.9) if sum(max(x)) > sum(max(y)): return x else: return y
def cxUniform(self, ind1, ind2, indpb): for _ in range(100): c1, c2 = tools.cxUniform(ind1, ind2, indpb) if self.check_constraint(c1) and self.check_constraint(c2): break return (c1, c2)
def crossover(self, individual_1, individual_2, probability): if self.method == 'Uniform': return tools.cxUniform(individual_1, individual_2, probability) elif self.method == 'TwoPoint': return tools.cxESTwoPoint(individual_1, individual_2)
def crossover_weights(ind1, ind2, force): #ind1.check() #ind2.check() child1, child2 = tools.cxUniform(ind1.weights, ind2.weights, indpb=0.5) ind1.weights[:] = fix_weights(child1, force) ind2.weights[:] = fix_weights(child2, force) #ind1.check() #ind2.check() return ind1, ind2
def crossoverAndMutation(problem, individuals): # Format a population data structure usable by DEAP's package dIndividuals = deap_format(problem, individuals) # Crossover for ind1, ind2 in zip(dIndividuals[::2], dIndividuals[1::2]): if random.random() <= 0.9: #crossover rate tools.cxUniform(ind1, ind2, indpb=1.0/len(problem.decisions)) # Mutation for ind in dIndividuals: tools.mutPolynomialBounded(ind, eta = 1.0, low=[dec.low for dec in problem.decisions], up=[dec.up for dec in problem.decisions], indpb=0.1 ) del ind.fitness.values # Update beginning population data structure for individual,dIndividual in zip(individuals, dIndividuals): for i in range(len(individual.decisionValues)): individual.decisionValues[i] = dIndividual[i] individual.fitness = None return individuals,0
def main(): # 杂交函数测试 ind1 = [1, 1, 1, 1, 1] ind2 = [0, 0, 0, 0, 0] print(ind1, ind2) """交换从任意位置开始并且到结尾的一段基因""" n1, n2 = tools.cxOnePoint(ind1, ind2) print(n1, n2) """交换连续的一段长度随机,位置随机的基因""" n3, n4 = tools.cxTwoPoint(ind1, ind2) print(n3, n4) """进行min(len(ind1), len(ind2))次杂交,每轮交换前产生一个随机数a,若a小于indpb则交换该轮次位置的两个基因,否则不执行交换""" n5, n6 = tools.cxUniform(ind1, ind2, indpb=0.5) print(n5, n6)
def customXover(ind1, ind2): g_01, g_02 = tools.cxUniform([ind1[0]], [ind2[0]], CXPROB) g1, g2 = tools.cxTwoPoint(ind1[1:], ind2[1:]) ind1[0] = g_01[0] ind2[0] = g_02[0] for i in range(1, len(ind1)): ind1[i] = g1[i - 1] for i in range(1, len(ind2)): ind2[i] = g2[i - 1] return ind1, ind2
def crossover_centroid(ind1, ind2): ind1.check() ind2.check() child1, child2 = tools.cxUniform(ind1.centroid.flatten(), ind2.centroid.flatten(), indpb=0.5) ind1.centroid[:, :] = child1.reshape((ind1.NC, ind1.ND)) ind2.centroid[:, :] = child2.reshape((ind2.NC, ind2.ND)) ind1.check() ind2.check() return ind1, ind2
def _mate(ind1, ind2, low, up, blend_prob=0.5): # a mixture of blend and 2 point crossover if random.random() < blend_prob: ind1, ind2 = tools.cxBlend(ind1, ind2, alpha=0.5) size = min(len(ind1), len(ind2)) for i, u, l in zip(range(size), up, low): ind1[i] = math.floor(ind1[i]) ind2[i] = math.ceil(ind2[i]) if ind1[i] > u: ind1[i] = u elif ind1[i] < l: ind1[i] = l if ind2[i] > u: ind2[i] = u elif ind2[i] < l: ind2[i] = l return ind1, ind2 else: return tools.cxUniform(ind1, ind2, indpb=0.5)
def my_crossover(self,LL,UU,ind1, ind2): t=self.t typeOfInput=len(t) ind11 = [] ind22 = [] for i in range(typeOfInput): if t[i] =='float': ind1var1,ind2var1=tools.cxSimulatedBinaryBounded([ind1[i]], [ind2[i]], low=LL[i], up=UU[i], eta=20.0) ind11.append(ind1var1[0]) ind22.append(ind2var1[0]) elif t[i]=='int': ind1var2,ind2var2=tools.cxUniform([ind1[i]], [ind2[i]],indpb=0.9) ind11.append(ind1var2[0]) ind22.append(ind2var2[0]) elif t[i]=='bool': toss = random.random() if toss > 0.5: ind1var3,ind2var3=ind2[i], ind1[i] ind11.append(ind1var3) ind22.append(ind2var3) return ind11,ind22
def crossover_weights(ind1, ind2, force): #ind1.check() #ind2.check() child1, child2 = tools.cxUniform(ind1.weights.flatten(), ind2.weights.flatten(), indpb=0.5) ind1.weights[:, :] = child1.reshape((ind1.NC, ind1.ND)) ind2.weights[:, :] = child2.reshape((ind2.NC, ind2.ND)) NC, ND = ind1.weights.shape for i in range(NC): ind1.weights[i, :] = fix_weights(ind1.weights[i, :], force) ind2.weights[i, :] = fix_weights(ind2.weights[i, :], force) #ind1.check() #ind2.check() return ind1, ind2
##Mutation mutant = toolbox.clone(ind1) #ind2 = tools.mutGaussian(mutant, mu=0.0, sigma=0.2, indpb=0.2) ind2, = tools.mutUniformInt(mutant, low=0, up=1, indpb=0.5) del mutant.fitness.values ind2 ind1 ind2.fitness.values = evalKnapsack(ind2) ind2.fitness.values ind1.fitness.values ##CROSSOVER child1, child2 = [toolbox.clone(ind) for ind in (ind1, ind2)] tools.cxUniform(child1, child2, 0.5) #tools.cxSimulatedBinary(child1, child2,0.5) #tools.cxPartialyMatched(child1, child2) del child1.fitness.values del child2.fitness.values selected = tools.selNSGA2([child1, child2], nd="standard") print(child1 in selected) # True for g in range(NGEN): # Select and clone the next generation individuals offspring = map(toolbox.clone, toolbox.select(pop, len(pop))) # Apply crossover and mutation on the offspring
def uniform_crossover(ind1, ind2, ind_pb): tools.cxUniform(ind1, ind2, ind_pb) # params: ind1, ind2, ind_pb
def customXover(self, ind1, ind2, indpb): """ Parameters ---------- ind1 : Deap invidual parent 1 ind2 : Deap invidual parent 2 indpb : float Defined the probability that a semantically equal slices of genetic code are recombined Returns ------- ind1 : Deap invidual ind2 : Deap invidual Recombined Individuals Semantically equal slice are recombined together with indpb probability. If the slice is a single attribute cxUniform is used, CxTwoPoint deap crossover is used in the other case. """ #Q g_q1, g_q2 = tools.cxUniform([ind1[0]], [ind2[0]], indpb=indpb) #GED g_ged1, g_ged2 = tools.cxTwoPoint(ind1[1:7], ind2[1:7]) #Tau g_tau1, g_tau2 = tools.cxUniform([ind1[7]], [ind2[7]], indpb=indpb) #Test weight comp card #g_eta1,g_eta2 = tools.cxUniform([ind1[8]], [ind2[8]], indpb = indpb) #################### #Set if crossovered ind1[0] = g_q1[0] ind2[0] = g_q2[0] #two point crossover individuals are always modified. We edit this slice of genetic code only if condition is valid if random.random() < indpb: for i, (g1, g2) in enumerate(zip(g_ged1, g_ged2), start=1): ind1[i] = g1 ind2[i] = g2 # for i in range(1,7): # ind2[i]=g2 # ind1[7] = g_tau1[0] ind2[7] = g_tau2[0] #Test weight comp card # ind1[8]=g_eta1[0] # ind2[8]=g_eta2[0] #############à if self._problemName == 'GREC': g_add1, g_add2 = tools.cxTwoPoint(ind1[8:13], ind2[8:13]) #Weight eta #g_add1, g_add2 = tools.cxTwoPoint(ind1[9:14], ind2[9:14]) ################ #Same for ged attributes if random.random() < indpb: for i, (g1, g2) in enumerate(zip(g_add1, g_add2), start=8): #Weight eta #for i,(g1,g2) in enumerate(zip(g_add1,g_add2),start = 9): ########### ind1[i] = g1 ind2[i] = g2 return ind1, ind2
def main(epsilon, delta): global lambda_values global population_size global population global population_obj_func_vals global iterations outputs = [] for lambda_index in range(1, number_of_lambdas+1): _lambda = float(lambda_index-1)/(number_of_lambdas-1) improved_solutions = [] #improved solutions for a particular lambda v_lambda = float('Inf') for i in range(1 , population_size+1): sample = [[0,0] for x in range(number_of_assets)] Q = random.sample([x for x in range(1, number_of_assets+1)],10) for asset in Q: sample[asset-1] = [1, myRandom(0,1)] population[i-1] = list(sample) for ind,S in enumerate(population): [population_obj_func_vals[ind], v_lambda, improved] = evaluate(S, _lambda, 0, v_lambda, False, improved_solutions, UPDATE_H) for itr in range(iterations): #binary tournament for selecting parents S_star and S_double_star chosen = [] for i in xrange(2): aspirants = tools.selRandom(population, 40) for i,aspirant in enumerate(aspirants): h = [] f_aspirant = 0 v = float('Inf') imp = False [f_aspirant, v, imp] = evaluate(aspirant, _lambda, 0, v, False, h, DONT_UPDATE_H) aspirants[i] = [aspirant, f_aspirant] chosen.append(min(aspirants, key=lambda x: x[1])[0]) S_star = list(chosen[0]) S_double_star = list(chosen[1]) #Uniform crossover to find child C C = [] [C1, C2] = tools.cxUniform(S_star, S_double_star, ind_prob) f1 = f2 = 0 v = float('Inf') imp = False h = [] [f1, v, imp] = evaluate(C1, _lambda, 0, v, False, h, DONT_UPDATE_H) [f2, v, imp] = evaluate(C2, _lambda, 0, v, False, h, DONT_UPDATE_H) if f1<f2: C = C1 else: C = C2 #find assets in parents but not in child A_star = [] for i in range(number_of_assets): if S_star[i][0]==1 and S_double_star[i][0]==0 and C[i][0]==0: A_star.append([i+1, S_star[i][1]]) elif S_star[i][0]==0 and S_double_star[i][0]==1 and C[i][0]==0: A_star.append([i+1, S_double_star[i][1]]) #Mutation mutation_index = random.randint(0, number_of_assets-1) while C[mutation_index][0]==0: mutation_index = random.randint(0, number_of_assets-1) m = random.randint(0,1) if m == 0: # C_i = 0.9*(epsilon + C[mutation_index][1]) - epsilon C_i = 0.9*(epsilon[mutation_index] + C[mutation_index][1]) - epsilon[mutation_index] else: # C_i = 1.1*(epsilon + C[mutation_index][1]) - epsilon C_i = 1.1*(epsilon[mutation_index] + C[mutation_index][1]) - epsilon[mutation_index] if C_i<0: C[mutation_index][0] = 0 C[mutation_index][1] = 0 #check if child contains more or less than K assets and fix it total_assets_in_child = 0 child_copy = list(C) sorted_child_copy = sorted(child_copy, key=itemgetter(1)) for item in sorted_child_copy: if item[0]==1: total_assets_in_child += 1 if total_assets_in_child > K: for item in sorted_child_copy[:-K]: # C.index(item) = [0,0] C[C.index(item)] = [0,0] elif total_assets_in_child < K: while total_assets_in_child < K: if len(A_star) > 0: random_index = random.randint(0,len(A_star)-1) random_element = A_star.pop(random_index) C[random_element[0]-1] = [1, random_element[1]] else: random_index = random.randint(0,30) while C[random_index][0]==1: random_index = random.randint(0,30) C[random_index] = [1, 0] total_assets_in_child += 1 #change the population by adding child to it obj_func_val_child = 0 [obj_func_val_child, v_lambda, improved] = evaluate(C, _lambda, 0, v_lambda, False, improved_solutions, UPDATE_H) if improved: population[population_obj_func_vals.index(max(population_obj_func_vals))] = C print lambda_index outputs.append(evaluate(improved_solutions[-1], _lambda, 0, float('Inf'), False, None, FINAL_SAMPLE)) H.append(improved_solutions) np_out_matrix = np.matrix(outputs) np_out_matrix = np_out_matrix.T outputs = np_out_matrix.tolist() f = open("out5.csv", "w") writer = csv.writer(f) for row in outputs: writer.writerow(tuple(row)) f.close()
def cxUniform(ind1, ind2, indpb): c1, c2 = tools.cxUniform(ind1, ind2, indpb) return (c1, c2)
def crossoverAndMutation(problem, individuals): from copy import copy new_individuals = individuals if CULLING is True: count = 0 new_crop = [] # Format a population data structure usable by DEAP's package dIndividuals = deap_format(problem, individuals) while True: count += 1 if count > 10 or len(dIndividuals) == 1 or len(new_crop) == len(individuals): break # Crossover for ind1, ind2 in zip(dIndividuals[::2], dIndividuals[1::2]): if random.random() <= 0.9: #crossover rate tools.cxUniform(ind1, ind2, indpb=1.0/len(problem.decisions)) # Mutation for ind in dIndividuals: temp = [] tools.mutPolynomialBounded(ind, eta = 1.0, low=[dec.low for dec in problem.decisions], up=[dec.up for dec in problem.decisions], indpb=0.1 ) del ind.fitness.values temp = problem.evaluate(ind) if temp[0] > jmoo_properties.CULLING_PD and temp[1] < jmoo_properties.CULLING_PF: import numpy as np test = np.array(ind).tolist() # print "IND: ", ind # print "TEST: ", test if len(new_crop) != len(individuals): new_crop = helper_list(new_crop, test) # print ">> ", problem.evaluate(ind) print "NEW CROP: ", len(new_crop) for x in new_crop: if x in dIndividuals: dIndividuals.remove(x) else: dIndividuals.remove(random.choice(dIndividuals)) for _ in xrange(1): print ">> ", problem.evaluate(x), x dIndividuals.extend(new_crop) print "Length : ", len(dIndividuals) # Update beginning population data structure for individual,dIndividual in zip(individuals, dIndividuals): for i in range(len(individual.decisionValues)): individual.decisionValues[i] = dIndividual[i] individual.fitness = None return individuals, len(individuals) * (count - 1) else: # Format a population data structure usable by DEAP's package dIndividuals = deap_format(problem, individuals) new_dIndividuals = [] # print "Number of Individuals: ", len(dIndividuals) # Crossover for ind1, ind2 in zip(dIndividuals[::2], dIndividuals[1::2]): if random.random() <= 1: #crossover rate # print ".", ind1, ind2 = tools.cxUniform(ind1, ind2, indpb=1.0/len(problem.decisions)) new_dIndividuals.append(ind1) new_dIndividuals.append(ind2) else: new_dIndividuals.append(ind1) new_dIndividuals.append(ind2) # Mutation for ind in new_dIndividuals: # print "+", tools.mutPolynomialBounded(ind, eta = 1.0, low=[dec.low for dec in problem.decisions], up=[dec.up for dec in problem.decisions], indpb=0.1 ) del ind.fitness.values # Update beginning population data structure for individual, dIndividual in zip(new_individuals, new_dIndividuals): for i in range(len(individual.decisionValues)): individual.decisionValues[i] = dIndividual[i] individual.fitness = None return new_individuals,0
def main(epsilon, delta): global lambda_values global population_size global population global population_obj_func_vals global iterations outputs = [] for lambda_index in range(1, number_of_lambdas+1): _lambda = float(lambda_index-1)/(number_of_lambdas-1) improved_solutions = [] #improved solutions for a particular lambda v_lambda = float('Inf') for i in range(1 , population_size+1): sample = [[0,0] for x in range(number_of_assets)] Q = random.sample([x for x in range(1, number_of_assets+1)],10) for asset in Q: sample[asset-1] = [1, myRandom(0,1)] population[i-1] = list(sample) for ind,S in enumerate(population): [population_obj_func_vals[ind], v_lambda, improved] = evaluate(S, _lambda, 0, v_lambda, False, improved_solutions, UPDATE_H) for itr in range(iterations): #binary tournament for selecting parents S_star and S_double_star chosen = [] for i in xrange(2): aspirants = tools.selRandom(population, 40) for i,aspirant in enumerate(aspirants): h = [] f_aspirant = 0 v = float('Inf') imp = False [f_aspirant, v, imp] = evaluate(aspirant, _lambda, 0, v, False, h, DONT_UPDATE_H) aspirants[i] = [aspirant, f_aspirant] chosen.append(min(aspirants, key=lambda x: x[1])[0]) S_star = list(chosen[0]) S_double_star = list(chosen[1]) #Uniform crossover to find child C C = [] [C1, C2] = tools.cxUniform(S_star, S_double_star, ind_prob) f1 = f2 = 0 v = float('Inf') imp = False h = [] [f1, v, imp] = evaluate(C1, _lambda, 0, v, False, h, DONT_UPDATE_H) [f2, v, imp] = evaluate(C2, _lambda, 0, v, False, h, DONT_UPDATE_H) if f1<f2: C = C1 else: C = C2 #find assets in parents but not in child A_star = [] for i in range(number_of_assets): if S_star[i][0]==1 and S_double_star[i][0]==0 and C[i][0]==0: A_star.append([i+1, S_star[i][1]]) elif S_star[i][0]==0 and S_double_star[i][0]==1 and C[i][0]==0: A_star.append([i+1, S_double_star[i][1]]) #Mutation mutation_index = random.randint(0, number_of_assets-1) while C[mutation_index][0]==0: mutation_index = random.randint(0, number_of_assets-1) m = random.randint(0,1) if m == 0: # C_i = 0.9*(epsilon + C[mutation_index][1]) - epsilon C_i = 0.9*(epsilon[mutation_index] + C[mutation_index][1]) - epsilon[mutation_index] else: # C_i = 1.1*(epsilon + C[mutation_index][1]) - epsilon C_i = 1.1*(epsilon[mutation_index] + C[mutation_index][1]) - epsilon[mutation_index] if C_i<0: C[mutation_index][0] = 0 C[mutation_index][1] = 0 #check if child contains more or less than K assets and fix it total_assets_in_child = 0 child_copy = list(C) sorted_child_copy = sorted(child_copy, key=itemgetter(1)) for item in sorted_child_copy: if item[0]==1: total_assets_in_child += 1 if total_assets_in_child > K: for item in sorted_child_copy[:-K]: # C.index(item) = [0,0] C[C.index(item)] = [0,0] elif total_assets_in_child < K: while total_assets_in_child < K: if len(A_star) > 0: random_index = random.randint(0,len(A_star)-1) random_element = A_star.pop(random_index) C[random_element[0]-1] = [1, random_element[1]] else: random_index = random.randint(0,30) while C[random_index][0]==1: random_index = random.randint(0,30) C[random_index] = [1, 0] total_assets_in_child += 1 #change the population by adding child to it obj_func_val_child = 0 [obj_func_val_child, v_lambda, improved] = evaluate(C, _lambda, 0, v_lambda, False, improved_solutions, UPDATE_H) if improved: population[population_obj_func_vals.index(max(population_obj_func_vals))] = C print lambda_index outputs.append(evaluate(improved_solutions[-1], _lambda, 0, float('Inf'), False, None, FINAL_SAMPLE)) H.append(improved_solutions) np_out_matrix = np.matrix(outputs) np_out_matrix = np_out_matrix.T outputs = np_out_matrix.tolist() f = open("out2.csv", "w") writer = csv.writer(f) for row in outputs: writer.writerow(tuple(row)) f.close()
def cxUniform(self, ind1, ind2, indpb): for _ in range(100): c1, c2 = tools.cxUniform(ind1, ind2, indpb) return (c1, c2)
img = (np.expand_dims(image_copy, 0)) predictions = model.predict(img) print(np.argmax(predictions)) print(test_labels[0]) # Select the next generation individuals offspring = tools.selRoulette(pop, len(pop)) # Clone the selected individuals offspring = list(map(toolbox.clone, offspring)) # Apply crossover and mutation on the offspring for child1, child2 in zip(offspring[::2], offspring[1::2]): if np.random.random() < CXPB: fitness_child1 = child1.fitness.values[0] fitness_child2 = child2.fitness.values[0] tools.cxUniform(child1, child2, fitness_child1 / (fitness_child1 + fitness_child2)) del child1.fitness.values del child2.fitness.values for mutant in offspring: if np.random.random() < MUTPB: operators.mutate(mutant, 0.5, DELTA) del mutant.fitness.values # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit pop[:] = offspring
def crossover(self, individualA, individualB, pb): tools.cxUniform(individualA, individualB, pb)
def cxGIMME_Order(self, ind1, ind2): # configs config1 = ind1[0] config2 = ind2[0] newConfig1 = [] newConfig2 = [] l1 = len(config1) l2 = len(config2) if (l1 > l2): maxLenConfig = config1 maxLen = l1 minLenConfig = config2 minLen = l2 else: maxLenConfig = config2 maxLen = l2 minLenConfig = config1 minLen = l1 cxpoints = [] clist1 = [] clist2 = [] remainder1 = [] remainder2 = [] for i in range(minLen): parent1 = minLenConfig[i] parent2 = maxLenConfig[i] cxpoint = random.randint(0,len(minLenConfig[i])) cxpoints.append(cxpoint) clist1.extend(parent1) clist2.extend(parent2) remainder1.extend(parent1[cxpoint:]) remainder2.extend(parent2[cxpoint:]) d1 = {k:v for v,k in enumerate(clist1)} d2 = {k:v for v,k in enumerate(clist2)} remainder1.sort(key=d2.get) remainder2.sort(key=d1.get) for i in range(minLen): parent1 = minLenConfig[i] parent2 = maxLenConfig[i] cxpoint = cxpoints[i] #C1 Implementation # maintain left part child1, child2 = parent1[:cxpoint], parent2[:cxpoint] # reorder right part missingLen1 = len(parent1) - len(child1) child1.extend(remainder1[:missingLen1]) remainder1 = remainder1[missingLen1:] missingLen2 = len(parent2) - len(child2) child2.extend(remainder2[:missingLen2]) remainder2 = remainder2[missingLen2:] newConfig1.append(child1) newConfig2.append(child2) #the inds become children ind1[0] = newConfig1 ind2[0] = newConfig2 # breakpoint() # profiles are crossed with one point (no need for that when profiles are 1D) # breakpoint() # if self.interactionsProfileTemplate.dimensionality > 1: for i in range(minLen): prof1 = ind1[1][i].flattened() prof2 = ind2[1][i].flattened() newProfiles = tools.cxUniform(prof1, prof2, 0.5) # newProfiles = tools.cxOnePoint(prof1, prof2) #the inds become children ind1[1][i] = self.interactionsProfileTemplate.unflattened(newProfiles[0]) ind2[1][i] = self.interactionsProfileTemplate.unflattened(newProfiles[1]) # breakpoint() del ind1.fitness.values del ind2.fitness.values return (ind1, ind2)
# SELECT WINNERS winners = toolbox.clone(winners) for w in winners: del w.fitness.values mutant = toolbox.clone(w) mutant = tools.mutGaussian(mutant, mu=0.0, sigma=0.1, indpb=0.2) pop_new.append(mutant[0]) # SELECT RANDOM AND CROSSOVER rand = toolbox.clone(rand) for r in rand: del r.fitness.values rand1 = rand[:int((POP_SIZE * 0.5) / 2)] rand2 = rand[int((POP_SIZE * 0.5) / 2):] for r1, r2 in zip(rand1, rand2): child1, child2 = tools.cxUniform(r1, r2, 0.25) pop_new.append(child1) pop_new.append(child2) for n in new: pop_new.append(n) for p in pop_new: if not p.fitness.values: p.fitness.values = evaluate(p, fin_list) pop[:] = pop_new HoF.update(pop) del pop_new
def crossover_main(ind1, ind2, indpb, column_names, heating_unit_names_share, cooling_unit_names_share, column_names_buildings_heating, column_names_buildings_cooling, district_heating_network, district_cooling_network): # create dict of individual with his/her name ind1_with_name_dict = dict(zip(column_names, ind1)) ind2_with_name_dict = dict(zip(column_names, ind2)) if district_heating_network: # MUTATE BUILDINGS CONNECTED buildings_heating_ind1 = [ ind1_with_name_dict[column] for column in column_names_buildings_heating ] buildings_heating_ind2 = [ ind2_with_name_dict[column] for column in column_names_buildings_heating ] # apply crossover buildings_heating_ind1, buildings_heating_ind2 = tools.cxUniform( buildings_heating_ind1, buildings_heating_ind2, indpb) # take back to the individual for column, cross_over_value in zip(column_names_buildings_heating, buildings_heating_ind1): ind1_with_name_dict[column] = cross_over_value for column, cross_over_value in zip(column_names_buildings_heating, buildings_heating_ind2): ind2_with_name_dict[column] = cross_over_value # MUTATE SUPPLY SYSTEM UNITS SHARE heating_units_share_ind1 = [ ind1_with_name_dict[column] for column in heating_unit_names_share ] heating_units_share_ind2 = [ ind2_with_name_dict[column] for column in heating_unit_names_share ] # apply crossover heating_units_share_ind1, heating_units_share_ind2 = tools.cxUniform( heating_units_share_ind1, heating_units_share_ind2, indpb) # takeback to the individual for column, cross_over_value in zip(heating_unit_names_share, heating_units_share_ind1): ind1_with_name_dict[column] = cross_over_value for column, cross_over_value in zip(heating_unit_names_share, heating_units_share_ind2): ind2_with_name_dict[column] = cross_over_value if district_cooling_network: # CROSSOVER BUILDINGS CONNECTED buildings_cooling_ind1 = [ ind1_with_name_dict[column] for column in column_names_buildings_cooling ] buildings_cooling_ind2 = [ ind2_with_name_dict[column] for column in column_names_buildings_cooling ] # apply crossover buildings_cooling_ind1, buildings_cooling_ind2 = tools.cxUniform( buildings_cooling_ind1, buildings_cooling_ind2, indpb) # take back to teh individual for column, cross_over_value in zip(column_names_buildings_cooling, buildings_cooling_ind1): ind1_with_name_dict[column] = cross_over_value for column, cross_over_value in zip(column_names_buildings_cooling, buildings_cooling_ind2): ind2_with_name_dict[column] = cross_over_value # CROSSOVER SUPPLY SYSTEM UNITS SHARE cooling_units_share_ind1 = [ ind1_with_name_dict[column] for column in cooling_unit_names_share ] cooling_units_share_ind2 = [ ind2_with_name_dict[column] for column in cooling_unit_names_share ] # apply crossover cooling_units_share_ind1, cooling_units_share_ind2 = tools.cxUniform( cooling_units_share_ind1, cooling_units_share_ind2, indpb) # takeback to teh individual for column, cross_over_value in zip(cooling_unit_names_share, cooling_units_share_ind1): ind1_with_name_dict[column] = cross_over_value for column, cross_over_value in zip(cooling_unit_names_share, cooling_units_share_ind2): ind2_with_name_dict[column] = cross_over_value # now validate individual # now validate individual ind1_with_name_dict = validation_main(ind1_with_name_dict, column_names_buildings_heating, column_names_buildings_cooling, district_heating_network, district_cooling_network) ind2_with_name_dict = validation_main(ind2_with_name_dict, column_names_buildings_heating, column_names_buildings_cooling, district_heating_network, district_cooling_network) # now pass all the values mutated to the original individual for i, column in enumerate(column_names): ind1[i] = ind1_with_name_dict[column] for i, column in enumerate(column_names): ind2[i] = ind2_with_name_dict[column] return ind1, ind2