pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/decomposition/pbi.py

@@ -0,0 +1,13 @@
+from pymoo.core.decomposition import Decomposition
+from pymoo.functions 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.functions 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/functions/__init__.py

@@ -0,0 +1,135 @@
+# Function package for pymoo
+# Contains both compiled (Cython) and standard (Python) implementations
+
+import importlib
+
+from pymoo.config import Config
+
+
+def get_functions():
+    from pymoo.functions.standard.non_dominated_sorting import (
+        fast_non_dominated_sort,
+        efficient_non_dominated_sort,
+        tree_based_non_dominated_sort,
+        dominance_degree_non_dominated_sort,
+        find_non_dominated,
+        fast_best_order_sort,
+    )
+    from pymoo.functions.standard.decomposition import calc_distance_to_weights
+    from pymoo.functions.standard.calc_perpendicular_distance import calc_perpendicular_distance
+    from pymoo.functions.standard.hv import hv
+    from pymoo.functions.standard.stochastic_ranking import stochastic_ranking
+    from pymoo.functions.standard.mnn import calc_mnn, calc_2nn
+    from pymoo.functions.standard.pruning_cd import calc_pcd
+
+    FUNCTIONS = {
+        "fast_non_dominated_sort": {
+            "python": fast_non_dominated_sort,
+            "cython": "pymoo.functions.compiled.non_dominated_sorting",
+        },
+        "find_non_dominated": {
+            "python": find_non_dominated,
+            "cython": "pymoo.functions.compiled.non_dominated_sorting",
+        },
+        "efficient_non_dominated_sort": {
+            "python": efficient_non_dominated_sort,
+            "cython": "pymoo.functions.compiled.non_dominated_sorting",
+        },
+        "fast_best_order_sort": {
+            "python": fast_best_order_sort,
+            "cython": "pymoo.functions.compiled.non_dominated_sorting",
+        },
+        "tree_based_non_dominated_sort": {
+            "python": tree_based_non_dominated_sort,
+            "cython": "pymoo.functions.compiled.non_dominated_sorting",
+        },
+        "dominance_degree_non_dominated_sort": {
+            "python": dominance_degree_non_dominated_sort,
+            "cython": "pymoo.functions.compiled.non_dominated_sorting",
+        },
+        "calc_distance_to_weights": {
+            "python": calc_distance_to_weights,
+            "cython": "pymoo.functions.compiled.decomposition",
+        },
+        "calc_perpendicular_distance": {
+            "python": calc_perpendicular_distance,
+            "cython": "pymoo.functions.compiled.calc_perpendicular_distance",
+        },
+        "stochastic_ranking": {
+            "python": stochastic_ranking,
+            "cython": "pymoo.functions.compiled.stochastic_ranking",
+        },
+        "calc_mnn": {"python": calc_mnn, "cython": "pymoo.functions.compiled.mnn"},
+        "calc_2nn": {"python": calc_2nn, "cython": "pymoo.functions.compiled.mnn"},
+        "calc_pcd": {"python": calc_pcd, "cython": "pymoo.functions.compiled.pruning_cd"},
+    }
+
+    return FUNCTIONS
+
+
+class FunctionLoader:
+    # -------------------------------------------------
+    # Singleton Pattern
+    # -------------------------------------------------
+    __instance = None
+
+    @staticmethod
+    def get_instance():
+        if FunctionLoader.__instance is None:
+            FunctionLoader.__instance = FunctionLoader()
+        return FunctionLoader.__instance
+
+    # -------------------------------------------------
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.is_compiled = is_compiled()
+        self.mode = "auto"
+
+        if Config.warnings["not_compiled"] and not self.is_compiled:
+            print("\nCompiled modules for significant speedup can not be used!")
+            print("https://pymoo.org/installation.html#installation")
+            print()
+            print("To disable this warning:")
+            print("from pymoo.config import Config")
+            print("Config.warnings['not_compiled'] = False\n")
+
+    def load(self, func_name=None, mode=None):
+        if mode is None:
+            mode = self.mode
+
+        FUNCTIONS = get_functions()
+
+        if mode == "auto":
+            mode = "cython" if self.is_compiled else "python"
+
+        if func_name not in FUNCTIONS:
+            raise Exception("Function %s not found: %s" % (func_name, FUNCTIONS.keys()))
+
+        func = FUNCTIONS[func_name]
+        if mode not in func:
+            raise Exception("Module not available in %s." % mode)
+        func = func[mode]
+
+        # either provide a function or a string to the module (used for cython)
+        if not callable(func):
+            module = importlib.import_module(func)
+            func = getattr(module, func_name)
+
+        return func
+
+
+def load_function(func_name=None, _type="auto"):
+    return FunctionLoader.get_instance().load(func_name, mode=_type)
+
+
+def is_compiled():
+    try:
+        from pymoo.functions.compiled.info import info
+
+        if info() == "yes":
+            return True
+        else:
+            return False
+    except:
+        return False