spotoptim 2.1.2__tar.gz → 3.0.0__tar.gz

{spotoptim-2.1.2 → spotoptim-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: spotoptim
-Version: 2.1.2
+Version: 3.0.0
 Summary: Sequential Parameter Optimization Toolbox
 Author: bartzbeielstein
 Author-email: bartzbeielstein <32470350+bartzbeielstein@users.noreply.github.com>
@@ -22,7 +22,6 @@ Requires-Dist: pytest-timeout>=2.3.0 ; extra == 'dev'
 Requires-Dist: black>=24.1.0 ; extra == 'dev'
 Requires-Dist: isort>=5.13.0 ; extra == 'dev'
 Requires-Dist: ruff>=0.3.0 ; extra == 'dev'
-Requires-Dist: safety>=3.0.0 ; extra == 'dev'
 Requires-Dist: bandit>=1.8.0 ; extra == 'dev'
 Requires-Dist: pre-commit>=3.7.0 ; extra == 'dev'
 Requires-Dist: ty>=0.0.29 ; extra == 'dev'

{spotoptim-2.1.2 → spotoptim-3.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spotoptim"
-version = "2.1.2"
+version = "3.0.0"
 description = "Sequential Parameter Optimization Toolbox"
 readme = "README.md"
 license = { text = "AGPL-3.0-or-later" }
@@ -35,7 +35,6 @@ dev = [
     "black>=24.1.0",
     "isort>=5.13.0",
     "ruff>=0.3.0",
-    "safety>=3.0.0",
     "bandit>=1.8.0",
     "pre-commit>=3.7.0",
     "ty>=0.0.29",
@@ -67,7 +66,6 @@ dev = [
     "black>=24.1.0",
     "isort>=5.13.0",
     "ruff>=0.3.0",
-    "safety>=3.0.0",
     "bandit>=1.8.0",
     "pre-commit>=3.7.0",
     "ty>=0.0.29",

{spotoptim-2.1.2 → spotoptim-3.0.0}/src/spotoptim/SpotOptim.py

@@ -278,7 +278,13 @@ class SpotOptim(BaseEstimator):
             For example, max_iter=30 with n_initial=10 will perform 10 initial evaluations plus
             20 sequential optimization iterations. Defaults to 20.
         n_initial (int, optional):
-            Number of initial design points. Defaults to 10.
+            Number of initial design points. Defaults to 10. A ``UserWarning`` is
+            raised when ``n_initial < 2 * n_dim``: a cold-start design that small
+            tends to under-sample the search space and gives the surrogate too
+            little signal to model dimension interactions. The warning is
+            guidance only (existing scripts with a deliberately small
+            ``n_initial`` keep working unchanged); consider
+            ``n_initial=max(10, 2 * n_dim)`` for cold starts.
         surrogate (object, optional):
             Surrogate model with scikit-learn interface (fit/predict methods).
             If None, uses a Gaussian Process Regressor with Matern kernel. Default configuration::
@@ -874,6 +880,26 @@ class SpotOptim(BaseEstimator):
         # Derived attribute dimension n_dim
         self.n_dim = len(self.bounds)
 
+        # Guidance for cold-start designs (ADR 2026-07-05, decision 4): a
+        # design with n_initial < 2*n_dim tends to under-sample the search
+        # space, giving the surrogate too little signal to model dimension
+        # interactions. Warning-only — existing small-budget scripts keep
+        # working unchanged. Nested catch_warnings + "always" mirrors
+        # _validate_factor_surrogate_compat: makes the warning visible even
+        # under the default warnings_filter="ignore".
+        if self.n_initial < 2 * self.n_dim:
+            with warnings.catch_warnings():
+                warnings.simplefilter("always")
+                warnings.warn(
+                    f"n_initial ({self.n_initial}) is below 2 * n_dim "
+                    f"({2 * self.n_dim}) for a {self.n_dim}-dimensional problem. "
+                    f"Cold-start designs this small may under-sample the search "
+                    f"space; consider n_initial=max(10, 2 * n_dim) = "
+                    f"{max(10, 2 * self.n_dim)}.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+
         # Default variable types
         if self.var_type is None:
             self.var_type = self.detect_var_type()
@@ -2503,6 +2529,8 @@ class SpotOptim(BaseEstimator):
                 * message: termination message indicating reason for stopping, including statistics (function value, iterations, evaluations)
                 * X: all evaluated points in Natural Space
                 * y: all function values
+                * x_encoded: best point in full-dimension natural-NUMERIC encoding (factor dimensions as integer level indices) — the representation restart injection and ``validate_x0`` consume
+                * X_encoded: all evaluated points in the same numeric encoding (numeric dtype even when factor dimensions map to string labels in ``X``)
 
         Examples:
             ```{python}
@@ -2615,9 +2643,16 @@ class SpotOptim(BaseEstimator):
 
                     if self.restart_inject_best:
                         # Inject the current global best into the next run's initial design.
-                        # best_res.x is in natural scale; validate_x0 converts to internal scale
-                        # so the injected point can be mixed with LHS samples.
-                        self.x0 = self.validate_x0(best_res.x)
+                        # Use the pre-string-map numeric encoding (x_encoded) when available:
+                        # best_res.x has factor dims mapped to string labels, which
+                        # validate_x0's `low <= val <= high` bounds check cannot compare
+                        # (UFuncTypeError). x_encoded carries the same full-dim natural-scale
+                        # point with factor dims still as integer codes.
+                        # validate_x0 converts to internal scale so the injected point can be
+                        # mixed with LHS samples.
+                        self.x0 = self.validate_x0(
+                            getattr(best_res, "x_encoded", best_res.x)
+                        )
                         # Keep current_X0 unset so the initial design is rebuilt around the injected x0.
                         current_X0 = None
 
@@ -2641,8 +2676,13 @@ class SpotOptim(BaseEstimator):
         # Find best result based on 'fun'
         best_result = min(self.restarts_results_, key=lambda r: r.fun)
 
-        # Merge results from all restart runs
-        X_all_list = [res.X for res in self.restarts_results_]
+        # Merge results from all restart runs. Use the numeric encoding
+        # (X_encoded) rather than the string-mapped X: on a factor problem the
+        # latter has object dtype, which would leave self.X_ non-numeric after
+        # a restart and break the post-restart surrogate fit.
+        X_all_list = [
+            getattr(res, "X_encoded", res.X) for res in self.restarts_results_
+        ]
         y_all_list = [res.y for res in self.restarts_results_]
 
         # Concatenate all evaluations
@@ -2653,8 +2693,9 @@ class SpotOptim(BaseEstimator):
         # Aggregated iterations (sum of all runs)
         self.n_iter_ = sum(getattr(res, "nit", 0) for res in self.restarts_results_)
 
-        # Update best solution found
-        self.best_x_ = best_result.x
+        # Update best solution found. Same numeric-encoding rationale as X_
+        # above, for cross-path (x0 injection vs. best_x_) consistency.
+        self.best_x_ = getattr(best_result, "x_encoded", best_result.x)
         self.best_y_ = best_result.fun
 
         # If the patience-based early-stopping rule fired, rewrite the result
@@ -3563,6 +3604,14 @@ class SpotOptim(BaseEstimator):
                     message=status_message,
                     X=X_result,
                     y=self.y_,
+                    # Pre-string-map numeric form of x/X (full-dim, natural
+                    # scale, with factor dims as integer codes rather than
+                    # string labels). optimize()'s restart-inject path and the
+                    # cross-restart X_ merge use these instead of x/X, so a
+                    # factor problem's restart never feeds a string into
+                    # validate_x0()/the surrogate (UFuncTypeError).
+                    x_encoded=best_x_full,
+                    X_encoded=X_full,
                 )
                 return "RESTART", res
 
@@ -3621,6 +3670,10 @@ class SpotOptim(BaseEstimator):
             message=message,
             X=X_result,
             y=self.y_,
+            # See the RESTART branch above: pre-string-map numeric x/X, used
+            # by optimize()'s restart-inject path and cross-restart X_ merge.
+            x_encoded=best_x_full,
+            X_encoded=X_full,
         )
 
     def determine_termination(self, timeout_start: float) -> str:

{spotoptim-2.1.2 → spotoptim-3.0.0}/src/spotoptim/optimizer/acquisition.py

@@ -6,6 +6,8 @@
 
 from __future__ import annotations
 
+import warnings
+
 from typing import TYPE_CHECKING, List, Optional, Tuple
 
 import numpy as np
@@ -43,8 +45,17 @@ def optimize_acquisition_tricands(optimizer: SpotOptimProtocol) -> np.ndarray:
     # Generate candidates
     nmax = max(100 * optimizer.n_dim, optimizer.acquisition_fun_return_size * 50)
 
-    # Normalize X_ to [0, 1] relative to bounds
-    X_norm = (optimizer.X_ - optimizer.lower) / (optimizer.upper - optimizer.lower)
+    # optimizer.lower/upper are TRANSFORMED-scale bounds, so X_ (natural scale)
+    # must be transformed first before normalizing against them — otherwise any
+    # log10/sqrt/... dim lands far outside [0, 1] and tricands() raises "X
+    # outside of lower/upper bounds" (mirrors try_optimizer_candidates, which
+    # already calls optimizer.transform_X before comparing against bounds).
+    X_internal = optimizer.transform_X(optimizer.X_)
+    span = optimizer.upper - optimizer.lower
+
+    # Normalize to [0, 1] relative to the transformed bounds, clipping away any
+    # residual floating-point overshoot at the box edges.
+    X_norm = np.clip((X_internal - optimizer.lower) / span, 0.0, 1.0)
 
     # Generate candidates in [0, 1] space
     X_cands_norm = tricands(
@@ -55,8 +66,10 @@ def optimize_acquisition_tricands(optimizer: SpotOptimProtocol) -> np.ndarray:
         fringe=optimizer.tricands_fringe,
     )
 
-    # Denormalize candidates back to original space
-    X_cands = X_cands_norm * (optimizer.upper - optimizer.lower) + optimizer.lower
+    # Denormalize candidates back to transformed space, clipping into bounds.
+    X_cands = np.clip(
+        X_cands_norm * span + optimizer.lower, optimizer.lower, optimizer.upper
+    )
 
     # Evaluate acquisition function on all candidates
     acq_values = optimizer._acquisition_function(X_cands.T)
@@ -374,7 +387,22 @@ def try_optimizer_candidates(
     if current_batch is None:
         current_batch = []
 
-    x_next_candidates = optimizer.optimize_acquisition_func()
+    try:
+        x_next_candidates = optimizer.optimize_acquisition_func()
+    except Exception as err:
+        # Any acquisition-optimizer failure (e.g. an out-of-bounds tricands
+        # candidate on a mixed-scale problem, or a restart-injected factor
+        # string reaching a numeric optimizer) degrades to an empty candidate
+        # set here, so suggest_next_infill_point() falls through to the
+        # existing acquisition_failure_strategy fallback instead of aborting
+        # optimize() entirely.
+        warnings.warn(
+            f"Acquisition optimizer failed ({err}); falling back to the "
+            f"{optimizer.acquisition_failure_strategy!r} infill strategy.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        return []
 
     # Ensure iterable of 1D arrays
     if x_next_candidates.ndim == 1:

{spotoptim-2.1.2 → spotoptim-3.0.0}/src/spotoptim/surrogate/kernels.py

@@ -75,7 +75,6 @@ class SpotOptimKernel(Kernel):
             Note: In standard Kriging usage, this corresponds to `10^theta_log`.
             This kernel expects the LINEAR scale theta values (weights), not log.
         var_type (list of str): List of variable types, e.g. ['float', 'int', 'factor'].
-        p_val (float, optional): Power parameter for ordered distance. Defaults to 2.0.
         metric_factorial (str, optional): Metric for factor distance (passed to cdist/pdist).
             Defaults to 'hamming'. Hamming is a true nominal (order-agnostic) metric;
             canberra distance on integer level indices is order-dependent and singles out
@@ -86,12 +85,10 @@ class SpotOptimKernel(Kernel):
         self,
         theta,
         var_type,
-        p_val=2.0,
         metric_factorial="hamming",
     ):
         self.theta = np.asanyarray(theta)
         self.var_type = var_type
-        self.p_val = p_val
         self.metric_factorial = metric_factorial
 
         # Precompute masks
@@ -166,21 +163,9 @@ class SpotOptimKernel(Kernel):
                 )
             D += D_factor
 
-        # Final exponential (Gaussian correlation)
-        # Note: Kriging's Psi = exp(-D)
-        if self.p_val != 2.0:
-            # If p != 2, the 'sqeuclidean' above was mathematically sum w * (diff^2).
-            # If we strictly want sum w * |diff|^p, we can't use 'sqeuclidean' directly if p != 2.
-            # But standard implementation often assumes p=2 for efficiency.
-            # Kriging code shows:
-            #    pdist(..., metric="sqeuclidean", ...)
-            #    Psi = np.exp(-Psi)
-            # This implies p=2 is hardcoded effectively in 'sqeuclidean' metric usage in Kriging code provided earlier.
-            # The parameter p_val seems unused in the `build_correlation_matrix` snippet I read earlier
-            # (which used `sqeuclidean`).
-            # I will stick to what the code did: sqeuclidean -> exp(-D).
-            pass
-
+        # Final exponential (Gaussian correlation). The Gaussian correlation
+        # power is fixed at 2: D_ordered is computed via the 'sqeuclidean'
+        # metric above (sum w * diff^2), so Psi = exp(-D) is exact.
         return np.exp(-D)
 
     def diag(self, X):

{spotoptim-2.1.2 → spotoptim-3.0.0}/src/spotoptim/surrogate/kriging.py

@@ -71,8 +71,6 @@ class Kriging(BaseEstimator, RegressorMixin):
         min_theta (float, optional): Minimum log10(theta) bound. Defaults to -3.0.
         max_theta (float, optional): Maximum log10(theta) bound. Defaults to 2.0.
         theta_init_zero (bool, optional): Initialize theta to zero. Defaults to False.
-        p_val (float, optional): Power parameter for correlation (fixed at 2.0 for Gaussian).
-            Defaults to 2.0.
         n_p (int, optional): Number of p parameters (currently not optimized). Defaults to 1.
         optim_p (bool, optional): Optimize p parameters (currently not supported). Defaults to False.
         min_Lambda (float, optional): Minimum log10(Lambda) bound. Defaults to -9.0.
@@ -160,7 +158,6 @@ class Kriging(BaseEstimator, RegressorMixin):
         min_theta: float = -3.0,
         max_theta: float = 2.0,
         theta_init_zero: bool = False,
-        p_val: float = 2.0,
         n_p: int = 1,
         optim_p: bool = False,
         min_Lambda: float = -9.0,
@@ -188,7 +185,6 @@ class Kriging(BaseEstimator, RegressorMixin):
         self.max_Lambda = max_Lambda
         self.n_theta = n_theta
         self.isotropic = isotropic
-        self.p_val = p_val
         self.n_p = n_p
         self.optim_p = optim_p
         self.theta_init_zero = theta_init_zero
@@ -393,7 +389,6 @@ class Kriging(BaseEstimator, RegressorMixin):
             kernel = SpotOptimKernel(
                 theta=theta10,
                 var_type=self.var_type,
-                p_val=self.p_val,
                 metric_factorial=self.metric_factorial,
             )
 
@@ -506,7 +501,6 @@ class Kriging(BaseEstimator, RegressorMixin):
         kernel = SpotOptimKernel(
             theta=theta10,
             var_type=self.var_type,
-            p_val=self.p_val,
             metric_factorial=self.metric_factorial,
         )
 
@@ -614,7 +608,6 @@ class Kriging(BaseEstimator, RegressorMixin):
             "min_theta": self.min_theta,
             "max_theta": self.max_theta,
             "theta_init_zero": self.theta_init_zero,
-            "p_val": self.p_val,
             "n_p": self.n_p,
             "optim_p": self.optim_p,
             "min_Lambda": self.min_Lambda,

{spotoptim-2.1.2 → spotoptim-3.0.0}/src/spotoptim/utils/transform.py

@@ -114,7 +114,8 @@ def inverse_transform_value(x: float, trans: Optional[str]) -> float:
     elif trans == "square":
         return np.sqrt(x)
     elif trans == "cube":
-        return np.power(x, 1.0 / 3.0)
+        # np.cbrt handles negative inputs; np.power(x, 1/3) returns NaN there.
+        return np.cbrt(x)
     elif trans == "inv" or trans == "reciprocal":
         return 1.0 / x