pymoo 0.6.1.5.dev0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pymoo/operators/sampling/lhs.py

@@ -0,0 +1,73 @@
+import numpy as np
+
+from pymoo.core.sampling import Sampling
+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)
+
+
+def sampling_lhs(n_samples, n_var, xl=0, xu=1, smooth=True, criterion=criterion_maxmin, n_iter=50):
+
+    X = sampling_lhs_unit(n_samples, n_var, smooth=smooth)
+
+    # 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)
+            _score = criterion(_X)
+
+            if _score > score:
+                X, score = _X, _score
+
+    return xl + X * (xu - xl)
+
+
+def sampling_lhs_unit(n_samples, n_var, smooth=True):
+    X = np.random.random(size=(n_samples, n_var))
+    Xp = X.argsort(axis=0) + 1
+
+    if smooth:
+        Xp = Xp - np.random.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, **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)
+
+        return X
+
+
+class LHS(LatinHypercubeSampling):
+    pass

pymoo/operators/sampling/rnd.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+from pymoo.core.sampling import Sampling
+
+
+def random(problem, n_samples=1):
+    X = np.random.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, **kwargs):
+        X = np.random.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, **kwargs):
+        val = np.random.random((n_samples, problem.n_var))
+        return (val < 0.5).astype(bool)
+
+
+class IntegerRandomSampling(FloatRandomSampling):
+
+    def _do(self, problem, n_samples, **kwargs):
+        n, (xl, xu) = problem.n_var, problem.bounds()
+        return np.column_stack([np.random.randint(xl[k], xu[k] + 1, size=n_samples) for k in range(n)])
+
+
+class PermutationRandomSampling(Sampling):
+
+    def _do(self, problem, n_samples, **kwargs):
+        X = np.full((n_samples, problem.n_var), 0, dtype=int)
+        for i in range(n_samples):
+            X[i, :] = np.random.permutation(problem.n_var)
+        return X

pymoo/operators/selection/rnd.py

@@ -0,0 +1,72 @@
+import math
+
+import numpy as np
+
+from pymoo.core.selection import Selection
+from pymoo.util.misc import random_permutations
+
+
+class RandomSelection(Selection):
+
+    def _do(self, _, pop, n_select, n_parents, **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))[:n_random]
+
+        return np.reshape(P, (n_select, n_parents))
+
+
+def fast_fill_random(X, N, columns=None, Xp=None, n_max_attempts=10):
+    """
+
+    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):
+
+            if len(rem) > N:
+                X[rem, col] = np.random.choice(N, replace=True, size=len(rem))
+            else:
+                X[rem, col] = np.random.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,76 @@
+import math
+
+import numpy as np
+
+from pymoo.core.selection import Selection
+from pymoo.util.misc import random_permutations
+
+
+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, **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))[:n_random]
+        P = np.reshape(P, (n_select * n_parents, self.pressure))
+
+        # compare using tournament function
+        S = self.func_comp(pop, P, **kwargs)
+
+        return np.reshape(S, (n_select, n_parents))
+
+
+def compare(a, a_val, b, b_val, method, return_random_if_equal=False):
+    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 np.random.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 np.random.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

pymoo/operators/survival/rank_and_crowding/classes.py

@@ -0,0 +1,209 @@
+import numpy as np
+from pymoo.util.randomized_argsort import randomized_argsort
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.core.survival import Survival, split_by_feasibility
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding.metrics import get_crowding_function
+
+
+class RankAndCrowding(Survival):
+
+    def __init__(self, nds=None, crowding_func="cd"):
+        """
+        A generalization of the NSGA-II survival operator that ranks individuals by dominance criteria
+        and sorts the last front by some user-specified crowding metric. The default is NSGA-II's crowding distances
+        although others might be more effective.
+
+        For many-objective problems, try using 'mnn' or '2nn'.
+
+        For Bi-objective problems, 'pcd' is very effective.
+
+        Parameters
+        ----------
+        nds : str or None, optional
+            Pymoo type of non-dominated sorting. Defaults to None.
+
+        crowding_func : str or callable, optional
+            Crowding metric. Options are:
+
+                - 'cd': crowding distances
+                - 'pcd' or 'pruning-cd': improved pruning based on crowding distances
+                - 'ce': crowding entropy
+                - 'mnn': M-Neaest Neighbors
+                - '2nn': 2-Neaest Neighbors
+
+            If callable, it has the form ``fun(F, filter_out_duplicates=None, n_remove=None, **kwargs)``
+            in which F (n, m) and must return metrics in a (n,) array.
+
+            The options 'pcd', 'cd', and 'ce' are recommended for two-objective problems, whereas 'mnn' and '2nn' for many objective.
+            When using 'pcd', 'mnn', or '2nn', individuals are already eliminated in a 'single' manner. 
+            Due to Cython implementation, they are as fast as the corresponding 'cd', 'mnn-fast', or '2nn-fast', 
+            although they can singnificantly improve diversity of solutions.
+            Defaults to 'cd'.
+        """
+
+        crowding_func_ = get_crowding_function(crowding_func)
+
+        super().__init__(filter_infeasible=True)
+        self.nds = nds if nds is not None else NonDominatedSorting()
+        self.crowding_func = crowding_func_
+
+    def _do(self,
+            problem,
+            pop,
+            *args,
+            n_survive=None,
+            **kwargs):
+
+        # get the objective space values and objects
+        F = pop.get("F").astype(float, copy=False)
+
+        # the final indices of surviving individuals
+        survivors = []
+
+        # do the non-dominated sorting until splitting front
+        fronts = self.nds.do(F, n_stop_if_ranked=n_survive)
+
+        for k, front in enumerate(fronts):
+            
+            I = np.arange(len(front))
+
+            # current front sorted by crowding distance if splitting
+            if len(survivors) + len(I) > n_survive:
+
+                # Define how many will be removed
+                n_remove = len(survivors) + len(front) - n_survive
+
+                # re-calculate the crowding distance of the front
+                crowding_of_front = \
+                    self.crowding_func.do(
+                        F[front, :],
+                        n_remove=n_remove
+                    )
+
+                I = randomized_argsort(crowding_of_front, order='descending', method='numpy')
+                I = I[:-n_remove]
+
+            # otherwise take the whole front unsorted
+            else:
+                # calculate the crowding distance of the front
+                crowding_of_front = \
+                    self.crowding_func.do(
+                        F[front, :],
+                        n_remove=0
+                    )
+
+            # save rank and crowding in the individual class
+            for j, i in enumerate(front):
+                pop[i].set("rank", k)
+                pop[i].set("crowding", crowding_of_front[j])
+
+            # extend the survivors by all or selected individuals
+            survivors.extend(front[I])
+
+        return pop[survivors]
+
+
+class ConstrRankAndCrowding(Survival):
+
+    def __init__(self, nds=None, crowding_func="cd"):
+        """
+        The Rank and Crowding survival approach for handling constraints proposed on
+        GDE3 by Kukkonen, S. & Lampinen, J. (2005).
+
+        Parameters
+        ----------
+        nds : str or None, optional
+            Pymoo type of non-dominated sorting. Defaults to None.
+
+        crowding_func : str or callable, optional
+            Crowding metric. Options are:
+
+                - 'cd': crowding distances
+                - 'pcd' or 'pruning-cd': improved pruning based on crowding distances
+                - 'ce': crowding entropy
+                - 'mnn': M-Neaest Neighbors
+                - '2nn': 2-Neaest Neighbors
+
+            If callable, it has the form ``fun(F, filter_out_duplicates=None, n_remove=None, **kwargs)``
+            in which F (n, m) and must return metrics in a (n,) array.
+
+            The options 'pcd', 'cd', and 'ce' are recommended for two-objective problems, whereas 'mnn' and '2nn' for many objective.
+            When using 'pcd', 'mnn', or '2nn', individuals are already eliminated in a 'single' manner. 
+            Due to Cython implementation, they are as fast as the corresponding 'cd', 'mnn-fast', or '2nn-fast', 
+            although they can singnificantly improve diversity of solutions.
+            Defaults to 'cd'.
+        """
+
+        super().__init__(filter_infeasible=False)
+        self.nds = nds if nds is not None else NonDominatedSorting()
+        self.ranking = RankAndCrowding(nds=nds, crowding_func=crowding_func)
+
+    def _do(self,
+            problem,
+            pop,
+            *args,
+            n_survive=None,
+            **kwargs):
+
+        if n_survive is None:
+            n_survive = len(pop)
+
+        n_survive = min(n_survive, len(pop))
+
+        # If the split should be done beforehand
+        if problem.n_constr > 0:
+
+            # Split by feasibility
+            feas, infeas = split_by_feasibility(pop, sort_infeas_by_cv=True, sort_feas_by_obj=False, return_pop=False)
+
+            # Obtain len of feasible
+            n_feas = len(feas)
+
+            # Assure there is at least_one survivor
+            if n_feas == 0:
+                survivors = Population()
+            else:
+                survivors = self.ranking.do(problem, pop[feas], *args, n_survive=min(len(feas), n_survive), **kwargs)
+
+            # Calculate how many individuals are still remaining to be filled up with infeasible ones
+            n_remaining = n_survive - len(survivors)
+
+            # If infeasible solutions need to be added
+            if n_remaining > 0:
+
+                # Constraints to new ranking
+                G = pop[infeas].get("G")
+                G = np.maximum(G, 0)
+                H = pop[infeas].get("H")
+                H = np.absolute(H)
+                C = np.column_stack((G, H))
+
+                # Fronts in infeasible population
+                infeas_fronts = self.nds.do(C, n_stop_if_ranked=n_remaining)
+
+                # Iterate over fronts
+                for k, front in enumerate(infeas_fronts):
+
+                    # Save ranks
+                    pop[infeas][front].set("cv_rank", k)
+
+                    # Current front sorted by CV
+                    if len(survivors) + len(front) > n_survive:
+
+                        # Obtain CV of front
+                        CV = pop[infeas][front].get("CV").flatten()
+                        I = randomized_argsort(CV, order='ascending', method='numpy')
+                        I = I[:(n_survive - len(survivors))]
+
+                    # Otherwise take the whole front unsorted
+                    else:
+                        I = np.arange(len(front))
+
+                    # extend the survivors by all or selected individuals
+                    survivors = Population.merge(survivors, pop[infeas][front[I]])
+
+        else:
+            survivors = self.ranking.do(problem, pop, *args, n_survive=n_survive, **kwargs)
+
+        return survivors

pymoo/operators/survival/rank_and_crowding/metrics.py

@@ -0,0 +1,208 @@
+import numpy as np
+from scipy.spatial.distance import pdist, squareform
+from pymoo.util.misc import find_duplicates
+from pymoo.util.function_loader import load_function
+
+
+def get_crowding_function(label):
+
+    if label == "cd":
+        fun = FunctionalDiversity(calc_crowding_distance, filter_out_duplicates=False)
+    elif (label == "pcd") or (label == "pruning-cd"):
+        fun = FunctionalDiversity(load_function("calc_pcd"), filter_out_duplicates=True)
+    elif label == "ce":
+        fun = FunctionalDiversity(calc_crowding_entropy, filter_out_duplicates=True)
+    elif label == "mnn":
+        fun = FuncionalDiversityMNN(load_function("calc_mnn"), filter_out_duplicates=True)
+    elif label == "2nn":
+        fun = FuncionalDiversityMNN(load_function("calc_2nn"), filter_out_duplicates=True)
+    elif hasattr(label, "__call__"):
+        fun = FunctionalDiversity(label, filter_out_duplicates=True)
+    elif isinstance(label, CrowdingDiversity):
+        fun = label
+    else:
+        raise KeyError("Crowding function not defined")
+    return fun
+
+
+class CrowdingDiversity:
+
+    def do(self, F, n_remove=0):
+        # Converting types Python int to Cython int would fail in some cases converting to long instead
+        n_remove = np.intc(n_remove)
+        F = np.array(F, dtype=np.double)
+        return self._do(F, n_remove=n_remove)
+
+    def _do(self, F, n_remove=None):
+        pass
+
+
+class FunctionalDiversity(CrowdingDiversity):
+
+    def __init__(self, function=None, filter_out_duplicates=True):
+        self.function = function
+        self.filter_out_duplicates = filter_out_duplicates
+        super().__init__()
+
+    def _do(self, F, **kwargs):
+
+        n_points, n_obj = F.shape
+
+        if n_points <= 2:
+            return np.full(n_points, np.inf)
+
+        else:
+
+            if self.filter_out_duplicates:
+                # filter out solutions which are duplicates - duplicates get a zero finally
+                is_unique = np.where(np.logical_not(find_duplicates(F, epsilon=1e-32)))[0]
+            else:
+                # set every point to be unique without checking it
+                is_unique = np.arange(n_points)
+
+            # index the unique points of the array
+            _F = F[is_unique]
+
+            _d = self.function(_F, **kwargs)
+
+            d = np.zeros(n_points)
+            d[is_unique] = _d
+
+        return d
+
+
+class FuncionalDiversityMNN(FunctionalDiversity):
+
+    def _do(self, F, **kwargs):
+
+        n_points, n_obj = F.shape
+
+        if n_points <= n_obj:
+            return np.full(n_points, np.inf)
+
+        else:
+            return super()._do(F, **kwargs)
+
+
+def calc_crowding_distance(F, **kwargs):
+    n_points, n_obj = F.shape
+
+    # sort each column and get index
+    I = np.argsort(F, axis=0, kind='mergesort')
+
+    # sort the objective space values for the whole matrix
+    F = F[I, np.arange(n_obj)]
+
+    # calculate the distance from each point to the last and next
+    dist = np.row_stack([F, np.full(n_obj, np.inf)]) - np.row_stack([np.full(n_obj, -np.inf), F])
+
+    # calculate the norm for each objective - set to NaN if all values are equal
+    norm = np.max(F, axis=0) - np.min(F, axis=0)
+    norm[norm == 0] = np.nan
+
+    # prepare the distance to last and next vectors
+    dist_to_last, dist_to_next = dist, np.copy(dist)
+    dist_to_last, dist_to_next = dist_to_last[:-1] / norm, dist_to_next[1:] / norm
+
+    # if we divide by zero because all values in one columns are equal replace by none
+    dist_to_last[np.isnan(dist_to_last)] = 0.0
+    dist_to_next[np.isnan(dist_to_next)] = 0.0
+
+    # sum up the distance to next and last and norm by objectives - also reorder from sorted list
+    J = np.argsort(I, axis=0)
+    cd = np.sum(dist_to_last[J, np.arange(n_obj)] + dist_to_next[J, np.arange(n_obj)], axis=1) / n_obj
+
+    return cd
+
+
+def calc_crowding_entropy(F, **kwargs):
+    """Wang, Y.-N., Wu, L.-H. & Yuan, X.-F., 2010. Multi-objective self-adaptive differential 
+    evolution with elitist archive and crowding entropy-based diversity measure. 
+    Soft Comput., 14(3), pp. 193-209.
+
+    Parameters
+    ----------
+    F : 2d array like
+        Objective functions.
+
+    Returns
+    -------
+    ce : 1d array
+        Crowding Entropies
+    """
+    n_points, n_obj = F.shape
+
+    # sort each column and get index
+    I = np.argsort(F, axis=0, kind='mergesort')
+
+    # sort the objective space values for the whole matrix
+    F = F[I, np.arange(n_obj)]
+
+    # calculate the distance from each point to the last and next
+    dist = np.row_stack([F, np.full(n_obj, np.inf)]) - np.row_stack([np.full(n_obj, -np.inf), F])
+
+    # calculate the norm for each objective - set to NaN if all values are equal
+    norm = np.max(F, axis=0) - np.min(F, axis=0)
+    norm[norm == 0] = np.nan
+
+    # prepare the distance to last and next vectors
+    dl = dist.copy()[:-1]
+    du = dist.copy()[1:]
+
+    # Fix nan
+    dl[np.isnan(dl)] = 0.0
+    du[np.isnan(du)] = 0.0
+
+    # Total distance
+    cd = dl + du
+
+    # Get relative positions
+    pl = (dl[1:-1] / cd[1:-1])
+    pu = (du[1:-1] / cd[1:-1])
+
+    # Entropy
+    entropy = np.row_stack([np.full(n_obj, np.inf),
+                            -(pl * np.log2(pl) + pu * np.log2(pu)),
+                            np.full(n_obj, np.inf)])
+
+    # Crowding entropy
+    J = np.argsort(I, axis=0)
+    _cej = cd[J, np.arange(n_obj)] * entropy[J, np.arange(n_obj)] / norm
+    _cej[np.isnan(_cej)] = 0.0
+    ce = _cej.sum(axis=1)
+
+    return ce
+
+
+def calc_mnn_fast(F, **kwargs):
+    return _calc_mnn_fast(F, F.shape[1], **kwargs)
+
+
+def calc_2nn_fast(F, **kwargs):
+    return _calc_mnn_fast(F, 2, **kwargs)
+
+
+def _calc_mnn_fast(F, n_neighbors, **kwargs):
+
+    # calculate the norm for each objective - set to NaN if all values are equal
+    norm = np.max(F, axis=0) - np.min(F, axis=0)
+    norm[norm == 0] = 1.0
+
+    # F normalized
+    F = (F - F.min(axis=0)) / norm
+
+    # Distances pairwise (Inefficient)
+    D = squareform(pdist(F, metric="sqeuclidean"))
+
+    # M neighbors
+    M = F.shape[1]
+    _D = np.partition(D, range(1, M+1), axis=1)[:, 1:M+1]
+
+    # Metric d
+    d = np.prod(_D, axis=1)
+
+    # Set top performers as np.inf
+    _extremes = np.concatenate((np.argmin(F, axis=0), np.argmax(F, axis=0)))
+    d[_extremes] = np.inf
+
+    return d