pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

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