def __init__(self, ref_dirs, **kwargs):
if 'pop_size' not in kwargs:
kwargs['pop_size'] = ref_dirs.shape[0]
set_if_none(
kwargs, 'selection',
TournamentSelection(func_comp=comp_by_rank_and_ref_line_dist))
super().__init__(ref_dirs, **kwargs)
def __init__(self,
var_type,
ref_points=None,
epsilon=0.001,
weights=None,
**kwargs):
self.ref_dirs = np.array(ref_points)
self.epsilon = epsilon
self.weights = weights
set_default_if_none(var_type, kwargs)
set_if_none(kwargs, 'survival', None)
super().__init__(**kwargs)
def __init__(self,
var_type,
ref_points=None,
mu=0.1,
ref_pop_size=None,
method='uniform',
p=None,
**kwargs):
"""
Parameters
----------
var_type : string
Variable type which must be real in this case
ref_points : numpy.array
Reference points to be focused on during the evolutionary computation.
mu : double
The shrink factor
ref_pop_size : int
If the structured reference lines should be based off of a different population size
than the actual population size. Default value is pop size.
p : double
If the structured reference directions should be based off of p gaps specify a p value, otherwise
reference directions will be based on the population size.
ref_sampling_method : string
Reference direction generation method. Currently only 'uniform' or 'random'.
"""
self.ref_points = ref_points
self.ref_dirs = None
self.mu = mu
self.method = method
set_default_if_none(var_type, kwargs)
set_if_none(kwargs, 'survival', None)
self.ref_pop_size = ref_pop_size
self.p = p
super().__init__(**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 __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, var_type, ref_points=None, **kwargs):
self.ref_points = ref_points
self.ref_dirs = None
set_default_if_none(var_type, kwargs)
set_if_none(kwargs, 'survival', None)
super().__init__(**kwargs)
def __init__(self, **kwargs):
self.tournament_selection = TournamentSelection(func_comp=comp_by_cv_and_fitness)
set_if_none(kwargs, 'pop_size', 100)
set_if_none(kwargs, 'sampling', RandomSampling())
set_if_none(kwargs, 'selection', MMRGATournamentSelection(self.tournament_selection))
set_if_none(kwargs, 'crossover', SimulatedBinaryCrossover(prob_cross=0.95, eta_cross=15))
set_if_none(kwargs, 'mutation', PolynomialMutation(prob_mut=None, eta_mut=20))
set_if_none(kwargs, 'survival', MMRGASurvivalSelection(self.tournament_selection))
set_if_none(kwargs, 'eliminate_duplicates', True)
super().__init__(**kwargs)
self.func_display_attrs = disp_single_objective
def __init__(self, var_type, **kwargs):
set_default_if_none(var_type, kwargs)
set_if_none(kwargs, 'selection',
TournamentSelection(f_comp=comp_by_rank_and_crowding))
set_if_none(kwargs, 'survival', RankAndCrowdingSurvival())
super().__init__(**kwargs)
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
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 _do(self, pop, n_survive, out=None, **kwargs):
# check if it is a population with a single objective
F, G = pop.get("F", "G")
if F.shape[1] != 1:
raise ValueError("FitnessSurvival can only used for single objective problems!")
# default parameters if not provided to the algorithm
DEFAULT_PARAMS = {
"parameter_less": {},
"epsilon_constrained": {"epsilon": 1e-2},
"penalty": {"weight": 0.1},
"stochastic_ranking": {"weight": 0.45},
}
# check if the method is known
if self.method not in DEFAULT_PARAMS.keys():
raise Exception("Unknown constraint handling method %s" % self.method)
# set the default parameter if not provided
for key, value in DEFAULT_PARAMS[self.method].items():
set_if_none(self.params, key, value)
# make the lowest possible constraint violation 0 - if not violated in that constraint
G = G * (G > 0).astype(np.float)
# find value to normalize to sum of for CV
for j in range(G.shape[1]):
N = np.median(G[:, j])
if N == 0:
N = np.max(G[:, j])
if N > 0:
pass
# G[:, j] /= N
# add the constraint violation and divide by normalization factor
CV = np.sum(G, axis=1)
if self.method == "parameter_less":
# if infeasible add the constraint violation to worst F value
_F = np.max(F, axis=0) + CV
infeasible = CV > 0
F[infeasible, 0] = _F[infeasible]
# do fitness survival as done before with modified f
return pop[np.argsort(F[:, 0])[:n_survive]]
elif self.method == "epsilon_constrained":
_F = np.max(F, axis=0) + CV
infeasible = CV > self.params["epsilon"]
F[infeasible, 0] = _F[infeasible]
# do fitness survival as done before with modified f
return pop[np.argsort(F[:, 0])[:n_survive]]
elif self.method == "penalty":
_F = normalize(F)
# add for each constraint violation a penalty
_F[:, 0] = _F[:, 0] + self.params["weight"] * CV
return pop[np.argsort(_F[:, 0])[:n_survive]]
elif self.method == "stochastic_ranking":
# first shuffle the population randomly - to be sorted again
I = np.random.permutation(len(pop))
pop, F, CV = pop[I], F[I], CV[I]
# func = load_function("stochastic_ranking", "stochastic_ranking")
from stochastic_ranking import stochastic_ranking
func = stochastic_ranking
index = func(F[:, 0], CV, self.params["prob"])
return pop[index[:n_survive]]
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_cross=1.0, eta_cross=30))
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)
super().__init__(**kwargs)
self.func_display_attrs = disp_multi_objective
def __init__(self, var_type, **kwargs):
set_if_none(kwargs, 'survival', FitnessSurvival())
set_default_if_none(var_type, kwargs)
super().__init__(**kwargs)
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, **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
