pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/functions/standard/stochastic_ranking.py

@@ -0,0 +1,42 @@
+"""
+Standard Python implementation of stochastic ranking.
+"""
+
+import numpy as np
+from pymoo.util import default_random_state
+
+
+def swap(M, a, b):
+    """Swap two elements in array M."""
+    M[a], M[b] = M[b], M[a]
+
+
+@default_random_state
+def stochastic_ranking(f, phi, pr, I=None, random_state=None):
+    """Stochastic ranking algorithm."""
+    _lambda = len(f)
+
+    if I is None:
+        I = np.arange(_lambda)
+
+    for i in range(_lambda):
+
+        at_least_one_swap = False
+
+        for j in range(_lambda - 1):
+
+            u = random_state.random()
+
+            if u < pr or (phi[I[j]] == 0 and phi[I[j + 1]] == 0):
+                if f[I[j]] > f[I[j + 1]]:
+                    swap(I, j, j + 1)
+                    at_least_one_swap = True
+            else:
+                if phi[I[j]] > phi[I[j + 1]]:
+                    swap(I, j, j + 1)
+                    at_least_one_swap = True
+
+        if not at_least_one_swap:
+            break
+
+    return I

pymoo/gradient/__init__.py

@@ -0,0 +1,24 @@
+import sys
+
+
+BACKENDS = {
+    "numpy": "numpy",
+    "autograd": "autograd.numpy", 
+    "jax": "jax.numpy"
+}
+
+# Current active backend
+active_backend = "numpy"
+
+def activate(name):
+    global active_backend
+    if name not in BACKENDS:
+        raise ValueError(f"Unknown backend: {name}. Choose from: {list(BACKENDS.keys())}")
+    active_backend = name
+    # No need to delete module - LazyBackend handles dynamic switching
+
+
+def deactivate():
+    activate("numpy")
+
+

pymoo/gradient/automatic.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem, ElementwiseEvaluationFunction
+from pymoo.gradient import activate, deactivate
+
+
+class ElementwiseEvaluationFunctionWithGradient(ElementwiseEvaluationFunction):
+
+    def __init__(self, problem, backend='autograd', args=(), kwargs={}):
+        super().__init__(problem, args, kwargs)
+        self.backend = backend
+
+    def __call__(self, x):
+        f = super().__call__
+
+        activate(self.backend)
+        if self.backend == "jax":
+            from pymoo.gradient.grad_jax import jax_elementwise_value_and_grad
+            out, grad = jax_elementwise_value_and_grad(f, x)
+        elif self.backend == "autograd":
+            from pymoo.gradient.grad_autograd import autograd_elementwise_value_and_grad
+            out, grad = autograd_elementwise_value_and_grad(f, x)
+        else:
+            raise Exception("Unknown backend %s" % self.backend)
+        deactivate()
+
+        for k, v in grad.items():
+            out["d" + k] = np.array(v)
+
+        return out
+
+
+class ElementwiseAutomaticDifferentiation(Meta, Problem):
+
+    def __init__(self, problem, backend='autograd', copy=True):
+        if not problem.elementwise:
+            raise Exception("Elementwise automatic differentiation can only be applied to elementwise problems.")
+
+        super().__init__(problem, copy)
+        self.backend = backend
+
+        # Set the elementwise_func to the class itself - it will handle the signature
+        self.elementwise_func = self._create_elementwise_func
+
+    def _create_elementwise_func(self, problem, args, kwargs):
+        """Create an elementwise function that matches the expected signature"""
+        return ElementwiseEvaluationFunctionWithGradient(self.__object__, self.backend, args, kwargs)
+
+
+class AutomaticDifferentiation(Meta, Problem):
+
+    def __init__(self, object, backend='autograd', **kwargs):
+        super().__init__(object, **kwargs)
+        self.backend = backend
+
+    def do(self, x, return_values_of, *args, **kwargs):
+
+        vals_not_grad = [v for v in return_values_of if not v.startswith("d")]
+
+        class F:
+
+            def __init__(self, object):
+                self.__object__ = object
+
+            def __call__(self, xp):
+                return self.__object__.do(xp, vals_not_grad, *args, **kwargs)
+
+        f = F(self.__object__)
+
+        activate(self.backend)
+        if self.backend == "jax":
+            from pymoo.gradient.grad_jax import jax_vectorized_value_and_grad
+            out, grad = jax_vectorized_value_and_grad(f, x)
+        elif self.backend == "autograd":
+            from pymoo.gradient.grad_autograd import autograd_vectorized_value_and_grad
+            out, grad = autograd_vectorized_value_and_grad(f, x)
+        else:
+            raise Exception("Unknown backend %s" % self.backend)
+        deactivate()
+
+        for k, v in grad.items():
+            out["d" + k] = v
+
+        return out

pymoo/gradient/grad_autograd.py

@@ -0,0 +1,105 @@
+import warnings
+import numpy as np
+
+try:
+    import autograd.numpy as anp
+    from autograd.core import VJPNode, backward_pass
+    from autograd.tracer import new_box, isbox
+except:
+    print("autograd only supports numpy < 2.0.0 versions.")
+
+
+def value_and_grad(*args, **kwargs):
+    from autograd import value_and_grad as vag
+    return vag(*args, **kwargs)
+
+
+def log(*args, **kwargs):
+    return anp.log(*args, **kwargs)
+
+
+def sqrt(*args, **kwargs):
+    return anp.sqrt(*args, **kwargs)
+
+
+def row_stack(*args, **kwargs):
+    return anp.row_stack(*args, **kwargs)
+
+
+def triu_indices(*args, **kwargs):
+    return anp.triu_indices(*args, **kwargs)
+
+
+def run_and_trace(f, x):
+    start_node = VJPNode.new_root()
+
+    start_box = new_box(x, 0, start_node)
+    out = f(start_box)
+
+    return out, start_box
+
+
+def autograd_elementwise_value_and_grad(f, x):
+    out, pullback = run_and_trace(f, x)
+
+    jac = dict()
+    for name in out:
+        val = out[name]
+
+        if val is not None:
+
+            if len(val.shape) == 0:
+                val = anp.array([val])
+
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+
+                # the backward pass is done for each objective function once
+                grad = []
+                for j in range(len(val)):
+                    b = np.zeros(val.shape)
+                    b[j] = 1
+
+                    n = new_box(b, 0, VJPNode.new_root())
+                    _grad = backward_pass(n, val._node)
+                    grad.append(_grad)
+
+                out[name] = np.array(val._value)
+                jac[name] = anp.stack(grad, axis=0)._value
+
+    return out, jac
+
+
+def autograd_vectorized_value_and_grad(f, x):
+    end, start = run_and_trace(f, x)
+
+    out, jac = dict(), dict()
+
+    end = {k: v for k, v in end.items() if v is not None}
+
+    for name, val in end.items():
+
+        v = val
+        if hasattr(v, "_value"):
+            v = np.array(v._value)
+        out[name] = v
+
+        # if the end_box is not a box - autograd can not track back
+        if not isbox(val):
+            n, m = val.shape
+            jac[name] = np.zeros((n, m, x.shape[1]))
+
+        else:
+
+            # the backward pass is done for each objective function once
+            grad = []
+            for j in range(val.shape[1]):
+                b = anp.zeros(val.shape)
+                b[:, j] = 1
+                n = new_box(b, 0, VJPNode.new_root())
+                _grad = backward_pass(n, val._node)
+                grad.append(_grad)
+
+            jac[name] = anp.stack(grad, axis=1)._value
+
+    return out, jac

pymoo/gradient/grad_complex.py

@@ -0,0 +1,35 @@
+import numpy as np
+
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem
+
+
+def calc_complex_gradient(problem, return_values_of, x, eps, *args, **kwargs):
+    xp = x + np.eye(len(x)) * complex(0, eps)
+    out = problem.do(xp, return_values_of, *args, **kwargs)
+
+    grad = {}
+    for name, value in out.items():
+        grad[name] = np.imag(value / eps).T
+
+    return grad
+
+
+class ComplexNumberGradient(Meta, Problem):
+
+    def __init__(self, problem, eps=1e-8, **kwargs):
+        super().__init__(problem, **kwargs)
+        self.eps = eps
+
+    def do(self, X, return_values_of, *args, **kwargs):
+        out = self.__object__.do(X, return_values_of, *args, **kwargs)
+
+        vals_not_grad = [v for v in return_values_of if not v.startswith("d")]
+
+        for i, x in enumerate(X):
+            grad = calc_complex_gradient(self.__object__, vals_not_grad, x, self.eps, *args, **kwargs)
+
+            for name, value in grad.items():
+                out['d' + name][i] = value
+
+        return out

pymoo/gradient/grad_jax.py

@@ -0,0 +1,51 @@
+from functools import partial
+
+import jax
+jax.config.update("jax_enable_x64", True)
+from jax import vjp
+from jax import vmap
+from jax._src.api import _jacrev_unravel, _std_basis
+from jax.tree_util import (tree_map)
+
+
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+
+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/numpy.py

@@ -0,0 +1,22 @@
+"""
+Numpy gradient toolbox - acts as a fallback when no automatic differentiation library is used.
+This module provides the same interface as autograd/jax but raises appropriate errors.
+"""
+import numpy as np
+
+def value_and_grad(*args, **kwargs):
+    raise NotImplementedError("Numpy gradient toolbox does not support automatic differentiation. "
+                              "Please use pymoo.gradient.activate('autograd.numpy') or "
+                              "pymoo.gradient.activate('jax.numpy') for automatic differentiation.")
+
+def log(*args, **kwargs):
+    return np.log(*args, **kwargs)
+
+def sqrt(*args, **kwargs):
+    return np.sqrt(*args, **kwargs)
+
+def row_stack(*args, **kwargs):
+    return np.vstack(*args, **kwargs)
+
+def triu_indices(*args, **kwargs):
+    return np.triu_indices(*args, **kwargs)

pymoo/gradient/toolbox/__init__.py

@@ -0,0 +1,19 @@
+import sys
+import importlib
+
+class LazyBackend:
+    """Lazy backend that always uses the current active backend"""
+    
+    def __getattr__(self, name):
+        from pymoo.gradient import active_backend, BACKENDS
+        backend_module = importlib.import_module(BACKENDS[active_backend])
+        return getattr(backend_module, name)
+    
+    def __dir__(self):
+        """Support for tab completion and introspection"""
+        from pymoo.gradient import active_backend, BACKENDS
+        backend_module = importlib.import_module(BACKENDS[active_backend])
+        return dir(backend_module)
+
+# Replace this module with the lazy backend
+sys.modules[__name__] = LazyBackend()

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,59 @@
+import numpy as np
+
+from pymoo.core.indicator import Indicator
+from pymoo.functions import FunctionLoader, load_function
+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 moocore 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 (deprecated)
+        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):
+        # calculate the hypervolume using moocore
+        val = _hypervolume(F, ref = self.ref_point)
+        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/approximate.py

@@ -0,0 +1,105 @@
+import numpy as np
+
+from pymoo.indicators.hv.exact import DynamicHypervolume
+from pymoo.util import default_random_state
+
+
+# from moocore import hv_approx, hv_contributions
+
+
+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 ApproximateHypervolume(DynamicHypervolume):
+
+    @default_random_state(seed=1)
+    def __init__(self, ref_point, n_samples=10000, n_exclusive=1, random_state=None, **kwargs) -> None:
+        self.n_samples = n_samples
+        self.n_exclusive = n_exclusive
+
+        self.V = None
+        self.dom = None
+
+        self.random_state = random_state
+
+        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 = self.random_state.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
+
+        # MOOCORE VERSION (commented out for comparison)
+        # if len(F) == 0:
+        #     return 0.0, np.zeros(0)
+        # 
+        # # Use moocore for approximate hypervolume calculation
+        # hv = hv_approx(F, ref=ref_point, nsamples=self.n_samples, seed=self.random_state.randint(0, 2**32-1))
+        # 
+        # # Use moocore for exact hypervolume contributions (no approximate version available)
+        # hvc = hv_contributions(F, ref=ref_point)
+        # 
+        # 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)
+
+        # MOOCORE VERSION (commented out for comparison)
+        # # Handle empty array case
+        # if len(self.F) == 0:
+        #     self.hv = 0.0
+        #     self.hvc = np.zeros(0)
+        # else:
+        #     # Use moocore for updated hypervolume and contributions
+        #     self.hv = hv_approx(self.F, ref=self.ref_point, nsamples=self.n_samples, seed=self.random_state.randint(0, 2**32-1))
+        #     self.hvc = hv_contributions(self.F, ref=self.ref_point)
+        # 
+        # return self
+

pymoo/indicators/hv/exact.py

@@ -0,0 +1,68 @@
+import numpy as np
+from moocore import hypervolume as hv
+from moocore import hv_contributions as hvc
+
+
+def hv_exact(ref_point, F):
+    return hv(F, ref=ref_point)
+
+
+def hvc_exact(ref_point, F):
+    return hvc(F, ref=ref_point)
+
+
+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.vstack([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, **kwargs) -> None:
+        super().__init__(ref_point, func_hv=func_hv, func_hvc=func_hvc, **kwargs)