pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/algorithms/soo/nonconvex/g3pcx.py

@@ -0,0 +1,94 @@
+import numpy as np
+
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.algorithm import LoopwiseAlgorithm
+from pymoo.core.initialization import Initialization
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+from pymoo.core.replacement import is_better
+from pymoo.core.variable import Real, Integer, get
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.pcx import PCX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.rnd import fast_fill_random
+from pymoo.util.display.single import SingleObjectiveOutput
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class G3PCX(LoopwiseAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 n_offsprings=2,
+                 n_parents=3,
+                 family_size=2,
+                 repair=NoRepair(),
+                 output=SingleObjectiveOutput(),
+                 **kwargs):
+
+        super().__init__(output=output, **kwargs)
+
+        self.pop_size = Integer(pop_size, bounds=(20, 200))
+        self.repair = repair
+
+        self.initialization = Initialization(sampling, repair=self.repair, eliminate_duplicates=False)
+
+        self.n_offsprings = Integer(n_offsprings, bounds=(1, 10))
+        self.n_parents = Integer(n_parents, bounds=(3, 10))
+        self.family_size = Integer(family_size, bounds=(1, 10))
+
+        self.crossover = PCX()
+        self.crossover.prob = 1.0
+
+        self.mutation = PM()
+        self.mutation.prob = Real(0.25, bounds=(0.0, 1.0))
+
+    def _initialize_infill(self):
+        return self.initialization.do(self.problem, get(self.pop_size), algorithm=self, random_state=self.random_state)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        self.pop = FitnessSurvival().do(self.problem, infills, n_survive=len(infills), algorithm=self, **kwargs)
+
+    def _next(self, **kwargs):
+        pop_size, n_offsprings, n_parents = get(self.pop_size, self.n_offsprings, self.n_parents)
+
+        # how many loops shall be iterated until one iteration has ended
+        loops_per_iter = pop_size // n_offsprings
+
+        for _ in range(loops_per_iter):
+
+            S = np.zeros((n_offsprings, n_parents), dtype=int)
+            S[:, 0] = 0
+            fast_fill_random(S, len(self.pop), columns=range(1, n_parents), random_state=self.random_state)
+
+            off = self.crossover(self.problem, self.pop, parents=S, algorithm=self, random_state=self.random_state)
+
+            off = self.mutation(self.problem, off, algorithm=self, random_state=self.random_state)
+
+            self.repair(self.problem, off, algorithm=self)
+
+            off = yield off
+
+            pop, family_size = self.pop, get(self.family_size)
+
+            rnd = self.random_state.choice(np.arange(len(pop)), size=family_size, replace=False)
+            family = Population.merge(pop[rnd], off)
+            pop[rnd] = FitnessSurvival().do(self.problem, family, n_survive=family_size)
+
+            for i in rnd:
+                if is_better(pop[i], pop[0]):
+                    tmp = pop[0]
+                    pop[0] = pop[i]
+                    pop[i] = tmp
+
+    def _set_optimum(self, **kwargs):
+        self.opt = self.pop[[0]]
+
+
+parse_doc_string(G3PCX.__init__)

pymoo/algorithms/soo/nonconvex/ga.py

@@ -0,0 +1,95 @@
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.crossover.spx import SPX
+from pymoo.operators.mutation.bitflip import BitflipMutation
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import BinaryRandomSampling
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.tournament import compare, TournamentSelection
+from pymoo.termination.default import DefaultSingleObjectiveTermination
+from pymoo.util import default_random_state
+from pymoo.util.display.single import SingleObjectiveOutput
+
+
+# =========================================================================================================
+# Survival
+# =========================================================================================================
+
+class FitnessSurvival(Survival):
+
+    def __init__(self) -> None:
+        super().__init__(filter_infeasible=False)
+
+    def _do(self, problem, pop, n_survive=None, **kwargs):
+        F, cv = pop.get("F", "cv")
+        assert F.shape[1] == 1, "FitnessSurvival can only used for single objective single!"
+        S = np.lexsort([F[:, 0], cv])
+        pop.set("rank", np.argsort(S))
+        return pop[S[:n_survive]]
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+@default_random_state
+def comp_by_cv_and_fitness(pop, P, random_state=None, **kwargs):
+    S = np.full(P.shape[0], np.nan)
+
+    for i in range(P.shape[0]):
+        a, b = P[i, 0], P[i, 1]
+
+        # if at least one solution is infeasible
+        if pop[a].CV > 0.0 or pop[b].CV > 0.0:
+            S[i] = compare(a, pop[a].CV, b, pop[b].CV, method='smaller_is_better', return_random_if_equal=True, random_state=random_state)
+
+        # both solutions are feasible just set random
+        else:
+            S[i] = compare(a, pop[a].F, b, pop[b].F, method='smaller_is_better', return_random_if_equal=True, random_state=random_state)
+
+    return S[:, None].astype(int)
+
+
+class GA(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 selection=TournamentSelection(func_comp=comp_by_cv_and_fitness),
+                 crossover=SBX(),
+                 mutation=PM(),
+                 survival=FitnessSurvival(),
+                 eliminate_duplicates=True,
+                 n_offsprings=None,
+                 output=SingleObjectiveOutput(),
+                 **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,
+                         output=output,
+                         **kwargs)
+
+        self.termination = DefaultSingleObjectiveTermination()
+
+
+class BGA(GA):
+
+    def __init__(self,
+                 sampling=BinaryRandomSampling(),
+                 crossover=SPX(),
+                 mutation=BitflipMutation(),
+                 **kwargs):
+        super().__init__(sampling=sampling, crossover=crossover, mutation=mutation, **kwargs)
+
+
+parse_doc_string(GA.__init__)

pymoo/algorithms/soo/nonconvex/ga_niching.py

@@ -0,0 +1,223 @@
+import numpy as np
+
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival, GA
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.operators.selection.tournament import compare, TournamentSelection
+from pymoo.termination.cv import ConstraintViolationTermination
+from pymoo.termination.default import DefaultSingleObjectiveTermination, DefaultTermination
+from pymoo.termination.ftol import SingleObjectiveSpaceTermination
+from pymoo.termination.robust import RobustTermination
+from pymoo.termination.xtol import DesignSpaceTermination
+from pymoo.util.clearing import EpsilonClearing
+from pymoo.util.display.column import Column
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.misc import norm_eucl_dist
+
+
+# =========================================================================================================
+# Display
+# =========================================================================================================
+
+class NicheOutput(SingleObjectiveOutput):
+
+    def __init__(self):
+        super().__init__()
+        self.n_niches = Column("n_niches", width=10, func=lambda algorithm: len(algorithm.opt))
+        self.columns += [self.n_niches]
+
+
+# =========================================================================================================
+# Termination
+# =========================================================================================================
+
+class NicheSingleObjectiveSpaceToleranceTermination(SingleObjectiveSpaceTermination):
+
+    def _data(self, algorithm):
+        return algorithm.opt.get("F").mean()
+
+
+class NicheTermination(DefaultTermination):
+
+    def __init__(self,
+                 x_tol=1e-32,
+                 cv_tol=1e-6,
+                 f_tol=1e-6,
+                 period=20,
+                 **kwargs) -> None:
+        super().__init__(RobustTermination(DesignSpaceTermination(tol=x_tol), period=period),
+                         RobustTermination(ConstraintViolationTermination(tol=cv_tol), period=period),
+                         RobustTermination(NicheSingleObjectiveSpaceToleranceTermination(tol=f_tol, n_skip=5),
+                                           period=period),
+                         **kwargs)
+
+
+# =========================================================================================================
+# Selection
+# =========================================================================================================
+
+
+def comp_by_cv_and_clearing_fitness(pop, P, **kwargs):
+    S = np.full(P.shape[0], np.nan)
+
+    for i in range(P.shape[0]):
+        a, b = P[i, 0], P[i, 1]
+
+        # if at least one solution is infeasible
+        if pop[a].CV[0] > 0.0 or pop[b].CV[0] > 0.0:
+            S[i] = compare(a, pop[a].CV, b, pop[b].CV,
+                           method='smaller_is_better',
+                           return_random_if_equal=True)
+
+        # first compare by the round the individual was selected
+        else:
+            S[i] = compare(a, pop[a].get("iter"), b, pop[b].get("iter"), method='smaller_is_better')
+
+            # if it was the same round - then use the rank of the fitness directly
+            if np.isnan(S[i]):
+                S[i] = compare(a, pop[a].get("rank"), b, pop[b].get("rank"),
+                               method='smaller_is_better', return_random_if_equal=True)
+
+    return S[:, None].astype(int)
+
+
+# =========================================================================================================
+# Survival
+# =========================================================================================================
+
+class EpsilonClearingSurvival(Survival):
+
+    def __init__(self, epsilon, n_max_each_iter=None, norm_by_dim=False) -> None:
+        super().__init__(False)
+        self.epsilon = epsilon
+        self.n_max_each_iter = n_max_each_iter
+        self.norm_by_dim = norm_by_dim
+
+    def _do(self, problem, pop, n_survive=None, out=None, **kwargs):
+        F = pop.get("F")
+
+        if F.shape[1] != 1:
+            raise ValueError("FitnessSurvival can only used for single objective single!")
+
+        # this basically sorts the population by constraint and objective value
+        pop = FitnessSurvival().do(problem, pop, n_survive=len(pop))
+
+        # calculate the distance from each individual to another - pre-processing for the clearing
+        # NOTE: the distance is normalized by the maximum distance possible
+        X = pop.get("X").astype(float)
+        D = norm_eucl_dist(problem, X, X)
+        if self.norm_by_dim:
+            D = D / (problem.n_var ** 0.5)
+
+        # initialize the clearing strategy
+        clearing = EpsilonClearing(D, self.epsilon)
+
+        # initialize the iteration and rank i the beginning
+        iter, rank = 1, 1
+
+        # also solutions that have been found in the first iteration
+        iter_one = None
+
+        # until the number of selected individuals are less than expected survivors
+        while len(clearing.selected()) < n_survive:
+
+            # get all the remaining indices
+            remaining = clearing.remaining()
+
+            # if no individuals are left because of clearing - perform a reset
+            if len(remaining) == 0 or (self.n_max_each_iter is not None and rank > self.n_max_each_iter):
+                # reset and retrieve the newly available indices
+                clearing.reset()
+                remaining = clearing.remaining()
+
+                # increase the iteration counter and start over from rank 1
+                iter += 1
+                rank = 1
+
+                # get the individual of the first iteration - needed for niche assignment
+                iter_one = np.where(pop.get("iter") == 1)[0] if iter_one is None else iter_one
+
+            # since the population is ordered by F and CV it is always the first index
+            k = remaining[0]
+
+            # set the attribute to the selected individual
+            pop[k].set("iter", iter)
+            pop[k].set("rank", rank)
+
+            # in the first iteration set the niche counter for each solution equal to rank
+            if iter == 1:
+                pop[k].set("niche", rank)
+            else:
+                closest_iter_one = iter_one[D[k][iter_one].argmin()]
+                niche = pop[closest_iter_one].get("niche")
+                pop[k].set("niche", niche)
+
+            clearing.select(k)
+            rank += 1
+
+        # retrieve all individuals being selected
+        S = clearing.selected()
+
+        return pop[S]
+
+
+# =========================================================================================================
+# Algorithm
+# =========================================================================================================
+
+
+class NicheGA(GA):
+
+    def __init__(self,
+                 pop_size=100,
+                 norm_niche_size=0.05,
+                 norm_by_dim=False,
+                 return_all_opt=True,
+                 output=NicheOutput(),
+                 survival=None,
+                 selection=None,
+                 **kwargs):
+        """
+
+        Parameters
+        ----------
+        norm_niche_size : float
+            The radius in which the clearing shall be performed. The clearing is performed in the normalized design
+            space, e.g. 0.05 corresponds to clear all solutions which have less norm euclidean distance than 5%.
+        pop_size : {pop_size}
+        sampling : {sampling}
+        selection : {selection}
+        crossover : {crossover}
+        mutation : {mutation}
+        eliminate_duplicates : {eliminate_duplicates}
+        n_offsprings : {n_offsprings}
+
+        """
+
+        if survival is None:
+            survival = EpsilonClearingSurvival(norm_niche_size, n_max_each_iter=None, norm_by_dim=norm_by_dim)
+
+        if selection is None:
+            selection = TournamentSelection(comp_by_cv_and_clearing_fitness)
+
+        super().__init__(pop_size=pop_size,
+                         selection=selection,
+                         survival=survival,
+                         output=output,
+                         advance_after_initial_infill=True,
+                         **kwargs)
+
+        # self.termination = NicheTermination()
+        self.termination = DefaultSingleObjectiveTermination()
+
+        # whether with rank one after clearing or just the best should be considered as optimal
+        self.return_all_opt = return_all_opt
+
+    def _set_optimum(self, **kwargs):
+        if self.return_all_opt:
+            self.opt = self.pop[self.pop.get("iter") == 1]
+        else:
+            super()._set_optimum()
+
+
+parse_doc_string(NicheGA.__init__)

pymoo/algorithms/soo/nonconvex/isres.py

@@ -0,0 +1,74 @@
+from math import sqrt, log, exp
+
+import numpy as np
+
+from pymoo.algorithms.soo.nonconvex.es import es_sigma, es_mut_repair
+from pymoo.algorithms.soo.nonconvex.sres import SRES
+from pymoo.core.population import Population
+from pymoo.docs import parse_doc_string
+
+
+class ISRES(SRES):
+
+    def __init__(self, gamma=0.85, alpha=0.2, **kwargs):
+        """
+        Improved Stochastic Ranking Evolutionary Strategy (SRES)
+
+        Parameters
+        ----------
+        alpha : float
+            Length scale of the differentials during mutation.
+        PF: float
+            The stochastic ranking weight for choosing a random decision while doing the modified bubble sort.
+        """
+
+        super().__init__(**kwargs)
+        self.gamma = gamma
+        self.alpha = alpha
+
+    def _setup(self, problem, **kwargs):
+        super()._setup(problem, **kwargs)
+        n = problem.n_var
+
+        chi = (1 / (2 * n) + 1 / (2 * (n ** 0.5)))
+        varphi = sqrt((2 / chi) * log((1 / self.alpha) * (exp(self.phi ** 2 * chi / 2) - (1 - self.alpha))))
+
+        self.taup = varphi / ((2 * n) ** 0.5)
+        self.tau = varphi / ((2 * (n ** 0.5)) ** 0.5)
+
+    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) % min(mu, len(X))
+
+        # transform X and sigma to the shape of number of offsprings
+        X, sigma = X[I], sigma[I]
+
+        # copy the original sigma to sigma prime to be modified
+        Xp, sigmap = np.copy(X), np.copy(sigma)
+
+        # for the best individuals do differential variation to provide a direction to search in
+        Xp[:mu - 1] = X[:mu - 1] + self.gamma * (X[0] - X[1:mu])
+
+        # update the sigma values for elite and non-elite individuals
+        sigmap[mu - 1:] = np.minimum(self.sigma_max, es_sigma(sigma[mu - 1:], self.tau, self.taup, random_state=self.random_state))
+
+        # execute the evolutionary strategy to calculate the offspring solutions
+        Xp[mu - 1:] = X[mu - 1:] + sigmap[mu - 1:] * self.random_state.normal(size=sigmap[mu - 1:].shape)
+
+        # repair the individuals which are not feasible by sampling from sigma again
+        Xp = es_mut_repair(Xp, X, sigmap, xl, xu, 10, random_state=self.random_state)
+
+        # now update the sigma values of the non-elites only
+        sigmap[mu:] = sigma[mu:] + self.alpha * (sigmap[mu:] - sigma[mu:])
+
+        # create the population to proceed further
+        off = Population.new(X=Xp, sigma=sigmap)
+
+        return off
+
+
+parse_doc_string(ISRES.__init__)