xopt 3.2.2__tar.gz → 3.3.0__tar.gz

{xopt-3.2.2/xopt.egg-info → xopt-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xopt
-Version: 3.2.2
+Version: 3.3.0
 Summary: Flexible optimization of arbitrary problems in Python.
 Author: Christopher Mayes, Ryan Roussel, Nikita Kuklev, Christopher Pierce, Sara Miskovich
 License:                                  Apache License
@@ -305,11 +305,12 @@ Currenty **Xopt** provides:
   - `extremum_seeking` Extremum seeking time-dependent optimization
   - `rcds` Robust Conjugate Direction Search (RCDS)
   - `neldermead` Nelder-Mead Simplex
+  - `scipy` Scipy-based optimization algorithms (Powell, L-BFGS-B, etc.)
 - Sampling algorithms:
   - `random` Uniform random sampling
 - Convenient YAML/JSON based input format
 - Driver programs:
-  - `xopt.mpi.run` Parallel MPI execution using this input format
+  - `xopt-mpirun` Parallel MPI execution using this input format
 
 Xopt does **not** provide:
 - your custom simulation or experimental measurement via an `evaluate` function.
@@ -428,7 +429,7 @@ Using MPI
 ===============
 Example MPI run, with `xopt.yaml` as the only user-defined file:
 ```b
-mpirun -n 64 python -m mpi4py.futures -m xopt.mpi.run xopt.yaml
+mpirun -n 64 xopt-mpirun xopt.yaml
 ```
 
 

{xopt-3.2.2 → xopt-3.3.0}/README.md

@@ -53,11 +53,12 @@ Currenty **Xopt** provides:
   - `extremum_seeking` Extremum seeking time-dependent optimization
   - `rcds` Robust Conjugate Direction Search (RCDS)
   - `neldermead` Nelder-Mead Simplex
+  - `scipy` Scipy-based optimization algorithms (Powell, L-BFGS-B, etc.)
 - Sampling algorithms:
   - `random` Uniform random sampling
 - Convenient YAML/JSON based input format
 - Driver programs:
-  - `xopt.mpi.run` Parallel MPI execution using this input format
+  - `xopt-mpirun` Parallel MPI execution using this input format
 
 Xopt does **not** provide:
 - your custom simulation or experimental measurement via an `evaluate` function.
@@ -176,7 +177,7 @@ Using MPI
 ===============
 Example MPI run, with `xopt.yaml` as the only user-defined file:
 ```b
-mpirun -n 64 python -m mpi4py.futures -m xopt.mpi.run xopt.yaml
+mpirun -n 64 xopt-mpirun xopt.yaml
 ```
 
 

{xopt-3.2.2 → xopt-3.3.0}/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
 ===

xopt-3.3.0/docs/api/generators/sequential/scipy.md

@@ -0,0 +1,80 @@
+# Scipy Minimize Generator
+
+`ScipyGenerator` exposes scipy's `optimize.minimize` methods through Xopt's sequential ingest/suggest 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.
+
+Only the first `add_data` call answering a pending request sends a response to
+scipy. Repeated submissions of the same candidate remain in the data history,
+but cannot answer a later request. Values are also cached under the requested
+coordinates, so small readback differences accepted by sequential point
+validation do not cause cache misses after a session restart.
+
+## 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 the result and completion state.
+- `set_data(...)` stops any active session, clears completion state, reloads data, and rebuilds the cache.
+- Each worker retains its own stop event, queues, and cache. Shutdown waits up to two seconds and warns if the worker is still running in scipy; that worker cannot consume responses or publish requests, results, or errors into a subsequent session.
+- `result` exposes scipy's `OptimizeResult` after termination, including `success`, `message`, and solver-specific fields such as `nit`. It is `None` before termination.
+- `is_done` is true once scipy terminates, including unsuccessful termination (for example, reaching an iteration limit). Check `result.success` to distinguish successful convergence.
+- Once terminated, later `generate()` calls do not restart scipy or rebuild the cache. For compatibility, they still return the latest known data row, with a `RuntimeWarning` emitted once per session on this fallback path. Further explicit `Xopt.step()` calls will re-evaluate and append this duplicate; stop stepping when `generator.is_done` is true.
+- 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.
+Pickling does not stop the original worker. Pickle and deep-copy roundtrips retain
+completed results and the completion latch without sharing runtime thread objects;
+model-level roundtrips restart from the restored evaluation history instead.
+Requested-coordinate cache entries are retained through `reset()`, pickle, and
+deep-copy roundtrips. Replacing the dataset with `set_data(...)` clears these
+entries; model-level roundtrips rebuild from observed coordinates in the restored
+history.
+
+## 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

xopt-3.3.0/docs/api/stopping_conditions.md

@@ -0,0 +1,33 @@
+# Stopping Conditions
+
+## Maximum elapsed time
+
+Use `MaxTimeCondition` to stop after a positive, finite number of wall-clock
+seconds:
+
+```python
+from xopt.stopping_conditions import MaxTimeCondition
+
+X.stopping_condition = MaxTimeCondition(max_time=60.0)
+X.run()
+```
+
+The timer starts when `should_stop()` is first called, normally at the start of
+`run()`, and uses a monotonic clock. Time before that first check is not counted.
+Conditions are checked between optimization steps, so an
+in-progress evaluation is allowed to finish and the time limit may be exceeded.
+The condition also works without evaluation data and can be nested inside a
+`CompositeCondition`.
+
+For YAML configuration:
+
+```yaml
+stopping_condition:
+  name: MaxTimeCondition
+  max_time: 60.0
+```
+
+Only the time limit is serialized. Loading a saved configuration resets the
+timer; the full time budget starts at the first check.
+
+::: xopt.stopping_conditions

{xopt-3.2.2 → xopt-3.3.0}/docs/index.md

@@ -42,12 +42,13 @@ Currenty **Xopt** provides:
     - [`extremum_seeking`](examples/sequential/extremum_seeking.ipynb) Extremum seeking time-dependent optimization
     - [`rcds`](examples/sequential/rcds.ipynb) Robust Conjugate Direction Search (RCDS)
     - [`neldermead`](examples/sequential/neldermead.ipynb) Nelder-Mead Simplex
+    - [`scipy`](examples/sequential/scipy.ipynb) Scipy-based optimization algorithms (Powell, L-BFGS-B, etc.)
 - Sampling algorithms:
     - `random` Uniform random sampling
 - Convenient YAML/JSON based input format
 - Driver programs:
-    - [`xopt-run`](examples/basic/xopt_cli.md) Run Xopt from the command line using a YAML config file
-    - `xopt.mpi.run` Parallel MPI execution using this input format
+    - [`xopt-run`](examples/basic/xopt_cli.md#xopt-run-usage) Run Xopt from the command line using a YAML config file
+    - [`xopt-mpirun`](examples/basic/xopt_cli.md#xopt-mpirun-usage) Parallel MPI execution using this input format
 
  **Xopt** does **not** provide:
 - your custom simulation via an `evaluate` function.
@@ -151,7 +152,7 @@ Using MPI
 ===============
 Example MPI run, with `xopt.yaml` as the only user-defined file:
 ```b
-mpirun -n 64 python -m mpi4py.futures -m xopt.mpi.run xopt.yaml
+mpirun -n 64 xopt-mpirun xopt.yaml
 ```
 
 

{xopt-3.2.2 → xopt-3.3.0}/mkdocs.yml

@@ -63,11 +63,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
 
@@ -105,6 +106,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-3.2.2 → xopt-3.3.0}/pyproject.toml

@@ -71,7 +71,8 @@ doc = [
 Homepage = "https://github.com/xopt-org/xopt"
 
 [project.scripts]
-xopt-run = "xopt.entrypoint:main"
+xopt-run = "xopt.entrypoint.multiprocessing:main"
+xopt-mpirun = "xopt.entrypoint.mpi:main"
 
 [options]
 zip_safe = false

{xopt-3.2.2 → xopt-3.3.0}/xopt/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.2'
-__version_tuple__ = version_tuple = (3, 2, 2)
+__version__ = version = '3.3.0'
+__version_tuple__ = version_tuple = (3, 3, 0)
 
-__commit_id__ = commit_id = 'gd4c488f75'
+__commit_id__ = commit_id = 'gf13d21cd6'

{xopt-3.2.2 → xopt-3.3.0}/xopt/asynchronous.py

@@ -159,6 +159,13 @@ class AsynchronousXopt(Xopt):
 
         self.add_data(new_data)
 
+        # dump to file(s) if specified
+        if len(new_data):
+            if self.xopt_dump_file is not None:
+                self.dump()
+            if self.data_dump_file is not None:
+                self.dump_data()
+
         # Cleanup
         self._input_data.drop(index, inplace=True)
 

{xopt-3.2.2 → xopt-3.3.0}/xopt/base.py

@@ -391,8 +391,8 @@ class Xopt(XoptBaseModel):
         while True:
             # Check custom stopping condition
             if self.stopping_condition is not None:
-                if self.data is not None and self.stopping_condition.should_stop(
-                    self.data, self.vocs
+                if self.stopping_condition.should_stop(
+                    self.data if self.data is not None else pd.DataFrame(), self.vocs
                 ):
                     logger.info("Xopt is done. Stopping condition met.")
                     break
@@ -539,6 +539,9 @@ class Xopt(XoptBaseModel):
         except DataError as exc:
             if self.strict:
                 raise exc
+            warnings.warn(
+                f"Generator rejected {len(new_data)} new data point(s) (strict=False): {exc}"
+            )
 
     def reset_data(self):
         """

xopt-3.3.0/xopt/entrypoint/__init__.py

@@ -0,0 +1 @@
+__all__ = []

xopt-3.3.0/xopt/entrypoint/mpi.py

@@ -0,0 +1,172 @@
+from mpi4py import MPI
+from mpi4py.futures import MPICommExecutor
+import argparse
+import logging
+import os
+import pandas as pd
+import sys
+import yaml
+
+from xopt import AsynchronousXopt
+from xopt.base import Xopt
+from xopt.entrypoint.utils import (
+    merge_dicts,
+    normalize_initial_data,
+    override_to_dict,
+    setup_import_paths,
+)
+from xopt.log import set_handler_with_logger
+from xopt.pydantic import remove_none_values
+
+
+comm = MPI.COMM_WORLD
+mpi_rank = comm.Get_rank()
+mpi_size = comm.Get_size()
+
+logger = logging.getLogger("xopt")
+
+
+def run_mpi(
+    config,
+    verbosity=None,
+    asynchronous=True,
+    logfile=None,
+    python_path=None,
+    initial_data=None,
+):
+    """
+    Xopt MPI driver
+
+    Basic usage:
+
+    mpirun -n 4 xopt-mpirun xopt.yaml
+
+    Parameters
+    ----------
+    config : dict
+        Xopt configuration.
+    verbosity : int, optional
+        Verbosity count controlling the log level.
+    asynchronous : bool, default=True
+        Run with AsynchronousXopt instead of Xopt.
+    logfile : str, optional
+        File log messages are written to.
+    python_path : list of str, optional
+        Directories added to the module search path on every rank. Worker ranks import
+        the evaluation function themselves, so this must run before the Xopt object is
+        built.
+    initial_data : str, optional
+        CSV file of existing data used to seed the generator, read on the root rank.
+    """
+
+    level = "WARN"
+    if verbosity:
+        iv = verbosity
+        if iv == 1:
+            level = "WARN"
+        elif iv == 2:
+            level = "INFO"
+        elif iv >= 3:
+            level = "DEBUG"
+
+        set_handler_with_logger(level=level)
+
+    if logfile:
+        set_handler_with_logger(file=logfile, level=level)
+
+    setup_import_paths(python_path or [])
+
+    # logger.info(xopt_logo)
+    # logger.info('_________________________________')
+    logger.info(f"Parallel execution with {mpi_size} workers")
+
+    if asynchronous:
+        logger.info("Enabling async mode")
+        X = AsynchronousXopt(**config)
+    else:
+        X = Xopt(**config)
+
+    if mpi_rank == 0:
+        print(X)
+        sys.stdout.flush()
+
+    # Launch MPI executor (it is None for the workers)
+    with MPICommExecutor(MPI.COMM_WORLD, root=0) as executor:
+        if executor is not None:
+            X.evaluator.executor = executor
+            X.evaluator.max_workers = mpi_size
+
+            if initial_data is not None:
+                logger.info(f"Loading initial data from {initial_data}")
+                X.add_data(normalize_initial_data(pd.read_csv(initial_data), X.vocs))
+
+            X.run()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Configure xopt")
+    parser.add_argument("input_file", help="input_file")
+    parser.add_argument("--logfile", "-l", help="Log file to write to")
+    parser.add_argument("--verbose", "-v", action="count", help="Show more log output")
+    parser.add_argument(
+        "--asynchronous",
+        "-a",
+        action=argparse.BooleanOptionalAction,
+        help="Use asynchronous execution",
+        default=True,
+    )
+    parser.add_argument(
+        "--python_path",
+        help="Additional path to add to Python import path for evaluation function module search",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "--override",
+        help="Override config values using dot notation (e.g., generator.mutation_operator.eta_m=20)",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "--initial_data",
+        help="CSV file with initial data to seed the generator before running",
+        type=str,
+        default=None,
+    )
+
+    args = parser.parse_args()
+    if mpi_rank == 0:
+        print(args)
+
+    input_file = args.input_file
+    logfile = args.logfile
+    verbosity = args.verbose
+    asynchronous = args.asynchronous
+
+    if not os.path.exists(input_file):
+        if mpi_rank == 0:
+            print(f"Input file does not exist: {input_file}", file=sys.stderr)
+        sys.exit(1)
+
+    with open(input_file) as f:
+        config = yaml.safe_load(f)
+        config = remove_none_values(config)
+
+    if args.override:
+        logger.info("Applying config file overrides:")
+    for override in args.override:
+        logger.info(f"  {override}")
+        config = merge_dicts(config, override_to_dict(override))
+
+    run_mpi(
+        config,
+        verbosity=verbosity,
+        logfile=logfile,
+        asynchronous=asynchronous,
+        python_path=[os.getcwd()] + args.python_path,
+        initial_data=args.initial_data,
+    )
+
+
+if __name__ == "__main__":
+    main()

xopt-3.2.2/xopt/entrypoint.py → xopt-3.3.0/xopt/entrypoint/multiprocessing.py

@@ -1,61 +1,23 @@
-from .base import Xopt
-from .evaluator import DummyExecutor
-from .pydantic import remove_none_values
+from ..base import Xopt
+from ..evaluator import DummyExecutor
+from ..pydantic import remove_none_values
+from .utils import (
+    merge_dicts,
+    normalize_initial_data,
+    override_to_dict,
+    setup_import_paths,
+)
 from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
 from contextlib import contextmanager
 import argparse
 import logging
 import os
 import pandas as pd
-import sys
 import yaml
 
 
 logger = logging.getLogger(__name__)
 
-_XOPT_INITIAL_COLS = ["xopt_candidate_idx", "xopt_runtime", "xopt_error"]
-
-
-def normalize_initial_data(df: pd.DataFrame, vocs) -> pd.DataFrame:
-    """
-    Validate and normalize a user-supplied initial-data DataFrame before
-    passing it to Xopt.add_data.
-
-    Parameters
-    ----------
-    df : pd.DataFrame
-        Raw DataFrame loaded from the user's CSV.
-    vocs : VOCS
-        The VOCS object from the Xopt instance.
-
-    Returns
-    -------
-    pd.DataFrame
-        Normalized DataFrame with required VOCS columns present, xopt metadata
-        columns filled with defaults if absent, and unrecognized columns dropped.
-    """
-    missing = set(vocs.all_names) - set(df.columns)
-    if missing:
-        raise ValueError(
-            f"Initial data is missing required VOCS columns: {sorted(missing)}"
-        )
-
-    df = df.copy()
-    if "xopt_candidate_idx" not in df.columns:
-        df["xopt_candidate_idx"] = range(len(df))
-    if "xopt_runtime" not in df.columns:
-        df["xopt_runtime"] = 0.0
-    if "xopt_error" not in df.columns:
-        df["xopt_error"] = False
-
-    keep = list(vocs.all_names) + _XOPT_INITIAL_COLS
-    if "xopt_error_str" in df.columns:
-        keep = keep + ["xopt_error_str"]
-    extra = sorted(set(df.columns) - set(keep))
-    if extra:
-        logger.warning(f"Dropping unrecognized columns from initial data: {extra}")
-    return df[[c for c in keep if c in df.columns]]
-
 
 @contextmanager
 def get_executor(name, max_workers=1):
@@ -88,59 +50,6 @@ def get_executor(name, max_workers=1):
         raise ValueError(f"Unknown executor: {name}")
 
 
-def override_to_dict(override: str) -> dict:
-    """
-    Convert strings of form "class_a.class_b.class_c.param=1" to
-    {'class_a': {'class_b': {'class_c': {'param': 1}}}}.
-
-    Uses yaml library for consistent type conversion of values following
-    same convention as in config files.
-
-    Parameters
-    ----------
-    override : str
-        The override string
-
-    Returns
-    -------
-    dict
-        The nested dictionary containing the value.
-    """
-    path, value = override.split("=", 1)
-    yaml_str = (
-        "\n".join([" " * idx + x + ":" for idx, x in enumerate(path.split("."))])
-        + " "
-        + value.strip()
-    )
-    return yaml.safe_load(yaml_str)
-
-
-def merge_dicts(dict1: dict, dict2: dict) -> dict:
-    """
-    Nested merging of dicts. Will combine nested dicts keeping keys in both with
-    the values in dict2 overriding those in dict1.
-
-    Parameters
-    ----------
-    dict1 : dict
-        Parameters to override
-    dict2 : dict
-        Parameters used to override those in dict1
-
-    Returns
-    -------
-    dict
-        Values from dict1 with overrides from dict2
-    """
-    result = dict1.copy()
-    for key, value in dict2.items():
-        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
-            result[key] = merge_dicts(result[key], value)
-        else:
-            result[key] = value
-    return result
-
-
 def main():
     # Handle the CLI arguments
     parser = argparse.ArgumentParser()
@@ -187,18 +96,7 @@ def main():
         format="%(asctime)s - %(levelname)s - %(message)s",
     )
 
-    # Add specified paths and CWD to sys.path
-    import_paths = [os.getcwd()]
-    import_paths.extend(
-        [os.path.expanduser(os.path.expandvars(x)) for x in args.python_path]
-    )
-    if len(import_paths) > 1:
-        logger.info("Python path additions:")
-    for idx, import_path in enumerate(import_paths):
-        if idx:
-            logger.info(f"  {import_path}")
-        if import_path not in sys.path:
-            sys.path.insert(0, import_path)
+    setup_import_paths([os.getcwd()] + args.python_path)
 
     # Create xopt
     with open(args.config) as f:
@@ -212,14 +110,8 @@ def main():
         if args.override:
             logger.info("Applying config file overrides:")
         for override in args.override:
-            logger.info(f"  {override}")
-            # Sanity check
-            if "=" not in override:
-                raise ValueError(
-                    f'Invalid override format: "{override}". Expected key=value'
-                )
-
             # Merge in the config override
+            logger.info(f"  {override}")
             config = merge_dicts(config, override_to_dict(override))
 
         # Construct Xopt object