pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/util/ref_dirs/optimizer.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+
+class Optimizer:
+
+    def __init__(self, precision=1e-6) -> None:
+        super().__init__()
+        self.has_converged = False
+        self.precision = precision
+
+    def next(self, X, dX):
+        _X = self._next(X, dX)
+
+        if np.abs(_X - X).mean() < self.precision:
+            self.has_converged = True
+
+        return _X
+
+
+class GradientDescent(Optimizer):
+
+    def __init__(self, learning_rate=0.01, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.learning_rate = learning_rate
+
+    def _next(self, X, dX):
+        return X - self.learning_rate * dX
+
+
+class Adam(Optimizer):
+
+    def __init__(self, alpha=0.01, beta_1=0.9, beta_2=0.999, epsilon=1e-8, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self.alpha = alpha
+        self.beta_1 = beta_1
+        self.beta_2 = beta_2
+        self.epsilon = epsilon
+
+        self.m_t = 0
+        self.v_t = 0
+        self.t = 0
+
+    def _next(self, X, dX):
+        self.t += 1
+        beta_1, beta_2 = self.beta_1, self.beta_2
+
+        # update moving average of gradient and squared gradient
+        self.m_t = beta_1 * self.m_t + (1 - beta_1) * dX
+        self.v_t = beta_2 * self.v_t + (1 - beta_2) * (dX * dX)
+
+        # calculates the bias-corrected estimates
+        m_cap = self.m_t / (1 - (beta_1 ** self.t))
+        v_cap = self.v_t / (1 - (beta_2 ** self.t))
+
+        # do the gradient update
+        _X = X - (self.alpha * m_cap) / (np.sqrt(v_cap) + self.epsilon)
+
+        return _X

pymoo/util/ref_dirs/performance.py

@@ -0,0 +1,162 @@
+import numpy as np
+import numpy as np
+from scipy.spatial.qhull import Delaunay
+from scipy.stats import gmean
+
+from pymoo.util.misc import distance_of_closest_points_to_others, vectorized_cdist, cdist
+from pymoo.util.ref_dirs.das_dennis import DasDennis
+from pymoo.util.reference_direction import get_partition_closest_to_points
+
+
+def distance_of_closest_point(ref_dirs):
+    _, dist = distance_of_closest_points_to_others(ref_dirs)
+    return dist.min()
+
+
+def average_distance_to_other_points(ref_dirs):
+    D = vectorized_cdist(ref_dirs, ref_dirs)
+    D = D[np.triu_indices(len(ref_dirs), 1)]
+    return D.mean()
+
+
+def closest_point_variance(z):
+    for row in np.eye(z.shape[1]):
+        if not np.any(np.all(row == z, axis=1)):
+            z = np.vstack([z, row])
+
+    D = vectorized_cdist(z, z)
+    np.fill_diagonal(D, 1)
+
+    return D.min(axis=1).var()
+
+
+def closest_point_variance_mod(z):
+    n_points, n_dim = z.shape
+
+    for row in np.eye(z.shape[1]):
+        if not np.any(np.all(row == z, axis=1)):
+            z = np.vstack([z, row])
+
+    D = vectorized_cdist(z, z)
+    np.fill_diagonal(D, np.inf)
+
+    k = int(np.ceil(np.sqrt(n_dim)))
+    I = D.argsort(axis=1)[:, k - 1]
+
+    return D[np.arange(n_points), I].var()
+
+
+def geometric_mean_var(z):
+    for row in np.eye(z.shape[1]):
+        if not np.any(np.all(row == z, axis=1)):
+            z = np.vstack([z, row])
+    n_points, n_dim = z.shape
+
+    D = vectorized_cdist(z, z)
+    np.fill_diagonal(D, np.inf)
+
+    k = n_dim - 1
+    I = D.argsort(axis=1)[:, :k]
+
+    first = np.column_stack([np.arange(n_points) for _ in range(k)])
+
+    val = gmean(D[first, I], axis=1)
+
+    return val.var()
+
+
+def mean_mean(z):
+    for row in np.eye(z.shape[1]):
+        if not np.any(np.all(row == z, axis=1)):
+            z = np.vstack([z, row])
+    n_points, n_dim = z.shape
+
+    D = vectorized_cdist(z, z)
+    np.fill_diagonal(D, np.inf)
+
+    k = n_dim - 1
+    I = D.argsort(axis=1)[:, :k]
+
+    first = np.column_stack([np.arange(n_points) for _ in range(k)])
+
+    val = np.mean(D[first, I], axis=1)
+
+    return val.mean()
+
+
+def potential_energy(x):
+    _x = x / x.sum(axis=1)[:, None]
+    D = ((_x[:, None] - _x[None, :]) ** 2).sum(axis=2)
+    D = D[np.triu_indices(len(_x), 1)]
+    return (1 / D).mean()
+
+
+def iterative_igd(X, n_partitions=None, batch_size=100):
+    n_points, n_dim = X.shape
+
+    if n_partitions is None:
+        n_partitions = get_partition_closest_to_points(n_points * n_dim * 10, n_dim) + 1
+
+    scaling = 1 + 1 / 2
+
+    dd = DasDennis(n_partitions, n_dim, scaling=scaling)
+    val = 0
+
+    while dd.has_next():
+        points = dd.next(n_points=batch_size)
+        val += cdist(points, X).min(axis=1).sum()
+
+    val /= dd.number_of_points()
+    return val
+
+
+def gram_schmidt(X, row_vecs=True, norm=True):
+    if not row_vecs:
+        X = X.T
+    Y = X[0:1, :].copy()
+    for i in range(1, X.shape[0]):
+        proj = np.diag((X[i, :].dot(Y.T) / np.linalg.norm(Y, axis=1) ** 2).flat).dot(Y)
+        Y = np.vstack((Y, X[i, :] - proj.sum(0)))
+    if norm:
+        Y = np.diag(1 / np.linalg.norm(Y, axis=1)).dot(Y)
+    if row_vecs:
+        return Y
+    else:
+        return Y.T
+
+
+def triangulation(X):
+    return simplex_edge_difference(project_onto_one_dim_less(X))
+
+
+def project_onto_one_dim_less(X):
+    E = np.eye(X.shape[1])
+    P = E[0]
+    D = E[1:] - P
+    O = gram_schmidt(D)
+    return (X - P) @ O.T
+
+
+def simplex_edge_difference(X):
+    tri = Delaunay(X, qhull_options="QJ")
+
+    simplices = []
+    for e in tri.simplices:
+        diff = X[e[1:]] - X[e[0]]
+        det = np.linalg.det(diff)
+        if det > 1e-6:
+            simplices.append(e)
+
+    val = []
+    for triangle in simplices:
+        dists = np.zeros(len(triangle))
+
+        for i in range(len(triangle)):
+            a, b = triangle[i], triangle[(i + 1) % len(triangle)]
+            dists[i] = np.linalg.norm(X[a] - X[b])
+
+        val.append(dists.max() - dists.min())
+
+    val = np.array(val)
+
+    return val.mean()

pymoo/util/ref_dirs/reduction.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+
+from pymoo.util.misc import cdist
+
+from pymoo.util.ref_dirs.misc import project_onto_unit_simplex_recursive
+from pymoo.util.reference_direction import ReferenceDirectionFactory, sample_on_unit_simplex, \
+    select_points_with_maximum_distance, get_partition_closest_to_points, UniformReferenceDirectionFactory
+
+
+def kmeans(X, centroids, n_max_iter, a_tol, n_ignore):
+
+    for i in range(n_max_iter):
+
+        # copy the old centroids
+        last_centroids = np.copy(centroids)
+
+        # assign all points to one of the centroids
+        points_to_centroid = cdist(X, centroids).argmin(axis=1)
+
+        centroids_to_points = [[] for _ in range(len(centroids))]
+        for j, k in enumerate(points_to_centroid):
+            centroids_to_points[k].append(j)
+
+        for j in range(n_ignore, len(centroids_to_points)):
+            centroids[j] = np.mean(X[centroids_to_points[j]], axis=0)
+
+        project_onto_unit_simplex_recursive(centroids)
+        centroids /= centroids.sum(axis=1)[:, None]
+
+        delta = np.abs(centroids - last_centroids).sum(axis=1).mean()
+
+        if delta < a_tol:
+            break
+
+    return centroids
+
+
+class ReductionBasedReferenceDirectionFactory(ReferenceDirectionFactory):
+
+    def __init__(self,
+                 n_dim,
+                 n_points,
+                 scaling=None,
+                 n_sample_points=10000,
+                 sampling="kraemer",
+                 kmeans=True,
+                 kmeans_max_iter=1000,
+                 kmeans_a_tol=0.0001,
+                 **kwargs):
+
+        super().__init__(n_dim, scaling, **kwargs)
+        self.n_sample_points = n_sample_points
+        self.sampling = sampling
+        self.kmeans = kmeans
+        self.kmeans_max_iter = kmeans_max_iter
+        self.kmeans_a_tol = kmeans_a_tol
+
+        if n_points is None:
+            raise Exception("Please provide the number of points to be factored!")
+
+        self.n_points = n_points
+
+    def _do(self, random_state=None):
+        rnd = sample_on_unit_simplex(self.n_sample_points, self.n_dim, random_state=random_state, unit_simplex_mapping=self.sampling)
+
+        def h(n):
+            return get_partition_closest_to_points(n, self.n_dim)
+
+        H = h(self.n_points)
+
+        E = UniformReferenceDirectionFactory(self.n_dim, n_partitions=H).do()
+        E = E[np.any(E == 0, axis=1)]
+
+        # add the edge coordinates
+        X = np.vstack([E, rnd])
+
+        I = select_points_with_maximum_distance(X, self.n_points, selected=list(range((len(E)))))
+        centroids = X[I].copy()
+
+        if self.kmeans:
+            #centroids = kmeans(X, centroids, self.kmeans_max_iter, self.kmeans_a_tol, 0)
+            centroids = kmeans(X, centroids, self.kmeans_max_iter, self.kmeans_a_tol, len(E))
+
+        return centroids

pymoo/util/ref_dirs/sample_and_map.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.operators.sampling.lhs import LatinHypercubeSampling
+from pymoo.util.reference_direction import ReferenceDirectionFactory, map_onto_unit_simplex
+
+
+class RandomSamplingAndMap(ReferenceDirectionFactory):
+
+    def __init__(self,
+                 n_dim,
+                 n_points,
+                 **kwargs):
+        super().__init__(n_dim, **kwargs)
+        self.n_points = n_points
+
+    def _do(self, random_state=None):
+        problem = Problem(n_var=self.n_dim, xl=0.0, xu=1.0)
+        sampling = LatinHypercubeSampling()
+
+        x = sampling(problem, self.n_points - self.n_dim, to_numpy=True, random_state=random_state)
+        x = map_onto_unit_simplex(x, "kraemer")
+        x = np.vstack([x, np.eye(self.n_dim)])
+        return x

pymoo/util/reference_direction.py

@@ -0,0 +1,258 @@
+import sys
+
+import numpy as np
+from scipy import special
+
+from pymoo.util.misc import find_duplicates, cdist
+from pymoo.util import default_random_state
+
+
+# =========================================================================================================
+# 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, **kwargs) -> None:
+        super().__init__()
+        self.n_dim = n_dim
+        self.scaling = scaling
+        self.lexsort = lexsort
+        self.verbose = verbose
+
+    def __call__(self):
+        return self.do()
+
+    @default_random_state(seed=1)
+    def do(self, random_state=None):
+
+        if self.n_dim == 1:
+            return np.array([[1.0]])
+        else:
+
+            val = self._do(random_state=random_state)
+            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, random_state=None):
+        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, random_state=None):
+        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
+# =========================================================================================================
+
+@default_random_state
+def get_rng(random_state=None, **kwargs):
+    return random_state
+
+
+@default_random_state
+def sample_on_unit_simplex(n_points, n_dim, unit_simplex_mapping="kraemer", random_state=None, **kwargs):
+    if unit_simplex_mapping == "sum":
+        rnd = map_onto_unit_simplex(random_state.random((n_points, n_dim)), "sum")
+
+    elif unit_simplex_mapping == "kraemer":
+        rnd = map_onto_unit_simplex(random_state.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=[], random_state=None):
+    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:
+        # random_state should be provided by caller
+        selected = [random_state.integers(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,29 @@
+import numpy as np
+from pymoo.util import default_random_state
+
+
+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))])
+
+    @default_random_state
+    def next(self, n=None, random_state=None):
+        if n is None:
+            X = random_state.random((1, 1))
+        else:
+            X = random_state.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