dfbench 0.1.0__py3-none-any.whl

dfbench/__init__.py

@@ -0,0 +1,48 @@
+"""Differometor Benchmark package.
+
+Provides optimization algorithms, problem definitions, and benchmarking tools.
+
+Usage:
+    ### Core classes
+    `from dfbench import Objective`
+
+    ### Protocols
+    `from dfbench import ContinuousProblem, OptimizationAlgorithm, AlgorithmType`
+
+    ### Algorithms (hierarchical)
+    `from dfbench.algorithms import AdamGD, EvoxES, BotorchBO`
+
+    ### Problems (hierarchical)
+    `from dfbench.problems import VoyagerProblem, UIFOProblem`
+
+    ### Benchmarking (hierarchical)
+    `from dfbench.benchmark import Benchmark, AlgorithmConfig`
+"""
+
+# Initialize environment variables first
+import dfbench.core._init_env  # noqa: F401
+
+# Import protocols
+from dfbench.core.problem import ContinuousProblem
+from dfbench.core.algorithm import OptimizationAlgorithm, AlgorithmType
+
+# Import core utilities
+from dfbench.core.config import create_parser
+from dfbench.core.utils import t2j, j2t
+
+# Import Objective for external use
+from dfbench.core.objective import Objective
+
+
+__all__ = [
+    # Core
+    "Objective",
+    # Protocols
+    "ContinuousProblem",
+    "OptimizationAlgorithm",
+    "AlgorithmType",
+    # Utilities
+    "create_parser",
+    "t2j",
+    "j2t",
+]

dfbench/algorithms/__init__.py

@@ -0,0 +1,219 @@
+"""Optimization algorithms."""
+
+from dfbench.algorithms.derivative_free.nelder_mead import NelderMead
+from dfbench.algorithms.derivative_free.omads_mads import OmadsMADS, OmadsOrthoMADS
+from dfbench.algorithms.derivative_free.powell import Powell
+from dfbench.algorithms.global_search.basin_hopping import BasinHopping
+from dfbench.algorithms.global_search.dual_annealing import DualAnnealing
+from dfbench.algorithms.evolutionary.evox_es import EvoxES
+from dfbench.algorithms.evolutionary.evox_pso import EvoxPSO
+from dfbench.algorithms.evolutionary.nevergrad.ngopt import NevergradNGOpt
+from dfbench.algorithms.evolutionary.nevergrad.oneplusone import NevergradOnePlusOne
+from dfbench.algorithms.evolutionary.nevergrad.tbpsa import NevergradTBPSA
+from dfbench.algorithms.evolutionary.random_search import RandomSearch
+from dfbench.algorithms.evolutionary.pycma_cmaes import (
+    PyCMACMAES,
+    PyCMAActiveCMAES,
+    PyCMAIPOP,
+    PyCMABIPOP,
+)
+from dfbench.algorithms.evolutionary.cmaes_sep_cma import CMAESSepCMA
+from dfbench.algorithms.evolutionary.evosax_es import EvosaxMAES, EvosaxLMMAES
+from dfbench.algorithms.evolutionary.jax_es import JAXOnePlusOneES, JAXMuLambdaES
+from dfbench.algorithms.gradient_based.adam_gd import AdamGD
+from dfbench.algorithms.gradient_based.custom_jax import (
+    ARCJAX,
+    ASAMJAX,
+    AdamToLBFGSJAX,
+    EntropySGDJAX,
+    GDRestartsJAX,
+    GaussianSmoothingGDJAX,
+    NoisyAdamJAX,
+    OAdamJAX,
+    OGDJAX,
+    PerturbedGDJAX,
+    SGHMCJAX,
+    SGLDJAX,
+)
+from dfbench.algorithms.gradient_based.scipy.bfgs import BFGS
+from dfbench.algorithms.gradient_based.scipy.cobyla import COBYLA
+from dfbench.algorithms.gradient_based.scipy.cobyqa import COBYQA
+from dfbench.algorithms.gradient_based.scipy.dogleg import Dogleg
+from dfbench.algorithms.gradient_based.lbfgs_gd import LBFGSGD
+from dfbench.algorithms.gradient_based.scipy.lbfgsb import LBFGSB
+from dfbench.algorithms.gradient_based.na_adam_gd import NAAdamGD
+from dfbench.algorithms.gradient_based.scipy.newton_cg import NewtonCG
+from dfbench.algorithms.gradient_based.scipy.nonlinear_cg import NonlinearCG
+from dfbench.algorithms.gradient_based.sa_gd import SAGD
+from dfbench.algorithms.gradient_based.scipy.slsqp import SLSQP
+from dfbench.algorithms.gradient_based.scipy.sr1 import SR1
+from dfbench.algorithms.gradient_based.scipy.tnc import TNC
+from dfbench.algorithms.gradient_based.scipy.trust_constr import TrustConstr
+from dfbench.algorithms.gradient_based.scipy.trust_krylov import TrustKrylov
+from dfbench.algorithms.gradient_based.scipy.trust_ncg import TrustNCG
+from dfbench.algorithms.surrogate_based.botorch.botorch_bo import BotorchBO
+from dfbench.algorithms.surrogate_based.botorch.botorch_turbo import BotorchTuRBO
+from dfbench.algorithms.surrogate_based.restir import ReSTIR
+from dfbench.algorithms.surrogate_based.ax_baxus import BAxUS
+from dfbench.algorithms.surrogate_based.botorch.botorch_qnei import BotorchqNEI
+from dfbench.algorithms.surrogate_based.botorch.botorch_qkg import BotorchqKG
+from dfbench.algorithms.surrogate_based.botorch.botorch_rembo import REMBO
+from dfbench.algorithms.surrogate_based.botorch.botorch_gebo import GEBO
+from dfbench.algorithms.surrogate_based.botorch.botorch_linebo import LineBO
+from dfbench.algorithms.surrogate_based.hebo_bo import HEBO
+from dfbench.algorithms.surrogate_based.turbo_lbfgs import TuRBOLBFGS
+from dfbench.algorithms.generative.vae_sampling import VAESampling
+from dfbench.algorithms.derivative_free.pdfo.uobyqa import PDFOUOBYQA
+from dfbench.algorithms.derivative_free.pdfo.newuoa import PDFONEWUOA
+from dfbench.algorithms.derivative_free.pdfo.lincoa import PDFOLINCOA
+from dfbench.algorithms.derivative_free.pybobyqa import PyBOBYQA
+
+# Optax
+from dfbench.algorithms.gradient_based.optax.adam import OptaxAdam
+from dfbench.algorithms.gradient_based.optax.adamw import OptaxAdamW
+from dfbench.algorithms.gradient_based.optax.adabelief import OptaxAdaBelief
+from dfbench.algorithms.gradient_based.optax.adafactor import OptaxAdafactor
+from dfbench.algorithms.gradient_based.optax.amsgrad import OptaxAMSGrad
+from dfbench.algorithms.gradient_based.optax.adagrad import OptaxAdaGrad
+from dfbench.algorithms.gradient_based.optax.adadelta import OptaxAdaDelta
+from dfbench.algorithms.gradient_based.optax.adamax import OptaxAdaMax
+from dfbench.algorithms.gradient_based.optax.adamaxw import OptaxAdaMaxW
+from dfbench.algorithms.gradient_based.optax.adan import OptaxAdan
+from dfbench.algorithms.gradient_based.optax.lion import OptaxLion
+from dfbench.algorithms.gradient_based.optax.lamb import OptaxLAMB
+from dfbench.algorithms.gradient_based.optax.nadam import OptaxNadam
+from dfbench.algorithms.gradient_based.optax.nadamw import OptaxNadamW
+from dfbench.algorithms.gradient_based.optax.rmsprop import OptaxRMSProp
+from dfbench.algorithms.gradient_based.optax.rprop import OptaxRProp
+from dfbench.algorithms.gradient_based.optax.radam import OptaxRAdam
+from dfbench.algorithms.gradient_based.optax.sgd import OptaxSGD, OptaxSGDM, OptaxNAG
+from dfbench.algorithms.gradient_based.optax.noisy_sgd import OptaxNoisySGD
+from dfbench.algorithms.gradient_based.optax.polyak_sgd import OptaxPolyakSGD
+from dfbench.algorithms.gradient_based.optax.sam import OptaxSAM
+from dfbench.algorithms.gradient_based.optax.sophia import OptaxSophia
+from dfbench.algorithms.gradient_based.optax.lookahead import OptaxLookahead
+from dfbench.algorithms.gradient_based.optax.schedule_free_adam import OptaxScheduleFreeAdam
+from dfbench.algorithms.gradient_based.optax.yogi import OptaxYogi
+from dfbench.algorithms.gradient_based.optax.novograd import OptaxNovoGrad
+from dfbench.algorithms.gradient_based.optax.ogd import OptaxOGD
+from dfbench.algorithms.gradient_based.optax.oadam import OptaxOAdam
+from dfbench.algorithms.gradient_based.optax.sign import OptaxSignSGD, OptaxSignum
+from dfbench.algorithms.gradient_based.optax.sm3 import OptaxSM3
+from dfbench.algorithms.gradient_based.optax_lbfgs import OptaxLBFGS
+
+# External-package algorithms: imported only when their dependencies exist.
+try:
+    from dfbench.algorithms.surrogate_based.ax_saasbo import AxSAASBO
+except ImportError:
+    pass
+
+try:
+    from dfbench.algorithms.surrogate_based.smac_bo import SMAC
+except ImportError:
+    pass
+
+__all__ = [
+    "BasinHopping",
+    "DualAnnealing",
+    "NelderMead",
+    "OmadsMADS",
+    "OmadsOrthoMADS",
+    "Powell",
+    "EvoxES",
+    "EvoxPSO",
+    "NevergradNGOpt",
+    "NevergradOnePlusOne",
+    "NevergradTBPSA",
+    "RandomSearch",
+    "PyCMACMAES",
+    "PyCMAActiveCMAES",
+    "PyCMAIPOP",
+    "PyCMABIPOP",
+    "CMAESSepCMA",
+    "EvosaxMAES",
+    "EvosaxLMMAES",
+    "JAXOnePlusOneES",
+    "JAXMuLambdaES",
+    "AdamGD",
+    "SGLDJAX",
+    "ASAMJAX",
+    "AdamToLBFGSJAX",
+    "EntropySGDJAX",
+    "SGHMCJAX",
+    "ARCJAX",
+    "OGDJAX",
+    "OAdamJAX",
+    "PerturbedGDJAX",
+    "NoisyAdamJAX",
+    "GDRestartsJAX",
+    "GaussianSmoothingGDJAX",
+    "BFGS",
+    "COBYLA",
+    "COBYQA",
+    "Dogleg",
+    "LBFGSGD",
+    "LBFGSB",
+    "NAAdamGD",
+    "NewtonCG",
+    "NonlinearCG",
+    "SAGD",
+    "SLSQP",
+    "SR1",
+    "TNC",
+    "TrustConstr",
+    "TrustKrylov",
+    "TrustNCG",
+    "BotorchBO",
+    "BotorchTuRBO",
+    "ReSTIR",
+    "AxSAASBO",
+    "BAxUS",
+    "BotorchqNEI",
+    "BotorchqKG",
+    "REMBO",
+    "GEBO",
+    "LineBO",
+    "HEBO",
+    "SMAC",
+    "TuRBOLBFGS",
+    "VAESampling",
+    "PDFOUOBYQA",
+    "PDFONEWUOA",
+    "PDFOLINCOA",
+    "PyBOBYQA",
+    # Optax batch
+    "OptaxAdam",
+    "OptaxAdamW",
+    "OptaxAdaBelief",
+    "OptaxAdafactor",
+    "OptaxAMSGrad",
+    "OptaxAdaGrad",
+    "OptaxAdaDelta",
+    "OptaxAdaMax",
+    "OptaxAdaMaxW",
+    "OptaxAdan",
+    "OptaxLion",
+    "OptaxLAMB",
+    "OptaxNadam",
+    "OptaxNadamW",
+    "OptaxRMSProp",
+    "OptaxRProp",
+    "OptaxRAdam",
+    "OptaxSGD",
+    "OptaxSGDM",
+    "OptaxNAG",
+    "OptaxNoisySGD",
+    "OptaxPolyakSGD",
+    "OptaxSAM",
+    "OptaxSophia",
+    "OptaxLookahead",
+    "OptaxScheduleFreeAdam",
+    "OptaxYogi",
+    "OptaxNovoGrad",
+    "OptaxOGD",
+    "OptaxOAdam",
+    "OptaxSignSGD",
+    "OptaxSignum",
+    "OptaxSM3",
+    "OptaxLBFGS",
+]

dfbench/algorithms/derivative_free/__init__.py

@@ -0,0 +1,23 @@
+"""Derivative-free optimization algorithms.
+
+Includes mesh-based direct search (OMADS), Powell-style trust-region methods
+(PDFO: UOBYQA, NEWUOA, LINCOA; plus Py-BOBYQA), and SciPy classics
+(Nelder-Mead, Powell).
+"""
+
+from dfbench.algorithms.derivative_free.nelder_mead import NelderMead
+from dfbench.algorithms.derivative_free.omads_mads import OmadsMADS, OmadsOrthoMADS
+from dfbench.algorithms.derivative_free.pdfo import PDFOLINCOA, PDFONEWUOA, PDFOUOBYQA
+from dfbench.algorithms.derivative_free.powell import Powell
+from dfbench.algorithms.derivative_free.pybobyqa import PyBOBYQA
+
+__all__ = [
+    "NelderMead",
+    "OmadsMADS",
+    "OmadsOrthoMADS",
+    "PDFOLINCOA",
+    "PDFONEWUOA",
+    "PDFOUOBYQA",
+    "Powell",
+    "PyBOBYQA",
+]

dfbench/algorithms/derivative_free/_dfo_common.py

@@ -0,0 +1,150 @@
+"""Common derivative-free optimization wrapper utilities.
+
+Provides shared infrastructure for wrapping DFO solvers (PDFO, Py-BOBYQA, etc.)
+so they integrate cleanly with the Objective / OptimizationAlgorithm interface.
+
+Key responsibilities:
+  - Convert between JAX arrays and NumPy arrays expected by solvers.
+  - Evaluate ``obj.value(...)`` in bounded space and log results.
+  - Enforce Objective budgets via a callback / early-termination mechanism.
+  - Support multistart restarts with fresh random starting points.
+  - Handle NaN / Inf returns and solver failure codes gracefully.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import jax.numpy as jnp
+from jax import random
+from jaxtyping import Array, Float
+
+from dfbench.core.objective import Objective
+
+
+# Large but finite penalty returned when the solver evaluates an infeasible
+# or NaN-producing point.  Using ``np.inf`` would crash most DFO solvers.
+_NAN_PENALTY = 1e30
+
+
+class _BudgetExhausted(Exception):
+    """Raised inside a DFO callback when the Objective budget is exhausted.
+
+    For pure-Python solvers (e.g. Py-BOBYQA) this propagates immediately and
+    terminates the optimisation loop.  For Fortran-backed solvers (PDFO/prima)
+    f2py stores the exception and re-raises it after the current Fortran call
+    returns, which also causes prima to abort early.
+    """
+
+
+def dfo_objective_wrapper(
+    obj: Objective,
+) -> callable:
+    """Return a NumPy-compatible scalar function that evaluates ``obj.value``.
+
+    The returned callable accepts a 1-D ``np.ndarray``, converts it to a JAX
+    array, evaluates through ``obj.value`` (which logs the evaluation), and
+    returns a Python float.
+
+    NaN / Inf losses are replaced with ``_NAN_PENALTY`` so that DFO solvers
+    do not crash.  When the Objective budget is exceeded the wrapper raises
+    ``_BudgetExhausted`` instead of calling the (expensive) physics evaluation.
+
+    Returns:
+        ``fun(x: np.ndarray) -> float``
+    """
+
+    def _fun(x: np.ndarray) -> float:
+        if obj.budget_exceeded:
+            raise _BudgetExhausted
+        params = jnp.asarray(x)
+        loss = obj.value(params)
+        loss_f = float(loss)
+        if not np.isfinite(loss_f):
+            return _NAN_PENALTY
+        return loss_f
+
+    return _fun
+
+
+def random_bounded_start(
+    obj: Objective,
+    key,
+) -> tuple[np.ndarray, "jax.Array"]:
+    """Sample a uniformly random starting point within problem bounds.
+
+    Args:
+        obj: Objective (must be in bounded mode).
+        key: JAX PRNG key; a new sub-key is split off and the updated key
+            is returned alongside the sample.
+
+    Returns:
+        (x0, new_key) – x0 is a 1-D ``np.ndarray`` of shape ``(n_params,)``.
+    """
+    key, subkey = random.split(key)
+    lower, upper = obj.problem.bounds
+    x0_jax = random.uniform(subkey, shape=(obj.n_params,), minval=lower, maxval=upper)
+    return np.asarray(x0_jax, dtype=np.float64), key
+
+
+def clip_to_bounds(x: np.ndarray, obj: Objective) -> np.ndarray:
+    """Clip a parameter vector to the problem bounds (in-place safe).
+
+    Returns:
+        Clipped copy of *x*.
+    """
+    lower = np.asarray(obj.problem.bounds[0], dtype=np.float64)
+    upper = np.asarray(obj.problem.bounds[1], dtype=np.float64)
+    return np.clip(x, lower, upper)
+
+
+def solver_bounds_np(obj: Objective) -> tuple[np.ndarray, np.ndarray]:
+    """Return ``(lower, upper)`` as plain NumPy float64 arrays."""
+    lower = np.asarray(obj.problem.bounds[0], dtype=np.float64)
+    upper = np.asarray(obj.problem.bounds[1], dtype=np.float64)
+    return lower, upper
+
+
+def multistart_loop(
+    obj: Objective,
+    key,
+    solve_fn: callable,
+    n_restarts: int = 1,
+    init_params: Float[Array, "..."] | None = None,
+) -> None:
+    """Run *solve_fn* up to *n_restarts* times with fresh random starts.
+
+    ``solve_fn(x0: np.ndarray)`` should call the DFO solver once from
+    starting point *x0*.  It may raise or return; either way the best
+    result is tracked by the Objective automatically.
+
+    The first restart uses *init_params* (if provided); subsequent restarts
+    sample uniformly within bounds.
+
+    Args:
+        obj: The Objective instance (already logging).
+        key: JAX PRNG key for sampling restarts.
+        solve_fn: ``(x0: np.ndarray) -> None`` – runs one solver call.
+        n_restarts: Total number of solver invocations.
+        init_params: Optional starting point for the first restart.
+    """
+    for i in range(n_restarts):
+        if obj.budget_exceeded:
+            break
+
+        if i == 0 and init_params is not None:
+            x0 = np.asarray(init_params, dtype=np.float64)
+        else:
+            x0, key = random_bounded_start(obj, key)
+
+        try:
+            solve_fn(x0)
+        except _BudgetExhausted:
+            break
+        except Exception as exc:  # noqa: BLE001
+            if obj.budget_exceeded:
+                # Exception was likely triggered (directly or indirectly) by
+                # _BudgetExhausted propagating through the solver; stop quietly.
+                break
+            # DFO solvers may raise on degenerate geometry, singular models,
+            # etc.  Log and continue with next restart.
+            print(f"[DFO restart {i+1}/{n_restarts}] solver raised {type(exc).__name__}: {exc}")

dfbench/algorithms/derivative_free/_scipy_common.py

@@ -0,0 +1,124 @@
+"""Shared utilities for SciPy-based derivative-free optimizers.
+
+Provides numpy↔JAX wrappers, bounds conversion, and budget-aware
+callbacks so individual algorithm modules stay DRY.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import jax.numpy as jnp
+from scipy.optimize import Bounds
+
+from dfbench.core.objective import Objective
+
+
+class SciPyBudgetExceeded(RuntimeError):
+    """Raised inside a SciPy objective/callback when the Objective budget is spent."""
+
+
+# Large but finite penalty returned when the objective produces NaN/Inf.
+# Using ``np.inf`` causes SciPy's derivative-free solvers (Nelder-Mead,
+# Powell, basin-hopping, dual-annealing) to terminate prematurely or crash.
+_NAN_PENALTY = 1e30
+
+
+# ---------------------------------------------------------------------------
+# Bounds helpers
+# ---------------------------------------------------------------------------
+
+
+def scipy_bounds(obj: Objective) -> Bounds:
+    """Convert problem bounds to :class:`scipy.optimize.Bounds`."""
+    lb = np.asarray(obj.problem.bounds[0], dtype=np.float64)
+    ub = np.asarray(obj.problem.bounds[1], dtype=np.float64)
+    return Bounds(lb, ub)
+
+
+def scipy_bounds_list(obj: Objective) -> list[tuple[float, float]]:
+    """Return bounds as ``[(lb0, ub0), …]`` (format used by *dual_annealing*)."""
+    lb = np.asarray(obj.problem.bounds[0], dtype=np.float64)
+    ub = np.asarray(obj.problem.bounds[1], dtype=np.float64)
+    return list(zip(lb.tolist(), ub.tolist()))
+
+
+# ---------------------------------------------------------------------------
+# Objective wrappers
+# ---------------------------------------------------------------------------
+
+
+def make_scipy_fun(obj: Objective):
+    """Return a numpy-in / float-out wrapper around ``obj.value()``.
+
+    Raises :class:`SciPyBudgetExceeded` when the evaluation budget is spent so
+    the calling SciPy routine can be interrupted cleanly.
+    """
+
+    def fun(x_np: np.ndarray) -> float:
+        if obj.budget_exceeded:
+            raise SciPyBudgetExceeded
+        loss = float(obj.value(jnp.asarray(x_np)))
+        if not np.isfinite(loss):
+            return _NAN_PENALTY
+        return loss
+
+    return fun
+
+
+def make_scipy_fun_and_grad(obj: Objective):
+    """Return a wrapper calling ``obj.value_and_grad()`` → ``(float, ndarray)``.
+
+    Intended for use with ``jac=True`` in :func:`scipy.optimize.minimize` so
+    that value and gradient are obtained in a single Objective call, avoiding
+    double-counted evaluations.
+    """
+
+    def fun(x_np: np.ndarray) -> tuple[float, np.ndarray]:
+        if obj.budget_exceeded:
+            raise SciPyBudgetExceeded
+        loss, grad = obj.value_and_grad(jnp.asarray(x_np))
+        loss_f = float(loss)
+        grad_np = np.asarray(grad, dtype=np.float64)
+        if not np.isfinite(loss_f) or not np.all(np.isfinite(grad_np)):
+            return _NAN_PENALTY, np.zeros_like(x_np, dtype=np.float64)
+        return loss_f, grad_np
+
+    return fun
+
+
+# ---------------------------------------------------------------------------
+# Callbacks
+# ---------------------------------------------------------------------------
+
+
+def make_budget_callback(obj: Objective):
+    """Return a ``callback(xk)`` that raises :class:`SciPyBudgetExceeded`."""
+
+    def callback(xk, *_args, **_kwargs):
+        if obj.budget_exceeded:
+            raise SciPyBudgetExceeded
+
+    return callback
+
+
+# ---------------------------------------------------------------------------
+# Bounded step-taker for basin-hopping
+# ---------------------------------------------------------------------------
+
+
+class BoundedStep:
+    """Random displacement clipped to problem bounds.
+
+    Drop-in replacement for SciPy's default ``RandomDisplacement`` that
+    guarantees the perturbed point remains feasible.
+    """
+
+    def __init__(self, stepsize: float, lb: np.ndarray, ub: np.ndarray) -> None:
+        self.stepsize = stepsize
+        self.lb = lb
+        self.ub = ub
+
+    def __call__(self, x: np.ndarray) -> np.ndarray:
+        scale = self.stepsize * (self.ub - self.lb)
+        x_new = x + np.random.uniform(-scale, scale, size=x.shape)
+        return np.clip(x_new, self.lb, self.ub)

dfbench/algorithms/derivative_free/nelder_mead.py

@@ -0,0 +1,97 @@
+"""Nelder-Mead simplex algorithm via :func:`scipy.optimize.minimize`."""
+
+from __future__ import annotations
+
+import numpy as np
+import jax.numpy as jnp
+from jaxtyping import Array, Float
+from scipy.optimize import minimize
+
+from dfbench.core.algorithm import AlgorithmType, OptimizationAlgorithm
+from dfbench.core.objective import Objective
+from dfbench.algorithms.derivative_free._scipy_common import (
+    SciPyBudgetExceeded,
+    make_scipy_fun,
+    scipy_bounds,
+    make_budget_callback,
+)
+
+
+class NelderMead(OptimizationAlgorithm):
+    """Nelder-Mead simplex derivative-free local optimizer.
+
+    Uses ``scipy.optimize.minimize(method='Nelder-Mead')`` in **bounded**
+    parameter space (requires SciPy >= 1.7).
+
+    Suitable as a local refinement method or for low-dimensional problems
+    where gradient information is unavailable or unreliable.
+
+    Attributes:
+        algorithm_str: ``"nelder_mead"``
+        algorithm_type: :attr:`AlgorithmType.EVOLUTIONARY`
+    """
+
+    algorithm_str: str = "nelder_mead"
+    algorithm_type: AlgorithmType = AlgorithmType.EVOLUTIONARY
+
+    def __init__(self) -> None:
+        pass
+
+    def optimize(
+        self,
+        problem_objective: Objective,
+        init_params: Float[Array, "..."] | None = None,
+        random_seed: int | None = None,
+        xatol: float = 1e-8,
+        fatol: float = 1e-8,
+        adaptive: bool = True,
+    ) -> None:
+        """Run Nelder-Mead simplex optimization.
+
+        Args:
+            problem_objective: Pre-configured Objective instance.
+            init_params: Starting point. If *None*, sampled uniformly in bounds.
+            random_seed: Seed for reproducibility (controls initial point).
+            xatol: Absolute parameter tolerance for convergence.
+            fatol: Absolute function-value tolerance for convergence.
+            adaptive: Adapt simplex parameters to dimensionality (recommended
+                for n > 1).
+        """
+        obj = problem_objective
+
+        random_seed, _key = self.prepare(
+            obj, unbounded=False, random_seed=random_seed
+        )
+
+        if init_params is None:
+            params = obj.random_params_bounded()
+        else:
+            params = init_params
+
+        # JIT warmup
+        _ = obj.value(params)
+
+        obj.start_logging()
+
+        fun = make_scipy_fun(obj)
+        x0 = np.asarray(params, dtype=np.float64)
+        bounds = scipy_bounds(obj)
+        callback = make_budget_callback(obj)
+        maxfev = obj.evals_left if obj.evals_left is not None else 10_000
+
+        try:
+            minimize(
+                fun,
+                x0,
+                method="Nelder-Mead",
+                bounds=bounds,
+                callback=callback,
+                options={
+                    "maxfev": maxfev,
+                    "xatol": xatol,
+                    "fatol": fatol,
+                    "adaptive": adaptive,
+                },
+            )
+        except SciPyBudgetExceeded:
+            pass