pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/termination/ftol.py

@@ -0,0 +1,144 @@
+import numpy as np
+
+from pymoo.indicators.hv import Hypervolume
+from pymoo.indicators.igd import IGD
+from pymoo.util.normalization import normalize
+from pymoo.termination.delta import DeltaToleranceTermination
+
+
+def calc_delta(a, b):
+    return np.max(np.abs((a - b)))
+
+
+def calc_delta_norm(a, b, norm):
+    return np.max(np.abs((a - b) / norm))
+
+
+class SingleObjectiveSpaceTermination(DeltaToleranceTermination):
+
+    def __init__(self, tol=1e-6, only_feas=True, **kwargs) -> None:
+        super().__init__(tol, **kwargs)
+        self.only_feas = only_feas
+
+    def _delta(self, prev, current):
+        if prev == np.inf or current == np.inf:
+            return np.inf
+        else:
+            return max(0, prev - current)
+
+    def _data(self, algorithm):
+        opt = algorithm.opt
+        f = opt.get("f")
+
+        if self.only_feas:
+            f = f[opt.get("feas")]
+
+        if len(f) > 0:
+            return f.min()
+        else:
+            return np.inf
+
+
+class MultiObjectiveSpaceTermination(DeltaToleranceTermination):
+
+    def __init__(self, tol=0.0025, only_feas=True, **kwargs):
+        super().__init__(tol, **kwargs)
+        self.delta_ideal = None
+        self.delta_nadir = None
+        self.delta_f = None
+        self.only_feas = only_feas
+
+    def _data(self, algorithm):
+        feas, F = algorithm.opt.get("feas", "F")
+
+        if self.only_feas:
+            F = F[feas]
+
+        if len(F) > 0:
+            return dict(ideal=F.min(axis=0), nadir=F.max(axis=0), F=F, feas=True)
+        else:
+            return dict(ideal=None, nadir=None, F=F, feas=False)
+
+    def _delta(self, prev, current):
+
+        if not (prev["feas"] and current["feas"]):
+            return np.inf
+
+        # this is the range between the nadir and the ideal point
+        norm = current["nadir"] - current["ideal"]
+
+        # if the range is degenerated (very close to zero) - disable normalization by dividing by one
+        norm[norm < 1e-32] = 1.0
+
+        # calculate the change from last to current in ideal and nadir point
+        delta_ideal = calc_delta_norm(current["ideal"], prev["ideal"], norm)
+        delta_nadir = calc_delta_norm(current["nadir"], prev["nadir"], norm)
+
+        # get necessary data from the current population
+        c_F, c_ideal, c_nadir = current["F"], current["ideal"], current["nadir"]
+        p_F = prev["F"]
+
+        # normalize last and current with respect to most recent ideal and nadir
+        c_N = normalize(c_F, c_ideal, c_nadir)
+        p_N = normalize(p_F, c_ideal, c_nadir)
+
+        # calculate IGD from one to another
+        delta_f = IGD(c_N).do(p_N)
+
+        # store the delta values to the object
+        self.delta_ideal, self.delta_nadir, self.delta_f = delta_ideal, delta_nadir, delta_f
+
+        return max(delta_ideal, delta_nadir, delta_f)
+
+
+class MultiObjectiveSpaceTerminationWithRenormalization(MultiObjectiveSpaceTermination):
+
+    def __init__(self,
+                 n=30,
+                 all_to_current=False,
+                 sliding_window=True,
+                 indicator="igd",
+                 **kwargs) -> None:
+
+        super().__init__(**kwargs)
+        self.n = n
+        self.all_to_current = all_to_current
+        self.sliding_window = sliding_window
+        self.indicator = indicator
+
+        self.data = []
+
+    def _metric(self, data):
+        ret = super()._metric(data)
+
+        if not self.sliding_window:
+            data = self.data[-self.metric_window_size:]
+
+        # get necessary data from the current population
+        current = data[-1]
+        c_F, c_ideal, c_nadir = current["F"], current["ideal"], current["nadir"]
+
+        # normalize all previous generations with respect to current ideal and nadir
+        N = [normalize(e["F"], c_ideal, c_nadir) for e in data]
+
+        # check if the movement of all points is significant
+        if self.all_to_current:
+
+            c_N = normalize(c_F, c_ideal, c_nadir)
+            if self.indicator == "igd":
+                delta_f = [IGD(c_N).do(N[k]) for k in range(len(N))]
+            elif self.indicator == "hv":
+                hv = Hypervolume(ref_point=np.ones(c_F.shape[1]))
+                delta_f = [hv.do(N[k]) for k in range(len(N))]
+        else:
+            delta_f = [IGD(N[k + 1]).do(N[k]) for k in range(len(N) - 1)]
+
+        ret["delta_f"] = delta_f
+
+        return ret
+
+    def _decide(self, metrics):
+        delta_ideal = [e["delta_ideal"] for e in metrics]
+        delta_nadir = [e["delta_nadir"] for e in metrics]
+        delta_f = [max(e["delta_f"]) for e in metrics]
+        return max(max(delta_ideal), max(delta_nadir), max(delta_f)) > self.tol

pymoo/termination/indicator.py

@@ -0,0 +1,49 @@
+from math import log
+
+from pymoo.core.termination import Termination
+
+
+class IndicatorTermination(Termination):
+
+    def __init__(self, indicator, threshold, goal, **kwargs) -> None:
+        super().__init__()
+
+        # the indicator to be used
+        self.indicator = indicator
+
+        # define the threshold for termination
+        self.threshold = threshold
+
+        # what is the optimization goal for this indicator
+        self.goal = goal
+        assert goal in ["minimize", "maximize"]
+
+        # optional parameters when the indicator calculation is performed
+        self.kwargs = kwargs
+
+        # initial the minimum and maximum values of the indicator
+        self._min = float("inf")
+        self._max = -float("inf")
+
+    def _update(self, algorithm):
+
+        # get the objective space values
+        F = algorithm.opt.get("F")
+
+        # get the resulting value from the indicator
+        v = self.indicator.do(F, **self.kwargs)
+
+        threshold = self.threshold
+
+        # update the minimum and maximum boundary ranges
+        self._min = min(self._min, v)
+        self._max = max(self._max, v)
+        _min, _max = self._min, self._max
+
+        # depending on the goal either set the percentage
+        if self.goal == "minimize":
+            perc = 1 - (v - threshold) / (_max - threshold)
+        else:
+            perc = (v - _min) / (threshold - _min)
+
+        return perc

pymoo/termination/max_eval.py

@@ -0,0 +1,14 @@
+from pymoo.core.termination import Termination
+
+
+class MaximumFunctionCallTermination(Termination):
+
+    def __init__(self, n_max_evals=float("inf")) -> None:
+        super().__init__()
+        self.n_max_evals = n_max_evals
+
+    def _update(self, algorithm):
+        if self.n_max_evals is None:
+            return 0.0
+        else:
+            return algorithm.evaluator.n_eval / self.n_max_evals

pymoo/termination/max_gen.py

@@ -0,0 +1,15 @@
+from pymoo.core.termination import Termination
+
+
+class MaximumGenerationTermination(Termination):
+
+    def __init__(self, n_max_gen=float("inf")) -> None:
+        super().__init__()
+        self.n_max_gen = n_max_gen
+
+    def _update(self, algorithm):
+        if self.n_max_gen is None:
+            return 0.0
+        else:
+            return algorithm.n_gen / self.n_max_gen
+

pymoo/termination/max_time.py

@@ -0,0 +1,20 @@
+import time
+
+from pymoo.core.termination import Termination
+from pymoo.util.misc import time_to_int
+
+
+class TimeBasedTermination(Termination):
+
+    def __init__(self, max_time) -> None:
+        super().__init__()
+        if isinstance(max_time, str):
+            self.max_time = time_to_int(max_time)
+        elif isinstance(max_time, int) or isinstance(max_time, float):
+            self.max_time = max_time
+        else:
+            raise Exception("Either provide the time as a string or an integer.")
+
+    def _update(self, algorithm):
+        elapsed = time.time() - algorithm.start_time
+        return elapsed / self.max_time

pymoo/termination/robust.py

@@ -0,0 +1,34 @@
+from pymoo.core.termination import Termination
+from pymoo.util.sliding_window import SlidingWindow
+
+
+class RobustTermination(Termination):
+
+    def __init__(self,
+                 termination,
+                 period=30,
+                 ) -> None:
+        """
+
+        Parameters
+        ----------
+
+        termination : Termination
+            The termination criterion that shall become robust
+
+        period : int
+            The number of last generations to be considered for termination.
+
+        """
+        super().__init__()
+
+        # create a collection in case number of max generation or evaluations is used
+        self.termination = termination
+
+        # the history calculated also in a sliding window
+        self.history = SlidingWindow(period)
+
+    def _update(self, algorithm):
+        perc = self.termination.update(algorithm)
+        self.history.append(perc)
+        return min(self.history)

pymoo/termination/xtol.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+from pymoo.indicators.igd import IGD
+from pymoo.termination.delta import DeltaToleranceTermination
+from pymoo.util.normalization import normalize
+
+
+
+class DesignSpaceTermination(DeltaToleranceTermination):
+
+    def __init__(self, tol=0.005, **kwargs):
+        """
+        Check the distance in the design-space and terminate based on tolerance.
+        (only works if variables can be converted to float)
+        """
+        super().__init__(tol, **kwargs)
+
+    def _delta(self, prev, current):
+        try:
+            return IGD(current.astype(float)).do(prev.astype(float))
+        except:
+            return np.inf
+
+    def _data(self, algorithm):
+
+        X = algorithm.opt.get("X")
+
+        # do normalization if bounds are given
+        problem = algorithm.problem
+        if X.dtype != object and problem.has_bounds():
+            X = normalize(X, xl=problem.xl, xu=problem.xu)
+
+        return X

pymoo/util/__init__.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+
+def default_random_state(func_or_seed=None, *, seed=None):
+    """
+    Decorator that provides a default random state to functions.
+    
+    Can be used as:
+    - @default_random_state
+    - @default_random_state(1)  # with positional seed
+    - @default_random_state(seed=1)  # with keyword seed
+    
+    If random_state is provided to the function call, it takes precedence.
+    """
+    def decorator(func, default_seed=None):
+        def wrapper(*args, random_state=None, **kwargs):
+            if random_state is None:
+                # Check if seed is provided in kwargs, otherwise use default_seed
+                seed_to_use = kwargs.pop('seed', default_seed)
+                random_state = np.random.default_rng(seed_to_use)
+            return func(*args, random_state=random_state, **kwargs)
+        return wrapper
+    
+    # Handle different calling patterns
+    if func_or_seed is None:
+        # Called as @default_random_state() or @default_random_state(seed=1)
+        return lambda func: decorator(func, seed)
+    elif callable(func_or_seed):
+        # Called as @default_random_state (no parentheses)
+        return decorator(func_or_seed, None)
+    else:
+        # Called as @default_random_state(1) (positional seed)
+        return lambda func: decorator(func, func_or_seed)

pymoo/util/archive.py

@@ -0,0 +1,152 @@
+import numpy as np
+
+from pymoo.core.duplicate import DefaultDuplicateElimination
+from pymoo.core.population import Population, merge
+from pymoo.util import default_random_state
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+
+
+class Truncation:
+
+    def __call__(self, sols, k):
+        pass
+
+
+class RandomTruncation(Truncation):
+
+    @default_random_state
+    def __call__(self, sols, k, random_state=None):
+        return random_state.choice(sols, size=k, replace=False)
+
+
+class SurvivalTruncation(Truncation):
+
+    def __init__(self, survival, problem=None) -> None:
+        super().__init__()
+        self.survival = survival
+
+        if problem is None:
+            from pymoo.core.problem import Problem
+            problem = Problem()
+
+        self.problem = problem
+
+    def __call__(self, sols, k):
+        return self.survival.do(self.problem, sols, n_survive=k)
+
+
+class Archive(Population):
+
+    def __new__(cls,
+                individuals=[],
+                max_size=None,
+                truncate_size=None,
+                truncation=RandomTruncation(),
+                duplicate_elimination=DefaultDuplicateElimination(epsilon=1e-32)):
+
+        obj = super().__new__(cls, individuals)
+        obj.max_size = max_size
+        obj.truncate_size = min(max_size, truncate_size) if truncate_size is not None else max_size
+        obj.truncation = truncation
+        obj.duplicate_elimination = duplicate_elimination
+
+        return obj
+
+    def __array_finalize__(self, obj):
+        if obj is None:  # __new__ handles instantiation
+            return
+
+        max_size = getattr(obj, 'max_size', None)
+        truncate_size = getattr(obj, 'truncate_size', None)
+        truncation = getattr(obj, 'truncation', RandomTruncation())
+        duplicate_elimination = getattr(obj, 'duplicate_elimination', DefaultDuplicateElimination(epsilon=1e-32))
+
+        self.max_size = max_size
+        self.truncate_size = min(max_size, truncate_size) if truncate_size is not None else max_size
+        self.truncation = truncation
+        self.duplicate_elimination = duplicate_elimination
+
+    def add(self, sols):
+
+        if len(self) > 0:
+            sols = merge(self, sols)
+
+        opt = self._find_opt(sols)
+
+        if self.duplicate_elimination:
+            opt = self.duplicate_elimination.do(opt)
+
+        if self.max_size and len(opt) > self.max_size:
+            opt = self.truncation(opt, self.truncate_size)
+
+        cls = self.__class__
+        obj = cls.__new__(cls, individuals=opt, **self.view(Archive).__dict__)
+        return obj
+
+    def _find_opt(self, sols):
+        pass
+
+
+class VoidArchive(Archive):
+
+    def add(self, sols):
+        return self
+
+
+class SingleObjectiveArchive(Archive):
+
+    def __new__(cls, max_size=10, **kwargs):
+        return super().__new__(cls, max_size=max_size, **kwargs).view(cls)
+
+    def _find_opt(self, sols):
+        feas = sols.get("feas")
+
+        if np.any(feas):
+            sols = sols[feas]
+
+            f = sols.get("f")
+            I, = np.where(f == f[f.argmin()])
+
+        else:
+            cv = sols.get("cv")
+            I, = np.where(cv == cv[cv.argmin()])
+
+        return sols[I]
+
+
+class MultiObjectiveArchive(Archive):
+
+    def __new__(cls, max_size=200, truncate_size=100, **kwargs):
+        return super().__new__(cls,
+                               max_size=max_size,
+                               truncate_size=truncate_size,
+                               **kwargs)
+
+    def _find_opt(self, sols):
+        feas = sols.get("feas")
+
+        if np.any(feas):
+            sols = sols[feas]
+
+            F = sols.get("F")
+            I = NonDominatedSorting().do(F, only_non_dominated_front=True)
+        else:
+            cv = sols.get("cv")
+            I, = np.where(cv == cv[cv.argmin()])
+
+        return sols[I]
+
+
+def default_archive(problem, **kwargs):
+    if problem.n_obj == 1:
+        return SingleObjectiveArchive(**kwargs)
+
+    elif problem.n_obj == 2:
+        from pymoo.algorithms.moo.sms import LeastHypervolumeContributionSurvival
+        survival = LeastHypervolumeContributionSurvival()
+        return MultiObjectiveArchive(truncation=SurvivalTruncation(survival, problem=problem), **kwargs)
+
+    elif problem.n_obj >= 3:
+        from pymoo.algorithms.moo.spea2 import SPEA2Survival
+        survival = SPEA2Survival()
+        return MultiObjectiveArchive(truncation=SurvivalTruncation(survival, problem=problem), **kwargs)

pymoo/util/cache.py

@@ -0,0 +1,29 @@
+def Cache(func):
+    """
+
+    This is a function decorator for class attributes. It just remembers the result of the FIRST function call
+    and returns this from there on. Other cashes like LRU are difficult to use because the input can be unhashable
+    or bigger numpy arrays. Thus the user has to choose how to use this cache.
+    """
+
+    func_name = func.__name__
+
+    def wrapper(self, *args, use_cache=True, set_cache=True, **kwargs):
+
+        if not hasattr(self, 'cache'):
+            setattr(self, 'cache', {})
+
+        cache = getattr(self, 'cache')
+
+        if use_cache and func_name in cache:
+            return cache[func_name]
+        else:
+
+            obj = func(self, *args, **kwargs)
+
+            if set_cache:
+                cache[func_name] = obj
+
+            return obj
+
+    return wrapper

pymoo/util/clearing.py

@@ -0,0 +1,82 @@
+import numpy as np
+
+
+def func_select_by_objective(pop):
+    F = pop.get("F")
+    return F[:, 0].argmin()
+
+
+def func_select_from_sorted(_):
+    return 0
+
+
+def select_by_clearing(pop, D, n_select, func_select, delta=0.05):
+    clearing = EpsilonClearing(D, delta)
+
+    while len(clearing.selected()) < n_select:
+        remaining = clearing.remaining()
+
+        if len(remaining) == 0:
+            clearing.reset()
+            remaining = clearing.remaining()
+
+        best = remaining[func_select(pop[remaining])]
+        clearing.select(best)
+
+    S = clearing.selected()
+    return S
+
+
+class EpsilonClearing:
+
+    def __init__(self,
+                 D,
+                 epsilon) -> None:
+
+        super().__init__()
+
+        if isinstance(D, tuple):
+            self.n, self.D = D
+        else:
+            self.D = D
+            self.n = len(D)
+
+        self.epsilon = epsilon
+
+        self.S = []
+        self.C = np.full(self.n, False)
+
+    def remaining(self):
+        return np.where(~self.C)[0]
+
+    def has_remaining(self):
+        return self.C.sum() != self.n
+
+    def cleared(self):
+        return self.C
+
+    def selected(self):
+        return self.S
+
+    def reset(self):
+        self.C = np.full(self.n, False)
+        self.C[self.S] = True
+
+    def select(self, k):
+        self.S.append(k)
+        self.C[k] = True
+
+        if callable(self.D):
+            dist_to_other = self.D(k)
+        else:
+            dist_to_other = self.D[k]
+
+        less_than_epsilon = dist_to_other < self.epsilon
+
+        # problems which are currently not cleared and are supposed to
+        cleared = np.where(np.logical_and(~self.C, less_than_epsilon))[0]
+
+        # set them to be cleared
+        self.C[cleared] = True
+
+        return cleared

pymoo/util/display/column.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+
+class Column:
+
+    def __init__(self, name, width=13, func=None, truncate=True) -> None:
+        super().__init__()
+        self.name = name
+        self.func = func
+        self.width = width
+        self.truncate = truncate
+        self.value = None
+
+    def update(self, algorithm):
+        if self.func:
+            self.value = self.func(algorithm)
+
+    def header(self):
+        return str(self.name).center(self.width)
+
+    def text(self):
+        value = self.value
+        if value is None:
+            value = "-"
+
+        return format_text(value, self.width, self.truncate)
+
+    def set(self, value):
+        self.value = value
+
+
+def number_to_text(number, width):
+    if number >= 10 or number * 1e5 < 1:
+        return f"%.{width - 7}E" % number
+    else:
+        return f"%.{width - 3}f" % number
+
+
+def format_text(value, width, truncate):
+    if value is not None:
+
+        if isinstance(value, (np.floating, float)):
+            text = number_to_text(value, width)
+        else:
+            text = str(value)
+
+        if truncate and len(text) > width:
+            text = text[:width]
+    else:
+        text = "-"
+    text = text.rjust(width)
+    return text