spotoptim 3.2.0__tar.gz → 3.3.1__tar.gz

{spotoptim-3.2.0 → spotoptim-3.3.1}/PKG-INFO

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

{spotoptim-3.2.0 → spotoptim-3.3.1}/pyproject.toml

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

{spotoptim-3.2.0 → spotoptim-3.3.1}/src/spotoptim/function/torch_objective.py

@@ -369,6 +369,10 @@ class TorchObjective:
 
         Executes the training loop for the specified number of epochs. Handles optimizer
         creation, loss calculation, backward pass, and validation evaluation.
+        Schedule-free optimizers (those exposing ``train()``/``eval()``, e.g.
+        ``AdamWScheduleFree``) are switched to training mode before each epoch and to
+        evaluation mode before validation, so validation metrics are computed on the
+        averaged parameters; the optimizer is left in evaluation mode on return.
 
         Args:
             model (nn.Module): The PyTorch model to train.
@@ -438,8 +442,17 @@ class TorchObjective:
         # For now, we train for exact 'epochs'
         trained_epochs = epochs
 
+        # Schedule-free optimizers (e.g. AdamWScheduleFree) keep the training
+        # iterate and the averaged parameters separate; they require
+        # optimizer.train()/optimizer.eval() around the respective phases so
+        # that validation sees the averaged weights.
+        optimizer_train = getattr(optimizer, "train", None)
+        optimizer_eval = getattr(optimizer, "eval", None)
+
         for epoch in range(epochs):
             model.train()
+            if callable(optimizer_train):
+                optimizer_train()
             train_loss = 0.0
             steps = 0
             for X_batch, y_batch in train_loader:
@@ -459,6 +472,8 @@ class TorchObjective:
             # Validation
             if val_loader:
                 model.eval()
+                if callable(optimizer_eval):
+                    optimizer_eval()
                 val_loss = 0.0
                 val_steps = 0
                 with torch.no_grad():
@@ -481,6 +496,11 @@ class TorchObjective:
                 if final_train_loss < min_val_loss:
                     min_val_loss = final_train_loss
 
+        # Leave schedule-free optimizers in eval mode so the model holds the
+        # averaged parameters for any downstream use.
+        if callable(optimizer_eval):
+            optimizer_eval()
+
         # Collect metrics
         metrics_out = {}
 

{spotoptim-3.2.0 → spotoptim-3.3.1}/src/spotoptim/nn/linear_regressor.py

@@ -296,8 +296,9 @@ class LinearRegressor(nn.Module):
         Args:
             optimizer_name (str, optional): Name of the optimizer from torch.optim.
                 Common options: "Adam", "AdamW", "Adamax", "SGD", "RMSprop", "Adagrad",
-                "Adadelta", "NAdam", "RAdam", "ASGD", "LBFGS", "Rprop".
-                Defaults to "Adam".
+                "Adadelta", "NAdam", "RAdam", "ASGD", "LBFGS", "Rprop". The vendored
+                schedule-free "AdamWScheduleFree" (spotoptim.optimizer) is also
+                supported. Defaults to "Adam".
             lr (float, optional): Unified learning rate multiplier. If None, uses self.lr.
                 This value is automatically scaled to optimizer-specific learning rates.
                 A value of 1.0 corresponds to the optimizer's default learning rate.
@@ -467,6 +468,16 @@ class LinearRegressor(nn.Module):
             optimizer_class = getattr(optim, optimizer_name)
             # Create optimizer with model parameters, mapped learning rate, and additional kwargs
             return optimizer_class(self.parameters(), lr=lr_actual, **kwargs)
+
+        # Check for custom schedule-free optimizer
+        elif optimizer_name == "AdamWScheduleFree":
+            try:
+                from spotoptim.optimizer import AdamWScheduleFree
+
+                return AdamWScheduleFree(self.parameters(), lr=lr_actual, **kwargs)
+            except ImportError as e:
+                raise ImportError(f"Could not import AdamWScheduleFree: {e}")
+
         else:
             raise ValueError(
                 f"Optimizer '{optimizer_name}' not found in torch.optim. "

{spotoptim-3.2.0 → spotoptim-3.3.1}/src/spotoptim/surrogate/kriging.py

@@ -73,8 +73,17 @@ class Kriging(BaseEstimator, RegressorMixin):
         theta_init_zero (bool, optional): Initialize theta to zero. Defaults to False.
         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.
+        min_Lambda (float, optional): Minimum log10(Lambda) bound; the admissible
+            nugget range is [10**min_Lambda, 10**max_Lambda] regardless of
+            ``lambda_scale``. Defaults to -9.0.
         max_Lambda (float, optional): Maximum log10(Lambda) bound. Defaults to 0.0.
+        lambda_scale (str, optional): Search parametrization of the nugget Lambda
+            within [10**min_Lambda, 10**max_Lambda]. Options:
+            - "log10": the optimizer searches the exponent log10(Lambda)
+              uniformly, emphasizing small nuggets (near-interpolation).
+            - "linear": the optimizer searches Lambda itself uniformly,
+              emphasizing larger nuggets (more smoothing on noisy data).
+            Defaults to "log10".
         metric_factorial (str, optional): Distance metric for factor variables.
             Defaults to ``"hamming"``. Hamming is a true nominal (order-agnostic) metric;
             canberra distance on integer level indices is order-dependent and singles out
@@ -86,7 +95,9 @@ class Kriging(BaseEstimator, RegressorMixin):
         X_ (ndarray): Training data, shape (n_samples, n_features).
         y_ (ndarray): Training targets, shape (n_samples,).
         theta_ (ndarray): Optimized log10(theta) parameters.
-        Lambda_ (float or None): Optimized log10(Lambda) for regression methods.
+        Lambda_ (float or None): Optimized Lambda parameter in the search scale
+            (the log10 exponent for ``lambda_scale="log10"``, the linear value
+            for ``lambda_scale="linear"``) for regression methods.
         mu_ (float): Mean of Kriging predictor.
         sigma2_ (float): Variance of Kriging predictor.
         U_ (ndarray): Cholesky factor of correlation matrix.
@@ -162,6 +173,7 @@ class Kriging(BaseEstimator, RegressorMixin):
         optim_p: bool = False,
         min_Lambda: float = -9.0,
         max_Lambda: float = 0.0,
+        lambda_scale: str = "log10",
         metric_factorial: str = "hamming",
         isotropic: bool = False,
         theta: Optional[np.ndarray] = None,
@@ -183,6 +195,9 @@ class Kriging(BaseEstimator, RegressorMixin):
         self.max_theta = max_theta
         self.min_Lambda = min_Lambda
         self.max_Lambda = max_Lambda
+        if lambda_scale not in ["log10", "linear"]:
+            raise ValueError("lambda_scale must be 'log10' or 'linear'")
+        self.lambda_scale = lambda_scale
         self.n_theta = n_theta
         self.isotropic = isotropic
         self.n_p = n_p
@@ -216,6 +231,18 @@ class Kriging(BaseEstimator, RegressorMixin):
         """Get square root of machine epsilon."""
         return np.sqrt(np.finfo(float).eps)
 
+    def _lambda_bounds(self) -> Tuple[float, float]:
+        """Search bounds of the Lambda parameter in the configured scale."""
+        if self.lambda_scale == "linear":
+            return (10.0**self.min_Lambda, 10.0**self.max_Lambda)
+        return (self.min_Lambda, self.max_Lambda)
+
+    def _lambda_value(self, param: float) -> float:
+        """Nugget value Lambda from its search-scale parameter."""
+        if self.lambda_scale == "linear":
+            return param
+        return 10.0**param
+
     def _set_variable_types(self) -> None:
         """Set variable type masks for different variable types.
 
@@ -298,7 +325,7 @@ class Kriging(BaseEstimator, RegressorMixin):
         bounds = [(self.min_theta, self.max_theta)] * self.n_theta
 
         if self.method in ["regression", "reinterpolation"]:
-            bounds += [(self.min_Lambda, self.max_Lambda)]
+            bounds += [self._lambda_bounds()]
 
         if self.optim_p:
             bounds += [(1.0, 2.0)] * self.n_p
@@ -431,8 +458,7 @@ class Kriging(BaseEstimator, RegressorMixin):
         self.theta_ = params[: self.n_theta]
 
         if self.method in ["regression", "reinterpolation"]:
-            lambda_log = params[self.n_theta : self.n_theta + 1][0]
-            lambda_ = 10.0**lambda_log
+            lambda_ = self._lambda_value(params[self.n_theta : self.n_theta + 1][0])
         else:
             lambda_ = self.noise
 
@@ -536,7 +562,7 @@ class Kriging(BaseEstimator, RegressorMixin):
             >>> y_pred, y_std = k.predict_single(x_new)
         """
         if self.method in ["regression", "reinterpolation"]:
-            lambda_ = 10.0**self.Lambda_
+            lambda_ = self._lambda_value(self.Lambda_)
         else:
             lambda_ = self.noise
 

{spotoptim-3.2.0 → spotoptim-3.3.1}/src/spotoptim/utils/mapping.py

@@ -27,6 +27,8 @@ OPTIMIZER_DEFAULT_LR: Dict[str, float] = {
     "RMSprop": 0.01,
     "Rprop": 0.01,
     "SGD": 0.01,
+    # spotoptim's vendored schedule-free optimizer (spotoptim.optimizer)
+    "AdamWScheduleFree": 0.0025,
 }
 
 
@@ -49,7 +51,9 @@ def map_lr(
             rate, values > 1.0 increase it. Typical range: [0.001, 100.0].
         optimizer_name (str): Name of the PyTorch optimizer. Must be one of:
             "Adadelta", "Adagrad", "Adam", "AdamW", "SparseAdam", "Adamax",
-            "ASGD", "LBFGS", "NAdam", "RAdam", "RMSprop", "Rprop", "SGD".
+            "ASGD", "LBFGS", "NAdam", "RAdam", "RMSprop", "Rprop", "SGD",
+            "AdamWScheduleFree" (spotoptim's vendored schedule-free optimizer,
+            default lr 0.0025).
         use_default_scale (bool, optional): Whether to scale by the optimizer's default
             learning rate. If True (default), lr_unified is multiplied by the default
             lr. If False, returns lr_unified directly. Defaults to True.