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

pymoo/gradient/grad_jax.py

@@ -0,0 +1,51 @@
+from functools import partial
+
+from jax.config import config
+
+config.update("jax_enable_x64", True)
+
+import pymoo.gradient.toolbox as anp
+import numpy as np
+from jax import vjp
+from jax import vmap
+from jax._src.api import _jacrev_unravel, _std_basis
+from jax.tree_util import (tree_map)
+
+
+def jax_elementwise_value_and_grad(f, x):
+    out, pullback = vjp(f, x)
+    u = _std_basis(out)
+    jac, = vmap(pullback, in_axes=0)(u)
+
+    grad = tree_map(partial(_jacrev_unravel, out), x, jac)
+
+    return out, grad
+
+
+def jax_vectorized_value_and_grad(f, x):
+    out, pullback = vjp(f, x)
+
+    ncols = sum([v.shape[1] for v in out.values()])
+
+    u = dict()
+    cols = dict()
+    cnt = 0
+    for k, v in out.items():
+        if k not in cols:
+            cols[k] = []
+
+        n, m = v.shape
+        a = np.zeros((ncols, n, m))
+        for i in range(m):
+            cols[k].append(cnt)
+            a[cnt, :, i] = 1.0
+            cnt += 1
+
+        u[k] = anp.array(a)
+
+    jac, = vmap(pullback, in_axes=0)(u)
+    jac = np.array(jac)
+
+    grad = {k: np.swapaxes(jac[I], 0, 1) for k, I in cols.items()}
+
+    return out, grad

pymoo/gradient/toolbox/__init__.py

@@ -0,0 +1,6 @@
+import importlib
+import sys
+
+from pymoo.gradient import TOOLBOX
+
+sys.modules[__name__] = importlib.import_module(TOOLBOX)

pymoo/indicators/distance_indicator.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+from pymoo.core.indicator import Indicator
+from pymoo.util.misc import vectorized_cdist, at_least_2d_array
+
+
+def euclidean_distance(a, b, norm=None):
+    return np.sqrt((((a - b) / norm) ** 2).sum(axis=1))
+
+
+def modified_distance(z, a, norm=None):
+    d = a - z
+    d[d < 0] = 0
+    d = d / norm
+    return np.sqrt((d ** 2).sum(axis=1))
+
+
+def derive_ideal_and_nadir_from_pf(pf, ideal=None, nadir=None):
+
+    # try to derive ideal and nadir if not already set and pf provided
+    if pf is not None:
+        if ideal is None:
+            ideal = np.min(pf, axis=0)
+        if nadir is None:
+            nadir = np.max(pf, axis=0)
+
+    return ideal, nadir
+
+
+class DistanceIndicator(Indicator):
+
+    def __init__(self, pf, dist_func, axis, zero_to_one=False, ideal=None, nadir=None, norm_by_dist=False, **kwargs):
+
+        # 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__(zero_to_one=zero_to_one, ideal=ideal, nadir=nadir, **kwargs)
+        self.dist_func = dist_func
+        self.axis = axis
+        self.norm_by_dist = norm_by_dist
+        self.pf = self.normalization.forward(pf)
+
+    def _do(self, F):
+
+        # a factor to normalize the distances by (1.0 disables that by default)
+        norm = 1.0
+
+        # if zero_to_one is disabled this can be used to normalize the distance calculation itself
+        if self.norm_by_dist:
+            assert self.ideal is not None and self.nadir is not None, "If norm_by_dist is enabled ideal and nadir must be set!"
+            norm = self.nadir - self.ideal
+
+        D = vectorized_cdist(self.pf, F, func_dist=self.dist_func, norm=norm)
+        return np.mean(np.min(D, axis=self.axis))

pymoo/indicators/gd.py

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

pymoo/indicators/gd_plus.py

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

pymoo/indicators/hv/__init__.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+from pymoo.core.indicator import Indicator
+from pymoo.indicators.distance_indicator import derive_ideal_and_nadir_from_pf
+from pymoo.util.misc import at_least_2d_array
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.vendor.hv import HyperVolume as _HyperVolume
+
+
+class Hypervolume(Indicator):
+
+    def __init__(self, ref_point=None, pf=None, nds=True, norm_ref_point=True, ideal=None, nadir=None, **kwargs):
+
+        pf = at_least_2d_array(pf, extend_as="row")
+        ideal, nadir = derive_ideal_and_nadir_from_pf(pf, ideal=ideal, nadir=nadir)
+
+        super().__init__(ideal=ideal, nadir=nadir, **kwargs)
+        # self.normalization = ZeroToOneNormalization(ideal, nadir)
+
+        # whether the input should be checked for domination or not
+        self.nds = nds
+
+        # the reference point that shall be used - either derived from pf or provided
+        ref_point = ref_point
+        if ref_point is None:
+            if pf is not None:
+                ref_point = pf.max(axis=0)
+
+        # we also have to normalize the reference point to have the same scales
+        if norm_ref_point:
+            ref_point = self.normalization.forward(ref_point)
+
+        self.ref_point = ref_point
+        assert self.ref_point is not None, "For Hypervolume a reference point needs to be provided!"
+
+    def _do(self, F):
+        if self.nds:
+            non_dom = NonDominatedSorting().do(F, only_non_dominated_front=True)
+            F = np.copy(F[non_dom, :])
+
+        # calculate the hypervolume using a vendor library
+        hv = _HyperVolume(self.ref_point)
+        val = hv.compute(F)
+        return val
+
+
+class HV(Hypervolume):
+    pass
+
+
+def hvc_looped(ref_point, F, func):
+    hv = func(ref_point, F)
+
+    hvc = []
+
+    for k in range(len(F)):
+        v = np.full(len(F), True)
+        v[k] = False
+        _hv = func(ref_point, F[v])
+        hvc.append(hv - _hv)
+
+    hvc = np.array(hvc)
+    return hvc

pymoo/indicators/hv/exact.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+from pymoo.indicators.hv import hvc_looped
+from pymoo.util.function_loader import load_function
+
+
+def hv_exact(ref_point, F):
+    func = load_function("hv")
+    hv = func(ref_point, F)
+    return hv
+
+
+def hvc_exact_loopwise(ref_point, F):
+    return hvc_looped(ref_point, F, hv_exact)
+
+
+class DynamicHypervolume:
+
+    def __init__(self, ref_point, F=None, func_hv=None, func_hvc=None) -> None:
+        super().__init__()
+        self.ref_point = ref_point
+
+        self.func_hv = func_hv
+        self.func_hvc = func_hvc
+
+        self.n_dim = len(ref_point)
+        self.F = np.zeros((0, self.n_dim))
+
+        self.hv = 0.0
+        self.hvc = np.zeros(0)
+
+        if F is not None:
+            self.add(F)
+
+    def add(self, F):
+        assert len(F.shape) == 2, "The points to add must be a two-dimensional array."
+        assert F.shape[1] == self.n_dim, "The dimensions of the ref_point and points to add must be equal"
+        self.F = np.row_stack([self.F, F])
+        self.hv, self.hvc = self.calc()
+        return self
+
+    def delete(self, k):
+        assert k < len(self.F)
+        self.F = np.delete(self.F, k, axis=0)
+        self.hv, self.hvc = self.calc()
+        return self
+
+    def calc(self):
+        return self._calc(self.ref_point, self.F)
+
+        # if len(self.F) == 0:
+        #     return 0.0, np.zeros(0)
+        # else:
+        #     return self._calc(self.ref_point, self.F)
+
+    def _calc(self, ref_point, F):
+        hv = None
+        if self.func_hv is not None:
+            hv = self.func_hv(ref_point, F)
+
+        hvc = None
+        if self.func_hvc is not None:
+            hvc = self.func_hvc(ref_point, F)
+
+        return hv, hvc
+
+
+class ExactHypervolume(DynamicHypervolume):
+
+    def __init__(self, ref_point, func_hv=hv_exact, func_hvc=hvc_exact_loopwise, **kwargs) -> None:
+        super().__init__(ref_point, func_hv=func_hv, func_hvc=func_hvc, **kwargs)

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.row_stack([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.row_stack([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.row_stack([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/hv/monte_carlo.py

@@ -0,0 +1,74 @@
+import numpy as np
+
+from pymoo.indicators.hv.exact import DynamicHypervolume
+
+
+def alpha(N, k):
+    alpha = np.zeros(N+1)
+
+    for i in range(1, N + 1):
+        alpha[i] = np.prod([(k - j) / (N - j) for j in range(1, i)]) / i
+
+    return alpha
+
+
+def hv_monte_carlo(dom, V, n_dom=None):
+    N, n_samples = dom.shape
+    if n_dom is None:
+        n_dom = dom.sum(axis=0)
+
+    a = alpha(N, N)
+    hv = sum([a[n_dom[dom[i]]].sum() for i in range(N)]) / n_samples * V
+    return hv
+
+
+def hvc_monte_carlo(dom, V, n_dom=None, k=1):
+    N, n_samples = dom.shape
+    if n_dom is None:
+        n_dom = dom.sum(axis=0)
+
+    a = alpha(N, k)
+    hvc = np.array([(a[n_dom[dom[i]]].sum() / n_samples * V).sum() for i in range(N)])
+    return hvc
+
+
+class ApproximateMonteCarloHypervolume(DynamicHypervolume):
+
+    def __init__(self, ref_point, n_samples=10000, n_exclusive=1, **kwargs) -> None:
+        self.n_samples = n_samples
+        self.n_exclusive = n_exclusive
+
+        self.V = None
+        self.dom = None
+
+        super().__init__(ref_point, **kwargs)
+
+    def _calc(self, ref_point, F):
+        (N, M) = F.shape
+
+        ideal = F.min(axis=0)
+        V = np.prod(ref_point - ideal)
+
+        S = np.random.uniform(low=ideal, high=ref_point, size=(self.n_samples, M))
+
+        dom = np.array([np.all(F[i] <= S, axis=1) for i in range(N)])
+
+        n_dom = dom.sum(axis=0)
+        hv = hv_monte_carlo(dom, V, n_dom=n_dom)
+        hvc = hvc_monte_carlo(dom, V, n_dom=n_dom, k=self.n_exclusive)
+
+        self.V = V
+        self.dom = dom
+
+        return hv, hvc
+
+    def delete(self, k):
+        self.F = np.delete(self.F, k, axis=0)
+        self.dom = np.delete(self.dom, k, axis=0)
+
+        self.hv -= self.hvc[k]
+
+        V, dom = self.V, self.dom
+        n_dom = dom.sum(axis=0)
+        self.hvc = hvc_monte_carlo(dom, V, n_dom=n_dom, k=self.n_exclusive)
+

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()