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, alpha=2.0, adapt_freq=0.1, pop_size=None, sampling=FloatRandomSampling(), selection=RandomSelection(), 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 = APDSurvival(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, 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): """ CTAEA 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) 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, 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 _infill(self): problem, particles, pbest = self.problem, self.particles, self.pop (X, V) = particles.get("X", "V") P_X = pbest.get("X") sbest = self._social_best() S_X = sbest.get("X") Xp, Vp = pso_equation(X, P_X, S_X, V, self.V_max, self.w, self.c1, self.c2) # if the problem has boundaries to be considered if problem.has_bounds(): for k in range(20): # find the individuals which are still infeasible m = is_out_of_bounds_by_problem(problem, Xp) # actually execute the differential equation Xp[m], Vp[m] = pso_equation(X[m], P_X[m], S_X[m], V[m], self.V_max, self.w, self.c1, self.c2) # if still infeasible do a random initialization Xp = repair_random_init(Xp, X, *problem.bounds()) # create the offspring population off = Population.new(X=Xp, V=Vp) # try to improve the current best with a pertubation if self.pertube_best: k = FitnessSurvival().do(problem, pbest, n_survive=1, return_indices=True)[0] eta = int(np.random.uniform(20, 30)) mutant = PolynomialMutation(eta).do(problem, pbest[[k]])[0] off[k].set("X", mutant.X) self.repair.do(problem, off) self.sbest = sbest.copy() return off
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=comp_by_cv_and_fitness), crossover=SimulatedBinaryCrossover(prob=0.9, eta=3), mutation=PolynomialMutation(prob=None, eta=5), survival=FitnessSurvival(), 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=survival, eliminate_duplicates=eliminate_duplicates, n_offsprings=n_offsprings, display=display, **kwargs) self.default_termination = SingleObjectiveDefaultTermination()
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, ref_points, pop_per_ref_point, mu=0.05, 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_points : {ref_points} pop_per_ref_point : int Size of the population used for each reference point. mu : float Defines the scaling of the reference lines used during survival selection. Increasing mu will result having solutions with a larger spread. Other Parameters ------- n_offsprings : {n_offsprings} sampling : {sampling} selection : {selection} crossover : {crossover} mutation : {mutation} eliminate_duplicates : {eliminate_duplicates} """ # number of objectives the reference lines have n_obj = ref_points.shape[1] # add the aspiration point lines aspiration_ref_dirs = UniformReferenceDirectionFactory( n_dim=n_obj, n_points=pop_per_ref_point).do() survival = AspirationPointSurvival(ref_points, aspiration_ref_dirs, mu=mu) pop_size = ref_points.shape[0] * aspiration_ref_dirs.shape[ 0] + aspiration_ref_dirs.shape[1] ref_dirs = None super().__init__(ref_dirs, pop_size=pop_size, sampling=sampling, selection=selection, crossover=crossover, mutation=mutation, survival=survival, eliminate_duplicates=eliminate_duplicates, n_offsprings=n_offsprings, **kwargs)