pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/operators/crossover/ox.py

@@ -0,0 +1,88 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.util import default_random_state
+
+
+@default_random_state
+def random_sequence(n, random_state=None):
+    start, end = np.sort(random_state.choice(n, 2, replace=False))
+    return tuple([start, end])
+
+
+@default_random_state
+def ox(receiver, donor, seq=None, shift=False, random_state=None):
+    """
+    The Ordered Crossover (OX) as explained in http://www.dmi.unict.it/mpavone/nc-cs/materiale/moscato89.pdf.
+
+    Parameters
+    ----------
+    receiver : numpy.array
+        The receiver of the sequence. The array needs to be repaired after the donation took place.
+    donor : numpy.array
+        The donor of the sequence.
+    seq : tuple (optional)
+        Tuple with two problems defining the start and the end of the sequence. Please note in our implementation
+        the end of the sequence is included. The sequence is randomly chosen if not provided.
+
+    shift : bool
+        Whether during the repair the receiver should be shifted or not. Both version of it can be found in the
+        literature.
+
+    Returns
+    -------
+
+    y : numpy.array
+        The offspring which was created by the ordered crossover.
+
+    """
+    assert len(donor) == len(receiver)
+
+    # the sequence which shall be use for the crossover
+    seq = seq if seq is not None else random_sequence(len(receiver), random_state=random_state)
+    start, end = seq
+
+    # the donation and a set of it to allow a quick lookup
+    donation = np.copy(donor[start:end + 1])
+    donation_as_set = set(donation)
+
+    # the final value to be returned
+    y = []
+
+    for k in range(len(receiver)):
+
+        # do the shift starting from the swapped sequence - as proposed in the paper
+        i = k if not shift else (start + k) % len(receiver)
+        v = receiver[i]
+
+        if v not in donation_as_set:
+            y.append(v)
+
+    # now insert the donation at the right place
+    y = np.concatenate([y[:start], donation, y[start:]]).astype(copy=False, dtype=int)
+
+    return y
+
+
+class OrderCrossover(Crossover):
+
+    def __init__(self, shift=False, **kwargs):
+        super().__init__(2, 2, **kwargs)
+        self.shift = shift
+
+    @default_random_state
+    def _do(self, problem, X, random_state=None, **kwargs):
+        _, n_matings, n_var = X.shape
+        Y = np.full((self.n_offsprings, n_matings, n_var), -1, dtype=int)
+
+        for i in range(n_matings):
+            a, b = X[:, i, :]
+            n = len(a)
+
+            # define the sequence to be used for crossover
+            start, end = random_sequence(n, random_state=random_state)
+
+            Y[0, i, :] = ox(a, b, seq=(start, end), shift=self.shift, random_state=random_state)
+            Y[1, i, :] = ox(b, a, seq=(start, end), shift=self.shift, random_state=random_state)
+
+        return Y

pymoo/operators/crossover/pcx.py

@@ -0,0 +1,84 @@
+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_random_init
+from pymoo.util import default_random_state
+
+
+@default_random_state
+def pcx(X, eta, zeta, index, random_state=None):
+    eps = 1e-32
+
+    # the number of parents to be considered
+    n_parents, n_matings, n_var = X.shape
+
+    # calculate the differences from all parents to index parent
+    diff_to_index = X - X[index]
+    dist_to_index = np.linalg.norm(diff_to_index, axis=-1)
+    dist_to_index = np.maximum(eps, dist_to_index)
+
+    # find the centroid of the parents
+    centroid = np.mean(X, axis=0)
+
+    # calculate the difference between the centroid and the k-th parent
+    diff_to_centroid = centroid - X[index]
+
+    dist_to_centroid = np.linalg.norm(diff_to_centroid, axis=-1)
+    dist_to_centroid = np.maximum(eps, dist_to_centroid)
+
+    # orthogonal directions are computed
+    orth_dir = np.zeros_like(dist_to_index)
+
+    for i in range(n_parents):
+        if i != index:
+            temp1 = (diff_to_index[i] * diff_to_centroid).sum(axis=-1)
+            temp2 = temp1 / (dist_to_index[i] * dist_to_centroid)
+            temp3 = np.maximum(0.0, 1.0 - temp2 ** 2)
+            orth_dir[i] = dist_to_index[i] * (temp3 ** 0.5)
+
+    # this is the avg of the perpendicular distances from other parents to the parent k
+    D_not = orth_dir.sum(axis=0) / (n_parents - 1)
+
+    # generating zero-mean normally distributed variables
+    sigma = D_not[:, None] * eta.repeat(n_var, axis=1)
+    rnd = random_state.normal(loc=0.0, scale=sigma)
+
+    # implemented just like the c code - generate_new.h file
+    inner_prod = np.sum(rnd * diff_to_centroid, axis=-1, keepdims=True)
+    noise = rnd - (inner_prod * diff_to_centroid) / dist_to_centroid[:, None] ** 2
+
+    bias_to_centroid = random_state.normal(0.0, zeta) * diff_to_centroid
+
+    # the array which is finally returned
+    Xp = X[index] + noise + bias_to_centroid
+
+    return Xp
+
+
+class ParentCentricCrossover(Crossover):
+    def __init__(self,
+                 eta=0.1,
+                 zeta=0.1,
+                 **kwargs):
+
+        super().__init__(n_parents=3, n_offsprings=1, **kwargs)
+        self.eta = Real(eta, bounds=(0.01, 0.3))
+        self.zeta = Real(zeta, bounds=(0.01, 0.3))
+
+    def _do(self, problem, X, params=None, random_state=None, **kwargs):
+        n_parents, n_matings, n_var = X.shape
+        zeta, eta = get(self.zeta, self.eta, size=(n_matings, 1))
+
+        index = 0
+
+        Xp = pcx(X, eta, zeta, index=index, random_state=random_state)
+
+        if problem.has_bounds():
+            Xp = repair_random_init(Xp, X[index], *problem.bounds(), random_state=random_state)
+
+        return Xp[None, :]
+
+
+class PCX(ParentCentricCrossover):
+    pass

pymoo/operators/crossover/pntx.py

@@ -0,0 +1,49 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.util.misc import crossover_mask
+
+
+class PointCrossover(Crossover):
+
+    def __init__(self, n_points, **kwargs):
+        super().__init__(2, 2, **kwargs)
+        self.n_points = n_points
+
+    def _do(self, _, X, random_state=None, **kwargs):
+
+        # get the X of parents and count the matings
+        _, n_matings, n_var = X.shape
+
+        # start point of crossover
+        r = np.vstack([random_state.permutation(n_var - 1) + 1 for _ in range(n_matings)])[:, :self.n_points]
+        r.sort(axis=1)
+        r = np.column_stack([r, np.full(n_matings, n_var)])
+
+        # the mask do to the crossover
+        M = np.full((n_matings, n_var), False)
+
+        # create for each individual the crossover range
+        for i in range(n_matings):
+
+            j = 0
+            while j < r.shape[1] - 1:
+                a, b = r[i, j], r[i, j + 1]
+                M[i, a:b] = True
+                j += 2
+
+        Xp = crossover_mask(X, M)
+
+        return Xp
+
+
+class SinglePointCrossover(PointCrossover):
+
+    def __init__(self, **kwargs):
+        super().__init__(n_points=1, **kwargs)
+
+
+class TwoPointCrossover(PointCrossover):
+
+    def __init__(self, **kwargs):
+        super().__init__(n_points=2, **kwargs)

pymoo/operators/crossover/sbx.py

@@ -0,0 +1,137 @@
+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
+from pymoo.util import default_random_state
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+@default_random_state
+def cross_sbx(X, xl, xu, eta, prob_var, prob_bin, eps=1.0e-14, random_state=None):
+    n_parents, n_matings, n_var = X.shape
+
+    # the probability of a crossover for each of the variables
+    cross = random_state.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
+
+    # preserve parent identity while getting values for SBX calculation
+    p1 = X[0][cross]
+    p2 = X[1][cross]
+    
+    # assign y1 the smaller and y2 the larger value for SBX calculation
+    sm = p1 < p2
+    y1 = np.where(sm, p1, p2)
+    y2 = np.where(sm, p2, p1)
+
+    # 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 = random_state.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)
+
+    # assign children based on parent position, then apply exchange probability
+    child1 = np.where(sm, c1, c2)  # child for parent 1
+    child2 = np.where(sm, c2, c1)  # child for parent 2
+    
+    # exchange children with given probability
+    b = np.bitwise_xor(
+        random_state.random(len(prob_bin)) < prob_bin,
+        X[0, cross] > X[1, cross]
+    )
+    child1, child2 = np.where(b, (child2, child1), (child1, child2))
+
+    # first copy the unmodified parents
+    Q = np.copy(X)
+
+    # copy the positions where the crossover was done
+    Q[0, cross] = child1
+    Q[1, cross] = child2
+
+    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, *args, random_state=None, **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 = random_state.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, random_state=random_state)
+
+        if self.n_offsprings == 1:
+            rand = random_state.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, random_state=None, **kwargs):
+        _, n_matings, n_var = X.shape
+        M = random_state.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, random_state=None, **kwargs):
+        prob_var = self.get_prob_var(problem, size=(len(X), 1))
+        Xp = np.copy(X)
+        flip = random_state.random(X.shape) < prob_var
+        Xp[flip] = ~X[flip]
+        return Xp
+
+
+class BFM(BitflipMutation):
+    pass

pymoo/operators/mutation/gauss.py

@@ -0,0 +1,60 @@
+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
+from pymoo.util import default_random_state
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+@default_random_state
+def mut_gauss(X, xl, xu, sigma, prob, random_state=None):
+    n, n_var = X.shape
+    assert len(sigma) == n
+    assert len(prob) == n
+
+    Xp = np.full(X.shape, np.inf)
+
+    mut = random_state.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] = random_state.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, random_state=None, **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, random_state=random_state)
+
+        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, random_state=None, **kwargs):
+        Y = X.copy()
+        for i, y in enumerate(X):
+            if random_state.random() < self.prob:
+                seq = random_sequence(len(y), random_state=random_state)
+                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,96 @@
+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
+from pymoo.util import default_random_state
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Function
+# ---------------------------------------------------------------------------------------------------------
+
+
+@default_random_state
+def mut_pm(X, xl, xu, eta, prob, at_least_once, random_state=None):
+    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, random_state=random_state)
+    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 = random_state.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, *args, random_state=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, random_state=random_state)
+
+        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, random_state=None, **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(random_state.random(len(X)) < prob_var)[0]
+
+            v = var.sample(len(mut), random_state=random_state)
+            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)