def createToolbox(MINCOMP, MAXCOMP, GENSIZE, CONSTRAINTPENALTY, TOURNMENTSIZE, GENECROSSOVERPROB, GENEMUTPROB): creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("attr_int", random.randint, MINCOMP, MAXCOMP) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_int, n=GENSIZE) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", evaluateIndividual) toolbox.decorate( "evaluate", tools.DeltaPenalty(sufficientNumberOfFormers, CONSTRAINTPENALTY, distance_sufficientNumberOfFormers)) toolbox.decorate( "evaluate", tools.DeltaPenalty(individualInsideDomain, CONSTRAINTPENALTY, distance_individualInsideDomain)) toolbox.register("mutate", tools.mutUniformInt, low=MINCOMP, up=MAXCOMP, indpb=GENEMUTPROB) toolbox.register("select", tools.selTournament, tournsize=TOURNMENTSIZE) toolbox.register("mate", tools.cxUniform, indpb=GENECROSSOVERPROB) return toolbox
def init_opti(): ### setup NSGA3 with deap (minimize the first two goals returned by the evaluate function and maximize the third one) creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, 1.0)) creator.create("Individual", list, fitness=creator.FitnessMulti) ref_points = tools.uniform_reference_points(nobj=3, p=12) #initial individual and pop toolbox.register("initial_indi", initial_indi) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.initial_indi, n=1) toolbox.register("population", tools.initRepeat, list, toolbox.individual) #evaluation and constraints toolbox.register("evaluate", evaluate) ##assign the feasibility of solutions and if not feasible a large number for the minimization tasks and a small number for the maximization task toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, (10e20, 10e20, 0))) #mate, mutate and select to perform crossover toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selNSGA3, ref_points=ref_points)
def setup(self, fitness_function_handle, constraint=None, GENOME_LENGTH=20, POPULATION_SIZE=100, P_CROSSOVER=0.5, P_MUTATION=0.2): '''Set up the parameters''' # Set the main variables self.GENOME_LENGTH = GENOME_LENGTH self.POPULATION_SIZE = POPULATION_SIZE self.P_CROSSOVER = P_CROSSOVER self.P_MUTATION = P_MUTATION # Set the lower level parameters self.toolbox = base.Toolbox() self.toolbox.register("attr_float", random.random) self.toolbox.register("individual", tools.initRepeat, creator.Individual, self.toolbox.attr_float, self.GENOME_LENGTH) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("evaluate", fitness_function_handle) self.toolbox.register("mate", tools.cxTwoPoint) # Mating method self.toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) # Mutation method self.toolbox.register("select", tools.selTournament, tournsize=3) # Selection method if constraint is not None: self.toolbox.decorate("evaluate", tools.DeltaPenalty(constraint, 7)) self.stats = [] # Initialize stats vector
def configuracionAlgoritmo_Experimento2(): toolbox.register("mate", tools.cxOnePoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.2) toolbox.register("select", tools.selBest) toolbox.register("evaluate", evaluate) toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 1000000, distance))
def configuracionAlgoritmo_Experimento3(): toolbox.register("mate", tools.cxUniform, indpb=0.2) toolbox.register("mutate", tools.mutFlipBit, indpb=0.2) toolbox.register("select", tools.selTournament, tournsize=3) toolbox.register("evaluate", evaluate) toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 1000000, distance))
def __init__(self, heroClass, initialSelection, useLibrary): self.heroClass = heroClass self.cardPool = getAvailableCardIdsForConstruction(heroClass) if not useLibrary else getLibraryCardIdsForConstruction(heroClass) self.initialSelection = initialSelection self.toolbox = base.Toolbox() creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) self.toolbox.register("attr_gen", random.randint, 0, len(self.cardPool) - 1) self.toolbox.register("individual", tools.initRepeat, creator.Individual, self.toolbox.attr_gen, 30 - len(self.initialSelection)) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) #---------- # Operator registration #---------- # register the goal / fitness function self.toolbox.register("evaluate", self.evalFct) self.toolbox.decorate("evaluate", tools.DeltaPenalty(self.feasible, -100)) # register the crossover operator self.toolbox.register("mate", tools.cxTwoPoint) # register a mutation operator with a probability to # flip each attribute/gene of 0.05 self.toolbox.register("mutate", tools.mutUniformInt, low=0, up=len(self.cardPool) - 1) # operator for selecting individuals for breeding the next # generation: each individual of the current generation # is replaced by the 'fittest' (best) of three individuals # drawn randomly from the current generation. self.toolbox.register("select", tools.selTournament)
def get_toolbox(target_func, weights): # collect the atomic building blocks of the individuals pset = gp.PrimitiveSet("MAIN", 1) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(protectedDiv, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(protectedPow, 2) pset.addPrimitive(math.cos, 1) pset.addPrimitive(sinX, 1) pset.addEphemeralConstant("rand101", lambda: random.randint(-1, 1)) pset.addEphemeralConstant("rand10010", lambda: random.randint(-10, 10)) pset.addTerminal(math.pi) # define the general form of an individual creator.create("FitnessMulti", base.Fitness, weights=weights) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMulti, target_func=target_func) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=3) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) eval_range = [x / 20. * math.pi for x in range(-20, 20)] + [x for x in range(-20, 20)] toolbox.register("evaluate", get_fitness, target_func=target_func, toolbox=toolbox, points=eval_range) # add filters for unwanted behaviour for filter_ in filters: toolbox.decorate('evaluate', tools.DeltaPenalty(filter_, [1000., 0.])) toolbox.register("select", tools.selSPEA2) toolbox.register("mate", gp.cxOnePoint) toolbox.register("expr_mut", gp.genFull, min_=0, max_=2) toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset) toolbox.decorate( "mate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mate", gp.staticLimit(key=len, max_value=20)) toolbox.decorate( "mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) toolbox.decorate("mutate", gp.staticLimit(key=len, max_value=20)) return toolbox
def configuracionAlgoritmo(toolbox): # Se seleccionan procedimiento standard para cruce, mutacion y seleccio toolbox.register("mate", tools.cxOrdered) toolbox.register("mutate", tools.mutShuffleIndexes, indpb=0.2) toolbox.register("select", tools.selTournament, tournsize=3) # Se define cómo se evaluará cada individuo # En este caso, se hará uso de la función de evaluación que se ha definido en el modulo Evaluacion.py toolbox.register("evaluate", eval) toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 0, distance))
def setup(self, fitness_function_handle, constraint=None, GENOME_LENGTH=20, POPULATION_SIZE=100, P_CROSSOVER=0.5, P_MUTATION=0.2, vartype="float"): '''Set up the standard parameters''' # Set the main variables self.GENOME_LENGTH = GENOME_LENGTH self.POPULATION_SIZE = POPULATION_SIZE self.P_CROSSOVER = P_CROSSOVER self.P_MUTATION = P_MUTATION # Set the lower level parameters self.toolbox = base.Toolbox() # Boolean or float evolution if vartype == "boolean": self.toolbox.register("attr_bool", random.randint, 0, 1) self.toolbox.register("individual", tools.initRepeat, creator.Individual, self.toolbox.attr_bool, GENOME_LENGTH) self.toolbox.register("mutate", tools.mutUniformInt, low=0, up=1, indpb=0.05) elif vartype == "float": self.toolbox.register("attr_float", random.random) self.toolbox.register("individual", tools.initRepeat, creator.Individual, self.toolbox.attr_float, self.GENOME_LENGTH) self.toolbox.register("mutate", tools.mutPolynomialBounded, eta=0.1, low=0.0, up=1.0, indpb=0.1) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("evaluate", fitness_function_handle) self.toolbox.register("mate", tools.cxUniform, indpb=0.1) self.toolbox.register("select", tools.selTournament, tournsize=3) if constraint is not None: self.toolbox.decorate( "evaluate", tools.DeltaPenalty(constraint, 0, self.distance)) self.stats = [] # Initialize stats vector
def prepare_toolbox(dataset: Dataset): creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() # typ i zakres genu osobnika rand_initialier = RandInitializer(NCLUSTERS, dataset.ncolumns, min=0., max=1.) toolbox.register("attr_float", rand_initialier.get_rand_val) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, NCLUSTERS * dataset.ncolumns) # populacja to lista osobników toolbox.register("population", tools.initRepeat, list, toolbox.individual) # wybór funkcji przystosowania toolbox.register("evaluate", dataset.evaluate) # funkcja kary arg_min = 0 arg_max = 1 def feasible(individual): for coord in individual: if coord < arg_min or coord > arg_max: return False return True def distance(individual): # tuple to float fit_val = dataset.evaluate(individual)[0] for x in individual: if x < arg_min: fit_val += 10**(1 + (arg_min - x)) if x > arg_max: fit_val += 10**(1 + (x - arg_max)) return fit_val, toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 0.0, distance)) # wybór metody krzyżowania toolbox.register("mate", tools.cxUniform, indpb=0.2) #wybór metody mutacji toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.05, indpb=0.3) # wybór metody selekcji toolbox.register("select", tools.selTournament, tournsize=2) return toolbox
def generate_toolbox(self, size, nmin, nmax, smin, smax, lmin, lmax, phi1, phi2): toolbox = base.Toolbox() toolbox.register("particle", ParticleSwarmOptimizer.generate, size=size, nmin=nmin, nmax=nmax, smin=smin, smax=smax, lmin=lmin, lmax=lmax) toolbox.register("population", tools.initRepeat, list, toolbox.particle) toolbox.register( "update", ParticleSwarmOptimizer.updateParticle, phi1=phi1, phi2=phi2) toolbox.register("evaluate", TransferMatrixMethod.evaluate_solution) toolbox.decorate("evaluate", tools.DeltaPenalty( ParticleSwarmOptimizer.feasible, -1.0)) return toolbox
def register(self): """REGISTERING GENES""" creator.create('FitnessMin', base.Fitness, weights=(-1.0,)) creator.create('Individual', list, fitness=creator.FitnessMin) self.toolbox.register('position', random.choice, self.possible) self.toolbox.register('first', lambda x: x, self.startpoint) self.toolbox.register('last', lambda x: x, self.endpoint) """INDIVIDUAL""" self.toolbox.register('individual', tools.initCycle, creator.Individual, (self.toolbox.first, self.toolbox.position, self.toolbox.position, self.toolbox.position, self.toolbox.position, self.toolbox.last), n=1) """POPULATION""" self.toolbox.register('population', tools.initRepeat, list, self.toolbox.individual) self.toolbox.register('evaluate', self.distance) self.toolbox.decorate('evaluate', tools.DeltaPenalty(self.validate, inf)) self.toolbox.register('mate', tools.cxTwoPoint) # crossover operator self.toolbox.register('mutate', tools.mutShuffleIndexes, indpb=0.5) # mutation operator self.toolbox.register('select', tools.selTournament, tournsize=3) # selecting 3 best individuals from batch
def create_toolbox(r_lower, r_upper): creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("IndividualContainer", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() #2 or 2 toolbox.register("InitialValue1", random.uniform, r_lower, r_upper) toolbox.register("indiv", tools.initRepeat, creator.IndividualContainer, toolbox.InitialValue1, 1) #toolbox.register( "InitialValue2",random.randint, N_lower, N_upper) #toolbox.register( "indiv", tools.initCycle, creator.IndividualContainer, (toolbox.InitialValue1, toolbox.InitialValue2), n=1) toolbox.register("population", tools.initRepeat, list, toolbox.indiv) toolbox.register("evaluate", FuncEvaluation) toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 100, distance)) ### examplar evolving functions toolbox.register("mate", tools.cxBlend, alpha=0.4) toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.8) toolbox.register("select", tools.selTournament, tournsize=5) return toolbox
def main(target_function=target_fun, penalty=True, **globals_dict): initialize_globals(**globals_dict) '''registering object and function in environment''' toolbox.register("individual", generate_ev_s, creator.Individual, creator.Strategy, IND_SIZE, EVO_STRATEGY, ATTR_RANGE) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", evaluate, target_function=target_function) if penalty: toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 1000, distance)) # out of region penalty toolbox.register("mate", tools.cxESTwoPoint) toolbox.decorate("mate", check_strategy(EVO_STRATEGY)) # toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=MUT_PROB) #mutESLogNormal has low efficiency toolbox.register("mutate", custom_mutation, mu=0, sigma=1) toolbox.decorate("mutate", check_strategy(EVO_STRATEGY)) toolbox.register("select", tools.selTournament, tournsize=T_SIZE) # selBest as an alternative? pop = toolbox.population(n=POP_SIZE) hof = tools.HallOfFame(1) fitness_stats = tools.Statistics(lambda ind: ind.fitness.values) strategy_stats = tools.Statistics(lambda ind: ind.strategy) stats = tools.MultiStatistics(fitness=fitness_stats, strategy=strategy_stats) stats.register("avg", np.mean) stats.register("std", np.std) stats.register("min", np.min) stats.register("max", np.max) result, log = algorithms.eaMuPlusLambda(pop, toolbox, POP_SIZE, POP_SIZE, MUT_PROB, MAT_PROB, ngen=EVO_CYCLES, stats=stats, halloffame=hof, verbose=False) result.sort(key=lambda x: x.fitness.values) return (result, log, hof)
def optim(MU, NGEN, path): # load the shp of the scenario #in_pts = "D:/04_PROJECTS/2001_WIND_OPTIM/WIND_OPTIM_git/intermediate_steps/3_wp/NSGA3_RES/in/B3.shp" #load in memory #all_pts = r"in_memory/inMemoryFeatureClass" all_pts = path #arcpy.CopyFeatures_management(in_pts, all_pts) #transform it to numpy array na = arcpy.da.TableToNumPyArray(all_pts, ['WT_ID', 'ENER_DENS', 'prod_MW']) # CXPB is the probability with which two individuals # are crossed # MUTPB is the probability for mutating an individual CXPB, MUTPB = 0.7, 0.4 #MU,NGEN =20, 10 enertarg = 4300000 #some parameters to define the random individual nBITS = len(na) #production of energy sum_MW = np.sum(na['prod_MW']) low_targ = enertarg up_targ = enertarg * 1.07 #the function to determine the initial random population which might reach the energy target def initial_indi(): # relative to the total energy production to build the initial vector bound_up = (1.0 * up_targ / sum_MW) bound_low = (1.0 * low_targ / sum_MW) x3 = random.uniform(bound_low, bound_up) return np.random.choice([1, 0], size=(nBITS, ), p=[x3, 1 - x3]) #some lists for the evaluation function enerd = list(na['ENER_DENS']) prod = list(na['prod_MW']) id = np.array(na['WT_ID']) #the evaluation function, taking the individual vector as input def evaluate(individual): individual = individual[0] #first check if the production of the seleced WT's is in the range between 4.31 and 4.29 TWH # goal 1 mean_enerdsel = sum( x * y for x, y in zip(enerd, individual)) / sum(individual) # goal 2 count_WTsel = sum(individual) # goal 3 (subset the input points by the WT_IDs which are in the ini pop (=1) WT_pop = np.column_stack((id, individual)) WT_sel = WT_pop[WT_pop[:, [1]] == 1] WT_sel = WT_sel.astype(int) qry = '"WT_ID" IN ' + str(tuple(WT_sel)) subset = arcpy.MakeFeatureLayer_management(all_pts, "tmp", qry) nn_output = arcpy.AverageNearestNeighbor_stats(subset, "EUCLIDEAN_DISTANCE", "NO_REPORT", "41290790000") clus = float(nn_output.getOutput(0)) res = (clus, count_WTsel, mean_enerdsel) ## delete the feature tmp since otherwise it will not work in a loop arcpy.Delete_management("tmp") arcpy.Delete_management("subset") return (res) def feasible(individual): individual = individual[0] prod_MWsel = sum(x * y for x, y in zip(prod, individual)) if (prod_MWsel <= up_targ and prod_MWsel >= low_targ): return True return False ### setup NSGA3 with deap (minimize the first two goals returned by the evaluate function and maximize the third one) creator.create("FitnessMulti", base.Fitness, weights=(-1.0, -1.0, 1.0)) creator.create("Individual", list, fitness=creator.FitnessMulti) ref_points = tools.uniform_reference_points(nobj=3, p=12) ##setup the optim toolbox I do not understand that totally toolbox = base.Toolbox() #initial individual and pop toolbox.register("initial_indi", initial_indi) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.initial_indi, n=1) toolbox.register("population", tools.initRepeat, list, toolbox.individual) #evaluation and constraints toolbox.register("evaluate", evaluate) ##assign the feasibility of solutions and if not feasible a large number for the minimization tasks and a small number for the maximization task toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, (10e20, 10e20, 0))) #mate, mutate and select to perform crossover toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selNSGA3, ref_points=ref_points) # initialize pareto front pareto = tools.ParetoFront(similar=np.array_equal) first_stats = tools.Statistics(key=lambda ind: ind.fitness.values[0]) second_stats = tools.Statistics(key=lambda ind: ind.fitness.values[1]) third_stats = tools.Statistics(key=lambda ind: ind.fitness.values[2]) first_stats.register("min_clus", np.min, axis=0) second_stats.register("min_WT", np.min, axis=0) third_stats.register("max_enerd", np.max, axis=0) logbook1 = tools.Logbook() logbook2 = tools.Logbook() logbook3 = tools.Logbook() logbook1.header = "gen", "evals", "TIME", "min_clus" logbook2.header = "gen", "evals", "min_WT" logbook2.header = "gen", "evals", "max_enerd" pop = toolbox.population(n=MU) # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in pop if not ind.fitness.valid] # invalid_ind = pop start_time = time.time() fitnesses = list(toolbox.map(toolbox.evaluate, invalid_ind)) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit end_time = time.time() delt_time = end_time - start_time ## Hyper volume # hv.hypervolume() # Compile statistics about the population record1 = first_stats.compile(pop) logbook1.record(gen=0, evals=len(invalid_ind), TIME=delt_time, **record1) record2 = second_stats.compile(pop) logbook2.record(gen=0, evals=len(invalid_ind), **record2) record3 = third_stats.compile(pop) logbook3.record(gen=0, evals=len(invalid_ind), **record3) # Begin the evolution with NGEN repetitions for gen in range(1, NGEN): print("-- Generation %i --" % gen) start_time = time.time() 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[0], child2[0]) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < MUTPB: toolbox.mutate(mutant[0]) del mutant.fitness.values # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = list(toolbox.map(toolbox.evaluate, invalid_ind)) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit end_time = time.time() delt_time = end_time - start_time #select the next generation with NSGA3 from pop and offspring of size MU pop = toolbox.select(pop + offspring, MU) pareto.update(pop) # Compile statistics about the new population record1 = first_stats.compile(invalid_ind) logbook1.record(gen=gen, evals=len(invalid_ind), TIME=delt_time, **record1) record2 = second_stats.compile(invalid_ind) logbook2.record(gen=gen, evals=len(invalid_ind), **record2) record3 = third_stats.compile(invalid_ind) logbook3.record(gen=gen, evals=len(invalid_ind), **record3) print("--- %s seconds ---" % delt_time) # pareto fitnes values fitness_pareto = toolbox.map(toolbox.evaluate, pareto) fitness_pareto = np.array(fitness_pareto) fitness_pareto = { 'CLUS': fitness_pareto[:, 0], 'N_WT': fitness_pareto[:, 1], 'ENERDENS': fitness_pareto[:, 2] } #pareto items and robustness par_items = np.array(pareto.items) par_rob = np.array(1.0 * sum(par_items[1:len(par_items)]) / len(par_items)) par_rob = par_rob.ravel() par_rob_mat = np.column_stack((id, par_rob)) par_rob_mat = {'WT_ID2': par_rob_mat[:, 0], 'par_rob': par_rob_mat[:, 1]} #last items and robustness last_rob = np.array(invalid_ind) last_rob = np.array(1.0 * sum(last_rob[1:len(last_rob)]) / len(last_rob)) last_rob = last_rob.ravel() last_rob_mat = np.column_stack((id, last_rob)) last_rob_mat = { 'WT_ID2': last_rob_mat[:, 0], 'last_rob': last_rob_mat[:, 1] } #logbook gen = np.array(logbook1.select('gen')) TIME = np.array(logbook1.select('TIME')) WT = np.array(logbook2.select('min_WT')) clus = np.array(logbook1.select('min_clus')) enerd = np.array(logbook3.select('max_enerd')) logbook = np.column_stack((gen, TIME, WT, clus, enerd)) logbook = { 'GENERATION': logbook[:, 0], 'TIME': logbook[:, 1], 'N_WT': logbook[:, 2], 'CLUS': logbook[:, 3], 'ENERDENS': logbook[:, 4] } arcpy.Delete_management("all_pts") arcpy.Delete_management("in_pts") arcpy.Delete_management("na") arcpy.Delete_management("in_memory/inMemoryFeatureClass") return par_rob_mat, last_rob_mat, fitness_pareto, logbook
elif len(individual) > 5: # delete a track del individual[random.choice(range(0, len(individual)))] return creator.Individual(individual), NUM_SONGS = 20 toolbox = base.Toolbox() toolbox.register("tracks", random.sample, all_tracks, NUM_SONGS) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.tracks) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", evalPlaylist, desired_play_time=120) invalidPlaylistScore = (sys.float_info.max, sys.float_info.max, sys.float_info.max, sys.float_info.max, sys.float_info.max, sys.float_info.max, sys.float_info.max, 0.0, 0.0, 0.0) toolbox.decorate("evaluate", tools.DeltaPenalty(validPlaylist, invalidPlaylistScore)) toolbox.register("mate", tools.cxOnePoint) toolbox.register("mutate", mutatePlaylist) toolbox.register("select", tools.selNSGA2) # Simulation parameters: # Number of generations NGEN = 5000 # The number of individuals to select for the next generation (eliminate bad ones). MU = 500 # The number of children to produce at each generation. LAMBDA = 50 # The probability that an offspring is produced by crossover. CXPB = 0.5 # The probability that an offspring is produced by mutation. MUTPB = 0.5
def fit(self): """ Setting up the DEAP - genetic algorithm parameters and functions. Notes ----- Must call this function before calling any algorithm. """ creator.create("FitnessMin", base.Fitness, weights=self.Weights) creator.create("Individual", list, fitness=creator.FitnessMin) self.toolbox = base.Toolbox() self.toolbox.register("individual", tools.initIterate, creator.Individual, self.chromosome_generator) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) if self.crossover_type == "OnePoint": self.toolbox.register("mate", tools.cxOnePoint) elif self.crossover_type == "TwoPoint": self.toolbox.register("mate", tools.cxTwoPoint) elif self.crossover_type == "Uniform": self.toolbox.register("mate", tools.cxUniform, indpb=self.crossover_prob) elif self.crossover_type == "Blend": self.toolbox.register("mate", tools.cxBlend, alpha=0.5) self.toolbox.register("selectTournament", tools.selTournament, tournsize=30) self.toolbox.register("selectRoulette", tools.selRoulette) def feasibility(indi): for x, i in zip(indi, range(self.chromosome_length)): if self.chromosome_length == 1: if self.bit_limits[0] <= x <= self.bit_limits[1]: continue else: return False else: if self.bit_limits[i][0] <= x <= self.bit_limits[i][1]: continue else: return False return True def distance(indi): s = 0 for x, i in zip(indi, range(self.chromosome_length)): if self.chromosome_length == 1: low = self.bit_limits[0] up = self.bit_limits[1] else: low = self.bit_limits[i][0] up = self.bit_limits[i][1] if x < low: s += ((x - low) * 100)**2 elif x > up: s += ((x - up) * 100)**2 return s self.toolbox.register("evaluate", self.evaluate) self.toolbox.decorate( "evaluate", tools.DeltaPenalty(feasibility, -100.0 * self.Weights[0], distance))
logbook.chapters['runtime'].header = 'start', classifier = GaussianNB() # classifier = MLPClassifier(solver='lbfgs', activation='relu', alpha=1e-5, max_iter=1000, hidden_layer_sizes=(100,60), random_state=RANDOMSTATE) cv = StratifiedShuffleSplit(n_splits=NSPLITS, test_size=TESTSIZE, random_state=RANDOMSTATE) #cv = StratifiedKFold(n_splits=NSPLITS, shuffle=True, random_state=RANDOMSTATE) tb.register('evaluate', evaluate_ml_classifier, data=test_X, target=test_y, classifier=classifier, cross_val=cv) tb.decorate('evaluate', tools.DeltaPenalty(feasible, (0, -60))) # Initial population pop = tb.population(n=POPSIZE) invalid = evaluate_population_fitness(tb, pop) pop = tb.select(pop, len(pop)) np.set_printoptions(precision=2) record = mstats.compile(pop) logbook.record(gen=0, evals=invalid, **record) print(logbook.stream) # Iterative mode on plt.ion() fig, ax = plt.subplots(dpi=150) ax.set_xlim([0, 1]) ax.set_ylim([-60, 0])
toolbox = base.Toolbox() #initial individual and pop toolbox.register("initial_indi", initial_indi) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.initial_indi, n=1) toolbox.register("population", tools.initRepeat, list, toolbox.individual) #evaluation and constraints toolbox.register("evaluate", evaluate) ##assign the feasibility of solutions and if not feasible a large number for the minimization tasks and a small number for the maximization task toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, (10e20, 10e20, 0))) #mate, mutate and select to perform crossover toolbox.register("mate", tools.cxTwoPoint) #toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("mutate", tools.mutPolynomialBounded, low=0, up=1, eta=20, indpb=0.05) toolbox.register("select", tools.selNSGA3, ref_points=ref_points) ## the optimization (n seems to be the number of individuals aka population size MU #def main(): # initialize pareto front
toolbox.register('mutate', tools.mutFlipBit, indpb=0.6) toolbox.register('select', tools.selNSGA2) toolbox.register('evaluate', J) listCons = [ geom_cons_1, geom_cons_2, geom_cons_3, geom_cons_4, geom_cons_5, geom_cons_6, geom_cons_7, geom_cons_9, func_cons_1, func_cons_2, func_cons_3, func_cons_4 ] listDist = [ geom_cons_1_dist, geom_cons_2_dist, geom_cons_3_dist, geom_cons_4_dist, geom_cons_5_dist, geom_cons_6_dist, geom_cons_7_dist, geom_cons_9_dist, func_cons_1_dist, func_cons_2_dist, func_cons_3_dist, func_cons_4_dist ] for i in range(len(listCons)): toolbox.decorate("evaluate", tools.DeltaPenalty(listCons[i], 12.0)) # pareto=tools.ParetoFront() population = toolbox.population(n=population_size) # fits=toolbox.map(toolbox.evaluate,population) # for fit,ind in zip(fits,population): # ind.fitness.values=fit # pareto.update(population) # counter = 0 # for gen in range(num_generations): # offspring=algorithms.varAnd(population,toolbox,cxpb=1.0,mutpb=0.1) # fits=toolbox.map(toolbox.evaluate,population) # for fit,ind in zip(fits,offspring): # ind.fitness.values=fit # population=toolbox.select(offspring+population,k=population_size) # pareto.update(population)
def registerEvaluate(self): evaluate = lambda ind: (self.fitnessUtils.computeFMeasure(ind), ) self.toolbox.register("evaluate", evaluate) self.toolbox.decorate("evaluate", tools.DeltaPenalty(self.feasible, 0.0))
individual.update([random.choice(ITEMS_NAME)]) else: val = random.choice(ITEMS_NAME) individual.subtract([val]) if individual[val] < 0: del individual[val] return individual, import sys # register the functions, some with extra fixed arguments (like target_price) toolbox.register("evaluate", evalXKCD, target_price=15.05) # severely penalize individuals that are over budget ($15.05)) # return a fixed terrible fitness toolbox.decorate("evaluate", tools.DeltaPenalty(lambda ind: evalXKCD(ind, 15.05)[0] <= 0, (-sys.float_info.max, sys.float_info.max, -sys.float_info.max))) toolbox.register("mate", cxCounter, indpb=0.5) toolbox.register("mutate", mutCounter) toolbox.register("select", tools.selNSGA2) # Simulation parameters: # Number of generations = 100 NGEN = 100 # The number of individuals to select for the next generation (eliminate bad ones). MU = 50 # The number of children to produce at each generation. LAMBDA = 20 # The probability that an offspring is produced by crossover. CXPB = 0.3
and (engine_design_point_pressure >= 33000 and engine_design_point_pressure <= 43000) and (engine_design_point_mach >= 0.74 and engine_design_point_mach <= 0.82) and (engine_position >= 0 and engine_position <= 1) and (winglet_presence >= 0 and winglet_presence <= 1) and (slat_precense >= 0 and slat_precense <= 1) and (attr_horizontal_tail_position >= 0 and attr_horizontal_tail_position <= 1)): return True return False toolbox.register("evaluate", evavl) toolbox.decorate("evaluate", tools.DeltaPenalty(feaseGeom, [ 1.0, ])) def main(): pop = toolbox.population(n=10) hof = tools.HallOfFame(5) 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) pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5,
toolbox.register("evaluate", simionescu) # define the valid input domain using the cosntraints: def feasible(individual): """Feasibility function for the individual. Returns True if feasible, False otherwise. """ x = individual[0] y = individual[1] return x**2 + y**2 <= (1 + 0.2 * math.cos(8.0 * math.atan2(x, y)))**2 # decorate the fitness function with the delta penalty function: toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, PENALTY_VALUE)) # genetic operators: toolbox.register("select", tools.selTournament, tournsize=2) toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=BOUND_LOW, up=BOUND_UP, eta=CROWDING_FACTOR) toolbox.register("mutate", tools.mutPolynomialBounded, low=BOUND_LOW, up=BOUND_UP, eta=CROWDING_FACTOR, indpb=1.0 / DIMENSIONS)
otherwise.""" if -0.5 < individual[0] < 0.5: return True return False # from https://deap.readthedocs.io/en/master/tutorials/advanced/constraints.html def distance(individual): """A distance function to the feasibility region.""" return (individual[0] - 0.0)**2 toolbox.register("evaluate", evalOneMax) # Here we apply a feasible constraint: # https://deap.readthedocs.io/en/master/tutorials/advanced/constraints.html toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 1.0, distance)) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) ##This is different!################################# toolbox.register("map", ray_deap_map, creator_setup=creator_setup) ###################################################### if __name__ == "__main__": random.seed(64) pop = toolbox.population(n=300) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values)
creator.create("FitnessMax", d_base.Fitness, weights=(1.0, )) creator.create("Individual", list, fitness=creator.FitnessMax) toolbox = d_base.Toolbox() toolbox.register("indices", routeInit) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.indices) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("mate", tools.cxTwoPoints) toolbox.register("mutate", tools.mutFlipBit, indpb=0.1) # mutation toolbox.register("select", tools.selTournament, tournsize=3) # selection toolbox.register("evaluate", evalTSP) # evaluation toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, -20, routeQ)) # penalization #%% def main(): random.seed(80) # As the algorithm converge rapidly to a solution and tends to stay around it, # the population is set to a higher value, and number of generations to a lower value # This will provide the algorithm with a better ability to match with the optimal solution CXPB, MUTPB, NIND, NGEN = 0.8, 0.1, 500, 40 pop = toolbox.population(NIND) # Save best individual and register data hof = tools.HallOfFame(1)
def ejecucion_ga(conn, ga_params): creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individuo", list, fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register("coordenada", crear_coordenadas, mapa=ga_params.get('barrios_caba_gdf'), poligono=ga_params.get('poligonos_caba')) toolbox.register("individuo", tools.initRepeat, creator.Individuo, toolbox.coordenada, n=ga_params.get('q_coord')) toolbox.register("poblacion", tools.initRepeat, list, toolbox.individuo) toolbox.register("mate", cxBlend_custom) toolbox.register("mutate", mutGaussian_custom, indpb=ga_params.get('mut_prob_alelo')) if ga_params.get('tipo_seleccion') == 1: toolbox.register("select", tools.selRoulette) else: toolbox.register("select", tools.selTournament, tournsize=ga_params.get('torneo_tam')) toolbox.register("evaluate", funcion_objetivo, Q_COORD = ga_params.get('q_coord'), area=ga_params.get('area')) toolbox.register("map", futures.map) toolbox.decorate("evaluate", tools.DeltaPenalty(validar_individuo, 0)) print('Ejecutando experimento {}'.format(ga_params.get('tipo_seleccion'))) ''' config_id = base_de_datos.insert_config(conn, ga_params.get('q_ind'), ga_params.get('q_coord'), ga_params.get('mut_prob'), ga_params.get('cross_prob'), ga_params.get('mut_prob_alelo'), ga_params.get('tipo_seleccion'), ga_params.get('torneo_tam'), ga_params.get('mu_x'), ga_params.get('mu_y'), ga_params.get('sigma_x'), ga_params.get('sigma_y'), ga_params.get('generacion_parada'), ga_params.get('alpha')) ''' pop = toolbox.poblacion(n=ga_params.get('q_ind')) fitnesses = list(map(toolbox.evaluate, pop)) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit fits = [ind.fitness.values[0] for ind in pop] g = 0 print('Generacion {} - Max Fit: {} Avg Fit {}'.format(g, max(fits), np.average(fits))) # generacion_id = base_de_datos.insert_generacion(conn, g, config_id) ''' for i, ind in enumerate(pop): individuo_id = base_de_datos.insert_individuo(conn, i, generacion_id, ind.fitness.values[0]) list_puntos = zip(count(start=1), repeat(individuo_id), [x.wkt for x in ind]) base_de_datos.insert_punto(conn, list(list_puntos)) ''' # Begin the evolution while max(fits) < 2.15 and g < 300:#ga_params.get('generacion_parada'): # A new generation g = g + 1 print('Generacion {} - Max Fit: {} Avg Fit {}'.format(g, max(fits), np.average(fits))) #generacion_id = base_de_datos.insert_generacion(conn, g, config_id) # 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() < ga_params.get('cross_prob'): toolbox.mate(child1, child2, ga_params.get('alpha')) # random.random()) del child1.fitness.values del child2.fitness.values for mutant in offspring: if random.random() < ga_params.get('mut_prob'): toolbox.mutate(mutant, ga_params.get('mu_x'), ga_params.get('sigma_x'), ga_params.get('mu_y'), ga_params.get('sigma_y')) del mutant.fitness.values # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] ''' for i, ind in enumerate(pop): individuo_id = base_de_datos.insert_individuo(conn, i, generacion_id, ind.fitness.values[0]) list_puntos = zip(count(start=1), repeat(individuo_id), [x.wkt for x in ind]) base_de_datos.insert_punto(conn, list(list_puntos)) base_de_datos.update_config(conn, config_id) ''' ''' Termina la ejecución y limpieza de variables, clases y funciones ''' toolbox.unregister('select') toolbox.unregister('poblacion') toolbox.unregister('individuo') del creator.Individuo del creator.FitnessMax
def distance(individual): """A distance function to the feasibility region.""" return (individual[0] - 5.0)**2 #register individuals toolbox = base.Toolbox() toolbox.register("attr_float", random.uniform, 0.90, 1.10) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, 5) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("mate", tools.cxTwoPoints) toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) toolbox.register("evaluate", objective) toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, -100.0)) CXPB, MUTPB = 0.5, 1.0 restart = True restart_file = "ga_restart.pkl" save_file = "ga_restart3.pkl" #restart from file if restart: with open(restart_file, "r") as cp_file: cp = pickle.load(cp_file) population = cp["population"] start_gen = cp["generation"]
def feasible(individual): #global jobFile, macroFile """Feasibility function for the individual. Returns True if feasible False otherwise.""" stress, disp = analyseStructure(jobFile, macroFile, individual) # need to make this function if compStressLim < stress < tensStressLim and dispLimLow < disp < dispLimUp: return True return False toolbox.register("evaluate", fitFunc) toolbox.decorate("evaluate", tools.DeltaPenalty( feasible, 10.0)) # applies penalty of 10 to result if it is unfeasible. toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) jobFile = 'Job-1.inp' macroFile = r'C:\Users\pqb18127\OneDrive\PhD\Training\NAFEMS Homework 1\dataOut.py' simResults = 'data.csv' def main(): pop = toolbox.population(n=300) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", np.mean)
HALL_OF_FAME_SIZE = 30 # Fitness creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create('Individual', list, fitness=creator.FitnessMin) # God toolbox = base.Toolbox() toolbox.register('random_float', random.uniform, BOUND_LOW, BOUND_HIGH) toolbox.register('individual_creator', tools.initRepeat, creator.Individual, toolbox.random_float, DIMENSIONS) toolbox.register('population_creator', tools.initRepeat, list, toolbox.individual_creator) # Evaluate toolbox.register('evaluate', simionescu) toolbox.decorate('evaluate', tools.DeltaPenalty(feasibility, CONSTRAINT_PENALTY)) # Genetic operators toolbox.register('select', tools.selTournament, tournsize=TOURNAMENT_SIZE) toolbox.register('mate', tools.cxSimulatedBinaryBounded, low=BOUND_LOW, up=BOUND_HIGH, eta=CROWDING_FACTOR) toolbox.register('mutate', tools.mutPolynomialBounded, low=BOUND_LOW, up=BOUND_HIGH, eta=CROWDING_FACTOR, indpb=1.0 / DIMENSIONS)