Python deap.tools.initRepeat() Examples
The following are 14
code examples of deap.tools.initRepeat().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
deap.tools
, or try the search function
.
Example #1
Source File: base.py From tpot with GNU Lesser General Public License v3.0 | 6 votes |
def _setup_toolbox(self): with warnings.catch_warnings(): warnings.simplefilter('ignore') creator.create('FitnessMulti', base.Fitness, weights=(-1.0, 1.0)) creator.create('Individual', gp.PrimitiveTree, fitness=creator.FitnessMulti, statistics=dict) self._toolbox = base.Toolbox() self._toolbox.register('expr', self._gen_grow_safe, pset=self._pset, min_=self._min, max_=self._max) self._toolbox.register('individual', tools.initIterate, creator.Individual, self._toolbox.expr) self._toolbox.register('population', tools.initRepeat, list, self._toolbox.individual) self._toolbox.register('compile', self._compile_to_sklearn) self._toolbox.register('select', tools.selNSGA2) self._toolbox.register('mate', self._mate_operator) if self.tree_structure: self._toolbox.register('expr_mut', self._gen_grow_safe, min_=self._min, max_=self._max + 1) else: self._toolbox.register('expr_mut', self._gen_grow_safe, min_=self._min, max_=self._max) self._toolbox.register('mutate', self._random_mutation_operator)
Example #2
Source File: evolutionHooks.py From japonicus with MIT License | 6 votes |
def getGlobalToolbox(representationModule): # GLOBAL FUNCTION TO GET GLOBAL TBX UNDER DEVELOPMENT; toolbox = base.Toolbox() creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create( "Individual", list, fitness=creator.FitnessMax, PromoterMap=None, Strategy=genconf.Strategy, ) toolbox.register("mate", representationModule.crossover) toolbox.register("mutate", representationModule.mutate) PromoterMap = initPromoterMap(Attributes) toolbox.register("newind", initInd, creator.Individual, PromoterMap) toolbox.register("population", tools.initRepeat, list, toolbox.newind) toolbox.register("constructPhenotype", representationModule.constructPhenotype) return toolbox
Example #3
Source File: moga.py From ocelot with GNU General Public License v3.0 | 5 votes |
def init_deap_functions(self): creator.create("Fitness", base.Fitness, weights=self.weights) creator.create("Individual", list, fitness=creator.Fitness) self.toolbox = base.Toolbox() self.toolbox.register("individual", tools.initIterate, creator.Individual, self.generate_ind) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("evaluate", self.fit_func) if self.penalty != None: self.toolbox.decorate("evaluate", tools.DeltaPenality(self.feasible, self.inf_val))
Example #4
Source File: create_toolbox.py From pyleecan with Apache License 2.0 | 5 votes |
def create_toolbox(self): """OptiGenAlgNsga2Deap method to create DEAP toolbox Parameters ---------- self : OptiGenAlgNsga2Deap Returns ------- self : OptiGenAlgNsga2Deap OptiGenAlgNsga2Deap with toolbox created """ # Create toolbox self.toolbox = base.Toolbox() # Create Fitness and individual creator.create( "FitnessMin", base.Fitness, weights=[-1 for _ in self.problem.design_var] ) creator.create("Individual", list, typecode="d", fitness=creator.FitnessMin) self.toolbox.register("creator", creator.Individual) # Register individual and population self.toolbox.register( "individual", create_indiv, self.toolbox.creator, self.problem.output, self.problem.design_var, ) self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual)
Example #5
Source File: gaFeatureSelection.py From GeneticAlgorithmForFeatureSelection with MIT License | 5 votes |
def geneticAlgorithm(X, y, n_population, n_generation): """ Deap global variables Initialize variables to use eaSimple """ # create individual creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) # create toolbox toolbox = base.Toolbox() toolbox.register("attr_bool", random.randint, 0, 1) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, len(X.columns)) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", getFitness, X=X, y=y) toolbox.register("mate", tools.cxOnePoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) # initialize parameters pop = toolbox.population(n=n_population) hof = tools.HallOfFame(n_population * n_generation) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", np.mean) stats.register("min", np.min) stats.register("max", np.max) # genetic algorithm pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=n_generation, stats=stats, halloffame=hof, verbose=True) # return hall of fame return hof
Example #6
Source File: bit_counter.py From Artificial-Intelligence-with-Python with MIT License | 5 votes |
def create_toolbox(num_bits): creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) # Initialize the toolbox toolbox = base.Toolbox() # Generate attributes toolbox.register("attr_bool", random.randint, 0, 1) # Initialize structures toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, num_bits) # Define the population to be a list of individuals toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Register the evaluation operator toolbox.register("evaluate", eval_func) # Register the crossover operator toolbox.register("mate", tools.cxTwoPoint) # Register a mutation operator toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) # Operator for selecting individuals for breeding toolbox.register("select", tools.selTournament, tournsize=3) return toolbox
Example #7
Source File: symbol_regression.py From Artificial-Intelligence-with-Python with MIT License | 5 votes |
def create_toolbox(): pset = gp.PrimitiveSet("MAIN", 1) pset.addPrimitive(operator.add, 2) pset.addPrimitive(operator.sub, 2) pset.addPrimitive(operator.mul, 2) pset.addPrimitive(division_operator, 2) pset.addPrimitive(operator.neg, 1) pset.addPrimitive(math.cos, 1) pset.addPrimitive(math.sin, 1) pset.addEphemeralConstant("rand101", lambda: random.randint(-1,1)) pset.renameArguments(ARG0='x') creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("evaluate", eval_func, points=[x/10. for x in range(-10,10)]) toolbox.register("select", tools.selTournament, tournsize=3) 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("mutate", gp.staticLimit(key=operator.attrgetter("height"), max_value=17)) return toolbox
Example #8
Source File: robot.py From Artificial-Intelligence-with-Python with MIT License | 5 votes |
def create_toolbox(): global robot, pset pset = gp.PrimitiveSet("MAIN", 0) pset.addPrimitive(robot.if_target_ahead, 2) pset.addPrimitive(Prog().prog2, 2) pset.addPrimitive(Prog().prog3, 3) pset.addTerminal(robot.move_forward) pset.addTerminal(robot.turn_left) pset.addTerminal(robot.turn_right) creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax) toolbox = base.Toolbox() # Attribute generator toolbox.register("expr_init", gp.genFull, pset=pset, min_=1, max_=2) # Structure initializers toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr_init) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", eval_func) toolbox.register("select", tools.selTournament, tournsize=7) 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) return toolbox
Example #9
Source File: oldschool.py From japonicus with MIT License | 5 votes |
def getToolbox(Strategy, genconf, Attributes): toolbox = base.Toolbox() creator = Creator.init(base.Fitness, {'Strategy': Strategy}) toolbox.register("newind", initInd, creator.Individual, Attributes) toolbox.register("population", tools.initRepeat, list, toolbox.newind) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutUniformInt, low=10, up=10, indpb=0.2) toolbox.register("constructPhenotype", constructPhenotype, Attributes) return toolbox
Example #10
Source File: chromosome.py From japonicus with MIT License | 5 votes |
def getToolbox(Strategy, genconf, Attributes): toolbox = base.Toolbox() creator = Creator.init(base.Fitness, {'promoterMap': None, 'Strategy': Strategy}) # creator.create("FitnessMax", base.Fitness, weights=(1.0, 3)) toolbox.register("mate", pachytene) toolbox.register("mutate", mutate) PromoterMap = initPromoterMap(Attributes) toolbox.register( "newind", initInd, creator.Individual, PromoterMap, genconf.chromosome ) toolbox.register("population", tools.initRepeat, list, toolbox.newind) toolbox.register( "constructPhenotype", constructPhenotype, Attributes, genconf.chromosome ) return toolbox
Example #11
Source File: truncation_elite.py From fast-symbolic-regression with GNU General Public License v3.0 | 4 votes |
def get_toolbox(self, predictors, response, pset, variable_type_indices, variable_names): subset_size = int(math.floor(predictors.shape[0] * self.subset_proportion)) creator.create("Error", base.Fitness, weights=(-1.0,)) creator.create("Individual", sp.SimpleParametrizedPrimitiveTree, fitness=creator.Error, age=int) toolbox = base.Toolbox() toolbox.register("expr", sp.generate_parametrized_expression, partial(gp.genHalfAndHalf, pset=pset, min_=self.min_depth_init, max_=self.max_depth_init), variable_type_indices, variable_names) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("compile", gp.compile, pset=pset) toolbox.register("grow", sp.generate_parametrized_expression, partial(gp.genGrow, pset=pset, min_=self.min_gen_grow, max_=self.max_gen_grow), variable_type_indices, variable_names) toolbox.register("mutate", operators.mutation_biased, expr=toolbox.grow, node_selector=operators.uniform_depth_node_selector) toolbox.decorate("mutate", operators.static_limit(key=operator.attrgetter("height"), max_value=self.max_height)) toolbox.decorate("mutate", operators.static_limit(key=len, max_value=self.max_size)) # self.history = tools.History() # toolbox.decorate("mutate", self.history.decorator) toolbox.register("error_func", self.error_function) expression_dict = cachetools.LRUCache(maxsize=1000) subset_selection_archive = subset_selection.RandomSubsetSelectionArchive(frequency=self.subset_change_frequency, predictors=predictors, response=response, subset_size=subset_size, expression_dict=expression_dict) evaluate_function = partial(subset_selection.fast_numpy_evaluate_subset, get_node_semantics=sp.get_node_semantics, context=pset.context, subset_selection_archive=subset_selection_archive, error_function=toolbox.error_func, expression_dict=expression_dict) toolbox.register("evaluate_error", evaluate_function) self.multi_archive = utils.get_archive(100) if self.log_mutate: mutation_stats_archive = archive.MutationStatsArchive(evaluate_function) toolbox.decorate("mutate", operators.stats_collector(archive=mutation_stats_archive)) self.multi_archive.archives.append(mutation_stats_archive) self.multi_archive.archives.append(subset_selection_archive) self.mstats = reports.configure_parametrized_inf_protected_stats() self.pop = toolbox.population(n=self.pop_size) toolbox.register("run", truncation_with_elite.optimize, population=self.pop, toolbox=toolbox, ngen=self.ngen, stats=self.mstats, archive=self.multi_archive, verbose=False, history=None) # history=self.history) toolbox.register("save", reports.save_log_to_csv) toolbox.decorate("save", reports.save_archive(self.multi_archive)) return toolbox
Example #12
Source File: run.py From ev_chargingcoordination2017 with GNU General Public License v3.0 | 4 votes |
def runOptGenetic(): ''' @return: @rtype: ''' # COULDDO parametrisation creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", list, fitness=creator.FitnessMin) IND_SIZE = num_slots * num_evs POP_SIZE = 30 toolbox = base.Toolbox() toolbox.register("attr_float", rd.random) # COULDDO heuristic init toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=IND_SIZE) toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=POP_SIZE) toolbox.register("evaluate", evaluate) toolbox.decorate("evaluate", tools.DeltaPenalty(feasible, 0.0, distance)) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.5, indpb=0.5) toolbox.register("select", tools.selTournament, tournsize=3) stats = tools.Statistics(key=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) hof = tools.HallOfFame(1) population = toolbox.population() # if no of-the-shelf algorithm used... # fits = toolbox.map(toolbox.evaluate, population) # for fit, ind in zip(fits, population): # ind.fitness.values = fit population, logbook = algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.3, ngen=5, stats=stats, verbose=True, halloffame=hof) sorted_pop = sorted(population, key=lambda ind: ind.fitness) ev_schedules = np.asarray(best).reshape((num_evs, num_slots)) schedules = np.zeros((num_households, num_slots)).tolist() for i in range(num_evs): schedules[evs[i].position] = ev_schedules[i].tolist() evs[i].schedule = schedules[evs[i].position] return schedules # ***************************************************************************************************** # * Metaheuristics Side Functions # ***************************************************************************************************** # UNUSED
Example #13
Source File: test_algorithms.py From deap with GNU Lesser General Public License v3.0 | 4 votes |
def test_nsga2(): NDIM = 5 BOUND_LOW, BOUND_UP = 0.0, 1.0 MU = 16 NGEN = 100 toolbox = base.Toolbox() toolbox.register("attr_float", random.uniform, BOUND_LOW, BOUND_UP) toolbox.register("individual", tools.initRepeat, creator.__dict__[INDCLSNAME], toolbox.attr_float, NDIM) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", benchmarks.zdt1) toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0) toolbox.register("mutate", tools.mutPolynomialBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0, indpb=1.0/NDIM) toolbox.register("select", tools.selNSGA2) pop = toolbox.population(n=MU) fitnesses = toolbox.map(toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit pop = toolbox.select(pop, len(pop)) for gen in range(1, NGEN): offspring = tools.selTournamentDCD(pop, len(pop)) offspring = [toolbox.clone(ind) for ind in offspring] for ind1, ind2 in zip(offspring[::2], offspring[1::2]): if random.random() <= 0.9: toolbox.mate(ind1, ind2) toolbox.mutate(ind1) toolbox.mutate(ind2) del ind1.fitness.values, ind2.fitness.values 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 pop = toolbox.select(pop + offspring, MU) hv = hypervolume(pop, [11.0, 11.0]) # hv = 120.777 # Optimal value assert hv > HV_THRESHOLD, "Hypervolume is lower than expected %f < %f" % (hv, HV_THRESHOLD) for ind in pop: assert not (any(numpy.asarray(ind) < BOUND_LOW) or any(numpy.asarray(ind) > BOUND_UP))
Example #14
Source File: test_algorithms.py From deap with GNU Lesser General Public License v3.0 | 4 votes |
def test_nsga3(): NDIM = 5 BOUND_LOW, BOUND_UP = 0.0, 1.0 MU = 16 NGEN = 100 ref_points = tools.uniform_reference_points(2, p=12) toolbox = base.Toolbox() toolbox.register("attr_float", random.uniform, BOUND_LOW, BOUND_UP) toolbox.register("individual", tools.initRepeat, creator.__dict__[INDCLSNAME], toolbox.attr_float, NDIM) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", benchmarks.zdt1) toolbox.register("mate", tools.cxSimulatedBinaryBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0) toolbox.register("mutate", tools.mutPolynomialBounded, low=BOUND_LOW, up=BOUND_UP, eta=20.0, indpb=1.0/NDIM) toolbox.register("select", tools.selNSGA3, ref_points=ref_points) pop = toolbox.population(n=MU) fitnesses = toolbox.map(toolbox.evaluate, pop) for ind, fit in zip(pop, fitnesses): ind.fitness.values = fit pop = toolbox.select(pop, len(pop)) # Begin the generational process for gen in range(1, NGEN): offspring = algorithms.varAnd(pop, toolbox, 1.0, 1.0) # 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 # Select the next generation population pop = toolbox.select(pop + offspring, MU) hv = hypervolume(pop, [11.0, 11.0]) # hv = 120.777 # Optimal value assert hv > HV_THRESHOLD, "Hypervolume is lower than expected %f < %f" % (hv, HV_THRESHOLD) for ind in pop: assert not (any(numpy.asarray(ind) < BOUND_LOW) or any(numpy.asarray(ind) > BOUND_UP))