pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/util/reference_direction.py

@@ -0,0 +1,260 @@
+import sys
+
+import numpy as np
+from scipy import special
+
+from pymoo.util.misc import find_duplicates, cdist
+
+
+# =========================================================================================================
+# Model
+# =========================================================================================================
+
+
+def default_ref_dirs(m):
+    if m == 1:
+        return np.array([[1.0]])
+    elif m == 2:
+        return UniformReferenceDirectionFactory(m, n_partitions=99).do()
+    elif m == 3:
+        return UniformReferenceDirectionFactory(m, n_partitions=12).do()
+    else:
+        raise Exception("No default reference directions for more than 3 objectives. Please provide them directly:"
+                        "https://pymoo.org/misc/reference_directions.html")
+
+
+class ReferenceDirectionFactory:
+
+    def __init__(self, n_dim, scaling=None, lexsort=True, verbose=False, seed=None, **kwargs) -> None:
+        super().__init__()
+        self.n_dim = n_dim
+        self.scaling = scaling
+        self.lexsort = lexsort
+        self.verbose = verbose
+        self.seed = seed
+
+    def __call__(self):
+        return self.do()
+
+    def do(self):
+
+        # set the random seed if it is provided
+        if self.seed is not None:
+            np.random.seed(self.seed)
+
+        if self.n_dim == 1:
+            return np.array([[1.0]])
+        else:
+
+            val = self._do()
+            if isinstance(val, tuple):
+                ref_dirs, other = val[0], val[1:]
+            else:
+                ref_dirs = val
+
+            if self.scaling is not None:
+                ref_dirs = scale_reference_directions(ref_dirs, self.scaling)
+
+            # do ref_dirs is desired
+            if self.lexsort:
+                I = np.lexsort([ref_dirs[:, j] for j in range(ref_dirs.shape[1])][::-1])
+                ref_dirs = ref_dirs[I]
+
+            return ref_dirs
+
+    def _do(self):
+        return None
+
+
+# =========================================================================================================
+# Das Dennis Reference Directions (Uniform)
+# =========================================================================================================
+
+
+def get_number_of_uniform_points(n_partitions, n_dim):
+    """
+    Returns the number of uniform points that can be created uniformly.
+    """
+    return int(special.binom(n_dim + n_partitions - 1, n_partitions))
+
+
+def get_partition_closest_to_points(n_points, n_dim):
+    """
+    Returns the corresponding partition number which create the desired number of points
+    or less!
+    """
+
+    if n_dim == 1:
+        return 0
+
+    n_partitions = 1
+    _n_points = get_number_of_uniform_points(n_partitions, n_dim)
+    while _n_points <= n_points:
+        n_partitions += 1
+        _n_points = get_number_of_uniform_points(n_partitions, n_dim)
+    return n_partitions - 1
+
+
+def das_dennis(n_partitions, n_dim):
+    if n_partitions == 0:
+        return np.full((1, n_dim), 1 / n_dim)
+    else:
+        ref_dirs = []
+        ref_dir = np.full(n_dim, np.nan)
+        das_dennis_recursion(ref_dirs, ref_dir, n_partitions, n_partitions, 0)
+        return np.concatenate(ref_dirs, axis=0)
+
+
+def das_dennis_recursion(ref_dirs, ref_dir, n_partitions, beta, depth):
+    if depth == len(ref_dir) - 1:
+        ref_dir[depth] = beta / (1.0 * n_partitions)
+        ref_dirs.append(ref_dir[None, :])
+    else:
+        for i in range(beta + 1):
+            ref_dir[depth] = 1.0 * i / (1.0 * n_partitions)
+            das_dennis_recursion(ref_dirs, np.copy(ref_dir), n_partitions, beta - i, depth + 1)
+
+
+class UniformReferenceDirectionFactory(ReferenceDirectionFactory):
+
+    def __init__(self, n_dim, scaling=None, n_points=None, n_partitions=None, **kwargs) -> None:
+        super().__init__(n_dim, scaling=scaling, **kwargs)
+
+        if n_points is not None:
+            n_partitions = get_partition_closest_to_points(n_points, n_dim)
+            results_in = get_number_of_uniform_points(n_partitions, n_dim)
+
+            # the number of points are not matching to any partition number
+            if results_in != n_points:
+                results_in_next = get_number_of_uniform_points(n_partitions + 1, n_dim)
+                raise Exception("The number of points (n_points = %s) can not be created uniformly.\n"
+                                "Either choose n_points = %s (n_partitions = %s) or "
+                                "n_points = %s (n_partitions = %s)." %
+                                (n_points, results_in, n_partitions, results_in_next, n_partitions + 1))
+
+            self.n_partitions = n_partitions
+
+        elif n_partitions is not None:
+            self.n_partitions = n_partitions
+
+        else:
+            raise Exception("Either provide number of partitions or number of points.")
+
+    def _do(self):
+        return das_dennis(self.n_partitions, self.n_dim)
+
+
+# =========================================================================================================
+# Multi Layer
+# =========================================================================================================
+
+
+class MultiLayerReferenceDirectionFactory:
+
+    def __init__(self, *args) -> None:
+        self.layers = []
+        self.layers.extend(args)
+
+    def __call__(self):
+        return self.do()
+
+    def add_layer(self, *args):
+        self.layers.extend(args)
+
+    def do(self):
+        ref_dirs = []
+        for factory in self.layers:
+            ref_dirs.append(factory)
+        ref_dirs = np.concatenate(ref_dirs, axis=0)
+        is_duplicate = find_duplicates(ref_dirs)
+        return ref_dirs[np.logical_not(is_duplicate)]
+
+
+# =========================================================================================================
+# Util
+# =========================================================================================================
+
+def get_rng(seed=None):
+    if seed is None or type(seed) == int:
+        rng = np.random.default_rng(seed)
+    return rng
+
+
+def sample_on_unit_simplex(n_points, n_dim, unit_simplex_mapping="kraemer", seed=None):
+    if unit_simplex_mapping == "sum":
+        rnd = map_onto_unit_simplex(get_rng(seed).random((n_points, n_dim)), "sum")
+
+    elif unit_simplex_mapping == "kraemer":
+        rnd = map_onto_unit_simplex(get_rng(seed).random((n_points, n_dim)), "kraemer")
+
+    elif unit_simplex_mapping == "das-dennis":
+        n_partitions = get_partition_closest_to_points(n_points, n_dim)
+        rnd = UniformReferenceDirectionFactory(n_dim, n_partitions=n_partitions).do()
+
+    else:
+        raise Exception("Please define a valid sampling on unit simplex strategy!")
+
+    return rnd
+
+
+def map_onto_unit_simplex(rnd, method):
+    n_points, n_dim = rnd.shape
+
+    if method == "sum":
+        ret = rnd / rnd.sum(axis=1)[:, None]
+
+    elif method == "kraemer":
+        M = sys.maxsize
+
+        rnd *= M
+        rnd = rnd[:, :n_dim - 1]
+        rnd = np.column_stack([np.zeros(n_points), rnd, np.full(n_points, M)])
+
+        rnd = np.sort(rnd, axis=1)
+
+        ret = np.full((n_points, n_dim), np.nan)
+        for i in range(1, n_dim + 1):
+            ret[:, i - 1] = rnd[:, i] - rnd[:, i - 1]
+        ret /= M
+
+    else:
+        raise Exception("Invalid unit simplex mapping!")
+
+    return ret
+
+
+def scale_reference_directions(ref_dirs, scaling):
+    return ref_dirs * scaling + ((1 - scaling) / ref_dirs.shape[1])
+
+
+def select_points_with_maximum_distance(X, n_select, selected=[]):
+    n_points, n_dim = X.shape
+
+    # calculate the distance matrix
+    D = cdist(X, X)
+
+    # if no selection provided pick randomly in the beginning
+    if len(selected) == 0:
+        selected = [np.random.randint(len(X))]
+
+    # create variables to store what selected and what not
+    not_selected = [i for i in range(n_points) if i not in selected]
+
+    # remove unnecessary points
+    dist_to_closest_selected = D[:, selected].min(axis=1)
+
+    # now select the points until sufficient ones are found
+    while len(selected) < n_select:
+        # find point that has the maximum distance to all others
+        index_in_not_selected = dist_to_closest_selected[not_selected].argmax()
+        I = not_selected[index_in_not_selected]
+
+        # add the closest distance to selected point
+        is_closer = D[I] < dist_to_closest_selected
+        dist_to_closest_selected[is_closer] = D[I][is_closer]
+
+        # add it to the selected and remove from not selected
+        selected.append(I)
+        not_selected = np.delete(not_selected, index_in_not_selected)
+
+    return selected

pymoo/util/remote.py

@@ -0,0 +1,55 @@
+import json
+import os
+import urllib.request
+from os.path import join, dirname, abspath
+
+import numpy as np
+
+from pymoo.config import Config
+
+
+class Remote:
+    # -------------------------------------------------
+    # Singleton Pattern
+    # -------------------------------------------------
+    __instance = None
+
+    @staticmethod
+    def get_instance():
+        if Remote.__instance is None:
+            server = Config.data()
+            folder = join(dirname(dirname(abspath(__file__))), 'data')
+            Remote.__instance = Remote(server, folder)
+        return Remote.__instance
+
+    # -------------------------------------------------
+
+    def __init__(self, server, folder=None) -> None:
+        super().__init__()
+        self.server = server
+        self.folder = folder
+
+    def load(self, *args, to="numpy"):
+
+        # the local file we can try loading
+        f = join(str(self.folder), *args)
+
+        # check if that path already exists
+        if not os.path.exists(f):
+
+            # if not make sure to create it that the file can be written
+            folder = dirname(f)
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+
+            # create the url to load it from and download the file remotely
+            url = self.server + "/".join(args)
+            urllib.request.urlretrieve(url, f)
+
+        if to == "numpy":
+            return np.loadtxt(f)
+        elif to == "json":
+            with open(f) as file:
+                return json.load(file)
+
+        return f

pymoo/util/roulette.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+
+class RouletteWheelSelection:
+
+    def __init__(self, val, larger_is_better=True):
+        super().__init__()
+        if not larger_is_better:
+            val = val.max() - val
+        _sum = val.sum()
+        self.cumulative = np.array([val[:k].sum() / _sum for k in range(1, len(val))])
+
+    def next(self, n=None):
+        if n is None:
+            X = np.random.random((1, 1))
+        else:
+            X = np.random.random((n, 1))
+            if n > 1:
+                X.repeat(n - 1, axis=1)
+
+        M = self.cumulative[None, :].repeat(len(X), axis=0)
+        B = X >= M
+        ret = B.sum(axis=1)
+
+        if n is None:
+            return ret[0]
+        return ret

pymoo/util/running_metric.py

@@ -0,0 +1,128 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+from pymoo.core.callback import Callback
+from pymoo.indicators.hv import Hypervolume
+from pymoo.indicators.igd import IGD
+from pymoo.termination.ftol import calc_delta_norm
+from pymoo.util.normalization import normalize
+from pymoo.util.sliding_window import SlidingWindow
+from pymoo.visualization.video.callback_video import AnimationCallback
+
+
+class RunningMetric(Callback):
+
+    def __init__(self,
+                 period=None,
+                 indicator="igd") -> None:
+
+        super().__init__()
+        self.indicator = indicator
+
+        self.delta_ideal = None
+        self.delta_nadir = None
+        self.delta_f = None
+
+        self.history = SlidingWindow(period)
+
+    def update(self, algorithm):
+        history = self.history
+
+        F = algorithm.opt.get("F")
+        c_F, c_ideal, c_nadir = F, F.min(axis=0), F.max(axis=0)
+
+        # find the normalization constant to divide by
+        norm = c_nadir - c_ideal
+
+        # make sure all dimensions in ideal are strictly lower than in nadir
+        c_nadir[c_ideal == c_nadir] += 1e-16
+        norm[c_ideal == c_nadir] = 1.0
+
+        # append the current optimum to the history
+        history.append(dict(F=F, ideal=c_ideal, nadir=c_nadir))
+
+        # normalize the current objective space values (use the utopian if equal)
+        c_N = normalize(c_F, c_ideal, c_nadir)
+
+        # normalize all previous generations with respect to current ideal and nadir
+        N = [normalize(e["F"], c_ideal, c_nadir) for e in history]
+
+        # calculate the delta difference for each previous ideal and nadir point to current
+        delta_ideal = [calc_delta_norm(history[k]["ideal"], history[k - 1]["ideal"], norm) for k in
+                       range(1, len(history))] + [0.0]
+        delta_nadir = [calc_delta_norm(history[k]["nadir"], history[k - 1]["nadir"], norm) for k in
+                       range(1, len(history))] + [0.0]
+
+        # now calculate the indicator from each previous one to the current
+        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:
+            raise Exception("Unknown indicator.")
+
+        self.delta_ideal, self.delta_nadir, self.delta_f = delta_ideal, delta_nadir, delta_f
+
+
+class RunningMetricAnimation(AnimationCallback):
+
+    def __init__(self,
+                 delta_gen,
+                 n_plots=4,
+                 key_press=True,
+                 **kwargs) -> None:
+
+        super().__init__(**kwargs)
+        self.running = RunningMetric()
+        self.delta_gen = delta_gen
+        self.key_press = key_press
+        self.data = SlidingWindow(n_plots)
+
+    def draw(self, data, ax):
+
+        for tau, x, f, v in data[:-1]:
+            ax.plot(x, f, label="t=%s" % tau, alpha=0.6, linewidth=3)
+
+        tau, x, f, v = data[-1]
+        ax.plot(x, f, label="t=%s (*)" % tau, alpha=0.9, linewidth=3)
+
+        for k in range(len(v)):
+            if v[k]:
+                ax.plot([k + 1, k + 1], [0, f[k]], color="black", linewidth=0.5, alpha=0.5)
+                ax.plot([k + 1], [f[k]], "o", color="black", alpha=0.5, markersize=2)
+
+        ax.set_yscale("symlog")
+        ax.legend()
+
+        ax.set_xlabel("Generation")
+        ax.set_ylabel("$\Delta \, f$", rotation=0)
+
+    def do(self, _, algorithm, force_plot=False, **kwargs):
+        running = self.running
+
+        # update the running metric to have the most recent information
+        running.update(algorithm)
+
+        tau = algorithm.n_gen
+
+        if (tau > 0 and tau % self.delta_gen == 0) or force_plot:
+
+            f = running.delta_f
+            x = np.arange(len(f)) + 1
+            v = [max(ideal, nadir) > 0.005 for ideal, nadir in zip(running.delta_ideal, running.delta_nadir)]
+            self.data.append((tau, x, f, v))
+
+            fig, ax = plt.subplots()
+            self.draw(self.data, ax)
+
+            if self.key_press:
+                def press(event):
+                    if event.key == 'q':
+                        algorithm.termination.force_termination = True
+
+                fig.canvas.mpl_connect('key_press_event', press)
+
+                plt.draw()
+                plt.waitforbuttonpress()
+                plt.close('all')

pymoo/util/sliding_window.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+
+class SlidingWindow(list):
+
+    def __init__(self, size=None) -> None:
+        super().__init__()
+        self.size = size
+
+    def append(self, entry):
+        super().append(entry)
+
+        if self.size is not None:
+            while len(self) > self.size:
+                self.pop(0)
+
+    def is_full(self):
+        return self.size == len(self)
+
+    def to_numpy(self):
+        return np.array(self)
+
+    def clear(self):
+        while len(self) > 0:
+            self.pop()

pymoo/util/stochastic_ranking.py

@@ -0,0 +1,32 @@
+from pymoo.util.misc import swap
+
+import numpy as np
+
+
+def stochastic_ranking(f, phi, pr, I=None):
+    _lambda = len(f)
+
+    if I is None:
+        I = np.arange(_lambda)
+
+    for i in range(_lambda):
+
+        at_least_one_swap = False
+
+        for j in range(_lambda - 1):
+
+            u = np.random.random()
+
+            if u < pr or (phi[I[j]] == 0 and phi[I[j + 1]] == 0):
+                if f[I[j]] > f[I[j + 1]]:
+                    swap(I, j, j + 1)
+                    at_least_one_swap = True
+            else:
+                if phi[I[j]] > phi[I[j + 1]]:
+                    swap(I, j, j + 1)
+                    at_least_one_swap = True
+
+        if not at_least_one_swap:
+            break
+
+    return I