pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/operators/crossover/dex.py

@@ -0,0 +1,122 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.population import Population
+from pymoo.operators.crossover.binx import mut_binomial
+from pymoo.operators.crossover.expx import mut_exp
+from pymoo.operators.repair.bounds_repair import is_out_of_bounds_by_problem, repair_random_init
+
+
+def de_differential(X, F, dither=None, jitter=True, gamma=0.0001, return_differentials=False):
+    n_parents, n_matings, n_var = X.shape
+    assert n_parents % 2 == 1, "For the differential an odd number of values need to be provided"
+
+    # make sure F is a one-dimensional vector
+    F = np.ones(n_matings) * F
+
+    # build the pairs for the differentials
+    pairs = (np.arange(n_parents - 1) + 1).reshape(-1, 2)
+
+    # the differentials from each pair subtraction
+    diffs = np.zeros((n_matings, n_var))
+
+    # for each difference
+    for i, j in pairs:
+
+        if dither == "vector":
+            F = (F + np.random.random(n_matings) * (1 - F))
+        elif dither == "scalar":
+            F = F + np.random.random() * (1 - F)
+
+        # http://www.cs.ndsu.nodak.edu/~siludwig/Publish/papers/SSCI20141.pdf
+        if jitter:
+            F = (F * (1 + gamma * (np.random.random(n_matings) - 0.5)))
+
+        # an add the difference to the first vector
+        diffs += F[:, None] * (X[i] - X[j])
+
+    # now add the differentials to the first parent
+    Xp = X[0] + diffs
+
+    if return_differentials:
+        return Xp, diffs
+    else:
+        return Xp
+
+
+class DEX(Crossover):
+
+    def __init__(self,
+                 F=None,
+                 CR=0.7,
+                 variant="bin",
+                 dither=None,
+                 jitter=False,
+                 n_diffs=1,
+                 n_iter=1,
+                 at_least_once=True,
+                 **kwargs):
+
+        super().__init__(1 + 2 * n_diffs, 1, **kwargs)
+        self.n_diffs = n_diffs
+        self.F = F
+        self.CR = CR
+        self.variant = variant
+        self.at_least_once = at_least_once
+        self.dither = dither
+        self.jitter = jitter
+        self.n_iter = n_iter
+
+    def do(self, problem, pop, parents=None, **kwargs):
+
+        # if a parents with array with mating indices is provided -> transform the input first
+        if parents is not None:
+            pop = [pop[mating] for mating in parents]
+
+        # get the actual values from each of the parents
+        X = np.swapaxes(np.array([[parent.get("X") for parent in mating] for mating in pop]), 0, 1).copy()
+
+        n_parents, n_matings, n_var = X.shape
+
+        # a mask over matings that need to be repeated
+        m = np.arange(n_matings)
+
+        # if the user provides directly an F value to use
+        F = self.F if self.F is not None else rnd_F(m)
+
+        # prepare the out to be set
+        Xp = de_differential(X[:, m], F)
+
+        # if the problem has boundaries to be considered
+        if problem.has_bounds():
+
+            for k in range(self.n_iter):
+                # find the individuals which are still infeasible
+                m = is_out_of_bounds_by_problem(problem, Xp)
+
+                F = rnd_F(m)
+
+                # actually execute the differential equation
+                Xp[m] = de_differential(X[:, m], F)
+
+            # if still infeasible do a random initialization
+            Xp = repair_random_init(Xp, X[0], *problem.bounds())
+
+        if self.variant == "bin":
+            M = mut_binomial(n_matings, n_var, self.CR, at_least_once=self.at_least_once)
+        elif self.variant == "exp":
+            M = mut_exp(n_matings, n_var, self.CR, at_least_once=self.at_least_once)
+        else:
+            raise Exception(f"Unknown variant: {self.variant}")
+
+        # take the first parents (this is already a copy)
+        X = X[0]
+
+        # set the corresponding values from the donor vector
+        X[M] = Xp[M]
+
+        return Population.new("X", X)
+
+
+def rnd_F(m):
+    return 0.5 * (1 + np.random.uniform(size=len(m)))

pymoo/operators/crossover/erx.py

@@ -0,0 +1,162 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+
+
+def remove_from_adj_list(H, val):
+    for e in list(H[val]):
+        H[e].remove(val)
+    del H[val]
+
+
+def has_duplicates(x):
+    H = set()
+    for v in x:
+        if v in H:
+            return True
+        H.add(v)
+    return False
+
+
+def erx(a, b):
+    """
+    http://www.rubicite.com/Tutorials/GeneticAlgorithms/CrossoverOperators/EdgeRecombinationCrossoverOperator.aspx
+
+    Algorithm Pseudo Code:
+
+    1. X = the first node from a random parent.
+
+    2. While the CHILD chromo isn't full, Loop:
+        - Append X to CHILD
+        - Remove X from Neighbor Lists
+
+        if X's neighbor list is empty:
+           - Xp = random node not already in CHILD
+        else
+           - Determine neighbor of X that has fewest neighbors
+           - If there is a tie, randomly choose 1
+           - Xp = chosen node
+        X = Xp
+     """
+
+    assert len(a) == len(b)
+
+    # calculate the edge matrix considering both permutation
+    H = calc_adjency_matrix(a)
+    H = calc_adjency_matrix(b, H=H)
+
+    # randomly select the first node
+    _next = np.random.choice(list(H.keys()))
+
+    y = []
+    while True:
+
+        # append to the child
+        y.append(_next)
+
+        # break if the child was successfully created.
+        if len(y) == len(a):
+            break
+
+        # get the neighbors to consider and remove them from the lists
+        neighbors = list(H[_next])
+        remove_from_adj_list(H, _next)
+
+        # if the current node does not have any neighbors
+        if len(neighbors) == 0:
+            _next = np.random.choice(list(H.keys()))
+
+        # otherwise search in the neighbors for a node with the fewest neighbors
+        else:
+            # search for the one with minimum neighbors
+            n_neighbors = [len(H[e]) for e in neighbors]
+            min_n_neighbors = min(n_neighbors)
+            _next = [neighbors[k] for k in range(len(neighbors)) if n_neighbors[k] == min_n_neighbors]
+
+            # break the tie if they might have the same number of neighbors
+            _next = np.random.choice(_next)
+
+    return y
+
+
+class EdgeRecombinationCrossover(Crossover):
+
+    def __init__(self, **kwargs):
+        super().__init__(2, 1, **kwargs)
+
+    def _do(self, problem, X, **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, :]
+            Y[0, i, :] = erx(a, b)
+
+        return Y
+
+class ERX(EdgeRecombinationCrossover):
+    pass
+
+def number_to_letter(n):
+    return chr(ord('@') + n)
+
+
+def numbers_to_letters(numbers):
+    return [number_to_letter(n) for n in numbers]
+
+
+def letter_to_number(char):
+    return ord(char.lower()) - 96
+
+
+def letters_to_numbers(letters):
+    return np.array([letter_to_number(char) for char in letters])
+
+
+def calc_adjency_matrix(x, H=None):
+    H = {} if H is None else H
+
+    for k in range(len(x)):
+        prev = (k - 1) % len(x)
+        succ = (k + 1) % len(x)
+
+        if x[k] not in H:
+            H[x[k]] = set()
+        H[x[k]].update([x[prev], x[succ]])
+
+    return H
+
+
+if __name__ == "__main__":
+    a = ['A', 'B', 'F', 'E', 'D', 'G', 'C']
+    b = ['G', 'F', 'A', 'B', 'C', 'D', 'E']
+
+    """
+    A: B C F
+    B: A F C
+    C: A G B D
+    D: E G C E
+    E: F D G
+    F: B E G A
+    G: D C E F
+    """
+
+    H = calc_adjency_matrix(a)
+    H = calc_adjency_matrix(b, H=H)
+
+    assert len(H["A"]) == 3
+    assert 'B' in H["A"] and 'C' in H["A"] and 'F' in H["A"]
+    assert len(H["B"]) == 3
+    assert 'A' in H["B"] and 'F' in H["B"] and 'C' in H["B"]
+    assert len(H["C"]) == 4
+    assert 'A' in H["C"] and 'G' in H["C"] and 'B' in H["C"] and 'D' in H["C"]
+    assert len(H["D"]) == 3
+    assert 'E' in H["D"] and 'G' in H["D"] and 'C' in H["D"]
+    assert len(H["E"]) == 3
+    assert 'F' in H["E"] and 'D' in H["E"] and 'G' in H["E"]
+    assert len(H["F"]) == 4
+    assert 'B' in H["F"] and 'E' in H["F"] and 'G' in H["F"] and 'A' in H["F"]
+    assert len(H["G"]) == 4
+    assert 'D' in H["G"] and 'E' in H["G"] and 'E' in H["G"] and 'F' in H["G"]
+
+    c = erx(a, b)

pymoo/operators/crossover/expx.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.variable import get, Real
+from pymoo.util.misc import crossover_mask, row_at_least_once_true
+
+
+def mut_exp(n_matings, n_var, prob, at_least_once=True):
+    assert len(prob) == n_matings
+
+    # the mask do to the crossover
+    M = np.full((n_matings, n_var), False)
+
+    # start point of crossover
+    s = np.random.randint(0, n_var, size=n_matings)
+
+    # create for each individual the crossover range
+    for i in range(n_matings):
+
+        # the actual index where we start
+        start = s[i]
+        for j in range(n_var):
+
+            # the current position where we are pointing to
+            current = (start + j) % n_var
+
+            # replace only if random value keeps being smaller than CR
+            if np.random.random() <= prob[i]:
+                M[i, current] = True
+            else:
+                break
+
+    if at_least_once:
+        M = row_at_least_once_true(M)
+
+    return M
+
+
+class ExponentialCrossover(Crossover):
+
+    def __init__(self, prob_exp=0.75, **kwargs):
+        super().__init__(2, 2, **kwargs)
+        self.prob_exp = Real(prob_exp, bounds=(0.5, 0.9), strict=(0.0, 1.0))
+
+    def _do(self, _, X, **kwargs):
+        _, n_matings, n_var = X.shape
+        prob_exp = get(self.prob_exp, size=n_matings)
+
+        M = mut_exp(n_matings, n_var, prob_exp, at_least_once=True)
+        _X = crossover_mask(X, M)
+        return _X

pymoo/operators/crossover/hux.py

@@ -0,0 +1,37 @@
+import math
+
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.util.misc import crossover_mask
+
+
+class HalfUniformCrossover(Crossover):
+
+    def __init__(self, prob_hux=0.5, **kwargs):
+        super().__init__(2, 2, **kwargs)
+        self.prob_hux = prob_hux
+
+    def _do(self, _, X, **kwargs):
+        _, n_matings, n_var = X.shape
+
+        # the mask do to the crossover
+        M = np.full((n_matings, n_var), False)
+
+        not_equal = X[0] != X[1]
+
+        # create for each individual the crossover range
+        for i in range(n_matings):
+            I = np.where(not_equal[i])[0]
+
+            n = math.ceil(len(I) / 2)
+            if n > 0:
+                _I = I[np.random.permutation(len(I))[:n]]
+                M[i, _I] = True
+
+        _X = crossover_mask(X, M)
+        return _X
+
+
+class HUX(HalfUniformCrossover):
+    pass

pymoo/operators/crossover/nox.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.population import Population
+
+
+class NoCrossover(Crossover):
+
+    def __init__(self):
+        super().__init__(1, 1, 0.0)
+
+    def do(self, problem, pop, **kwargs):
+        return Population.create(*[np.random.choice(parents) for parents in pop])

pymoo/operators/crossover/ox.py

@@ -0,0 +1,84 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+
+
+def random_sequence(n):
+    start, end = np.sort(np.random.choice(n, 2, replace=False))
+    return tuple([start, end])
+
+
+def ox(receiver, donor, seq=None, shift=False):
+    """
+    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))
+    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
+
+    def _do(self, problem, X, **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)
+
+            Y[0, i, :] = ox(a, b, seq=(start, end), shift=self.shift)
+            Y[1, i, :] = ox(b, a, seq=(start, end), shift=self.shift)
+
+        return Y

pymoo/operators/crossover/pcx.py

@@ -0,0 +1,82 @@
+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
+
+
+def pcx(X, eta, zeta, index):
+    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 = np.random.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 = np.random.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, **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)
+
+        if problem.has_bounds():
+            Xp = repair_random_init(Xp, X[index], *problem.bounds())
+
+        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, **kwargs):
+
+        # get the X of parents and count the matings
+        _, n_matings, n_var = X.shape
+
+        # start point of crossover
+        r = np.row_stack([np.random.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)