pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/algorithms/soo/nonconvex/random_search.py

@@ -0,0 +1,25 @@
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.population import Population
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.util.display.single import SingleObjectiveOutput
+
+
+class RandomSearch(Algorithm):
+
+    def __init__(self,
+                 n_points_per_iteration=100,
+                 sampling=FloatRandomSampling(),
+                 output=SingleObjectiveOutput(),
+                 **kwargs):
+        super().__init__(output=output, **kwargs)
+        self.n_points_per_iteration = n_points_per_iteration
+        self.sampling = sampling
+
+    def _initialize_infill(self):
+        return self._infill()
+
+    def _infill(self):
+        return self.sampling.do(self.problem, self.n_points_per_iteration)
+
+    def _advance(self, infills=None, **kwargs):
+        self.pop = infills if self.opt is None else Population.merge(infills, self.opt)

pymoo/algorithms/soo/nonconvex/sres.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+from pymoo.algorithms.soo.nonconvex.es import ES
+from pymoo.core.population import Population, calc_cv
+from pymoo.core.survival import Survival
+from pymoo.docs import parse_doc_string
+from pymoo.util.function_loader import load_function
+
+
+class StochasticRankingSurvival(Survival):
+
+    def __init__(self, PR):
+        super().__init__(filter_infeasible=False)
+        self.PR = PR
+
+    def _do(self, problem, pop, *args, n_survive=None, tcv=None, **kwargs):
+        assert problem.n_obj == 1, "This stochastic ranking implementation only works for single-objective problems."
+
+        F, G = pop.get("F", "G")
+        f = F[:, 0]
+
+        if not problem.has_constraints():
+            I = f.argsort()
+
+        else:
+            phi = calc_cv(pop)
+            J = np.arange(len(phi))
+            I = load_function("stochastic_ranking")(f, phi, self.PR, J)
+
+        return pop[I][:n_survive]
+
+
+class SRES(ES):
+
+    def __init__(self, PF=0.45, **kwargs):
+        """
+        Stochastic Ranking Evolutionary Strategy (SRES)
+
+        Parameters
+        ----------
+        PF: float
+            The stochastic ranking weight for choosing a random decision while doing the modified bubble sort.
+        """
+        super().__init__(survival=StochasticRankingSurvival(PF), **kwargs)
+        self.PF = PF
+
+    def _advance(self, infills=None, **kwargs):
+
+        # if not all solutions suggested by infill() are evaluated we create a more semi (mu+lambda) algorithm
+        if len(infills) < self.pop_size:
+            infills = Population.merge(infills, self.pop)
+
+        self.pop = self.survival.do(self.problem, infills, n_survive=self.pop_size)
+
+
+parse_doc_string(SRES.__init__)

pymoo/algorithms/soo/univariate/backtracking.py

@@ -0,0 +1,59 @@
+from pymoo.algorithms.base.line import LineSearch
+from pymoo.core.evaluator import Evaluator
+from pymoo.core.solution import Solution, SolutionSet
+from pymoo.core.termination import NoTermination
+from pymoo.optimize import minimize
+from pymoo.problems.single import Sphere
+
+
+class BacktrackingLineSearch(LineSearch):
+
+    def __init__(self, alpha=0.1, beta=0.33, **kwargs):
+        super().__init__(**kwargs)
+        self.alpha = alpha
+        self.beta = beta
+        self.termination = NoTermination()
+
+    def _initialize_infill(self):
+        super()._initialize_infill()
+        self.t = 1.0
+        self.point.set("t", self.t)
+
+        # TODO:  evaluate_values_of needs to be moved into evaluator to be more flexible
+        if self.point.get("dF") is None:
+            self.evaluator.eval(self.problem, self.point, evaluate_values_of=["dF"], algorithm=self)
+
+    def step(self):
+        t = self.t
+        x, f, df, p = self.point.X, self.point.F[0], self.point.get("dF")[0], self.direction
+
+        infill = Solution(X=x + t * p, t=t)
+        self.evaluator.eval(self.problem, infill, algorithm=self, evaluate_values_of=["F"])
+        _f = infill.F[0]
+
+        self.pop = SolutionSet.merge(self.pop, infill)
+        self.infill = infill
+
+        if _f < f + self.alpha * self.t * df.T @ p or self.t <= 1e-8:
+            self.termination.force_termination = True
+        else:
+            self.t = self.t * self.beta
+
+
+if __name__ == '__main__':
+    import numpy as np
+
+    problem = Sphere()
+
+    X = np.array(np.random.random(problem.n_var))
+
+    point = Solution(X=X)
+    Evaluator(evaluate_values_of=["F", "dF"]).eval(problem, point)
+
+    direction = - point.get("dF")[0]
+
+    algorithm = BacktrackingLineSearch().setup(problem, point=point, direction=direction)._initialize()
+
+    res = minimize(problem, algorithm)
+
+    print(res.X)

pymoo/algorithms/soo/univariate/exp.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.core.replacement import is_better
+from pymoo.termination.default import DefaultSingleObjectiveTermination
+
+
+class ExponentialSearch(Algorithm):
+
+    def __init__(self, delta=0.05, **kwargs):
+        super().__init__(**kwargs)
+        self.termination = DefaultSingleObjectiveTermination()
+        self.alpha = delta
+        self.point = None
+
+    def _setup(self, problem, x0=None, **kwargs):
+        msg = "Only problems with one variable, one objective and no constraints can be solved!"
+        assert problem.n_var == 1 and not problem.has_constraints() and problem.n_obj == 1, msg
+        self.point = x0
+
+    def _initialize_infill(self):
+        self.step_size = self.alpha
+
+        if self.point is None:
+            return Population.new(X=np.copy(self.problem.xl[None, :]))
+        else:
+            return Population.create(self.point)
+
+    def step(self):
+        alpha, max_alpha = self.alpha, self.problem.xu[0]
+
+        if alpha > max_alpha:
+            alpha = max_alpha
+
+        infill = Individual(X=np.array([alpha]))
+        self.evaluator.eval(self.problem, infill)
+        self.pop = Population.merge(self.pop, infill)[-10:]
+
+        if is_better(self.point, infill, eps=0.0) or alpha == max_alpha:
+            self.termination.force_termination = True
+            return
+
+        self.point = infill
+        self.alpha *= 2

pymoo/algorithms/soo/univariate/golden.py

@@ -0,0 +1,65 @@
+from pymoo.algorithms.base.bracket import BracketSearch
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+
+
+class GoldenSectionSearch(BracketSearch):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.left, self.right = None, None
+        self.R = (5 ** 0.5 - 1) / 2
+
+    def _initialize_infill(self):
+        super()._initialize_infill()
+        a, b = self.a, self.b
+
+        # the golden ratio (precomputed constant)
+        R = self.R
+
+        # create the left and right in the interval itself
+        c, d = Individual(X=b.X - R * (b.X - a.X)), Individual(X=a.X + R * (b.X - a.X))
+
+        # create a population with all four individuals
+        pop = Population.create(a, c, d, b)
+
+        self.pop, self.infills = pop, pop
+
+        return pop
+
+    def _advance(self, **kwargs):
+
+        # all the elements in the interval
+        a, c, d, b = self.pop
+
+        # the golden ratio (precomputed constant)
+        R = self.R
+
+        # if the left solution is better than the right
+        if c.F[0] < d.F[0]:
+
+            # make the right to be the new right bound and the left becomes the right
+            a, b = a, d
+            d = c
+
+            # create a new left individual and evaluate
+            c = Individual(X=b.X - R * (b.X - a.X))
+            self.evaluator.eval(self.problem, c, algorithm=self)
+            self.infills = c
+
+        # if the right solution is better than the left
+        else:
+
+            # make the left to be the new left bound and the right becomes the left
+            a, b = c, b
+            c = d
+
+            # create a new right individual and evaluate
+            d = Individual(X=a.X + R * (b.X - a.X))
+            self.evaluator.eval(self.problem, d, algorithm=self)
+            self.infills = d
+
+        # update the population with all the four individuals
+        self.pop = Population.create(a, c, d, b)
+
+

pymoo/algorithms/soo/univariate/quadr_interp.py

@@ -0,0 +1,81 @@
+from pymoo.algorithms.base.bracket import BracketSearch
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+
+
+def quadr_interp_equ(xa, fa, xb, fb, xc, fc):
+    g1 = (fc - fa) / (xc - xa)
+    g2 = ((fb - fc) / (xb - xc) - g1) * (xb - xa)
+    xd = 0.5 * ((xa - xb) - g1 / g2)
+    return xd
+
+
+def quadr_interp(a, b, c):
+    return Individual(X=quadr_interp_equ(a.X, a.F, b.X, b.F, c.X, c.F))
+
+
+class QuadraticInterpolationSearch(BracketSearch):
+
+    def __init__(self, a=None, b=None, **kwargs):
+        """
+
+        7.1.2 Quadratic Interpolation Search
+        http://www.mathcs.emory.edu/~haber/math315/chap7.pdf
+
+        Parameters
+        ----------
+        a
+        b
+        kwargs
+        """
+        super().__init__(a, b, **kwargs)
+
+    def _initialize_infill(self):
+        super()._initialize_infill()
+        a, b = self.a, self.b
+
+        # set c to be directly in the middle between the two brackets
+        c = Individual(X=(b.X - a.X) / 2)
+
+        # create a population with all three individuals
+        pop = Population.create(a, b, c)
+
+        return pop
+
+    def _advance(self, **kwargs):
+
+        # all the elements in the interval
+        a, b, c = self.pop
+
+        # if this is the case then the function is not convex (which means U shaped)
+        if c.F[0] >= a.F[0] or c.F[0] >= b.F[0]:
+
+            # choose the left side if a smaller than b, or the right side otherwise
+            if a.F[0] <= b.F[0]:
+                a = c
+            else:
+                b = c
+
+            c = Individual(X=(b.X - a.X) / 2)
+            self.evaluator.eval(self.problem, c, algorithm=self)
+            self.infills = c
+
+        else:
+
+            d = quadr_interp(a, b, c)
+            self.evaluator.eval(self.problem, d, algorithm=self)
+            self.infills = d
+
+            # swap c and d -> make sure d is always on the right of c -> a, c, d, b
+            if c.X[0] > d.X[0]:
+                c, d = d, c
+
+            # if c is better than d, then d becomes the new right bound
+            if c.F[0] <= d.F[0]:
+                b = d
+
+            # if d is better than c, then c becomes the new left bound and d the new right bound
+            else:
+                a, c = c, d
+
+        self.pop = Population.create(a, b, c)

pymoo/algorithms/soo/univariate/wolfe.py

@@ -0,0 +1,163 @@
+import numpy as np
+
+from pymoo.algorithms.base.line import LineSearchProblem
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.evaluator import Evaluator
+from pymoo.core.individual import Individual
+from pymoo.core.solution import SolutionSet
+
+
+class WolfeSearch(Algorithm):
+
+    def __init__(self, c1=1e-4, c2=0.9, max_iter=10, **kwargs):
+
+        super().__init__(**kwargs)
+        self.c1 = c1
+        self.c2 = c2
+        self.max_iter = max_iter
+
+    def _setup(self, problem, **kwargs):
+        assert isinstance(problem,
+                          LineSearchProblem), "The wolfe search only purpose is to solve a line search problem!"
+        self.pop = SolutionSet.create(problem.point)
+        self.opt = self.pop
+
+    def _set_optimum(self, force=False):
+        pass
+
+    def step(self):
+        sol = self._infill()
+
+        self.opt = sol
+        self.termination.force_termination = True
+
+    def _infill(self):
+
+        problem, evaluator = self.problem, self.evaluator
+        evaluator.skip_already_evaluated = False
+
+        sol, direction = self.problem.point, self.problem.direction
+
+        # the function value and gradient of the initial solution
+        sol.set("alpha", 0.0)
+        sol_F, sol_dF = sol.F[0], sol.get("dF")[0]
+
+        def zoom(alpha_low, alpha_high, max_iter=100):
+
+            while True:
+
+                _alpha = (alpha_high.get("alpha") + alpha_low.get("alpha")) / 2
+                _point = Individual(X=_alpha)
+                evaluator.eval(problem, _point, evaluate_values_of=["F", "CV"])
+
+                if _point.F[0] > sol_F + self.c1 * _alpha * sol_dF @ direction or _point.F[0] > alpha_low.F[0]:
+                    alpha_high = _point
+                else:
+                    evaluator.eval(problem, _point, evaluate_values_of=["dF"])
+                    point_dF = _point.get("dF")[0]
+
+                    if np.abs(point_dF @ direction) <= -self.c2 * sol_dF @ direction:
+                        return _point
+
+                    if (point_dF @ direction) * (alpha_high.get("alpha") - alpha_low.get("alpha")) >= 0:
+                        alpha_high = alpha_low
+
+                    alpha_low = _point
+
+        last = sol
+
+        alpha = 1.0
+        current = Individual(X=alpha)
+
+        for i in range(1, self.max_iter + 1):
+
+            # evaluate the solutions
+            evaluator.eval(problem, current, evaluate_values_of=["F", "CV"])
+
+            # get the values from the solution to be used to evaluate the conditions
+            F, dF, _F = last.F[0], last.get("dF")[0], current.F[0]
+
+            # if the wolfe condition is violate we have found our upper bound
+            if _F > sol_F + self.c1 * sol_dF @ direction or (i > 1 and F >= _F):
+                return zoom(last, current)
+
+            # for the other condition we need the gradient information
+            evaluator.eval(problem, current, evaluate_values_of=["dF"])
+            _dF = current.get("dF")[0]
+
+            if np.abs(_dF @ direction) <= -self.c2 * sol_dF @ direction:
+                return current
+
+            if _dF @ direction >= 0:
+                return zoom(current, last)
+
+            alpha = 2 * alpha
+            last = current
+            current = Individual(X=alpha)
+
+        return current
+
+
+def wolfe_line_search(problem, sol, direction, c1=1e-4, c2=0.9, max_iter=10, evaluator=None):
+    # initialize the evaluator to be used (this will make sure evaluations are counted)
+    evaluator = evaluator if evaluator is not None else Evaluator()
+    evaluator.skip_already_evaluated = False
+
+    # the function value and gradient of the initial solution
+    sol.set("alpha", 0.0)
+    sol_F, sol_dF = sol.F[0], sol.get("dF")[0]
+
+    def zoom(alpha_low, alpha_high, max_iter=100):
+
+        while True:
+
+            _alpha = (alpha_high.get("alpha") + alpha_low.get("alpha")) / 2
+            _point = Individual(X=sol.X + _alpha * direction, alpha=_alpha)
+            evaluator.eval(problem, _point, evaluate_values_of=["F", "CV"])
+
+            if _point.F[0] > sol_F + c1 * _alpha * sol_dF @ direction or _point.F[0] > alpha_low.F[0]:
+                alpha_high = _point
+            else:
+                evaluator.eval(problem, _point, evaluate_values_of=["dF"])
+                point_dF = _point.get("dF")[0]
+
+                if np.abs(point_dF @ direction) <= -c2 * sol_dF @ direction:
+                    return _point
+
+                if (point_dF @ direction) * (alpha_high.get("alpha") - alpha_low.get("alpha")) >= 0:
+                    alpha_high = alpha_low
+
+                alpha_low = _point
+
+    last = sol
+
+    alpha = 1.0
+    current = Individual(X=sol.X + alpha * direction, alpha=alpha)
+
+    for i in range(1, max_iter + 1):
+
+        # evaluate the solutions
+        evaluator.eval(problem, current, evaluate_values_of=["F", "CV"])
+
+        # get the values from the solution to be used to evaluate the conditions
+        F, dF, _F = last.F[0], last.get("dF")[0], current.F[0]
+
+        # if the wolfe condition is violate we have found our upper bound
+        if _F > sol_F + c1 * sol_dF @ direction or (i > 1 and F >= _F):
+            return zoom(last, current)
+
+        # for the other condition we need the gradient information
+        evaluator.eval(problem, current, evaluate_values_of=["dF"])
+        _dF = current.get("dF")[0]
+
+        if np.abs(_dF @ direction) <= -c2 * sol_dF @ direction:
+            return current
+
+        if _dF @ direction >= 0:
+            return zoom(current, last)
+
+        alpha = 2 * alpha
+        last = current
+        current = Individual(X=sol.X + alpha * direction, alpha=alpha)
+
+    return current

pymoo/config.py

@@ -0,0 +1,33 @@
+from os.path import dirname, realpath
+
+from pymoo.version import __version__
+
+
+class Config:
+    """
+    The configuration of this package in general providing the place
+    for declaring global variables.
+    """
+
+    # the root directory where the package is located at
+    root = dirname(realpath(__file__))
+
+    warnings = {
+        "not_compiled": True
+    }
+
+    # whether a warning should be printed if compiled modules are not available
+    show_compile_hint = True
+
+    # whether when import a file the doc should be parsed - only activate when creating doc files
+    parse_custom_docs = False
+
+    # a method defining the endpoint to load data remotely - default from GitHub repo
+    @classmethod
+    def data(cls):
+        return f"https://raw.githubusercontent.com/anyoptimization/pymoo-data/main/"
+
+
+# returns the directory to be used for imports
+def get_pymoo():
+    return dirname(Config.root)

pymoo/constraints/__init__.py

@@ -0,0 +1,3 @@
+
+
+

pymoo/constraints/adaptive.py

@@ -0,0 +1,62 @@
+from copy import deepcopy
+
+import numpy as np
+
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.evaluator import Evaluator
+from pymoo.core.individual import Individual
+from pymoo.core.meta import Meta
+from pymoo.core.population import Population
+from pymoo.core.problem import Problem
+
+
+class AttachConfigEvaluator(Meta, Evaluator):
+
+    def __init__(self, wrapped, config):
+        super().__init__(wrapped)
+        self.config = config
+
+    def eval(self, problem: Problem, pop: Population, **kwargs):
+        pop = super().eval(problem, pop, **kwargs)
+        pop.apply(lambda ind: ind.set("config", self.config))
+
+
+def copy_to_dict(src, dest):
+    dest.clear()
+    dest.update(**src)
+
+
+class AdaptiveConstraintHandling(Meta, Algorithm):
+
+    def __init__(self, algorithm):
+        super().__init__(algorithm)
+
+        self.config = Individual.default_config()
+        self.config["cache"] = False
+
+        self.default_config = deepcopy(self.config)
+        self.adapted_config = deepcopy(self.config)
+
+    def _setup(self, _, **kwargs):
+        self.evaluator = AttachConfigEvaluator(self.evaluator, self.config)
+
+    def _adapt_constraint_handling(self, config, infills=None, **kwargs):
+        pass
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        copy_to_dict(self.adapted_config, self.config)
+        super()._initialize_advance(infills=infills, **kwargs)
+        copy_to_dict(self.default_config, self.config)
+
+    def _advance(self, infills=None, **kwargs):
+        copy_to_dict(self.adapted_config, self.config)
+        super()._advance(infills=infills, **kwargs)
+        copy_to_dict(self.default_config, self.config)
+
+        self._adapt_constraint_handling(self.adapted_config, infills=infills, **kwargs)
+
+    def _infill(self):
+        copy_to_dict(self.adapted_config, self.config)
+        pop = super()._infill()
+        copy_to_dict(self.default_config, self.config)
+        return pop

pymoo/constraints/as_obj.py

@@ -0,0 +1,56 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.individual import calc_cv
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem
+from pymoo.util.misc import from_dict
+
+
+class ConstraintsAsObjective(Meta, Problem):
+
+    def __init__(self,
+                 problem,
+                 config=None,
+                 append=True):
+
+        super().__init__(problem)
+        self.config = config
+        self.append = append
+
+        if append:
+            self.n_obj = problem.n_obj + 1
+        else:
+            self.n_obj = 1
+
+        self.n_ieq_constr = 0
+        self.n_eq_constr = 0
+
+    def do(self, X, return_values_of, *args, **kwargs):
+        out = self.__object__.do(X, return_values_of, *args, **kwargs)
+
+        # get at the values from the output
+        F, G, H = from_dict(out, "F", "G", "H")
+
+        # store a backup of the values in out
+        out["__F__"], out["__G__"], out["__H__"] = F, G, H
+
+        # calculate the total constraint violation (here normalization shall be already included)
+        CV = calc_cv(G=G, H=H, config=self.config)
+
+        # append the constraint violation as objective
+        if self.append:
+            out["F"] = anp.column_stack([CV, F])
+        else:
+            out["F"] = CV
+
+        del out["G"]
+        del out["H"]
+
+        return out
+
+    def pareto_front(self, *args, **kwargs):
+        pf = super().pareto_front(*args, **kwargs)
+        if pf is not None:
+            pf = np.column_stack([np.zeros(len(pf)), pf])
+        return pf