pymoo 0.6.1.5.dev0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pymoo/indicators/rmetric.py

@@ -0,0 +1,203 @@
+import numpy as np
+from scipy.spatial.distance import cdist
+
+from pymoo.core.indicator import Indicator
+from pymoo.indicators.hv import Hypervolume
+from pymoo.indicators.igd import IGD
+
+
+class RMetric(Indicator):
+
+    def __init__(self, problem, ref_points, w=None, delta=0.2, pf=None):
+        """
+
+        Parameters
+        ----------
+        
+        problem : class
+            problem instance
+            
+        ref_points : numpy.array
+            list of reference points
+
+        w : numpy.array
+            weights for each objective
+
+        delta : float
+            The delta value representing the region of interest
+
+        """
+
+        Indicator.__init__(self)
+        self.ref_points = ref_points
+        self.problem = problem
+        w_ = np.ones(self.ref_points.shape[1]) if not w else w
+        self.w_points = self.ref_points + 2 * w_
+        self.delta = delta
+
+        self.pf = pf
+        self.F = None
+        self.others = None
+
+    def _filter(self):
+
+        def check_dominance(a, b, n_obj):
+            flag1 = False
+            flag2 = False
+            for i in range(n_obj):
+                if a[i] < b[i]:
+                    flag1 = True
+                else:
+                    if a[i] > b[i]:
+                        flag2 = True
+            if flag1 and not flag2:
+                return 1
+            elif not flag1 and flag2:
+                return -1
+            else:
+                return 0
+
+        num_objs = np.size(self.F, axis=1)
+        index_array = np.zeros(np.size(self.F, axis=0))
+
+        # filter out all solutions that are dominated by solutions found by other algorithms
+        if self.others is not None:
+            for i in range(np.size(self.F, 0)):
+                for j in range(np.size(self.others, 0)):
+                    flag = check_dominance(self.F[i, :], self.others[j, :], num_objs)
+                    if flag == -1:
+                        index_array[i] = 1
+                        break
+
+        final_index = np.logical_not(index_array)
+        filtered_pop = self.F[final_index, :]
+
+        return filtered_pop
+
+    def _preprocess(self, data, ref_point, w_point):
+
+        datasize = np.size(data, 0)
+
+        # Identify representative point
+        ref_matrix = np.tile(ref_point, (datasize, 1))
+        w_matrix = np.tile(w_point, (datasize, 1))
+        # ratio of distance to the ref point over the distance between the w_point and the ref_point
+        diff_matrix = (data - ref_matrix) / (w_matrix - ref_matrix)
+        agg_value = np.amax(diff_matrix, axis=1)
+        idx = np.argmin(agg_value)
+        zp = [data[idx, :]]
+
+        return zp,
+
+    def _translate(self, zp, trimmed_data, ref_point, w_point):
+        # Solution translation - Matlab reproduction
+        # find k
+        temp = ((zp[0] - ref_point) / (w_point - ref_point))
+        kIdx = np.argmax(temp)
+
+        # find zl
+        temp = (zp[0][kIdx] - ref_point[kIdx]) / (w_point[kIdx] - ref_point[kIdx])
+        zl = ref_point + temp * (w_point - ref_point)
+
+        temp = zl - zp
+        shift_direction = np.tile(temp, (trimmed_data.shape[0], 1))
+        # new_size = self.curr_pop.shape[0]
+        return trimmed_data + shift_direction
+
+    def _trim(self, pop, centeroid, range=0.2):
+        popsize, objDim = pop.shape
+        diff_matrix = pop - np.tile(centeroid, (popsize, 1))[0]
+        flags = np.sum(abs(diff_matrix) < range / 2, axis=1)
+        filtered_matrix = pop[np.where(flags == objDim)]
+        return filtered_matrix
+
+    def _trim_fast(self, pop, centeroid, range=0.2):
+        centeroid_matrix = cdist(pop, centeroid, metric='euclidean')
+        filtered_matrix = pop[np.where(centeroid_matrix < range / 2), :][0]
+        return filtered_matrix
+
+    def do(self, F, others=None, calc_hv=True):
+        """
+
+        This method calculates the R-IGD and R-HV based off of the values provided.
+        
+        
+        Parameters
+        ----------
+
+        F : numpy.ndarray
+            The objective space values
+
+        others : numpy.ndarray
+            Results from other algorithms which should be used for filtering nds solutions
+
+        calc_hv : bool
+            Whether the hv is calculate - (None if more than 3 dimensions)
+
+
+        Returns
+        -------
+        rigd : float
+            R-IGD
+
+        rhv : float
+            R-HV if calc_hv is true and less or equal to 3 dimensions
+
+        """
+        self.F, self.others = F, others
+
+        translated = []
+        final_PF = []
+
+        # 1. Prescreen Procedure - NDS Filtering
+        pop = self._filter()
+
+        pf = self.pf
+        if pf is None:
+            pf = self.problem.pareto_front()
+
+        if pf is None:
+            raise Exception("Please provide the Pareto front to calculate the R-Metric!")
+
+        labels = np.argmin(cdist(pop, self.ref_points), axis=1)
+
+        for i in range(len(self.ref_points)):
+            cluster = pop[np.where(labels == i)]
+            if len(cluster) != 0:
+                # 2. Representative Point Identification
+                zp = self._preprocess(cluster, self.ref_points[i], w_point=self.w_points[i])[0]
+                # 3. Filtering Procedure - Filter points
+                trimmed_data = self._trim(cluster, zp, range=self.delta)
+                # 4. Solution Translation
+                pop_t = self._translate(zp, trimmed_data, self.ref_points[i], w_point=self.w_points[i])
+                translated.extend(pop_t)
+
+            # 5. R-Metric Computation
+            target = self._preprocess(data=pf, ref_point=self.ref_points[i], w_point=self.w_points[i])
+            PF = self._trim(pf, target)
+            final_PF.extend(PF)
+
+        translated = np.array(translated)
+        final_PF = np.array(final_PF)
+
+        rigd, rhv = None, None
+
+        if len(translated) > 0:
+
+            # IGD Computation
+            rigd = IGD(final_PF).do(translated)
+
+            nadir_point = np.amax(self.w_points, axis=0)
+            front = translated
+            dim = self.ref_points[0].shape[0]
+            if calc_hv:
+                if dim <= 3:
+                    try:
+                        rhv = Hypervolume(ref_point=nadir_point).do(front)
+                    except:
+                        pass
+
+        if calc_hv:
+            return rigd, rhv
+        else:
+            return rigd

pymoo/indicators/spacing.py

@@ -0,0 +1,52 @@
+import numpy as np
+from pymoo.core.indicator import Indicator
+from pymoo.indicators.distance_indicator import at_least_2d_array, derive_ideal_and_nadir_from_pf
+from scipy.spatial.distance import pdist, squareform
+
+
+class SpacingIndicator(Indicator):
+    
+    def __init__(self,
+                 pf=None,
+                 zero_to_one=False,
+                 ideal=None,
+                 nadir=None):
+        """Spacing indicator
+        
+        The smaller the value this indicator assumes, the most uniform is the distribution of elements on the pareto front.
+
+        Parameters
+        ----------
+        pf : 2d array, optional
+            Pareto front, by default None
+        zero_to_one : bool, optional
+            Whether or not the objective values should be normalized in calculations, by default False
+        ideal : 1d array, optional
+            Ideal point, by default None
+        nadir : 1d array, optional
+            Nadir point, by default None
+        """
+        
+        # the pareto front if necessary to calculate the indicator
+        pf = at_least_2d_array(pf, extend_as="row")
+        ideal, nadir = derive_ideal_and_nadir_from_pf(pf, ideal=ideal, nadir=nadir)
+        
+        super().__init__(pf=pf,
+                         zero_to_one=zero_to_one,
+                         ideal=ideal,
+                         nadir=nadir)
+    
+    def _do(self, F, *args, **kwargs):
+        
+        # Get F dimensions
+        n_points, n_obj = F.shape
+        
+        # knn
+        D = squareform(pdist(F, metric="cityblock"))
+        d = np.partition(D, 1, axis=1)[:, 1]
+        dm = np.mean(d)
+        
+        # Get spacing
+        S = np.sqrt(np.sum(np.square(d - dm)) / n_points)
+        
+        return S

pymoo/mcdm/compromise_programming.py

@@ -0,0 +1,19 @@
+from pymoo.core.decision_making import DecisionMaking
+from pymoo.util.normalization import normalize
+
+
+class CompromiseProgramming(DecisionMaking):
+
+    def __init__(self, metric="euclidean", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.metric = metric
+
+    def _do(self, F, **kwargs):
+
+        F, _, ideal_point, nadir_point = normalize(F,
+                                                   xl=self.ideal_point,
+                                                   xu=self.nadir_point,
+                                                   estimate_bounds_if_none=True,
+                                                   return_bounds=True)
+
+        return None

pymoo/mcdm/high_tradeoff.py

@@ -0,0 +1,40 @@
+import warnings
+
+import numpy as np
+
+from pymoo.core.decision_making import DecisionMaking, find_outliers_upper_tail, NeighborFinder
+
+
+class HighTradeoffPoints(DecisionMaking):
+
+    def __init__(self, epsilon=0.125, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.epsilon = epsilon
+
+    def _do(self, F, **kwargs):
+        n, m = F.shape
+
+        neighbors_finder = NeighborFinder(F, epsilon=0.125, n_min_neigbors="auto", consider_2d=False)
+
+        mu = np.full(n, - np.inf)
+
+        # for each solution in the set calculate the least amount of improvement per unit deterioration
+        for i in range(n):
+
+            # for each neighbour in a specific radius of that solution
+            neighbors = neighbors_finder.find(i)
+
+            # calculate the trade-off to all neighbours
+            diff = F[neighbors] - F[i]
+
+            # calculate sacrifice and gain
+            sacrifice = np.maximum(0, diff).sum(axis=1)
+            gain = np.maximum(0, -diff).sum(axis=1)
+
+            warnings.filterwarnings('ignore')
+            tradeoff = sacrifice / gain
+
+            # otherwise find the one with the smalled one
+            mu[i] = np.nanmin(tradeoff)
+
+        return find_outliers_upper_tail(mu)

pymoo/mcdm/pseudo_weights.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+from pymoo.core.decision_making import DecisionMaking
+
+
+class PseudoWeights(DecisionMaking):
+
+    def __init__(self, weights, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.weights = weights
+
+    def _do(self, F, return_pseudo_weights=False, **kwargs):
+        ideal, nadir = self.ideal, self.nadir
+
+        if ideal is None:
+            ideal = F.min(axis=0)
+        if nadir is None:
+            nadir = F.max(axis=0)
+
+        # normalized distance to the worst solution
+        pseudo_weights = ((nadir - F) / (nadir - ideal))
+
+        # normalize weights to sum up to one
+        pseudo_weights = pseudo_weights / np.sum(pseudo_weights, axis=1)[:, None]
+
+        # search for the closest individual having this pseudo weights
+        I = np.argmin(np.sum(np.abs(pseudo_weights - self.weights), axis=1))
+
+        if return_pseudo_weights:
+            return I, pseudo_weights
+        else:
+            return I

pymoo/operators/control.py

@@ -0,0 +1,187 @@
+import math
+from abc import abstractmethod
+
+import numpy as np
+
+from pymoo.core.duplicate import NoDuplicateElimination
+from pymoo.core.individual import Individual
+from pymoo.core.infill import InfillCriterion
+from pymoo.core.mixed import MixedVariableMating
+from pymoo.core.parameters import get_params, flatten
+from pymoo.core.problem import Problem
+from pymoo.core.variable import Choice, Real, Integer, Binary
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.crossover.ux import UX
+from pymoo.operators.mutation.bitflip import BFM
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.mutation.rm import ChoiceRandomMutation
+from pymoo.operators.repair.rounding import RoundingRepair
+from pymoo.operators.selection.tournament import TournamentSelection, compare
+
+
+class ParameterControl:
+
+    def __init__(self, obj) -> None:
+        super().__init__()
+
+        self.data = None
+
+        params = flatten({"ParameterControl": get_params(obj)})
+        self.params = params
+
+        # print("PARAMETER CONTROL:", list(self.params))
+
+    def do(self, N, set_to_params=True):
+        vals = self._do(N)
+        if set_to_params:
+            if vals is not None:
+                for k, v in vals.items():
+                    self.params[k].set(v)
+        return vals
+
+    @abstractmethod
+    def _do(self, N):
+        pass
+
+    def tell(self, **kwargs):
+        self.data = dict(kwargs)
+
+    def advance(self, infills=None):
+        for k, v in self.params.items():
+            assert len(v.get()) == len(
+                infills), "Make sure that the infills and parameters asked for have the same size."
+            infills.set(k, v.get())
+
+
+class NoParameterControl(ParameterControl):
+
+    def __init__(self, _) -> None:
+        super().__init__(None)
+
+    def _do(self, N):
+        return {}
+
+
+class RandomParameterControl(ParameterControl):
+
+    def _do(self, N):
+        return {key: value.sample(N) for key, value in self.params.items()}
+
+
+class EvolutionaryParameterControl(ParameterControl):
+
+    def __init__(self, obj) -> None:
+        super().__init__(obj)
+        self.eps = 0.05
+
+    def _do(self, N):
+        params = self.params
+        pop = self.data.get("pop")
+
+        # make sure that for each parameter a value exists - if not simply set it randomly
+        for name, param in params.items():
+            is_none = np.where(pop.get(name) == None)[0]
+            if len(is_none) > 0:
+                pop[is_none].set(name, param.sample(len(is_none)))
+
+        selection = AgeBasedTournamentSelection()
+
+        crossover = {
+            Binary: UX(),
+            Real: SBX(),
+            Integer: SBX(vtype=float, repair=RoundingRepair()),
+            Choice: UX(),
+        }
+
+        mutation = {
+            Binary: BFM(),
+            Real: PM(),
+            Integer: PM(vtype=float, repair=RoundingRepair()),
+            Choice: ChoiceRandomMutation(),
+        }
+
+        mating = MixedVariableMating(
+            crossover=crossover,
+            mutation=mutation,
+            eliminate_duplicates=NoDuplicateElimination()
+        )
+
+        problem = Problem(vars=params)
+
+        parents = selection(problem, pop, N, n_parents=2)
+        parents = [[Individual(X={key: parent.get(key) for key in params}) for parent in mating] for mating in parents]
+
+        off = mating(problem, parents, N, parents=True)
+
+        Xp = off.get("X")
+        ret = {param: np.array([Xp[i][param] for i in range(len(Xp))]) for param in params}
+
+        return ret
+
+
+class AgeBasedTournamentSelection(TournamentSelection):
+
+    def __init__(self, pressure=2):
+        super().__init__(age_binary_tournament, pressure)
+
+
+def age_binary_tournament(pop, P, **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_gen, b_gen = pop[a].get("n_gen"), pop[b].get("n_gen")
+        S[i] = compare(a, a_gen, b, b_gen, method='larger_is_better', return_random_if_equal=True)
+
+    return S[:, None].astype(int, copy=False)
+
+
+class ParameterControlMating(InfillCriterion):
+
+    def __init__(self,
+                 selection,
+                 crossover,
+                 mutation,
+                 control=NoParameterControl,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.selection = selection
+        self.crossover = crossover
+        self.mutation = mutation
+        self.control = control(self)
+
+    def _do(self, problem, pop, n_offsprings, parents=None, **kwargs):
+
+        # how many parents need to be select for the mating - depending on number of offsprings remaining
+        n_matings = math.ceil(n_offsprings / self.crossover.n_offsprings)
+
+        # do the parameter control for the mating
+        control = self.control
+        control.tell(pop=pop)
+        control.do(n_matings)
+
+        # if the parents for the mating are not provided directly - usually selection will be used
+        if parents is None:
+
+            # select the parents for the mating - just an index array
+            parents = self.selection.do(problem, pop, n_matings, n_parents=self.crossover.n_parents, **kwargs)
+
+        # do the crossover using the parents index and the population - additional data provided if necessary
+        off = self.crossover(problem, parents, **kwargs)
+
+        # now we have to consider during parameter control that a crossover can produce multiple offsprings
+        for name, param in control.params.items():
+            param.set(np.repeat(param.get(), self.crossover.n_offsprings))
+
+        # do the mutation on the offsprings created through crossover
+        off = self.mutation(problem, off, **kwargs)
+
+        # finally attach the parameters back to the offsprings
+        control.advance(off)
+
+        return off

pymoo/operators/crossover/binx.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.variable import Real, get
+from pymoo.util.misc import row_at_least_once_true
+
+
+def mut_binomial(n, m, prob, at_least_once=True):
+    prob = np.ones(n) * prob
+    M = np.random.random((n, m)) < prob[:, None]
+
+    if at_least_once:
+        M = row_at_least_once_true(M)
+
+    return M
+
+
+class BinomialCrossover(Crossover):
+
+    def __init__(self, bias=0.5, n_offsprings=2, **kwargs):
+        super().__init__(2, n_offsprings, **kwargs)
+        self.bias = Real(bias, bounds=(0.1, 0.9), strict=(0.0, 1.0))
+
+    def _do(self, problem, X, **kwargs):
+        _, n_matings, n_var = X.shape
+
+        bias = get(self.bias, size=n_matings)
+        M = mut_binomial(n_matings, n_var, bias, at_least_once=True)
+
+        if self.n_offsprings == 1:
+            Xp = X[0].copy()
+            Xp[~M] = X[1][~M]
+            Xp = Xp[None, ...]
+        elif self.n_offsprings == 2:
+            Xp = np.copy(X)
+            Xp[0][~M] = X[1][~M]
+            Xp[1][~M] = X[0][~M]
+        else:
+            raise Exception
+
+        return Xp
+
+
+class BX(BinomialCrossover):
+    pass