pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/operators/control.py

@@ -0,0 +1,190 @@
+import math
+from abc import abstractmethod
+
+import numpy as np
+
+from pymoo.core.duplicate import NoDuplicateElimination
+from pymoo.core.individual import Individual
+from pymoo.core.infill import InfillCriterion
+from pymoo.core.mixed import MixedVariableMating
+from pymoo.core.parameters import get_params, flatten
+from pymoo.core.problem import Problem
+from pymoo.core.variable import Choice, Real, Integer, Binary
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.crossover.ux import UX
+from pymoo.operators.mutation.bitflip import BFM
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.mutation.rm import ChoiceRandomMutation
+from pymoo.operators.repair.rounding import RoundingRepair
+from pymoo.operators.selection.tournament import TournamentSelection, compare
+from pymoo.util import default_random_state
+
+
+class ParameterControl:
+
+    def __init__(self, obj) -> None:
+        super().__init__()
+
+        self.data = None
+
+        params = flatten({"ParameterControl": get_params(obj)})
+        self.params = params
+
+        # print("PARAMETER CONTROL:", list(self.params))
+
+    @default_random_state
+    def do(self, N, set_to_params=True, random_state=None):
+        vals = self._do(N, random_state=random_state)
+        if set_to_params:
+            if vals is not None:
+                for k, v in vals.items():
+                    self.params[k].set(v)
+        return vals
+
+    @abstractmethod
+    def _do(self, N, random_state=None):
+        pass
+
+    def tell(self, **kwargs):
+        self.data = dict(kwargs)
+
+    def advance(self, infills=None):
+        for k, v in self.params.items():
+            assert len(v.get()) == len(
+                infills), "Make sure that the infills and parameters asked for have the same size."
+            infills.set(k, v.get())
+
+
+class NoParameterControl(ParameterControl):
+
+    def __init__(self, _) -> None:
+        super().__init__(None)
+
+    def _do(self, N, random_state=None):
+        return {}
+
+
+class RandomParameterControl(ParameterControl):
+
+    def _do(self, N, random_state=None):
+        return {key: value.sample(N, random_state=random_state) for key, value in self.params.items()}
+
+
+class EvolutionaryParameterControl(ParameterControl):
+
+    def __init__(self, obj) -> None:
+        super().__init__(obj)
+        self.eps = 0.05
+
+    def _do(self, N, random_state=None):
+        params = self.params
+        pop = self.data.get("pop")
+
+        # make sure that for each parameter a value exists - if not simply set it randomly
+        for name, param in params.items():
+            is_none = np.where(pop.get(name) == None)[0]
+            if len(is_none) > 0:
+                pop[is_none].set(name, param.sample(len(is_none), random_state=random_state))
+
+        selection = AgeBasedTournamentSelection()
+
+        crossover = {
+            Binary: UX(),
+            Real: SBX(),
+            Integer: SBX(vtype=float, repair=RoundingRepair()),
+            Choice: UX(),
+        }
+
+        mutation = {
+            Binary: BFM(),
+            Real: PM(),
+            Integer: PM(vtype=float, repair=RoundingRepair()),
+            Choice: ChoiceRandomMutation(),
+        }
+
+        mating = MixedVariableMating(
+            crossover=crossover,
+            mutation=mutation,
+            eliminate_duplicates=NoDuplicateElimination()
+        )
+
+        problem = Problem(vars=params)
+
+        parents = selection(problem, pop, N, n_parents=2, random_state=random_state)
+        parents = [[Individual(X={key: parent.get(key) for key in params}) for parent in mating] for mating in parents]
+
+        off = mating(problem, parents, N, parents=True, random_state=random_state)
+
+        Xp = off.get("X")
+        ret = {param: np.array([Xp[i][param] for i in range(len(Xp))]) for param in params}
+
+        return ret
+
+
+class AgeBasedTournamentSelection(TournamentSelection):
+
+    def __init__(self, pressure=2):
+        super().__init__(age_binary_tournament, pressure)
+
+
+def age_binary_tournament(pop, P, **kwargs):
+    n_tournaments, n_parents = P.shape
+
+    if n_parents != 2:
+        raise ValueError("Only implemented for binary tournament!")
+
+    S = np.full(n_tournaments, np.nan)
+    random_state = kwargs.get('random_state', None)
+
+    for i in range(n_tournaments):
+        a, b = P[i, 0], P[i, 1]
+        a_gen, b_gen = pop[a].get("n_gen"), pop[b].get("n_gen")
+        S[i] = compare(a, a_gen, b, b_gen, method='larger_is_better', return_random_if_equal=True, random_state=random_state)
+
+    return S[:, None].astype(int, copy=False)
+
+
+class ParameterControlMating(InfillCriterion):
+
+    def __init__(self,
+                 selection,
+                 crossover,
+                 mutation,
+                 control=NoParameterControl,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.selection = selection
+        self.crossover = crossover
+        self.mutation = mutation
+        self.control = control(self)
+
+    def _do(self, problem, pop, n_offsprings, parents=None, **kwargs):
+
+        # how many parents need to be select for the mating - depending on number of offsprings remaining
+        n_matings = math.ceil(n_offsprings / self.crossover.n_offsprings)
+
+        # do the parameter control for the mating
+        control = self.control
+        control.tell(pop=pop)
+        control.do(n_matings)
+
+        # if the parents for the mating are not provided directly - usually selection will be used
+        if parents is None:
+
+            # select the parents for the mating - just an index array
+            parents = self.selection.do(problem, pop, n_matings, n_parents=self.crossover.n_parents, **kwargs)
+
+        # do the crossover using the parents index and the population - additional data provided if necessary
+        off = self.crossover(problem, parents, **kwargs)
+
+        # now we have to consider during parameter control that a crossover can produce multiple offsprings
+        for name, param in control.params.items():
+            param.set(np.repeat(param.get(), self.crossover.n_offsprings))
+
+        # do the mutation on the offsprings created through crossover
+        off = self.mutation(problem, off, **kwargs)
+
+        # finally attach the parameters back to the offsprings
+        control.advance(off)
+
+        return off

pymoo/operators/crossover/binx.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.variable import Real, get
+from pymoo.util import default_random_state
+from pymoo.util.misc import row_at_least_once_true
+
+
+@default_random_state
+def mut_binomial(n, m, prob, at_least_once=True, random_state=None):
+    prob = np.ones(n) * prob
+    M = random_state.random((n, m)) < prob[:, None]
+
+    if at_least_once:
+        M = row_at_least_once_true(M, random_state=random_state)
+
+    return M
+
+
+class BinomialCrossover(Crossover):
+
+    def __init__(self, bias=0.5, n_offsprings=2, **kwargs):
+        super().__init__(2, n_offsprings, **kwargs)
+        self.bias = Real(bias, bounds=(0.1, 0.9), strict=(0.0, 1.0))
+
+    def _do(self, problem, X, *args, random_state=None, **kwargs):
+        _, n_matings, n_var = X.shape
+
+        bias = get(self.bias, size=n_matings)
+        M = mut_binomial(n_matings, n_var, bias, at_least_once=True, random_state=random_state)
+
+        if self.n_offsprings == 1:
+            Xp = X[0].copy()
+            Xp[~M] = X[1][~M]
+            Xp = Xp[None, ...]
+        elif self.n_offsprings == 2:
+            Xp = np.copy(X)
+            Xp[0][~M] = X[1][~M]
+            Xp[1][~M] = X[0][~M]
+        else:
+            raise Exception
+
+        return Xp
+
+
+class BX(BinomialCrossover):
+    pass

pymoo/operators/crossover/dex.py

@@ -0,0 +1,125 @@
+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
+from pymoo.util import default_random_state
+
+
+@default_random_state
+def de_differential(X, F, dither=None, jitter=True, gamma=0.0001, return_differentials=False, random_state=None):
+    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 + random_state.random(n_matings) * (1 - F))
+        elif dither == "scalar":
+            F = F + random_state.random() * (1 - F)
+
+        # http://www.cs.ndsu.nodak.edu/~siludwig/Publish/papers/SSCI20141.pdf
+        if jitter:
+            F = (F * (1 + gamma * (random_state.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, *args, random_state, **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, random_state=random_state)
+
+        # prepare the out to be set
+        Xp = de_differential(X[:, m], F, random_state=random_state)
+
+        # 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, random_state=random_state)
+
+                # actually execute the differential equation
+                Xp[m] = de_differential(X[:, m], F, random_state=random_state)
+
+            # 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, random_state=random_state)
+        elif self.variant == "exp":
+            M = mut_exp(n_matings, n_var, self.CR, at_least_once=self.at_least_once, random_state=random_state)
+        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)
+
+
+@default_random_state
+def rnd_F(m, random_state=None):
+    return 0.5 * (1 + random_state.uniform(size=len(m)))

pymoo/operators/crossover/erx.py

@@ -0,0 +1,164 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.util import default_random_state
+
+
+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
+
+
+@default_random_state
+def erx(a, b, random_state=None):
+    """
+    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 = random_state.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 = random_state.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 = random_state.choice(_next)
+
+    return y
+
+
+class EdgeRecombinationCrossover(Crossover):
+
+    def __init__(self, **kwargs):
+        super().__init__(2, 1, **kwargs)
+
+    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, :]
+            Y[0, i, :] = erx(a, b, random_state=random_state)
+
+        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,53 @@
+import numpy as np
+
+from pymoo.core.crossover import Crossover
+from pymoo.core.variable import get, Real
+from pymoo.util import default_random_state
+from pymoo.util.misc import crossover_mask, row_at_least_once_true
+
+
+@default_random_state
+def mut_exp(n_matings, n_var, prob, at_least_once=True, random_state=None):
+    assert len(prob) == n_matings
+
+    # the mask do to the crossover
+    M = np.full((n_matings, n_var), False)
+
+    # start point of crossover
+    s = random_state.integers(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 random_state.random() <= prob[i]:
+                M[i, current] = True
+            else:
+                break
+
+    if at_least_once:
+        M = row_at_least_once_true(M, random_state=random_state)
+
+    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, random_state=None, **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, random_state=random_state)
+        _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, random_state=None, **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[random_state.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,25 @@
+from pymoo.core.crossover import Crossover
+from pymoo.core.population import Population
+
+
+class NoCrossover(Crossover):
+    def __init__(self, *, n_parents=1, n_offsprings=None, prob=0.0, **kwargs):
+        if n_offsprings is None:
+            n_offsprings = n_parents
+        super().__init__(n_parents, n_offsprings, prob, **kwargs)
+
+    def do(self, problem, pop, *args, random_state, **kwargs):
+        offsprings = []
+        for parents in pop:
+            if self.n_offsprings < self.n_parents:
+                # Select without replacement
+                offsprings.extend(random_state.choice(parents, size=self.n_offsprings, replace=False))
+            elif self.n_offsprings == self.n_parents:
+                # Return all parents as-is
+                offsprings.extend(parents)
+            else:
+                # Keep each parent at least once, then fill randomly
+                offsprings.extend(parents)
+                extra = self.n_offsprings - self.n_parents
+                offsprings.extend(random_state.choice(parents, size=extra, replace=True))
+        return Population.create(*offsprings)