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. \n" "Please 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, advance_after_initial_infill=True, **kwargs)
def __init__(self, ref_dirs, pop_size=None, sampling=FloatRandomSampling(), selection=NeighborhoodSelection(), crossover=DEX(prob=0.9, CR=0.5, variant='bin'), mutation=PM(eta=20), display=MultiObjectiveDisplay(), **kwargs): # 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) super().__init__(pop_size=pop_size, sampling=sampling, selection=selection, crossover=crossover, mutation=mutation, eliminate_duplicates=False, display=display, **kwargs) self.RA = None self.norm = None self.archive = None
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, 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 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, display=display, **kwargs)
def __init__(self, ref_dirs, n_neighbors=20, decomposition='auto', prob_neighbor_mating=0.9, display=MultiObjectiveDisplay(), **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__(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, 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, CR=0.3, F=None, variant="DE/rand/1/bin", mutation=PM(eta=15), **kwargs): super().__init__(CR=CR, F=F, variant=variant, mutation=mutation, display=MultiObjectiveDisplay(), **kwargs) self.default_termination = MultiObjectiveDefaultTermination()
def __init__(self, ref_dirs, n_neighbors=20, decomposition=Tchebicheff2(), prob_neighbor_mating=0.9, sampling=FloatRandomSampling(), crossover=SimulatedBinaryCrossover(prob=1.0, eta=20), mutation=PolynomialMutation(prob=None, eta=20), display=MultiObjectiveDisplay(), **kwargs): """ Parameters ---------- ref_dirs n_neighbors decomposition prob_neighbor_mating display kwargs """ self.ref_dirs = ref_dirs self.pc_capacity = len(ref_dirs) self.pc_pop = Population.new() self.npc_pop = Population.new() self.n_neighbors = min(len(ref_dirs), n_neighbors) self.prob_neighbor_mating = prob_neighbor_mating self.decomp = decomposition # initialise the neighborhood of subproblems based on the distances of weight vectors self.neighbors = np.argsort(cdist(self.ref_dirs, self.ref_dirs), axis=1, kind='quicksort')[:, :self.n_neighbors] self.selection = NeighborhoodSelection(self.neighbors, prob=prob_neighbor_mating) super().__init__(pop_size=len(ref_dirs), sampling=sampling, crossover=crossover, mutation=mutation, eliminate_duplicates=DefaultDuplicateElimination(), display=display, advance_after_initialization=False, **kwargs)
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, ref_dirs, n_neighbors=20, decomposition='auto', prob_neighbor_mating=0.9, sampling=FloatRandomSampling(), crossover=SimulatedBinaryCrossover(prob=1.0, eta=20), mutation=PolynomialMutation(prob=None, eta=20), display=MultiObjectiveDisplay(), **kwargs): """ Parameters ---------- ref_dirs n_neighbors decomposition prob_neighbor_mating display kwargs """ self.ref_dirs = ref_dirs self.n_neighbors = min(len(ref_dirs), n_neighbors) self.prob_neighbor_mating = prob_neighbor_mating self.decomp = decomposition # 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] self.selection = NeighborhoodSelection(self.neighbors, prob=prob_neighbor_mating) super().__init__(pop_size=len(ref_dirs), sampling=sampling, crossover=crossover, mutation=mutation, eliminate_duplicates=NoDuplicateElimination(), display=display, advance_after_initialization=False, **kwargs) # the mating is just performed once here - population does not need to be filled up self.mating.n_max_iterations = 1
def __init__(self, pop_size=100, sampling=FloatRandomSampling(), selection=TournamentSelection(func_comp=binary_tournament), crossover=SBX(eta=15, prob=0.9), mutation=PM(prob=None, eta=20), eliminate_duplicates=True, n_offsprings=None, display=MultiObjectiveDisplay(), **kwargs): """ Adapted from: Panichella, A. (2019). An adaptive evolutionary algorithm based on non-euclidean geometry for many-objective optimization. GECCO 2019 - Proceedings of the 2019 Genetic and Evolutionary Computation Conference, July, 595–603. https://doi.org/10.1145/3321707.3321839 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=AGEMOEASurvival(), eliminate_duplicates=eliminate_duplicates, n_offsprings=n_offsprings, display=display, advance_after_initial_infill=True, **kwargs) self.default_termination = MultiObjectiveDefaultTermination() self.tournament_type = 'comp_by_rank_and_crowding'
def __init__(self, pop_size=100, beta=1.5, alpha=0.1, pa=0.35, display=MultiObjectiveDisplay(), sampling=FloatRandomSampling(), survival=RankAndCrowdingSurvival(), eliminate_duplicates=DefaultDuplicateElimination(), **kwargs): """ Parameters ---------- display : {display} sampling : {sampling} survival : {survival} eliminate_duplicates: {eliminate_duplicates} termination : {termination} pop_size : The number of nests (solutions) beta : The input parameter of the Mantegna's Algorithm to simulate sampling on Levy Distribution alpha : The scaling step size and is usually O(L/100) with L is the scale of the problem pa : The switch probability, pa fraction of the nests will be abandoned on every iteration """ super().__init__(display=display, sampling=sampling, survival=survival, eliminate_duplicates=eliminate_duplicates, pop_size=pop_size, beta=beta, alpha=alpha, pa=pa, **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), survival=RankAndCrowdingSurvival(), 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} """ 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, advance_after_initial_infill=True, **kwargs) self.default_termination = MultiObjectiveDefaultTermination() self.tournament_type = 'comp_by_dom_and_crowding'
def __init__(self, **kwargs): super().__init__(display=MultiObjectiveDisplay(), **kwargs)
def __init__(self, ref_dirs, n_neighbors=20, decomposition=Tchebicheff(), prob_neighbor_mating=0.9, rate_update_weight=0.05, rate_evol=0.8, wag=20, archive_size_multiplier=1.5, use_new_ref_dirs_initialization=True, display=MultiObjectiveDisplay(), **kwargs): """ MOEAD-AWA Algorithm. Parameters ---------- ref_dirs n_neighbors decomposition prob_neighbor_mating rate_update_weight rate_evol wag archive_size_multiplier use_new_ref_dirs_initialization display kwargs """ self.n_neighbors = n_neighbors self.prob_neighbor_mating = prob_neighbor_mating self.decomp = decomposition self.rate_update_weight = rate_update_weight self.rate_evol = rate_evol self.wag = wag self.EP = None self.nEP = np.ceil(len(ref_dirs) * archive_size_multiplier) set_if_none(kwargs, 'pop_size', len(ref_dirs)) set_if_none(kwargs, 'sampling', FloatRandomSampling()) set_if_none(kwargs, 'crossover', SBX(prob=1.0, eta=20)) set_if_none(kwargs, 'mutation', PM(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 use_new_ref_dirs_initialization: self.ref_dirs = 1.0 / (self.ref_dirs + 1e-6) self.ref_dirs = self.ref_dirs / np.sum(self.ref_dirs, axis=1)[:, None] 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] self.nds = NonDominatedSorting() # compute neighbors of reference directions using euclidean distance self._update_neighbors()