pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/indicators/hv/exact_2d.py

@@ -0,0 +1,102 @@
+import numpy as np
+
+from pymoo.indicators.hv.exact import ExactHypervolume
+
+
+def hvc_2d_slow(ref_point, F):
+    n = len(F)
+
+    I = np.lexsort((-F[:, 1], F[:, 0]))
+
+    V = np.vstack([ref_point, F[I], ref_point])
+
+    hvi = np.zeros(n)
+
+    for k in range(1, n + 1):
+        height = V[k - 1, 1] - V[k, 1]
+        width = V[k + 1, 0] - V[k, 0]
+
+        hvi[I[k - 1]] = width * height
+
+    return np.array(hvi)
+
+
+def hvc_2d_fast(ref_point, F_sorted, left=None, right=None):
+    if left is None:
+        left = [F_sorted[0, 0], ref_point[1]]
+
+    if right is None:
+        right = [ref_point[0], F_sorted[-1, 1]]
+
+    V = np.vstack([left, F_sorted, right])
+    height = (V[:-1, 1] - V[1:, 1])[:-1]
+    width = (V[1:, 0] - V[:-1, 0])[1:]
+
+    hvc = height * width
+    return hvc
+
+
+def hv_2d_fast(ref_point, F_sorted):
+    V = np.vstack([ref_point, F_sorted])
+    height = (V[:-1, 1] - V[1:, 1])
+    width = ref_point[0] - V[1:, 0]
+    return (height * width).sum()
+
+
+class ExactHypervolume2D(ExactHypervolume):
+
+    def __init__(self, ref_point, **kwargs) -> None:
+        assert len(ref_point) == 2, "This hypervolume calculation only works in 2 dimensions."
+        super().__init__(ref_point, func_hv=hv_2d_fast, func_hvc=hvc_2d_fast, **kwargs)
+        self.S = None
+        self.I = None
+
+    def _calc(self, ref_point, F):
+        if len(F) == 0:
+            self.I, self.S = [], []
+            return 0.0, np.zeros(0)
+
+        F = np.minimum(self.ref_point, self.F)
+        I = np.lexsort((-F[:, 1], F[:, 0]))
+        S = np.argsort(I)
+
+        hv, hvc = super()._calc(ref_point, F[I])
+        hvc = hvc[S]
+        self.I, self.S = I, S
+
+        return hv, hvc
+
+    # this very efficiently just recomputes hvc of the points necessary
+    # however has not shown to be much faster because of reindexing
+    # def delete(self, k):
+    #     assert k < len(self.F)
+    #
+    #     F, I, S, hv, hvc = self.F, self.I, self.S, self.hv, self.hvc
+    #
+    #     hv -= hvc[k]
+    #
+    #     i = S[k]
+    #
+    #     S = np.delete(S, k, axis=0)
+    #     S[S > i] -= 1
+    #
+    #     I = np.delete(I, i, axis=0)
+    #     I[I > k] -= 1
+    #
+    #     F = np.delete(F, k, axis=0)
+    #     hvc = np.delete(self.hvc, k, axis=0)
+    #
+    #     v = [I[i] if 0 <= i < len(I) else None for i in np.arange(i-2, i+2)]
+    #     left, middle, right = v[0], v[1:-1], v[-1]
+    #
+    #     middle = [e for e in middle if e is not None]
+    #
+    #     if len(middle) > 0:
+    #
+    #         hvc[middle] = hvc_2d_fast(self.ref_point,
+    #                                   F[middle],
+    #                                   left=F[left] if left is not None else None,
+    #                                   right=F[right] if right is not None else None,
+    #                                   )
+    #
+    #     self.F, self.I, self.S, self.hv, self.hvc = F, I, S, hv, hvc

pymoo/indicators/igd.py

@@ -0,0 +1,7 @@
+from pymoo.indicators.distance_indicator import DistanceIndicator, euclidean_distance
+
+
+class IGD(DistanceIndicator):
+
+    def __init__(self, pf, **kwargs):
+        super().__init__(pf, euclidean_distance, 1, **kwargs)

pymoo/indicators/igd_plus.py

@@ -0,0 +1,7 @@
+from pymoo.indicators.distance_indicator import DistanceIndicator, modified_distance
+
+
+class IGDPlus(DistanceIndicator):
+
+    def __init__(self, pf, **kwargs):
+        super().__init__(pf, modified_distance, 1, **kwargs)

pymoo/indicators/kktpm.py

@@ -0,0 +1,151 @@
+import numpy as np
+
+from pymoo.core.individual import calc_cv
+
+
+class KKTPM:
+
+    def calc(self, X, problem, ideal=None, utopian_eps=1e-4, rho=1e-3):
+        """
+
+        Returns the Karush-Kuhn-Tucker Approximate Measure.
+
+        Parameters
+        ----------
+        X : np.array
+
+        problem : pymoo.core.problem
+        ideal : np.array
+            The ideal point if not in the problem defined or intentionally overwritten.
+        utopian_eps : float
+            The epsilon used for decrease the ideal point to get the utopian point.
+        rho : float
+            Since augmented achievement scalarization function is used the F for all other weights
+            - here rho - needs to be defined.
+
+        Returns
+        -------
+
+        """
+
+        # the final result to be returned
+        kktpm = np.full((X.shape[0], 1), np.inf)
+        fval = np.full((X.shape[0], 1), np.inf)
+
+        # set the ideal point for normalization
+        z = ideal
+
+        # if not provided take the one defined in the problem
+        if z is None:
+            z = problem.ideal_point()
+        z -= utopian_eps
+
+        # for convenience get the counts directly
+        n_solutions, n_var, n_obj, n_ieq_constr = X.shape[0], problem.n_var, problem.n_obj, problem.n_ieq_constr
+
+        F, G, dF, dG = problem.evaluate(X, return_values_of=["F", "G", "dF", "dG"])
+        CV = calc_cv(G=G)
+
+        # loop through each solution to be considered
+        for i in range(n_solutions):
+
+            # get the corresponding values for this solution
+            x, f, cv, df = X[i, :], F[i, :], CV[i], dF[i, :].swapaxes(1, 0)
+            if n_ieq_constr > 0:
+                g, dg = G[i, :], dG[i].T
+
+            # if the solution that is provided is infeasible
+            if cv > 0:
+                _kktpm = 1 + cv
+                _fval = None
+
+            else:
+
+                w = np.sqrt(np.sum(np.power(f - z, 2))) / (f - z)
+                a_m = (df * w + (rho * np.sum(df * w, axis=1))[:, None]).T
+
+                A = np.ones((problem.n_obj, problem.n_obj)) + a_m @ a_m.T
+                b = np.ones(problem.n_obj)
+
+                if n_ieq_constr > 0:
+                    # a_j is just the transpose of the differential of constraints
+                    a_j = dg.T
+
+                    # part of the matrix for additional constraints
+                    gsq = np.zeros((n_ieq_constr, n_ieq_constr))
+                    np.fill_diagonal(gsq, g * g)
+
+                    # now add the constraints to the optimization problem
+                    A = np.vstack([np.hstack([A, a_m @ a_j.T]), np.hstack([a_j @ a_m.T, a_j @ a_j.T + gsq])])
+                    b = np.hstack([b, np.zeros(n_ieq_constr)])
+
+                method = "qr"
+                u = solve(A, b, method=method)
+
+                # until all the lagrange multiplier are positive
+                while np.any(u < 0):
+
+                    # go through one by one
+                    for j in range(len(u)):
+
+                        # if a lagrange multiplier is negative - we need to fix it
+                        if u[j] < 0:
+                            # modify the optimization problem
+                            A[j, :], A[:, j], A[j, j] = 0, 0, 1
+                            b[j] = 0
+
+                            # resolve the problem and redefine u. for sure all preview u[j] are positive now
+                            u = solve(A, b, method=method)
+
+                # split up the lagrange multiplier for objective and not
+                u_m, u_j = u[:n_obj], u[n_obj:]
+
+                if n_ieq_constr > 0:
+                    _kktpm = (1 - np.sum(u_m)) ** 2 + np.sum((np.vstack([a_m, a_j]).T @ u) ** 2)
+                    _fval = _kktpm + np.sum((u_j * g.T) ** 2)
+                else:
+                    _kktpm = (1 - np.sum(u_m)) ** 2 + np.sum((a_m.T @ u) ** 2)
+                    _fval = _kktpm
+
+                ujgj = -g @ u_j
+                if np.sum(u_m) + ujgj * (1 + ujgj) > 1:
+                    adjusted_kktpm = - (u_j @ g.T)
+                    projected_kktpm = (_kktpm * g @ g.T - g @ u_j) / (1 + g @ g.T)
+                    _kktpm = (_kktpm + adjusted_kktpm + projected_kktpm) / 3
+
+            # assign to the values to be returned
+            kktpm[i] = _kktpm
+            fval[i] = _fval
+
+        return kktpm[:, 0]
+
+
+def solve(A, b, method="elim"):
+    if method == "elim":
+        return np.linalg.solve(A, b)
+
+    elif method == "qr":
+        Q, R = np.linalg.qr(A)
+        y = np.dot(Q.T, b)
+        return np.linalg.solve(R, y)
+
+    elif method == "svd":
+        U, s, V = np.linalg.svd(A)  # SVD decomposition of A
+        A_inv = np.dot(np.dot(V.T, np.linalg.inv(np.diag(s))), U.T)
+        return A_inv @ b
+
+
+if __name__ == '__main__':
+    from pymoo.problems import get_problem
+    from pymoo.gradient.automatic import AutomaticDifferentiation
+
+    from pymoo.constraints.from_bounds import ConstraintsFromBounds
+    problem = ConstraintsFromBounds(AutomaticDifferentiation(get_problem("zdt2", n_var=30)))
+
+    # X = (0.5 * np.ones(10))[None, :]
+    X = np.array(
+        [0.394876, 0.963263, 0.173956, 0.126330, 0.135079, 0.505662, 0.021525, 0.947970, 0.827115, 0.015019, 0.176196,
+         0.332064, 0.130997, 0.809491, 0.344737, 0.940107, 0.582014, 0.878832, 0.844734, 0.905392, 0.459880, 0.546347,
+         0.798604, 0.285719, 0.490254, 0.599110, 0.015533, 0.593481, 0.433676, 0.807361])
+
+    print(KKTPM().calc(X[None, :], problem))

pymoo/indicators/migd.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+from pymoo.core.callback import Callback
+from pymoo.indicators.igd import IGD
+
+
+class MIGD(Callback):
+
+    def __init__(self, reevaluate=True) -> None:
+        """
+        Mean Inverted Generational Distance (MIGD)
+
+        For dynamic optimization problems the performance metric needs to involve the IGD value over time as the
+        problem is changing. Thus, the performance needs to be evaluated in each iteration for which
+        defining a callback is ideal.
+
+        """
+
+        super().__init__()
+
+        # whether the MIGD should be based on reevaluated solutions
+        self.reevaluate = reevaluate
+
+        # the list where each of the recordings are stored: timesteps and igd
+        self.records = []
+
+    def update(self, algorithm, **kwargs):
+
+        # the problem to be solved
+        problem = algorithm.problem
+        assert problem.n_constr == 0, "The current implementation only works for unconstrained problems!"
+
+        # the current time
+        t = problem.time
+
+        # the current pareto-front of the problem (at the specific time step)
+        pf = problem.pareto_front()
+
+        # the current population of the algorithm
+        pop = algorithm.pop
+
+        # if the callback should reevaluate to match the current time step and avoid deprecated values
+        if self.reevaluate:
+            X = pop.get("X")
+            F = problem.evaluate(X, return_values_of=["F"])
+        else:
+            F = pop.get("F")
+
+        # calculate the current igd values
+        igd = IGD(pf).do(F)
+
+        self.records.append((t, igd))
+
+    def value(self):
+        return np.array([igd for _, igd in self.records]).mean()

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