pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/util/ref_dirs/energy.py

@@ -0,0 +1,317 @@
+import numpy as np
+
+from pymoo.gradient.grad_autograd import triu_indices, sqrt, log
+from pymoo.util.ref_dirs.construction import ConstructionBasedReferenceDirectionFactory
+from pymoo.util.ref_dirs.misc import project_onto_sum_equals_zero_plane, project_onto_unit_simplex_recursive
+from pymoo.util.ref_dirs.optimizer import Adam
+from pymoo.util.ref_dirs.reduction import ReductionBasedReferenceDirectionFactory
+from pymoo.util.reference_direction import ReferenceDirectionFactory, scale_reference_directions
+
+
+class RieszEnergyReferenceDirectionFactory(ReferenceDirectionFactory):
+
+    def __init__(self,
+                 n_dim,
+                 n_points,
+                 ref_points=None,
+                 return_as_tuple=False,
+                 n_max_iter=1000,
+                 n_until_optimizer_reset=30,
+                 sampling="reduction",
+                 norm_gradients=True,
+                 verify_gradient=False,
+                 freeze_edges=False,
+                 precision=1e-5,
+                 restarts=True,
+                 X=None,
+                 d=None,
+                 callback=None,
+                 **kwargs):
+
+        super().__init__(n_dim, **kwargs)
+
+        self.n_points = n_points
+        self.n_max_iter = n_max_iter
+        self.n_max_not_improved = n_until_optimizer_reset
+        self.return_as_tuple = return_as_tuple
+        self.sampling = sampling
+        self.X = X
+        self.ref_points = ref_points
+        self.precision = precision
+        self.verify_gradient = verify_gradient
+        self.norm_gradients = norm_gradients
+        self.freeze_edges = freeze_edges
+        self.d = d
+        self.callback = callback
+        self.restarts = restarts
+
+        # experiments have shown that dimensions squared is good value to choose here
+        if self.d is None:
+            self.d = n_dim * 2
+
+    def _step(self, optimizer, X, freeze=None):
+        free = np.logical_not(freeze)
+
+        obj, grad, mutual_dist = calc_potential_energy_with_grad(X, self.d, return_mutual_dist=True)
+        # obj, grad = value_and_grad(calc_potential_energy)(X, self.d)
+
+        if self.verify_gradient:
+            from autograd import value_and_grad
+            obj, grad = calc_potential_energy_with_grad(X, self.d)
+            _obj, _grad = value_and_grad(calc_potential_energy)(X, self.d)
+            if np.abs(grad - _grad).mean() > 1e-5:
+                print("GRADIENT IMPLEMENTATION IS INCORRECT!")
+
+        # set the gradients for frozen points to zero - make them not to move
+        if freeze is not None:
+            grad[freeze] = 0
+
+        # project the gradient to have a sum of zero - guarantees to stay on the simplex
+        proj_grad = project_onto_sum_equals_zero_plane(grad)
+
+        # normalize the gradients by the largest gradient norm
+        if self.norm_gradients:
+            norm = np.linalg.norm(proj_grad, axis=1)
+            proj_grad = (proj_grad / max(norm.max(), 1e-24))
+
+        # apply a step of gradient descent by subtracting the projected gradient with a learning rate
+        X = optimizer.next(X, proj_grad)
+
+        # project the out of bounds points back onto the unit simplex
+        X[free] = project_onto_unit_simplex_recursive(X[free])
+
+        # because of floating point issues make sure it is on the unit simplex
+        X /= X.sum(axis=1)[:, None]
+
+        return X, obj
+
+    def _solve(self, X, F=None, freeze_edges=True):
+        n_points = len(X)
+        ret, obj = X, np.inf
+        n_not_improved = 0
+
+        # get the edge mask
+        if freeze_edges:
+            freeze = np.any(X < 1e-16, axis=1)
+        else:
+            freeze = np.full(len(X), False)
+
+        # if additional points to be frozen are provided - add them to the X and mark them as frozen
+        if F is not None:
+            X = np.vstack([X, F])
+            freeze = np.concatenate([freeze, np.full(len(F), True)])
+
+        # if all points are frozen - simply return it
+        if np.all(freeze):
+            return X
+
+        # initialize the optimizer for the run
+        self.optimizer = Adam(alpha=0.005)
+
+        if self.callback is not None:
+            self.callback(self, X)
+
+        # for each iteration of gradient descent
+        for i in range(self.n_max_iter):
+
+            # execute one optimization step
+            _X, _obj = self._step(self.optimizer, X, freeze=freeze)
+
+            # if it is the current best solution -> store it
+            if _obj < obj:
+                ret, obj, n_not_improved = _X, _obj, 0
+            else:
+                n_not_improved += 1
+
+            # evaluate how much the points have moved
+            delta = np.sqrt((_X[:n_points] - X[:n_points]) ** 2).mean(axis=1).mean()
+
+            if self.verbose:
+                print(i, "objective", _obj, "delta", delta)
+
+            # if there was only a little delta during the last iteration -> terminate
+            if delta < self.precision or np.isnan(_obj):
+                break
+
+            # reset the optimizer if the objective value has not improved x iterations
+            if self.restarts and n_not_improved > self.n_max_not_improved:
+                self.optimizer = Adam(alpha=self.optimizer.alpha / 2)
+                _X = ret
+                n_not_improved = 0
+
+            # otherwise use the new points for the next iteration
+            X = _X
+
+            if self.callback is not None:
+                self.callback(self, X)
+
+        return ret[:n_points]
+
+    def _do(self, random_state=None):
+        X = self.X
+
+        # if no initial points are provided by the user
+        if X is None:
+            if self.sampling == "reduction":
+                X = ReductionBasedReferenceDirectionFactory(self.n_dim,
+                                                            self.n_points,
+                                                            kmeans=True,
+                                                            lexsort=False) \
+                    .do(random_state=random_state)
+
+            elif self.sampling == "construction":
+                X = ConstructionBasedReferenceDirectionFactory(self.n_dim,
+                                                               self.n_points) \
+                    .do(random_state=random_state)
+            else:
+                raise Exception("Unknown sampling method. Either reduction or construction.")
+
+        X = self._solve(X, freeze_edges=self.freeze_edges)
+
+        if self.ref_points is not None:
+            X, R = self.calc_ref_points(X, self.ref_points)
+
+            if self.return_as_tuple:
+                return X, R
+            else:
+                return np.vstack([X, R])
+
+        return X
+
+    def calc_ref_points(self, X, ref_points):
+        n_points = len(X)
+
+        # the center needed for translations
+        centroid = np.full((1, self.n_dim), 1 / self.n_dim)
+
+        R = []
+
+        # for each reference point provided by the user
+        for entry in ref_points:
+            ref_point, n_points_of_ref = entry.get("coordinates"), entry.get("n_points")
+            scale, volume = entry.get("scale"), entry.get("volume")
+
+            if scale is None:
+                if volume is None:
+                    raise Exception("Either define scale or volume!")
+                else:
+                    scale = volume ** (self.n_dim - 1)
+
+            # retrieve all points to consider
+            _X = np.vstack([X] + R)
+
+            # translate X to make the simplex to fill the unit
+            v = centroid - ref_point
+            X_t = _X + v
+            X_t = scale_reference_directions(X_t, 1 / scale)
+
+            # find the indices of points which are used as edges
+            I = np.where(np.any(X_t < 1e-5, axis=1))[0]
+
+            # create new points in the simplex where reference directions are supposed to be optimized
+            _n_points = n_points_of_ref + (n_points - len(I))
+            _R = ReductionBasedReferenceDirectionFactory(self.n_dim, n_points=_n_points, kmeans=True,
+                                                         lexsort=False).do()
+
+            # detect the edges and just optimize them and shrink later
+            outer = np.any(_R == 0, axis=1)
+            inner = ~outer
+
+            # rescale the reference directions to be not too close to existing points
+            _R = scale_reference_directions(_R, 0.9)
+
+            # optimize just the edges
+            _R[outer] = self._solve(_R[outer], F=np.vstack([X_t[I], _R[inner]]), freeze_edges=False)
+
+            # no set the reference point and freeze it
+            # closest_to_centroid = cdist(centroid, _R).argmin()
+            # outer[closest_to_centroid] = True
+            # inner[closest_to_centroid] = False
+            # _R[closest_to_centroid] = centroid
+
+            # now when translated the reference point becomes the centroid - fix that point to be included
+            _R[inner] = self._solve(_R[inner], F=np.vstack([X_t[I], _R[outer]]), freeze_edges=False)
+
+            # rescale and translate them back
+            _R_t = scale_reference_directions(_R, scale)
+            _R_t = _R_t - v
+
+            # if any point is out of bounds - volume was too large
+            if not np.all(_R_t >= 0):
+
+                # get the corner points if not transformed
+                V = (np.eye(self.n_dim) - centroid)
+
+                # get the corner points of the ref dir simplex
+                P = ref_point + scale * V
+                E = centroid + scale * V
+
+                # project because at least is out of points
+                P_proj = project_onto_unit_simplex_recursive(np.copy(P))
+
+                for i in range(len(P)):
+
+                    if not np.all(P[i] == P_proj[i]):
+                        _R_t = scale_reference_directions(_R, scale)
+                        _R_t = _R_t - (E[i] - P_proj[i])
+
+                        if np.all(_R_t >= 0):
+                            break
+
+            n_points += n_points_of_ref
+            R.append(_R_t)
+
+            # filter out points from to be removed from the original array
+            X = X[[i for i in I if i < len(X)]]
+
+        R = np.vstack(R)
+
+        return X, R
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Energy Functions
+# ---------------------------------------------------------------------------------------------------------
+
+
+def squared_dist(A, B):
+    return ((A[:, None] - B[None, :]) ** 2).sum(axis=2)
+
+
+def calc_potential_energy(A, d):
+    i, j = triu_indices(len(A), 1)
+    D = sqrt(squared_dist(A, A)[i, j])
+    energy = log((1 / D ** d).mean())
+    return energy
+
+
+def calc_potential_energy_with_grad(x, d, return_mutual_dist=False):
+    diff = (x[:, None] - x[None, :])
+    # calculate the squared euclidean from each point to another
+    dist = np.sqrt((diff ** 2).sum(axis=2))
+
+    # make sure the distance to itself does not count
+    np.fill_diagonal(dist, np.inf)
+
+    # epsilon which is the smallest distance possible to avoid an overflow during gradient calculation
+    eps = 10 ** (-320 / (d + 2))
+    b = dist < eps
+    dist[b] = eps
+
+    # select only upper triangular matrix to have each mutual distance once
+    mutual_dist = dist[np.triu_indices(len(x), 1)]
+
+    # calculate the energy by summing up the squared distances
+    energy = (1 / mutual_dist ** d).sum()
+    log_energy = - np.log(len(mutual_dist)) + np.log(energy)
+
+    # calculate the gradient
+    grad = (-d * diff) / (dist ** (d + 2))[..., None]
+    grad = np.sum(grad, axis=1)
+    grad /= energy
+
+    ret = [log_energy, grad]
+    if return_mutual_dist:
+        ret.append(mutual_dist)
+
+    return tuple(ret)

pymoo/util/ref_dirs/energy_layer.py

@@ -0,0 +1,119 @@
+
+
+import numpy as np
+
+from pymoo.gradient.grad_autograd import value_and_grad, triu_indices, row_stack
+from pymoo.util.normalization import normalize
+from pymoo.util.ref_dirs.energy import squared_dist
+from pymoo.util.ref_dirs.optimizer import Adam
+from pymoo.util.reference_direction import ReferenceDirectionFactory, scale_reference_directions
+
+
+class LayerwiseRieszEnergyReferenceDirectionFactory(ReferenceDirectionFactory):
+
+    def __init__(self,
+                 n_dim,
+                 partitions,
+                 return_as_tuple=False,
+                 n_max_iter=1000,
+                 verbose=False,
+                 X=None,
+                 **kwargs):
+
+        super().__init__(n_dim, **kwargs)
+        self.scalings = None
+        self.n_max_iter = n_max_iter
+        self.verbose = verbose
+        self.return_as_tuple = return_as_tuple
+        self.X = X
+        self.partitions = partitions
+
+    def _step(self, optimizer, X, scalings):
+        obj, grad = value_and_grad(calc_potential_energy)(scalings, X)
+        scalings = optimizer.next(scalings, np.array(grad))
+        scalings = normalize(scalings, xl=0, xu=scalings.max())
+        return scalings, obj
+
+    def _solve(self, X, scalings):
+
+        # initialize the optimizer for the run
+        optimizer = Adam()
+
+        # for each iteration of gradient descent
+        for i in range(self.n_max_iter):
+
+            # execute one optimization step
+            _scalings, _obj = self._step(optimizer, X, scalings)
+
+            # evaluate how much the points have moved
+            delta = np.abs(_scalings - scalings).sum()
+
+            if self.verbose:
+                print(i, "objective", _obj, "delta", delta)
+
+            # if there was only a little delta during the last iteration -> terminate
+            if delta < 1e-5:
+                scalings = _scalings
+                break
+
+            # otherwise use the new points for the next iteration
+            scalings = _scalings
+
+        self.scalings = scalings
+        return get_points(X, scalings)
+
+    def do(self, **kwargs):
+
+        X = []
+        scalings = []
+
+        for k, p in enumerate(self.partitions):
+
+            if p > 1:
+                val = np.linspace(0, 1, p + 1)[1:-1]
+                _X = []
+                for i in range(self.n_dim):
+                    for j in range(i + 1, self.n_dim):
+                        x = np.zeros((len(val), self.n_dim))
+                        x[:, i] = val
+                        x[:, j] = 1 - val
+                        _X.append(x)
+
+                X.append(np.vstack(_X + [np.eye(self.n_dim)]))
+
+            elif p == 1:
+                X.append(np.eye(self.n_dim))
+            else:
+                X.append(np.full(self.n_dim, 1 / self.n_dim)[None, :])
+
+            scalings.append(1 - k / len(self.partitions))
+
+        scalings = np.array(scalings)
+        X = self._solve(X, scalings)
+
+        return X
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Energy Functions
+# ---------------------------------------------------------------------------------------------------------
+
+
+def get_points(X, scalings):
+    vals = []
+    for i in range(len(X)):
+        vals.append(scale_reference_directions(X[i], scalings[i]))
+    X = row_stack(vals)
+    return X
+
+
+def calc_potential_energy(scalings, X):
+    X = get_points(X, scalings)
+
+    i, j = triu_indices(len(X), 1)
+    D = squared_dist(X, X)[i, j]
+
+    if np.any(D < 1e-12):
+        return np.nan, np.nan
+
+    return (1 / D).mean()

pymoo/util/ref_dirs/genetic_algorithm.py

@@ -0,0 +1,64 @@
+from pymoo.algorithms.soo.nonconvex.ga import GA
+from pymoo.core.problem import Problem
+from pymoo.optimize import minimize
+from pymoo.util.reference_direction import get_partition_closest_to_points, ReferenceDirectionFactory
+
+
+class ReferenceDirectionGA(ReferenceDirectionFactory):
+
+    def __init__(self,
+                 n_dim,
+                 n_points,
+                 fun,
+                 pop_size=20,
+                 n_gen=200,
+                 verbose=False,
+                 **kwargs):
+
+        super().__init__(n_dim, **kwargs)
+
+        self.n_points = n_points
+        self.pop_size = pop_size
+        self.n_gen = n_gen
+
+        self.fun = fun
+        self.verbose = verbose
+
+    def _do(self, random_state=None):
+        pop_size, n_gen = self.pop_size, self.n_gen
+        n_points, n_dim, = self.n_points, self.n_dim
+        fun = self.fun
+
+        class MyProblem(Problem):
+
+            def __init__(self):
+                self.n_points = n_points
+                self.n_dim = n_dim
+                self.n_partitions = get_partition_closest_to_points(n_points, n_dim)
+
+                super().__init__(n_var=n_points * n_dim,
+                                 n_obj=1,
+                                 xl=0.0,
+                                 xu=1.0,
+                                 elementwise_evaluation=True)
+
+            def get_points(self, x):
+                _x = x.reshape((self.n_points, self.n_dim)) ** 2
+                _x = _x / _x.sum(axis=1)[:, None]
+                return _x
+
+            def _evaluate(self, x, out, *args, **kwargs):
+                out["F"] = fun(self.get_points(x))
+
+        problem = MyProblem()
+
+        algorithm = GA(pop_size=pop_size, eliminate_duplicates=True)
+
+        res = minimize(problem,
+                       algorithm,
+                       termination=('n_gen', n_gen),
+                       random_state=random_state,
+                       verbose=True)
+
+        ref_dirs = problem.get_points(res.X)
+        return ref_dirs

pymoo/util/ref_dirs/incremental.py

@@ -0,0 +1,69 @@
+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, **kwargs):
+        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