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,
