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)