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,
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)
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):
"""
CTAEA
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)
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,
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 _infill(self):
problem, particles, pbest = self.problem, self.particles, self.pop
(X, V) = particles.get("X", "V")
P_X = pbest.get("X")
sbest = self._social_best()
S_X = sbest.get("X")
Xp, Vp = pso_equation(X, P_X, S_X, V, self.V_max, self.w, self.c1,
self.c2)
# if the problem has boundaries to be considered
if problem.has_bounds():
for k in range(20):
# find the individuals which are still infeasible
m = is_out_of_bounds_by_problem(problem, Xp)
# actually execute the differential equation
Xp[m], Vp[m] = pso_equation(X[m], P_X[m], S_X[m], V[m],
self.V_max, self.w, self.c1,
self.c2)
# if still infeasible do a random initialization
Xp = repair_random_init(Xp, X, *problem.bounds())
# create the offspring population
off = Population.new(X=Xp, V=Vp)
# try to improve the current best with a pertubation
if self.pertube_best:
k = FitnessSurvival().do(problem,
pbest,
n_survive=1,
return_indices=True)[0]
eta = int(np.random.uniform(20, 30))
mutant = PolynomialMutation(eta).do(problem, pbest[[k]])[0]
off[k].set("X", mutant.X)
self.repair.do(problem, off)
self.sbest = sbest.copy()
return off
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=comp_by_cv_and_fitness),
crossover=SimulatedBinaryCrossover(prob=0.9, eta=3),
mutation=PolynomialMutation(prob=None, eta=5),
survival=FitnessSurvival(),
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=survival,
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
display=display,
**kwargs)
self.default_termination = SingleObjectiveDefaultTermination()
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,
ref_points,
pop_per_ref_point,
mu=0.05,
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,
**kwargs):
"""
Parameters
----------
ref_points : {ref_points}
pop_per_ref_point : int
Size of the population used for each reference point.
mu : float
Defines the scaling of the reference lines used during survival selection. Increasing mu will result
having solutions with a larger spread.
Other Parameters
-------
n_offsprings : {n_offsprings}
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
"""
# number of objectives the reference lines have
n_obj = ref_points.shape[1]
# add the aspiration point lines
aspiration_ref_dirs = UniformReferenceDirectionFactory(
n_dim=n_obj, n_points=pop_per_ref_point).do()
survival = AspirationPointSurvival(ref_points,
aspiration_ref_dirs,
mu=mu)
pop_size = ref_points.shape[0] * aspiration_ref_dirs.shape[
0] + aspiration_ref_dirs.shape[1]
ref_dirs = None
super().__init__(ref_dirs,
pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=survival,
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
**kwargs)