pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/util/display/multi.py

@@ -0,0 +1,96 @@
+from pymoo.indicators.gd import GD
+from pymoo.indicators.hv import Hypervolume
+from pymoo.indicators.igd import IGD
+from pymoo.termination.ftol import MultiObjectiveSpaceTermination
+
+from pymoo.util.display.column import Column
+from pymoo.util.display.output import Output, pareto_front_if_possible
+from pymoo.util.display.single import MinimumConstraintViolation, AverageConstraintViolation
+
+
+class NumberOfNondominatedSolutions(Column):
+
+    def __init__(self, width=6, **kwargs) -> None:
+        super().__init__("n_nds", width=width, **kwargs)
+
+    def update(self, algorithm):
+        self.value = len(algorithm.opt)
+
+
+class MultiObjectiveOutput(Output):
+
+    def __init__(self):
+        super().__init__()
+        self.cv_min = MinimumConstraintViolation()
+        self.cv_avg = AverageConstraintViolation()
+        self.n_nds = NumberOfNondominatedSolutions()
+
+        self.igd = Column("igd")
+        self.gd = Column("gd")
+        self.hv = Column("hv")
+        self.eps = Column("eps")
+        self.indicator = Column("indicator")
+
+        self.pf = None
+        self.indicator_no_pf = None
+
+    def initialize(self, algorithm):
+        problem = algorithm.problem
+
+        self.columns += [self.n_nds]
+
+        if problem.has_constraints():
+            self.columns += [self.cv_min, self.cv_avg]
+
+        self.pf = pareto_front_if_possible(problem)
+        if self.pf is not None:
+            self.columns += [self.igd, self.gd]
+
+            if problem.n_obj == 2:
+                self.columns += [self.hv]
+
+        else:
+            self.indicator_no_pf = MultiObjectiveSpaceTermination()
+            self.columns += [self.eps, self.indicator]
+
+    def update(self, algorithm):
+        super().update(algorithm)
+
+        for col in [self.igd, self.gd, self.hv, self.eps, self.indicator]:
+            col.set(None)
+
+        F, feas = algorithm.opt.get("F", "feas")
+        F = F[feas]
+
+        if len(F) > 0:
+
+            if self.pf is not None:
+
+                if feas.sum() > 0:
+                    self.igd.set(IGD(self.pf, zero_to_one=True).do(F))
+                    self.gd.set(GD(self.pf, zero_to_one=True).do(F))
+
+                    if self.hv in self.columns:
+                        self.hv.set(Hypervolume(pf=self.pf, zero_to_one=True).do(F))
+
+            if self.indicator_no_pf is not None:
+
+                ind = self.indicator_no_pf
+                ind.update(algorithm)
+
+                valid = ind.delta_ideal is not None
+
+                if valid:
+
+                    if ind.delta_ideal > ind.tol:
+                        max_from = "ideal"
+                        eps = ind.delta_ideal
+                    elif ind.delta_nadir > ind.tol:
+                        max_from = "nadir"
+                        eps = ind.delta_nadir
+                    else:
+                        max_from = "f"
+                        eps = ind.delta_f
+
+                    self.eps.set(eps)
+                    self.indicator.set(max_from)

pymoo/util/display/output.py

@@ -0,0 +1,53 @@
+from pymoo.core.callback import Callback
+from pymoo.util.display.column import Column
+
+
+def pareto_front_if_possible(problem):
+    try:
+        return problem.pareto_front()
+    except:
+        return None
+
+
+class NumberOfGenerations(Column):
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__("n_gen", **kwargs)
+
+    def update(self, algorithm):
+        self.value = algorithm.n_gen
+
+
+class NumberOfEvaluations(Column):
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__("n_eval", **kwargs)
+
+    def update(self, algorithm):
+        self.value = algorithm.evaluator.n_eval
+
+
+class Output(Callback):
+
+    def __init__(self):
+        super().__init__()
+        self.n_gen = NumberOfGenerations(width=6)
+        self.n_eval = NumberOfEvaluations(width=8)
+        self.columns = [self.n_gen, self.n_eval]
+
+    def update(self, algorithm):
+        [col.update(algorithm) for col in self.columns]
+
+    def header(self, border=False):
+        regex = " | ".join(["{}"] * len(self.columns))
+        header = regex.format(*[col.name.center(col.width) for col in self.columns])
+
+        if border:
+            line = "=" * len(header)
+            header = line + '\n' + header + '\n' + line
+
+        return header
+
+    def text(self):
+        regex = " | ".join(["{}"] * len(self.columns))
+        return regex.format(*[col.text() for col in self.columns])

pymoo/util/display/progress.py

@@ -0,0 +1,54 @@
+import math
+
+from alive_progress import alive_bar
+
+
+class ProgressBar:
+
+    def __init__(self, *args, start=True, non_decreasing=True, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+        for key, default in [("manual", True), ("force_tty", True)]:
+            if key not in kwargs:
+                kwargs[key] = default
+
+        self.func = None
+        self.obj = None
+        self.non_decreasing = non_decreasing
+        self._max = 0.0
+
+        if start:
+            self.start()
+
+    def set(self, value, *args, **kwargs):
+        if self.non_decreasing:
+            self._max = max(self._max, value)
+            value = self._max
+
+        prec = 100
+        value = math.floor(value * prec) / prec
+
+        self.obj(value, *args, **kwargs)
+
+    def start(self):
+
+        if not self.obj:
+            # save the generator to this object
+            self.func = alive_bar(*self.args, **self.kwargs).gen
+
+            # create the bar
+            self.obj = next(self.func)
+
+    def close(self):
+        if self.obj:
+            try:
+                next(self.func)
+            except:
+                pass
+
+    def __enter__(self):
+        self.start()
+
+    def __exit__(self, type, value, traceback):
+        self.close()

pymoo/util/display/single.py

@@ -0,0 +1,67 @@
+from pymoo.util.display.column import Column
+from pymoo.util.display.output import Output, pareto_front_if_possible
+
+
+class MinimumConstraintViolation(Column):
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__("cv_min", **kwargs)
+
+    def update(self, algorithm):
+        self.value = algorithm.opt.get("cv").min()
+
+
+class AverageConstraintViolation(Column):
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__("cv_avg", **kwargs)
+
+    def update(self, algorithm):
+        self.value = algorithm.pop.get("cv").mean()
+
+
+class SingleObjectiveOutput(Output):
+
+    def __init__(self):
+        super().__init__()
+        self.cv_min = MinimumConstraintViolation()
+        self.cv_avg = AverageConstraintViolation()
+
+        self.f_min = Column(name="f_min")
+        self.f_avg = Column(name="f_avg")
+        self.f_gap = Column(name="f_gap")
+
+        self.best = None
+
+    def initialize(self, algorithm):
+        problem = algorithm.problem
+
+        if problem.has_constraints():
+            self.columns += [self.cv_min, self.cv_avg]
+
+        self.columns += [self.f_avg, self.f_min]
+
+        pf = pareto_front_if_possible(problem)
+        if pf is not None:
+            self.best = pf.flatten()[0]
+            self.columns += [self.f_gap]
+
+    def update(self, algorithm):
+        super().update(algorithm)
+
+        f, cv, feas = algorithm.pop.get("f", "cv", "feas")
+
+        if feas.sum() > 0:
+            self.f_avg.set(f[feas].mean())
+        else:
+            self.f_avg.set(None)
+
+        opt = algorithm.opt[0]
+
+        if opt.feas:
+            self.f_min.set(opt.f)
+            if self.best is not None:
+                self.f_gap.set(opt.f - self.best)
+        else:
+            self.f_min.set(None)
+            self.f_gap.set(None)

pymoo/util/dominator.py

@@ -0,0 +1,67 @@
+import numpy as np
+
+
+def get_relation(ind_a, ind_b):
+    return Dominator.get_relation(ind_a.F, ind_b.F, ind_a.CV[0], ind_b.CV[0])
+
+
+class Dominator:
+
+    @staticmethod
+    def get_relation(a, b, cva=None, cvb=None):
+
+        if cva is not None and cvb is not None:
+            if cva < cvb:
+                return 1
+            elif cvb < cva:
+                return -1
+
+        val = 0
+        for i in range(len(a)):
+            if a[i] < b[i]:
+                # indifferent because once better and once worse
+                if val == -1:
+                    return 0
+                val = 1
+            elif b[i] < a[i]:
+                # indifferent because once better and once worse
+                if val == 1:
+                    return 0
+                val = -1
+        return val
+
+    @staticmethod
+    def calc_domination_matrix_loop(F, G):
+        n = F.shape[0]
+        CV = np.sum(G * (G > 0).astype(float), axis=1)
+        M = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i + 1, n):
+                M[i, j] = Dominator.get_relation(F[i, :], F[j, :], CV[i], CV[j])
+                M[j, i] = -M[i, j]
+
+        return M
+
+    @staticmethod
+    def calc_domination_matrix(F, _F=None, epsilon=0.0):
+
+        if _F is None:
+            _F = F
+
+        # look at the obj for dom
+        n = F.shape[0]
+        m = _F.shape[0]
+
+        L = np.repeat(F, m, axis=0)
+        R = np.tile(_F, (n, 1))
+
+        smaller = np.reshape(np.any(L + epsilon < R, axis=1), (n, m))
+        larger = np.reshape(np.any(L > R + epsilon, axis=1), (n, m))
+
+        M = np.logical_and(smaller, np.logical_not(larger)) * 1 \
+            + np.logical_and(larger, np.logical_not(smaller)) * -1
+
+        # if cv equal then look at dom
+        # M = constr + (constr == 0) * dom
+
+        return M

pymoo/util/function_loader.py

@@ -0,0 +1,129 @@
+import importlib
+
+from pymoo.config import Config
+
+
+def get_functions():
+    from pymoo.util.nds.fast_non_dominated_sort import fast_non_dominated_sort
+    from pymoo.util.nds.efficient_non_dominated_sort import efficient_non_dominated_sort
+    from pymoo.util.nds.tree_based_non_dominated_sort import (
+        tree_based_non_dominated_sort,
+    )
+    from pymoo.util.nds.dominance_degree_non_dominated_sort import (
+        dominance_degree_non_dominated_sort,
+    )
+    from pymoo.decomposition.util import calc_distance_to_weights
+    from pymoo.util.misc import calc_perpendicular_distance
+    from pymoo.util.hv import hv
+    from pymoo.util.stochastic_ranking import stochastic_ranking
+    from pymoo.util.mnn import calc_mnn, calc_2nn
+    from pymoo.util.pruning_cd import calc_pcd
+
+    FUNCTIONS = {
+        "fast_non_dominated_sort": {
+            "python": fast_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "efficient_non_dominated_sort": {
+            "python": efficient_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "fast_best_order_sort": {
+            "python": None,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "tree_based_non_dominated_sort": {
+            "python": tree_based_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "dominance_degree_non_dominated_sort": {
+            "python": dominance_degree_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "calc_distance_to_weights": {
+            "python": calc_distance_to_weights,
+            "cython": "pymoo.cython.decomposition",
+        },
+        "calc_perpendicular_distance": {
+            "python": calc_perpendicular_distance,
+            "cython": "pymoo.cython.calc_perpendicular_distance",
+        },
+        "stochastic_ranking": {
+            "python": stochastic_ranking,
+            "cython": "pymoo.cython.stochastic_ranking",
+        },
+        "hv": {"python": hv, "cython": "pymoo.cython.hv"},
+        "calc_mnn": {"python": calc_mnn, "cython": "pymoo.cython.mnn"},
+        "calc_2nn": {"python": calc_2nn, "cython": "pymoo.cython.mnn"},
+        "calc_pcd": {"python": calc_pcd, "cython": "pymoo.cython.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.cython.info import info
+
+        if info() == "yes":
+            return True
+        else:
+            return False
+    except:
+        return False

pymoo/util/hv.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+from pymoo.vendor.hv import HyperVolume
+
+
+def hv(ref_point, F):
+    hv = HyperVolume(ref_point)
+    return hv.compute(F)
+
+
+def calc_hvc_looped(ref_point, F, func=hv):
+    hv = func(F, ref_point)
+
+    hvi = []
+
+    for k in range(len(F)):
+        v = np.full(len(F), True)
+        v[k] = False
+        _hv = func(F[v], ref_point)
+        hvi.append(hv - _hv)
+
+    hvi = np.array(hvi)
+    return hvi

pymoo/util/matlab_engine.py

@@ -0,0 +1,39 @@
+def install_matlab():
+    print("Please install the Matlab python interface:")
+    print("Tutorial: https://www.mathworks.com/help/matlab/matlab_external/install-the-matlab-engine-for-python.html")
+    print("---------------------------")
+    print("Go to:")
+    print("Windows:", 'cd "matlabroot\extern\engines\python"')
+    print("Linux/Mac:", 'cd "matlabroot/extern/engines/python"')
+    print("python setup.py install")
+    print("---------------------------")
+
+
+class MatlabEngine:
+    """
+    Launching the Matlab engine can become time-consuming and thus shall only be done once and the instance
+    could be reused by different kinds of problems at the same time.
+
+    This is an implementation based on the singleton pattern where only one instance of the engine is used.
+
+    """
+
+    __instance = None
+
+    @staticmethod
+    def get_instance():
+        if MatlabEngine.__instance is None:
+
+            try:
+                import matlab
+                import matlab.engine
+            except:
+                print(install_matlab())
+
+            MatlabEngine.__instance = matlab.engine.start_matlab(option="")
+
+        return MatlabEngine.__instance
+
+    @staticmethod
+    def shutdown():
+        MatlabEngine.__instance.quit()