pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/algorithms/soo/nonconvex/nelder.py

@@ -0,0 +1,251 @@
+import numpy as np
+
+from pymoo.algorithms.base.local import LocalSearch
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.core.population import pop_from_array_or_individual
+from pymoo.core.replacement import is_better
+from pymoo.core.termination import Termination
+from pymoo.docs import parse_doc_string
+from pymoo.operators.repair.to_bound import set_to_bounds_if_outside_by_problem
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.misc import vectorized_cdist
+from pymoo.util.vectors import max_alpha
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class NelderAndMeadTermination(Termination):
+
+    def __init__(self,
+                 x_tol=1e-6,
+                 f_tol=1e-6,
+                 n_max_iter=1e6,
+                 n_max_evals=1e6):
+
+        super().__init__()
+        self.x_tol = x_tol
+        self.f_tol = f_tol
+        self.n_max_iter = n_max_iter
+        self.n_max_evals = n_max_evals
+
+    def _update(self, algorithm):
+        pop, problem = algorithm.pop, algorithm.problem
+
+        if len(pop) <= 1:
+            return 0.0
+
+        X, F = pop.get("X", "F")
+
+        f_delta = np.abs(F[1:] - F[0]).max()
+        f_tol = 1 / (1 + (f_delta - self.f_tol))
+
+        # if the problem has bounds we can normalize the x space to to be more accurate
+        if problem.has_bounds():
+            x_delta = np.abs((X[1:] - X[0]) / (problem.xu - problem.xl)).max()
+        else:
+            x_delta = np.abs(X[1:] - X[0]).max()
+
+        x_tol = 1 / (1 + (x_delta - self.x_tol))
+
+        # degenerated simplex - get all edges and minimum and maximum length
+        D = vectorized_cdist(X, X)
+        val = D[np.triu_indices(len(pop), 1)]
+        min_e, max_e = val.min(), val.max()
+
+        # either if the maximum length is very small or the ratio is degenerated
+        is_degenerated = int(max_e < 1e-16 or min_e / max_e < 1e-16)
+
+        max_iter = algorithm.n_iter / self.n_max_iter
+        max_evals = algorithm.evaluator.n_eval / self.n_max_evals
+
+        return max(f_tol, x_tol, max_iter, max_evals, is_degenerated)
+
+
+def adaptive_params(problem):
+    n = problem.n_var
+    alpha = 1
+    beta = 1 + 2 / n
+    gamma = 0.75 - 1 / (2 * n)
+    delta = 1 - 1 / n
+    return alpha, beta, gamma, delta
+
+
+def default_params(_):
+    alpha = 1
+    beta = 2.0
+    gamma = 0.5
+    delta = 0.05
+    return alpha, beta, gamma, delta
+
+
+def initialize_simplex(problem, x0, scale=0.05):
+    n = len(x0)
+
+    if problem.has_bounds():
+        delta = scale * (problem.xu - problem.xl)
+    else:
+        delta = scale * x0
+        delta[delta == 0] = 0.00025
+
+    # repeat the x0 already and add the values
+    X = x0[None, :].repeat(n, axis=0)
+
+    for k in range(n):
+
+        # if the problem has bounds do the check
+        if problem.has_bounds():
+            if X[k, k] + delta[k] < problem.xu[k]:
+                X[k, k] = X[k, k] + delta[k]
+            else:
+                X[k, k] = X[k, k] - delta[k]
+
+        # otherwise just add the init_simplex_scale
+        else:
+            X[k, k] = X[k, k] + delta[k]
+
+    return X
+
+
+class NelderMead(LocalSearch):
+
+    def __init__(self,
+                 init_simplex_scale=0.05,
+                 func_params=adaptive_params,
+                 output=SingleObjectiveOutput(),
+                 **kwargs):
+
+        super().__init__(output=output, **kwargs)
+
+        # the function to return the parameter
+        self.func_params = func_params
+
+        # the attributes for the simplex operations
+        self.alpha = None
+        self.beta = None
+        self.gamma = None
+        self.delta = None
+
+        # whether the simplex has been initialized or not
+        self.is_simplex_initialized = False
+
+        # the initial simplex scale used
+        self.init_simplex_scale = init_simplex_scale
+
+        # the termination used for nelder and mead if nothing else provided
+        self.termination = NelderAndMeadTermination()
+
+    def _setup(self, problem, **kwargs):
+        self.alpha, self.beta, self.gamma, self.delta = self.func_params(self.problem)
+
+    def _initialize_simplex(self):
+        simplex = pop_from_array_or_individual(initialize_simplex(self.problem, self.x0.X, scale=0.05))
+        return Population.merge(self.x0, simplex)
+
+    def _next(self):
+        if not self.is_simplex_initialized:
+            self.pop = yield self._initialize_simplex()
+            self.is_simplex_initialized = True
+        else:
+            yield from self._step()
+
+    def _step(self):
+
+        # number of variables increased by one - matches equations in the paper
+        xl, xu = self.problem.bounds()
+        pop, n = self.pop, self.problem.n_var - 1
+
+        # calculate the centroid
+        centroid = pop[:n + 1].get("X").mean(axis=0)
+
+        # -------------------------------------------------------------------------------------------
+        # REFLECT
+        # -------------------------------------------------------------------------------------------
+
+        # check the maximum alpha until the bounds are hit
+        alphaU = max_alpha(centroid, (centroid - pop[n + 1].X), xl, xu)
+
+        # reflect the point, consider factor if bounds are there, make sure in bounds (floating point) evaluate
+        x_reflect = centroid + min(self.alpha, alphaU) * (centroid - pop[n + 1].X)
+        x_reflect = set_to_bounds_if_outside_by_problem(self.problem, x_reflect)
+        reflect = yield Individual(X=x_reflect)
+
+        # whether a shrink is necessary or not - decided during this step
+        shrink = False
+
+        better_than_current_best = is_better(reflect, pop[0])
+        better_than_second_worst = is_better(reflect, pop[n])
+        better_than_worst = is_better(reflect, pop[n + 1])
+
+        # if better than the current best - check for expansion
+        if better_than_current_best:
+
+            # -------------------------------------------------------------------------------------------
+            # EXPAND
+            # -------------------------------------------------------------------------------------------
+
+            # the maximum expansion until the bounds are hit
+            betaU = max_alpha(centroid, (x_reflect - centroid), xl, xu)
+
+            # expand using the factor, consider bounds, make sure in case of floating point issues
+            x_expand = centroid + min(self.beta, betaU) * (x_reflect - centroid)
+            x_expand = set_to_bounds_if_outside_by_problem(self.problem, x_expand)
+            expand = yield Individual(X=x_expand)
+
+            # if the expansion further improved take it - otherwise use expansion
+            if is_better(expand, reflect):
+                pop[n + 1] = expand
+            else:
+                pop[n + 1] = reflect
+
+        # if the new point is not better than the best, but better than second worst - just keep it
+        elif not better_than_current_best and better_than_second_worst:
+            pop[n + 1] = reflect
+
+        # if not worse than the worst - outside contraction
+        elif not better_than_second_worst and better_than_worst:
+
+            # -------------------------------------------------------------------------------------------
+            # Outside Contraction
+            # -------------------------------------------------------------------------------------------
+
+            x_contract_outside = centroid + self.gamma * (x_reflect - centroid)
+            contract_outside = yield Individual(X=x_contract_outside)
+
+            if is_better(contract_outside, reflect):
+                pop[n + 1] = contract_outside
+            else:
+                shrink = True
+
+        # if the reflection was worse than the worst - inside contraction
+        else:
+
+            # -------------------------------------------------------------------------------------------
+            # Inside Contraction
+            # -------------------------------------------------------------------------------------------
+
+            x_contract_inside = centroid - self.gamma * (x_reflect - centroid)
+            contract_inside = yield Individual(X=x_contract_inside)
+
+            if is_better(contract_inside, pop[n + 1]):
+                pop[n + 1] = contract_inside
+            else:
+                shrink = True
+
+        # -------------------------------------------------------------------------------------------
+        # Shrink (only if necessary)
+        # -------------------------------------------------------------------------------------------
+
+        if shrink:
+            x_best, x_others = pop[0].X, pop[1:].get("X")
+            x_shrink = x_best + self.delta * (x_others - x_best)
+            pop[1:] = yield Population.new(X=x_shrink)
+
+        self.pop = FitnessSurvival().do(self.problem, pop, n_survive=len(pop))
+
+
+parse_doc_string(NelderMead.__init__)

pymoo/algorithms/soo/nonconvex/optuna.py

@@ -0,0 +1,80 @@
+from pymoo.util.optimum import filter_optimum
+
+try:
+    import optuna
+    from optuna.samplers import TPESampler
+    from optuna.logging import get_logger
+except:
+    raise Exception("Please install optuna: pip install optuna")
+
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.core.variable import Real, Integer, Choice, Binary
+from pymoo.util.display.single import SingleObjectiveOutput
+
+
+class Optuna(Algorithm):
+
+    def __init__(self, sampler=None, output=SingleObjectiveOutput(), **kwargs):
+        super().__init__(output=output, **kwargs)
+        self.sampler = sampler
+
+    def _setup(self, problem, **kwargs):
+
+        sampler = self.sampler
+        if sampler is None:
+            sampler = TPESampler(seed=self.seed)
+
+        # that disables the warning in the very beginning
+        get_logger('optuna.storages._in_memory').disabled = True
+
+        # create a new study
+        self.study = optuna.create_study(study_name=f"Study@{id(self)}", sampler=sampler, direction='minimize')
+
+        # the current trial for an individual
+        self.trial = None
+
+    def _infill(self):
+        self.trial = self.study.ask()
+
+        vars = self.problem.vars
+        assert vars is not None, "Optuna needs explicitly defined variables."
+
+        x = {}
+        for name, param in vars.items():
+            if isinstance(param, Real):
+                lower, upper = param.bounds
+                v = self.trial.suggest_float(name, lower, upper)
+            elif isinstance(param, Integer):
+                lower, upper = param.bounds
+                v = self.trial.suggest_int(name, lower, upper)
+            elif isinstance(param, Choice):
+                options = param.options
+                v = self.trial.suggest_categorical(name, options)
+            elif isinstance(param, Binary):
+                v = self.trial.suggest_categorical(name, [False, True])
+            else:
+                raise Exception("Type not supported yet.")
+            x[name] = v
+
+        return Individual(X=x)
+
+    def _advance(self, infills=None, **kwargs):
+        self.pop = Population.create(infills)
+        self.study.tell(self.trial, infills.f)
+
+    def _initialize_infill(self):
+        return self._infill()
+
+    def _initialize_advance(self, **kwargs):
+        return self._advance(**kwargs)
+
+    def _set_optimum(self):
+        pop = self.pop
+        if self.opt is not None:
+            pop = Population.merge(self.opt, pop)
+        self.opt = filter_optimum(pop, least_infeasible=True)
+
+
+

pymoo/algorithms/soo/nonconvex/pattern.py

@@ -0,0 +1,183 @@
+import numpy as np
+
+from pymoo.algorithms.base.local import LocalSearch
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+from pymoo.core.replacement import is_better
+from pymoo.docs import parse_doc_string
+from pymoo.operators.repair.to_bound import set_to_bounds_if_outside_by_problem
+from pymoo.util.display.single import SingleObjectiveOutput
+from pymoo.util.optimum import filter_optimum
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class PatternSearch(LocalSearch):
+    def __init__(self,
+                 init_delta=0.25,
+                 init_rho=0.5,
+                 step_size=1.0,
+                 output=SingleObjectiveOutput(),
+                 **kwargs):
+        """
+        An implementation of well-known Hooke and Jeeves Pattern Search.
+
+        Parameters
+        ----------
+
+        x0 : numpy.array
+            The initial value where the local search should be initiated. If not provided `n_sample_points` are
+            created using latin hypercube sampling and the best solution found is set to `x0`.
+
+        n_sample_points : int
+            Number of sample points to be used to determine the initial search point. (Only used of `x0` is not provided)
+
+        delta : float
+            The `delta` values which is used for the exploration move. If lower and upper bounds are provided the
+            value is in relation to the overall search space. For instance, a value of 0.25 means that initially the
+            pattern is created in 25% distance of the initial search point.
+
+        rho : float
+            If the move was unsuccessful then the `delta` value is reduced by multiplying it with the value provided.
+            For instance, `explr_rho` implies that with a value of `delta/2` is continued.
+
+        step_size : float
+            After the exploration move the new center is determined by following a promising direction.
+            This value defines how large to step on this direction will be.
+
+        """
+
+        super().__init__(output=output, **kwargs)
+        self.init_rho = init_rho
+        self.init_delta = init_delta
+        self.step_size = step_size
+
+        self.n_not_improved = 0
+
+        self._rho = init_rho
+        self._delta = None
+        self._center = None
+        self._current = None
+        self._trial = None
+        self._direction = None
+        self._sign = None
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        super()._initialize_advance(infills=infills, **kwargs)
+        self._center, self._explr = self.x0, self.x0
+        self._sign = np.ones(self.problem.n_var)
+
+        if self.problem.has_bounds():
+            xl, xu = self.problem.bounds()
+            self._delta = self.init_delta * (xu - xl)
+        else:
+            self._delta = np.abs(self.x0.X) / 2.0
+            self._delta[self._delta <= 1.0] = 1.0
+
+    def _next(self):
+
+        # whether the last iteration has resulted in a new optimum or not
+        has_improved = is_better(self._explr, self._center)
+
+        # that means that the exploration did not find any new point and was thus unsuccessful
+        if not has_improved:
+
+            # increase the counter (by default this will be initialized to 0 and directly increased to 1)
+            self.n_not_improved += 1
+
+            # keep track of the rho values in the normalized space
+            self._rho = self.init_rho ** self.n_not_improved
+
+            # explore around the current center - try finding a suitable direction
+            self._explr = yield from exploration_move(self.problem, self._center, self._sign, self._delta, self._rho)
+
+        # if we have found a direction in the last iteration to be worth following
+        else:
+
+            # get the direction which was successful in the last move
+            self._direction = (self._explr.X - self._center.X)
+
+            # declare the exploration point the new center (it has led to an improvement in the last iteration!)
+            self._center = self._explr
+
+            # use the pattern move to get a new trial vector along that given direction
+            self._trial = yield pattern_move(self.problem, self._center, self._direction, self.step_size)
+
+            # get the delta sign adjusted for the exploration
+            self._sign = calc_sign(self._direction)
+
+            # explore around the current center to try finding a suitable direction
+            self._explr = yield from exploration_move(self.problem, self._trial, self._sign, self._delta, self._rho)
+
+        self.pop = Population.create(self._center, self._explr)
+
+    def _set_optimum(self):
+        pop = self.pop if self.opt is None else Population.merge(self.opt, self.pop)
+        self.opt = filter_optimum(pop, least_infeasible=True)
+
+
+def exploration_move(problem, center, sign, delta, rho, randomize=True):
+    n_var = problem.n_var
+
+    # the order for the variable iteration
+    if randomize:
+        K = np.random.permutation(n_var)
+    else:
+        K = np.arange(n_var)
+
+    # iterate over each variable
+    for k in K:
+
+        # the value to be tried first is given by the amount times the sign
+        _delta = sign[k] * rho * delta
+
+        # make a step of delta on the k-th variable
+        _explr = yield step_along_axis(problem, center.X, _delta, k)
+
+        if is_better(_explr, center, eps=0.0):
+            center = _explr
+
+        # if not successful try the other direction
+        else:
+
+            # now try the negative value of delta and see if we can improve
+            _explr = yield step_along_axis(problem, center.X, -1 * _delta, k)
+
+            if is_better(_explr, center, eps=0.0):
+                center = _explr
+
+    return center
+
+
+def pattern_move(problem, current, direction, step_size):
+    # calculate the new X and repair out of bounds if necessary
+    X = current.X + step_size * direction
+    set_to_bounds_if_outside_by_problem(problem, X)
+
+    # create the new center individual
+    return Individual(X=X)
+
+
+def calc_sign(direction):
+    sign = np.sign(direction)
+    sign[sign == 0] = -1
+    return sign
+
+
+def step_along_axis(problem, x, delta, axis):
+    # copy and add delta to the new point
+    X = np.copy(x)
+
+    # now add to the current solution
+    X[axis] = X[axis] + delta[axis]
+
+    # repair if out of bounds if necessary
+    X = set_to_bounds_if_outside_by_problem(problem, X)
+
+    return Individual(X=X)
+
+
+parse_doc_string(PatternSearch.__init__)