Algorithms¶

class
pymoo.algorithms.soo.nonconvex.ga.
GA
(pop_size=100, sampling=<pymoo.operators.sampling.rnd.FloatRandomSampling object>, selection=<pymoo.operators.selection.tournament.TournamentSelection object>, crossover=<pymoo.operators.crossover.sbx.SBX object>, mutation=<pymoo.operators.mutation.pm.PM object>, survival=<pymoo.algorithms.soo.nonconvex.ga.FitnessSurvival object>, eliminate_duplicates=True, n_offsprings=None, output=<pymoo.util.display.single.SingleObjectiveOutput object>, **kwargs)

class
pymoo.algorithms.soo.nonconvex.de.
DE
(pop_size=100, n_offsprings=None, sampling=<pymoo.operators.sampling.rnd.FloatRandomSampling object>, variant='DE/best/1/bin', output=<pymoo.util.display.single.SingleObjectiveOutput object>, **kwargs)

class
pymoo.algorithms.soo.nonconvex.pso.
PSO
(self, pop_size=25, sampling=LHS(), w=0.9, c1=2.0, c2=2.0, adaptive=True, initial_velocity='random', max_velocity_rate=0.20, pertube_best=True, repair=NoRepair(), output=PSOFuzzyOutput(), **kwargs)  Parameters
 pop_sizeThe size of the swarm being used.
 sampling
Sampling
,Population
,numpy.array
The sampling process defines the initial set of solutions which are the starting point of the optimization algorithm. Here, you have three different options by passing
(i) A
Sampling
implementation which is an implementation of a random sampling method.(ii) A
Population
object containing the variables to be evaluated initially OR already evaluated solutions (F needs to be set in this case).(iii) Pass a two dimensional
numpy.array
with (n_individuals, n_var) which contains the variable space values for each individual. adaptivebool
Whether w, c1, and c2 are changed dynamically over time. The update uses the spread from the global optimum to determine suitable values.
 wfloat
The inertia F to be used in each iteration for the velocity update. This can be interpreted as the momentum term regarding the velocity. If adaptive=True this is only the initially used value.
 c1float
The cognitive impact (personal best) during the velocity update. If adaptive=True this is only the initially used value.
 c2float
The social impact (global best) during the velocity update. If adaptive=True this is only the initially used value.
 initial_velocitystr  (‘random’, or ‘zero’)
How the initial velocity of each particle should be assigned. Either ‘random’ which creates a random velocity vector or ‘zero’ which makes the particles start to find the direction through the velocity update equation.
 max_velocity_ratefloat
The maximum velocity rate. It is determined variable (and not vector) wise. We consider the rate here since the value is normalized regarding the xl and xu defined in the problem.
 pertube_bestbool
Some studies have proposed to mutate the global best because it has been found to converge better. Which means the population size is reduced by one particle and one function evaluation is spend additionally to permute the best found solution so far.

class
pymoo.algorithms.moo.nsga2.
NSGA2
(pop_size=100, sampling=<pymoo.operators.sampling.rnd.FloatRandomSampling object>, selection=<pymoo.operators.selection.tournament.TournamentSelection object>, crossover=<pymoo.operators.crossover.sbx.SBX object>, mutation=<pymoo.operators.mutation.pm.PM object>, survival=<pymoo.operators.survival.rank_and_crowding.classes.RankAndCrowding object>, output=<pymoo.util.display.multi.MultiObjectiveOutput object>, **kwargs)

class
pymoo.algorithms.moo.rnsga2.
RNSGA2
(self, ref_points, epsilon=0.001, normalization='front', weights=None, extreme_points_as_reference_points=False, **kwargs)  Parameters
 ref_points
numpy.array
Reference Points (or also called Aspiration Points) as a
numpy.array
where each row represents a point and each column a variable (must be equal to the objective dimension of the problem) epsilonfloat
 weightsnp.array
 normalization{‘no’, ‘front’, ‘ever’}
 extreme_points_as_reference_pointsbool
 ref_points

class
pymoo.algorithms.moo.nsga3.
NSGA3
(self, ref_dirs, pop_size=None, sampling=FloatRandomSampling(), selection=TournamentSelection(func_comp=comp_by_cv_then_random), crossover=SBX(eta=30, prob=1.0), mutation=PM(eta=20), eliminate_duplicates=True, n_offsprings=None, output=MultiObjectiveOutput(), **kwargs)  Parameters
 ref_dirs
numpy.array
The reference direction that should be used during the optimization. Each row represents a reference line and each column a variable.
 pop_sizeint (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
,Population
,numpy.array
The sampling process defines the initial set of solutions which are the starting point of the optimization algorithm. Here, you have three different options by passing
(i) A
Sampling
implementation which is an implementation of a random sampling method.(ii) A
Population
object containing the variables to be evaluated initially OR already evaluated solutions (F needs to be set in this case).(iii) Pass a two dimensional
numpy.array
with (n_individuals, n_var) which contains the variable space values for each individual. selection
Selection
This object defines the mating selection to be used. In an evolutionary algorithm each generation parents need to be selected to produce new offsprings using different recombination and mutation operators. Different strategies for selecting parents are possible e.g. selecting them just randomly, only in the neighborhood, using a tournament selection to introduce some selection pressure, …
 crossover
Crossover
The crossover has the purpose of create offsprings during the evolution. After the mating selection the parents are passed to the crossover operator which will dependent on the implementation create a different number of offsprings.
 mutation
Mutation
Some genetic algorithms rely only on the mutation operation. However, it has shown that increases the performance to perform a mutation after creating the offsprings through crossover as well. Usually the mutation operator needs to be initialized with a probability to be executed. Having a high probability of mutation will most of the time increase the diversity in the population.
 eliminate_duplicatesbool
The genetic algorithm implementation has a built in feature that eliminates duplicates after merging the parent and the offspring population. If there are duplicates with respect to the current population or in the offsprings itself they are removed and the mating process is repeated to fill up the offsprings until the desired number of unique offsprings is met.
 n_offspringsint (default: None)
Number of offspring that are created through mating. By default n_offsprings=None which sets the number of offsprings equal to the population size. By setting n_offsprings=1 a, so called, steadystate version of an algorithm can be achieved.
 ref_dirs

class
pymoo.algorithms.moo.unsga3.
UNSGA3
(self, ref_dirs, pop_size=None, sampling=FloatRandomSampling(), selection=TournamentSelection(func_comp=comp_by_cv_then_random), crossover=SBX(eta=30, prob=1.0), mutation=PM(eta=20), eliminate_duplicates=True, n_offsprings=None, output=MultiObjectiveOutput(), **kwargs)  Parameters
 ref_dirs
numpy.array
The reference direction that should be used during the optimization. Each row represents a reference line and each column a variable.
 pop_sizeint (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
,Population
,numpy.array
The sampling process defines the initial set of solutions which are the starting point of the optimization algorithm. Here, you have three different options by passing
(i) A
Sampling
implementation which is an implementation of a random sampling method.(ii) A
Population
object containing the variables to be evaluated initially OR already evaluated solutions (F needs to be set in this case).(iii) Pass a two dimensional
numpy.array
with (n_individuals, n_var) which contains the variable space values for each individual. selection
Selection
This object defines the mating selection to be used. In an evolutionary algorithm each generation parents need to be selected to produce new offsprings using different recombination and mutation operators. Different strategies for selecting parents are possible e.g. selecting them just randomly, only in the neighborhood, using a tournament selection to introduce some selection pressure, …
 crossover
Crossover
The crossover has the purpose of create offsprings during the evolution. After the mating selection the parents are passed to the crossover operator which will dependent on the implementation create a different number of offsprings.
 mutation
Mutation
Some genetic algorithms rely only on the mutation operation. However, it has shown that increases the performance to perform a mutation after creating the offsprings through crossover as well. Usually the mutation operator needs to be initialized with a probability to be executed. Having a high probability of mutation will most of the time increase the diversity in the population.
 eliminate_duplicatesbool
The genetic algorithm implementation has a built in feature that eliminates duplicates after merging the parent and the offspring population. If there are duplicates with respect to the current population or in the offsprings itself they are removed and the mating process is repeated to fill up the offsprings until the desired number of unique offsprings is met.
 n_offspringsint (default: None)
Number of offspring that are created through mating. By default n_offsprings=None which sets the number of offsprings equal to the population size. By setting n_offsprings=1 a, so called, steadystate version of an algorithm can be achieved.
 ref_dirs

class
pymoo.algorithms.moo.rnsga3.
RNSGA3
(self, ref_points, pop_per_ref_point, mu=0.05, sampling=FloatRandomSampling(), selection=TournamentSelection(func_comp=comp_by_cv_then_random), eliminate_duplicates=True, n_offsprings=None, **kwargs)  Parameters
 ref_points
numpy.array
Reference Points (or also called Aspiration Points) as a
numpy.array
where each row represents a point and each column a variable (must be equal to the objective dimension of the problem) pop_per_ref_pointint
Size of the population used for each reference point.
 mufloat
Defines the init_simplex_scale of the reference lines used during survival selection. Increasing mu will result having solutions with a larger spread.
 n_offspringsint (default: None)
Number of offspring that are created through mating. By default n_offsprings=None which sets the number of offsprings equal to the population size. By setting n_offsprings=1 a, so called, steadystate version of an algorithm can be achieved.
 sampling
Sampling
,Population
,numpy.array
The sampling process defines the initial set of solutions which are the starting point of the optimization algorithm. Here, you have three different options by passing
(i) A
Sampling
implementation which is an implementation of a random sampling method.(ii) A
Population
object containing the variables to be evaluated initially OR already evaluated solutions (F needs to be set in this case).(iii) Pass a two dimensional
numpy.array
with (n_individuals, n_var) which contains the variable space values for each individual. selection
Selection
This object defines the mating selection to be used. In an evolutionary algorithm each generation parents need to be selected to produce new offsprings using different recombination and mutation operators. Different strategies for selecting parents are possible e.g. selecting them just randomly, only in the neighborhood, using a tournament selection to introduce some selection pressure, …
 crossover
Crossover
The crossover has the purpose of create offsprings during the evolution. After the mating selection the parents are passed to the crossover operator which will dependent on the implementation create a different number of offsprings.
 mutation
Mutation
Some genetic algorithms rely only on the mutation operation. However, it has shown that increases the performance to perform a mutation after creating the offsprings through crossover as well. Usually the mutation operator needs to be initialized with a probability to be executed. Having a high probability of mutation will most of the time increase the diversity in the population.
 eliminate_duplicatesbool
The genetic algorithm implementation has a built in feature that eliminates duplicates after merging the parent and the offspring population. If there are duplicates with respect to the current population or in the offsprings itself they are removed and the mating process is repeated to fill up the offsprings until the desired number of unique offsprings is met.
 ref_points

class
pymoo.algorithms.moo.moead.
MOEAD
(ref_dirs=None, n_neighbors=20, decomposition=None, prob_neighbor_mating=0.9, sampling=<pymoo.operators.sampling.rnd.FloatRandomSampling object>, crossover=<pymoo.operators.crossover.sbx.SBX object>, mutation=<pymoo.operators.mutation.pm.PM object>, output=<pymoo.util.display.multi.MultiObjectiveOutput object>, **kwargs)