pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/operators/repair/bounds_repair.py

@@ -0,0 +1,97 @@
+import abc
+
+import numpy as np
+
+from pymoo.core.population import Population
+from pymoo.core.repair import Repair
+from pymoo.util import default_random_state
+
+
+def is_in_bounds(X, xl, xu):
+    return np.where(np.all(np.logical_and(X >= xl, X <= xu), axis=1))[0]
+
+
+def is_in_bounds_by_problem(problem, X):
+    return is_in_bounds(X, problem.xl, problem.xu)
+
+
+def is_out_of_bounds(X, xl, xu):
+    return np.where(np.any(np.logical_or(X < xl, X > xu), axis=1))[0]
+
+
+def is_out_of_bounds_by_problem(problem, X):
+    return is_out_of_bounds(X, problem.xl, problem.xu)
+
+
+def repeat_bounds(xl, xu, n):
+    XL = np.tile(xl, (n, 1))
+    XU = np.tile(xu, (n, 1))
+    return XL, XU
+
+
+def repair_clamp(Xp, xl, xu):
+    XL, XU = repeat_bounds(xl, xu, len(Xp))
+
+    I = np.where(Xp < XL)
+    Xp[I] = XL[I]
+
+    I = np.where(Xp > XU)
+    Xp[I] = XU[I]
+
+    return Xp
+
+
+def repair_periodic(Xp, xl, xu):
+    XL, XU = repeat_bounds(xl, xu, len(Xp))
+
+    S = (XU - XL)
+
+    I = np.where(Xp < XL)
+    Xp[I] = XU[I] - (XL[I] - Xp[I]) % S[I]
+
+    I = np.where(Xp > XU)
+    Xp[I] = XL[I] + (Xp[I] - XU[I]) % S[I]
+
+    return Xp
+
+
+@default_random_state
+def repair_random_init(Xp, X, xl, xu, random_state=None):
+    XL, XU = repeat_bounds(xl, xu, len(Xp))
+
+    i, j = np.where(Xp < XL)
+    if len(i) > 0:
+        Xp[i, j] = XL[i, j] + random_state.random(len(i)) * (X[i, j] - XL[i, j])
+
+    i, j = np.where(Xp > XU)
+    if len(i) > 0:
+        Xp[i, j] = XU[i, j] - random_state.random(len(i)) * (XU[i, j] - X[i, j])
+
+    return Xp
+
+
+class BoundsRepair(Repair):
+
+    def _do(self,
+            problem,
+            pop_or_X,
+            check_out_of_bounds=True,
+            **kwargs):
+
+        is_array = not isinstance(pop_or_X, Population)
+
+        X = pop_or_X if is_array else pop_or_X.get("X")
+
+        X = self.repair_out_of_bounds(problem, X, **kwargs)
+
+        assert len(is_out_of_bounds_by_problem(problem, X)) == 0
+
+        if is_array:
+            return X
+        else:
+            pop_or_X.set("X", X)
+            return pop_or_X
+
+    @abc.abstractmethod
+    def repair_out_of_bounds(self, problem, X, **kwargs):
+        pass

pymoo/operators/repair/inverse_penalty.py

@@ -0,0 +1,91 @@
+import numpy as np
+
+from pymoo.operators.repair.bounds_repair import BoundsRepair
+from pymoo.util import default_random_state
+
+
+@default_random_state
+def inverse_penality(x, p, xl, xu, alpha=None, random_state=None):
+    assert len(p) == len(x)
+
+    normv = np.linalg.norm(p - x)
+
+    # violated boundaries
+    idl = x < xl
+    idr = xu < x
+
+    # if nothing is out of bounds just return the value
+    if not np.any(np.logical_or(idl, idr)):
+        return x
+
+    else:
+        # lower bounds of Y
+        diff = (p - x)
+        diff[diff == 0] = 1e-32
+        d = normv * np.max(np.maximum(idl * (xl - x) / diff, idr * (xu - x) / diff))
+
+        # upper bounds on Y
+        bounds = np.array([~idl * ((xl - x) / diff), ~idr * (xu - x) / diff])
+
+        D = normv * np.min(bounds[bounds > 0])
+
+        if alpha is None:
+            alpha = (normv - d) / normv
+            alpha += 1e-32
+
+        r = random_state.random()
+        Y = d * (1.0 + alpha * np.tan(r * np.arctan((D - d) / (alpha * d))))
+
+        ret = x + (p - x) * Y / normv
+
+        # for floating point error - in theory it will always be in bounds
+        ret[ret < xl] = xl[ret < xl]
+        ret[ret > xu] = xu[ret > xu]
+
+        return ret
+
+
+def inverse_penality_by_problem(problem, x, p, **kwargs):
+    return inverse_penality(x, p, problem.xl, problem.xu, **kwargs)
+
+
+class InversePenaltyOutOfBoundsRepair(BoundsRepair):
+
+    def repair_out_of_bounds(self, problem, X, P=None, **kwargs):
+        if P is None:
+            raise Exception("For this out of bounds handling a parent solution in bounds needs to be provided.")
+        assert len(X) == len(P)
+        n = len(X)
+
+        for k in range(n):
+            X[k] = inverse_penality_by_problem(problem, X[k], P[k])
+
+        return X
+
+
+if __name__ == '__main__':
+
+    # lower and upper bounds
+    xl = np.zeros(2)
+    xu = np.ones(2)
+
+    # chosen parents
+    # p = np.array([0.1, 1.0])
+    p = np.array([0.5, 0.6])
+
+    c = np.array([-0.1, 1.0])
+
+    from pymoo.visualization.matplotlib import plt
+
+    plt.scatter(p[0], p[1], color="green", label="Parent")
+    plt.scatter(c[0], c[1], color="orange", label="Offspring")
+
+    data = []
+    for j in range(200):
+        ret = inverse_penality(c, p, xl, xu, alpha=None)
+        plt.scatter(ret[0], ret[1], facecolor="none", edgecolor="red", s=10, alpha=0.6)
+
+    plt.ylim(0.0, 1.3)
+    plt.xlim(-0.2, 1)
+    plt.legend()
+    plt.show()

pymoo/operators/repair/rounding.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+from pymoo.core.repair import Repair
+
+
+class RoundingRepair(Repair):
+
+    def __init__(self, **kwargs) -> None:
+        """
+
+        Returns
+        -------
+        object
+        """
+        super().__init__(**kwargs)
+
+    def _do(self, problem, X, **kwargs):
+        return np.around(X).astype(int)

pymoo/operators/repair/to_bound.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+from pymoo.operators.repair.bounds_repair import BoundsRepair
+from pymoo.util.misc import at_least_2d_array
+
+
+def set_to_bounds_if_outside(X, xl, xu):
+    _X, only_1d = at_least_2d_array(X, return_if_reshaped=True)
+
+    if xl is not None:
+        xl = np.repeat(xl[None, :], _X.shape[0], axis=0)
+        _X[_X < xl] = xl[_X < xl]
+
+    if xu is not None:
+        xu = np.repeat(xu[None, :], _X.shape[0], axis=0)
+        _X[_X > xu] = xu[_X > xu]
+
+    if only_1d:
+        return _X[0, :]
+    else:
+        return _X
+
+
+def set_to_bounds_if_outside_by_problem(problem, X):
+    return set_to_bounds_if_outside(X, problem.xl, problem.xu)
+
+
+class ToBoundOutOfBoundsRepair(BoundsRepair):
+
+    def repair_out_of_bounds(self, problem, X, **kwargs):
+        return set_to_bounds_if_outside_by_problem(problem, X)

pymoo/operators/repair/vtype.py

@@ -0,0 +1,11 @@
+from pymoo.core.repair import Repair
+
+
+class TypeRepair(Repair):
+
+    def __init__(self, vtype) -> None:
+        super().__init__()
+        self.vtype = vtype
+
+    def _do(self, problem, X, **kwargs):
+        return X.astype(self.vtype)

pymoo/operators/sampling/lhs.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from pymoo.core.sampling import Sampling
+from pymoo.util import default_random_state
+from pymoo.util.misc import cdist
+
+
+def criterion_maxmin(X):
+    D = cdist(X, X)
+    np.fill_diagonal(D, np.inf)
+    return np.min(D)
+
+
+def criterion_corr(X):
+    M = np.corrcoef(X.T, rowvar=True)
+    return -np.sum(np.tril(M, -1) ** 2)
+
+
+@default_random_state
+def sampling_lhs(n_samples, n_var, xl=0, xu=1, smooth=True, criterion=criterion_maxmin, n_iter=50, random_state=None):
+
+    X = sampling_lhs_unit(n_samples, n_var, smooth=smooth, random_state=random_state)
+
+    # if a criterion is selected to further improve the sampling
+    if criterion is not None:
+
+        # current best score is stored here
+        score = criterion(X)
+
+        for j in range(1, n_iter):
+
+            # create new random sample and check the score again
+            _X = sampling_lhs_unit(n_samples, n_var, smooth=smooth, random_state=random_state)
+            _score = criterion(_X)
+
+            if _score > score:
+                X, score = _X, _score
+
+    return xl + X * (xu - xl)
+
+
+@default_random_state
+def sampling_lhs_unit(n_samples, n_var, smooth=True, random_state=None):
+    X = random_state.random(size=(n_samples, n_var))
+    Xp = X.argsort(axis=0) + 1
+
+    if smooth:
+        Xp = Xp - random_state.random(Xp.shape)
+    else:
+        Xp = Xp - 0.5
+    Xp /= n_samples
+    return Xp
+
+
+class LatinHypercubeSampling(Sampling):
+
+    def __init__(self,
+                 smooth=True,
+                 iterations=20,
+                 criterion=criterion_maxmin) -> None:
+        super().__init__()
+        self.smooth = smooth
+        self.iterations = iterations
+        self.criterion = criterion
+
+    def _do(self, problem, n_samples, random_state=None, **kwargs):
+        xl, xu = problem.bounds()
+
+        X = sampling_lhs(n_samples, problem.n_var, xl=xl, xu=xu, smooth=self.smooth,
+                         criterion=self.criterion, n_iter=self.iterations, random_state=random_state)
+
+        return X
+
+
+class LHS(LatinHypercubeSampling):
+    pass

pymoo/operators/sampling/rnd.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+from pymoo.core.sampling import Sampling
+from pymoo.util import default_random_state
+
+
+@default_random_state
+def random(problem, n_samples=1, random_state=None):
+    X = random_state.random((n_samples, problem.n_var))
+
+    if problem.has_bounds():
+        xl, xu = problem.bounds()
+        assert np.all(xu >= xl)
+        X = xl + (xu - xl) * X
+
+    return X
+
+
+class FloatRandomSampling(Sampling):
+
+    def _do(self, problem, n_samples, *args, random_state=None, **kwargs):
+        X = random_state.random((n_samples, problem.n_var))
+
+        if problem.has_bounds():
+            xl, xu = problem.bounds()
+            assert np.all(xu >= xl)
+            X = xl + (xu - xl) * X
+
+        return X
+
+
+class BinaryRandomSampling(Sampling):
+
+    def _do(self, problem, n_samples, *args, random_state=None, **kwargs):
+        val = random_state.random((n_samples, problem.n_var))
+        return (val < 0.5).astype(bool)
+
+
+class IntegerRandomSampling(FloatRandomSampling):
+
+    def _do(self, problem, n_samples, *args, random_state=None, **kwargs):
+        n, (xl, xu) = problem.n_var, problem.bounds()
+        return np.column_stack([random_state.integers(xl[k], xu[k] + 1, size=n_samples) for k in range(n)])
+
+
+class PermutationRandomSampling(Sampling):
+
+    def _do(self, problem, n_samples, *args, random_state=None, **kwargs):
+        X = np.full((n_samples, problem.n_var), 0, dtype=int)
+        for i in range(n_samples):
+            X[i, :] = random_state.permutation(problem.n_var)
+        return X

pymoo/operators/selection/rnd.py

@@ -0,0 +1,75 @@
+import math
+
+import numpy as np
+
+from pymoo.core.selection import Selection
+from pymoo.util.misc import random_permutations
+from pymoo.util import default_random_state
+
+
+class RandomSelection(Selection):
+
+    def _do(self, _, pop, n_select, n_parents, *args, random_state=None, **kwargs):
+        # number of random individuals needed
+        n_random = n_select * n_parents
+
+        # number of permutations needed
+        n_perms = math.ceil(n_random / len(pop))
+
+        # get random permutations and reshape them
+        P = random_permutations(n_perms, len(pop), random_state=random_state)[:n_random]
+
+        return np.reshape(P, (n_select, n_parents))
+
+
+@default_random_state
+def fast_fill_random(X, N, columns=None, Xp=None, n_max_attempts=10, random_state=None):
+    """
+
+    Parameters
+    ----------
+    X : np.ndarray
+        The actually array to fill with random values.
+    N : int
+        The upper limit for the values. The values will be in range (0, ..., N)
+    columns : list
+        The columns which should be filled randomly. Other columns indicate duplicates
+    Xp : np.ndarray
+        If some other duplicates shall be avoided by default
+
+    """
+
+    _, n_cols = X.shape
+
+    if columns is None:
+        columns = range(n_cols)
+
+    # all columns set so far to be checked for duplicates
+    J = []
+
+    # for each of the columns which should be set to be no duplicates
+    for col in columns:
+
+        D = X[:, J]
+        if Xp is not None:
+            D = np.column_stack([D, Xp])
+
+        # all the remaining indices that need to be filled with no duplicates
+        rem = np.arange(len(X))
+
+        for _ in range(n_max_attempts):
+
+            # random_state is guaranteed to be set by decorator
+            if len(rem) > N:
+                X[rem, col] = random_state.choice(N, replace=True, size=len(rem))
+            else:
+                X[rem, col] = random_state.permutation(N)[:len(rem)]
+
+            rem = np.where((X[rem, col][:, None] == D[rem]).any(axis=1))[0]
+
+            if len(rem) == 0:
+                break
+
+        J.append(col)
+
+    return X

pymoo/operators/selection/tournament.py

@@ -0,0 +1,78 @@
+import math
+
+import numpy as np
+
+from pymoo.core.selection import Selection
+from pymoo.util.misc import random_permutations
+from pymoo.util import default_random_state
+
+
+class TournamentSelection(Selection):
+    """
+      The Tournament selection is used to simulate a tournament between individuals. The pressure balances
+      greedy the genetic algorithm will be.
+    """
+
+    def __init__(self, func_comp=None, pressure=2, **kwargs):
+        """
+
+        Parameters
+        ----------
+        func_comp: func
+            The function to compare two individuals. It has the shape: comp(pop, indices) and returns the winner.
+            If the function is None it is assumed the population is sorted by a criterion and only indices are compared.
+
+        pressure: int
+            The selection pressure to be applied. Default it is a binary tournament.
+        """
+
+        super().__init__(**kwargs)
+
+        # selection pressure to be applied
+        self.pressure = pressure
+
+        self.func_comp = func_comp
+        if self.func_comp is None:
+            raise Exception("Please provide the comparing function for the tournament selection!")
+
+    def _do(self, _, pop, n_select, n_parents=1, random_state=None, **kwargs):
+        # number of random individuals needed
+        n_random = n_select * n_parents * self.pressure
+
+        # number of permutations needed
+        n_perms = math.ceil(n_random / len(pop))
+
+        # get random permutations and reshape them
+        P = random_permutations(n_perms, len(pop), random_state=random_state)[:n_random]
+        P = np.reshape(P, (n_select * n_parents, self.pressure))
+
+        # compare using tournament function
+        S = self.func_comp(pop, P, random_state=random_state, **kwargs)
+
+        return np.reshape(S, (n_select, n_parents))
+
+
+@default_random_state
+def compare(a, a_val, b, b_val, method, return_random_if_equal=False, random_state=None):
+    if method == 'larger_is_better':
+        if a_val > b_val:
+            return a
+        elif a_val < b_val:
+            return b
+        else:
+            if return_random_if_equal:
+                return random_state.choice([a, b])
+            else:
+                return None
+    elif method == 'smaller_is_better':
+        if a_val < b_val:
+            return a
+        elif a_val > b_val:
+            return b
+        else:
+            if return_random_if_equal:
+                return random_state.choice([a, b])
+            else:
+                return None
+    else:
+        raise Exception("Unknown method.")

pymoo/operators/survival/rank_and_crowding/__init__.py

@@ -0,0 +1 @@
+from pymoo.operators.survival.rank_and_crowding.classes import RankAndCrowding, ConstrRankAndCrowding