pymoo 0.6.1.5.dev0__cp310-cp310-macosx_11_0_arm64.whl

pymoo/core/decision_making.py

@@ -0,0 +1,102 @@
+import numpy as np
+from scipy.spatial.ckdtree import cKDTree
+
+from pymoo.core.indicator import Indicator
+
+
+class DecisionMaking(Indicator):
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.default_if_empty = None
+
+    def _do(self, F, *args, **kwargs):
+        pass
+
+
+class NeighborFinder:
+
+    def __init__(self, N,
+                 epsilon=0.125,
+                 n_neighbors=None,
+                 n_min_neigbors=None,
+                 consider_2d=True):
+
+        super().__init__()
+        self.N = N
+        self.consider_2d = consider_2d
+
+        _, n_dim = N.shape
+
+        # at least find min(dimensionality times two neighbors, number PO solutions - 1) - if enabled
+        if n_min_neigbors == "auto":
+            self.n_min_neigbors = min(2 * n_dim, _ - 1)
+
+        # disable the minimum neighbor variable
+        else:
+            self.n_min_neigbors = np.inf
+
+        # either choose epsilon
+        self.epsilon = epsilon
+
+        # if none choose the number of neighbors
+        self.n_neighbors = n_neighbors
+
+        if self.N.shape[1] == 1:
+            raise Exception("At least 2 objectives must be provided.")
+
+        elif self.consider_2d and self.N.shape[1] == 2:
+            self.min, self.max = N.min(), N.max()
+            self.rank = np.argsort(N[:, 0])
+            self.pos_in_rank = np.argsort(self.rank)
+
+        else:
+            self.tree = cKDTree(N)
+
+    def find(self, i):
+
+        if self.consider_2d and self.N.shape[1] == 2:
+            neighbours = []
+
+            pos = self.pos_in_rank[i]
+            if pos > 0:
+                neighbours.append(self.rank[pos - 1])
+            if pos < len(self.N) - 1:
+                neighbours.append(self.rank[pos + 1])
+
+        else:
+
+            # for each neighbour in a specific radius of that solution
+            if self.epsilon is not None:
+                neighbours = self.tree.query_ball_point([self.N[i]], self.epsilon).tolist()[0]
+            elif self.n_neighbors is not None:
+                neighbours = self.tree.query([self.N[i]], k=self.n_neighbors + 1)[1].tolist()[0]
+            else:
+                raise Exception("Either define epsilon or number of neighbors.")
+
+            # in case n_min_neigbors is enabled
+            if len(neighbours) < self.n_min_neigbors:
+                neighbours = self.tree.query([self.N[i]], k=self.n_min_neigbors + 1)[1].tolist()[0]
+
+        return neighbours
+
+
+def find_outliers_upper_tail(mu):
+
+    # remove values that are nan
+    I = np.where(np.logical_and(np.logical_not(np.isnan(mu)), np.logical_not(np.isinf(mu))))[0]
+    mu = mu[I]
+
+    # calculate mean and sigma
+    mean, sigma = mu.mean(), mu.std()
+
+    # calculate the deviation in terms of sigma
+    deviation = (mu - mean) / sigma
+
+    # 2 * sigma is considered as an outlier
+    S = I[np.where(deviation >= 2)[0]]
+
+    if len(S) == 0 and deviation.max() > 1:
+        S = I[[np.argmax(mu)]]
+
+    return S if len(S) > 0 else None

pymoo/core/decomposition.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from pymoo.util.misc import at_least_2d_array, to_1d_array_if_possible
+
+
+class Decomposition:
+
+    def __init__(self, eps=0.0, _type="auto", **kwargs) -> None:
+        super().__init__()
+        self.eps = eps
+        self._type = _type
+        self.ideal_point, self.utopian_point, self.nadir_point = None, None, None
+
+    def __call__(self, *args, **kwargs):
+        return self.do(*args, **kwargs)
+
+    def do(self,
+           F,
+           weights,
+           _type="auto",
+           ideal_point=None,
+           utopian_point=None,
+           nadir_point=None,
+           **kwargs):
+
+        _F, _weights = to_1d_array_if_possible(F), to_1d_array_if_possible(weights)
+
+        if _type == "auto":
+            if _F.ndim == 1 and _weights.ndim > 1:
+                _type = "one_to_many"
+            elif _F.ndim > 1 and _weights.ndim == 1:
+                _type = "many_to_one"
+            elif _F.ndim == 2 and _weights.ndim == 2 and _F.shape[0] == _weights.shape[0]:
+                _type = "one_to_one"
+            else:
+                _type = "many_to_many"
+
+        # make both at least 2d arrays
+        F, weights = at_least_2d_array(F), at_least_2d_array(weights)
+
+        # get the number of points and weights
+        n_points, n_weights = F.shape[0], weights.shape[0]
+
+        self.ideal_point = ideal_point
+        if self.ideal_point is None:
+            self.ideal_point = np.zeros(F.shape[1])
+
+        self.utopian_point = utopian_point
+        if self.utopian_point is None:
+            self.utopian_point = self.ideal_point - self.eps
+
+        # set the nadir point by default to value or default
+        self.nadir_point = nadir_point
+        if self.nadir_point is None:
+            self.nadir_point = self.utopian_point + np.ones(F.shape[1])
+
+        if _type == "one_to_one":
+            D = self._do(F, weights=weights, **kwargs).flatten()
+
+        elif _type == "one_to_many":
+            F = np.repeat(F, n_weights, axis=0)
+            D = self._do(F, weights=weights, **kwargs).flatten()
+
+        elif _type == "many_to_one":
+            weights = np.repeat(weights, n_points, axis=0)
+            D = self._do(F, weights=weights, **kwargs).flatten()
+
+        elif _type == "many_to_many":
+            F = np.repeat(F, n_weights, axis=0)
+            weights = np.tile(weights, (n_points, 1))
+            D = self._do(F, weights=weights, **kwargs).reshape(n_points, n_weights)
+
+        else:
+            raise Exception("Unknown type for decomposition: %s" % _type)
+
+        return D

pymoo/core/duplicate.py

@@ -0,0 +1,163 @@
+import numpy as np
+
+from pymoo.util.misc import cdist
+
+
+def default_attr(pop):
+    return pop.get("X")
+
+
+class DuplicateElimination:
+
+    def __init__(self, func=None) -> None:
+        super().__init__()
+        self.func = func
+
+        if self.func is None:
+            self.func = default_attr
+
+    def do(self, pop, *args, return_indices=False, to_itself=True):
+        original = pop
+
+        if len(pop) == 0:
+            return (pop, [], []) if return_indices else pop
+
+        if to_itself:
+            pop = pop[~self._do(pop, None, np.full(len(pop), False))]
+
+        for arg in args:
+            if len(arg) > 0:
+
+                if len(pop) == 0:
+                    break
+                elif len(arg) == 0:
+                    continue
+                else:
+                    pop = pop[~self._do(pop, arg, np.full(len(pop), False))]
+
+        if return_indices:
+            no_duplicate, is_duplicate = [], []
+            H = set(pop)
+
+            for i, ind in enumerate(original):
+                if ind in H:
+                    no_duplicate.append(i)
+                else:
+                    is_duplicate.append(i)
+
+            return pop, no_duplicate, is_duplicate
+        else:
+            return pop
+
+    def _do(self, pop, other, is_duplicate):
+        return is_duplicate
+
+
+class DefaultDuplicateElimination(DuplicateElimination):
+
+    def __init__(self, epsilon=1e-16, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.epsilon = epsilon
+
+    def calc_dist(self, pop, other=None):
+        X = self.func(pop)
+
+        if other is None:
+            D = cdist(X, X)
+            D[np.triu_indices(len(X))] = np.inf
+        else:
+            _X = self.func(other)
+            D = cdist(X, _X)
+
+        return D
+
+    def _do(self, pop, other, is_duplicate):
+        D = self.calc_dist(pop, other)
+        D[np.isnan(D)] = np.inf
+
+        is_duplicate[np.any(D <= self.epsilon, axis=1)] = True
+        return is_duplicate
+
+
+def to_float(val):
+    if isinstance(val, bool) or isinstance(val, np.bool_):
+        return 0.0 if val else 1.0
+    else:
+        return val
+
+
+class ElementwiseDuplicateElimination(DefaultDuplicateElimination):
+
+    def __init__(self, cmp_func=None, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        if cmp_func is None:
+            cmp_func = self.is_equal
+
+        self.cmp_func = cmp_func
+
+    def is_equal(self, a, b):
+        pass
+
+    def _do(self, pop, other, is_duplicate):
+
+        if other is None:
+            for i in range(len(pop)):
+                for j in range(i + 1, len(pop)):
+                    val = to_float(self.cmp_func(pop[i], pop[j]))
+                    if val < self.epsilon:
+                        is_duplicate[i] = True
+                        break
+        else:
+            for i in range(len(pop)):
+                for j in range(len(other)):
+                    val = to_float(self.cmp_func(pop[i], other[j]))
+                    if val < self.epsilon:
+                        is_duplicate[i] = True
+                        break
+
+        return is_duplicate
+
+
+def to_hash(x):
+    try:
+        h = hash(x)
+    except:
+        try:
+            h = hash(str(x))
+        except:
+            raise Exception("Hash could not be calculated. Please use another duplicate elimination.")
+
+    return h
+
+
+class HashDuplicateElimination(DuplicateElimination):
+
+    def __init__(self, func=to_hash) -> None:
+        super().__init__()
+        self.func = func
+
+    def _do(self, pop, other, is_duplicate):
+        H = set()
+
+        if other is not None:
+            for o in other:
+                val = self.func(o)
+                H.add(self.func(val))
+
+        for i, ind in enumerate(pop):
+            val = self.func(ind)
+            h = self.func(val)
+
+            if h in H:
+                is_duplicate[i] = True
+            else:
+                H.add(h)
+
+        return is_duplicate
+
+
+class NoDuplicateElimination(DuplicateElimination):
+
+    def do(self, pop, *args, **kwargs):
+        return pop

pymoo/core/evaluator.py

@@ -0,0 +1,116 @@
+import numpy as np
+
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.core.problem import Problem
+
+
+class Evaluator:
+
+    def __init__(self,
+                 skip_already_evaluated: bool = True,
+                 evaluate_values_of: list = ["F", "G", "H"],
+                 callback=None):
+
+        """
+        The evaluator has the purpose to glue the problem with the population/individual objects.
+        Additionally, it serves as a bookkeeper to store determine the number of function evaluations of runs, time,
+        and others.
+
+
+        Parameters
+        ----------
+        skip_already_evaluated : bool
+            If individual that are already evaluated shall be skipped.
+
+        evaluate_values_of : list
+            The type of values to be asked the problem to evaluated. By default all objective, ieq. and eq. constraints.
+
+        """
+
+        self.evaluate_values_of = evaluate_values_of
+        self.skip_already_evaluated = skip_already_evaluated
+        self.callback = callback
+
+        # current number of function evaluations - initialized to zero
+        self.n_eval = 0
+
+    def eval(self,
+             problem: Problem,
+             pop: Population,
+             skip_already_evaluated: bool = None,
+             evaluate_values_of: list = None,
+             count_evals: bool = True,
+             **kwargs):
+
+        # load the default settings from the evaluator object if not already provided
+        evaluate_values_of = self.evaluate_values_of if evaluate_values_of is None else evaluate_values_of
+        skip_already_evaluated = self.skip_already_evaluated if skip_already_evaluated is None else skip_already_evaluated
+
+        # check the type of the input
+        is_individual = isinstance(pop, Individual)
+
+        # make sure the object is a population
+        if is_individual:
+            pop = Population().create(pop)
+
+        # filter the index to have individual where not all attributes have been evaluated
+        if skip_already_evaluated:
+            I = [i for i, ind in enumerate(pop) if not all([e in ind.evaluated for e in evaluate_values_of])]
+
+        # if skipping is deactivated simply make the index being all individuals
+        else:
+            I = np.arange(len(pop))
+
+        # evaluate the solutions (if there are any)
+        if len(I) > 0:
+
+            # do the actual evaluation - call the sub-function to set the corresponding values to the population
+            self._eval(problem, pop[I], evaluate_values_of, **kwargs)
+
+        # update the function evaluation counter
+        if count_evals:
+            self.n_eval += len(I)
+
+        # allow to have a callback registered
+        if self.callback:
+            self.callback(pop)
+
+        if is_individual:
+            return pop[0]
+        else:
+            return pop
+
+    def _eval(self, problem, pop, evaluate_values_of, **kwargs):
+
+        # get the design space value from the individuals
+        X = pop.get("X")
+
+        # call the problem to evaluate the solutions
+        out = problem.evaluate(X, return_values_of=evaluate_values_of, return_as_dictionary=True, **kwargs)
+
+        # for each of the attributes set it to the problem
+        for key, val in out.items():
+            if val is not None:
+                pop.set(key, val)
+
+        # finally set all the attributes to be evaluated for all individuals
+        pop.apply(lambda ind: ind.evaluated.update(out.keys()))
+
+
+class VoidEvaluator(Evaluator):
+
+    def __init__(self, value=np.inf, **kwargs):
+        super().__init__(**kwargs)
+        self.value = value
+
+    def eval(self, problem, pop, **kwargs):
+        val = self.value
+        if val is not None:
+            for individual in pop:
+                if len(individual.evaluated) == 0:
+                    individual.F = np.full(problem.n_obj, val)
+                    individual.G = np.full(problem.n_ieq_constr, val) if problem.n_ieq_constr > 0 else None
+                    individual.H = np.full(problem.n_eq_constr, val) if problem.n_eq_constr else None
+                    individual.CV = [-np.inf]
+                    individual.feas = [False]

pymoo/core/indicator.py

@@ -0,0 +1,34 @@
+import abc
+
+from pymoo.util.normalization import PreNormalization
+
+
+class Indicator(PreNormalization):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # what should an indicator return if no solutions are provided is defined here
+        self.default_if_empty = 0.0
+
+    def __call__(self, F, *args, **kwargs):
+        return self.do(F, *args, **kwargs)
+
+    def do(self, F, *args, **kwargs):
+
+        # if it is a 1d array
+        if F.ndim == 1:
+            F = F[None, :]
+
+        # if no points have been provided just return the default
+        if len(F) == 0:
+            return self.default_if_empty
+
+        # do the normalization - will only be done if zero_to_one is enabled
+        F = self.normalization.forward(F)
+
+        return self._do(F, *args, **kwargs)
+
+    @abc.abstractmethod
+    def _do(self, F, *args, **kwargs):
+        return