scipy minimize generator

docs/algorithms.md

@@ -65,7 +65,8 @@ Scipy Generators
 These generators serve as wrappers for algorithms implemented in scipy.
 
 - [`NelderMeadGenerator`](examples/sequential/neldermead.ipynb): implements Nelder-Mead (simplex) optimization.
-- [`LatinHypercubeGenerator`](examples/scipy/latin_hypercube.ipynb): perform latin hypercube sampling of the evaluation function.
+- [`ScipyGenerator`](examples/sequential/scipy.ipynb): generic wrapper around `scipy.optimize.minimize` methods.
+- [`LatinHypercubeGenerator`](examples/other/latin_hypercube.ipynb): performs latin hypercube sampling of the evaluation function.
 
 RCDS Generators
 ===

docs/api/generators/sequential/scipy.md

@@ -0,0 +1,64 @@
+# Scipy Minimize Generator
+
+`ScipyGenerator` exposes scipy's `optimize.minimize` methods through Xopt's sequential ask/tell interface.
+
+## Integration Model
+
+Xopt evaluates objective functions externally, one point at a time. `scipy.optimize.minimize` expects an in-process callable objective. `ScipyGenerator` bridges this mismatch by running one persistent scipy session in a worker thread:
+
+1. A cache is built from prior evaluations (`data`) keyed by rounded variable values.
+2. A single `minimize` call starts in a background thread.
+3. The objective callback first checks the cache.
+4. For an uncached point, that point is pushed to Xopt via a request queue.
+5. Xopt evaluates the point externally and calls `add_data`.
+6. The objective value is sent back through a response queue, and the same scipy run continues from in-memory state.
+
+## Performance Notes
+
+- Cache reconstruction is O(N) when a session starts or data is reloaded.
+- The active scipy run is maintained between `step` calls; `minimize` is not restarted each step.
+- Keys are rounded to 12 decimals before cache lookup to reduce floating-point key mismatch issues.
+
+## Supported Methods
+
+`method` is validated against bounded scipy methods supported by this wrapper:
+
+- `Nelder-Mead`
+- `Powell`
+- `L-BFGS-B`
+- `TNC`
+- `SLSQP`
+- `trust-constr`
+- `COBYLA`
+- `COBYQA`
+
+Invalid or empty method names fail validation.
+
+## Session Lifecycle and Errors
+
+- `reset()` stops the active worker session and clears transient runtime state.
+- `set_data(...)` stops any active session, reloads data, and rebuilds the cache.
+- If scipy converges using only cached values, generation falls back to the latest known data row.
+- Common scipy `ValueError` messages are remapped to clearer runtime errors (for example unsupported solver availability or bound handling).
+
+## State Restoration
+
+For model-level roundtrips, use pydantic serialization:
+
+- `model_dump()`
+- `model_validate(...)`
+
+Then restore the evaluation history with `set_data(...)` so the cache and last outcome are reconstructed before continuing optimization.
+
+The class also defines `__getstate__` and `__setstate__` for explicit state handling of non-picklable runtime thread objects.
+
+## Configuration
+
+Typical fields:
+
+- `method`: scipy minimization method name, e.g. `Powell`, `Nelder-Mead`, `L-BFGS-B`.
+- `initial_point`: optional starting point dictionary.
+- `tol`, `options`: passed directly to `scipy.optimize.minimize`.
+- `scipy_kwargs`: additional keyword arguments forwarded to scipy.
+
+::: xopt.generators.sequential.scipy

docs/examples/sequential/scipy.ipynb

@@ -0,0 +1,161 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3841297f",
+   "metadata": {},
+   "source": [
+    "# ScipyGenerator with scipy.optimize.minimize\n",
+    "\n",
+    "This notebook demonstrates how to use Xopt's `ScipyGenerator` to drive any supported scipy `optimize.minimize` method in a sequential ask/tell workflow."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ece077aa",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2517dcff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from xopt import Evaluator, VOCS, Xopt\n",
+    "from xopt.generators.sequential.scipy import ScipyGenerator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca499090",
+   "metadata": {},
+   "source": [
+    "## Define a simple objective\n",
+    "\n",
+    "We will optimize the 2D Rosenbrock function, exposed through an Xopt evaluator function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7702f19c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rosenbrock_eval(input_dict):\n",
+    "    x0 = input_dict[\"x0\"]\n",
+    "    x1 = input_dict[\"x1\"]\n",
+    "    y = (1 - x0) ** 2 + 100.0 * (x1 - x0**2) ** 2\n",
+    "    return {\"y\": float(y)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29a8f4d5",
+   "metadata": {},
+   "source": [
+    "## Configure `ScipyGenerator`\n",
+    "\n",
+    "Choose a scipy method using `method`. Here we use `L-BFGS-B`, but methods such as `Nelder-Mead`, `Powell`, and others can also be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b020f9b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vocs = VOCS(\n",
+    "    variables={\"x0\": [-2.0, 2.0], \"x1\": [-1.0, 3.0]},\n",
+    "    objectives={\"y\": \"MINIMIZE\"},\n",
+    ")\n",
+    "\n",
+    "generator = ScipyGenerator(\n",
+    "    vocs=vocs,\n",
+    "    method=\"L-BFGS-B\",\n",
+    "    initial_point={\"x0\": -1.2, \"x1\": 1.0},\n",
+    "    options={\"maxiter\": 200},\n",
+    ")\n",
+    "\n",
+    "evaluator = Evaluator(function=rosenbrock_eval)\n",
+    "X = Xopt(generator=generator, evaluator=evaluator, vocs=vocs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b3fe58b",
+   "metadata": {},
+   "source": [
+    "## Run optimization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "775e0fe9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for _ in range(200):\n",
+    "    X.step()\n",
+    "\n",
+    "best_idx = X.data[\"y\"].argmin()\n",
+    "best = X.data.iloc[best_idx]\n",
+    "\n",
+    "print(\"Evaluations:\", len(X.data))\n",
+    "print(\"Best point:\", {\"x0\": float(best[\"x0\"]), \"x1\": float(best[\"x1\"])})\n",
+    "print(\"Best objective:\", float(best[\"y\"]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "444a1f87",
+   "metadata": {},
+   "source": [
+    "## Inspect convergence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5518499",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ax = X.data[\"y\"].plot(figsize=(7, 4), logy=True)\n",
+    "ax.set_xlabel(\"iteration\")\n",
+    "ax.set_ylabel(\"objective y (log scale)\")\n",
+    "ax.set_title(\"ScipyGenerator optimization progression\")\n",
+    "plt.tight_layout()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "xopt-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

mkdocs.yml

@@ -62,11 +62,12 @@ nav:
               - Genetic operators: examples/ga/nsga2/genetic_operators.ipynb
 
         - Sequential:
+            - Scipy Minimize: examples/sequential/scipy.ipynb
             - Nelder-Mead: examples/sequential/neldermead.ipynb
             - Extremum seeking: examples/sequential/extremum_seeking.ipynb
             - RCDS: examples/sequential/rcds.ipynb
         - Other:
-            - Latin Hypercube: examples/scipy/latin_hypercube.ipynb
+            - Latin Hypercube: examples/other/latin_hypercube.ipynb
         - Developer:
             - Benchmarking & Profiling: examples/developer/benchmarking.md
 
@@ -104,6 +105,7 @@ nav:
               - Genetic Operators: api/generators/ga/operators.md
           - Sequential generators:
               - Sequential Base Class: api/generators/sequential/sequential_generator.md
+              - Scipy Minimize: api/generators/sequential/scipy.md
               - RCDS: api/generators/sequential/rcds.md
               - Extremum Seeking: api/generators/sequential/extremumseeking.md
               - Nelder-Mead: api/generators/sequential/neldermead.md

xopt/generators/__init__.py

@@ -15,7 +15,7 @@
 # don't import this directly -- use
 all_generator_names = {
     "mggpo": {"mggpo"},
-    "scipy": {"neldermead", "latin_hypercube"},
+    "scipy": {"neldermead", "latin_hypercube", "scipy"},
     "bo": {
         "upper_confidence_bound",
         "mobo",
@@ -61,9 +61,11 @@ def get_generator_dynamic(name: str) -> type[Generator]:
         try:
             from xopt.generators.scipy.latin_hypercube import LatinHypercubeGenerator
             from xopt.generators.sequential.neldermead import NelderMeadGenerator
+            from xopt.generators.sequential.scipy import ScipyGenerator
 
             registered_generators = [
                 NelderMeadGenerator,
+                ScipyGenerator,
                 LatinHypercubeGenerator,
             ]
 
@@ -159,6 +161,8 @@ def get_generator_defaults(
 
         if v.is_required():
             defaults[k] = None
+        elif v.default_factory is not None:
+            defaults[k] = v.default_factory()
         else:
             if v.default is None:
                 defaults[k] = None

xopt/generators/scipy/__init__.py

@@ -1,4 +0,0 @@
-from xopt.generators.scipy.latin_hypercube import LatinHypercubeGenerator
-from xopt.generators.sequential.neldermead import NelderMeadGenerator
-
-__all__ = ["LatinHypercubeGenerator", "NelderMeadGenerator"]

xopt/generators/sequential/__init__.py

@@ -2,10 +2,12 @@
 from xopt.generators.sequential.rcds import RCDSGenerator
 from xopt.generators.sequential.extremumseeking import ExtremumSeekingGenerator
 from xopt.generators.sequential.neldermead import NelderMeadGenerator
+from xopt.generators.sequential.scipy import ScipyGenerator
 
 __all__ = [
     "SequentialGenerator",
     "RCDSGenerator",
     "ExtremumSeekingGenerator",
     "NelderMeadGenerator",
+    "ScipyGenerator",
 ]