def xmut(ind, expr, unipb, shrpb, psetR, psetT): choice = random.random() if choice < unipb: indx1 = gp.mutUniform(ind[0], expr, pset=psetR) ind[0] = indx1[0] indx2 = gp.mutUniform(ind[1], expr, pset=psetT) ind[1] = indx2[0] elif unipb <= choice < unipb + shrpb: indx1 = gp.mutShrink(ind[0]) ind[0] = indx1[0] indx2 = gp.mutShrink(ind[1]) ind[1] = indx2[0] else: indx1 = gp.mutInsert(ind[0], pset=psetR) ind[0] = indx1[0] indx2 = gp.mutInsert(ind[1], pset=psetT) ind[1] = indx2[0] #else: # choice2 = random.random() # if choice2 < 0.5: # indx1 = gp.mutEphemeral(ind[0], "all") # ind[0] = indx1[0] # indx2 = gp.mutEphemeral(ind[1], "all") # ind[1] = indx2[0] #else: # indx1 = gp.mutEphemeral(ind[0], "one") # ind[0] = indx1[0] # indx2 = gp.mutEphemeral(ind[1], "one") #ind[1] = indx2[0] return ind,
def staticLimitMutation(individual, expr, heightLimit, toolbox): # Store a backup of the original individual keepInd = toolbox.clone(individual) # Mutate the individual # The mutation is done in place (see the documentation) gp.mutUniform(individual, expr) # If the mutation sets the individual higher than the maximum allowed, # replaced it by the original individual if individual.height > heightLimit: individual[:] = keepInd return individual,
def replaces_features(ind: MultipleGeneGP): for i, c in enumerate(ind.coef): if c < threshold: new_features = mutUniform( copy.deepcopy(random.choice(regressor.good_features)), expr, pset) ind.gene[i] = new_features[0]
def replaces_features(ind: MultipleGeneGP): for i, c in enumerate(ind.coef): positive = False if (positive and c >= threshold) or (not positive and c < threshold): new_features = mutUniform( copy.deepcopy(random.choice(good_features)), expr, pset) ind.gene[i] = new_features[0]
def multi_mutate(individual, expr, pset): '''定义变异函数''' rand = np.random.uniform(0) if rand <= 0.33: return gp.mutUniform(individual, expr, pset) elif rand <= 0.66: return gp.mutShrink(individual) else: return gp.mutNodeReplacement(individual, pset)
def mutate(individual, pset, expr): rand = np.random.rand() if rand <= 0.25: return gp.mutShrink(individual), elif rand <= 0.5: return gp.mutInsert(individual, pset) elif rand <= 0.75: return gp.mutNodeReplacement(individual, pset) return gp.mutUniform(individual, expr, pset)
def _random_mutation_operator(self, individual): """Randomly picks a replacement, insert, or shrink mutation.""" roll = random.random() if roll <= 0.333333: return gp.mutUniform(individual, expr=self.toolbox.expr_mut, pset=self.pset) elif roll <= 0.666666: return gp.mutInsert(individual, pset=self.pset) else: return gp.mutShrink(individual)
def customMut(individual, expr, pset): '''To handle multiple mutation operators''' r = random.random() if r >= 0.4: individual = gp.mutUniform(individual, expr, pset) else: #apply shrink individual = gp.mutShrink(individual) return individual
def multi_mutate(individual, expr, pset): ''' apply multiple kinds of mutation in a funciton ''' rand = np.random.uniform(0) if rand <= 0.4: return gp.mutUniform(individual, expr, pset) elif rand <= 0.75: return gp.mutShrink(individual) else: return gp.mutNodeReplacement(individual, pset)
def xmut(ind, expr, psetR, psetT, unipb, shrpb, Ngenes): ch = random.randint(0, Ngenes - 1) choice = random.random() #if choice < opti: # ind = deepcopy(ind) # ind = optimize_ind(ind) if choice < unipb: indx1 = gp.mutUniform(ind[0][ch], expr, pset=psetR) ind[0][ch] = indx1[0] indx2 = gp.mutUniform(ind[1][ch], expr, pset=psetT) ind[1][ch] = indx2[0] elif choice < unipb + shrpb: indx1 = gp.mutShrink(ind[0][ch]) ind[0][ch] = indx1[0] indx2 = gp.mutShrink(ind[1][ch]) ind[1][ch] = indx2[0] else: indx1 = gp.mutInsert(ind[0][ch], pset=psetR) ind[0][ch] = indx1[0] indx2 = gp.mutInsert(ind[1][ch], pset=psetT) ind[1][ch] = indx2[0] return ind,
def xmut(ind, expr, strp): i1 = random.randrange(len(ind)) i2 = random.randrange(len(ind[i1])) choice = random.random() if choice < strp: indx = gp.mutUniform(ind[i1], expr, pset=pset) ind[i1] = indx[0] return ind, else: '''this part execute the mutation on a random constant''' indx = gp.mutEphemeral(ind[i1], "one") ind[i1] = indx[0] return ind,
def multiple_mutator(individual, pset): weight_sum = gencome.config.mut_uniform_weight + gencome.config.mut_replacement_weight \ + gencome.config.mut_insert_weight + gencome.config.mut_shrink_weight cur_weight = gencome.config.mut_uniform_weight rng = random.random() * weight_sum if rng < cur_weight: logger.debug( f"Starting mutation: Uniform {str_individual_with_real_feature_names(individual)}" ) new_ind = gp.mutUniform(individual, expr=gencome.config.toolbox.expr_mut, pset=pset) logger.debug( f"Successful mutation: Uniform {str_individual_with_real_feature_names(new_ind[0])}" ) return new_ind cur_weight += gencome.config.mut_replacement_weight if rng < cur_weight: logger.debug( f"Starting mutation: Node Replace {str_individual_with_real_feature_names(individual)}" ) new_ind = gp.mutNodeReplacement(individual, pset=pset) logger.debug( f"Successful mutation: Node Replace {str_individual_with_real_feature_names(new_ind[0])}" ) return new_ind cur_weight += gencome.config.mut_insert_weight if rng < cur_weight: logger.debug( f"Starting mutation Insert {str_individual_with_real_feature_names(individual)}" ) new_ind = gp.mutInsert(individual, pset=pset) logger.debug( f"Successful mutation Insert {str_individual_with_real_feature_names(new_ind[0])}" ) return new_ind logger.debug( f"Starting mutation Shrink {str_individual_with_real_feature_names(individual)}" ) new_ind = gp.mutShrink(individual) logger.debug( f"Successful mutation Shrink {str_individual_with_real_feature_names(new_ind[0])}" ) return new_ind
def _random_mutation_operator(self, individual): """Perform a replacement, insert, or shrink mutation on an individual Parameters ---------- individual: DEAP individual A list of pipeline operators and model parameters that can be compiled by DEAP into a callable function Returns ------- fitness: list Returns the individual with one of the mutations applied to it """ roll = random.random() if roll <= 0.333333: return gp.mutUniform(individual, expr=self.toolbox.expr_mut, pset=self.pset) elif roll <= 0.666666: return gp.mutInsert(individual, pset=self.pset) else: return gp.mutShrink(individual)
def repeated_mutation(individual, expr, pset, existing, toolbox, max_tries=10): """ Repeated apply mutUniform until the mutated individual has not existed before. :param individual: :param expr: :param pset: :return: """ # Try for max_tries, or until we generate a unique individual for i in range(max_tries): ind = toolbox.clone(individual) mutated = gp.mutUniform(ind, expr, pset) # mutUniform returns a tuple, so access the first element of the tuple and see if that is unique if str(mutated[0]) not in existing: break return mutated
def full_uniform_mutation(individual, pset, min_, max_): expr = functools.partial(genFullTyped, min_=min_, max_=max_) return gp.mutUniform(individual, expr=expr, pset=pset)
def _mutate(individual, expr, pset): r = random.random() if r < 0.9: return gp.mutUniform(individual, expr, pset) else: return gp.mutNodeReplacement(individual, pset)
def xmut(ind, expr): i1 = random.randrange(len(ind)) indx = gp.mutUniform(ind[i1], expr, pset=ind.pset) ind[i1] = indx[0] return ind,
def mutUniform_multiple_gene(individual: MultipleGeneGP, expr, pset): mutUniform(individual.random_select(), expr, pset) return individual,
def mutUniform_multiple_gene_deterministic(individual: MultipleGeneGP, expr, pset): mutUniform(individual.deterministic_select(), expr, pset) return individual,
def mutUniform_multiple_gene_weight(individual: MultipleGeneGP, expr, pset): mutUniform(individual.weight_select(), expr, pset) return individual,
def random_mutation(individual, expr, pset): return random.choice([gp.mutShrink(individual), gp.mutNodeReplacement(individual, pset), gp.mutUniform(individual, expr, pset), gp.mutEphemeral(individual, "all")])
def xmutSimple(ind, expr, pset): """From [1] """ i1 = random.randrange(len(ind)) indx = gp.mutUniform(ind[i1], expr, pset) ind[i1] = indx[0] return ind,
def mutate(self): mut_expr = partial(genGrow, max_=self.grow_mut, prob=self.grow_pb) branch = random.choice(range(len(self))) self[branch] = mutUniform(self[branch], expr=mut_expr, pset=self.psets[branch])[0]
def xmut(ind, expr, unipb, shrpb, inspb, pset, creator): """ Author(s): Francesco Marchetti email: [email protected] From [1] and modified. Added several mutations possibilities. """ choice = random.random() try: if type(ind[0]) == creator.SubIndividual: if hasattr(pset, '__len__'): if choice < unipb: indx1 = gp.mutUniform(ind[0], expr, pset=pset[0]) ind[0] = indx1[0] indx2 = gp.mutUniform(ind[1], expr, pset=pset[1]) ind[1] = indx2[0] elif unipb <= choice < unipb + shrpb: indx1 = gp.mutShrink(ind[0]) ind[0] = indx1[0] indx2 = gp.mutShrink(ind[1]) ind[1] = indx2[0] elif unipb + shrpb <= choice < unipb + shrpb + inspb: indx1 = gp.mutInsert(ind[0], pset=pset[0]) ind[0] = indx1[0] indx2 = gp.mutInsert(ind[1], pset=pset[1]) ind[1] = indx2[0] else: choice2 = random.random() if choice2 < 0.5: indx1 = gp.mutEphemeral(ind[0], "all") ind[0] = indx1[0] indx2 = gp.mutEphemeral(ind[1], "all") ind[1] = indx2[0] else: indx1 = gp.mutEphemeral(ind[0], "one") ind[0] = indx1[0] indx2 = gp.mutEphemeral(ind[1], "one") ind[1] = indx2[0] else: if choice < unipb: indx1 = gp.mutUniform(ind[0], expr, pset=pset) ind[0] = indx1[0] indx2 = gp.mutUniform(ind[1], expr, pset=pset) ind[1] = indx2[0] elif unipb <= choice < unipb + shrpb: indx1 = gp.mutShrink(ind[0]) ind[0] = indx1[0] indx2 = gp.mutShrink(ind[1]) ind[1] = indx2[0] elif unipb + shrpb <= choice < unipb + shrpb + inspb: indx1 = gp.mutInsert(ind[0], pset=pset) ind[0] = indx1[0] indx2 = gp.mutInsert(ind[1], pset=pset) ind[1] = indx2[0] else: choice2 = random.random() if choice2 < 0.5: indx1 = gp.mutEphemeral(ind[0], "all") ind[0] = indx1[0] indx2 = gp.mutEphemeral(ind[1], "all") ind[1] = indx2[0] else: indx1 = gp.mutEphemeral(ind[0], "one") ind[0] = indx1[0] indx2 = gp.mutEphemeral(ind[1], "one") ind[1] = indx2[0] except AttributeError: if choice < unipb: indx1 = gp.mutUniform(ind, expr, pset=pset) ind = indx1[0] elif unipb <= choice < unipb + shrpb: indx1 = gp.mutShrink(ind) ind = indx1[0] elif unipb + shrpb <= choice < unipb + shrpb + inspb: indx1 = gp.mutInsert(ind, pset=pset) ind = indx1[0] else: choice2 = random.random() if choice2 < 0.5: indx1 = gp.mutEphemeral(ind, "all") ind = indx1[0] else: indx1 = gp.mutEphemeral(ind, "one") ind = indx1[0] return ind,