def _do(self, pop, n_select, n_parents, **kwargs):
_type = pop.get("type")
elites = np.where(_type == "elite")[0]
non_elites = np.where(_type == "non_elite")[0]
# do the mating selection - always one elite and one non-elites
s_elite = elites[RandomSelection().do(elites, n_select, 1)[:, 0]]
s_non_elite = non_elites[RandomSelection().do(non_elites, n_select,
1)[:, 0]]
return np.column_stack([s_elite, s_non_elite])
def __init__(self, variant="DE/rand/1/exp", CR=0.1, F=0.75, **kwargs):
set_default_if_none("real", kwargs)
super().__init__(**kwargs)
self.selection = RandomSelection()
self.crossover = DifferentialEvolutionCrossover(weight=F)
_, self.var_selection, self.var_n, self.var_mutation, = variant.split(
"/")
self.mutation = DifferentialEvolutionMutation(self.var_mutation, CR)
self.func_display_attrs = disp_single_objective
def _do(self, pop, n_select, n_parents, **kwargs):
_type = pop.get("type")
elites = np.where(_type == "elite")[0]
non_elites = np.where(_type == "non_elite")[0]
# if through duplicate elimination no non-elites exist
if len(non_elites) == 0:
non_elites = elites
# do the mating selection - always one elite and one non-elites
s_elite = elites[RandomSelection().do(elites, n_select, 1)[:, 0]]
s_non_elite = non_elites[RandomSelection().do(non_elites, n_select, 1)[:, 0]]
return np.column_stack([s_elite, s_non_elite])
def __init__(self,
ref_points,
epsilon=0.001,
normalization="front",
weights=None,
extreme_points_as_reference_points=False,
**kwargs):
"""
Parameters
----------
ref_points : {ref_points}
epsilon : float
weights : np.array
normalization : {{'no', 'front', 'ever'}}
extreme_points_as_reference_points : bool
"""
self.epsilon = epsilon
self.weights = weights
self.normalization = normalization
self.selection = RandomSelection()
super().__init__(**kwargs)
self.survival = RankAndModifiedCrowdingSurvival(
ref_points, epsilon, weights, normalization,
extreme_points_as_reference_points)
def _do(self, pop, n_select, n_parents, **kwargs):
variant = self.variant
# create offsprings and add it to the data of the algorithm
P = RandomSelection().do(pop, n_select, n_parents)
F, CV = pop.get("F", "CV")
fitness = parameter_less(F, CV)[:, 0]
sorted_by_fitness = fitness.argsort()
best = sorted_by_fitness[0]
if variant == "best":
P[:, 0] = best
elif variant == "current-to-best":
P[:, 0] = np.arange(len(pop))
P[:, 1] = best
P[:, 2] = np.arange(len(pop))
elif variant == "current-to-rand":
P[:, 0] = np.arange(len(pop))
P[:, 2] = np.arange(len(pop))
elif variant == "rand-to-best":
P[:, 1] = best
P[:, 2] = np.arange(len(pop))
elif variant == "current-to-pbest":
n_pbest = int(np.ceil(0.1 * len(pop)))
pbest = sorted_by_fitness[:n_pbest]
P[:, 0] = np.arange(len(pop))
P[:, 1] = np.random.choice(pbest, len(pop))
P[:, 2] = np.arange(len(pop))
return P
def de(
pop_size=100,
sampling=LatinHypercubeSampling(criterion="maxmin", iterations=100),
variant="DE/rand+best/1/bin",
CR=0.5,
F=0.75,
**kwargs):
"""
Parameters
----------
pop_size : {pop_size}
sampling : {sampling}
variant : str
CR : float
F : float
Returns
-------
de : :class:`~pymoo.model.algorithm.Algorithm`
Returns an DifferentialEvolution algorithm object.
"""
_, _selection, _n, _mutation, = variant.split("/")
return DifferentialEvolution(pop_size=pop_size,
sampling=sampling,
selection=RandomSelection(),
crossover=DifferentialEvolutionCrossover(weight=F),
mutation=DifferentialEvolutionMutation(_mutation, CR),
**kwargs)
def __init__(self,
pop_size=100,
sampling=LatinHypercubeSampling(iterations=100,
criterion="maxmin"),
variant="DE/rand/1/bin",
CR=0.5,
F=0.3,
dither="vector",
jitter=False,
**kwargs):
"""
Parameters
----------
pop_size : {pop_size}
sampling : {sampling}
variant : {{DE/(rand|best)/1/(bin/exp)}}
The different variants of DE to be used. DE/x/y/z where x how to select individuals to be pertubed,
y the number of difference vector to be used and z the crossover type. One of the most common variant
is DE/rand/1/bin.
F : float
The weight to be used during the crossover.
CR : float
The probability the individual exchanges variable values from the donor vector.
dither : {{'no', 'scalar', 'vector'}}
One strategy to introduce adaptive weights (F) during one run. The option allows
the same dither to be used in one iteration ('scalar') or a different one for
each individual ('vector).
jitter : bool
Another strategy for adaptive weights (F). Here, only a very small value is added or
subtracted to the weight used for the crossover for each individual.
"""
_, self.var_selection, self.var_n, self.var_mutation, = variant.split(
"/")
if self.var_mutation == "exp":
mutation = ExponentialCrossover(CR)
elif self.var_mutation == "bin":
mutation = UniformCrossover(CR)
super().__init__(pop_size=pop_size,
sampling=sampling,
selection=RandomSelection(),
crossover=DifferentialEvolutionCrossover(
weight=F, dither=dither, jitter=jitter),
mutation=mutation,
survival=None,
**kwargs)
self.func_display_attrs = disp_single_objective
def __init__(self,
ref_dirs,
alpha=2.0,
adapt_freq=0.1,
pop_size=None,
sampling=FloatRandomSampling(),
selection=RandomSelection(),
crossover=SimulatedBinaryCrossover(eta=30, prob=1.0),
mutation=PolynomialMutation(eta=20, prob=None),
eliminate_duplicates=True,
n_offsprings=None,
display=MultiObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
ref_dirs : {ref_dirs}
adapt_freq : float
Defines the ratio of generation when the reference directions are updated.
pop_size : int (default = None)
By default the population size is set to None which means that it will be equal to the number of reference
line. However, if desired this can be overwritten by providing a positive number.
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
n_offsprings : {n_offsprings}
"""
# set reference directions and pop_size
self.ref_dirs = ref_dirs
if self.ref_dirs is not None:
if pop_size is None:
pop_size = len(self.ref_dirs)
# the fraction of n_max_gen when the the reference directions are adapted
self.adapt_freq = adapt_freq
# you can override the survival if necessary
survival = kwargs.pop("survival", None)
if survival is None:
survival = APDSurvival(ref_dirs, alpha=alpha)
super().__init__(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=survival,
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
display=display,
**kwargs)
class DifferentialEvolution(GeneticAlgorithm):
def __init__(self, variant="DE/rand/1/exp", CR=0.1, F=0.75, **kwargs):
set_default_if_none("real", kwargs)
super().__init__(**kwargs)
self.selection = RandomSelection()
self.crossover = DifferentialEvolutionCrossover(weight=F)
_, self.var_selection, self.var_n, self.var_mutation, = variant.split(
"/")
self.mutation = DifferentialEvolutionMutation(self.var_mutation, CR)
self.func_display_attrs = disp_single_objective
def _next(self, pop):
# create offsprings and add it to the data of the algorithm
if self.var_selection == "rand":
P = self.selection.do(pop, self.pop_size, self.crossover.n_parents)
elif self.var_selection == "best":
P = self.selection.do(pop, self.pop_size,
self.crossover.n_parents - 1)
best = np.argmin(pop.get("F")[:, 0])
P = np.hstack([np.full(len(pop), best)[:, None], P])
else:
raise Exception("Unknown selection: %s" % self.var_selection)
self.off = self.crossover.do(self.problem, pop, P)
# do the mutation by using the offsprings
self.off = self.mutation.do(self.problem, pop, algorithm=self)
# evaluate the results
self.evaluator.eval(self.problem, self.off, algorithm=self)
# replace whenever offspring is better than population member
for i in range(len(pop)):
if self.off[i].F < pop[i].F:
pop[i] = self.off[i]
return pop
def _next(self, pop):
# all neighbors shuffled (excluding the individual itself)
P = RandomSelection().do(pop, self.pop_size, self.crossover.n_parents - 1)
P = np.concatenate([np.arange(self.pop_size)[:, None], P], axis=1)
# do recombination and create an offspring
X = self.crossover.do(self.problem, pop.X[P, :])
F, _ = self.evaluator.eval(self.problem, X)
# replace whenever offspring is better than population member
off_is_better = np.where(F < pop.F)[0]
pop.F[off_is_better, :] = F[off_is_better, :]
pop.X[off_is_better, :] = X[off_is_better, :]
def set_default_if_none(var_type, kwargs):
set_if_none(kwargs, 'pop_size', 100)
set_if_none(kwargs, 'verbose', False)
set_if_none(kwargs, 'selection', RandomSelection())
# values for mating
if var_type == "real":
set_if_none(kwargs, 'sampling', RealRandomSampling())
set_if_none(kwargs, 'crossover', SimulatedBinaryCrossover())
set_if_none(kwargs, 'mutation', PolynomialMutation())
elif var_type == "binary":
set_if_none(kwargs, 'sampling', BinaryRandomSampling())
set_if_none(kwargs, 'crossover', BinaryUniformCrossover())
set_if_none(kwargs, 'mutation', BinaryBitflipMutation())
set_if_none(kwargs, 'eliminate_duplicates', True)
def set_default_if_none(var_type, kwargs):
set_if_none(kwargs, 'pop_size', 100)
set_if_none(kwargs, 'disp', False)
set_if_none(kwargs, 'selection', RandomSelection())
set_if_none(kwargs, 'survival', None)
# values for mating
if var_type == "real":
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'crossover', SimulatedBinaryCrossover(prob_cross=0.9, eta_cross=20))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob_mut=None, eta_mut=15))
elif var_type == "binary":
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'crossover', BinaryUniformCrossover())
set_if_none(kwargs, 'mutation', BinaryBitflipMutation())
set_if_none(kwargs, 'eliminate_duplicates', True)
def __init__(self,
variant="DE/rand+best/1/bin",
CR=0.5,
F=0.75,
n_replace=None,
**kwargs):
_, self.var_selection, self.var_n, self.var_mutation, = variant.split("/")
set_if_none(kwargs, 'pop_size', 200)
set_if_none(kwargs, 'sampling', LatinHypercubeSampling(criterion="maxmin", iterations=100))
set_if_none(kwargs, 'crossover', DifferentialEvolutionCrossover(weight=F))
set_if_none(kwargs, 'selection', RandomSelection())
set_if_none(kwargs, 'mutation', DifferentialEvolutionMutation(self.var_mutation, CR))
set_if_none(kwargs, 'survival', None)
super().__init__(**kwargs)
self.n_replace = n_replace
self.func_display_attrs = disp_single_objective
def __init__(self,
pop_size=100,
sampling=FloatRandomSampling(),
selection=RandomSelection(),
crossover=SimulatedBinaryCrossover(prob=0.9, eta=3),
mutation=PolynomialMutation(prob=None, eta=5),
eliminate_duplicates=True,
n_offsprings=None,
display=SingleObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
pop_size : {pop_size}
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
n_offsprings : {n_offsprings}
"""
super().__init__(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=NichingSurvival(),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
display=display,
**kwargs)
# self.mating = NeighborBiasedMating(selection,
# crossover,
# mutation,
# repair=self.mating.repair,
# eliminate_duplicates=self.mating.eliminate_duplicates,
# n_max_iterations=self.mating.n_max_iterations)
self.default_termination = SingleObjectiveDefaultTermination()
def rnsga2(ref_points,
epsilon=0.001,
normalization="front",
weights=None,
extreme_points_as_reference_points=False,
**kwargs):
"""
Parameters
----------
ref_points : {ref_points}
epsilon : float
weights : np.array
normalization : {{'no', 'front', 'ever'}}
extreme_points_as_reference_points : bool
Returns
-------
rnsga2 : :class:`~pymoo.model.algorithm.Algorithm`
Returns an RNSGA2 algorithm object.
"""
rnsga2 = nsga2(**kwargs)
rnsga2.epsilon = epsilon
rnsga2.weights = weights
rnsga2.normalization = normalization
rnsga2.selection = RandomSelection()
rnsga2.survival = RankAndModifiedCrowdingSurvival(
ref_points, epsilon, weights, normalization,
extreme_points_as_reference_points)
return rnsga2
def __init__(self,
variant,
CR,
F,
dither,
jitter,
**kwargs):
_, self.var_selection, self.var_n, self.var_mutation, = variant.split("/")
set_if_none(kwargs, 'pop_size', 200)
set_if_none(kwargs, 'sampling', LatinHypercubeSampling(criterion="maxmin", iterations=100))
set_if_none(kwargs, 'crossover', DifferentialEvolutionCrossover(weight=F, dither=dither, jitter=jitter))
set_if_none(kwargs, 'selection', RandomSelection())
if self.var_mutation == "exp":
set_if_none(kwargs, 'mutation', ExponentialCrossover(CR))
elif self.var_mutation == "bin":
set_if_none(kwargs, 'mutation', UniformCrossover(CR))
set_if_none(kwargs, 'survival', None)
super().__init__(**kwargs)
self.func_display_attrs = disp_single_objective
self.crossovers = crossovers
self.mutations = mutations
self.repairs = repairs if len(repairs) > 0 else [NoRepair()]
def do(self, problem, pop, n_offsprings, **kwargs):
# randomly choose a combination to be tried
self.selection = random.choice(self.selections)
self.crossover = random.choice(self.crossovers)
self.mutation = random.choice(self.mutations)
self.repair = random.choice(self.repairs)
off = super().do(problem, pop, n_offsprings, **kwargs)
return off
selections = [RandomSelection()]
# define all the crossovers to be tried
crossovers = [SimulatedBinaryCrossover(10.0), SimulatedBinaryCrossover(30.0), DifferentialEvolutionCrossover()]
# COMMENT out this line to only use the SBX crossover with one eta value
# crossovers = [SimulatedBinaryCrossover(30)]
mutations = [NoMutation(), PolynomialMutation(10.0), PolynomialMutation(30.0)]
repairs = []
ensemble = EnsembleMating(selections, crossovers, mutations, repairs)
problem = Rastrigin(n_var=30)
algorithm = GA(
pop_size=100,