pymoo 0.6.1.5.dev0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pymoo/algorithms/moo/rnsga3.py

@@ -0,0 +1,246 @@
+import numpy as np
+
+from pymoo.algorithms.moo.nsga3 import calc_niche_count, niching, comp_by_cv_then_random, associate_to_niches, NSGA3
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.tournament import TournamentSelection
+from pymoo.util.misc import intersect
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.util.normalization import denormalize, get_extreme_points_c, get_nadir_point
+from pymoo.util.reference_direction import UniformReferenceDirectionFactory
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class RNSGA3(NSGA3):
+
+    def __init__(self,
+                 ref_points,
+                 pop_per_ref_point,
+                 mu=0.05,
+                 sampling=FloatRandomSampling(),
+                 selection=TournamentSelection(func_comp=comp_by_cv_then_random),
+                 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 init_simplex_scale of the reference lines used during survival selection. Increasing mu will result
+            having solutions with a larger spread.
+
+        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,
+                         survival=survival,
+                         eliminate_duplicates=eliminate_duplicates,
+                         n_offsprings=n_offsprings,
+                         **kwargs)
+
+    def _setup(self, problem, **kwargs):
+        if self.survival.ref_points.shape[1] != problem.n_obj:
+            raise Exception("Dimensionality of reference points must be equal to the number of objectives: %s != %s" %
+                            (self.survival.ref_points.shape[1], problem.n_obj))
+
+    def _finalize(self):
+        pass
+
+
+class AspirationPointSurvival(Survival):
+
+    def __init__(self, ref_points, aspiration_ref_dirs, mu=0.1):
+        super().__init__()
+
+        self.ref_points = ref_points
+        self.aspiration_ref_dirs = aspiration_ref_dirs
+        self.mu = mu
+
+        self.ref_dirs = aspiration_ref_dirs
+        self.extreme_points = None
+        self.intercepts = None
+        self.nadir_point = None
+        self.opt = None
+        self.ideal_point = np.full(ref_points.shape[1], np.inf)
+        self.worst_point = np.full(ref_points.shape[1], -np.inf)
+
+    def _do(self, problem, pop, n_survive, D=None, **kwargs):
+
+        # attributes to be set after the survival
+        F = pop.get("F")
+
+        # find or usually update the new ideal point - from feasible solutions
+        self.ideal_point = np.min(np.vstack((self.ideal_point, F, self.ref_points)), axis=0)
+        self.worst_point = np.max(np.vstack((self.worst_point, F, self.ref_points)), axis=0)
+
+        # calculate the fronts of the population
+        fronts, rank = NonDominatedSorting().do(F, return_rank=True, n_stop_if_ranked=n_survive)
+        non_dominated, last_front = fronts[0], fronts[-1]
+
+        # find the extreme points for normalization
+        self.extreme_points = get_extreme_points_c(
+            np.vstack([F[non_dominated], self.ref_points])
+            , self.ideal_point,
+            extreme_points=self.extreme_points)
+
+        # find the intercepts for normalization and do backup if gaussian elimination fails
+        worst_of_population = np.max(F, axis=0)
+        worst_of_front = np.max(F[non_dominated, :], axis=0)
+
+        self.nadir_point = get_nadir_point(self.extreme_points, self.ideal_point, self.worst_point,
+                                           worst_of_population, worst_of_front)
+
+        #  consider only the population until we come to the splitting front
+        I = np.concatenate(fronts)
+        pop, rank, F = pop[I], rank[I], F[I]
+
+        # update the front indices for the current population
+        counter = 0
+        for i in range(len(fronts)):
+            for j in range(len(fronts[i])):
+                fronts[i][j] = counter
+                counter += 1
+        last_front = fronts[-1]
+
+        unit_ref_points = (self.ref_points - self.ideal_point) / (self.nadir_point - self.ideal_point)
+        ref_dirs = get_ref_dirs_from_points(unit_ref_points, self.aspiration_ref_dirs, mu=self.mu)
+        self.ref_dirs = denormalize(ref_dirs, self.ideal_point, self.nadir_point)
+
+        # associate individuals to niches
+        niche_of_individuals, dist_to_niche, dist_matrix = associate_to_niches(F, ref_dirs, self.ideal_point,
+                                                                               self.nadir_point)
+        pop.set('rank', rank, 'niche', niche_of_individuals, 'dist_to_niche', dist_to_niche)
+
+        # set the optimum, first front and closest to all reference directions
+        closest = np.unique(dist_matrix[:, np.unique(niche_of_individuals)].argmin(axis=0))
+        self.opt = pop[intersect(fronts[0], closest)]
+
+        # if we need to select individuals to survive
+        if len(pop) > n_survive:
+
+            # if there is only one front
+            if len(fronts) == 1:
+                n_remaining = n_survive
+                until_last_front = np.array([], dtype=int)
+                niche_count = np.zeros(len(ref_dirs), dtype=int)
+
+            # if some individuals already survived
+            else:
+                until_last_front = np.concatenate(fronts[:-1])
+                niche_count = calc_niche_count(len(ref_dirs), niche_of_individuals[until_last_front])
+                n_remaining = n_survive - len(until_last_front)
+
+            S = niching(pop[last_front], n_remaining, niche_count, niche_of_individuals[last_front],
+                        dist_to_niche[last_front])
+
+            survivors = np.concatenate((until_last_front, last_front[S].tolist()))
+            pop = pop[survivors]
+
+        return pop
+
+
+def get_ref_dirs_from_points(ref_point, ref_dirs, mu=0.1):
+    """
+    This function takes user specified reference points, and creates smaller sets of equidistant
+    Das-Dennis points around the projection of user points on the Das-Dennis hyperplane
+    :param ref_point: List of user specified reference points
+    :param n_obj: Number of objectives to consider
+    :param mu: Shrinkage factor (0-1), Smaller = tighter convergence, Larger= larger convergence
+    :return: Set of reference points
+    """
+
+    n_obj = ref_point.shape[1]
+
+    val = []
+    n_vector = np.ones(n_obj) / np.sqrt(n_obj)  # Normal vector of Das Dennis plane
+    point_on_plane = np.eye(n_obj)[0]  # Point on Das-Dennis
+
+    for point in ref_point:
+
+        ref_dir_for_aspiration_point = np.copy(ref_dirs)  # Copy of computed reference directions
+        ref_dir_for_aspiration_point = mu * ref_dir_for_aspiration_point
+
+        cent = np.mean(ref_dir_for_aspiration_point, axis=0)  # Find centroid of shrunken reference points
+
+        # Project shrunken Das-Dennis points back onto original Das-Dennis hyperplane
+        intercept = line_plane_intersection(np.zeros(n_obj), point, point_on_plane, n_vector)
+        shift = intercept - cent  # shift vector
+
+        ref_dir_for_aspiration_point += shift
+
+        # If reference directions are located outside of first octant, redefine points onto the border
+        if not (ref_dir_for_aspiration_point > 0).min():
+            ref_dir_for_aspiration_point[ref_dir_for_aspiration_point < 0] = 0
+            ref_dir_for_aspiration_point = ref_dir_for_aspiration_point / np.sum(ref_dir_for_aspiration_point, axis=1)[
+                                                                          :, None]
+        val.extend(ref_dir_for_aspiration_point)
+
+    val.extend(np.eye(n_obj))  # Add extreme points
+    return np.array(val)
+
+
+# intersection function
+
+def line_plane_intersection(l0, l1, p0, p_no, epsilon=1e-6):
+    """
+    l0, l1: define the line
+    p0, p_no: define the plane:
+        p0 is a point on the plane (plane coordinate).
+        p_no is a normal vector defining the plane direction;
+             (does not need to be normalized).
+
+    reference: https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection
+    return a Vector or None (when the intersection can't be found).
+    """
+
+    l = l1 - l0
+    dot = np.dot(l, p_no)
+
+    if abs(dot) > epsilon:
+        # the factor of the point between p0 -> p1 (0 - 1)
+        # if 'fac' is between (0 - 1) the point intersects with the segment.
+        # otherwise:
+        #  < 0.0: behind p0.
+        #  > 1.0: in front of p1.
+        w = p0 - l0
+        d = np.dot(w, p_no) / dot
+        l = l * d
+        return l0 + l
+    else:
+        # The segment is parallel to plane then return the perpendicular projection
+        ref_proj = l1 - (np.dot(l1 - p0, p_no) * p_no)
+        return ref_proj
+
+
+parse_doc_string(RNSGA3.__init__)

pymoo/algorithms/moo/rvea.py

@@ -0,0 +1,214 @@
+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.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.rnd import RandomSelection
+from pymoo.termination.max_eval import MaximumFunctionCallTermination
+from pymoo.termination.max_gen import MaximumGenerationTermination
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.misc import has_feasible, vectorized_cdist
+
+
+class RVEA(GeneticAlgorithm):
+
+    def __init__(self,
+                 ref_dirs,
+                 alpha=2.0,
+                 adapt_freq=0.1,
+                 pop_size=None,
+                 sampling=FloatRandomSampling(),
+                 selection=RandomSelection(),
+                 crossover=SBX(eta=30, prob=1.0),
+                 mutation=PM(eta=20),
+                 eliminate_duplicates=True,
+                 n_offsprings=None,
+                 output=MultiObjectiveOutput(),
+                 **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,
+                         output=output,
+                         **kwargs)
+
+    def _setup(self, problem, **kwargs):
+
+        # if maximum functions termination convert it to generations
+        if isinstance(self.termination, MaximumFunctionCallTermination):
+            n_gen = np.ceil((self.termination.n_max_evals - self.pop_size) / self.n_offsprings)
+            self.termination = MaximumGenerationTermination(n_gen)
+
+        # check whether the n_gen termination is used - otherwise this algorithm can be not run
+        if not isinstance(self.termination, MaximumGenerationTermination):
+            raise Exception("Please use the n_gen or n_eval as a termination criterion to run RVEA!")
+
+    def _advance(self, **kwargs):
+        super()._advance(**kwargs)
+
+        # get the  current generation and maximum of generations
+        n_gen, n_max_gen = self.n_gen, self.termination.n_max_gen
+
+        # each i-th generation (define by fr and n_max_gen) the reference directions are updated
+        if self.adapt_freq is not None and n_gen % np.ceil(n_max_gen * self.adapt_freq) == 0:
+            self.survival.adapt()
+
+    def _set_optimum(self, **kwargs):
+        if not has_feasible(self.pop):
+            self.opt = self.pop[[np.argmin(self.pop.get("CV"))]]
+        else:
+            self.opt = self.pop
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Survival Selection
+# ---------------------------------------------------------------------------------------------------------
+
+def calc_gamma(V):
+    gamma = np.arccos((- np.sort(-1 * V @ V.T))[:, 1])
+    gamma = np.maximum(gamma, 1e-64)
+    return gamma
+
+
+def calc_V(ref_dirs):
+    return ref_dirs / np.linalg.norm(ref_dirs, axis=1)[:, None]
+
+
+class APDSurvival(Survival):
+
+    def __init__(self, ref_dirs, alpha=2.0) -> None:
+        super().__init__(filter_infeasible=True)
+        n_dim = ref_dirs.shape[1]
+
+        self.alpha = alpha
+        self.niches = None
+        self.V, self.gamma = None, None
+        self.ideal, self.nadir = np.full(n_dim, np.inf), None
+
+        self.ref_dirs = ref_dirs
+        self.extreme_ref_dirs = np.where(np.any(vectorized_cdist(self.ref_dirs, np.eye(n_dim)) == 0, axis=1))[0]
+
+        self.V = calc_V(self.ref_dirs)
+        self.gamma = calc_gamma(self.V)
+
+    def adapt(self):
+        if self.nadir is not None:
+            self.V = calc_V(calc_V(self.ref_dirs) * (self.nadir - self.ideal))
+            self.gamma = calc_gamma(self.V)
+
+    def _do(self, problem, pop, n_survive, algorithm=None, n_gen=None, n_max_gen=None, **kwargs):
+
+        if n_gen is None:
+            n_gen = algorithm.n_gen - 1
+        if n_max_gen is None:
+            n_max_gen = algorithm.termination.n_max_gen
+
+        # get the objective space values
+        F = pop.get("F")
+
+        # store the ideal and nadir point estimation for adapt - (and ideal for transformation)
+        self.ideal = np.minimum(F.min(axis=0), self.ideal)
+
+        # translate the population to make the ideal point the origin
+        F = F - self.ideal
+
+        # the distance to the ideal point
+        dist_to_ideal = np.linalg.norm(F, axis=1)
+        dist_to_ideal[dist_to_ideal < 1e-64] = 1e-64
+
+        # normalize by distance to ideal
+        F_prime = F / dist_to_ideal[:, None]
+
+        # calculate for each solution the acute angles to ref dirs
+        acute_angle = np.arccos(F_prime @ self.V.T)
+        niches = acute_angle.argmin(axis=1)
+
+        # assign to each reference direction the solution
+        niches_to_ind = [[] for _ in range(len(self.V))]
+        for k, i in enumerate(niches):
+            niches_to_ind[i].append(k)
+
+        # all individuals which will be surviving
+        survivors = []
+
+        # for each reference direction
+        for k in range(len(self.V)):
+
+            # individuals assigned to the niche
+            assigned_to_niche = niches_to_ind[k]
+
+            # if niche not empty
+            if len(assigned_to_niche) > 0:
+
+                # the angle of niche to nearest neighboring niche
+                gamma = self.gamma[k]
+
+                # the angle from the individuals of this niches to the niche itself
+                theta = acute_angle[assigned_to_niche, k]
+
+                # the penalty which is applied for the metric
+                M = problem.n_obj if problem.n_obj > 2.0 else 1.0
+                penalty = M * ((n_gen / n_max_gen) ** self.alpha) * (theta / gamma)
+
+                # calculate the angle-penalized penalized (APD)
+                apd = dist_to_ideal[assigned_to_niche] * (1 + penalty)
+
+                # the individual which survives
+                survivor = assigned_to_niche[apd.argmin()]
+
+                # set attributes to the individual
+                pop[assigned_to_niche].set(theta=theta, apd=apd, niche=k, opt=False)
+                pop[survivor].set("opt", True)
+
+                # select the one with smallest APD value
+                survivors.append(survivor)
+
+        ret = pop[survivors]
+        self.niches = niches_to_ind
+        self.nadir = ret.get("F").max(axis=0)
+
+        return ret
+
+
+parse_doc_string(RVEA.__init__)

pymoo/algorithms/moo/sms.py

@@ -0,0 +1,195 @@
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.core.population import Population
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.indicators.hv.exact import ExactHypervolume
+from pymoo.indicators.hv.exact_2d import ExactHypervolume2D
+from pymoo.indicators.hv.monte_carlo import ApproximateMonteCarloHypervolume
+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 compare, TournamentSelection
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.dominator import Dominator
+from pymoo.util.function_loader import load_function
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.util.normalization import normalize
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Environmental Survival - Remove the solution with the least HV contribution
+# ---------------------------------------------------------------------------------------------------------
+
+
+class LeastHypervolumeContributionSurvival(Survival):
+
+    def __init__(self, eps=10.0) -> None:
+        super().__init__(filter_infeasible=True)
+        self.eps = eps
+
+    def _do(self, problem, pop, *args, n_survive=None, ideal=None, nadir=None, **kwargs):
+
+        # get the objective space values and objects
+        F = pop.get("F").astype(float, copy=False)
+
+        # if the boundary points are not provided -> estimate them from pop
+        if ideal is None:
+            ideal = F.min(axis=0)
+        if nadir is None:
+            nadir = F.max(axis=0)
+
+        # the number of objectives
+        _, n_obj = F.shape
+
+        # the final indices of surviving individuals
+        survivors = []
+
+        # do the non-dominated sorting until splitting front
+        fronts = NonDominatedSorting().do(F, n_stop_if_ranked=n_survive)
+
+        for k, front in enumerate(fronts):
+
+            # get the actual front as individuals
+            front = pop[front]
+            front.set("rank", k)
+
+            if len(survivors) + len(front) > n_survive:
+
+                # normalize all the function values for the front
+                F = front.get("F")
+                F = normalize(F, ideal, nadir)
+
+                # define the reference point and shift it a bit - F is already normalized!
+                ref_point = np.full(problem.n_obj, 1.0 + self.eps)
+
+                _, n_obj = F.shape
+
+                # choose the suitable hypervolume method
+                clazz = ExactHypervolume
+                if n_obj == 2:
+                    clazz = ExactHypervolume2D
+                elif n_obj > 3:
+                    clazz = ApproximateMonteCarloHypervolume
+
+                # finally do the computation
+                hv = clazz(ref_point).add(F)
+
+                # current front sorted by crowding distance if splitting
+                while len(survivors) + len(front) > n_survive:
+                    k = hv.hvc.argmin()
+                    hv.delete(k)
+                    front = np.delete(front, k)
+
+            # extend the survivors by all or selected individuals
+            survivors.extend(front)
+
+        return Population.create(*survivors)
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Binary Tournament
+# ---------------------------------------------------------------------------------------------------------
+
+
+def cv_and_dom_tournament(pop, P, *args, **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:
+
+            # if one dominates another choose the nds one
+            rel = Dominator.get_relation(a_f, b_f)
+            if rel == 1:
+                S[i] = a
+            elif rel == -1:
+                S[i] = b
+
+            # if rank or domination relation didn't make a decision compare by crowding
+            if np.isnan(S[i]):
+                S[i] = np.random.choice([a, b])
+
+    return S[:, None].astype(int, copy=False)
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Algorithm
+# ---------------------------------------------------------------------------------------------------------
+
+class SMSEMOA(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 selection=TournamentSelection(func_comp=cv_and_dom_tournament),
+                 crossover=SBX(),
+                 mutation=PM(),
+                 survival=LeastHypervolumeContributionSurvival(),
+                 eliminate_duplicates=True,
+                 n_offsprings=None,
+                 normalize=True,
+                 output=MultiObjectiveOutput(),
+                 **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,
+                         output=output,
+                         advance_after_initial_infill=True,
+                         **kwargs)
+
+        self.normalize = normalize
+
+    def _advance(self, infills=None, **kwargs):
+
+        ideal, nadir = None, None
+
+        # estimate ideal and nadir from the current population (more robust then from doing it from merged)
+        if self.normalize:
+            F = self.pop.get("F")
+            ideal, nadir = F.min(axis=0), F.max(axis=0) + 1e-32
+
+        # merge the offsprings with the current population
+        if infills is not None:
+            pop = Population.merge(self.pop, infills)
+        else:
+            pop = self.pop
+
+
+        self.pop = self.survival.do(self.problem, pop, n_survive=self.pop_size, algorithm=self,
+                                    ideal=ideal, nadir=nadir, **kwargs)
+
+
+parse_doc_string(SMSEMOA.__init__)