pymoo 0.6.1.2__cp312-cp312-macosx_10_9_universal2.whl

pymoo/decomposition/util.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def calc_distance_to_weights(F, weights, utopian_point=None):
+    norm = np.linalg.norm(weights, axis=1)
+
+    if utopian_point is not None:
+        F = F - utopian_point
+
+    d1 = (F * weights).sum(axis=1) / norm
+    d2 = np.linalg.norm(F - (d1[:, None] * weights / norm[:, None]), axis=1)
+
+    return d1, d2

pymoo/decomposition/weighted_sum.py

@@ -0,0 +1,8 @@
+from pymoo.core.decomposition import Decomposition
+import numpy as np
+
+
+class WeightedSum(Decomposition):
+
+    def _do(self, F, weights, **kwargs):
+        return np.sum(F * weights, axis=1)

pymoo/docs.py

@@ -0,0 +1,187 @@
+# -*- encoding: utf-8 -*-
+
+import inspect
+import re
+from pymoo.config import Config
+
+# =========================================================================================================
+# Docstrings Dictionary
+# =========================================================================================================
+
+
+algorithms = {
+    "pop_size": """ int
+                The population sized used by the algorithm.
+    """,
+
+    "n_offsprings": """ int
+                The number of offsprings that should be created in each generation.
+    """,
+
+    "sampling": """
+                :class:`~pymoo.core.sampling.Sampling`, :class:`~pymoo.core.population.Population`, :obj:`numpy.array`
+                    The sampling process defines the initial set of solutions which are the starting point of the
+                    optimization algorithm. Here, you have three different options by passing
+
+                        (i) A :class:`~pymoo.core.sampling.Sampling` implementation which is an implementation of a 
+                        random sampling method. 
+
+                        (ii) A :class:`~pymoo.core.population.Population` object containing the variables to
+                        be evaluated initially OR already evaluated solutions (F needs to be set in this case).
+
+                        (iii) Pass a two dimensional :obj:`numpy.array` with (n_individuals, n_var) which contains the variable 
+                        space values for each individual.        
+                """,
+
+    "selection": """:class:`~pymoo.core.selection.Selection`
+                    This object defines the mating selection to be used. 
+                    In an evolutionary algorithm each generation parents need to be selected to produce new offsprings using 
+                    different recombination and mutation operators. Different strategies for selecting parents are possible e.g. 
+                    selecting them just randomly, only in the neighborhood, using a tournament selection to introduce some selection 
+                    pressure, ... 
+                    """,
+    "crossover": """:class:`~pymoo.core.crossover.Crossover`
+                    The crossover has the purpose of create offsprings during the evolution. After the mating selection
+                    the parents are passed to the crossover operator which will dependent on the implementation create
+                    a different number of offsprings.
+                """,
+
+    "mutation": """:class:`~pymoo.core.mutation.Mutation`
+                    Some genetic algorithms rely only on the mutation operation. However, it has shown that increases
+                    the performance to perform a mutation after creating the offsprings through crossover as well.
+                    Usually the mutation operator needs to be initialized with a probability to be executed. 
+                    Having a high probability of mutation will most of the time increase the diversity in the population.
+                """,
+
+    "survival": """:class:`~pymoo.core.survival.Survival`
+                    The survival selection is the key for many genetic algorithms. It is responsible to define the
+                    goal of convergence by choosing the individual to survive or be truncated each generation.
+                    For single-objective single a selection based on the fitness is used commonly. However, for 
+                    multi-objective single different concepts are introduced.
+                """,
+
+    "ref_points": """:obj:`numpy.array`
+                    Reference Points (or also called Aspiration Points) as a :obj:`numpy.array` where each row 
+                    represents a point and each column a variable (must be equal to the objective dimension of the problem)
+                """,
+
+    "eliminate_duplicates": """bool
+                    The genetic algorithm implementation has a built in feature that eliminates duplicates after merging
+                    the parent and the offspring population. If there are duplicates with respect to the current 
+                    population or in the offsprings itself they are removed and the mating process is repeated to
+                    fill up the offsprings until the desired number of unique offsprings is met.            
+                """,
+
+    "n_offsprings": """int (default: None)
+                    Number of offspring that are created through mating. By default *n_offsprings=None* which
+                    sets the number of offsprings equal to the population size. By setting *n_offsprings=1* a, so called,
+                    steady-state version of an algorithm can be achieved.
+            """,
+
+    "ref_dirs": """:obj:`numpy.array`
+                    The reference direction that should be used during the optimization. Each row represents a reference line
+                    and each column a variable.
+            """
+
+}
+
+visualization = {
+    "figsize": """tuple
+                The figure size. Default (figsize=(8, 6)). For some plots changing the size might have side-effects for position.
+                """,
+
+    "title": """str or tuple
+                The title of the figure. If some additional kwargs should be provided this can be achieved by providing a tuple
+                ("name", {"key" : val}).
+                """,
+
+    "legend": """str
+                Whether a legend should be shown or not.
+                """,
+
+    "tight_layout": """bool
+                        Whether tight layout should be used.
+                    """,
+
+    "bounds": """tuple
+                If plot requires normalization, it might be necessary to supply the boundaries. (Otherwise they might be
+                approximate by the minimum and maximum of the provided data). The boundaries should be provided as a list/tuple or
+                2D numpy array, where the first element represents the minimum, second the second the maximum values.
+                If only an integer or float is supplied, the boundaries apply for each variable.
+            """,
+
+    "reverse": """bool
+                    If plot requires normalization, then the reverse values can be plotted (1 - Input). For some plots
+                    it can be useful to interpret a larger area as better regarding a value. If minimization applies, a smaller
+                    area means better, which can be misleading.
+                """,
+
+    "axis_style": """dict
+                        Most of the plots consists of an axis. The style of the axis, e.g. color, alpha, ..., can be changed to
+                        further modify the plot appealing.
+                    """,
+
+    "cmap": """colormap
+                    For some plots different kind of colors are used. The colormap can be changed to modify the color sequence
+                    for the plots.
+            """,
+
+    "labels": """str or list
+                    The labels to be used for each variable provided in the plot. If a string is used, then they will
+                    be enumerated. Otherwise, a list equal to the number of variables can be provided directly.
+            """,
+
+    "func_number_to_text": """func
+                                A function which defines how numerical values should be represented if present in the plot 
+                                for instance scientific notation, rounding and so on.
+                            """,
+
+}
+
+docs = {**algorithms, **visualization}
+
+
+# =========================================================================================================
+# Util for docstrings
+# =========================================================================================================
+
+def parse_doc_string(source, dest=None, other={}):
+    if not Config.parse_custom_docs:
+        return
+
+    if dest is None:
+        dest = source
+
+    D = {k: v.strip() for k, v in docs.items()}
+    
+    doc = source.__doc__
+    
+
+    lines = inspect.getsource(source)
+    if doc is not None:
+        
+        doc = doc.format(**{**D, **other})
+
+        lines = inspect.getsource(source)
+
+        cnt = 0
+        b = False
+
+        for i, c in enumerate(lines):
+            
+            if b and cnt == 0:
+                break
+            if c == "(":
+                cnt += 1
+                b = True
+            elif c == ")":
+                cnt -= 1
+
+        signature = lines[:i]
+        signature = re.sub(r"[\n\t]*", "", signature)
+        signature = re.sub(r"\s+", " ", signature)
+        signature = re.sub(r"def\s*", "", signature)
+        signature = signature.strip()
+
+        if dest is not None:
+            dest.__doc__ = signature + "\n" + doc

pymoo/experimental/algorithms/gde3.py

@@ -0,0 +1,57 @@
+from pymoo.algorithms.moo.nsga2 import RankAndCrowdingSurvival
+from pymoo.algorithms.soo.nonconvex.de import DE, Variant
+from pymoo.core.population import Population
+
+from pymoo.docs import parse_doc_string
+from pymoo.operators.control import NoParameterControl
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.dominator import get_relation
+from pymoo.termination.default import DefaultMultiObjectiveTermination
+
+
+class GDE3(DE):
+
+    def __init__(self, variant=None, **kwargs):
+
+        if variant is None:
+
+            if "control" not in kwargs:
+                kwargs["control"] = NoParameterControl
+
+            # the setting as proposed in the paper
+            variant = Variant(selection="rand", F=0.1, CR=0.9, **kwargs)
+
+        super().__init__(variant=variant, output=MultiObjectiveOutput(), **kwargs)
+        self.termination = DefaultMultiObjectiveTermination()
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        RankAndCrowdingSurvival().do(self.problem, infills, return_indices=True)
+
+    def _advance(self, infills=None, **kwargs):
+        assert infills is not None, "This algorithms uses the AskAndTell interface thus 'infills' must to be provided."
+        pop = self.pop
+
+        # the pool of solutions considered to survive
+        pool = pop.tolist()
+
+        # now do the replacement of individuals
+        for infill in infills:
+            k = infill.get("index")
+
+            # get the relation between the infill and the solution from the population
+            rel = get_relation(infill, pop[k])
+
+            # if the new solution is not dominated by the individual
+            if rel <= 0:
+                pool.append(infill)
+
+            # if the individual is not dominated by the new solution
+            if rel >= 0:
+                pool.append(pop[k])
+
+        # set the rank and crowding in the current population
+        pool = Population.create(*pool)
+        self.pop = RankAndCrowdingSurvival().do(self.problem, pool, n_survive=self.pop_size)
+
+
+parse_doc_string(GDE3.__init__)

pymoo/gradient/__init__.py

@@ -0,0 +1,21 @@
+import sys
+import importlib
+
+GRADIENT_MODULE = "pymoo.gradient.toolbox"
+
+TOOLBOX = "numpy"
+
+
+def activate(name):
+    global TOOLBOX
+    TOOLBOX = name
+
+    if GRADIENT_MODULE in sys.modules:
+        del sys.modules[GRADIENT_MODULE]
+    importlib.import_module(GRADIENT_MODULE)
+
+
+def deactivate():
+    activate("numpy")
+
+

pymoo/gradient/automatic.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem, ElementwiseEvaluationFunction
+
+
+class ElementwiseEvaluationFunctionWithGradient(ElementwiseEvaluationFunction):
+
+    def __call__(self, x):
+        f = super().__call__
+
+        from pymoo.gradient import TOOLBOX
+
+        if TOOLBOX == "jax.numpy":
+            from pymoo.gradient.grad_jax import jax_elementwise_value_and_grad
+            out, grad = jax_elementwise_value_and_grad(f, x)
+
+        elif TOOLBOX == "autograd.numpy":
+            from pymoo.gradient.grad_autograd import autograd_elementwise_value_and_grad
+            out, grad = autograd_elementwise_value_and_grad(f, x)
+
+        for k, v in grad.items():
+            out["d" + k] = np.array(v)
+
+        return out
+
+
+class ElementwiseAutomaticDifferentiation(Meta, Problem):
+
+    def __init__(self, problem, copy=True):
+        if not problem.elementwise:
+            raise Exception("Elementwise automatic differentiation can only be applied to elementwise problems.")
+
+        super().__init__(problem, copy)
+        self.elementwise_func = ElementwiseEvaluationFunctionWithGradient
+
+
+class AutomaticDifferentiation(Meta, Problem):
+
+    def do(self, x, return_values_of, *args, **kwargs):
+        from pymoo.gradient import TOOLBOX
+
+        vals_not_grad = [v for v in return_values_of if not v.startswith("d")]
+        f = lambda xp: self.__object__.do(xp, vals_not_grad, *args, **kwargs)
+
+        if TOOLBOX == "jax.numpy":
+            from pymoo.gradient.grad_jax import jax_vectorized_value_and_grad
+            out, grad = jax_vectorized_value_and_grad(f, x)
+
+        elif TOOLBOX == "autograd.numpy":
+            from pymoo.gradient.grad_autograd import autograd_vectorized_value_and_grad
+            out, grad = autograd_vectorized_value_and_grad(f, x)
+
+        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 import value_and_grad
+    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):
+    return value_and_grad(*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, object, eps=1e-8, **kwargs):
+        super().__init__(object, **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
+
+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)