pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/operators/crossover/sbx.py

@@ -0,0 +1,125 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.variable import Real, get
+from pymoo.operators.repair.bounds_repair import repair_clamp
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+def cross_sbx(X, xl, xu, eta, prob_var, prob_bin, eps=1.0e-14):
+    n_parents, n_matings, n_var = X.shape
+
+    # the probability of a crossover for each of the variables
+    cross = np.random.random((n_matings, n_var)) < prob_var
+
+    # when solutions are too close -> do not apply sbx crossover
+    too_close = np.abs(X[0] - X[1]) <= eps
+
+    # disable if two individuals are already too close
+    cross[too_close] = False
+
+    # disable crossover when lower and upper bound are identical
+    cross[:, xl == xu] = False
+
+    # assign y1 the smaller and y2 the larger value
+    y1 = np.min(X, axis=0)[cross]
+    y2 = np.max(X, axis=0)[cross]
+
+    # mask all the values that should be crossovered
+    _xl = np.repeat(xl[None, :], n_matings, axis=0)[cross]
+    _xu = np.repeat(xu[None, :], n_matings, axis=0)[cross]
+    eta = eta.repeat(n_var, axis=1)[cross]
+    prob_bin = prob_bin.repeat(n_var, axis=1)[cross]
+
+    # random values for each individual
+    rand = np.random.random(len(eta))
+
+    def calc_betaq(beta):
+        alpha = 2.0 - np.power(beta, -(eta + 1.0))
+
+        mask, mask_not = (rand <= (1.0 / alpha)), (rand > (1.0 / alpha))
+
+        betaq = np.zeros(mask.shape)
+        betaq[mask] = np.power((rand * alpha), (1.0 / (eta + 1.0)))[mask]
+        betaq[mask_not] = np.power((1.0 / (2.0 - rand * alpha)), (1.0 / (eta + 1.0)))[mask_not]
+
+        return betaq
+
+    # difference between all variables
+    delta = (y2 - y1)
+
+    beta = 1.0 + (2.0 * (y1 - _xl) / delta)
+    betaq = calc_betaq(beta)
+    c1 = 0.5 * ((y1 + y2) - betaq * delta)
+
+    beta = 1.0 + (2.0 * (_xu - y2) / delta)
+    betaq = calc_betaq(beta)
+    c2 = 0.5 * ((y1 + y2) + betaq * delta)
+
+    # with the given probability either assign the value from the first or second parent
+    b = np.random.random(len(prob_bin)) < prob_bin
+    tmp = np.copy(c1[b])
+    c1[b] = c2[b]
+    c2[b] = tmp
+
+    # first copy the unmodified parents
+    Q = np.copy(X)
+
+    # copy the positions where the crossover was done
+    Q[0, cross] = c1
+    Q[1, cross] = c2
+
+    Q[0] = repair_clamp(Q[0], xl, xu)
+    Q[1] = repair_clamp(Q[1], xl, xu)
+
+    return Q
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Class
+# ---------------------------------------------------------------------------------------------------------
+
+
+class SimulatedBinaryCrossover(Crossover):
+
+    def __init__(self,
+                 prob_var=0.5,
+                 eta=15,
+                 prob_exch=1.0,
+                 prob_bin=0.5,
+                 n_offsprings=2,
+                 **kwargs):
+        super().__init__(2, n_offsprings, **kwargs)
+
+        self.prob_var = Real(prob_var, bounds=(0.1, 0.9))
+        self.eta = Real(eta, bounds=(3.0, 30.0), strict=(1.0, None))
+        self.prob_exch = Real(prob_exch, bounds=(0.0, 1.0), strict=(0.0, 1.0))
+        self.prob_bin = Real(prob_bin, bounds=(0.0, 1.0), strict=(0.0, 1.0))
+
+    def _do(self, problem, X, **kwargs):
+        _, n_matings, _ = X.shape
+
+        # get the parameters required by SBX
+        eta, prob_var, prob_exch, prob_bin = get(self.eta, self.prob_var, self.prob_exch, self.prob_bin,
+                                                 size=(n_matings, 1))
+
+        # set the binomial probability to zero if no exchange between individuals shall happen
+        rand = np.random.random((len(prob_bin), 1))
+        prob_bin[rand > prob_exch] = 0.0
+
+        Q = cross_sbx(X.astype(float), problem.xl, problem.xu, eta, prob_var, prob_bin)
+
+        if self.n_offsprings == 1:
+            rand = np.random.random(size=n_matings) < 0.5
+            Q[0, rand] = Q[1, rand]
+            Q = Q[[0]]
+
+        return Q
+
+
+class SBX(SimulatedBinaryCrossover):
+    pass

pymoo/operators/crossover/spx.py

@@ -0,0 +1,5 @@
+from pymoo.operators.crossover.pntx import SinglePointCrossover
+
+
+class SPX(SinglePointCrossover):
+    pass

pymoo/operators/crossover/ux.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.util.misc import crossover_mask
+
+
+class UniformCrossover(Crossover):
+
+    def __init__(self, **kwargs):
+        super().__init__(2, 2, **kwargs)
+
+    def _do(self, _, X, **kwargs):
+        _, n_matings, n_var = X.shape
+        M = np.random.random((n_matings, n_var)) < 0.5
+        _X = crossover_mask(X, M)
+        return _X
+
+
+class UX(UniformCrossover):
+    pass

pymoo/operators/mutation/bitflip.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+from pymoo.core.mutation import Mutation
+
+
+class BitflipMutation(Mutation):
+
+    def _do(self, problem, X, **kwargs):
+        prob_var = self.get_prob_var(problem, size=(len(X), 1))
+        Xp = np.copy(X)
+        flip = np.random.random(X.shape) < prob_var
+        Xp[flip] = ~X[flip]
+        return Xp
+
+
+class BFM(BitflipMutation):
+    pass

pymoo/operators/mutation/gauss.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+from pymoo.core.mutation import Mutation
+from pymoo.core.variable import Real, get
+from pymoo.operators.repair.bounds_repair import repair_random_init
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+def mut_gauss(X, xl, xu, sigma, prob):
+    n, n_var = X.shape
+    assert len(sigma) == n
+    assert len(prob) == n
+
+    Xp = np.full(X.shape, np.inf)
+
+    mut = np.random.random(X.shape) < prob[:, None]
+
+    Xp[:, :] = X
+
+    _xl = np.repeat(xl[None, :], X.shape[0], axis=0)[mut]
+    _xu = np.repeat(xu[None, :], X.shape[0], axis=0)[mut]
+    sigma = sigma[:, None].repeat(n_var, axis=1)[mut]
+
+    Xp[mut] = np.random.normal(X[mut], sigma * (_xu - _xl))
+
+    Xp = repair_random_init(Xp, X, xl, xu)
+
+    return Xp
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Class
+# ---------------------------------------------------------------------------------------------------------
+
+
+class GaussianMutation(Mutation):
+
+    def __init__(self, sigma=0.1, **kwargs):
+        super().__init__(**kwargs)
+        self.sigma = Real(sigma, bounds=(0.01, 0.25), strict=(0.0, 1.0))
+
+    def _do(self, problem, X, **kwargs):
+        X = X.astype(float)
+
+        sigma = get(self.sigma, size=len(X))
+        prob_var = self.get_prob_var(problem, size=len(X))
+
+        Xp = mut_gauss(X, problem.xl, problem.xu, sigma, prob_var)
+
+        return Xp
+
+
+class GM(GaussianMutation):
+    pass

pymoo/operators/mutation/inversion.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+from pymoo.core.mutation import Mutation
+from pymoo.operators.crossover.ox import random_sequence
+
+
+def inversion_mutation(y, seq, inplace=True):
+    y = y if inplace else np.copy(y)
+
+    if seq is None:
+        seq = random_sequence(len(y))
+    start, end = seq
+
+    y[start:end + 1] = np.flip(y[start:end + 1])
+    return y
+
+
+class InversionMutation(Mutation):
+
+    def __init__(self, prob=1.0):
+        """
+
+        This mutation is applied to permutations. It randomly selects a segment of a chromosome and reverse its order.
+        For instance, for the permutation `[1, 2, 3, 4, 5]` the segment can be `[2, 3, 4]` which results in `[1, 4, 3, 2, 5]`.
+
+        Parameters
+        ----------
+        prob : float
+            Probability to apply the mutation to the individual
+            
+        """
+        super().__init__()
+        self.prob = prob
+
+    def _do(self, problem, X, **kwargs):
+        Y = X.copy()
+        for i, y in enumerate(X):
+            if np.random.random() < self.prob:
+                seq = random_sequence(len(y))
+                Y[i] = inversion_mutation(y, seq, inplace=True)
+
+        return Y

pymoo/operators/mutation/nom.py

@@ -0,0 +1,7 @@
+from pymoo.core.mutation import Mutation
+
+
+class NoMutation(Mutation):
+
+    def do(self, problem, pop, **kwargs):
+        return pop

pymoo/operators/mutation/pm.py

@@ -0,0 +1,94 @@
+import numpy as np
+
+from pymoo.core.mutation import Mutation
+from pymoo.core.variable import get, Real
+from pymoo.operators.crossover.binx import mut_binomial
+from pymoo.operators.repair.to_bound import set_to_bounds_if_outside
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+def mut_pm(X, xl, xu, eta, prob, at_least_once):
+    n, n_var = X.shape
+    assert len(eta) == n
+    assert len(prob) == n
+
+    Xp = np.full(X.shape, np.inf)
+
+    mut = mut_binomial(n, n_var, prob, at_least_once=at_least_once)
+    mut[:, xl == xu] = False
+
+    Xp[:, :] = X
+
+    _xl = np.repeat(xl[None, :], X.shape[0], axis=0)[mut]
+    _xu = np.repeat(xu[None, :], X.shape[0], axis=0)[mut]
+
+    X = X[mut]
+    eta = np.tile(eta[:, None], (1, n_var))[mut]
+
+    delta1 = (X - _xl) / (_xu - _xl)
+    delta2 = (_xu - X) / (_xu - _xl)
+
+    mut_pow = 1.0 / (eta + 1.0)
+
+    rand = np.random.random(X.shape)
+    mask = rand <= 0.5
+    mask_not = np.logical_not(mask)
+
+    deltaq = np.zeros(X.shape)
+
+    xy = 1.0 - delta1
+    val = 2.0 * rand + (1.0 - 2.0 * rand) * (np.power(xy, (eta + 1.0)))
+    d = np.power(val, mut_pow) - 1.0
+    deltaq[mask] = d[mask]
+
+    xy = 1.0 - delta2
+    val = 2.0 * (1.0 - rand) + 2.0 * (rand - 0.5) * (np.power(xy, (eta + 1.0)))
+    d = 1.0 - (np.power(val, mut_pow))
+    deltaq[mask_not] = d[mask_not]
+
+    # mutated values
+    _Y = X + deltaq * (_xu - _xl)
+
+    # back in bounds if necessary (floating point issues)
+    _Y[_Y < _xl] = _xl[_Y < _xl]
+    _Y[_Y > _xu] = _xu[_Y > _xu]
+
+    # set the values for output
+    Xp[mut] = _Y
+
+    # in case out of bounds repair (very unlikely)
+    Xp = set_to_bounds_if_outside(Xp, xl, xu)
+
+    return Xp
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Class
+# ---------------------------------------------------------------------------------------------------------
+
+
+class PolynomialMutation(Mutation):
+
+    def __init__(self, prob=0.9, eta=20, at_least_once=False, **kwargs):
+        super().__init__(prob=prob, **kwargs)
+        self.at_least_once = at_least_once
+        self.eta = Real(eta, bounds=(3.0, 30.0), strict=(1.0, 100.0))
+
+    def _do(self, problem, X, params=None, **kwargs):
+        X = X.astype(float)
+
+        eta = get(self.eta, size=len(X))
+        prob_var = self.get_prob_var(problem, size=len(X))
+
+        Xp = mut_pm(X, problem.xl, problem.xu, eta, prob_var, at_least_once=self.at_least_once)
+
+        return Xp
+
+
+class PM(PolynomialMutation):
+    pass
+

pymoo/operators/mutation/rm.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+from pymoo.core.mutation import Mutation
+
+
+class ChoiceRandomMutation(Mutation):
+
+    def _do(self, problem, X, **kwargs):
+        assert problem.vars is not None
+
+        # ensure the type object (fixed string length <UX can cause issues)
+        X = X.astype(object)
+
+        prob_var = self.get_prob_var(problem, size=len(X))
+
+        for k, (_, var) in enumerate(problem.vars.items()):
+            mut = np.where(np.random.random(len(X)) < prob_var)[0]
+
+            v = var.sample(len(mut))
+            X[mut, k] = v
+
+        return X
+

pymoo/operators/repair/bounce_back.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+from pymoo.operators.repair.bounds_repair import BoundsRepair
+from pymoo.util.misc import at_least_2d_array
+
+
+def bounce_back(X, xl, xu):
+    only_1d = (X.ndim == 1)
+    X = at_least_2d_array(X)
+
+    xl = np.repeat(xl[None, :], X.shape[0], axis=0)
+    xu = np.repeat(xu[None, :], X.shape[0], axis=0)
+
+    # otherwise bounds back into the feasible space
+    _range = xu - xl
+    X[X < xl] = (xl + np.mod((xl - X), _range))[X < xl]
+    X[X > xu] = (xu - np.mod((X - xu), _range))[X > xu]
+
+    if only_1d:
+        return X[0, :]
+    else:
+        return X
+
+
+def bounce_back_by_problem(problem, X):
+    return bounce_back(X, problem.xl, problem.xu)
+
+
+class BounceBackOutOfBoundsRepair(BoundsRepair):
+
+    def repair_out_of_bounds(self, problem, X, **kwargs):
+        return bounce_back_by_problem(problem, X)

pymoo/operators/repair/bounds_repair.py

@@ -0,0 +1,95 @@
+import abc
+
+import numpy as np
+
+from pymoo.core.population import Population
+from pymoo.core.repair import Repair
+
+
+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
+
+
+def repair_random_init(Xp, X, xl, xu):
+    XL, XU = repeat_bounds(xl, xu, len(Xp))
+
+    i, j = np.where(Xp < XL)
+    if len(i) > 0:
+        Xp[i, j] = XL[i, j] + np.random.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] - np.random.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,89 @@
+import numpy as np
+
+from pymoo.operators.repair.bounds_repair import BoundsRepair
+
+
+def inverse_penality(x, p, xl, xu, alpha=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 = np.random.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])
+
+    import matplotlib.pyplot as 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)