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