def main(): pop = toolbox.population(n = POPULATION_SIZE) CXPB, MUTPB, NGEN = 0.6, 0.2, 100 if DEBUG: print("-- Life Span --") fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit for g in xrange(NGEN): print("-- Generation %i --" % (g+1)) elite = toolbox.elite(pop) elite = list(map(toolbox.clone, elite)) offspring = toolbox.select(pop, POPULATION_SIZE-2) offspring = list(map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2],offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values offspring = elite + offspring if DEBUG: print("-- Calculating fitness for prole --") 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 fits = [ind.fitness.values[0] for ind in offspring] length = len(pop) mean = sum(fits) / length sum2 = sum(x*x for x in fits) std = abs(sum2/length - mean**2)**0.5 print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) if DEBUG: print(" Best Chromossome: %s"%tools.selBest(offspring, k = 1)) pop[:] = offspring print(" The Walker: %s"% tools.selBest(pop, k = 1))
def train(self, pop = 20, gen = 10): from deap import algorithms from deap import base from deap import creator from deap import tools from deap.tools import Statistics # import random from scipy.stats import rv_discrete # creator.create("FitnessMulti", base.Fitness, weights=(1.0, -1.0)) # creator.create("Individual", list, fitness=creator.FitnessMulti) creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() # Attribute generator custm = rv_discrete(name='custm', values=(self.a_w.index, self.a_w.values)) toolbox.register("attr_int", custm.rvs) # Structure initializers toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_int, n=len(self.s)) toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=pop) # Operator registering toolbox.register("evaluate", self.eval_classifer) toolbox.register("mate", tools.cxUniform, indpb=0.5) toolbox.register("mutate", tools.mutUniformInt, low=min(self.a.index), up=max(self.a.index), indpb=0.1) toolbox.register("select", tools.selNSGA2) MU, LAMBDA = pop, pop population = toolbox.population(n=MU) hof = tools.ParetoFront() s = Statistics(key=lambda ind: ind.fitness.values) s.register("mean", np.mean) s.register("min", min) # pop, logbook = algorithms.eaMuPlusLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, cxpb=0.7, mutpb=0.3, ngen=gen, stats=s, halloffame=hof) for i in range(gen): offspring = algorithms.varAnd(population, toolbox, cxpb=0.95, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = tools.selBest(offspring, int(0.05*len(offspring))) + tools.selTournament(offspring, len(offspring)-int(0.05*len(offspring)), tournsize=3) # population = toolbox.select(offspring, k=len(population)) print s.compile(population) top10 = tools.selBest(population, k=10) return top10
def main(): global sut, rgen, nbugs, start, CXPB, MUTPB, NGEN sut = sut.sut() rgen = random.Random(opts.seed) CXPB, MUTPB, NGEN = 0.5, 0.2, 1 best, timeclock = [], [] nbugs, g, prev_best = 0, 0, 1 init() start = time.time() while True: print("Building population") pop = toolbox.population(n=100) print(" n=%d" % len(pop)) print("Start of evolution") fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit while True: g += 1 generation(g, pop) best_test = tools.selBest(pop, 1)[0] elapsed = time.time()-start if 0.02 > (best_test.fitness.values[0] - prev_best) / prev_best or elapsed > (0.95 * opts.timeout): break else: prev_best = max(best_test.fitness.values[0], prev_best) best_test = tools.selBest(pop, 1)[0] print("Best test has %s lines covered" % int(best_test.fitness.values[0])) best.append(best_test.fitness.values[0]) elapsed = time.time()-start timeclock.append(elapsed) if not timeclock else timeclock.append(elapsed - timeclock[-1]) average_time = sum(timeclock) / len(timeclock) print("elapsed: %f seconds out of %f seconds" % (elapsed, opts.timeout)) if (elapsed + average_time) > opts.timeout: break overall_best = max(best) print("Overall best test has %s lines covered" % int(overall_best)) if (opts.coverage): sut.internalReport()
def train(self, pop = 20, gen = 10): from deap import algorithms from deap import base from deap import creator from deap import tools import random import numpy as np from deap.tools import Statistics # creator.create("FitnessMulti", base.Fitness, weights=(1.0, -1.0)) # creator.create("Individual", list, fitness=creator.FitnessMulti) creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) toolbox = base.Toolbox() # Attribute generator toolbox.register("attr_bool", random.randint, 0, 1) # Structure initializers toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=len(self.X.columns)) toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=pop) # Operator registering toolbox.register("evaluate", self.eval_classifer) toolbox.register("mate", tools.cxUniform, indpb=0.1) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) # toolbox.register("select", tools.selNSGA2) MU, LAMBDA = pop, pop population = toolbox.population(n=MU) # hof = tools.ParetoFront() s = Statistics(key=lambda ind: ind.fitness.values) s.register("mean", np.mean) s.register("max", max) # pop, logbook = algorithms.eaMuPlusLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, cxpb=0.7, mutpb=0.3, ngen=gen, stats=s, halloffame=hof) for i in range(gen): offspring = algorithms.varAnd(population, toolbox, cxpb=0.95, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = tools.selBest(offspring, int(0.05*len(offspring))) + tools.selTournament(offspring, len(offspring)-int(0.05*len(offspring)), tournsize=3) # population = toolbox.select(offspring, k=len(population)) print s.compile(population) top10 = tools.selBest(population, k=10) print top10 return top10[0]
def _combined_selection_operator(self, individuals, k): """Regular selection + elitism.""" best_inds = int(0.1 * k) rest_inds = k - best_inds return (tools.selBest(individuals, 1) * best_inds + tools.selDoubleTournament(individuals, k=rest_inds, fitness_size=3, parsimony_size=2, fitness_first=True))
def selElites(pop): #Selector function attkTypes = len(attkUniqs) # 4, Numbers of attacks in integer attkPop = [] elitesSub = [] elitesAll = [] for i in xrange(attkTypes): #create lists within the attkPop list attkPop.append([]) #equals to the number of attkTypes for i in xrange(attkTypes): for j, k in enumerate(pop): if k[-1] == attkUniqs[i]: #if last field is the same attack attkPop[i].append(k) #type then add to the attkPop for i in attkPop: elitesSub.append(tools.selBest(i, elitesNo)) for i in elitesSub: #appending all elites to elitesAll list i = list(i for i,_ in itertools.groupby(i)) #eliminate duplicate elites by attk type for j in i: elitesAll.append(j) #for i in elitesAll: # i = list(i for i,_ in itertools.groupby(i)) return elitesAll #This will be returned to create part of new
def compose(toolbox, window, tonic): global chords_in_vector population = toolbox.population(n=pop_size) NGEN = num_gens for gen in range(NGEN): offspring = algorithms.varAnd(population, toolbox, cxpb=cx_pb, mutpb=mut_pb) fits = toolbox.map(toolbox.evaluate, offspring) total_fitness = 0 for fit, ind in zip(fits, offspring): ind.fitness.values = fit total_fitness += fit population = toolbox.select(offspring, k=len(population)) #print("Total fitness in gen %s : %s" % (gen, total_fitness)) #print("Best : %s" % evaluate(tools.selBest(population, k=1)[0])) top = tools.selBest(population, k=1)[0] np.set_printoptions(threshold=np.nan) #pprint("%s, %s" % (window, top)) #pprint(evaluate(top)) return top, evaluate(top)
def main_program(pop): HOF = [] fitnesses = toolbox.map(toolbox.evaluate, pop) # eval. fitness of pop for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit for g in range(ngen): if g%5==0: print(str(g) + ' of ' + str(ngen)) offspring = toolbox.select(pop, len(pop)) #select which individuals to mate offspring = list(map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2], offspring[1::2]): #determine whether to have a cross over if random.random() < cxpb: toolbox.mate(child1[0], child2[0]) del child1.fitness.values, child2.fitness.values for mutant in offspring: #determine whether to mutate if random.random() < mutpb: toolbox.mutate(mutant[0]) del mutant.fitness.values invalids = [ind for ind in offspring if not ind.fitness.valid] #assign fitness scores to new offspring fitnesses = toolbox.map(toolbox.evaluate, invalids) for ind, fit in zip(invalids, fitnesses): ind.fitness.values = fit pop[:] = offspring #update population with offspring log.record(gen=g,**stats.compile(pop)) return tools.selBest(pop,k=1)[0][0], log, HOF
def learn(self): """ Runs genetic algorithms. By using DEAP, generates an initial population and runs for n generations. Returns: A dict with the features weight and others params. """ solution = {} # Generate Population population = self.deap_toolbox.population(n=self.population) # Evolve for gen in range(self.generations): offspring = algorithms.varAnd(population, self.deap_toolbox, cxpb=0.5, mutpb=0.1) fits = self.deap_toolbox.map(self.deap_toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = self.deap_toolbox.select(offspring, k=len(population)) # Select best best = tools.selBest(population, k=1)[0] best_fitness, = self.fitness_wrapper(best) revisions_weight, fixes_weight, authors_weight = self.decode_individual(best) solution["revisions"] = revisions_weight solution["fixes"] = fixes_weight solution["authors"] = authors_weight solution["fitness"] = best_fitness solution["bits"] = self.bits solution["generations"] = self.generations return solution
def aceComparison(elites): supremes = [] for i in uniq_attack: space = [] jail = [] for j in elites: if j[-1] == i: space.append(j) global ace ace = tools.selBest(space, 1) ace = ace[0] if fitnessDiff_opt == True: for idx, ind in enumerate(space): if (((ace.fitness.values[0] - ind.fitness.values[0]) <= fitnessDiff_value) and (idx > 0)): jail.append(ind) for ind in jail: space.remove(ind) if matchEliminate_opt == True: jail = [] for idx, ind in enumerate(space): if matchEliminate(ace, ind) and ind != ace: jail.append(ind) for ind in jail: space.remove(ind) for i in space: supremes.append(i) return supremes
def example_nevzpominam(): # Creating appropriate type creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) # Initialization IND_SIZE = 100 toolbox = base.Toolbox() toolbox.register("attr_bool", random.randint, 0, 1) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=IND_SIZE) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", evalOneMax) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) population = toolbox.population(n=300) NGEN=40 for gen in range(NGEN): offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) top10 = tools.selBest(population, k=10)
def main(): NGEN = 10 MU = 25 LAMBDA = 25 CXPB = 0.7 MUTPB = 0.2 random.seed(60) print("Beginning Initial Learning\n") apriori.learn(MIN_SUPPORT_THRESHOLD, MIN_CONF_THRESHOLD, DEFAULT_COVERAGE_THRESHOLD, verbose = True) print("\n\nInitial Learning complete") pop = toolbox.population(n=MU) hof = tools.ParetoFront() stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean, axis=0) stats.register("std", numpy.std, axis=0) stats.register("min", numpy.min, axis=0) stats.register("max", numpy.max, axis=0) result = algorithms.eaMuPlusLambda(pop, toolbox, MU, LAMBDA, CXPB, MUTPB, NGEN, stats, halloffame=hof) best_ind = tools.selBest(pop, 1)[0] logbook = result[1] print("Best individual found using GA is %s, %s" % (best_ind, best_ind.fitness.values)) return logbook.select("gen", "avg", "min", "max")
def selElites(pop): #Selector function """ Needs **UPDATE** The basic idea of this selector is to: 1. Accept the generated individuals 2. Categorize individuals into different attack type lists 3. Then append them back together to pass on as elites for the next generation. """ attkTypes = len(attkUniqs) # 4, Numbers of attacks in integer attkPop = [] elitesSub = [] elitesAll = [] for i in xrange(attkTypes): #create lists within the attkPop list attkPop.append([]) #equals to the number of attkTypes for i in xrange(attkTypes): for j, k in enumerate(pop): if k[-1] == attkUniqs[i]: #if last field is the same attack attkPop[i].append(k) #type then add to the attkPop for i in attkPop: elitesSub.append(tools.selBest(i, elitesNo)) for i in elitesSub: #appending all elites to elitesAll list i = list(i for i,_ in itertools.groupby(i)) #eliminate duplicate elites by attk type for j in i: elitesAll.append(j) #for i in elitesAll: # i = list(i for i,_ in itertools.groupby(i)) return elitesAll #This will be returned to create part of new
def compose(params): global window, chords_in_vector start = time() pop_size = 35 # int(params[0]) num_gens = 65 # int(params[1]) tourn_size = int(params[0]) ind_pb = params[1] cx_pb = params[2] mut_pb = params[3] creator.create("FitnessMulti", base.Fitness, weights=(-1.0, 1.0)) creator.create("Individual", list, fitness=creator.FitnessMulti) toolbox = base.Toolbox() IND_SIZE = chords_in_vector - len(window) toolbox.register("attr_chord", cg.generate_chord) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_chord, n=IND_SIZE) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", predict) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", mutate_individual, indpb=ind_pb) toolbox.register("select", tools.selTournament, tournsize=tourn_size) population = toolbox.population(n=pop_size) NGEN = num_gens for gen in range(NGEN): offspring = algorithms.varAnd(population, toolbox, cxpb=cx_pb, mutpb=mut_pb) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) top = tools.selBest(population, k=1)[0] np.set_printoptions(threshold=np.nan, suppress=True) #pprint("%s, %s" % (window, top)) #pprint(predict(top)) score = predict(top) end = time() run_time = end - start #time_dist = power(absolute(20 - run_time), 2) + 1 #f = -log(score[1] / time_dist) f = -log(score[1]) * 100000000 print(params) print("{:2.10f}".format(f)) results.append([list(params), f]) return f
def select_nextGen(self): """ Selects the components for the next generation """ #TODO: Complete this function next_gen_pop = dict(); model_pick = int(self.params['percentNextGen'] * self.params['model_pop_size']); conn_pick = int(self.params['percentNextGen'] * self.params['conn_pop_size']); ##Select node next_gen_pop['node_pop'] = self.pop['node_pop']; #move all to next generation ##Select weights next_gen_pop['connWeights_IH_pop'] = tools.selBest(self.pop['connWeights_IH_pop'],conn_pick); next_gen_pop['connWeights_HH_pop'] = tools.selBest(self.pop['connWeights_HH_pop'],conn_pick); next_gen_pop['connWeights_HO_pop'] = tools.selBest(self.pop['connWeights_HO_pop'],conn_pick); ##Select connectivity next_gen_pop['connActive_IH_pop'] = tools.selBest(self.pop['connActive_IH_pop'],conn_pick); next_gen_pop['connActive_HH_pop'] = tools.selBest(self.pop['connActive_HH_pop'],conn_pick); next_gen_pop['connActive_HO_pop'] = tools.selBest(self.pop['connActive_HO_pop'],conn_pick); ##select model next_gen_pop['model_pop'] = tools.selBest(self.pop['model_pop'],model_pick); return next_gen_pop;
def learn(self): weights = {} population = self.toolbox.population(n=FeatureWeightLearner.POPULATION) NGEN = FeatureWeightLearner.GENERATIONS for gen in range(NGEN): offspring = algorithms.varAnd(population, self.toolbox, cxpb=0.5, mutpb=0.1) fits = self.toolbox.map(self.toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = self.toolbox.select(offspring, k=len(population)) top10 = tools.selBest(population, k=10) best = tools.selBest(population, k=1)[0] #print(top10) revisions_weight, fixes_weight, authors_weight = FeatureWeightLearner.decode_individual(best) weights["revisions"] = revisions_weight weights["fixes"] = fixes_weight weights["authors"] = authors_weight return weights
def main(): pop = toolbox.population(n=50)#染色體個數 print(pop) CXPB, MUTPB, NGEN = 0.5, 0.2, 40#交配率,突變率,迭代數 ''' # CXPB is the probability with which two individuals # are crossed # # MUTPB is the probability for mutating an individual # # NGEN is the number of generations for which the # evolution runs ''' # Evaluate the entire population fitnesses = map(toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit #print(ind.fitness.values ) print(" Evaluated %i individuals" % len(pop)) print("-- Iterative %i times --" % NGEN) for g in range(NGEN): #if g % 1 == 0: #print("-- Generation %i --" % g) # Select the next generation individuals選擇子代 offspring = toolbox.select(pop, len(pop)) # Clone the selected individuals offspring = list(map(toolbox.clone, offspring)) # Change map to list,The documentation on the official website is wrong # Apply crossover and mutation on the offspring子代的基因交叉、變異產生新的子代 for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) 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 print(ind.fitness.values) # The population is entirely replaced by the offspring pop[:] = offspring print("-- End of (successful) evolution --") best_ind = tools.selBest(pop, 1)[0] return best_ind, best_ind.fitness.values # return the result:Last individual,The Return of Evaluate function
def output_results(pop, logbook): print logbook print '\n' for p in pop: for i in individual_to_tollgates(p): print i print '\nBEST\n\n' for i in individual_to_tollgates(tools.selBest(pop, 1)[0]): print i
def main(dictionary, g1, g2, g3): global features preprocess_data(dictionary, g1, g2, g3) data = pd.read_csv('student-mat-pre.csv', delimiter = ';') cols = list(data.columns) cols.remove('G1') cols.remove('G2') cols.remove('G3') for col in cols: data[col] = (data[col] - data[col].mean()) / data[col].std(ddof=0) data.to_csv('temp') features = [] with open('temp') as f: for index, line in enumerate(f): params = line.strip().split(',') if index != 0: for i in range(len(params)): params[i] = float(params[i]) features.append(params[1:-3]) features = features[1:len(features)] tree_c = DecisionTreeClassifier(criterion='entropy') gnb_c = GaussianNB() creator.create('FitnessMax', base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register('bit', random.random) toolbox.register('individual', tools.initRepeat, creator.Individual, toolbox.bit, n=30) toolbox.register('population',tools.initRepeat, list, toolbox.individual, n=200) toolbox.register('evaluate', fitness_value) toolbox.register('mate', tools.cxUniform, indpb=0.1) toolbox.register('mutate', tools.mutFlipBit, indpb=0.05) toolbox.register('select', tools.selNSGA2) population = toolbox.population() fits = toolbox.map(toolbox.evaluate, population) for fit, ind in zip(fits, population): ind.fitness.values = (fit,) for gen in range(100): offspring = algorithms.varOr(population, toolbox, lambda_ = 10, cxpb=0.5, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = (fit,) population = toolbox.select(offspring+population, k=20) individual = tools.selBest(population, k=1)
def evolve_machines(POP): population = POP offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, population) for fit, ind in zip(fits, population): ind.fitness = fit population = toolbox.select(population, k=len(population)) top10 = tools.selBest(population, k=10) return population
def evaluate_possible_solutions(self): invalid_ind = [ind for ind in self.offspring if not ind.fitness.valid] fitnesses = map(self.toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit if self.offspring != []: self.pop[:] = self.offspring self.steady_state_crossover() self.best_solution = tools.selBest(self.pop, 1)[0]
def loop(pop, c_prob, m_prob, max_loop): for i in xrange(max_loop): # 最良個体の表示 best = tools.selBest(pop, 1)[0] print i, "世代:", best.fitness.values # 次世代の集団 next_pop = toolbox.select(pop, len(pop)) next_pop = list(map(toolbox.clone, next_pop)) # 交叉 for i in xrange(len(next_pop)): for j in xrange(i, len(next_pop)): if random.random() < c_prob: toolbox.crossover(next_pop[i], next_pop[j]) # 突然変位 for x in next_pop: if random.random() < m_prob: toolbox.mutate(x) # 評価 evaluate_pop(next_pop) # 世代交代 pop = next_pop return tools.selBest(pop, 1)[0] # 最良個体を返す
def getBestIndividual(self): """Determines the best individual. """ best_ind = tools.selBest(self.population, 1)[0] # If the first or the end point are not presents the original line should be returned if best_ind.fitness.values[0] > len(self.original.coords): # print "Returning the original" return self.original.to_wkb() wkb = self.createSimplifiedLine(best_ind) return wkb
def evolve(toolbox): pop = toolbox.population(n = POPULATION_SIZE) fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit for g in range(NGEN): print("-- Generation %i --" % g) elite = toolbox.elite(pop) elite = list(map(toolbox.clone, elite)) offspring = toolbox.select(pop, POPULATION_SIZE-2) offspring = list(map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2],offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values offspring = elite + offspring # 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 if len(offspring) > 0: pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) if min(fits) < 2: break return tools.selBest(pop, k = 1)[0]
def main(): # Generate the population pop = toolBox.toolbox.population(n=POPULATION_SIZE) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolBox.toolbox, cxpb=CROSS_OVER_PROB, mutpb=MUTATION_PROB, ngen=NO_OF_GENERATION, stats=stats, halloffame=hof, verbose=True) ## Evaluate the entire population #fitnesses = list(map(toolBox.toolbox.evaluate, pop)) #for ind, fit in zip(pop, fitnesses): # ind.fitness.values = fit # Iterate trough a number of generations # for g in range(NGEN): # print("-- Generation %i --" % g) # # Select individuals based on their fitness # offspring = toolBox.toolbox.select(pop, len(pop)) # # Cloning those individuals into a new population # offspring = list(map(toolBox.toolbox.clone, offspring)) # # Calling the crossover function # crossover(offspring) # mutation(offspring) # invalidfitness(offspring) # The Best Individual found best_ind = tools.selBest(pop, 1)[0] individual = sorted(best_ind, key=itemgetter(3)) individual = sorted(individual, key=itemgetter(0)) #print "InsertBusTrip and TimeTable......" print("Best individual is %s, %s" % (individual, best_ind.fitness.values)) print ("Length of best individual: " + str(len(best_ind))) fitnessClass = Fitness() timetable = fitnessClass.genTimetable(best_ind) databaseClass = DB() #databaseClass.insertBusTrip(timetable) evaluate_timetable.eval(best_ind)
def test_cma(): NDIM = 5 strategy = cma.Strategy(centroid=[0.0]*NDIM, sigma=1.0) toolbox = base.Toolbox() toolbox.register("evaluate", benchmarks.sphere) toolbox.register("generate", strategy.generate, creator.__dict__[INDCLSNAME]) toolbox.register("update", strategy.update) pop, _ = algorithms.eaGenerateUpdate(toolbox, ngen=100) best, = tools.selBest(pop, k=1) assert best.fitness.values < (1e-8,), "CMA algorithm did not converged properly."
def eaSimple(population, toolbox, cxpb, mutpb, ngen, stats=None, halloffame=None, verbose=__debug__): logbook = tools.Logbook() logbook.header = ['gen', 'nevals'] + (stats.fields if stats else []) # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in population if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit if halloffame is not None: halloffame.update(population) record = stats.compile(population) if stats else {} logbook.record(gen=0, nevals=len(invalid_ind), **record) if verbose: print logbook.stream # Begin the generational process gen = 1 while evalNumThreaten(tools.selBest(population, k=1)[0])[0] != 0: gen += 1 # Select the next generation individuals offspring = toolbox.select(population, len(population)) # Vary the pool of individuals offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb) # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit # Update the hall of fame with the generated individuals if halloffame is not None: halloffame.update(offspring) # Replace the current population by the offspring population[:] = offspring # Append the current generation statistics to the logbook record = stats.compile(population) if stats else {} logbook.record(gen=gen, nevals=len(invalid_ind), **record) if verbose: print logbook.stream print 'total generations is',gen return population, logbook
def run(self): meta_spec = self.experiment.spec['meta'] ray.init(**meta_spec.get('resources', {})) max_generation = meta_spec['max_generation'] pop_size = meta_spec['max_trial'] or calc_population_size(self.experiment) logger.info(f'EvolutionarySearch max_generation: {max_generation}, population size: {pop_size}') trial_data_dict = {} config_hash = {} # config hash_str to trial_index toolbox = self.init_deap() population = toolbox.population(n=pop_size) for gen in range(1, max_generation + 1): logger.info(f'Running generation: {gen}/{max_generation}') ray_id_to_config = {} pending_ids = [] for individual in population: config = dict(individual.items()) hash_str = util.to_json(config, indent=0) if hash_str not in config_hash: trial_index = self.experiment.info_space.tick('trial')['trial'] config_hash[hash_str] = config['trial_index'] = trial_index ray_id = run_trial.remote(self.experiment, config) ray_id_to_config[ray_id] = config pending_ids.append(ray_id) individual['trial_index'] = config_hash[hash_str] trial_data_dict.update(get_ray_results(pending_ids, ray_id_to_config)) for individual in population: trial_index = individual.pop('trial_index') trial_data = trial_data_dict.get(trial_index, {'fitness': 0}) # if trial errored individual.fitness.values = trial_data['fitness'], preview = 'Fittest of population preview:' for individual in tools.selBest(population, k=min(10, pop_size)): preview += f'\nfitness: {individual.fitness.values[0]}, {individual}' logger.info(preview) # prepare offspring for next generation if gen < max_generation: population = toolbox.select(population, len(population)) # Vary the pool of individuals population = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.5) ray.worker.cleanup() return trial_data_dict
def showResults(World): ValidationDataset =\ promoterz.evaluation.gekko.globalEvaluationDataset(World.EnvironmentParameters, World.genconf.deltaDays, World.genconf.proofSize) for LOCALE in World.locales: LOCALE.population = [ ind for ind in LOCALE.population if ind.fitness.valid ] B = World.genconf.finaltest['NBBESTINDS'] BestIndividues = tools.selBest(LOCALE.population,B) Z = min(World.genconf.finaltest['NBADDITIONALINDS'], len(LOCALE.population)-B) Z = min(0, Z) print("Selecting %i+%i individues, random test;" % (B,Z)) AdditionalIndividues = promoterz.evolutionHooks.Tournament(LOCALE.population, Z, Z*2) print("%i selected;" % len(AdditionalIndividues)) AdditionalIndividues = [ x for x in AdditionalIndividues\ if x not in BestIndividues ] FinalIndividues = BestIndividues + AdditionalIndividues print("%i selected;" % len(FinalIndividues)) for FinalIndividue in FinalIndividues: proof = stratSettingsProofOfViability AssertFitness, FinalProfit = proof(World, FinalIndividue, ValidationDataset) print("Testing Strategy:\n") if AssertFitness or FinalProfit > 50: print("Following strategy is viable.") else: print("Strategy Fails.") FinalIndividueSettings = World.tools.constructPhenotype( FinalIndividue) Show = json.dumps(FinalIndividueSettings, indent=2) logInfo("~" * 18) logInfo(" %.3f final profit ~~~~" % FinalProfit) print(" -- Settings for Gekko config.js -- ") print(Show) print(" -- Settings for Gekko --ui webpage -- ") logInfo(pasteSettingsToUI(FinalIndividueSettings)) print("\nRemember to check MAX and MIN values for each parameter.") print("\tresults may improve with extended ranges.")
def main(): pop = toolbox.population(n=50) print(pop) CXPB, MUTPB, NGEN = 0.5, 0.2, 40 fitnesses = map(toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit #print(ind.fitness.values ) print(" Evaluated %i individuals" % len(pop)) print("-- Iterative %i times --" % NGEN) for g in range(NGEN): offspring = toolbox.select(pop, len(pop)) offspring = list(map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values 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 print(ind.fitness.values) pop[:] = offspring print("-- End of (successful) evolution --") best_ind = tools.selBest(pop, 1)[0] return best_ind, best_ind.fitness.values
def main(): global snake global pset ## THIS IS WHERE YOUR CORE EVOLUTIONARY ALGORITHM WILL GO # #random.seed(318) pop = toolbox.population(n=POP_SIZE) hof = tools.HallOfFame(5) stats_fit = tools.Statistics(lambda ind: ind.fitness.values) stats_size = tools.Statistics(len) mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size) mstats.register("avg", lambda val: round(numpy.mean(val), 2)) mstats.register("std", lambda val: round(numpy.std(val), 2)) mstats.register("min", numpy.min) mstats.register("max", numpy.max) start = timer() try: pop, log = algorithms.eaSimple( pop, toolbox, CRX_PB, # CHANCE OF CROSSOVER MUT_PB, # CHANCE OF MUTATION TOTAL_GENS, # NO Generations halloffame=hof, verbose=True, stats=mstats) except KeyboardInterrupt: pool.terminate() pool.join() raise KeyboardInterrupt end = timer() # Total score as.. # Attempt parsimony length prevention first best = tools.selBest(pop, 1) for ind in best: runs = [] for run in range(500): #displayStrategyRun(ind) runs.append(runGame(ind)[0]) print("Max: " + str(max(runs))) print("Mean: " + str(numpy.mean(runs))) print("St.dv: " + str(numpy.std(runs))) nodes, edges, labels = gp.graph(ind) g = nx.Graph() g.add_nodes_from(nodes) g.add_edges_from(edges) pos = nx.graphviz_layout(g, prog="dot") nx.draw_networkx_nodes(g, pos) nx.draw_networkx_edges(g, pos) nx.draw_networkx_labels(g, pos, labels) plt.show() while True: #displayRunPythonista(ind) displayStrategyRun(ind)
def onGA(fleet: Fleet, hp: HyperParameters, critical_points: Dict, save_to: str = None, best_ind: IndividualType = None, savefig=False): customers_to_visit = { ev_id: fleet.vehicles[ev_id].assigned_customers for ev_id in fleet.vehicles_to_route } indices = block_indices(customers_to_visit, hp.r) # Fitness objects creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", list, fitness=creator.FitnessMin, feasible=False, acceptable=False) # Toolbox toolbox = base.Toolbox() toolbox.register("individual", random_individual, indices=indices, starting_points=critical_points, customers_to_visit=customers_to_visit, charging_stations=fleet.network.charging_stations, allowed_charging_operations=hp.r) toolbox.register("evaluate", fitness, indices=indices, critical_points=critical_points, fleet=fleet, hp=hp) toolbox.register("mate", crossover, indices=indices, allowed_charging_operations=hp.r, index=None) toolbox.register("mutate", mutate, indices=indices, starting_points=critical_points, customers_to_visit=customers_to_visit, charging_stations=fleet.network.charging_stations, allowed_charging_operations=hp.r, index=None) toolbox.register("select", tools.selTournament, tournsize=hp.tournament_size) toolbox.register("select_worst", tools.selWorst) toolbox.register("decode", decode, indices=indices, critical_points=critical_points, fleet=fleet, hp=hp) # BEGIN ALGORITHM t_init = time.time() # Random population if best_ind is None: pop = [ creator.Individual(toolbox.individual()) for i in range(hp.num_individuals) ] else: pop = [creator.Individual(best_ind)] pop += [ creator.Individual(toolbox.individual()) for i in range(hp.num_individuals - 1) ] # Evaluate the initial population and get fitness of each individual for k, ind in enumerate(pop): fit, feasible, acceptable = toolbox.evaluate(ind) ind.fitness.values = (fit, ) ind.feasible = feasible ind.acceptable = acceptable print(f' Evaluated {len(pop)} individuals') bestOfAll = tools.selBest(pop, 1)[0] print( f"Best individual : {bestOfAll}\n Fitness: {bestOfAll.fitness.wvalues[0]} Feasible: {bestOfAll.feasible}" ) # These will save statistics cs_capacity = fleet.network.nodes[ fleet.network.charging_stations[0]].capacity opt_data = GenerationsData([], [], [], [], [], [], fleet, hp, bestOfAll, bestOfAll.feasible, bestOfAll.acceptable, len(fleet), cs_capacity) print("################ Start of evolution ################") # Begin the evolution for g in range(hp.max_generations): # A new generation print(f"-- Generation {g}/{hp.max_generations} --") opt_data.generations.append(g) # Select the best individuals, if given if hp.elite_individuals: best_individuals = list( map(toolbox.clone, tools.selBest(pop, hp.elite_individuals))) # Select and clone the next generation individuals offspring = toolbox.select(pop, len(pop)) offspring = list(map(toolbox.clone, offspring)) # Mutation for mutant in offspring: if np.random.random() < hp.MUTPB: toolbox.mutate(mutant) del mutant.fitness.values # Crossover for child1, child2 in zip(offspring[::2], offspring[1::2]): if np.random.random() < hp.MUTPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values # Evaluate the individuals with invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] for ind in invalid_ind: fit, feasible, acceptable = toolbox.evaluate(ind) ind.fitness.values = (fit, ) ind.feasible = feasible ind.acceptable = acceptable print(f' Evaluated {len(invalid_ind)} individuals') # The population is entirely replaced by a sorted offspring pop[:] = offspring pop[:] = tools.selBest(pop, len(pop)) # Insert best individuals from previous generation if hp.elite_individuals: pop[:] = best_individuals + pop[:-hp.elite_individuals] # Update best individual bestInd = tools.selBest(pop, 1)[0] if bestInd.fitness.wvalues[0] > bestOfAll.fitness.wvalues[0]: bestOfAll = bestInd # Real-time info print( f"Best individual : {bestInd}\n Fitness: {bestInd.fitness.wvalues[0]} Feasible: {bestInd.feasible}" ) worstInd = tools.selWorst(pop, 1)[0] print( f"Worst individual : {worstInd}\n Fitness: {worstInd.fitness.wvalues[0]} Feasible: {worstInd.feasible}" ) print( f"Curr. best-of-all: {bestOfAll}\n Fitness: {bestOfAll.fitness.wvalues[0]} Feasible: {bestOfAll.feasible}" ) # Statistics fits = [sum(ind.fitness.wvalues) for ind in pop] mean = np.average(fits) std = np.std(fits) print(f"Max {max(fits)}") print(f"Min {min(fits)}") print(f"Avg {mean}") print(f"Std {std}") opt_data.best_fitness.append(-max(fits)) opt_data.worst_fitness.append(-min(fits)) opt_data.average_fitness.append(mean) opt_data.std_fitness.append(std) opt_data.best_individuals.append(bestInd) print() t_end = time.time() print("################ End of (successful) evolution ################") algo_time = t_end - t_init print('Algorithm time:', algo_time) fit, feasible, acceptable = toolbox.evaluate(bestOfAll) fit, feasible, acceptable = toolbox.evaluate(bestOfAll) routes = toolbox.decode(bestOfAll) opt_data.bestOfAll = bestOfAll opt_data.feasible = feasible opt_data.acceptable = acceptable opt_data.algo_time = algo_time opt_data.fleet = fleet if save_to: path = save_to try: os.mkdir(path) except FileExistsError: pass opt_data.save_opt_data(path, savefig=savefig) for r in routes.values(): L = r[0][1] if sum([1 for Lk in L if Lk < 0]): print('negative') return routes, opt_data, toolbox
if __name__ == "__main__": # random.seed(64) N_POPULATION = N_PROCESSES pool = multiprocessing.Pool(processes=N_PROCESSES) toolbox.register("map", pool.map) pop = toolbox.population(n=N_POPULATION) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", np.mean) stats.register("std", np.std) stats.register("min", np.min) stats.register("max", np.max) algorithms.eaSimple(pop, toolbox, cxpb=0.3, mutpb=0.1, ngen=N_GENERATIONS, stats=stats, halloffame=hof, verbose=0) pool.close() best_ind = tools.selBest(pop, 1)[0] # print("Best individual of current population is %s, %s" % (best_ind, best_ind.fitness.values)) # print("Best individual ever is %s, %s" % (hof[0],hof[0].fitness.values)) if N_GENERATIONS > 20: with open(r'output/results_ga_3.txt', 'a') as output_file: output_file.write("\n" + str(best_ind.fitness.values[0]) + " " + str(N_BLOCKS) + " " + str(N_GENERATIONS) + " " + str(DAYS) + " " + str(time.ctime()) + " " + str(hof[0]))
def run_algorithm(self, seed): # Set up custom hall of fame to keep track of the top chromosomes and their generations hall_of_fame = hof.HallOfFame(self.HOF_SIZE) # set up standard hall of fame that comes with DEAP hall_of_fame_with_dupes = tools.HallOfFame(self.HOF_SIZE) # Get date and time date_time = datetime.datetime.now().strftime("%m-%d_%I%M%p") # print out to file file_name = date_time + '.txt' sys.stdout = open(file_name, 'w') print 'Seed:', seed i = 0 while i < self.GENERATIONS and not self.isConverged: i += 1 print('--------------------------------' + 'Generation: ' + str(i) + '-----------------------------------') # evaluate each chromosome in the population and assign its fitness score for index, x in enumerate(self.population): # update the chromosome, write out to JSON tactical file chromosome_parameters.update_chromosome( x[0].value, x[1].value, x[2].value, x[3].value, x[4].value) # use Ace0 to evaluate the chromosome x.fitness.values = helper.evaluate(self.repetitions) # Select the best chromosome from this generation and display it best_chromosome = tools.selBest(self.population, 1)[0] print "Best chromosome is: ", helper.list_to_string( best_chromosome), best_chromosome.fitness.values # Select worst chromosome and display worst_chromosome = tools.selWorst(self.population, 1)[0] print "Worst chromosome is: ", helper.list_to_string( worst_chromosome), worst_chromosome.fitness.values # Get the over all fitness values sum_fits = sum(ind.fitness.values[0] for ind in self.population) average_fitness = sum_fits / self.POP print 'Generation average fitness: ', average_fitness # save best and average fitness to plot lists self.plot_best_fitness.append(best_chromosome.fitness.values) self.plot_average_fitness.append(average_fitness) self.plot_worst_fitness.append(worst_chromosome.fitness.values) # Update the hall of fame to track the best chromosomes from each generation hall_of_fame.update(self.population, i) hall_of_fame_with_dupes.update(self.population) # hall_of_fame.print_hof() # this is where we evolve the population # Select the next generation individuals offspring = self.toolbox.select(self.population, len(self.population)) # Clone the selected individuals so we can apply crossover offspring = list(map(self.toolbox.clone, offspring)) # Apply crossover on the offspring for child1, child2 in zip(offspring[::2], offspring[::-2]): if random.random() < self.CROSSOVER_PROBABILITY: # mate the two children self.toolbox.mate(child1, child2) # Apply mutation on the offspring for mutant in offspring: if random.random() < self.MUTATION_PROBABILITY: # print 'Mutated Chromosome before: ', helper.list_to_string(mutant) for index, x in enumerate(mutant): mutant[index].value = helper.convert_range( mutant[index].value, mutant[index].min, mutant[index].max) self.toolbox.mutate(mutant) for index, x in enumerate(mutant): mutant[index].value = helper.change_back( mutant[index].value, mutant[index].min, mutant[index].max) helper.bounds_check(mutant[index]) # print 'Mutated Chromosome after: ', helper.list_to_string(mutant) # The population is entirely replaced by the offspring self.population[:] = offspring if float(best_chromosome.fitness.values[0] ) - average_fitness < 0.0001: self.converge_tracker += 1 if self.converge_tracker >= self.converge_tracker_max: print 'CONVERGED' self.isConverged = True else: self.converge_tracker = 0 # # Elitism self.population[0] = hall_of_fame_with_dupes[0] print( '-------------------------------------Hall Of Fame Regular----------------------------------------' ) for chromosomes in hall_of_fame_with_dupes: print 'Chromosome: ', helper.list_to_string( chromosomes), 'Fitness: ', chromosomes.fitness print( '-------------------------------------Hall Of Fame with Gen----------------------------------------' ) hall_of_fame.print_hof() print( '-------------------------------------Stats----------------------------------------' ) print("Pop size: " + str(self.POP)) print("Generations: " + str(self.GENERATIONS)) print("Crossover Prob: " + str(self.CROSSOVER_PROBABILITY)) print("Mutation Prob: " + str(self.MUTATION_PROBABILITY)) # Select the best chromosome from this generation and display it best_chromosome = tools.selBest(self.population, 1)[0] print "Best chromosome is: ", helper.list_to_string( best_chromosome), best_chromosome.fitness.values # Select worst chromosome and display worst_chromosome = tools.selWorst(self.population, 1)[0] print "Worst chromosome is: ", helper.list_to_string( worst_chromosome), worst_chromosome.fitness.values # Get the over all fitness values sum_fits = sum(ind.fitness.values[0] for ind in self.population) average_fitness = sum_fits / self.POP print 'Generation average fitness: ', average_fitness title = 'Seed: ' + str(seed) visualization.draw_plot(title, self.plot_average_fitness, self.plot_best_fitness, self.plot_worst_fitness, 'average per generation', 'best fitness', 'worst fitness', 'generation', 'fitness', 1, 250, 150, date_time) del creator.fitness del creator.Tactic
def parameter_tuning(X_train, feat_vec, seizure_times, f_s, window_length, window_overlap): #creating types creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", list, fitness=creator.FitnessMax) toolbox = base.Toolbox() t_per_min = 10 * f_s t_per_max = 200 * f_s #defining genes #ranges are given by Gardner paper toolbox.register("attr_v", random.uniform, .02, .2) toolbox.register("attr_g", random.uniform, .25, 10) toolbox.register("attr_p", random.uniform, .3, 1) toolbox.register("attr_N", random.uniform, 10, 100) toolbox.register("attr_T", random.uniform, t_per_min, t_per_max) #defining an individual as a group of the five genes toolbox.register("individual", tools.initCycle, creator.Individual, (toolbox.attr_v, toolbox.attr_g, toolbox.attr_p, toolbox.attr_N, toolbox.attr_T), 1) #defining the population as a list of individuals toolbox.register("population", tools.initRepeat, list, toolbox.individual) # register the fitness function toolbox.register( "evaluate", fitness_fn(X_train, feat_vec, seizure_times, f_s, window_length, window_overlap)) MIN = [0.02, 0.25, 0.3, 10, t_per_min] MAX = [.2, 10, 1, 100, t_per_max] # register the crossover operator # other options are: cxOnePoint, cxUniform (requires an indpb input, probably can just use CXPB) # there are others, more particular than these options toolbox.register("mate", tools.cxTwoPoint) toolbox.decorate("mate", within_constraints(MIN, MAX)) # register a mutation operator with a probability to mutate of 0.05 # can change: mu, sigma, and indpb # there are others, more particular than this toolbox.register("mutate", tools.mutGaussian, mu=1, sigma=10, indpb=0.03) toolbox.decorate("mutate", within_constraints(MIN, MAX)) # operator for selecting individuals for breeding the next generation # other options are: tournament: randonly picks tournsize out of population, chosses fittest, and has that be # a parent. continues until number of parents is equal to size of population. # there are others, more particular than this toolbox.register("select", tools.selTournament, tournsize=3) #toolbox.register("select", tools.selRoulette) #create an initial population of size 20 pop = toolbox.population(n=20) # CXPB is the probability with which two individuals are crossed CXPB = 0.3 # MUTPB is the probability for mutating an individual MUTPB = 0.5 # NGEN is the number of generations until final parameters are picked NGEN = 40 print("Start of evolution") # find the fitness of every individual in the population fitnesses = list(map(toolbox.evaluate, pop)) #assigning each fitness to the individual it represents for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit #defining variables to keep track of best indivudals throughout species best_species_genes = tools.selBest(pop, 1)[0] best_species_value = best_species_genes.fitness.values best_gen = 0 next_mean = 1 prev_mean = 0 #start evolution for g in range(NGEN): if abs(next_mean - prev_mean) > 0.005: prev_mean = next_mean # Select the next generation's parents parents = toolbox.select(pop, len(pop)) # Clone the parents and call them offspring: crossover and mutation will be performed below offspring = list(map(toolbox.clone, parents)) # Apply crossover to children in offspring with probability CXPB for child1, child2 in zip(offspring[::2], offspring[1::2]): # cross two individuals with probability CXPB if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values # Apply mutation to children in offspring with probability MUTPB for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values # Find the fitnessess for all the children for whom fitness changed 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 # Offspring becomes the new population pop[:] = offspring #updating best species values if max(fitnesses): if max(fitnesses) > best_species_value: best_species_genes = tools.selBest(pop, 1)[0] best_species_value = best_species_genes.fitness.values best_gen = g best_next_obj = max(fitnesses) fits = [ind.fitness.values[0] for ind in pop] length = len(pop) next_mean = sum(fits) / length best_ind = tools.selBest(pop, 1)[0] print("Best individual in final population is %s with fitness value %s" % (best_ind, best_ind.fitness.values)) print( "Best individual in species is %s and occurred during generation %s with fitness %s" % (best_species_genes, best_gen, best_species_value)) return best_species_genes[0], best_species_genes[1], best_species_genes[ 2], best_species_genes[3], best_species_genes[4]
length = len(population) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 gensMin.append(min(fits)) gensMax.append(max(fits)) gensAvg.append(mean) gensStd.append(std) # print(" Min %s" % int(min(fits))) print(" Max %s" % int(max(fits))) # print(" Avg %s" % mean) # print(" Std %s" % std) population = toolbox.select(offspring, k=len(population)) topk = tools.selBest(population, k=1) #print(top10) for solution in topk: print("Pontos: %i/243" % int(fitnessFromDNA64(solution)[0])) printBoardFromDNA64(solution) print("") plt.subplot(111) plt.plot(gensMax, label="Max") plt.plot(gensAvg, label="Avg") plt.plot(gensMin, label="Min") plt.legend(bbox_to_anchor=(0.8, 0.0, 0.2, .102), loc=3, ncol=1, mode="expand", borderaxespad=0.)
def gaVRPTW(instName, unitCost, initCost, waitCost, delayCost, indSize, popSize, cxPb, mutPb, NGen, exportCSV=False, customizeData=False): if customizeData: jsonDataDir = os.path.join(BASE_DIR, 'data', 'json_customize') else: jsonDataDir = os.path.join(BASE_DIR, 'data', 'json') jsonFile = os.path.join(jsonDataDir, '%s.json' % instName) with open(jsonFile) as f: instance = load(f) creator.create('FitnessMax', base.Fitness, weights=(1.0, )) creator.create('Individual', list, fitness=creator.FitnessMax) toolbox = base.Toolbox() # Attribute generator toolbox.register('indexes', random.sample, range(1, indSize + 1), indSize) # Structure initializers toolbox.register('individual', tools.initIterate, creator.Individual, toolbox.indexes) toolbox.register('population', tools.initRepeat, list, toolbox.individual) # Operator registering toolbox.register('evaluate', evalVRPTW, instance=instance, unitCost=unitCost, initCost=initCost, waitCost=waitCost, delayCost=delayCost) toolbox.register('select', tools.selRoulette) toolbox.register('mate', cxPartialyMatched) toolbox.register('mutate', mutInverseIndexes) pop = toolbox.population(n=popSize) # Results holders for exporting results to CSV file csvData = [] print 'Start of evolution' # Evaluate the entire population fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit print ' Evaluated %d individuals' % len(pop) # Begin the evolution for g in range(NGen): print '-- Generation %d --' % g # Select the next generation individuals offspring = toolbox.select(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 random.random() < cxPb: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < mutPb: toolbox.mutate(mutant) del mutant.fitness.values # Evaluate the individuals with an invalid fitness invalidInd = [ind for ind in offspring if not ind.fitness.valid] fitnesses = map(toolbox.evaluate, invalidInd) for ind, fit in zip(invalidInd, fitnesses): ind.fitness.values = fit print ' Evaluated %d individuals' % len(invalidInd) # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 print ' Min %s' % min(fits) print ' Max %s' % max(fits) print ' Avg %s' % mean print ' Std %s' % std # Write data to holders for exporting results to CSV file if exportCSV: csvRow = { 'generation': g, 'evaluated_individuals': len(invalidInd), 'min_fitness': min(fits), 'max_fitness': max(fits), 'avg_fitness': mean, 'std_fitness': std, } csvData.append(csvRow) print '-- End of (successful) evolution --' bestInd = tools.selBest(pop, 1)[0] #print 'Best individual: %s' % bestInd #print 'Fitness: %s' % bestInd.fitness.values[0] #printRoute(ind2route(bestInd, instance)) #print 'Total cost: %s' % (1 / bestInd.fitness.values[0]) # We need returning json, not print on console and/or writing csv return_json = {} our_order = bestInd[:] return_json['order'] = order_map(our_order) return_json['route'] = route_map(ind2route(bestInd, instance)) return_json['Fitness'] = bestInd.fitness.values[0] return_json['cost'] = 1 / bestInd.fitness.values[0] return return_json if exportCSV: csvFilename = '%s_uC%s_iC%s_wC%s_dC%s_iS%s_pS%s_cP%s_mP%s_nG%s.csv' % ( instName, unitCost, initCost, waitCost, delayCost, indSize, popSize, cxPb, mutPb, NGen) csvPathname = os.path.join(BASE_DIR, 'results', csvFilename) print 'Write to file: %s' % csvPathname makeDirsForFile(pathname=csvPathname) if not exist(pathname=csvPathname, overwrite=True): with open(csvPathname, 'w') as f: fieldnames = [ 'generation', 'evaluated_individuals', 'min_fitness', 'max_fitness', 'avg_fitness', 'std_fitness' ] writer = DictWriter(f, fieldnames=fieldnames, dialect='excel') writer.writeheader() for csvRow in csvData: writer.writerow(csvRow)
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 print(" Evaluated %i individuals" % len(invalid_ind)) # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 print("".join(tools.selBest(pop, 1)[0])) print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % ("".join(best_ind), best_ind.fitness.values))
n=len(data)) toolbox.register("population", tools.initRepeat, list, toolbox.individual) population = toolbox.population(n=pop_size) NGEN = 500 best_fit = 0 best_gen = 0 differential = 30 start_time = time.time() for gen in range(NGEN): offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) current_gen_best_individual = tools.selBest(population, k=1)[0] current_gen_best_fit = current_gen_best_individual.fitness.values[0] if current_gen_best_fit > best_fit: best_individual = current_gen_best_individual best_fit = current_gen_best_fit best_gen = gen time_diff = time.time() - start_time results_list.append([ time_diff, best_individual.fitness.values[0], best_gen, best_individual ]) print(time_diff) print(best_individual.fitness.values[0], best_individual) print(results_list) with open("DEAP_results.csv", "w", newline="") as file: writer = csv.writer(file, delimiter=';') writer.writerows(results_list)
def evolve(predict_type, fitness_measure, trX, trY, max_layers=5, num_gens=10, gen_size=40, teX=[], teY=[], layer_types=[ 'relu', 'softplus', 'dropout', 'bias_add', 'sigmoid', 'tanh', 'none', 'normalize' ], layer_sizes=[0, 0, 10, 50, 100, 200, 500, 1000], end_types=[ 'sum', 'prod', 'min', 'max', 'mean', 'none', 'sigmoid', 'tanh' ], train_types=[ 'GradientDescent', 'GradientDescent', 'GradientDescent', 'Adagrad', 'Momentum', 'Adam', 'Ftrl', 'RMSProp' ], cross_prob=0.2, mut_prob=0.2, tourn_size=5, train_iters=5, squash_errors=True): ''' :param predict_type: String denoting the type of neural network to evolve. Two options: 'regression' and 'classification'. :param fitness_measure: String denoting the type of measurement to use for evaluating the performance of the network type. Options: - 'rmse': Root mean squared error between the predicted values and known values. Use for regression. - 'r_squared': Coefficient of determination for determining how well the data fits the model. Use for regression. - 'accuracy': Fraction of samples that were classified correctly. Use for classification, and can be used for multi-class classification. - 'sensitivity': Fraction of positive samples correctly identified as positive. Use for classification with two classes, and the second class is the positive class. - 'specificity': Fraction of negative samples correctly identified as negative. Use for classification with two classes, and the first class is the negative class. :param trX: Numpy array with input data to use for training. Will pull randomly from this array to create test and training sets. :param trY: Numpy array with output data to use for training. :param max_layers: Integer denoting the maximum number of layers that exist between the input and output layer. Set at 5 by default. :param num_gens: Number of generations to simulate. Set at 10 by default. :param gen_size: Number of individual members per generation. Set at 40 by default. :param teX: If a specific test set is desired, enter the input data here as a numpy array. :param teY: Test output data as a numpy array. :param layer_types: List of strings denoting the layer types possible to be used. Set to ['relu', 'softplus', 'dropout', 'bias_add', 'sigmoid', 'tanh', 'none', 'normalize'] by default. :param layer_sizes: List of integers denoting the layer sizes possible to be used. List must be of the same length as layer_types. Set to [0, 0, 10, 50, 100, 200, 500, 1000] by default. :param end_types: List of strings denoting the options for the type of transformation that gives the output. List must be of same length as layer_types. Set to ['sum', 'prod', 'min', 'max', 'mean', 'none', 'sigmoid', 'tanh'] by default. :param train_types: List of strings denoting the optimizer types possible to be used. List must be of same length as layer_types. Set to ['GradientDescent', 'GradientDescent', 'GradientDescent', 'Adagrad', 'Momentum', 'Adam', 'Ftrl', 'RMSProp'] by default. :param cross_prob: Float value denoting the probability of crossing the genetics of different individuals. Set at 0.2 by default. :param mut_prob: Float value denoting the probability of changing the genetics of a single individual. Set at 0.2 by default. :param tourn_size: Integer denoting the number of individuals to carry from each generation. Set at 5 by default. :param train_iters: Integer denoting the number of training iterations to use for each neural network. Set at 5 by default. :param squash_errors: Boolean value denoting whether to give a fail value if the network results in an error. Set to True by default. :return: List of strings giving the best net_type, string denoting the best optimizer, and Float value denoting the measure of the best network type. ''' # Checks that the different options have the same size. if not len(layer_types) == len(layer_sizes) == len(end_types) == len( train_types): print('Input attribute lists have different sizes.') return None # Gets the type of network to check. if predict_type == 'regression': predictor = tf_functions.Regresser elif predict_type == 'classification': predictor = tf_functions.Classifier end_types = ['softmax'] * len(layer_types) # Gets the type of success measure to use. if fitness_measure == 'rmse': measure = rmse creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", list, fitness=creator.FitnessMin) fail_val = np.inf elif fitness_measure == 'r_squared': measure = r_squared creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", list, fitness=creator.FitnessMax) fail_val = 0 elif fitness_measure == 'accuracy': measure = accuracy creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", list, fitness=creator.FitnessMax) fail_val = 0 elif fitness_measure == 'specificity': measure = specificity creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", list, fitness=creator.FitnessMax) fail_val = 0 elif fitness_measure == 'sensitivity': measure = sensitivity creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", list, fitness=creator.FitnessMax) fail_val = 0 toolbox = base.Toolbox() # Attribute generator. toolbox.register("attr_ints", random.randint, 0, len(layer_types) - 1) # Structure initializers. toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_ints, n=(max_layers * 2) + 2) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Operator registering. toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutUniformInt, low=0, up=len(layer_types) - 1, indpb=0.5) toolbox.register("select", tools.selTournament, tournsize=tourn_size) # Gets the initial population. pop = toolbox.population(n=gen_size) # Performs an initial selection. for ind in pop: # Turns the individual's genes into a net_type and an optimizer. net_type = [] for i in range(max_layers): net_type.append(layer_types[ind[i * 2]]) net_type.append(layer_sizes[ind[i * 2 + 1]]) net_type.append(end_types[ind[-2]]) # Splits into test and train if needed. if teX == []: ttrX, ttrY, tteX, tteY = test_train_split(trX, trY) else: ttrX, ttrY, tteX, tteY = trX, trY, teX, teY # Attempts to test network if errors to be squashed. if squash_errors: try: # Sets up, trains, and tests network. ind_predictor = predictor(net_type, optimizer=train_types[ind[-1]]) ind_predictor.train(ttrX, ttrY, train_iters) p = ind_predictor.predict(tteX) m = measure(p, tteY) ind_predictor.close() # Upon an error, gives the worst possible value. except: m = fail_val if np.isnan(m): m = fail_val else: ind_predictor = predictor(net_type, optimizer=train_types[ind[-1]]) ind_predictor.train(ttrX, ttrY, train_iters) p = ind_predictor.predict(tteX) m = measure(p, tteY) ind_predictor.close() ind.fitness.values = (m, ) # Begins the evolution. for g in range(num_gens): # Selects the next generation individuals. offspring = toolbox.select(pop, len(pop)) # Clones the selected individuals. offspring = list(map(toolbox.clone, offspring)) # Applies crossover and mutation on the offspring. for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < cross_prob: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < mut_prob: toolbox.mutate(mutant) del mutant.fitness.values # Evaluates the individuals with an invalid fitness. invalid_ind = [ind for ind in offspring if not ind.fitness.valid] for ind in invalid_ind: net_type = [] for i in range(max_layers): net_type.append(layer_types[ind[i * 2]]) net_type.append(layer_sizes[ind[i * 2 + 1]]) net_type.append(end_types[ind[-2]]) if squash_errors: try: ind_predictor = predictor(net_type, optimizer=train_types[ind[-1]]) ind_predictor.train(ttrX, ttrY, train_iters) p = ind_predictor.predict(tteX) m = measure(p, tteY) ind_predictor.close() except: m = fail_val if np.isnan(m): m = fail_val else: ind_predictor = predictor(net_type, optimizer=train_types[ind[-1]]) ind_predictor.train(ttrX, ttrY, train_iters) p = ind_predictor.predict(tteX) m = measure(p, tteY) ind_predictor.close() ind.fitness.values = (m, ) # The population is entirely replaced by the offspring. pop[:] = offspring # Gets the best individual remaining after best_ind = tools.selBest(pop, 1)[0] net_type = [] for i in range(max_layers): net_type.append(layer_types[best_ind[i * 2]]) net_type.append(layer_sizes[best_ind[i * 2 + 1]]) net_type.append(end_types[best_ind[-2]]) optimizer = train_types[best_ind[-1]] return net_type, optimizer, best_ind.fitness.values
pop, logbook = algorithms.eaMuCommaLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, cxpb=0.6, mutpb=0.3, ngen=500, stats=stats, halloffame=hof) return pop, logbook, hof pop, logbook, hof = main() best = tools.selBest(pop, 1)[0] G = get_G_from_individual(best) W = calculate_W(G, y) temp2 = G.dot(W) y_pred = np.argmax(temp2, axis = 1) y_pred = y_pred[:, np.newaxis] i = np.where(y_pred == classes)[0] j = np.where(y_pred != classes)[0] correct = X[i, :] incorrect = X[j, :] v, r = find_centers_radial(best) # c = plt.Circle((0,0), 2, facecolor='none', edgecolor='red')
def gaROADEF2003(instName,iniMethod = 'RS',indSize=0,popSize = 100, cxPb=0.5, mutPb=0.05, NGen=100, \ simple_flag = False, Mul_Flag = False, strip_flag =False,track_flag = False, exportCSV=False): ''' :param iniMethod: one from ['RS', 'RNDS', 'HRHS', 'FS'] :param simple_flag: True for no stereo constraint and pair constraint :param strip_flag: True for strip instance for customized data :param Mul_Flag: True for NSGA2 [Deb2002] Deb, Pratab, Agarwal, and Meyarivan, "A fast elitist non-dominated sorting genetic algorithm for multi-objective optimization: NSGA-II", 2002. ''' if strip_flag or track_flag: jsonDataDir = os.path.join(BASE_DIR, 'data', 'json_customize') jsonFile = os.path.join(jsonDataDir, '%s.json' % instName) with open(jsonFile) as f: instance = load(f) indSize = instance['strip-number'] else: jsonDataDir = os.path.join(BASE_DIR, 'data', 'json_ROADEF2003') jsonFile = os.path.join(jsonDataDir, '%s.json' % instName) with open(jsonFile) as f: instance = load(f) indSize = instance['strip-number'] * 2 creator.create('FitnessMax', base.Fitness, weights=(1.0, -1.0) if Mul_Flag else (1.0, )) creator.create('Individual', list, fitness=creator.FitnessMax) toolbox = base.Toolbox() # Attribute generator toolbox.register('indexes', random.sample, range(1, indSize + 1), indSize) # Evaluate define toolbox.register('evaluate', evalMulROADEF2003 if Mul_Flag else evalROADEF2003, \ simple_flag = simple_flag, strip_flag = strip_flag, \ track_flag = track_flag, instance=instance) # Structure initializers toolbox.register('individual', tools.initIterate, creator.Individual, toolbox.indexes) toolbox.register('heuristic', Heuristic, instance, simple_flag=simple_flag, strip_flag=strip_flag) toolbox.register('individual_heuri', tools.initIterate, creator.Individual, toolbox.heuristic) if iniMethod == 'RS': # STRATEGY 1: RS toolbox.register('population', tools.initRepeat, list, toolbox.individual) pop = toolbox.population(n=popSize) elif iniMethod == 'RNDS': # STRATEGY 2: RNDS toolbox.register('population', initRNDS, list, toolbox.individual, toolbox.evaluate) pop = toolbox.population(n=popSize) elif iniMethod == 'HRHS': # STRATEGY 3: HRHS toolbox.register('population', tools.initRepeat, list, toolbox.individual_heuri) pop = toolbox.population(n=popSize) elif iniMethod == 'FS': # STRATEGY 4 : FS toolbox.register('population', tools.initRepeat, list, toolbox.individual) omega = 2 pop_big = toolbox.population(n=omega * popSize) fitnesses = list(map(toolbox.evaluate, pop_big)) for ind, fit in zip(pop_big, fitnesses): ind.fitness.values = fit pop = tools.selBest(pop_big, popSize) else: print('Currently unsupported initialization method!') exit(1) # Operator registering toolbox.register('select', tools.selNSGA2 if Mul_Flag else tools.selRoulette) toolbox.register('mate', cxSameSitCopyFirst) toolbox.register('mutate', mutExchangeLocation) if iniMethod == 'RNDS': # check if the pop successfully initialized with RNDS fitnesses = list(map(toolbox.evaluate, pop)) for fitness in fitnesses: if fitnesses.count(fitness) > 1: print('***Error for same fitness value') # check the validity of pop initialization if not checkPopValidity(pop): print('not a valid pop initialization!!!') csvData = [] print('Start of evolution') # Evaluate the entire population fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit print(' Evaluated %d individuals' % len(pop)) # Begin the evolution for g in range(NGen): print('-- Generation %d --' % g) # Select the next generation individuals offspring = toolbox.select(pop, len(pop)) # Clone the selected individuals offspring = list(map(toolbox.clone, offspring)) # Apply crossover and mutation on the offspring for child1, child2, i in zip(offspring[::2], offspring[1::2], range(1, len(offspring), 2)): if random.random() < cxPb and child1 != child2: # print(offspring[i - 1], offspring[i]) child1_oldFit = 0 child2_olfFit = 0 count = 0 # Preserve the solution with greater fitness while (child1_oldFit <= child1.fitness.values[0] or child2_olfFit <= child2.fitness.values[0]) \ and count < 10 : child1_oldFit = child1.fitness.values[0] child2_olfFit = child2.fitness.values[0] toolbox.mate(child1, child2) count = count + 1 # if not count < 10: print('crossover 10 times') del child1.fitness.values del child2.fitness.values # print (offspring[i - 1], offspring[i] ) # check the validity of pop if not checkPopValidity(offspring): print('not a valid pop after cross over!!!') for mutant in offspring: if random.random() < mutPb and mutant.fitness.valid: # print(mutant) mutant_oldFit = 0 count = 0 while (mutant_oldFit <= mutant.fitness.values[0]) \ and count < 10: mutant_oldFit = mutant.fitness.values[0] toolbox.mutate(mutant) count = count + 1 # if not count < 10: print('mutation 10 times') del mutant.fitness.values # print(mutant) # check the validity of pop if not checkPopValidity(offspring): print('not a valid pop after mutation!!!') # Evaluate the individuals with an invalid fitness invalidInd = [ind for ind in offspring if not ind.fitness.valid] fitnesses = map(toolbox.evaluate, invalidInd) for ind, fit in zip(invalidInd, fitnesses): ind.fitness.values = fit print(' Evaluated %d individuals' % len(invalidInd)) # The population is entirely replaced by the offspring pop[:] = toolbox.select(offspring + pop, popSize) # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] #if not [0], returns tuple instead of float length = len(pop) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 print(' Min %s' % min(fits)) print(' Max %s' % max(fits)) print(' Avg %s' % mean) print(' Std %s' % std) # Write data to holders for exporting results to CSV file if exportCSV: csvRow = { 'generation': g, 'evaluated_individuals': len(invalidInd), 'min_fitness': min(fits), 'max_fitness': max(fits), 'avg_fitness': mean, 'std_fitness': std, } csvData.append(csvRow) print('-- End of (successful) evolution --') bestInd = tools.selBest(pop, 1)[0] print('Best individual: %s' % bestInd) print('Fitness: ', bestInd.fitness.values) print( ind2solution(bestInd, instance, simple_flag=simple_flag, strip_flag=strip_flag, track_flag=track_flag)) print('Total cost: %s' % (1 / bestInd.fitness.values[0])) print('End of evolution') if not strip_flag: solutionFile = os.path.join(BASE_DIR, 'Solutions', 'solution' + instName[8:]) #testSolution = [4, 6, 8, 2, 10, 12, 14] testSolution = readsolution2solution(solutionFile, instance) verifySolution(testSolution, instance) print(toolbox.evaluate(testSolution)) if exportCSV: csvFilename = '%s_iS%s_pS%s_cP%s_mP%s_nG%s.csv' % ( instName, indSize, popSize, cxPb, mutPb, NGen) csvPathname = os.path.join(BASE_DIR, 'results', csvFilename) print('Write to file: %s' % csvPathname) makeDirsForFile(pathname=csvPathname) if not exist(pathname=csvPathname, overwrite=True): with open(csvPathname, 'w') as f: fieldnames = [ 'generation', 'evaluated_individuals', 'min_fitness', 'max_fitness', 'avg_fitness', 'std_fitness' ] writer = DictWriter(f, fieldnames=fieldnames, dialect='excel') writer.writeheader() for csvRow in csvData: writer.writerow(csvRow)
toolbox, cxpb=probabilidadCruce, mutpb=probabilidadMutacion, # Probabilidades de cruce y mutacion ngen=numeroGeneraciones, verbose=False, stats=mstats ) # Numero de generaciones a completar y estadisticas a recoger # Por cada generación, la estructura de logbook va almacenando un resumen de los # avances del algoritmo. file = open("estadisticas_" + nombreArchivo + ".txt", 'a') file.write(str(logbook) + os.linesep) file.close() file = open("fenotipo_" + nombreArchivo + ".txt", 'a') file.write(str(feno(tools.selBest(population, 1)[0])) + os.linesep) file.close() file = open("solucion_" + nombreArchivo + ".txt", 'a') file.write(str(len(tools.selBest(population, 1)[0])) + os.linesep) salida = set(tools.selBest(population, 1)[0]) a = 0 for i in salida: if a == 0: if len(i) > 1: file.write(str(i)[1:-1]) else: file.write(str(i)[1:-2]) a = 1 else: if len(i) > 1:
def run(self): """Run the optimization.""" pool = multiprocessing.Pool(processes=self.nproc) self.toolbox.register("map", pool.map) random.seed(42) pop = self.toolbox.population(n=self.pop) opt_log.info('Starting optimization') # fitnesses = self.toolbox.map(self.toolbox.evaluate, pop) # for ind, fit in zip(pop, fitnesses): # ind.fitness.values = fit # fits = [ind.fitness.values[0] for ind in pop] fits = [.0] # Begin the evolution opt_log.info('Starting the evolution') opt_log.info(f'Max generations={self.max_gen} Pop={len(pop)}') gen = 0 while max(fits) < 1 and gen < self.max_gen: # A new generation gen += 1 # Select the next generation individuals offspring = self.toolbox.select(pop, len(pop)) # Clone the selected individuals offspring = list(map(self.toolbox.clone, offspring)) # Apply crossover and mutation on the offspring for child1, child2 in zip(offspring[::2], offspring[1::2]): # cross two individuals with probability CXPB if random.random() < self.cxpb: self.toolbox.mate(child1, child2) # fitness values of the children # must be recalculated later del child1.fitness.values del child2.fitness.values for mutant in offspring: # mutate an individual with probability MUTPB if random.random() < self.mutpb: self.toolbox.mutate(mutant) # https://stackoverflow.com/a/44722548 del mutant.fitness.values # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = self.toolbox.map(self.toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit opt_log.debug(f"Evaluated {len(invalid_ind)} individuals") # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 opt_log.info(f"Gen {gen} {mean:.2f} +- {std:.2f} ({min(fits):.2f}," f"{max(fits):.2f})") pool.close() pool.join() opt_log.info("Optimization complete") best_ind = tools.selBest(pop, 1)[0] opt_log.info(f"Optimal scoring function is: (energy * " f"{best_ind[0]:.2f}) / (satisfaction *" f" {best_ind[1]:.2f})") opt_log.info(f"This function will give a correlation of" f" {best_ind.fitness.values[0]:.2f}")
creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("indices", random.sample, range(NUM_CITIES), NUM_CITIES) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.indices) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", evalF) toolbox.register("mate", tools.cxOrdered) toolbox.register("mutate", tools.mutShuffleIndexes, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) CXPB, MUTPB, NGEN = 0.5, 0.2, 1000 population = toolbox.population(n=50) print("\n\tBest 20 of the initial population:") printPop(tools.selBest(population, k=20)) for _ in itertools.repeat(None, NGEN): offspring = algorithms.varAnd(population, toolbox, CXPB, MUTPB) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) print("\n\tBest 5 of the final population:") printPop(tools.selBest(population, k=5))
stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean, axis=0) stats.register("std", numpy.std, axis=0) stats.register("min", numpy.min, axis=0) stats.register("max", numpy.max, axis=0) algorithms.eaMuPlusLambda(pop, toolbox, MU, LAMBDA, CXPB, MUTPB, NGEN, stats, halloffame=hof) return pop, stats, hof if __name__ == "__main__": pop = main()[0] best_ind = tools.selBest(pop, -1) for i in best_ind: print("best_ind", i) print("best_value", i.fitness.values)
if min(fits) == 0: break #print("gen:",i," Min %s" % min(fits)," Max %s" % max(fits)," Avg %s" % mean) #print("gen:",i," Min %s" % min(fits)," Max %s" % max(fits)," Avg %s" % mean," Std %s" % std) #print(i,max(fits),mean) #nvmap.fig.show() #time.sleep(100000000) return pop, hof if __name__ == '__main__': print("pop_num = ", POPNUM) print("gen_num ", NGEN) pop, hof = main() expr = tools.selBest(pop, 1)[0] print(expr) """ 2回連続で最小値が一致していたらnovelty_searchを行う. 0 4.075023050190184 1156.1453120427354 166.4136630695671 1 0.022914707811938422 659.4723034874191 87.58800368033285 2 0.022914707811938422 565.286954344603 46.92552132727429 3 0.022914707811938422 1155.8698271088651 32.86141289300736 4 0.16929126310766854 130.72871631851797 10.603308629914354 5 0.26926918751105927 116.1383051077541 13.440188120269836 6 0.0790438329543217 226.68121785607093 11.451844704279138 7 0.04616787809424775 126.51163292258249 8.864807308145636 8 0.042111253129909064 69.50050986331198 3.726453945503491 9 0.005903559769173528 86.89761470235598 1.2720889780771634 10 0.005863780260742529 0.6259415090656157 0.12919107959593795
toolbox = base.Toolbox() toolbox.register("attr_bool", random.randint, 0, 1) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=100) toolbox.register("population", tools.initRepeat, list, toolbox.individual) def evalOneMax(individual): return sum(individual), toolbox.register("evaluate", evalOneMax) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) population = toolbox.population(n=300) NGEN = 40 for gen in range(NGEN): offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) top10 = tools.selBest(population, k=10)
def main(game, enemy): file_aux=open(experiment_name+'/results_enemy' + \ str(enemy) + str(algorithm) + '.txt', 'a') file_aux.write(f'\ngame {game} \n') file_aux.write('gen, best, mean, std, median, q1, q3, life') file_aux.close() #Creating the population pop = toolbox.populationCreator(n=pop_size) # Population is created as a list object pop_array = np.array(pop) generationCounter=0 print("Start of evolution") # Evaluating all the population # fitnessValues=list(map(toolbox.evaluate, pop_array)) -> Won't work. Used Kamiel's fitnessValue = evaluate(pop_array) fitnessValue = fitnessValue[0].tolist() fitnesses = [] lifes = [] for value in fitnessValue: fitnesses.append(value[0]) lifes.append(value[1]) for count, individual in enumerate(fitnesses): # Rewrites the fitness value in a way the DEAP algorithm can understand fitnesses[count] = (-individual, ) # Assigning the fitness value to each individual for individual, fitnessValue in zip(pop, fitnesses): individual.fitness.values=fitnessValue # Extract each fitness value fitnessValues=[individual.fitness.values[0] for individual in pop] # Saves first generation fits = fitnessValues g = generationCounter length = len(pop) mean = sum(fits) / length sum2 = sum(x*x for x in fits) std = abs(sum2 / length - abs(mean)**2)**0.5 q1 = np.percentile(fits, 25) median = np.percentile(fits, 50) q3 = np.percentile(fits, 75) max_life = max(lifes) file_aux = open(experiment_name+'/results_enemy' + str(enemy)+'Tournement.txt', 'a') file_aux.write( f'\n{str(g)}, {str(round(max(fits)))}, {str(round(mean,6))}, {str(round(std,6))}, {str(round(median,6))}, {str(round(q1,6))}, {str(round(q3,6))}, {str(round(max_life,6))}') file_aux.close() # Beggin the genetic loop # First, we start with the stopping condition while max(fitnessValues) < 100 and generationCounter < max_generations: begin_time = datetime.datetime.now() print("Being evolution time:", begin_time,"!!!") # Update generation counter generationCounter=generationCounter + 1 print("-- Generation %i --" % generationCounter) # Begin genetic operators # 1. Selection: since we already defined the tournament before # we only need to select the population and its lenght # Selected individuals now will be in a list print("selection...") offspring=toolbox.select(pop, len(pop)) for i in offspring: print(i.fitness.values[0]) # Cloning the selected indv so we can apply the next genetic operators without affecting the original pop offspring=list(map(toolbox.clone, offspring)) print("done") # 2. Crossover. Note taht the mate function takes two individuals as arguments and # modifies them in place, meaning they don't need to be reassigned print("Crossover...") for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < p_crossover: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values print("done") # 3. Mutation print("Mutation...") for mutant in offspring: # if random.random() < p_mutation: if random.random() < (1 - (generationCounter/max_generations)): toolbox.mutate(mutant) del mutant.fitness.values # Individuals that werent mutated remain intact, their fitness values don't need to eb recalculated # The rest of the individuals will have this value EMPTY # We now find those individuals and calculate the new fitness print("...re-evaluating fitness...") freshIndividuals=[ind for ind in offspring if not ind.fitness.valid] # Eval not work!!! :(( used Kamiels # freshFitnessValues=list(map(toolbox.evaluate, freshIndividuals)) # for individual, fitnessValue in zip(freshIndividuals, freshFitnessValues): # individual.fitness.values=fitnessValue pop_array = np.array(freshIndividuals) values = evaluate(pop_array) values = values[0].tolist() fitnesses = [] for value in values: fitnesses.append(value[0]) lifes.append(value[1]) for count, individual in enumerate(fitnesses): fitnesses[count] = (individual, ) for ind, fit in zip(freshIndividuals, fitnesses): ind.fitness.values = fit print("done") # Changes best individuals of population with worst individuals of the offspring amount_swithed_individuals=int(len(pop)/10) worst_offspring=deap.tools.selWorst( offspring, amount_swithed_individuals, fit_attr='fitness') best_gen=deap.tools.selBest( pop, amount_swithed_individuals, fit_attr='fitness') for count, individual in enumerate(worst_offspring): index=offspring.index(individual) offspring[index]=best_gen[count] # End of the proccess -> replace the old population wiht the new one pop[:]=offspring print(f"There are {len(pop)} individuals in the population ") # Gather all the fitnesses in one list and print the stats fits=[ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x*x for x in fits) std = abs(sum2 / length - abs(mean)**2)**0.5 q1 = np.percentile(fits, 25) median = np.percentile(fits, 50) q3 = np.percentile(fits, 75) max_life = max(lifes) # For plotting maxFitness = max(fits) meanFitness = sum(fits)/len(pop) maxFitnessValues.append(maxFitness) meanFitnessValues.append(meanFitness) print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) # Plot plt.plot(maxFitnessValues) plt.plot(meanFitnessValues) ymax = max(maxFitnessValues) plt.ylabel("Values") plt.xlabel("Generations") plt.title("Maximum fitness: "+ str(ymax) + " Algorithm :" + str(algorithm)) plt.savefig("adrian-testing" + "-algorithm-" + str(algorithm) +"-enemy-"+ str(enemy)+".png") plt.show() # DataFrame df.loc[int(algorithm)]=[min(fits),max(fits),mean,std] df.to_csv("adrian-testing-4" + "-algorithm-" + str(algorithm) +"-enemy-"+ str(enemy)+".csv", index=False) print("Saving...") # saves results for first pop file_aux=open(experiment_name+'/results_enemy' + \ str(enemy)+'Tournement.txt', 'a') file_aux.write( f'\n{str(g)}, {str(round(max(fits),6))}, {str(round(mean,6))}, {str(round(std,6))}, {str(round(median,6))}, {str(round(q1,6))}, {str(round(q3,6))}, {str(round(max_life,6))}') file_aux.close() print("Evolution ended in:", datetime.datetime.now() - begin_time) print("-- End of (successful) evolution --") best_ind=tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (best_ind, best_ind.fitness.values)) np.savetxt(experiment_name+'/best_game_'+str(game) + \ ',enemy_'+str(enemy)+'Tournement.txt', best_ind) print("Done. New generation...")
def generate(self, n_pop, cxpb=0.8, mutxpb=0.3, ngen=20, set_toolbox=False): if self.verbose == 1: print( "Population: {}, crossover_probablity: {}, mutation_probablity: {}, total generations: {}" .format(n_pop, cxpb, mutxpb, ngen)) if not set_toolbox: self.toolbox = self._default_toolbox() else: raise Exception( "Please create a toolbox.Use create_toolbox to create and register_toolbox to register. Else set set_toolbox = False to use defualt toolbox" ) pop = self.toolbox.population(n_pop) CXPB, MUTPB, NGEN = cxpb, mutxpb, ngen # Evaluate the entire population print("EVOLVING.......") fitnesses = list(map(self.toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit for g in range(NGEN): print("-- GENERATION {} --".format(g + 1)) offspring = self.toolbox.select(pop, len(pop)) self.fitness_in_generation[str(g + 1)] = max( [ind.fitness.values[0] for ind in pop]) # Clone the selected individuals offspring = list(map(self.toolbox.clone, offspring)) # Apply crossover and mutation on the offspring for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: self.toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: self.toolbox.mutate(mutant) del mutant.fitness.values # Evaluate the individuals with an invalid fitness weak_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = list(map(self.toolbox.evaluate, weak_ind)) for ind, fit in zip(weak_ind, fitnesses): ind.fitness.values = fit print("Evaluated %i individuals" % len(weak_ind)) # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] print("-- Only the fittest survives --") self.best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (self.best_ind, self.best_ind.fitness.values)) self.get_final_scores(pop, fits) f_obj = ff.keshihua() np_ind = np.asarray(self.best_ind) feature_idx = np.where(np_ind == 1)[0] fitness = f_obj.huatu \ (self.model, self.x[:, feature_idx], self.y, self.x_test[:, feature_idx], self.y_test, self.x_development[:, feature_idx], self.y_development) return pop
def solve(self): """Setup the deap module and find the best permutation.""" maximum_score = self.maximum_score() if maximum_score <= 0.0: print("Nothing to solve, aborting.") exit() toolbox = self.setup_deap() # Create population population = toolbox.population(n=self.population) # Perform evoluationary algorithm result = None self.solution_iterator.initialize_progressbar() maximum_fit = -10 * 6 maximum_score_object = None for step in self.solution_iterator: self.current_step = step self.solution_iterator.update_progressbar(100 * maximum_fit / maximum_score) offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): score = fit[0].score() # Update maximum fit if score > maximum_fit: maximum_fit = score maximum_score_object = fit[0] if int(score) == maximum_score: result = ind break ind.fitness.values = score, population = toolbox.select(offspring, k=len(population)) if maximum_score_object: self.solution_iterator.register_fitness(maximum_score_object) if result: break else: result = tools.selBest(population, k=1)[0] self.solution_iterator.update_progressbar(100 * maximum_fit / maximum_score, final=True) self.solution = finalize_solution(result, self) new_score = evaluate_permutation(self.solution, self) if new_score[0].score() > maximum_fit: print("Improved final solution: {} > {}".format( new_score[0].score(), maximum_fit)) else: print("Could not improve final solution") self.solution_generated_groups = sorted_teams_from_solution( self.solution, self.assignable_individuals, self.generated_group_prefix) self.solution_groups = self.assignable_groups + self.solution_generated_groups self.solution_schedule = self.generate_schedule_from_solution( self.solution, self.solution_groups) return result
def main(): random.seed(128) # multiprocesssing pool p = Pool(4) pop = toolbox.population(n=100) # CXPB is the probability with which two individuals # are crossed # # MUTPB is the probability for mutating an individual # # NGEN is the number of generations for which the # evolution runs CXPB, MUTPB, NGEN = 0.5, 0.2, 40 print("Start of evolution") # Evaluate the entire population fitnesses = list(p.map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit print(" Evaluated %i individuals" % len(pop)) # Begin the evolution for g in range(NGEN): print("-- Generation %i --" % g) offspring = toolbox.select(pop, len(pop)) offspring = list(p.map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = p.map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit print(" Evaluated %i individuals" % len(invalid_ind)) pop[:] = offspring fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) print("-- End of (successful) evolution --") best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (best_ind, best_ind.fitness.values)) e.calc_labels(best_ind)
def evolve(Xsource, Ysource, Xtarget, Ytarget, file, mutation_rate, full_init, dim_p=20, eta_p=0.1): """ Running GA algorithms, where each individual is a set of target pseudo labels. :return: the best solution of GAs. """ exe_time = 0 start = time.time() global ns, nt, C, Xs, Ys, Xt, Yt, YY, K, A, e, M0, L, dim, eta dim = dim_p eta = eta_p archive = [] Xs = Xsource Ys = Ysource Xt = Xtarget Yt = Ytarget ns, nt = Xs.shape[0], Xt.shape[0] C = len(np.unique(Ys)) # Transform data using gfk gfk = GFK.GFK(dim=dim) _, Xs_new, Xt_new = gfk.fit(Xs, Xt) Xs_new, Xt_new = Xs_new.T, Xt_new.T X = np.hstack((Xs_new, Xt_new)) X /= np.linalg.norm(X, axis=0) Xs = X[:, :ns].T Xt = X[:, ns:].T # do not using any feature transformation # X = np.hstack((Xs.T, Xt.T)) # X /= np.linalg.norm(X, axis=0) # Xs = X[:, :ns].T # Xt = X[:, ns:].T # coral = CORAL.CORAL() # Xs = coral.fit(Xs, Xt) # X = np.hstack((Xs.T, Xt.T)) # X /= np.linalg.norm(X, axis=0) # Xs = X[:, :ns].T # Xt = X[:, ns:].T # tca = TCA.TCA(kernel_type='linear', dim=dim, lamb=1, gamma=1.0) # Xs_new, Xt_new = tca.fit(Xs, Xt) # X = np.hstack((Xs_new.T, Xt_new.T)) # X /= np.linalg.norm(X, axis=0) # Xs = X[:, :ns].T # Xt = X[:, ns:].T # build some matrices that are not changed K = kernel(kernel_type, X, X2=None, gamma=gamma) A = np.diagflat(np.vstack((np.ones((ns, 1)), np.zeros((nt, 1))))) e = np.vstack((1.0 / ns * np.ones((ns, 1)), -1.0 / nt * np.ones((nt, 1)))) M0 = e * e.T * C L = Helpers.laplacian_matrix(X.T, p) YY = np.zeros((ns, C)) for c in range(1, C + 1): ind = np.where(Ys == c) YY[ind, c - 1] = 1 YY = np.vstack((YY, np.zeros((nt, C)))) pos_min = 1 pos_max = C # parameters for GA N_BIT = nt MUTATION_RATE = 1.0/N_BIT*C MPB = mutation_rate CXPB = 1-mutation_rate creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Ind", list, fitness=creator.FitnessMin) creator.create("Pop", list) # for creating the population toolbox.register("bit", random.randint, a=pos_min, b=pos_max) toolbox.register("ind", tools.initRepeat, creator.Ind, toolbox.bit, n=N_BIT) toolbox.register("pop", tools.initRepeat, creator.Pop, toolbox.ind) # for evaluation toolbox.register("evaluate", fitness_evaluation) # for genetic operators toolbox.register("select", tools.selTournament, tournsize=2) toolbox.register("crossover", tools.cxUniform, indpb=0.5) toolbox.register("mutate", tools.mutUniformInt, low=pos_min, up=pos_max, indpb=MUTATION_RATE) # pool = multiprocessing.Pool(4) # toolbox.register("map", pool.map) # initialize some individuals by predefined classifiers pop = toolbox.pop(n=N_IND) classifiers = list([]) classifiers.append(KNeighborsClassifier(1)) # classifiers.append(SVC(kernel="linear", C=0.025, random_state=np.random.randint(2 ** 10))) # classifiers.append(GaussianProcessClassifier(1.0 * RBF(1.0), random_state=np.random.randint(2 ** 10))) # classifiers.append(KNeighborsClassifier(3)) # classifiers.append(SVC(kernel="rbf", C=1, gamma=2, random_state=np.random.randint(2 ** 10))) # classifiers.append(DecisionTreeClassifier(max_depth=5, random_state=np.random.randint(2 ** 10))) # classifiers.append(KNeighborsClassifier(5)) # classifiers.append(GaussianNB()) # classifiers.append(RandomForestClassifier(max_depth=5, n_estimators=10, random_state=np.random.randint(2 ** 10))) # classifiers.append(AdaBoostClassifier(random_state=np.random.randint(2 ** 10))) step = N_IND/len(classifiers) for ind_index, classifier in enumerate(classifiers): classifier.fit(Xs, Ys) Yt_pseu = classifier.predict(Xt) for bit_idex, value in enumerate(Yt_pseu): pop[ind_index*step][bit_idex] = value if full_init: Helpers.opposite_init(pop, pos_min, pos_max) # evaluate the initialized populations fitnesses = toolbox.map(toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit, hof = tools.HallOfFame(maxsize=1) hof.update(pop) exe_time = exe_time + time.time()-start for g in range(N_GEN): file.write("*****Iteration %d*****\n" % (g+1)) start = time.time() # selection offspring = toolbox.select(pop, len(pop)) offspring = map(toolbox.clone, offspring) # applying crossover for c1, c2 in zip(offspring[::2], offspring[1::2]): if np.random.rand() < CXPB: toolbox.crossover(c1, c2) del c1.fitness.values del c2.fitness.values # applying mutation for mutant in offspring: if np.random.rand() < MPB: toolbox.mutate(mutant) del mutant.fitness.values # opposite_local(offspring) invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind) for ind, fitness in zip(invalid_ind, fitnesses): ind.fitness.values = fitness, # now select the best individual from offspring # pass it to the single step meda to refine the label best_inds = tools.selBest(offspring, N_IND/10) for best_ind in best_inds: Yt_pseu = label_evolve(best_ind) new_ind = toolbox.ind() for index, label in enumerate(Yt_pseu): new_ind[index] = label new_ind.fitness.values = fitness_evaluation(new_ind), offspring.append(new_ind) archive.append(new_ind) # The population is entirely replaced by the offspring exe_time = exe_time + time.time() - start pop[:] = tools.selBest(offspring + list(hof), len(pop)) hof.update(pop) file.write('Average distance: %f\n' %(Helpers.pop_distance(pop))) file.write('Best fitness: %f\n' %(hof[0].fitness.values[0])) best_ind = tools.selBest(pop, 1)[0] acc = np.mean(best_ind == Yt) file.write("Accuracy of the best individual: %f\n" % acc) no_10p = int(0.1*N_IND) top10 = tools.selBest(pop, no_10p) vote_label = Helpers.voting(top10) acc = np.mean(vote_label == Yt) file.write("Accuracy of the 10%% population: %f\n" % acc) # Use the whole population vote_label = Helpers.voting(pop) acc = np.mean(vote_label == Yt) file.write("Accuracy of the population: %f\n" % acc) file.write("*****Final result*****\n") best_ind = tools.selBest(pop, 1)[0] acc = np.mean(best_ind == Yt) file.write("Accuracy of the best individual: %f\n" % acc) best_evolve = label_evolve(best_ind) acc = np.mean(best_evolve == Yt) return_acc = acc file.write("Accuracy of the evovled best individual: %f\n" % acc) top10 = tools.selBest(pop, 10) vote_label = Helpers.voting(top10) acc = np.mean(vote_label == Yt) file.write("Accuracy of the 10%% population: %f\n" % acc) # Use the whole population vote_label = Helpers.voting(pop) acc = np.mean(vote_label == Yt) file.write("Accuracy of the population: %f\n" % acc) # Use the archive if len(archive)>0: vote_label = Helpers.voting(archive) acc = np.mean(vote_label == Yt) file.write("Accuracy of the archive: %f\n" % acc) file.write('GA-MEDA time: %f' % (exe_time)+'\n') return return_acc
def main(): random.seed(42) # create an initial population of 300 individuals (where # each individual is a list of integers) pop = toolbox.population(n=300) # CXPB is the probability with which two individuals # are crossed # # MUTPB is the probability for mutating an individual CXPB, MUTPB = 0.5, 0.2 print("Start of evolution") # Evaluate the entire population fitnesses = [toolbox.evaluate(ind) for ind in pop] for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit print(" Evaluated %i individuals" % len(pop)) # Extracting all the fitnesses of the individuals fits = [ind.fitness.values[0] for ind in pop] # Variable keeping track of the number of generations g = 0 # Begin the evolution while max(fits) < 100 and g < 1000: # A new generation g = g + 1 print("-- Generation %i --" % g) # Select the next generation individuals offspring = toolbox.select(pop, len(pop)) # Clone the selected individuals offspring = [toolbox.clone(ind) for ind in offspring] # Apply crossover and mutation on the offspring for child1, child2 in zip(offspring[::2], offspring[1::2]): # cross two individuals with probability CXPB if random.random() < CXPB: toolbox.mate(child1, child2) # fitness values of the children # must be recalculated later del child1.fitness.values del child2.fitness.values for mutant in offspring: # mutate an individual with probability MUTPB if random.random() < MUTPB: toolbox.mutate(mutant) 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 print("Evaluated %i individuals" % len(invalid_ind)) # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x*x for x in fits) std = abs(sum2 / length - mean**2)**0.5 print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) print("-- End of (successful) evolution --") best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (best_ind, best_ind.fitness.values))
"mutate", tools.mutFlipBit, indpb=0.05 ) # the registered method "mutate" will lunch the method "tools.mutFlipBit" and will fix the second argument of the method (porbability of each attribute to flip) toolbox.register( "select", tools.selTournament, tournsize=3 ) # the registered method "select" will lunch the methot "selTournament" and fix the argument tournsize = 3 -> look at "selTournament" for more info. """ START OF EXPERIMENT """ # generate a population of 300 "Individual", each of them is a list off 100 random numbers in the range [0,1] pop = toolbox.population(n=300) # compute for ngen times the new generation, evaluating the previous one. It uses the methods defined in lines [34 to 37] and it needs this names in order to work correctly. result = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=10, verbose=False) # NGEN = 10 # print results print('Current best fitness:', evalOneMax(tools.selBest(pop, k=1)[0])) # compute for ngen times the new generation, evaluating the previous one. It uses the methods defined in lines [34 to 37] and it needs this names in order to work correctly. result = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=50, verbose=False) # NGEN = 50 # print results print('Current best fitness:', evalOneMax(tools.selBest(pop, k=1)[0]))
def main(): random.seed(64) pop = toolbox.population(n=30) CXPB, MUTPB, NGEN = 0.5, 0.2, 10 print("Start of evolution") fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit print(" Evaluated %i individuals" % len(pop)) for g in range(NGEN): print("-- Generation %i --" % g) offspring = toolbox.select(pop, len(pop)) offspring = list(map(toolbox.clone, offspring)) for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant) del mutant.fitness.values 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 print(" Evaluated %i individuals" % len(invalid_ind)) pop[:] = offspring fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x*x for x in fits) std = abs(sum2 / length - mean**2)**0.5 print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) print ('Total Time is ' + str(time.time()-start_time) + ' seconds.') print("-- End of (successful) evolution --") best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (best_ind, best_ind.fitness.values)) new_features = [] for i in range(0,len(best_ind)-1): if best_ind[i] == 1: new_features.append(i) ############################################################## ############################################################## ############################################################## ####Ensemble Learning print('#####################################################') new_X_train = Xtrain[new_features] new_Y_train = Ytrain new_X_test = Xtest[new_features] new_Y_test = Ytest clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(150,50,15,5,3), random_state=1) y_pred = clf.fit(new_X_train, new_Y_train).predict(new_X_test) f = open('MLP_GA.txt','w') print(classification_report(Ytest,y_pred)) f.write(classification_report(Ytest,y_pred)) f.write('\n') f.write('ROC = ' + str(roc_auc_score(Ytest,y_pred))) f.write('\n') f.close()
def generate(self, n_pop, cxpb=0.5, mutxpb=0.2, ngen=5, set_toolbox=False): """ Generate evolved population Parameters ----------- n_pop : {int} population size cxpb : {float} crossover probablity mutxpb: {float} mutation probablity n_gen : {int} number of generations set_toolbox : {boolean} If True then you have to create custom toolbox before calling method. If False use default toolbox. Returns -------- Fittest population """ if self.verbose == 1: print( "Population: {}, crossover_probablity: {}, mutation_probablity: {}, total generations: {}" .format(n_pop, cxpb, mutxpb, ngen)) if not set_toolbox: self.toolbox = self._default_toolbox() else: raise Exception( "Please create a toolbox.Use create_toolbox to create and register_toolbox to register. Else set set_toolbox = False to use defualt toolbox" ) pop = self.toolbox.population(n_pop) CXPB, MUTPB, NGEN = cxpb, mutxpb, ngen # Evaluate the entire population print("EVOLVING.......") fitnesses = list(map(self.toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit for g in range(NGEN): print("-- GENERATION {} --".format(g + 1)) offspring = self.toolbox.select(pop, len(pop)) self.fitness_in_generation[str(g + 1)] = max( [ind.fitness.values[0] for ind in pop]) # Clone the selected individuals offspring = list(map(self.toolbox.clone, offspring)) # Apply crossover and mutation on the offspring for child1, child2 in zip(offspring[::2], offspring[1::2]): if random.random() < CXPB: self.toolbox.mate(child1, child2) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: self.toolbox.mutate(mutant) del mutant.fitness.values # Evaluate the individuals with an invalid fitness weak_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = list(map(self.toolbox.evaluate, weak_ind)) for ind, fit in zip(weak_ind, fitnesses): ind.fitness.values = fit print("Evaluated %i individuals" % len(weak_ind)) # The population is entirely replaced by the offspring pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x * x for x in fits) std = abs(sum2 / length - mean**2)**0.5 if self.verbose == 1: print(" Min %s" % min(fits)) print(" Max %s" % max(fits)) print(" Avg %s" % mean) print(" Std %s" % std) print("-- Only the fittest survives --") self.best_ind = tools.selBest(pop, 1)[0] print("Best individual is %s, %s" % (self.best_ind, self.best_ind.fitness.values)) self.get_final_scores(pop, fits) return pop
if (verbose): print("Building first part of training dataset...") clfin = [] tops = [] for population in training: pareto = tools.sortNondominated(population, len(population)) top = pareto[0] #the actual pareto front #using best and worst elements to build training data for member in top: #careful avoiding duplicates if member not in tops: tops.append(member) if member not in clfin: clfin.append(member) elems = len(clfin) for member in tools.selBest(population, k=len(population))[:-elems]: if member not in clfin: clfin.append(member) ############## # running nsga if (verbose): print("Starting nsga runs") def uniform(low, up, size=None): try: return [random.uniform(a, b) for a, b in zip(low, up)] except TypeError: return [
def main(self,NGen=1000,NIndiv=100,DoPlot=True): #os.system("rm png/*.png") #random.seed(64) #np.random.seed(64) toolbox=self.toolbox # pool = multiprocessing.Pool(processes=6) # toolbox.register("map", pool.map) self.pop = toolbox.population(n=NIndiv) self.hof = tools.HallOfFame(1, similar=numpy.array_equal) #self.hof = tools.ParetoFront(1, similar=numpy.array_equal) # stats = tools.Statistics(lambda ind: ind.fitness.values) # stats.register("avg", numpy.mean) # stats.register("std", numpy.std) # stats.register("min", numpy.min) # stats.register("max", numpy.max) for indiv in self.pop: indiv.fill(0) #print "Best indiv start", #self.ArrayMethodsMachine.PM.PrintIndiv(self.IslandBestIndiv) #print if self.IslandBestIndiv is not None: #SModelArrayMP,Alpha=self.ArrayMethodsMachine.DeconvCLEAN() #AModelArrayMP=None DicoModelMP=self.ListInitIslands[self.iIsland] if DicoModelMP is not None: SModelArrayMP,AModelArrayMP=DicoModelMP["S"],DicoModelMP["Alpha"] else: SModelArrayMP,_=self.ArrayMethodsMachine.DeconvCLEAN() AModelArrayMP=np.zeros_like(SModelArrayMP) if NGen==0: self.ArrayMethodsMachine.PM.ReinitPop(self.pop,SModelArrayMP,AlphaModel=AModelArrayMP) self.ArrayMethodsMachine.KillWorkers() return self.pop[0] if np.max(np.abs(self.IslandBestIndiv))==0: #print "NEW" self.ArrayMethodsMachine.PM.ReinitPop(self.pop,SModelArrayMP,AlphaModel=AModelArrayMP) else: #print "MIX" NIndiv=len(self.pop)/10 pop0=self.pop[0:NIndiv] pop1=self.pop[NIndiv::] pop1=self.pop pop0=[] pop1=self.pop[0:1] pop0=self.pop[1::] # self.ArrayMethodsMachine.PM.ReinitPop(pop0,SModelArray) # half with the best indiv SModelArrayBest=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"S") AlphaModel=None if "Alpha" in self.ArrayMethodsMachine.PM.SolveParam: AlphaModel=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"Alpha") GSigModel=None if "GSig" in self.ArrayMethodsMachine.PM.SolveParam: GSigModel=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"GSig") self.ArrayMethodsMachine.PM.ReinitPop(pop1,SModelArrayBest,AlphaModel=AlphaModel,GSigModel=GSigModel) # half of the pop with the MP model #SModelArrayBest0=SModelArrayBest.copy() #mask=(SModelArrayBest0==0) #SModelArrayBest0[mask]=SModelArrayMP[mask] #self.ArrayMethodsMachine.PM.ReinitPop(pop0,SModelArrayBest0,AlphaModel=AlphaModel,GSigModel=GSigModel) self.ArrayMethodsMachine.PM.ReinitPop(pop0,SModelArrayMP,AlphaModel=AModelArrayMP) # _,Chi20=self.ArrayMethodsMachine.GiveFitnessPop(pop0) # _,Chi21=self.ArrayMethodsMachine.GiveFitnessPop(pop1) # print # print Chi20 # print Chi21 # stop self.pop=pop1+pop0 #print # if self.IslandBestIndiv is not None: # if np.max(np.abs(self.IslandBestIndiv))==0: # #print "deconv" # SModelArray,Alpha=self.ArrayMethodsMachine.DeconvCLEAN() # #print "Estimated alpha",Alpha # AlphaModel=np.zeros_like(SModelArray)+Alpha # #AlphaModel[SModelArray==np.max(SModelArray)]=0 # self.ArrayMethodsMachine.PM.ReinitPop(self.pop,SModelArray)#,AlphaModel=AlphaModel) # #print self.ArrayMethodsMachine.GiveFitness(self.pop[0],DoPlot=True) # #stop # #print self.pop # else: # SModelArray=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"S") # AlphaModel=None # if "Alpha" in self.ArrayMethodsMachine.PM.SolveParam: # AlphaModel=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"Alpha") # GSigModel=None # if "GSig" in self.ArrayMethodsMachine.PM.SolveParam: # GSigModel=self.ArrayMethodsMachine.PM.ArrayToSubArray(self.IslandBestIndiv,"GSig") # self.ArrayMethodsMachine.PM.ReinitPop(self.pop,SModelArray,AlphaModel=AlphaModel,GSigModel=GSigModel) # set best Chi2 # _=self.ArrayMethodsMachine.GiveFitnessPop([self.IslandBestIndiv]) _=self.ArrayMethodsMachine.GiveFitnessPop(self.pop) self.pop, log= algorithms.eaSimple(self.pop, toolbox, cxpb=0.3, mutpb=0.5, ngen=NGen, halloffame=self.hof, #stats=stats, verbose=False, ArrayMethodsMachine=self.ArrayMethodsMachine, DoPlot=DoPlot, MutConfig=self.MutConfig) self.ArrayMethodsMachine.KillWorkers() # #:param mu: The number of individuals to select for the next generation. # #:param lambda\_: The number of children to produce at each generation. # #:param cxpb: The probability that an offspring is produced by crossover. # #:param mutpb: The probability that an offspring is produced by mutation. # mu=70 # lambda_=50 # cxpb=0.3 # mutpb=0.5 # ngen=1000 # self.pop, log= algorithms.eaMuPlusLambda(self.pop, toolbox, mu, lambda_, cxpb, mutpb, ngen, # stats=None, halloffame=None, verbose=__debug__, # ArrayMethodsMachine=self.ArrayMethodsMachine) V = tools.selBest(self.pop, 1)[0] #print "Best indiv end" #self.ArrayMethodsMachine.PM.PrintIndiv(V) # V.fill(0) # S=self.ArrayMethodsMachine.PM.ArrayToSubArray(V,"S") # G=self.ArrayMethodsMachine.PM.ArrayToSubArray(V,"GSig") # S[0]=1. # #S[1]=2. # G[0]=1. # #G[1]=2. # MA=self.ArrayMethodsMachine.PM.GiveModelArray(V) # # print "Sum best indiv",MA.sum(axis=1) # # print "Size indiv",V.size # # print "indiv",V # # print self.ArrayMethodsMachine.ListPixData # # print MA[0,:] return V
toolbox.register('mutate', tools.mutFlipBit, indpb= 0.01) toolbox.register('select', tools.selRoulette) populacao = toolbox.population(20) prob_crossover = 1.0 prob_mutacao = 0.01 num_geracoes = 100 estatisticas = tools.Statistics(key= lambda individuo: individuo.fitness.values) estatisticas.register('max', numpy.max) estatisticas.register('min', numpy.min) estatisticas.register('med', numpy.mean) estatisticas.register('std', numpy.std) populacao, info = algorithms.eaSimple(populacao, toolbox, prob_crossover, prob_mutacao, num_geracoes, estatisticas) melhores = tools.selBest(populacao, 1) for i in melhores: print(i) print(i.fitness) soma = 0 for s in range(len(lista_produtos)): if(i[s] == 1): soma += valores[s] print(f'Nome: {nomes[s]} - Valor: {valores[s]}') print(f'Melhor solução: {soma}') valores_grafico = info.select('max') plt.plot(valores_grafico) plt.title('Acompanhamento dos valores')