pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/operators/survival/rank_and_crowding/classes.py

@@ -0,0 +1,212 @@
+import numpy as np
+
+from pymoo.core.population import Population
+from pymoo.core.survival import Survival, split_by_feasibility
+from pymoo.operators.survival.rank_and_crowding.metrics import get_crowding_function
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.util.randomized_argsort import randomized_argsort
+
+
+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,
+            random_state=None,
+            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', random_state=random_state)
+                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.functions 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.vstack([F, np.full(n_obj, np.inf)]) - np.vstack([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.vstack([F, np.full(n_obj, np.inf)]) - np.vstack([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.vstack([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

pymoo/optimize.py

@@ -0,0 +1,72 @@
+import copy
+
+
+def minimize(problem, algorithm, termination=None, copy_algorithm=True, copy_termination=True, **kwargs):
+    """
+
+    Minimization of function of one or more variables, objectives and constraints.
+
+    This is used as a convenience function to execute several algorithms with default settings which turned
+    out to work for a test single. However, evolutionary computations utilizes the idea of customizing a
+    meta-algorithm. Customizing the algorithm using the object-oriented interface is recommended to improve the
+    convergence.
+
+    Parameters
+    ----------
+
+    problem : :class:`~pymoo.core.problem.Problem`
+        A problem object which is defined using pymoo.
+
+    algorithm : :class:`~pymoo.core.algorithm.Algorithm`
+        The algorithm object that should be used for the optimization.
+
+    termination : :class:`~pymoo.core.termination.Termination` or tuple
+        The termination criterion that is used to stop the algorithm.
+
+    seed : integer
+        The random seed to be used.
+
+    verbose : bool
+        Whether output should be printed or not.
+
+    display : :class:`~pymoo.util.display.Display`
+        Each algorithm has a default display object for printouts. However, it can be overwritten if desired.
+
+    callback : :class:`~pymoo.core.callback.Callback`
+        A callback object which is called each iteration of the algorithm.
+
+    save_history : bool
+        Whether the history should be stored or not.
+
+    copy_algorithm : bool
+        Whether the algorithm object should be copied before optimization.
+
+    Returns
+    -------
+    res : :class:`~pymoo.core.result.Result`
+        The optimization result represented as an object.
+
+    """
+
+    # create a copy of the algorithm object to ensure no side effects
+    if copy_algorithm:
+        algorithm = copy.deepcopy(algorithm)
+
+    # initialize the algorithm object given a problem - if not set already
+    if algorithm.problem is None:
+        if termination is not None:
+
+            if copy_termination:
+                termination = copy.deepcopy(termination)
+
+            kwargs["termination"] = termination
+
+        algorithm.setup(problem, **kwargs)
+
+    # actually execute the algorithm
+    res = algorithm.run()
+
+    # store the deep copied algorithm in the result object
+    res.algorithm = algorithm
+
+    return res

pymoo/parallelization/__init__.py

@@ -0,0 +1,15 @@
+"""
+Parallelization utilities for pymoo.
+"""
+
+from .starmap import StarmapParallelization
+from .dask import DaskParallelization
+from .joblib import JoblibParallelization
+from .ray import RayParallelization
+
+__all__ = [
+    'StarmapParallelization', 
+    'DaskParallelization', 
+    'JoblibParallelization', 
+    'RayParallelization'
+]

pymoo/parallelization/dask.py

@@ -0,0 +1,25 @@
+"""
+Dask-based parallelization for pymoo.
+"""
+
+
+class DaskParallelization:
+    """Parallelization using Dask distributed client.
+    
+    Parameters
+    ----------
+    client : dask.distributed.Client
+        Dask client for distributed computing
+    """
+
+    def __init__(self, client):
+        self.client = client
+
+    def __call__(self, f, X):
+        jobs = [self.client.submit(f, x) for x in X]
+        return [job.result() for job in jobs]
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("client", None)
+        return state

pymoo/parallelization/joblib.py

@@ -0,0 +1,28 @@
+
+class JoblibParallelization:
+    """Parallelization using joblib.
+    
+    Parameters
+    ----------
+    n_jobs : int, default=-1
+        Number of parallel jobs. -1 uses all available cores.
+    **kwargs
+        Additional arguments passed to joblib.Parallel
+    """
+
+    def __init__(self, n_jobs=-1, **kwargs):
+        try:
+            import joblib
+        except ImportError:
+            raise ImportError("joblib must be installed: pip install joblib")
+        
+        self.joblib = joblib
+        self.n_jobs = n_jobs
+        self.kwargs = kwargs
+
+    def __call__(self, f, X):
+        with self.joblib.Parallel(n_jobs=self.n_jobs, **self.kwargs) as parallel:
+            return parallel(self.joblib.delayed(f)(x) for x in X)
+
+    def __getstate__(self):
+        return self.__dict__.copy()

pymoo/parallelization/ray.py

@@ -0,0 +1,31 @@
+"""
+Ray-based parallelization for pymoo.
+"""
+
+
+class RayParallelization:
+    """Parallelization using Ray.
+    
+    Parameters
+    ----------
+    job_resources : dict, default={'num_cpus': 1}
+        Ray resource requirements per job
+    """
+
+    def __init__(self, job_resources={'num_cpus': 1}):
+        try:
+            import ray
+        except ImportError:
+            raise ImportError("Ray must be installed: pip install ray")
+        
+        self.ray = ray
+        self.job_resources = job_resources
+
+    def __call__(self, f, X):
+        runnable = self.ray.remote(f.__call__.__func__)
+        runnable = runnable.options(**self.job_resources)
+        futures = [runnable.remote(f, x) for x in X]
+        return self.ray.get(futures)
+
+    def __getstate__(self):
+        return self.__dict__.copy()

pymoo/parallelization/starmap.py

@@ -0,0 +1,24 @@
+"""
+Starmap-based parallelization for pymoo.
+"""
+
+
+class StarmapParallelization:
+    """Parallelization using a starmap function.
+    
+    Parameters
+    ----------
+    starmap : callable
+        A starmap function like multiprocessing.Pool.starmap
+    """
+
+    def __init__(self, starmap):
+        self.starmap = starmap
+
+    def __call__(self, f, X):
+        return list(self.starmap(f, [[x] for x in X]))
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("starmap", None)
+        return state