pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/__init__.py

@@ -0,0 +1,3 @@
+from pymoo.version import __version__
+
+

pymoo/algorithms/base/bracket.py

@@ -0,0 +1,38 @@
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.individual import Individual
+
+
+class BracketSearch(Algorithm):
+
+    def __init__(self, a=None, b=None, **kwargs):
+        super().__init__(**kwargs)
+        self.a, self.b = a, b
+
+    def _setup(self, problem, a=None, b=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.a, self.b = a, b
+
+    def _initialize_infill(self):
+
+        # the boundaries of the problem for initialization
+        xl, xu = self.problem.bounds()
+
+        # take care of the lower bound - make sure it is an individual and make sure it is evaluated
+        if self.a is None:
+            assert xl is not None, "Either provide a left bound or set the xl attribute in the problem."
+            self.a = Individual(X=xl)
+
+        if self.a.F is None:
+            self.evaluator.eval(self.problem, self.a, algorithm=self)
+
+        # take care of the upper bound - make sure it is an individual and make sure it is evaluated
+        if self.b is None:
+            assert xl is not None, "Either provide a right bound or set the xu attribute in the problem."
+            self.b = Individual(X=xu)
+
+        if self.b.F is None:
+            self.evaluator.eval(self.problem, self.b, algorithm=self)
+
+        assert self.a.X[0] <= self.b.X[0], "The left bound must be smaller than the left bound!"
+

pymoo/algorithms/base/genetic.py

@@ -0,0 +1,109 @@
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.duplicate import DefaultDuplicateElimination, NoDuplicateElimination
+from pymoo.core.initialization import Initialization
+from pymoo.core.mating import Mating
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+
+
+class GeneticAlgorithm(Algorithm):
+
+    def __init__(self,
+                 pop_size=None,
+                 sampling=None,
+                 selection=None,
+                 crossover=None,
+                 mutation=None,
+                 survival=None,
+                 n_offsprings=None,
+                 eliminate_duplicates=DefaultDuplicateElimination(),
+                 repair=None,
+                 mating=None,
+                 advance_after_initial_infill=False,
+                 **kwargs
+                 ):
+
+        super().__init__(**kwargs)
+
+        # the population size used
+        self.pop_size = pop_size
+
+        # whether the algorithm should be advanced after initialization of not
+        self.advance_after_initial_infill = advance_after_initial_infill
+
+        # the survival for the genetic algorithm
+        self.survival = survival
+
+        # number of offsprings to generate through recombination
+        self.n_offsprings = n_offsprings
+
+        # if the number of offspring is not set - equal to population size
+        if self.n_offsprings is None:
+            self.n_offsprings = pop_size
+
+        # set the duplicate detection class - a boolean value chooses the default duplicate detection
+        if isinstance(eliminate_duplicates, bool):
+            if eliminate_duplicates:
+                self.eliminate_duplicates = DefaultDuplicateElimination()
+            else:
+                self.eliminate_duplicates = NoDuplicateElimination()
+        else:
+            self.eliminate_duplicates = eliminate_duplicates
+
+        # simply set the no repair object if it is None
+        self.repair = repair if repair is not None else NoRepair()
+
+        self.initialization = Initialization(sampling,
+                                             repair=self.repair,
+                                             eliminate_duplicates=self.eliminate_duplicates)
+
+        if mating is None:
+            mating = Mating(selection,
+                            crossover,
+                            mutation,
+                            repair=self.repair,
+                            eliminate_duplicates=self.eliminate_duplicates,
+                            n_max_iterations=100)
+        self.mating = mating
+
+        # other run specific data updated whenever solve is called - to share them in all algorithms
+        self.n_gen = None
+        self.pop = None
+        self.off = None
+
+    def _initialize_infill(self):
+        pop = self.initialization.do(self.problem, self.pop_size, algorithm=self)
+        return pop
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        if self.advance_after_initial_infill:
+            self.pop = self.survival.do(self.problem, infills, n_survive=len(infills), algorithm=self, **kwargs)
+
+    def _infill(self):
+
+        # do the mating using the current population
+        off = self.mating.do(self.problem, self.pop, self.n_offsprings, algorithm=self)
+
+        # if the mating could not generate any new offspring (duplicate elimination might make that happen)
+        if len(off) == 0:
+            self.termination.force_termination = True
+            return
+
+        # if not the desired number of offspring could be created
+        elif len(off) < self.n_offsprings:
+            if self.verbose:
+                print("WARNING: Mating could not produce the required number of (unique) offsprings!")
+
+        return off
+
+    def _advance(self, infills=None, **kwargs):
+
+        # the current population
+        pop = self.pop
+
+        # merge the offsprings with the current population
+        if infills is not None:
+            pop = Population.merge(self.pop, infills)
+
+        # execute the survival to find the fittest solutions
+        self.pop = self.survival.do(self.problem, pop, n_survive=self.pop_size, algorithm=self, **kwargs)

pymoo/algorithms/base/line.py

@@ -0,0 +1,62 @@
+import numpy as np
+
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.individual import Individual
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem
+from pymoo.operators.repair.to_bound import set_to_bounds_if_outside
+
+
+class LineSearch(Algorithm):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.point, self.direction = None, None
+
+    def setup(self, problem, point=None, direction=None, **kwargs):
+        super().setup(problem, **kwargs)
+
+        msg = "Only problems with one objective and no constraints can be solved using a line search!"
+        assert not problem.has_constraints() and problem.n_obj == 1, msg
+
+        assert point is not None, "You have to define a starting point for the algorithm"
+        self.point = point
+
+        assert direction is not None, "You have to define a direction point for the algorithm"
+        self.direction = direction
+
+        return self
+
+    def _initialize_infill(self):
+
+        # x could be a vector or an individual
+        if isinstance(self.point, np.ndarray):
+            self.point = Individual(X=self.point)
+
+        # make sure it is evaluated - if not yet also get the gradient
+        if self.point.get("F") is None:
+            self.evaluator.eval(self.problem, self.point, algorithm=self)
+
+        self.infill = self.point
+
+
+class LineSearchProblem(Meta, Problem):
+
+    def __init__(self, problem, point, direction, strict_bounds=True, xl=0.0, xu=np.inf):
+        super().__init__(problem)
+        self.n_var = 1
+        self.xl, self.xu = np.array([xl]), np.array([xu])
+
+        self.point = point
+        self.direction = direction
+        self.strict_bounds = strict_bounds
+
+    def _evaluate(self, alpha, out, *args, **kwargs):
+        out["alpha"] = alpha
+
+        x = self.point.X + alpha * self.direction
+        if self.strict_bounds:
+            x = set_to_bounds_if_outside(x, self.xl, self.xu)
+        out["__X__"] = x
+
+        super()._evaluate(x, out, *args, **kwargs)

pymoo/algorithms/base/local.py

@@ -0,0 +1,39 @@
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.algorithm import Algorithm, LoopwiseAlgorithm
+from pymoo.core.initialization import Initialization
+from pymoo.operators.sampling.lhs import LatinHypercubeSampling
+from pymoo.termination.ftol import SingleObjectiveSpaceTermination
+from pymoo.termination.robust import RobustTermination
+from pymoo.util.display.single import SingleObjectiveOutput
+
+
+class LocalSearch(LoopwiseAlgorithm, Algorithm):
+
+    def __init__(self,
+                 initial=None,
+                 sampling=LatinHypercubeSampling(),
+                 output=SingleObjectiveOutput(),
+                 n_sample_points=20,
+                 **kwargs):
+        super().__init__(output=output, **kwargs)
+
+        # the default termination if not specified otherwise
+        self.termination = RobustTermination(SingleObjectiveSpaceTermination(tol=1e-8), period=10)
+
+        # the type of initial sampling
+        initial = initial if "x0" not in kwargs else kwargs["x0"]
+        if initial is not None:
+            sampling = initial
+
+        self.initialization = Initialization(sampling)
+
+        # the number of sampling points to determine x0
+        self.n_sample_points = n_sample_points
+
+    def _initialize_infill(self):
+        return self.initialization.do(self.problem, self.n_sample_points, algorithm=self)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        self.x0 = FitnessSurvival().do(self.problem, infills, n_survive=1, algorithm=self)[0]
+
+

pymoo/algorithms/base/meta.py

@@ -0,0 +1,79 @@
+from copy import deepcopy
+from typing import Any
+
+from pymoo.core.algorithm import Algorithm
+
+
+class MetaAlgorithm:
+
+    def __new__(cls, algorithm) -> Any:
+
+
+
+
+        return algorithm
+
+
+    def __init__(self, algorithm) -> None:
+        super().__init__()
+        self.algorithm = algorithm
+
+    def __getattr__(self, attr):
+        print(attr)
+        if attr in self.__dict__:
+            return getattr(self, attr)
+        return getattr(self.__dict__["algorithm"], attr)
+
+
+class MetaAlgorithm2(Algorithm):
+
+    def __init__(self,
+                 algorithm,
+                 copy=False,
+                 ):
+        super().__init__()
+
+        # if the algorithm object should be copied to keep the original one unmodified
+        if copy:
+            algorithm = deepcopy(algorithm)
+
+        self.algorithm = algorithm
+
+    def _copy_from_orig(self):
+        for k, v in self.algorithm.__dict__.items():
+            if k not in ["opt", "display"]:
+                self.__dict__[k] = v
+
+    def setup(self, *args, **kwargs):
+        self.algorithm.setup(*args, **kwargs)
+        self._copy_from_orig()
+
+        self.display = self.algorithm.display
+        self.algorithm.display = None
+
+        self._setup(*args, **kwargs)
+
+        return self
+
+    def _infill(self):
+        ret = self.algorithm.infill()
+        self._copy_from_orig()
+        return ret
+
+    def _initialize_infill(self):
+        return self._infill()
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        self.algorithm.advance(infills=infills, **kwargs)
+        self._copy_from_orig()
+
+    def _advance(self, infills=None, **kwargs):
+        self.algorithm.advance(infills=infills, **kwargs)
+        self._copy_from_orig()
+
+    def advance(self, infills=None, **kwargs):
+        super().advance(infills, **kwargs)
+        self._copy_from_orig()
+
+    def _set_optimum(self):
+        self.opt = self.algorithm.opt

pymoo/algorithms/hyperparameters.py

@@ -0,0 +1,89 @@
+from copy import deepcopy
+
+import numpy as np
+
+from pymoo.core.parameters import get_params, flatten, set_params, hierarchical
+from pymoo.core.problem import ElementwiseProblem
+from pymoo.optimize import minimize
+
+
+def create(algorithm, params):
+    algorithm = deepcopy(algorithm)
+    set_params(algorithm, hierarchical(params))
+    return algorithm
+
+
+class HyperparameterProblem(ElementwiseProblem):
+
+    def __init__(self, algorithm, performance, func_create=create, vars=None, **kwargs):
+
+        # get the parameters from the algorithm object
+        if vars is None:
+            vars = get_params(algorithm)
+
+        if isinstance(vars, dict):
+            vars = flatten(vars)
+
+        assert len(vars) > 0, "No hyper-parameters found to optimize."
+
+        super().__init__(vars=vars, **kwargs)
+
+        self.algorithm = algorithm
+        self.performance = performance
+        self.func_create = func_create
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        algorithm = self.func_create(self.algorithm, x)
+        v = self.performance(algorithm)
+        out.update(v)
+
+
+class SingleObjectiveSingleRun:
+
+    def __init__(self, problem, **kwargs):
+        super().__init__()
+        self.problem = problem
+        self.kwargs = kwargs
+
+    def __call__(self, algorithm):
+        ret = minimize(self.problem, algorithm, **self.kwargs)
+        return dict(F=ret.F, G=ret.G, H=ret.H)
+
+
+def stats_single_objective_mean(rets):
+    F, G, H = [], [], []
+    for ret in rets:
+        F.append(ret.F)
+        G.append(ret.G)
+        H.append(ret.H)
+
+    F, G, H = np.array(F), np.array(G), np.array(H)
+
+    return dict(F=F.mean(axis=0), G=G.mean(axis=0), H=H.mean(axis=0))
+
+
+def stats_avg_nevals(rets):
+    return dict(F=np.array([ret.algorithm.evaluator.n_eval for ret in rets]).mean())
+
+
+class MultiRun:
+
+    def __init__(self, problem, n_runs=None, seeds=None, func_stats=stats_single_objective_mean, **kwargs):
+        super().__init__()
+        self.problem = problem
+        self.kwargs = kwargs
+
+        if seeds is None:
+            if n_runs is None:
+                raise Exception("Either provide number of runs or seeds directly.")
+
+            seeds = np.random.randint(1, 1000000, size=n_runs)
+
+        self.seeds = seeds
+        self.func_stats = func_stats
+
+    def __call__(self, algorithm):
+        rets = [minimize(self.problem, algorithm, seed=seed, **self.kwargs) for seed in self.seeds]
+        out = self.func_stats(rets)
+        out["__results__"] = rets
+        return out