pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/util/display/display.py

@@ -0,0 +1,34 @@
+from pymoo.core.callback import Callback
+from pymoo.util.display.progress import ProgressBar
+
+
+class Display(Callback):
+
+    def __init__(self, output=None, progress=False, verbose=False):
+        super().__init__()
+        self.output = output
+        self.verbose = verbose
+        self.progress = ProgressBar() if progress else None
+
+    def update(self, algorithm, **kwargs):
+        output, progress = self.output, self.progress
+
+        if self.verbose and output:
+            text = ""
+            header = not output.is_initialized
+            output(algorithm)
+
+            if header:
+                text += output.header(border=True) + '\n'
+            text += output.text()
+
+            print(text)
+
+        if progress:
+            perc = algorithm.termination.perc
+            progress.set(perc)
+
+    def finalize(self):
+
+        if self.progress:
+            self.progress.close()

pymoo/util/display/multi.py

@@ -0,0 +1,100 @@
+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:
+            
+            problem = algorithm.problem
+            if hasattr(problem, "time"):
+                self.pf = pareto_front_if_possible(problem)
+
+            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/hv.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+from moocore import hypervolume as _hypervolume
+
+
+def hv(ref_point, F):
+    return _hypervolume(F, ref = ref_point)
+
+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()