def test_sbx(self):
with open(os.path.join("resources", "crossover.json"),
encoding='utf-8') as f:
data = json.loads(f.read())
for i, e in enumerate(data):
Configuration.rand.random = MagicMock()
Configuration.rand.random.side_effect = e['rnd']
sbx = SimulatedBinaryCrossover(0.9, 15)
parents = np.array(e['parents'])[None, :, :]
children = sbx.do(ZDT4(), parents)
_children = np.array(e['children'])
is_equal = np.all(np.abs(children - _children) < 0.001)
if not is_equal:
print(i)
print(np.abs(children - _children))
self.assertTrue(is_equal)
def ZDT_Test():
ref_dirs = {
ZDT1: [[(0.2, 0.4), (0.8, 0.4)],
[(0.2, 0.6), (0.4, 0.6), (0.5, 0.2), (0.7, 0.2), (0.9, 0)]],
ZDT2: [[(0.2, 0.8), (0.7, 1), (0.8, 0.2)]],
ZDT3: [[(0.1, 0.6), (0.3, 0.2), (0.7, -0.25)]]
}
crossover = SimulatedBinaryCrossover(10)
p = []
name_list = ["ZDT1_1", "ZDT1_2", "ZDT2_1", "ZDT3_1"]
for problem, ref_points in ref_dirs.items():
for i, points in enumerate(ref_points):
sublist = []
for algorithm in [
RNSGA3("real",
pop_size=100,
ep=0.001,
crossover=crossover,
ref_dirs=points,
verbose=0)
]:
for run in range(1, n_runs + 1):
name = problem.__class__.__name__ + '_' + str(
i) + '_' + str(run)
sublist.append((algorithm, problem, run, points, name))
# yield (algorithm, problem, run)
p.append(sublist)
return p, name_list
def get_setup(n_obj):
if n_obj == 3:
pop_size = 92
ref_dirs = UniformReferenceDirectionFactory(n_obj, n_partitions=12).do()
elif n_obj == 5:
pop_size = 212
ref_dirs = UniformReferenceDirectionFactory(n_obj, n_partitions=6).do()
elif n_obj == 8:
pop_size = 156
ref_dirs = MultiLayerReferenceDirectionFactory([
UniformReferenceDirectionFactory(n_obj, n_partitions=3, scaling=1.0),
UniformReferenceDirectionFactory(n_obj, n_partitions=2, scaling=0.5)]).do()
elif n_obj == 10:
pop_size = 276
ref_dirs = MultiLayerReferenceDirectionFactory([
UniformReferenceDirectionFactory(n_obj, n_partitions=3, scaling=1.0),
UniformReferenceDirectionFactory(n_obj, n_partitions=2, scaling=0.5)]).do()
elif n_obj == 15:
pop_size = 136
ref_dirs = MultiLayerReferenceDirectionFactory([
UniformReferenceDirectionFactory(n_obj, n_partitions=2, scaling=1.0),
UniformReferenceDirectionFactory(n_obj, n_partitions=1, scaling=0.5)]).do()
return {
'ref_dirs': ref_dirs,
'pop_size': pop_size,
'crossover': SimulatedBinaryCrossover(1.0, 30),
'mutation': PolynomialMutation(20)
}
def __init__(self,
ref_dirs,
n_neighbors=15,
decomposition='auto',
prob_neighbor_mating=0.7,
**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', RandomSampling())
set_if_none(kwargs, 'crossover',
SimulatedBinaryCrossover(prob_cross=0.9, eta_cross=20))
set_if_none(kwargs, 'mutation', PolynomialMutation(eta_mut=15))
set_if_none(kwargs, 'survival', None)
set_if_none(kwargs, 'selection', None)
super().__init__(**kwargs)
self.func_display_attrs = disp_multi_objective
# 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,
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),
eliminate_duplicates=True,
n_offsprings=None,
**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=FitnessSurvival(),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
**kwargs)
self.func_display_attrs = disp_single_objective
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. \nPlease 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,
**kwargs)
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,
framework_id=None,
metamodel_list=None,
acq_list=None,
framework_acq_dict=None,
aggregation=None,
disp=False,
lf_algorithm_list=None,
init_pop_size=None,
pop_size_per_epoch=None,
pop_size_per_algorithm=None,
pop_size_lf=None,
n_split=10,
n_gen_lf=100,
**kwargs):
kwargs['individual'] = Individual(rank=np.inf,
niche=-1,
dist_to_niche=np.inf)
set_if_none(kwargs, 'pop_size', init_pop_size)
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'crossover',
SimulatedBinaryCrossover(prob_cross=1.0, eta_cross=15))
set_if_none(kwargs, 'mutation',
PolynomialMutation(prob_mut=None, eta_mut=20))
set_if_none(kwargs, 'selection',
TournamentSelection(func_comp=comp_by_cv_then_random))
set_if_none(kwargs, 'survival', ReferenceDirectionSurvival(ref_dirs))
set_if_none(kwargs, 'eliminate_duplicates', True)
set_if_none(kwargs, 'disp', disp)
super().__init__(**kwargs)
self.func_display_attrs = disp_multi_objective
self.init_pop_size = init_pop_size
self.pop_size_lf = pop_size_lf
self.pop_size_per_epoch = pop_size_per_epoch
self.pop_size_per_algorithm = pop_size_per_algorithm
self.framework_crossval = 10
self.n_gen_lf = n_gen_lf
self.ref_dirs = ref_dirs
self.cur_ref_no = 0
self.framework_id = framework_id
self.metamodel_list = metamodel_list
self.metamodel_list = self.metamodel_list
self.acq_list = acq_list
self.framework_acq_dict = framework_acq_dict
self.aggregation = aggregation
self.lf_algorithm_list = lf_algorithm_list
self.n_split = n_split
self.problem = None
self.archive = None
self.metamodel = None
self.pop = None
self.samoo_evaluator = SamooEvaluator()
self.generative_algorithm = ['rga', 'rga_x', 'de']
self.simultaneous_algorithm = ['mm_rga', 'nsga2', 'nsga3', 'moead']
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,
**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,
**kwargs)
self.func_display_attrs = disp_multi_objective
def from_args(cls, args: Namespace, index=None) -> Crossover:
type_, prob, eta = cls._parsed_arguments(['type', 'prob', 'eta'],
args,
index=index)
if type_ == 'int':
return IntegerFromFloatCrossover(clazz=SimulatedBinaryCrossover,
prob=prob,
eta=eta)
elif type_ == 'real':
return SimulatedBinaryCrossover(prob=prob, eta=eta)
raise NotImplementedError
def get_setup(n_obj):
if n_obj == 3:
pop_size = 92
ref_dirs = get_reference_directions("das-dennis",
n_obj,
n_partitions=12)
elif n_obj == 5:
pop_size = 212
ref_dirs = get_reference_directions("das-dennis",
n_obj,
n_partitions=6)
elif n_obj == 8:
pop_size = 156
ref_dirs = get_reference_directions(
"multi-layer",
get_reference_directions("das-dennis",
n_obj,
n_partitions=3,
scaling=1.0),
get_reference_directions("das-dennis",
n_obj,
n_partitions=2,
scaling=0.5))
elif n_obj == 10:
pop_size = 276
ref_dirs = get_reference_directions(
"multi-layer",
get_reference_directions("das-dennis",
n_obj,
n_partitions=3,
scaling=1.0),
get_reference_directions("das-dennis",
n_obj,
n_partitions=2,
scaling=0.5))
elif n_obj == 15:
pop_size = 136
ref_dirs = get_reference_directions(
"multi-layer",
get_reference_directions("das-dennis",
n_obj,
n_partitions=2,
scaling=1.0),
get_reference_directions("das-dennis",
n_obj,
n_partitions=1,
scaling=0.5))
return {
'ref_dirs': ref_dirs,
'pop_size': pop_size,
'crossover': SimulatedBinaryCrossover(30, prob=1.0),
'mutation': PolynomialMutation(20)
}
def __init__(self, **kwargs):
set_if_none(kwargs, 'pop_size', 100)
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'selection', TournamentSelection(func_comp=comp_by_cv_and_fitness))
set_if_none(kwargs, 'crossover', SimulatedBinaryCrossover(prob=0.9, eta=3))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob=None, eta=5))
set_if_none(kwargs, 'survival', FitnessSurvival())
set_if_none(kwargs, 'eliminate_duplicates', True)
super().__init__(**kwargs)
self.func_display_attrs = disp_single_objective
def get_setup(n_obj):
if n_obj == 3:
pop_size = 91
ref_dirs = get_reference_directions("das-dennis",
n_obj,
n_points=pop_size)
return {
'ref_dirs': ref_dirs,
'crossover': SimulatedBinaryCrossover(20, n_offsprings=1, prob=0.9),
'mutation': PolynomialMutation(20)
}
def __init__(self,
ref_dirs,
n_neighbors=20,
decomposition='auto',
prob_neighbor_mating=0.9,
**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__(**kwargs)
self.func_display_attrs = disp_multi_objective
# 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, ref_dirs, **kwargs):
self.ref_dirs = ref_dirs
kwargs['individual'] = Individual(rank=np.inf, niche=-1, dist_to_niche=np.inf)
set_if_none(kwargs, 'pop_size', len(ref_dirs))
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'crossover', SimulatedBinaryCrossover(prob=1.0, eta=30))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob=None, eta=20))
set_if_none(kwargs, 'selection', TournamentSelection(func_comp=comp_by_cv_then_random))
set_if_none(kwargs, 'survival', ReferenceDirectionSurvival(ref_dirs))
set_if_none(kwargs, 'eliminate_duplicates', True)
super().__init__(**kwargs)
self.func_display_attrs = disp_multi_objective
def calculate_pareto_front(
state_space_equation,
tau,
y_measured,
x0,
xl: Union[np.ndarray, None],
xu: Union[np.ndarray, None],
n_var: int,
n_obj: int,
normalize_quaternions: bool,
n_constr=0,
pop_size=100,
n_max_gen=1000,
verbose=True,
display=MyDisplay(),
) -> Result:
# calculate pareto frontier
problem = UUVParameterProblem(
state_space_equation,
tau,
y_measured,
x0,
n_var=n_var,
n_obj=n_obj,
n_constr=n_constr,
xl=xl,
xu=xu,
normalize_quaternions=normalize_quaternions,
)
algorithm = NSGA2(
pop_size=pop_size,
# n_offsprings=int(pop_size / 2),
crossover=SimulatedBinaryCrossover(eta=15, prob=0.9),
mutation=PolynomialMutation(prob=None, eta=15),
)
termination_default = MultiObjectiveDefaultTermination(n_max_gen=n_max_gen)
termination_design_space = DesignSpaceToleranceTermination(n_max_gen=n_max_gen)
termination_generations = get_termination("n_gen", 100)
res = minimize(
problem,
algorithm,
termination_default,
verbose=verbose,
display=display,
)
return res
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, pop_size=100, **kwargs):
# always store the individual to store rank and crowding
kwargs['individual'] = Individual(rank=np.inf, crowding=-1)
# default settings for nsga2 - not overwritten if provided as kwargs
set_if_none(kwargs, 'pop_size', pop_size)
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'selection', TournamentSelection(func_comp=binary_tournament))
set_if_none(kwargs, 'crossover', SimulatedBinaryCrossover(prob_cross=0.9, eta_cross=15))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob_mut=None, eta_mut=20))
set_if_none(kwargs, 'survival', RankAndCrowdingSurvival())
set_if_none(kwargs, 'eliminate_duplicates', True)
super().__init__(**kwargs)
self.tournament_type = 'comp_by_dom_and_crowding'
self.func_display_attrs = disp_multi_objective
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,
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 DTLZ_test():
ref_dirs = {
DTLZ2: [{
"n_var": 11,
"n_obj": 3,
"ref_points": [[[0.2, 0.2, 0.6], [0.8, 0.8, 0.8]]]
}, {
"n_var":
14,
"n_obj":
5,
"ref_points": [[[0.5, 0.5, 0.5, 0.5, 0.5],
[0.2, 0.2, 0.2, 0.2, 0.8]]]
}, {
"n_var": 19,
"n_obj": 10,
"ref_points": [[[0.25 for i in range(10)]]]
}]
}
crossover = SimulatedBinaryCrossover(10)
p = []
name_list = ["DTLZ2_1", "DTLZ2_2", "DTLZ2_3"]
for problem, setup in ref_dirs.items():
for params in setup:
parameters = {"n_var": params["n_var"], "n_obj": params["n_obj"]}
prob = problem(**parameters)
for i, points in enumerate(params["ref_points"]):
sublist = []
for algorithm in [
RNSGA3("real",
pop_size=100,
ep=0.01,
crossover=crossover,
ref_dirs=points,
verbose=0)
]:
for run in range(1, n_runs + 1):
name = problem.__class__.__name__ + '_' + str(
i) + '_' + str(run)
sublist.append((algorithm, prob, run, points, name))
# yield (algorithm, prob, run)
p.append(sublist)
return p, name_list
def nsga3(
ref_dirs,
pop_size=None,
sampling=RandomSampling(),
selection=TournamentSelection(func_comp=comp_by_cv_then_random),
crossover=SimulatedBinaryCrossover(prob=1.0, eta=30),
mutation=PolynomialMutation(prob=None, eta=20),
eliminate_duplicates=True,
n_offsprings=None,
**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 positve number.
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
n_offsprings : {n_offsprings}
Returns
-------
nsga3 : :class:`~pymoo.model.algorithm.Algorithm`
Returns an NSGA3 algorithm object.
"""
return NSGA3(ref_dirs,
pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=ReferenceDirectionSurvival(ref_dirs),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
**kwargs)
def __init__(self, m_nEs, typeC, local_search_on_n_vars,
using_surrogate_model, update_model_after_n_gens, path,
**kwargs):
set_if_none(kwargs, 'individual', Individual(rank=np.inf, crowding=-1))
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'crossover',
SimulatedBinaryCrossover(prob=1.0, eta=20))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob=None, eta=20))
super().__init__(**kwargs)
self.tournament_type = 'comp_by_dom_and_crowding'
self.func_display_attrs = disp_multi_objective
''' Custom '''
self.typeC = typeC
self.alpha = 1
self.DS = []
self.A_X, self.A_hashX, self.A_F = [], [], []
self.tmp_A_X, self.tmp_A_hashX, self.tmp_A_F = [], [], []
self.dpfs = []
self.no_eval = []
self.m_nEs = m_nEs
self.n_vars = local_search_on_n_vars
self.using_surrogate_model = using_surrogate_model
self.update_model_after_n_gens = update_model_after_n_gens
self.surrogate_model = None
self.update_model = True
self.n_updates = 0
self.training_data = []
self.nEs = 0
self.path = path
self.F_total = []
self.worst_f0 = -np.inf
self.worst_f1 = -np.inf
def ga(
pop_size=100,
sampling=RandomSampling(),
selection=TournamentSelection(func_comp=comp_by_cv_and_fitness),
crossover=SimulatedBinaryCrossover(prob=0.9, eta=3),
mutation=PolynomialMutation(prob=None, eta=5),
eliminate_duplicates=True,
n_offsprings=None,
**kwargs):
"""
Parameters
----------
pop_size : {pop_size}
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
n_offsprings : {n_offsprings}
Returns
-------
ga : :class:`~pymoo.model.algorithm.Algorithm`
Returns an SingleObjectiveGeneticAlgorithm algorithm object.
"""
return SingleObjectiveGeneticAlgorithm(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=FitnessSurvival(),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
**kwargs)
def nsga2(
pop_size=100,
sampling=RandomSampling(),
selection=TournamentSelection(func_comp=binary_tournament),
crossover=SimulatedBinaryCrossover(prob=0.9, eta=15),
mutation=PolynomialMutation(prob=None, eta=20),
eliminate_duplicates=True,
n_offsprings=None,
**kwargs):
"""
Parameters
----------
pop_size : {pop_size}
sampling : {sampling}
selection : {selection}
crossover : {crossover}
mutation : {mutation}
eliminate_duplicates : {eliminate_duplicates}
n_offsprings : {n_offsprings}
Returns
-------
nsga2 : :class:`~pymoo.model.algorithm.Algorithm`
Returns an NSGA2 algorithm object.
"""
return NSGA2(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=RankAndCrowdingSurvival(),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
**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),
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}
"""
kwargs['individual'] = Individual(rank=np.inf, crowding=-1)
super().__init__(pop_size=pop_size,
sampling=sampling,
selection=selection,
crossover=crossover,
mutation=mutation,
survival=RankAndCrowdingSurvival(),
eliminate_duplicates=eliminate_duplicates,
n_offsprings=n_offsprings,
display=display,
**kwargs)
self.tournament_type = 'comp_by_dom_and_crowding'
from pymoo.algorithms.nsga2 import NSGA2
from pymoo.factory import get_problem, get_termination
from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover
from pymoo.operators.mutation.polynomial_mutation import PolynomialMutation
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter
problem = get_problem("welded_beam")
algorithm = NSGA2(
pop_size=200,
crossover=SimulatedBinaryCrossover(eta=20, prob=0.9),
mutation=PolynomialMutation(prob=0.25, eta=40),
)
termination = get_termination("f_tol", n_last=60)
res = minimize(
problem,
algorithm,
# ("n_gen", 800),
pf=False,
seed=10,
verbose=True)
print(res.algorithm.n_gen)
Scatter().add(res.F, s=20).add(problem.pareto_front(),
plot_type="line",
color="black").show()
import numpy as np from pymoo.operators.crossover.simulated_binary_crossover import SimulatedBinaryCrossover from pymoo.operators.sampling.random_sampling import FloatRandomSampling from pymoo.problems.single import Rastrigin problem = Rastrigin(n_var=30) crossover = SimulatedBinaryCrossover(eta=20) pop = FloatRandomSampling().do(problem, 2) parents = np.array([[0, 1]]) off = crossover.do(problem, pop, parents) print(off) ind_a = pop[0] ind_b = pop[1] off = crossover.do(problem, ind_a, ind_b) print(off)
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,
mating=ensemble,
eliminate_duplicates=True)
