spotoptim 2.0.0__tar.gz → 2.1.1__tar.gz

{spotoptim-2.0.0 → spotoptim-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: spotoptim
-Version: 2.0.0
+Version: 2.1.1
 Summary: Sequential Parameter Optimization Toolbox
 Author: bartzbeielstein
 Author-email: bartzbeielstein <32470350+bartzbeielstein@users.noreply.github.com>

{spotoptim-2.0.0 → spotoptim-2.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spotoptim"
-version = "2.0.0"
+version = "2.1.1"
 description = "Sequential Parameter Optimization Toolbox"
 readme = "README.md"
 license = { text = "AGPL-3.0-or-later" }

{spotoptim-2.0.0 → spotoptim-2.1.1}/src/spotoptim/SpotOptim.py

@@ -89,10 +89,6 @@ class SpotOptimConfig:
         acquisition_optimizer_kwargs (Optional[Dict[str, Any]]): Keyword arguments for the acquisition function optimizer.
         args (Tuple): Arguments for the objective function.
         kwargs (Optional[Dict[str, Any]]): Keyword arguments for the objective function.
-        metric_factorial (str): Distance metric used by a factor-aware Kriging surrogate for
-            nominal (categorical) variables.  ``"hamming"`` (default) treats all distinct
-            factor levels as equidistant, which is correct for unordered factors.
-            Any scipy pairwise distance metric string is accepted.
 
 
     Examples:
@@ -193,7 +189,6 @@ class SpotOptimConfig:
     acquisition_optimizer_kwargs: Optional[Dict[str, Any]] = None
     args: Tuple = ()
     kwargs: Optional[Dict[str, Any]] = None
-    metric_factorial: str = "hamming"
 
     def __post_init__(self):
         if self.kwargs is None:
@@ -442,13 +437,6 @@ class SpotOptim(BaseEstimator):
                 * "cosine": Cosine distance.
                 * "correlation": Correlation distance.
                 * "canberra", "braycurtis", "sqeuclidean", etc.
-        metric_factorial (str, optional):
-            Distance metric used for nominal (factor) variables by a factor-aware
-            Kriging surrogate. ``"hamming"`` (default) treats all distinct factor
-            levels as equidistant, which is correct for unordered factors; any
-            scipy pairwise distance metric string is accepted. Only takes effect
-            when factor variables are present and ``surrogate`` is left as ``None``
-            (an order-agnostic Kriging is then built automatically).
 
     Attributes:
         X_ (ndarray): All evaluated points, shape (n_samples, n_features).
@@ -774,7 +762,6 @@ class SpotOptim(BaseEstimator):
         acquisition_optimizer_kwargs: Optional[Dict[str, Any]] = None,
         args: Tuple = (),
         kwargs: Optional[Dict[str, Any]] = None,
-        metric_factorial: str = "hamming",
     ):
         warnings.filterwarnings(warnings_filter)
 
@@ -853,7 +840,6 @@ class SpotOptim(BaseEstimator):
             acquisition_optimizer_kwargs=acquisition_optimizer_kwargs,
             args=args,
             kwargs=kwargs,
-            metric_factorial=metric_factorial,
         )
 
         # Initialize State
@@ -1662,36 +1648,30 @@ class SpotOptim(BaseEstimator):
             self._max_surrogate_points_list = None
             self._active_max_surrogate_points = self.config.max_surrogate_points
 
-            if self._factor_maps:
-                # Factor variables are present: use a nominal (order-agnostic) Kriging
-                # surrogate so the kernel treats factor levels as equidistant.
-                # var_type is already the reduced var_type (after setup_dimension_reduction).
-                self.surrogate = Kriging(
-                    var_type=list(self.var_type),
-                    metric_factorial=self.config.metric_factorial,
-                    seed=self.seed if self.seed is not None else 124,
-                )
-            else:
-                # No factor variables: use the standard GaussianProcessRegressor.
-                kernel = ConstantKernel(1.0, (1e-2, 1e12)) * Matern(
-                    length_scale=1.0, length_scale_bounds=(1e-4, 1e2), nu=2.5
-                )
-
-                # Determine optimizer for GPR
-                optimizer = "fmin_l_bfgs_b"  # Default used by sklearn
-                if self.config.acquisition_optimizer_kwargs is not None:
-                    optimizer = partial(
-                        gpr_minimize_wrapper, **self.config.acquisition_optimizer_kwargs
-                    )
+            # Default surrogate is the GaussianProcessRegressor for ALL problem
+            # types. Factor variables are NOT auto-switched to a Kriging: the user
+            # keeps full control over the surrogate (and is informed by
+            # _validate_factor_surrogate_compat that a factor-aware
+            # Kriging(metric_factorial="hamming") is available for nominal factors).
+            kernel = ConstantKernel(1.0, (1e-2, 1e12)) * Matern(
+                length_scale=1.0, length_scale_bounds=(1e-4, 1e2), nu=2.5
+            )
 
-                self.surrogate = GaussianProcessRegressor(
-                    kernel=kernel,
-                    n_restarts_optimizer=100,
-                    normalize_y=True,
-                    random_state=self.seed,
-                    optimizer=optimizer,
+            # Determine optimizer for GPR
+            optimizer = "fmin_l_bfgs_b"  # Default used by sklearn
+            if self.config.acquisition_optimizer_kwargs is not None:
+                optimizer = partial(
+                    gpr_minimize_wrapper, **self.config.acquisition_optimizer_kwargs
                 )
 
+            self.surrogate = GaussianProcessRegressor(
+                kernel=kernel,
+                n_restarts_optimizer=100,
+                normalize_y=True,
+                random_state=self.seed,
+                optimizer=optimizer,
+            )
+
     def _validate_factor_surrogate_compat(self) -> None:
         """Warn when factor variables are present but the surrogate is factor-blind.
 

{spotoptim-2.0.0 → spotoptim-2.1.1}/src/spotoptim/optimizer/acquisition.py

@@ -117,6 +117,107 @@ def prepare_de_kwargs(optimizer: SpotOptimProtocol, x0=None):
     return filtered_kwargs
 
 
+# Normalized-space margin used to pull a warm-start x0 strictly inside the unit
+# interval that scipy's DifferentialEvolutionSolver validates against. It must
+# exceed the ~1e-16 rounding granularity of that rescaling by several orders of
+# magnitude (robust) while staying negligible in parameter space (faithful).
+_DE_X0_NORM_MARGIN = 1e-12
+
+
+def sanitize_de_x0(
+    x0: np.ndarray, bounds: Optional[List[Tuple[float, float]]]
+) -> Optional[np.ndarray]:
+    """Make a warm-start ``x0`` acceptable to scipy ``differential_evolution``.
+
+    ``DifferentialEvolutionSolver`` does not validate ``x0`` against the raw box
+    ``[lower, upper]``. It rescales every coordinate into a unit interval using
+    ``scaled = (x0 - mid) * recip + 0.5`` with ``mid = (lower + upper) / 2`` and
+    ``recip = 1 / |upper - lower|`` (``0`` when ``lower == upper``), then rejects
+    the whole run if any ``scaled`` falls outside ``[0, 1]``.
+
+    An incumbent that legitimately sits *on* a box bound (optimizers converge to
+    corners; clipped warm-starts and estimator defaults land exactly on a bound)
+    can rescale to a hair outside ``[0, 1]`` purely from floating-point rounding
+    — e.g. ``0.01`` on the bound ``(0.01, 100.0)`` normalizes to ``-1.1e-16``.
+    A raw-space nudge such as ``np.nextafter`` cannot repair this: one ULP at a
+    small bound (``~1.7e-18`` at ``0.01``) is far below the rounding granularity
+    of the rescaling at the span's magnitude, so the nudged value normalizes to
+    the same out-of-range number. The nudge is simply in the wrong metric.
+
+    This helper therefore clamps in scipy's *own* normalized metric and maps the
+    result back with scipy's exact inverse, leaving an already-valid ``x0``
+    untouched (bit-for-bit) and returning ``None`` only if a coordinate cannot be
+    made interior — in which case the caller drops the optional warm-start.
+
+    Args:
+        x0 (ndarray): Candidate warm-start point in internal (transformed) scale,
+            shape ``(n_features,)``.
+        bounds (list of tuple): Per-dimension ``(lower, upper)`` bounds in
+            internal scale, exactly as passed to ``differential_evolution``.
+
+    Returns:
+        Optional[ndarray]: ``x0`` unchanged when scipy already accepts it; a
+        minimally adjusted copy guaranteed to pass scipy's check; or ``None``
+        when no acceptable point exists — ``bounds`` is ``None``, ``x0`` is not
+        all finite, or a coordinate cannot be made interior. ``None`` simply
+        drops the optional warm-start for that infill.
+
+    Examples:
+        ```{python}
+        import numpy as np
+        from spotoptim.optimizer.acquisition import sanitize_de_x0
+
+        # An incumbent exactly on the lower bound of a wide span: the raw value
+        # normalizes just below 0 and scipy would reject it.
+        bounds = [(0.01, 100.0)]
+        x0 = np.array([0.01])
+        fixed = sanitize_de_x0(x0, bounds)
+        lb, ub = 0.01, 100.0
+        mid, span = 0.5 * (lb + ub), abs(ub - lb)
+        scaled = (fixed[0] - mid) / span + 0.5
+        print(f"accepted by scipy: {0.0 <= scaled <= 1.0}")
+        print(f"distance from incumbent: {fixed[0] - 0.01:.2e}")
+        ```
+    """
+    if bounds is None:
+        return None
+    x0 = np.asarray(x0, dtype=float).ravel()
+    # A non-finite incumbent is pathological; never use it as a warm-start.
+    if not np.all(np.isfinite(x0)):
+        return None
+    lower = np.array([b[0] for b in bounds], dtype=float)
+    upper = np.array([b[1] for b in bounds], dtype=float)
+
+    # scipy's exact rescaling constants (see DifferentialEvolutionSolver.__init__
+    # and _unscale_parameters): note span uses |upper - lower|, so reversed
+    # bounds are handled identically to scipy.
+    mid = 0.5 * (lower + upper)
+    span = np.abs(lower - upper)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        recip = np.where(span > 0.0, 1.0 / span, 0.0)
+
+    scaled = (x0 - mid) * recip + 0.5
+
+    # Fast path: scipy already accepts every coordinate -> leave x0 untouched so
+    # currently-working runs stay bit-for-bit identical.
+    if not np.any((scaled < 0.0) | (scaled > 1.0)):
+        return x0
+
+    # Clamp in scipy's normalized metric, then map back with its exact inverse
+    # (_scale_parameters: x = mid + (scaled - 0.5) * span).
+    scaled = np.clip(scaled, _DE_X0_NORM_MARGIN, 1.0 - _DE_X0_NORM_MARGIN)
+    x0_fixed = mid + (scaled - 0.5) * span
+
+    # Defense in depth: re-run scipy's exact check and drop x0 if any residual
+    # rounding still leaves a coordinate outside the unit interval. With finite
+    # x0 and finite bounds this is algebraically unreachable (the margin is far
+    # above the round-trip rounding error); it guards against future drift.
+    check = (x0_fixed - mid) * recip + 0.5
+    if not np.all(np.isfinite(x0_fixed)) or np.any((check < 0.0) | (check > 1.0)):
+        return None
+    return x0_fixed
+
+
 def optimize_acquisition_de(optimizer: SpotOptimProtocol) -> np.ndarray:
     """Optimize using differential evolution.
 
@@ -140,11 +241,17 @@ def optimize_acquisition_de(optimizer: SpotOptimProtocol) -> np.ndarray:
 
     if best_x is not None:
         best_x = optimizer.transform_X(best_x)
-        # Nudge x0 strictly inside DE bounds using nextafter
-        _lb = np.array([b[0] for b in optimizer.bounds])
-        _ub = np.array([b[1] for b in optimizer.bounds])
-        best_x = np.clip(best_x, np.nextafter(_lb, _ub), np.nextafter(_ub, _lb))
-        best_X = best_x if optimizer.rng.rand() < optimizer.de_x0_prob else None
+        # Make x0 acceptable to scipy's differential_evolution, which validates
+        # x0 in a NORMALIZED metric rather than the raw box. An incumbent on a
+        # box bound can otherwise be rejected by floating-point rounding; a
+        # raw-space nudge (np.nextafter) is in the wrong metric and too small to
+        # survive scipy's rescaling when |bound| << span (see sanitize_de_x0).
+        best_x = sanitize_de_x0(best_x, optimizer.bounds)
+        # Draw unconditionally within this branch so the RNG stream is identical
+        # whether or not sanitization succeeds; drop the optional warm-start if
+        # it could not be sanitized.
+        use_x0 = optimizer.rng.rand() < optimizer.de_x0_prob
+        best_X = best_x if (best_x is not None and use_x0) else None
     else:
         best_X = None