pymoo 0.6.1.5.dev0__cp310-cp310-macosx_11_0_arm64.whl

pymoo/util/ref_dirs/incremental.py

@@ -0,0 +1,68 @@
+import numpy as np
+
+from pymoo.util.reference_direction import ReferenceDirectionFactory
+
+def check_n_points(n_points, n_dim):
+    """
+    Returns n_partitions or a numeric value associated with the exception message.
+    """
+
+    if n_dim == 1:
+        return [0]
+    
+    I = n_dim * np.eye(n_dim)
+    W = np.zeros((1, n_dim))
+    edgeW = W
+    i = 0
+
+    while len(W) < n_points:
+        edgeW = np.tile(edgeW, (n_dim, 1)) + np.repeat(I, edgeW.shape[0], axis=0)
+        edgeW = np.unique(edgeW, axis=0)
+        edgeW = edgeW [np.any(edgeW == 0, axis=1)]
+        W = np.vstack((W + 1, edgeW))
+        i += 1
+
+    if len(W) == n_points:
+        return [i]
+    
+    return  [len(W) - len(edgeW), i - 1, len(W), i]
+
+
+def incremental_lattice(n_partitions, n_dim):
+    I = n_dim * np.eye(n_dim)
+    W = np.zeros((1, n_dim))
+    edgeW = W
+
+    for _ in range(n_partitions):
+        edgeW = np.tile(edgeW, (n_dim, 1)) + np.repeat(I, edgeW.shape[0], axis=0)
+        edgeW = np.unique(edgeW, axis=0)
+        edgeW = edgeW [np.any(edgeW == 0, axis=1)]
+        W = np.vstack((W + 1, edgeW))
+
+    return W / (n_dim * n_partitions)
+
+class IncrementalReferenceDirectionFactory(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:
+            results = check_n_points(n_points, n_dim)
+
+            # the number of points are not matching to any partition number
+            if len(results) > 1:
+                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[0], results[1], results[2], results[3]))
+
+            self.n_partitions = results[0]
+
+        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 incremental_lattice(self.n_partitions, self.n_dim)

pymoo/util/ref_dirs/misc.py

@@ -0,0 +1,128 @@
+import numpy as np
+
+
+def project_onto(y, p, n):
+    """
+
+    Project a point onto a plane.
+
+    Parameters
+    ----------
+    y : The point that should be project
+    p : A point which lies on the plane
+    n : The normal vector of the plane
+
+    Returns
+    -------
+
+    proj_y : The projection onto the plane
+
+    """
+
+    is_1d = False
+    if len(y.shape) == 1:
+        is_1d = True
+        y = np.atleast_2d(y)
+
+    # make sure the plane vector is normalized
+    n = n / np.linalg.norm(n)
+
+    proj_y = y - n[None, :] * ((y - p) @ n)[:, None]
+
+    if is_1d:
+        proj_y = proj_y[0]
+
+    return proj_y
+
+
+def project_onto_sum_equals_one_plane(y):
+    n_dim = y.shape[-1]
+    return project_onto(y, np.eye(n_dim)[0], np.ones(n_dim))
+
+
+def project_onto_sum_equals_zero_plane(y):
+    n_dim = y.shape[-1]
+    return project_onto(y, np.zeros(n_dim), np.ones(n_dim))
+
+
+def project_onto_unit_simplex(X):
+    n_points, n_dim = X.shape
+
+    # a boolean mask of violating values - less than 0
+    I = X < 0
+
+    # get all the points which are out of bounds and need to be fixed
+    out_of_unit_simplex = np.where(I.sum(axis=1) > 0)[0]
+
+    # now check for each point if it is still in bound
+    for j in out_of_unit_simplex:
+
+        # indices where the last point was already out of bounds
+        subspace = np.logical_not(I[j])
+
+        # project the bounds back onto the simplex in the subspace
+        proj = np.zeros(n_dim)
+        proj[subspace] = project_onto_sum_equals_one_plane(X[j][subspace])
+
+        # set the result to the corresponding value
+        X[j] = proj
+
+        test1 = matrix_project_onto_sum_equals_one_plane(X[j][subspace])
+        test2 = project_onto_sum_equals_one_plane(X[j][subspace])
+
+        if not np.allclose(test1, test2):
+            print("test")
+
+        if np.any(X[j] < 0):
+            print("test")
+
+
+def project_onto_unit_simplex_recursive(X):
+    # get all the points which are out of bounds and need to be fixed
+    out_of_unit_simplex = np.where(np.any(X < 0, axis=1))[0]
+
+    # now check for each point if it is still in bound
+    for j in out_of_unit_simplex:
+
+        while True:
+            X[j, X[j] < 0] = 0
+
+            # indices where the last point was already out of bounds
+            subspace = X[j] > 0
+
+            # project the bounds back onto the simplex in the subspace
+            X[j, subspace] = project_onto_sum_equals_one_plane(X[j][subspace])
+
+            if np.all(X[j] >= 0):
+                break
+
+    return X
+
+
+def matrix_project_onto_sum_equals_one_plane(next):
+    n_dim = len(next)
+    P, S = np.eye(n_dim)[0], next
+
+    # create for each subspace dimension a point on the hyperplane
+    points = P + np.eye(n_dim)[1:]
+    points /= points.sum(axis=1)[:, None]
+
+    v = points - P
+    s = S - P
+
+    # solve a system of linear equations to project the point
+    A = np.zeros((n_dim - 1, n_dim - 1))
+    for i in range(n_dim - 1):
+        for j in range(n_dim - 1):
+            A[i, j] = np.dot(v[i], v[j])
+
+    b = np.zeros(n_dim - 1)
+    for i in range(n_dim - 1):
+        b[i] = np.dot(s, v[i])
+
+    x = np.linalg.solve(A, b)
+
+    # finally calculate the projection onto the plane
+    proj = (P + x @ v)
+
+    return proj

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.row_stack([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.row_stack([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.row_stack([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.row_stack([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):
+        rnd = sample_on_unit_simplex(self.n_sample_points, self.n_dim, seed=self.seed, 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.row_stack([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):
+        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)
+        x = map_onto_unit_simplex(x, "kraemer")
+        x = np.row_stack([x, np.eye(self.n_dim)])
+        return x