pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/core/selection.py

@@ -0,0 +1,61 @@
+from abc import abstractmethod
+
+import numpy as np
+
+from pymoo.core.operator import Operator
+from pymoo.util import default_random_state
+
+
+class Selection(Operator):
+
+    def __init__(self, **kwargs) -> None:
+        """
+        This class is used to select parents for the mating or other evolutionary operators.
+        Several strategies can be used to increase the selection pressure.
+        """
+        super().__init__(**kwargs)
+
+    @default_random_state
+    def do(self, problem, pop, n_select, n_parents, to_pop=True, *args, random_state=None, **kwargs):
+        """
+        Choose from the population new individuals to be selected.
+
+        Parameters
+        ----------
+
+
+        problem: class
+            The problem to be solved. Provides information such as lower and upper bounds or feasibility
+            conditions for custom crossovers.
+
+        pop : :class:`~pymoo.core.population.Population`
+            The population which should be selected from. Some criteria from the design or objective space
+            might be used for the selection. Therefore, only the number of individual might be not enough.
+
+        n_select : int
+            Number of individuals to select.
+
+        n_parents : int
+            Number of parents needed to create an offspring.
+
+        to_pop : bool
+            Whether IF(!) the implementation returns only indices, it should be converted to individuals.
+
+        Returns
+        -------
+        parents : list
+            List of parents to be used in the crossover
+
+        """
+
+        ret = self._do(problem, pop, n_select, n_parents, *args, random_state=random_state, **kwargs)
+
+        # if some selections return indices they are used to create the individual list
+        if to_pop and isinstance(ret, np.ndarray) and np.issubdtype(ret.dtype, np.integer):
+            ret = pop[ret]
+
+        return ret
+
+    @abstractmethod
+    def _do(self, problem, pop, n_select, n_parents, *args, random_state=None, **kwargs):
+        pass

pymoo/core/solution.py

@@ -0,0 +1,10 @@
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+
+
+class Solution(Individual):
+    pass
+
+
+class SolutionSet(Population):
+    pass

pymoo/core/survival.py

@@ -0,0 +1,107 @@
+from abc import abstractmethod
+
+import numpy as np
+
+from pymoo.core.population import Population
+from pymoo.util import default_random_state
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Survival
+# ---------------------------------------------------------------------------------------------------------
+
+
+class Survival:
+
+    def __init__(self, filter_infeasible=True):
+        super().__init__()
+        self.filter_infeasible = filter_infeasible
+
+    @default_random_state
+    def do(self,
+           problem,
+           pop,
+           *args,
+           n_survive=None,
+           random_state=None,
+           return_indices=False,
+           **kwargs):
+
+        # make sure the population has at least one individual
+        if len(pop) == 0:
+            return pop
+
+        if n_survive is None:
+            n_survive = len(pop)
+
+        n_survive = min(n_survive, len(pop))
+
+        # if the split should be done beforehand
+        if self.filter_infeasible and problem.has_constraints():
+
+            # split feasible and infeasible solutions
+            feas, infeas = split_by_feasibility(pop, sort_infeas_by_cv=True)
+
+            if len(feas) == 0:
+                survivors = Population()
+            else:
+                survivors = self._do(problem, pop[feas], *args, n_survive=min(len(feas), n_survive),
+                                     random_state=random_state, **kwargs)
+
+            # calculate how many individuals are still remaining to be filled up with infeasible ones
+            n_remaining = n_survive - len(survivors)
+
+            # if infeasible solutions needs to be added
+            if n_remaining > 0:
+                survivors = Population.merge(survivors, pop[infeas[:n_remaining]])
+
+        else:
+            survivors = self._do(problem, pop, *args, n_survive=n_survive, random_state=random_state, **kwargs)
+
+        if return_indices:
+            H = {}
+            for k, ind in enumerate(pop):
+                H[ind] = k
+            return [H[survivor] for survivor in survivors]
+        else:
+            return survivors
+
+    @abstractmethod
+    def _do(self, problem, pop, *args, n_survive=None, random_state=None, **kwargs):
+        pass
+
+
+class ToReplacement(Survival):
+
+    def __init__(self, survival):
+        super().__init__(False)
+        self.survival = survival
+
+    def _do(self, problem, pop, off, random_state=None, **kwargs):
+        merged = Population.merge(pop, off)
+        I = self.survival.do(problem, merged, n_survive=len(merged), return_indices=True, random_state=random_state, **kwargs)
+        merged.set("__rank__", I)
+
+        for k in range(len(pop)):
+            if off[k].get("__rank__") < pop[k].get("__rank__"):
+                pop[k] = off[k]
+
+        return pop
+
+
+def split_by_feasibility(pop, sort_infeas_by_cv=True, sort_feas_by_obj=False, return_pop=False):
+    F, CV, b = pop.get("F", "CV", "FEAS")
+
+    feasible = np.where(b)[0]
+    infeasible = np.where(~b)[0]
+
+    if sort_infeas_by_cv:
+        infeasible = infeasible[np.argsort(CV[infeasible, 0])]
+
+    if sort_feas_by_obj:
+        feasible = feasible[np.argsort(F[feasible, 0])]
+
+    if not return_pop:
+        return feasible, infeasible
+    else:
+        return feasible, infeasible, pop[feasible], pop[infeasible]

pymoo/core/termination.py

@@ -0,0 +1,70 @@
+from abc import abstractmethod
+
+
+class Termination:
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # the algorithm can be forced to terminate by setting this attribute to true
+        self.force_termination = False
+
+        # the value indicating how much perc has been made
+        self.perc = 0.0
+
+    def update(self, algorithm):
+        """
+        Provide the termination criterion a current status of the algorithm to update the perc.
+
+        Parameters
+        ----------
+        algorithm : object
+            The algorithm object which is used to determine whether a run has terminated.
+        """
+
+        if self.force_termination:
+            progress = 1.0
+        else:
+            progress = self._update(algorithm)
+            assert progress >= 0.0, "Invalid progress was set by the TerminationCriterion."
+
+        self.perc = progress
+        return self.perc
+
+    def has_terminated(self):
+        return self.perc >= 1.0
+
+    def do_continue(self):
+        return not self.has_terminated()
+
+    def terminate(self):
+        self.force_termination = True
+
+    @abstractmethod
+    def _update(self, algorithm):
+        pass
+
+
+class NoTermination(Termination):
+
+    def _update(self, algorithm):
+        return 0.0
+
+
+class MultipleCriteria(Termination):
+
+    def __init__(self, *args) -> None:
+        super().__init__()
+        self.criteria = args
+
+
+class TerminateIfAny(MultipleCriteria):
+
+    def _update(self, algorithm):
+        return max([termination.update(algorithm) for termination in self.criteria])
+
+
+class TerminateIfAll(MultipleCriteria):
+
+    def _update(self, algorithm):
+        return min([termination.update(algorithm) for termination in self.criteria])

pymoo/core/variable.py

@@ -0,0 +1,415 @@
+"""
+Module containing infrastructure for representing decision variable classes.
+"""
+
+# public API for when using ``from pymoo.core.variable import *``
+__all__ = [
+    "Variable",
+    "BoundedVariable",
+    "Real",
+    "Integer",
+    "Binary",
+    "Choice",
+    "get",
+]
+
+from typing import Any, Optional, Tuple
+from typing import Union
+import numpy as np
+from numpy.typing import ArrayLike
+from pymoo.util import default_random_state
+
+
+class Variable(object):
+    """
+    Semi-abstract base class for the representation of a decision variable.
+    """
+
+    def __init__(
+            self, 
+            value: Optional[object] = None, 
+            active: bool = True, 
+            flag: str = "default",
+        ) -> None:
+        """
+        Constructor for the ``Variable`` class.
+
+        Parameters
+        ----------
+        value : object, None
+            Value the decision variable is to take.
+        active : bool
+            Whether the variable is active (``True``) or inactive (``False``).
+        flag : str
+            Flag to bind to the decision variable.
+        """
+        super().__init__()
+        self.value = value
+        self.flag = flag
+        self.active = active
+
+    @default_random_state
+    def sample(
+            self, 
+            n: Optional[int] = None,
+            random_state=None,
+        ) -> Union[object,np.ndarray]:
+        """
+        Randomly sample ``n`` instances of a decision variable.
+
+        Parameters
+        ----------
+        n : int, None
+            Number of decision variable samples which to draw.
+            If ``int``, sample ``n`` decision variables.
+            If ``None``, sample a single decision variables.
+        
+        Returns
+        -------
+        out : object, np.ndarray
+            If ``n`` is ``int``, return a ``np.ndarray`` of shape ``(n,)`` 
+            containing sampled decision variables.
+            If ``n`` is ``None``, return an ``object`` of a sampled decision 
+            variable.
+        """
+        if n is None:
+            return self._sample(1, random_state=random_state)[0]
+        else:
+            return self._sample(n, random_state=random_state)
+
+    def _sample(
+            self, 
+            n: int,
+            random_state=None,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a decision variable.
+        This is an abstract private method governing the behavior of the 
+        ``sample`` method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled decision variables.
+        """
+        pass
+
+    def set(
+            self, 
+            value: object,
+        ) -> None:
+        """
+        Set the value of a decision variable.
+
+        Parameters
+        ----------
+        value : object
+            Value to assign to the decision variable.
+        """
+        self.value = value
+
+    def get(
+            self, 
+            **kwargs: Any
+        ) -> object:
+        """
+        Get the value of a decision variable.
+
+        Parameters
+        ----------
+        kwargs : Any
+            Additional keyword arguments.
+        
+        Returns
+        -------
+        out : object
+            The value of the decision variable.
+        """
+        return self.value
+
+
+class BoundedVariable(Variable):
+    """
+    Semi-abstract class for the representation of a bounded decision variable.
+    """
+
+    def __init__(
+            self, 
+            value: Optional[object] = None, 
+            bounds: Tuple[Optional[object],Optional[object]] = (None, None), 
+            strict: Optional[Tuple[Optional[object],Optional[object]]] = None, 
+            **kwargs: Any,
+        ) -> None:
+        """
+        Constructor for the ``BoundedVariable`` class.
+
+        Parameters
+        ----------
+        value : object
+            Value the decision variable is to take.
+        bounds : tuple
+            A tuple of length 2 containing upper and lower limits for the 
+            decision variable.
+        strict : tuple, None
+            Strict boundaries for the decision variable.
+            If ``None``, the value of ``bounds`` is copied to ``strict``.
+        kwargs : Any
+            Additional keyword arguments for ``active`` and ``flag``.
+        """
+        # call the Variable constructor 
+        super().__init__(value=value, **kwargs)
+        self.bounds = bounds
+
+        # if no strict boundaries were provided, consider ``bounds`` as 
+        # strict boundaries
+        if strict is None:
+            strict = bounds
+        self.strict = strict
+
+    @property
+    def lb(self) -> object:
+        """
+        Lower bound of the decision variable.
+
+        Returns
+        -------
+        out : object
+            The decision variable lower bound.
+        """
+        return self.bounds[0]
+
+    @property
+    def ub(self) -> object:
+        """
+        Upper bound of the decision variable.
+
+        Returns
+        -------
+        out : object
+            The decision variable upper bound.
+        """
+        return self.bounds[1]
+
+
+class Real(BoundedVariable):
+    """
+    Class for the representation of bounded, real decision variables.
+    """
+    # variable type represented by this object class
+    vtype = float
+
+    def _sample(
+            self, 
+            n: int,
+            random_state=None,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a real, bounded decision variable.
+        Decision variables are sampled from a uniform distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+        random_state
+            Random state for sampling.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled real, bounded 
+            decision variables.
+        """
+        low, high = self.bounds
+        return random_state.uniform(low=low, high=high, size=n)
+
+
+class Integer(BoundedVariable):
+    """
+    Class for the representation of bounded, integer decision variables.
+    """
+    # variable type represented by this object class
+    vtype = int
+
+    def _sample(
+            self, 
+            n: int,
+            random_state=None,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a bounded, integer decision variable.
+        Decision variables are sampled from a uniform distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+        random_state
+            Random state for sampling.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled bounded, integer 
+            decision variables.
+        """
+        low, high = self.bounds
+        return random_state.integers(low, high + 1, size=n)
+
+
+class Binary(BoundedVariable):
+    """
+    Class for the representation of a binary, bounded decision variable.
+    """
+    # variable type represented by this object class
+    vtype = bool
+
+    def _sample(
+            self, 
+            n: int,
+            random_state=None,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a bounded, binary decision variable.
+        Decision variables are sampled from a uniform distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+        random_state
+            Random state for sampling.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled bounded, binary 
+            decision variables.
+        """
+        return random_state.random(size=n) < 0.5
+
+
+class Choice(Variable):
+    """
+    Class for the representation of a discrete, subset decision variable.
+    """
+    # variable type represented by this object class
+    vtype = object
+
+    def __init__(
+            self, 
+            value: Optional[object] = None, 
+            options: Optional[ArrayLike] = None, 
+            all: Optional[ArrayLike] = None, 
+            **kwargs: Any,
+        ) -> None:
+        """
+        Constructor for the ``Choice`` class.
+
+        Parameters
+        ----------
+        value : object
+            Value the decision variable is to take.
+        options : ArrayLike, None
+            A list of decision variable options from which to choose.
+        all : ArrayLike, None
+            A strict list of decision variable options from which to choose.
+            If ``None``, the value of ``options`` is copied to ``all``.
+        kwargs : Any
+            Additional keyword arguments for ``active`` and ``flag``.
+        """
+        # all super constructor
+        super().__init__(value=value, **kwargs)
+        self.options = options
+
+        # if strict list not provided, set to ``options``
+        if all is None:
+            all = options
+        self.all = all
+
+    def _sample(
+            self, 
+            n: int,
+            random_state=None,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a discrete, subset decision variable.
+        Decision variables are sampled with replacement from a uniform 
+        distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+        random_state
+            Random state for sampling.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled bounded, integer 
+            decision variables.
+        """
+        return random_state.choice(self.options, size=n)
+
+
+def get(
+        *args: Tuple[Union[Variable,object],...], 
+        size: Optional[Union[tuple,int]] = None, 
+        **kwargs: Any
+    ) -> Union[tuple,object,None]:
+    """
+    Get decision variable values from a tuple of ``Variable`` objects.
+
+    Parameters
+    ----------
+    args : tuple
+        A tuple of ``Variable`` or ``object``s.
+    size : tuple, int, None
+        Size to reshape decision variables.
+    kwargs : Any
+        Additional keyword arguments to pass to the ``get`` method of the 
+        ``Variable`` class when getting decision variable values.
+    
+    Returns
+    -------
+    out : tuple, object, None
+        Decision variable value(s).
+    """
+    if len(args) == 0:
+        return
+
+    ret = []
+    for arg in args:
+        v = arg.get(**kwargs) if isinstance(arg, Variable) else arg
+
+        if size is not None:
+
+            if isinstance(v, np.ndarray):
+                v = np.reshape(v, size)
+            else:
+                v = np.full(size, v)
+
+        ret.append(v)
+
+    if len(ret) == 1:
+        return ret[0]
+    else:
+        return tuple(ret)

pymoo/decomposition/aasf.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+from pymoo.decomposition.asf import ASF
+
+
+class AASF(ASF):
+
+    def __init__(self, eps=1e-10, _type="auto", rho=None, beta=None, **kwargs) -> None:
+        super().__init__(eps, _type, **kwargs)
+        if rho is None and beta is None:
+            raise Exception("Either provide rho or beta!")
+        elif rho is None:
+            self.rho = calc_rho(beta)
+        else:
+            self.rho = rho
+
+    def _do(self, F, weights, **kwargs):
+        asf = super()._do(F, weights, **kwargs)
+        augment = ((F - self.utopian_point) / np.clip(weights, 1e-12, np.inf)).sum(axis=1)
+        return asf + self.rho * augment
+
+
+def calc_rho(beta):
+    return 1 / (1 - np.tan(beta / 360 * 2 * np.pi)) - 1

pymoo/decomposition/asf.py

@@ -0,0 +1,10 @@
+from pymoo.core.decomposition import Decomposition
+
+
+class ASF(Decomposition):
+
+    def _do(self, F, weights, weight_0=1e-10, **kwargs):
+        _weights = weights.astype(float)
+        _weights[weights == 0] = weight_0
+        asf = ((F - self.utopian_point) / _weights).max(axis=1)
+        return asf