def __init__(self,
ref_dirs,
pop_size=None,
sampling=FloatRandomSampling(),
selection=TournamentSelection(func_comp=comp_by_cv_then_random),
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}
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}
"""
self.ref_dirs = ref_dirs
# in case of R-NSGA-3 they will be None - otherwise this will be executed
if self.ref_dirs is not None:
if pop_size is None:
pop_size = len(self.ref_dirs)
if pop_size < len(self.ref_dirs):
print(
f"WARNING: pop_size={pop_size} is less than the number of reference directions ref_dirs={len(self.ref_dirs)}.\n"
"This might cause unwanted behavior of the algorithm. \n"
"Please make sure pop_size is equal or larger than the number of reference directions. ")
if 'survival' in kwargs:
survival = kwargs['survival']
del kwargs['survival']
else:
survival = ReferenceDirectionSurvival(ref_dirs)
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,
advance_after_initial_infill=True,
**kwargs)
def __init__(self,
ref_dirs,
pop_size=None,
sampling=FloatRandomSampling(),
selection=NeighborhoodSelection(),
crossover=DEX(prob=0.9, CR=0.5, variant='bin'),
mutation=PM(eta=20),
display=MultiObjectiveDisplay(),
**kwargs):
# 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)
super().__init__(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
eliminate_duplicates=False,
display=display,
**kwargs)
self.RA = None
self.norm = None
self.archive = None
def __init__(self,
ref_dirs,
alpha=2.0,
adapt_freq=0.1,
pop_size=None,
sampling=FloatRandomSampling(),
selection=TournamentSelection(binary_tournament),
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 = ModifiedAPDSurvival(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)
def __init__(
self,
ref_dirs,
pop_size=None,
sampling=FloatRandomSampling(),
selection=TournamentSelection(func_comp=comp_by_cv_then_random),
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}
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}
"""
self.ref_dirs = ref_dirs
if pop_size is None:
pop_size = len(ref_dirs)
kwargs['individual'] = Individual(rank=np.inf,
niche=-1,
dist_to_niche=np.inf)
if 'survival' in kwargs:
survival = kwargs['survival']
del kwargs['survival']
else:
survival = ReferenceDirectionSurvival(ref_dirs)
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)
def __init__(self,
ref_dirs,
n_neighbors=20,
decomposition='auto',
prob_neighbor_mating=0.9,
display=MultiObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
ref_dirs : {ref_dirs}
decomposition : {{ 'auto', 'tchebi', 'pbi' }}
The decomposition approach that should be used. If set to `auto` for two objectives `tchebi` and for more than
two `pbi` will be used.
n_neighbors : int
Number of neighboring reference lines to be used for selection.
prob_neighbor_mating : float
Probability of selecting the parents in the neighborhood.
"""
self.n_neighbors = n_neighbors
self.prob_neighbor_mating = prob_neighbor_mating
self.decomposition = decomposition
set_if_none(kwargs, 'pop_size', len(ref_dirs))
set_if_none(kwargs, 'sampling', FloatRandomSampling())
set_if_none(kwargs, 'crossover',
SimulatedBinaryCrossover(prob=1.0, eta=20))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob=None, eta=20))
set_if_none(kwargs, 'survival', None)
set_if_none(kwargs, 'selection', None)
super().__init__(display=display, **kwargs)
# initialized when problem is known
self.ref_dirs = ref_dirs
if self.ref_dirs.shape[0] < self.n_neighbors:
print("Setting number of neighbours to population size: %s" %
self.ref_dirs.shape[0])
self.n_neighbors = self.ref_dirs.shape[0]
# neighbours includes the entry by itself intentionally for the survival method
self.neighbors = np.argsort(cdist(self.ref_dirs, self.ref_dirs),
axis=1,
kind='quicksort')[:, :self.n_neighbors]
def __init__(
self,
ref_dirs,
sampling=FloatRandomSampling(),
selection=RestrictedMating(func_comp=comp_by_cv_dom_then_random),
crossover=SimulatedBinaryCrossover(n_offsprings=1,
eta=30,
prob=1.0),
mutation=PolynomialMutation(eta=20, prob=None),
eliminate_duplicates=True,
display=MultiObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
ref_dirs : {ref_dirs}
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
"""
self.ref_dirs = ref_dirs
pop_size = len(ref_dirs)
kwargs['individual'] = Individual(rank=np.inf, niche=-1, FV=-1)
if 'survival' in kwargs:
survival = kwargs['survival']
del kwargs['survival']
else:
survival = CADASurvival(ref_dirs)
# Initialize diversity archives
self.da = None
super().__init__(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=survival,
eliminate_duplicates=eliminate_duplicates,
n_offsprings=pop_size,
display=display,
**kwargs)
def __init__(self,
CR=0.3,
F=None,
variant="DE/rand/1/bin",
mutation=PM(eta=15),
**kwargs):
super().__init__(CR=CR,
F=F,
variant=variant,
mutation=mutation,
display=MultiObjectiveDisplay(),
**kwargs)
self.default_termination = MultiObjectiveDefaultTermination()
def __init__(self,
ref_dirs,
n_neighbors=20,
decomposition=Tchebicheff2(),
prob_neighbor_mating=0.9,
sampling=FloatRandomSampling(),
crossover=SimulatedBinaryCrossover(prob=1.0, eta=20),
mutation=PolynomialMutation(prob=None, eta=20),
display=MultiObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
ref_dirs
n_neighbors
decomposition
prob_neighbor_mating
display
kwargs
"""
self.ref_dirs = ref_dirs
self.pc_capacity = len(ref_dirs)
self.pc_pop = Population.new()
self.npc_pop = Population.new()
self.n_neighbors = min(len(ref_dirs), n_neighbors)
self.prob_neighbor_mating = prob_neighbor_mating
self.decomp = decomposition
# initialise the neighborhood of subproblems based on the distances of weight vectors
self.neighbors = np.argsort(cdist(self.ref_dirs, self.ref_dirs),
axis=1,
kind='quicksort')[:, :self.n_neighbors]
self.selection = NeighborhoodSelection(self.neighbors,
prob=prob_neighbor_mating)
super().__init__(pop_size=len(ref_dirs),
sampling=sampling,
crossover=crossover,
mutation=mutation,
eliminate_duplicates=DefaultDuplicateElimination(),
display=display,
advance_after_initialization=False,
**kwargs)
def __init__(self,
ref_dirs,
n_neighbors=20,
decomposition='auto',
prob_neighbor_mating=0.9,
display=MultiObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
ref_dirs
n_neighbors
decomposition
prob_neighbor_mating
display
kwargs
"""
self.n_neighbors = n_neighbors
self.prob_neighbor_mating = prob_neighbor_mating
self.decomposition = decomposition
set_if_none(kwargs, 'pop_size', len(ref_dirs))
set_if_none(kwargs, 'sampling', FloatRandomSampling())
set_if_none(kwargs, 'crossover',
SimulatedBinaryCrossover(prob=1.0, eta=20))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob=None, eta=20))
set_if_none(kwargs, 'survival', None)
set_if_none(kwargs, 'selection', None)
super().__init__(display=display, **kwargs)
# initialized when problem is known
self.ref_dirs = ref_dirs
if self.ref_dirs.shape[0] < self.n_neighbors:
print("Setting number of neighbours to population size: %s" %
self.ref_dirs.shape[0])
self.n_neighbors = self.ref_dirs.shape[0]
# neighbours includes the entry by itself intentionally for the survival method
self.neighbors = np.argsort(cdist(self.ref_dirs, self.ref_dirs),
axis=1,
kind='quicksort')[:, :self.n_neighbors]
def __init__(self,
ref_dirs,
n_neighbors=20,
decomposition='auto',
prob_neighbor_mating=0.9,
sampling=FloatRandomSampling(),
crossover=SimulatedBinaryCrossover(prob=1.0, eta=20),
mutation=PolynomialMutation(prob=None, eta=20),
display=MultiObjectiveDisplay(),
**kwargs):
"""
Parameters
----------
ref_dirs
n_neighbors
decomposition
prob_neighbor_mating
display
kwargs
"""
self.ref_dirs = ref_dirs
self.n_neighbors = min(len(ref_dirs), n_neighbors)
self.prob_neighbor_mating = prob_neighbor_mating
self.decomp = decomposition
# neighbours includes the entry by itself intentionally for the survival method
self.neighbors = np.argsort(cdist(self.ref_dirs, self.ref_dirs),
axis=1,
kind='quicksort')[:, :self.n_neighbors]
self.selection = NeighborhoodSelection(self.neighbors,
prob=prob_neighbor_mating)
super().__init__(pop_size=len(ref_dirs),
sampling=sampling,
crossover=crossover,
mutation=mutation,
eliminate_duplicates=NoDuplicateElimination(),
display=display,
advance_after_initialization=False,
**kwargs)
# the mating is just performed once here - population does not need to be filled up
self.mating.n_max_iterations = 1
def __init__(self,
pop_size=100,
sampling=FloatRandomSampling(),
selection=TournamentSelection(func_comp=binary_tournament),
crossover=SBX(eta=15, prob=0.9),
mutation=PM(prob=None, eta=20),
eliminate_duplicates=True,
n_offsprings=None,
display=MultiObjectiveDisplay(),
**kwargs):
"""
Adapted from:
Panichella, A. (2019). An adaptive evolutionary algorithm based on non-euclidean geometry for many-objective
optimization. GECCO 2019 - Proceedings of the 2019 Genetic and Evolutionary Computation Conference, July, 595–603.
https://doi.org/10.1145/3321707.3321839
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=AGEMOEASurvival(),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
display=display,
advance_after_initial_infill=True,
**kwargs)
self.default_termination = MultiObjectiveDefaultTermination()
self.tournament_type = 'comp_by_rank_and_crowding'
def __init__(self,
pop_size=100,
beta=1.5,
alpha=0.1,
pa=0.35,
display=MultiObjectiveDisplay(),
sampling=FloatRandomSampling(),
survival=RankAndCrowdingSurvival(),
eliminate_duplicates=DefaultDuplicateElimination(),
**kwargs):
"""
Parameters
----------
display : {display}
sampling : {sampling}
survival : {survival}
eliminate_duplicates: {eliminate_duplicates}
termination : {termination}
pop_size : The number of nests (solutions)
beta : The input parameter of the Mantegna's Algorithm to simulate
sampling on Levy Distribution
alpha : The scaling step size and is usually O(L/100) with L is the
scale of the problem
pa : The switch probability, pa fraction of the nests will be
abandoned on every iteration
"""
super().__init__(display=display,
sampling=sampling,
survival=survival,
eliminate_duplicates=eliminate_duplicates,
pop_size=pop_size,
beta=beta,
alpha=alpha,
pa=pa,
**kwargs)
def __init__(self,
pop_size=100,
sampling=FloatRandomSampling(),
selection=TournamentSelection(func_comp=binary_tournament),
crossover=SimulatedBinaryCrossover(eta=15, prob=0.9),
mutation=PolynomialMutation(prob=None, eta=20),
survival=RankAndCrowdingSurvival(),
eliminate_duplicates=True,
n_offsprings=None,
display=MultiObjectiveDisplay(),
**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=survival,
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
display=display,
advance_after_initial_infill=True,
**kwargs)
self.default_termination = MultiObjectiveDefaultTermination()
self.tournament_type = 'comp_by_dom_and_crowding'
def __init__(self, **kwargs):
super().__init__(display=MultiObjectiveDisplay(), **kwargs)
def __init__(self,
ref_dirs,
n_neighbors=20,
decomposition=Tchebicheff(),
prob_neighbor_mating=0.9,
rate_update_weight=0.05,
rate_evol=0.8,
wag=20,
archive_size_multiplier=1.5,
use_new_ref_dirs_initialization=True,
display=MultiObjectiveDisplay(),
**kwargs):
"""
MOEAD-AWA Algorithm.
Parameters
----------
ref_dirs
n_neighbors
decomposition
prob_neighbor_mating
rate_update_weight
rate_evol
wag
archive_size_multiplier
use_new_ref_dirs_initialization
display
kwargs
"""
self.n_neighbors = n_neighbors
self.prob_neighbor_mating = prob_neighbor_mating
self.decomp = decomposition
self.rate_update_weight = rate_update_weight
self.rate_evol = rate_evol
self.wag = wag
self.EP = None
self.nEP = np.ceil(len(ref_dirs) * archive_size_multiplier)
set_if_none(kwargs, 'pop_size', len(ref_dirs))
set_if_none(kwargs, 'sampling', FloatRandomSampling())
set_if_none(kwargs, 'crossover', SBX(prob=1.0, eta=20))
set_if_none(kwargs, 'mutation', PM(prob=None, eta=20))
set_if_none(kwargs, 'survival', None)
set_if_none(kwargs, 'selection', None)
super().__init__(display=display, **kwargs)
# initialized when problem is known
self.ref_dirs = ref_dirs
if use_new_ref_dirs_initialization:
self.ref_dirs = 1.0 / (self.ref_dirs + 1e-6)
self.ref_dirs = self.ref_dirs / np.sum(self.ref_dirs, axis=1)[:,
None]
if self.ref_dirs.shape[0] < self.n_neighbors:
print("Setting number of neighbours to population size: %s" %
self.ref_dirs.shape[0])
self.n_neighbors = self.ref_dirs.shape[0]
self.nds = NonDominatedSorting()
# compute neighbors of reference directions using euclidean distance
self._update_neighbors()