pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/algorithms/soo/nonconvex/de.py

@@ -0,0 +1,283 @@
+"""
+
+Differential Evolution (DE)
+
+-------------------------------- Description -------------------------------
+
+
+
+-------------------------------- References --------------------------------
+
+[1] J. Blank and K. Deb, pymoo: Multi-Objective Optimization in Python, in IEEE Access,
+vol. 8, pp. 89497-89509, 2020, DOI: 10.1109/ACCESS.2020.2990567
+
+-------------------------------- License -----------------------------------
+
+
+----------------------------------------------------------------------------
+"""
+
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.infill import InfillCriterion
+from pymoo.core.population import Population
+from pymoo.core.replacement import ImprovementReplacement
+from pymoo.core.variable import Choice, get
+from pymoo.core.variable import Real
+from pymoo.docs import parse_doc_string
+from pymoo.operators.control import EvolutionaryParameterControl, NoParameterControl
+from pymoo.operators.crossover.binx import mut_binomial
+from pymoo.operators.crossover.expx import mut_exp
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.repair.bounds_repair import repair_random_init
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.rnd import fast_fill_random
+from pymoo.termination.default import DefaultSingleObjectiveTermination
+from pymoo.util import default_random_state
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.misc import where_is_what
+
+
+# =========================================================================================================
+# Crossover
+# =========================================================================================================
+
+@default_random_state
+def de_differential(X, F, jitter, alpha=0.001, random_state=None):
+    n_parents, n_matings, n_var = X.shape
+    assert n_parents % 2 == 1, "For the differential an odd number of values need to be provided"
+
+    # the differentials from each pair
+    delta = np.zeros((n_matings, n_var))
+
+    # for each difference of the differences
+    for i in range(1, n_parents, 2):
+        # create the weight vectors with jitter to give some variation
+        _F = F[:, None].repeat(n_var, axis=1)
+        # random_state is guaranteed by decorator
+        _F[jitter] *= (1 + alpha * (random_state.random((jitter.sum(), n_var)) - 0.5))
+
+        # add the difference to the vector
+        delta += _F * (X[i] - X[i + 1])
+
+    # now add the differentials to the first parent
+    Xp = X[0] + delta
+
+    return Xp
+
+
+# =========================================================================================================
+# Variant
+# =========================================================================================================
+
+class Variant(InfillCriterion):
+
+    def __init__(self,
+                 selection="best",
+                 n_diffs=1,
+                 F=0.5,
+                 crossover="bin",
+                 CR=0.2,
+                 jitter=False,
+                 prob_mut=0.1,
+                 control=EvolutionaryParameterControl,
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.selection = Choice(selection, options=["rand", "best"], all=["rand", "best", "target-to-best"])
+        self.n_diffs = Choice(n_diffs, options=[1], all=[1, 2])
+        self.F = Real(F, bounds=(0.4, 0.7), strict=(0.0, None))
+        self.crossover = Choice(crossover, ["bin"], all=["bin", "exp", "hypercube", "line"])
+        self.CR = Real(CR, bounds=(0.2, 0.8), strict=(0.0, 1.0))
+        self.jitter = Choice(jitter, options=[False], all=[True, False])
+
+        self.mutation = PM(at_least_once=True)
+        self.mutation.eta = 20
+        self.mutation.prob = prob_mut
+
+        self.control = control(self)
+
+    def do(self, problem, pop, n_offsprings, algorithm=None, **kwargs):
+        random_state = algorithm.random_state
+        control = self.control
+
+        # let the parameter control now some information
+        control.tell(pop=pop)
+
+        # set the controlled parameter for the desired number of offsprings
+        control.do(n_offsprings)
+
+        # find the different groups of selection schemes and order them by category
+        sel, n_diffs = get(self.selection, self.n_diffs, size=n_offsprings)
+        H = where_is_what(zip(sel, n_diffs))
+
+        # get the parameters used for reproduction during the crossover
+        F, CR, jitter = get(self.F, self.CR, self.jitter, size=n_offsprings)
+
+        # the `target` vectors which will be recombined
+        X = pop.get("X")
+
+        # the `donor` vector which will be obtained through the differential equation
+        donor = np.full((n_offsprings, problem.n_var), np.nan)
+
+        # for each type defined by the type and number of differentials
+        for (sel_type, n_diffs), targets in H.items():
+
+            # the number of offsprings created in this run
+            n_matings, n_parents = len(targets), 1 + 2 * n_diffs
+
+            # create the parents array
+            P = np.full([n_matings, n_parents], -1)
+
+            itself = np.array(targets)[:, None]
+
+            best = lambda: random_state.choice(np.where(pop.get("rank") == 0)[0], replace=True, size=n_matings)
+
+            if sel_type == "rand":
+                fast_fill_random(P, len(pop), columns=range(n_parents), Xp=itself, random_state=random_state)
+            elif sel_type == "best":
+                P[:, 0] = best()
+                fast_fill_random(P, len(pop), columns=range(1, n_parents), Xp=itself, random_state=random_state)
+            elif sel_type == "target-to-best":
+                P[:, 0] = targets
+                P[:, 1] = best()
+                fast_fill_random(P, len(pop), columns=range(2, n_parents), Xp=itself, random_state=random_state)
+            else:
+                raise Exception("Unknown selection method.")
+
+            # get the values of the parents in the design space
+            XX = np.swapaxes(X[P], 0, 1)
+
+            # do the differential crossover to create the donor vector
+            Xp = de_differential(XX, F[targets], jitter[targets], random_state=random_state)
+
+            # make sure everything stays in bounds
+            if problem.has_bounds():
+                Xp = repair_random_init(Xp, XX[0], *problem.bounds(), random_state=random_state)
+
+            # set the donors (the one we have created in this step)
+            donor[targets] = Xp
+
+        # the `trial` created by by recombining target and donor
+        trial = np.full((n_offsprings, problem.n_var), np.nan)
+
+        crossover = get(self.crossover, size=n_offsprings)
+        for name, K in where_is_what(crossover).items():
+
+            _target = X[K]
+            _donor = donor[K]
+            _CR = CR[K]
+
+            if name == "bin":
+                M = mut_binomial(len(K), problem.n_var, _CR, at_least_once=True, random_state=random_state)
+                _trial = np.copy(_target)
+                _trial[M] = _donor[M]
+            elif name == "exp":
+                M = mut_exp(len(K), problem.n_var, _CR, at_least_once=True, random_state=random_state)
+                _trial = np.copy(_target)
+                _trial[M] = _donor[M]
+            elif name == "line":
+                w = random_state.random((len(K), 1)) * _CR[:, None]
+                _trial = _target + w * (_donor - _target)
+            elif name == "hypercube":
+                w = random_state.random((len(K), _target.shape[1])) * _CR[:, None]
+                _trial = _target + w * (_donor - _target)
+            else:
+                raise Exception(f"Unknown crossover variant: {name}")
+
+            trial[K] = _trial
+
+        # create the population
+        off = Population.new(X=trial)
+
+        # do the mutation which helps to add some more diversity
+        off = self.mutation(problem, off, random_state=random_state)
+
+        # repair the individuals if necessary - disabled if repair is NoRepair
+        off = self.repair(problem, off, **kwargs)
+
+        # advance the parameter control by attaching them to the offsprings
+        control.advance(off)
+
+        return off
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class DE(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 n_offsprings=None,
+                 sampling=FloatRandomSampling(),
+                 variant="DE/best/1/bin",
+                 output=SingleObjectiveOutput(),
+                 **kwargs
+                 ):
+
+        if variant is None:
+            if "control" not in kwargs:
+                kwargs["control"] = NoParameterControl
+            variant = Variant(**kwargs)
+
+        elif isinstance(variant, str):
+            try:
+                _, selection, n_diffs, crossover = variant.split("/")
+                if "control" not in kwargs:
+                    kwargs["control"] = NoParameterControl
+                variant = Variant(selection=selection, n_diffs=int(n_diffs), crossover=crossover, **kwargs)
+            except:
+                raise Exception("Please provide a valid variant: DE/<selection>/<n_diffs>/<crossover>")
+
+        super().__init__(pop_size=pop_size,
+                         n_offsprings=n_offsprings,
+                         sampling=sampling,
+                         mating=variant,
+                         survival=None,
+                         output=output,
+                         eliminate_duplicates=False,
+                         **kwargs)
+
+        self.termination = DefaultSingleObjectiveTermination()
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        FitnessSurvival().do(self.problem, self.pop, return_indices=True)
+
+    def _infill(self):
+        infills = self.mating.do(self.problem, self.pop, self.n_offsprings, algorithm=self, random_state=self.random_state)
+
+        # tag each individual with an index - if a steady state version is executed
+        index = np.arange(len(infills))
+
+        # if number of offsprings is set lower than pop_size - randomly select
+        if self.n_offsprings < self.pop_size:
+            index = self.random_state.permutation(len(infills))[:self.n_offsprings]
+            infills = infills[index]
+
+        infills.set("index", index)
+
+        return infills
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, "This algorithms uses the AskAndTell interface thus infills must to be provided."
+
+        # get the indices where each offspring is originating from
+        I = infills.get("index")
+
+        # replace the individuals with the corresponding parents from the mating
+        self.pop[I] = ImprovementReplacement().do(self.problem, self.pop[I], infills)
+
+        # update the information regarding the current population
+        FitnessSurvival().do(self.problem, self.pop, return_indices=True)
+
+    def _set_optimum(self, **kwargs):
+        k = self.pop.get("rank") == 0
+        self.opt = self.pop[k]
+
+
+parse_doc_string(DE.__init__)

pymoo/algorithms/soo/nonconvex/direct.py

@@ -0,0 +1,148 @@
+import numpy as np
+
+from pymoo.algorithms.base.local import LocalSearch
+from pymoo.algorithms.moo.nsga2 import RankAndCrowdingSurvival
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.util.normalization import normalize, denormalize
+
+
+def norm_bounds(pop, problem):
+    nxl = normalize(pop.get("xl"), problem.xl, problem.xu)
+    nxu = normalize(pop.get("xu"), problem.xl, problem.xu)
+    return nxl, nxu
+
+
+def update_bounds(ind, xl, xu, k, delta):
+    _xl = np.copy(xl)
+    _xl[k] = ind.X[k] - delta
+    ind.set("xl", _xl)
+
+    _xu = np.copy(xu)
+    _xu[k] = ind.X[k] + delta
+    ind.set("xu", _xu)
+
+
+class DIRECT(LocalSearch):
+
+    def __init__(self,
+                 eps=1e-2,
+                 penalty=0.1,
+                 n_max_candidates=10,
+                 n_max_archive=400,
+                 archive_reduct=0.66,
+                 output=SingleObjectiveOutput(),
+                 **kwargs):
+        super().__init__(output=output, **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 _setup(self, problem, **kwargs):
+
+        xl, xu = problem.bounds()
+        X = denormalize(0.5 * np.ones(problem.n_var), xl, xu)
+
+        x0 = Individual(X=X)
+        x0.set("xl", xl)
+        x0.set("xu", xu)
+        x0.set("depth", 0)
+
+        self.x0 = x0
+
+    def _initialize_infill(self, **kwargs):
+        return Population.create(self.x0)
+
+    def _potential_optimal(self):
+        pop = self.pop
+
+        if len(pop) == 1:
+            return pop
+
+        # get the intervals of each individual
+        _F, _CV, xl, xu = pop.get("F", "CV", "xl", "xu")
+        nF = normalize(_F)
+        F = nF + self.penalty * _CV
+
+        # get the length of the interval of each solution
+        nxl, nxu = norm_bounds(pop, self.problem)
+        length = (nxu - nxl) / 2
+        val = length.mean(axis=1)
+
+        # (a) non-dominated set with respect to interval
+        obj = np.column_stack([-val, F])
+
+        # an unlimited archive size can cause issues - thus truncate if necessary
+        if len(pop) > self.n_max_archive:
+            # find the rank of each individual
+            _, rank = NonDominatedSorting().do(obj, return_rank=True)
+
+            # calculate the number of solutions after truncation and filter the best ones out
+            n_truncated = int(self.archive_reduct * self.n_max_archive)
+            I = np.argsort(rank)[:n_truncated]
+
+            # also update all the utility variables defined so far to match the truncation
+            pop, F, nxl, nxu, length, val, obj = pop[I], F[I], nxl[I], nxu[I], length[I], val[I], obj[I]
+            self.pop = pop
+
+        I = NonDominatedSorting().do(obj, only_non_dominated_front=True)
+        candidates, F, xl, xu, val = pop[I], F[I], xl[I], xu[I], val[I]
+
+        # if all candidates are expanded in each iteration this can cause issues - here use crowding distance to decide
+        if len(candidates) == 1:
+            return candidates
+        else:
+            if len(candidates) > self.n_max_candidates:
+                candidates = RankAndCrowdingSurvival().do(self.problem, pop, n_survive=self.n_max_candidates, algorithm=self)
+
+            return candidates
+
+    def _infill(self):
+
+        # the offspring population to finally evaluate and attach to the population
+        infills = Population()
+
+        # find the potential optimal solution in the current population
+        potential_optimal = self._potential_optimal()
+
+        # for each of those solutions execute the division move
+        for current in potential_optimal:
+
+            # find the largest dimension the solution has not been evaluated yet
+            nxl, nxu = norm_bounds(current, self.problem)
+            k = np.argmax(nxu - nxl)
+
+            # the delta value to be used to get left and right - this is one sixth of the range
+            xl, xu = current.get("xl"), current.get("xu")
+
+            delta = (xu[k] - xl[k]) / 6
+
+            # create the left individual
+            left_x = np.copy(current.X)
+            left_x[k] = xl[k] + delta
+            left = Individual(X=left_x)
+
+            # create the right individual
+            right_x = np.copy(current.X)
+            right_x[k] = xu[k] - delta
+            right = Individual(X=right_x)
+
+            # update the boundaries for all the points accordingly
+            for ind in [current, left, right]:
+                update_bounds(ind, xl, xu, k, delta)
+
+            # create the offspring population, evaluate and attach to current population
+            _infill = Population.create(left, right)
+            _infill.set("depth", current.get("depth") + 1)
+
+            infills = Population.merge(infills, _infill)
+
+        return infills
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, "This algorithms uses the AskAndTell interface thus infills must to be provided."
+        self.pop = Population.merge(self.pop, infills)

pymoo/algorithms/soo/nonconvex/es.py

@@ -0,0 +1,213 @@
+import math
+
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.population import Population
+from pymoo.docs import parse_doc_string
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.termination.default import DefaultSingleObjectiveTermination
+from pymoo.util import default_random_state
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.optimum import filter_optimum
+
+
+class ES(GeneticAlgorithm):
+
+    def __init__(self,
+                 n_offsprings=None,
+                 pop_size=None,
+                 rule=1.0 / 7.0,
+                 phi=1.0,
+                 gamma=0.85,
+                 sampling=FloatRandomSampling(),
+                 survival=FitnessSurvival(),
+                 output=SingleObjectiveOutput(),
+                 **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 n_offsprings is None and pop_size is None:
+            n_offsprings = 200
+            pop_size = int(math.ceil(n_offsprings * rule))
+        elif n_offsprings is not None and pop_size is None:
+            pop_size = int(math.ceil(n_offsprings * rule))
+        elif n_offsprings is None and pop_size is not None:
+            n_offsprings = int(math.floor(pop_size / 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,
+                         output=output,
+                         advance_after_initial_infill=True,
+                         eliminate_duplicates=False,
+                         **kwargs)
+
+        self.termination = DefaultSingleObjectiveTermination()
+        self.phi = phi
+        self.gamma = gamma
+
+        self.tau, self.taup, self.sigma_max = None, None, None
+
+    def _setup(self, problem, **kwargs):
+        n = problem.n_var
+        self.taup = self.phi / ((2 * n) ** 0.5)
+        self.tau = self.phi / ((2 * (n ** 0.5)) ** 0.5)
+
+        xl, xu = self.problem.bounds()
+        self.sigma_max = (xu - xl) / (self.problem.n_var ** 0.5)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        super()._initialize_advance(infills=infills, **kwargs)
+
+        # initialize all individuals with the maximum sigma value
+        infills.set("sigma", [self.sigma_max] * len(infills))
+
+    def _infill(self):
+        pop, mu, _lambda = self.pop, self.pop_size, self.n_offsprings
+        xl, xu = self.problem.bounds()
+        X, sigma = pop.get("X", "sigma")
+
+        # cycle through the elites individuals for create the solutions
+        I = np.arange(_lambda) % mu
+
+        # transform X and sigma to the shape of number of offsprings
+        X, sigma = X[I], sigma[I]
+
+        # get the sigma only of the elites to be used
+        sigmap = es_intermediate_recomb(sigma, random_state=self.random_state)
+
+        # calculate the new sigma based on tau and tau prime
+        sigmap = np.minimum(self.sigma_max, es_sigma(sigmap, self.tau, self.taup, random_state=self.random_state))
+
+        # execute the evolutionary strategy to calculate the offspring solutions
+        Xp = X + sigmap * self.random_state.normal(size=sigmap.shape)
+
+        # if gamma is not none do the differential variation overwrite Xp and sigmap for the first mu-1 individuals
+        if self.gamma is not None:
+            Xp[:mu - 1] = X[:mu - 1] + self.gamma * (X[0] - X[1:mu])
+            sigmap[:mu - 1] = sigma[:mu - 1]
+
+        # if we have bounds to consider -> repair the individuals which are out of bounds
+        if self.problem.has_bounds():
+            Xp = es_mut_repair(Xp, X, sigmap, xl, xu, 10, random_state=self.random_state)
+
+        # create the population to proceed further
+        off = Population.new(X=Xp, sigma=sigmap)
+
+        return off
+
+    def _advance(self, infills=None, **kwargs):
+
+        # if not all solutions suggested by infill() are evaluated we create a more semi (mu+lambda) algorithm
+        if len(infills) < self.pop_size:
+            infills = Population.merge(infills, self.pop)
+
+        self.pop = self.survival.do(self.problem, infills, n_survive=self.pop_size)
+
+    def _set_optimum(self):
+        pop = self.pop if self.opt is None else Population.merge(self.opt, self.pop)
+        self.opt = filter_optimum(pop, least_infeasible=True)
+
+
+@default_random_state
+def es_sigma(sigma, tau, taup, random_state=None):
+    _lambda, _n = sigma.shape
+    return sigma * np.exp(taup * random_state.normal(size=(_lambda, 1)) + tau * random_state.normal(size=(_lambda, _n)))
+
+
+@default_random_state
+def es_intermediate_recomb(sigma, random_state=None):
+    _lambda, _n = sigma.shape
+    sigma_hat = np.zeros_like(sigma)
+
+    for i in range(_lambda):
+        for j in range(_n):
+            k = random_state.integers(_lambda)
+            sigma_hat[i, j] = (sigma[i, j] + sigma[k, j]) / 2.0
+
+    return sigma_hat
+
+
+@default_random_state
+def es_mut_repair(Xp, X, sigma, xl, xu, n_trials, random_state=None):
+    # reshape xl and xu to be the same shape as the input
+    XL = xl[None, :].repeat(len(Xp), axis=0)
+    XU = xu[None, :].repeat(len(Xp), axis=0)
+
+    all_in_bounds = False
+
+    # for the given number of trials
+    for k in range(n_trials):
+
+        # find all indices which are out of bounds
+        i, j = np.where(np.logical_or(Xp < XL, Xp > XU))
+
+        if len(i) == 0:
+            all_in_bounds = True
+            break
+        else:
+            # do the mutation again vectored for all values not in bound
+            Xp[i, j] = X[i, j] + sigma[i, j] * random_state.normal(size=len(i))
+
+    # if there are still solutions which boundaries are violated, set them to the original X
+    if not all_in_bounds:
+        i, j = np.where(np.logical_or(Xp < XL, Xp > XU))
+        Xp[i, j] = X[i, j]
+
+    return Xp
+
+
+@default_random_state
+def es_mut_loop(X, sigmap, xl, xu, n_trials=10, random_state=None):
+    _lambda, _n = sigmap.shape
+
+    # X prime which will be returned by the algorithm (set the default value to the same as parent)
+    Xp = np.zeros_like(sigmap)
+
+    # for each of the new offsprings
+    for i in range(_lambda):
+
+        # for each variable of it
+        for j in range(_n):
+
+            # by default just copy the value if no value is in bounds this will stay
+            Xp[i, j] = X[i, j]
+
+            # try to set the value a few time and be done if in bounds
+            for _ in range(n_trials):
+
+                # calculate the mutated value
+                x = X[i, j] + sigmap[i, j] * random_state.normal()
+
+                # if it is inside the bounds accept it - otherwise try again
+                if xl[j] <= x <= xu[j]:
+                    Xp[i, j] = x
+                    break
+
+    return Xp
+
+
+parse_doc_string(ES.__init__)