pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/cython/vendor/hypervolume.h

@@ -0,0 +1,63 @@
+
+
+#ifndef HYPERVOLUME_H
+#define HYPERVOLUME_H
+
+/*!
+ *
+ * \brief Implementation of the Overmars-Yap Algorithm, originally provided by N. Beume.
+ *
+ * Applicable to points of dimension d >= 3. It is assumed that the array of points is sorted
+ * according to the 'last' objective.
+ *
+ * <PRE>
+ * author = {Nicola Beume and G\"unther Rudolph},
+ * title = {Faster {S}-Metric Calculation By Considering Dominated Hypervolume as {Klee}'s Measure Problem},
+ * booktitle = {IASTED International Conference on Computational Intelligence},
+ * publisher = {ACTA Press},
+ * pages = {231-236},
+ * year = {2006},
+ * </PRE>
+ */
+ 
+double overmars_yap( double * points, double * referencePoint, unsigned noObjectives, unsigned noPoints );
+
+/*!
+ *
+ * \brief Algorithm for the special case of d = 3 objectives.
+ *
+ * Applicable to points of dimension d = 3.
+ *
+ * Relevant literature:
+ *
+ * [1]  C. M. Fonseca, L. Paquete, and M. Lopez-Ibanez. An
+ *     improved dimension-sweep algorithm for the hypervolume
+ *     indicator. In IEEE Congress on Evolutionary Computation,
+ *     pages 1157-1163, Vancouver, Canada, July 2006.
+ *
+ * [2]  L. Paquete, C. M. Fonseca and M. Lopez-Ibanez. An optimal
+ *     algorithm for a special case of Klee's measure problem in three
+ *     dimensions. Technical Report CSI-RT-I-01/2006, CSI, Universidade
+ *     do Algarve, 2006.
+ */
+ 
+double fonseca( double * points, double * referencePoint, unsigned noObjectives, unsigned noPoints );
+
+
+//!
+//! \brief computation of the hypervolume
+//!
+//! \par
+//! This function acts as a frontend to various algorithms
+//! for the computation of the hypervolume.
+//!
+//! \param  points          the list containes the coordinates of all points in a single array
+//! \param  referencePoint  the reference or nadir point
+//! \param  noObjectives    number of coordinates per point
+//! \param  noPoints        number of points in the list
+//! \return                 dominated hypervolume
+//!
+double hypervolume(double* points, double* referencePoint, unsigned int noObjectives, unsigned int noPoints);
+
+
+#endif // HYPERVOLUME_H

pymoo/decomposition/aasf.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+from pymoo.decomposition.asf import ASF
+
+
+class AASF(ASF):
+
+    def __init__(self, eps=1e-10, _type="auto", rho=None, beta=None, **kwargs) -> None:
+        super().__init__(eps, _type, **kwargs)
+        if rho is None and beta is None:
+            raise Exception("Either provide rho or beta!")
+        elif rho is None:
+            self.rho = calc_rho(beta)
+        else:
+            self.rho = rho
+
+    def _do(self, F, weights, **kwargs):
+        asf = super()._do(F, weights, **kwargs)
+        augment = ((F - self.utopian_point) / np.clip(weights, 1e-12, np.inf)).sum(axis=1)
+        return asf + self.rho * augment
+
+
+def calc_rho(beta):
+    return 1 / (1 - np.tan(beta / 360 * 2 * np.pi)) - 1

pymoo/decomposition/asf.py

@@ -0,0 +1,10 @@
+from pymoo.core.decomposition import Decomposition
+
+
+class ASF(Decomposition):
+
+    def _do(self, F, weights, weight_0=1e-10, **kwargs):
+        _weights = weights.astype(float)
+        _weights[weights == 0] = weight_0
+        asf = ((F - self.utopian_point) / _weights).max(axis=1)
+        return asf

pymoo/decomposition/pbi.py

@@ -0,0 +1,13 @@
+from pymoo.core.decomposition import Decomposition
+from pymoo.util.function_loader import load_function
+
+
+class PBI(Decomposition):
+
+    def __init__(self, theta=5, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.theta = theta
+
+    def _do(self, F, weights, **kwargs):
+        d1, d2 = load_function("calc_distance_to_weights")(F, weights, self.utopian_point)
+        return d1 + self.theta * d2

pymoo/decomposition/perp_dist.py

@@ -0,0 +1,13 @@
+from pymoo.core.decomposition import Decomposition
+from pymoo.util.function_loader import load_function
+
+
+class PerpendicularDistance(Decomposition):
+
+    def __init__(self, theta=5, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.theta = theta
+
+    def _do(self, F, weights, **kwargs):
+        _, d2 = load_function("calc_distance_to_weights")(F, weights)
+        return d2

pymoo/decomposition/tchebicheff.py

@@ -0,0 +1,11 @@
+import numpy as np
+
+from pymoo.core.decomposition import Decomposition
+
+
+class Tchebicheff(Decomposition):
+
+    def _do(self, F, weights, **kwargs):
+        v = np.abs(F - self.utopian_point) * weights
+        tchebi = v.max(axis=1)
+        return tchebi

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.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, 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