pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.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/nrbo.py

@@ -0,0 +1,191 @@
+"""
+Newton-Raphson-based optimizer (NRBO)
+
+-------------------------------- Description -------------------------------
+
+
+
+-------------------------------- References --------------------------------
+
+[1]. Sowmya, R., Premkumar, M. & Jangir, P. Newton-Raphson-based optimizer:
+A new population-based metaheuristic algorithm for continuous optimization problems.
+Engineering Applications of Artificial Intelligence 128, 107532 (2024).
+
+----------------------------------------------------------------------------
+"""
+
+import numpy as np
+
+from pymoo.core.algorithm import Algorithm
+from pymoo.core.initialization import Initialization
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+from pymoo.core.replacement import ImprovementReplacement
+from pymoo.core.survival import Survival
+from pymoo.operators.repair.bounds_repair import repair_random_init
+from pymoo.operators.sampling.lhs import LHS
+from pymoo.util import default_random_state
+
+
+class FitnessSurvival(Survival):
+
+    def __init__(self) -> None:
+        super().__init__(filter_infeasible=False)
+
+    def _do(self, problem, pop, n_survive=None, **kwargs):
+        F, cv = pop.get("F", "cv")
+        assert F.shape[1] == 1, "FitnessSurvival can only used for single objective single!"
+        S = np.lexsort([F[:, 0], cv])
+        pop.set("rank", np.argsort(S))
+        return pop[S[:n_survive]]
+
+
+@default_random_state
+def Search_Rule(Xb, Xw, Xn, rho, random_state=None):
+    dim = len(Xn)
+
+    dx = random_state.random(dim) * np.abs(Xb - Xn)
+
+    tmp = Xw + Xb - 2 * Xn
+    idx = np.where(tmp == 0.0)
+    # repair if xj=0
+    if idx:
+        tmp[idx] = tmp[idx] + 1e-12
+    nrsr = random_state.standard_normal() * (((Xw - Xb) * dx) / (2 * tmp))
+    Z = Xn - nrsr
+
+    r1 = random_state.random()
+    # r2 = random_state.random()
+    tmp = np.mean(Z + Xn)
+
+    yw = r1 * (tmp + r1 * dx)
+    yb = r1 * (tmp - r1 * dx)
+
+    NRSR = random_state.standard_normal() * ((yw - yb) * dx) / (2 * (yw + yb - 2 * Xn))
+
+    step = NRSR - rho
+    X1 = Xn - step
+    X2 = Xb - step
+    return X1, X2
+
+
+class NRBO(Algorithm):
+    def __init__(
+        self,
+        pop_size=50,
+        deciding_factor=0.6,
+        sampling=LHS(),
+        max_iteration=100,
+        repair=NoRepair(),
+        output=None,
+        display=None,
+        callback=None,
+        archive=None,
+        return_least_infeasible=False,
+        save_history=False,
+        verbose=False,
+        seed=None,
+        evaluator=None,
+        **kwargs,
+    ):
+        self.max_iteration = max_iteration
+        termination = ("n_gen", self.max_iteration)
+        self.pop_size = pop_size
+        self.deciding_factor = deciding_factor
+        self.repair = repair
+        self.survial = FitnessSurvival()
+        self.initialization = Initialization(sampling, self.repair)
+        super().__init__(
+            termination,
+            output,
+            display,
+            callback,
+            archive,
+            return_least_infeasible,
+            save_history,
+            verbose,
+            seed,
+            evaluator,
+            **kwargs,
+        )
+
+    def _setup(self, problem, **kwargs):
+        return super()._setup(problem, **kwargs)
+
+    def _initialize_infill(self):
+        return self.initialization.do(self.problem, self.pop_size, algorithm=self, random_state=self.random_state)
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        self.pop = self.survial.do(self.problem, infills)
+
+    def _infill(self):
+        delta = (1 - (2 * self.n_iter) / self.max_iteration) ** 5
+
+        # find Xb, Xw inviduals
+        rank = self.pop.get("rank")
+        Xb_idx = np.argmin(rank)
+        X = self.pop.get("X")
+        Xb = X[Xb_idx]
+        Xw_idx = np.argmax(rank)
+        Xw = X[Xw_idx]
+
+        off = []
+
+        for i in range(self.pop_size):
+
+            # random select r1,r2
+            idx = np.arange(self.pop_size)
+            idx = np.delete(idx, i)
+            r1, r2 = self.random_state.choice(idx, size=2, replace=False)
+
+            a, b = self.random_state.random(2)
+            rho = a * (Xb - X[i]) + b * (X[r1] - X[r2])
+
+            # NRSR
+            X1, X2 = Search_Rule(Xb=Xb, Xw=Xw, Xn=X[i], rho=rho, random_state=self.random_state)
+
+            X3 = X[i] - delta * (X2 - X1)
+
+            r2 = self.random_state.random()
+            Xn_new = r2 * (r2 * X1 + (1 - r2) * X2) + (1 - r2) * X3
+
+            # TAO
+            if self.random_state.random() < self.deciding_factor:
+                theta1 = self.random_state.uniform(-1, 1, 1)
+                theta2 = self.random_state.uniform(-0.5, 0.5, 1)
+
+                beta = 0 if self.random_state.random() > 0.5 else 1
+                u1 = beta * 3 * self.random_state.random() + (1 - beta)
+                u2 = beta * self.random_state.random() + (1 - beta)
+
+                tmp = theta1 * (u1 * Xb - u2 * X[i]) + theta2 * delta * (u1 * np.mean(X[i]) - u2 * X[i])
+                if u1 < 0.5:
+                    X_tao = Xn_new + tmp
+                else:
+                    X_tao = Xb + tmp
+
+                Xn_new = X_tao
+            off.append(Xn_new)
+
+        off = np.array(off)
+        if self.problem.has_bounds():
+            # off = set_to_bounds_if_outside(off, *self.problem.bounds())
+            off = repair_random_init(off, X, *self.problem.bounds(), random_state=self.random_state)
+
+        off = Population.new(X=off)
+
+        off = self.repair.do(self.problem, off)
+        return off
+
+    def _advance(self, infills=None, **kwargs):
+        off = infills
+        has_improved = ImprovementReplacement().do(self.problem, self.pop, off, return_indices=True)
+
+        self.pop[has_improved] = off[has_improved]
+        self.survial.do(self.problem, self.pop)
+
+    def _set_optimum(self):
+        k = self.pop.get("rank") == 0
+        self.opt = self.pop[k]
+
+

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,185 @@
+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
+from pymoo.util import default_random_state
+
+
+# =========================================================================================================
+# 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)
+
+
+@default_random_state
+def exploration_move(problem, center, sign, delta, rho, randomize=True, random_state=None):
+    n_var = problem.n_var
+
+    # the order for the variable iteration
+    if randomize:
+        K = random_state.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__)