pymoo 0.6.1.5.dev0__cp313-cp313-macosx_10_13_universal2.whl

pymoo/algorithms/moo/spea2.py

@@ -0,0 +1,190 @@
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.moo.nsga3 import HyperplaneNormalization
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.tournament import TournamentSelection, compare
+from pymoo.termination.default import DefaultMultiObjectiveTermination
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.dominator import Dominator
+from pymoo.util.misc import vectorized_cdist
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Environmental Survival (in the original paper it is referred to as archiving)
+# ---------------------------------------------------------------------------------------------------------
+
+
+class SPEA2Survival(Survival):
+
+    def __init__(self, normalize=False, filter_infeasible=True):
+        super().__init__(filter_infeasible)
+
+        # whether the survival should considered normalized distance or just raw
+        self.normalize = normalize
+
+        # an object keeping track of normalization points
+        self.norm = None
+
+    def _do(self, problem, pop, *args, n_survive=None, **kwargs):
+
+        # get the objective space values and objects
+        F = pop.get("F").astype(float, copy=False)
+
+        # the domination matrix to see the relation for each solution to another
+        M = Dominator().calc_domination_matrix(F)
+
+        # the number of solutions each individual dominates
+        S = (M == 1).sum(axis=0)
+
+        # the raw fitness of each solution - strength of its dominators
+        R = ((M == -1) * S).sum(axis=1)
+
+        # determine what k-th nearest neighbor to consider
+        k = int(np.sqrt(len(pop)))
+        if k >= len(pop):
+            k = len(pop) - 1
+
+        # if normalization is enabled keep track of ideal and nadir
+        if self.normalize:
+
+            # initialize the first time and then always update the boundary points
+            if self.norm is None:
+                self.norm = HyperplaneNormalization(F.shape[1])
+            self.norm.update(F)
+
+            ideal, nadir = self.norm.ideal_point, self.norm.nadir_point
+
+            _F = (F - ideal) / (nadir - ideal)
+            dists = vectorized_cdist(_F, _F, fill_diag_with_inf=True)
+
+        # if no normalize is required simply use the F values from the population
+        else:
+            dists = vectorized_cdist(F, F, fill_diag_with_inf=True)
+
+        # the distances sorted for each individual
+        sdists = np.sort(dists, axis=1)
+
+        # inverse distance as part of the fitness
+        D = 1 / (sdists[:, k] + 2)
+
+        # the actual fitness value used to determine who survives
+        SPEA_F = R + D
+
+        # set all the attributes to the population
+        pop.set(SPEA_F=SPEA_F, SPEA_R=R, SPEA_D=D)
+
+        # get all the non-dominated solutions
+        survivors = list(np.where(np.all(M >= 0, axis=1))[0])
+
+        # if we normalize give boundary points most importance - give the boundary points in the nds set the lowest fit.
+        if self.normalize:
+            I = vectorized_cdist(self.norm.extreme_points, F[survivors]).argmin(axis=1)
+            pop[survivors][I].set("SPEA_F", -1.0)
+
+        # identify the remaining individuals to choose from
+        H = set(survivors)
+        rem = np.array([k for k in range(len(pop)) if k not in H])
+
+        # if not enough solutions, will up by F
+        if len(survivors) < n_survive:
+
+            # sort them by the fitness values (lower is better) and append them
+            rem_by_F = rem[SPEA_F[rem].argsort()]
+            survivors.extend(rem_by_F[:n_survive - len(survivors)])
+
+        # if too many, delete based on distances
+        elif len(survivors) > n_survive:
+
+            # remove one individual per loop, until we hit n_survive
+            while len(survivors) > n_survive:
+                i = dists[survivors][:, survivors].min(axis=1).argmin()
+                survivors = [survivors[j] for j in range(len(survivors)) if j != i]
+
+        return pop[survivors]
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Binary Tournament Selection
+# ---------------------------------------------------------------------------------------------------------
+
+
+def spea_binary_tournament(pop, P, algorithm, **kwargs):
+    n_tournaments, n_parents = P.shape
+
+    if n_parents != 2:
+        raise ValueError("Only implemented for binary tournament!")
+
+    S = np.full(n_tournaments, np.nan)
+
+    for i in range(n_tournaments):
+
+        a, b = P[i, 0], P[i, 1]
+        a_cv, a_f, b_cv, b_f, = pop[a].CV[0], pop[a].F, pop[b].CV[0], pop[b].F
+
+        # if at least one solution is infeasible
+        if a_cv > 0.0 or b_cv > 0.0:
+            S[i] = compare(a, a_cv, b, b_cv, method='smaller_is_better', return_random_if_equal=True)
+
+        # both solutions are feasible
+        else:
+            S[i] = compare(a, pop[a].get("SPEA_F"), b, pop[b].get("SPEA_F"), method='smaller_is_better',
+                           return_random_if_equal=True)
+
+    return S[:, None].astype(int, copy=False)
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Algorithm
+# ---------------------------------------------------------------------------------------------------------
+
+
+class SPEA2(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 selection=TournamentSelection(spea_binary_tournament),
+                 crossover=SBX(),
+                 mutation=PM(),
+                 survival=SPEA2Survival(normalize=True),
+                 eliminate_duplicates=True,
+                 n_offsprings=None,
+                 output=MultiObjectiveOutput(),
+                 **kwargs):
+        """
+
+        SPEA2 - Strength Pareto EA 2
+
+        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,
+                         output=output,
+                         advance_after_initial_infill=True,
+                         **kwargs)
+        self.termination = DefaultMultiObjectiveTermination()
+
+
+parse_doc_string(SPEA2.__init__)
+

pymoo/algorithms/moo/unsga3.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+from pymoo.algorithms.moo.nsga3 import NSGA3
+from pymoo.operators.selection.tournament import compare, TournamentSelection
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+def comp_by_rank_and_ref_line_dist(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 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)
+
+        # both solutions are feasible
+        else:
+
+            # if in the same niche select by rank
+            if pop[a].get("niche") == pop[b].get("niche"):
+
+                if pop[a].get("rank") != pop[b].get("rank"):
+                    S[i] = compare(a, pop[a].get("rank"), b, pop[b].get("rank"), method='smaller_is_better')
+
+                else:
+                    S[i] = compare(a, pop[a].get("dist_to_niche"), b, pop[b].get("dist_to_niche"),
+                                   method='smaller_is_better')
+
+        if np.isnan(S[i]):
+            S[i] = np.random.choice([a, b])
+
+    return S[:, None].astype(int)
+
+
+class UNSGA3(NSGA3):
+
+    def __init__(self,
+                 ref_dirs,
+                 selection=TournamentSelection(func_comp=comp_by_rank_and_ref_line_dist),
+                 **kwargs):
+        super().__init__(ref_dirs, selection=selection, **kwargs)

pymoo/algorithms/soo/nonconvex/brkga.py

@@ -0,0 +1,161 @@
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.duplicate import DefaultDuplicateElimination, DuplicateElimination
+from pymoo.core.population import Population
+from pymoo.core.selection import Selection
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.binx import BinomialCrossover
+from pymoo.operators.mutation.nom import NoMutation
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.termination.default import DefaultSingleObjectiveTermination
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class EliteSurvival(Survival):
+
+    def __init__(self, n_elites, eliminate_duplicates=None):
+        super().__init__(False)
+        self.n_elites = n_elites
+        self.eliminate_duplicates = eliminate_duplicates
+
+    def _do(self, problem, pop, n_survive=None, algorithm=None, **kwargs):
+
+        if isinstance(self.eliminate_duplicates, bool) and self.eliminate_duplicates:
+            pop = DefaultDuplicateElimination(func=lambda p: p.get("F")).do(pop)
+
+        elif isinstance(self.eliminate_duplicates, DuplicateElimination):
+            _, no_candidates, candidates = DefaultDuplicateElimination(func=lambda pop: pop.get("F")).do(pop,
+                                                                                                         return_indices=True)
+            _, _, is_duplicate = self.eliminate_duplicates.do(pop[candidates], pop[no_candidates], return_indices=True,
+                                                              to_itself=False)
+            elim = set(np.array(candidates)[is_duplicate])
+            pop = pop[[k for k in range(len(pop)) if k not in elim]]
+
+        if problem.n_obj == 1:
+            pop = FitnessSurvival().do(problem, pop, n_survive=len(pop))
+            elites = pop[:self.n_elites]
+            non_elites = pop[self.n_elites:]
+        else:
+            I = NonDominatedSorting().do(pop.get("F"), only_non_dominated_front=True)
+            elites = pop[I]
+            non_elites = pop[[k for k in range(len(pop)) if k not in I]]
+
+        elites.set("type", ["elite"] * len(elites))
+        non_elites.set("type", ["non_elite"] * len(non_elites))
+
+        return pop
+
+
+class EliteBiasedSelection(Selection):
+
+    def _do(self, problem, pop, n_select, n_parents, **kwargs):
+        _type = pop.get("type")
+        elites = np.where(_type == "elite")[0].astype(int)
+        non_elites = np.where(_type == "non_elite")[0].astype(int)
+
+        # if through duplicate elimination no non-elites exist
+        if len(non_elites) == 0:
+            non_elites = elites
+
+        # do the mating selection - always one elite and one non-elites
+        s_elite = np.random.choice(elites, size=n_select)
+        s_non_elite = np.random.choice(non_elites, size=n_select)
+
+        return np.column_stack([s_elite, s_non_elite])
+
+
+class BRKGA(GeneticAlgorithm):
+
+    def __init__(self,
+                 n_elites=200,
+                 n_offsprings=700,
+                 n_mutants=100,
+                 bias=0.7,
+                 sampling=FloatRandomSampling(),
+                 survival=None,
+                 output=SingleObjectiveOutput(),
+                 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, n_offsprings=1),
+                         mutation=NoMutation(),
+                         survival=survival,
+                         output=output,
+                         eliminate_duplicates=True,
+                         advance_after_initial_infill=True,
+                         **kwargs)
+
+        self.n_elites = n_elites
+        self.n_mutants = n_mutants
+        self.bias = bias
+        self.termination = DefaultSingleObjectiveTermination()
+
+    def _infill(self):
+        pop = self.pop
+
+        # actually do the mating given the elite selection and biased crossover
+        off = self.mating.do(self.problem, pop, n_offsprings=self.n_offsprings, algorithm=self)
+
+        # create the mutants randomly to fill the population with
+        mutants = FloatRandomSampling().do(self.problem, self.n_mutants, algorithm=self)
+
+        # evaluate all the new solutions
+        return Population.merge(off, mutants)
+
+    def _advance(self, infills=None, **kwargs):
+        pop = self.pop
+
+        # get all the elites from the current population
+        elites = np.where(pop.get("type") == "elite")[0]
+
+        # finally merge everything together and sort by fitness
+        pop = Population.merge(pop[elites], infills)
+
+        # the do survival selection - set the elites for the next round
+        self.pop = self.survival.do(self.problem, pop, n_survive=len(pop), algorithm=self)
+
+
+parse_doc_string(BRKGA.__init__)