def __init__(self, method, with_bounds=False, with_constr=False, require_jac=False, use_bounds=True, use_constr=True, estm_gradients=True, disp=False, show_warnings=False, **kwargs): super().__init__(display=SingleObjectiveDisplay(), **kwargs) self.method, self.with_bounds, self.with_constr, self.require_jac = method, with_bounds, with_constr, require_jac self.show_warnings = show_warnings self.use_bounds = use_bounds self.use_constr = use_constr self.estm_gradients = estm_gradients self.options = { 'maxiter': int(1e8), # because of C code interfacing this can not be inf 'disp': disp }
def __init__(self, eps=1e-2, penalty=0.1, display=SingleObjectiveDisplay(), **kwargs): super().__init__(display=display, **kwargs) self.eps = eps self.penalty = penalty
def __init__(self, n_points_per_iteration=100, sampling=LatinHypercubeSampling(), display=SingleObjectiveDisplay(), **kwargs): super().__init__(display=display, **kwargs) self.n_points_per_iteration = n_points_per_iteration self.sampling = sampling
def __init__(self, n_elites=200, n_offsprings=700, n_mutants=100, bias=0.7, sampling=FloatRandomSampling(), survival=None, display=SingleObjectiveDisplay(), eliminate_duplicates=False, **kwargs ): """ Parameters ---------- n_elites : int Number of elite individuals n_offsprings : int Number of offsprings to be generated through mating of an elite and a non-elite individual n_mutants : int Number of mutations to be introduced each generation bias : float Bias of an offspring inheriting the allele of its elite parent eliminate_duplicates : bool or class The duplicate elimination is more important if a decoding is used. The duplicate check has to be performed on the decoded variable and not on the real values. Therefore, we recommend passing a DuplicateElimination object. If eliminate_duplicates is simply set to `True`, then duplicates are filtered out whenever the objective values are equal. """ if survival is None: survival = EliteSurvival(n_elites, eliminate_duplicates=eliminate_duplicates) super().__init__(pop_size=n_elites + n_offsprings + n_mutants, n_offsprings=n_offsprings, sampling=sampling, selection=EliteBiasedSelection(), crossover=BinomialCrossover(bias, prob=1.0), mutation=NoMutation(), survival=survival, display=display, eliminate_duplicates=True, advance_after_initial_infill=True, **kwargs) self.n_elites = n_elites self.n_mutants = n_mutants self.bias = bias self.default_termination = SingleObjectiveDefaultTermination()
def __init__(self, eps=1e-2, penalty=0.1, n_max_candidates=10, display=SingleObjectiveDisplay(), **kwargs): super().__init__(display=display, **kwargs) self.eps = eps self.penalty = penalty self.n_max_candidates = n_max_candidates
def __init__(self, pop_size=100, sampling=LatinHypercubeSampling(), variant="DE/rand/1/bin", CR=0.5, F=0.3, dither="vector", jitter=False, display=SingleObjectiveDisplay(), **kwargs): """ Parameters ---------- pop_size : {pop_size} sampling : {sampling} variant : {{DE/(rand|best)/1/(bin/exp)}} The different variants of DE to be used. DE/x/y/z where x how to select individuals to be pertubed, y the number of difference vector to be used and z the crossover type. One of the most common variant is DE/rand/1/bin. F : float The weight to be used during the crossover. CR : float The probability the individual exchanges variable values from the donor vector. dither : {{'no', 'scalar', 'vector'}} One strategy to introduce adaptive weights (F) during one run. The option allows the same dither to be used in one iteration ('scalar') or a different one for each individual ('vector). jitter : bool Another strategy for adaptive weights (F). Here, only a very small value is added or subtracted to the weight used for the crossover for each individual. """ mating = DifferentialEvolutionMating(variant=variant, CR=CR, F=F, dither=dither, jitter=jitter) super().__init__(pop_size=pop_size, sampling=sampling, mating=mating, survival=None, display=display, **kwargs) self.default_termination = SingleObjectiveDefaultTermination()
def __init__(self, pop_size=200, n_parallel=10, sampling=LatinHypercubeSampling(), display=SingleObjectiveDisplay(), repair=None, individual=Individual(), **kwargs): """ Parameters ---------- pop_size : {pop_size} sampling : {sampling} selection : {selection} crossover : {crossover} mutation : {mutation} eliminate_duplicates : {eliminate_duplicates} n_offsprings : {n_offsprings} """ super().__init__(display=display, **kwargs) self.initialization = Initialization(sampling, individual=individual, repair=repair) self.pop_size = pop_size self.n_parallel = n_parallel self.each_pop_size = pop_size // n_parallel self.solvers = None self.niches = [] def cmaes(problem, x): solver = CMAES(x0=x, tolfun=1e-11, tolx=1e-3, restarts=0) solver.initialize(problem) solver.next() return solver def nelder_mead(problem, x): solver = NelderMead(X=x) solver.initialize(problem) solver._initialize() solver.n_gen = 1 solver.next() return solver self.func_create_solver = nelder_mead self.default_termination = SingleObjectiveDefaultTermination()
def __init__(self, eps=1e-2, penalty=0.1, n_max_candidates=10, n_max_archive=400, archive_reduct=0.66, display=SingleObjectiveDisplay(), **kwargs): super().__init__(display=display, **kwargs) self.eps = eps self.penalty = penalty self.n_max_candidates = n_max_candidates self.n_max_archive = n_max_archive self.archive_reduct = archive_reduct
def __init__(self, n_offsprings=200, pop_size=None, rule=1.0 / 7.0, phi=1.0, gamma=0.85, sampling=FloatRandomSampling(), survival=FitnessSurvival(), display=SingleObjectiveDisplay(), **kwargs): """ Evolutionary Strategy (ES) Parameters ---------- n_offsprings : int The number of individuals created in each iteration. pop_size : int The number of individuals which are surviving from the offspring population (non-elitist) rule : float The rule (ratio) of individuals surviving. This automatically either calculated `n_offsprings` or `pop_size`. phi : float Expected rate of convergence (usually 1.0). gamma : float If not `None`, some individuals are created using the differentials with this as a length scale. sampling : object The sampling method for creating the initial population. """ if pop_size is None and n_offsprings is not None: pop_size = int(np.math.ceil(n_offsprings * rule)) elif n_offsprings is None and pop_size is not None: n_offsprings = int(np.math.fllor(n_offsprings / rule)) assert pop_size is not None and n_offsprings is not None, "You have to at least provivde pop_size of n_offsprings." assert n_offsprings >= 2 * pop_size, "The number of offsprings should be at least double the population size." super().__init__(pop_size=pop_size, n_offsprings=n_offsprings, sampling=sampling, survival=survival, display=display, advance_after_initial_infill=True, **kwargs) self.default_termination = SingleObjectiveDefaultTermination() self.phi = phi self.gamma = gamma self.tau, self.taup, self.sigma_max = None, None, None
def __init__(self, n_elites=20, n_offsprings=70, n_mutants=10, bias=0.7, sampling=FloatRandomSampling(), survival=None, display=SingleObjectiveDisplay(), eliminate_duplicates=False, **kwargs): """ Parameters ---------- n_elites : int Population size n_offsprings : int Fraction of elite items into each population n_mutants : int Fraction of mutants introduced at each generation into the population bias : float Probability that an offspring inherits the allele of its elite parent """ if survival is None: survival = EliteSurvival(n_elites, eliminate_duplicates=eliminate_duplicates) super().__init__(pop_size=n_elites + n_offsprings + n_mutants, n_offsprings=n_offsprings, sampling=sampling, selection=EliteBiasedSelection(), crossover=BiasedCrossover(bias, prob=1.0), mutation=NoMutation(), survival=survival, display=display, eliminate_duplicates=True, **kwargs) self.n_elites = n_elites self.n_mutants = n_mutants self.bias = bias self.default_termination = SingleObjectiveToleranceBasedTermination()
def __init__(self, func_params=adaptive_params, display=SingleObjectiveDisplay(), **kwargs): """ Parameters ---------- X : np.array or Population The initial point where the search should be based on or the complete initial simplex (number of dimensions plus 1 points). The population objective can be already evaluated with objective space values. If a numpy array is provided it is evaluated by the algorithm. By default it is None which means the search starts at a random point. func_params : func A function that returns the parameters alpha, beta, gamma, delta for the search. By default: >>> def adaptive_params(problem): ... n = problem.n_var ... ... alpha = 1 ... beta = 1 + 2 / n ... gamma = 0.75 - 1 / (2 * n) ... delta = 1 - 1 / n ... return alpha, beta, gamma, delta It can be overwritten if necessary. criterion_local_restart : Termination Provide a termination object which decides whether a local restart should be performed or not. """ super().__init__(display=display, **kwargs) # the function to return the parameter self.func_params = func_params # the attributes for the simplex operations self.alpha, self.beta, self.gamma, self.delta = None, None, None, None # the scaling used for the initial simplex self.simplex_scaling = None # the termination used for nelder and mead if nothing else provided self.default_termination = NelderAndMeadTermination()
def __init__(self, x0=None, sampling=LatinHypercubeSampling(), display=SingleObjectiveDisplay(), n_sample_points="auto", n_max_sample_points=20, **kwargs): super().__init__(display=display, **kwargs) self.sampling = sampling self.n_sample_points = n_sample_points self.n_max_sample_points = n_max_sample_points self.x0 = x0 self.default_termination = SingleObjectiveSpaceToleranceTermination( n_last=5, tol=1e-8) self.is_local_initialized = False
def __init__(self, X, dX=None, objective=0, display=SingleObjectiveDisplay(), **kwargs) -> None: super().__init__(display=display, **kwargs) self.objective = objective self.n_restarts = 0 self.default_termination = SingleObjectiveDefaultTermination() self.X, self.dX = X, dX self.F, self.CV = None, None if self.X.ndim == 1: self.X = np.atleast_2d(X)
def __init__(self, pop_size=25, n_offsprings=None, sampling=LHS(), termination=SingleObjectiveDefaultTermination(), display=SingleObjectiveDisplay(), beta=1.5, alpha=0.01, pa=0.1, **kwargs): """ Parameters ---------- sampling : {sampling} termination : {termination} pop_size : int The number of nests to be used beta : float The input parameter of the Mantegna's Algorithm to simulate sampling on Levy Distribution alpha : float The step size scaling factor and is usually 0.01. pa : float The switch probability, pa fraction of the nests will be abandoned on every iteration """ mating = kwargs.get("mating") if mating is None: mating = LevyFlights(alpha, beta) super().__init__(pop_size=pop_size, n_offsprings=n_offsprings, sampling=sampling, mating=mating, termination=termination, display=display, **kwargs) self.pa = pa
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 __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=DES("rand"), crossover=DEX(CR=0.7), mutation=PM(eta=20), survival=NichingSurvival(0.1, 0.01, 5, 4), eliminate_duplicates=True, n_offsprings=None, display=SingleObjectiveDisplay(), **kwargs): 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, X=None, func_params=adaptive_params, n_max_local_restarts=0, criterion_local_restart=NelderAndMeadTermination(xtol=1e-2, ftol=1e-2), display=SingleObjectiveDisplay(), **kwargs): """ Parameters ---------- X : np.array or Population The initial point where the search should be based on or the complete initial simplex (number of dimensions plus 1 points). The population objective can be already evaluated with objective space values. If a numpy array is provided it is evaluated by the algorithm. By default it is None which means the search starts at a random point. func_params : func A function that returns the parameters alpha, beta, gamma, delta for the search. By default: >>> def adaptive_params(problem): ... n = problem.n_var ... ... alpha = 1 ... beta = 1 + 2 / n ... gamma = 0.75 - 1 / (2 * n) ... delta = 1 - 1 / n ... return alpha, beta, gamma, delta It can be overwritten if necessary. n_max_local_restarts : int This algorithm employs local restarts by starting with a new initial simplex. This can be turned of by setting it to 0. criterion_local_restart : Termination Provide a termination object which decides whether a local restart should be performed or not. """ super().__init__(display=display, **kwargs) # the function to return the parameter self.func_params = func_params # the attributes for the simplex operations self.alpha, self.beta, self.gamma, self.delta = None, None, None, None # the scaling used for the initial simplex self.simplex_scaling = None # the initial point to be used to build the simplex self.x0 = X self.opt = None self.default_termination = NelderAndMeadTermination(xtol=1e-6, ftol=1e-6, n_max_iter=1e6, n_max_evals=1e6) # everything needed for local restarts self.n_max_local_restarts = n_max_local_restarts self.criterion_local_restart = criterion_local_restart # internal variables to keep track of restarts self.restarts_disabled = False self.restart_history = []
def __init__(self, pop_size=100, n_offsprings=None, sampling=LHS(), variant="DE/best/1/bin", CR=0.5, F=None, dither="vector", jitter=False, mutation=NoMutation(), survival=None, display=SingleObjectiveDisplay(), **kwargs): """ Parameters ---------- pop_size : {pop_size} sampling : {sampling} variant : {{DE/(rand|best)/1/(bin/exp)}} The different variants of DE to be used. DE/x/y/z where x how to select individuals to be pertubed, y the number of difference vector to be used and z the crossover type. One of the most common variant is DE/rand/1/bin. F : float The F to be used during the crossover. CR : float The probability the individual exchanges variable values from the donor vector. dither : {{'no', 'scalar', 'vector'}} One strategy to introduce adaptive weights (F) during one run. The option allows the same dither to be used in one iteration ('scalar') or a different one for each individual ('vector). jitter : bool Another strategy for adaptive weights (F). Here, only a very small value is added or subtracted to the F used for the crossover for each individual. """ # parse the information from the string _, sel, n_diff, mut, = variant.split("/") n_diffs = int(n_diff) if "-to-" in variant: n_diffs += 1 selection = DES(sel) crossover = DEX(prob=1.0, n_diffs=n_diffs, F=F, CR=CR, variant=mut, dither=dither, jitter=jitter) super().__init__(pop_size=pop_size, n_offsprings=n_offsprings, sampling=sampling, selection=selection, crossover=crossover, mutation=mutation, survival=survival, display=display, **kwargs) self.default_termination = SingleObjectiveDefaultTermination()