spotoptim 2.1.2__tar.gz → 3.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: spotoptim
-Version: 2.1.2
+Version: 3.1.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.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spotoptim"
-version = "2.1.2"
+version = "3.1.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.1.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.1.0}/src/spotoptim/data/__init__.py

@@ -10,11 +10,24 @@ machine learning tasks.
 
 from .base import Config, FileConfig
 
-__all__ = ["DiabetesDataset", "get_diabetes_dataloaders", "Config", "FileConfig"]
+__all__ = [
+    "DiabetesDataset",
+    "get_diabetes_dataloaders",
+    "Config",
+    "FileConfig",
+    "ManyToManyDataset",
+    "ManyToOneDataset",
+    "PadSequenceManyToMany",
+    "PadSequenceManyToOne",
+]
 
 _lazy_map = {
     "DiabetesDataset": ("spotoptim.data.diabetes", "DiabetesDataset"),
     "get_diabetes_dataloaders": ("spotoptim.data.diabetes", "get_diabetes_dataloaders"),
+    "ManyToManyDataset": ("spotoptim.data.manydataset", "ManyToManyDataset"),
+    "ManyToOneDataset": ("spotoptim.data.manydataset", "ManyToOneDataset"),
+    "PadSequenceManyToMany": ("spotoptim.data.manydataset", "PadSequenceManyToMany"),
+    "PadSequenceManyToOne": ("spotoptim.data.manydataset", "PadSequenceManyToOne"),
 }
 
 

spotoptim-3.1.0/src/spotoptim/data/manydataset.py

@@ -0,0 +1,236 @@
+# SPDX-FileCopyrightText: 2026 bartzbeielstein
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Variable-length sequence datasets and padding collates for recurrent models.
+
+Ported from spotPython (``spotpython.data.manydataset`` and the padding
+collates from ``spotpython.data.lightdatamodule``) without any Lightning
+dependency. Each dataset item is one complete sequence (e.g. one operating
+curve of a compressor map), so batches must be padded with the collate
+classes provided here.
+
+Requires the ``torch`` optional extra (``pip install 'spotoptim[torch]'``).
+"""
+
+from typing import List, Optional, Union
+
+import pandas as pd
+import torch
+from torch.nn.utils.rnn import pad_sequence
+from torch.utils.data import Dataset
+
+
+class ManyToManyDataset(Dataset):
+    """Sequence dataset with one target value per time step.
+
+    Each element of ``df_list`` is one variable-length sequence; item ``i``
+    is the pair ``(features_i, targets_i)`` with shapes ``(T_i, n_features)``
+    and ``(T_i,)``.
+
+    Args:
+        df_list (List[pd.DataFrame]): List of pandas DataFrames, one per sequence.
+        target (str): The target column name.
+        drop (Optional[Union[str, List[str]]]): Column(s) to drop from the
+            DataFrames before extracting features. If a listed column is
+            missing, no column is dropped. Defaults to None.
+        dtype (torch.dtype): Data type for the tensors. Defaults to ``torch.float32``.
+
+    Attributes:
+        data (List[pd.DataFrame]): DataFrames with the ``drop`` columns removed.
+        target (List[torch.Tensor]): Per-sequence target tensors, shape ``(T_i,)``.
+        features (List[torch.Tensor]): Per-sequence feature tensors, shape
+            ``(T_i, n_features)``.
+
+    Examples:
+        ```{python}
+        import pandas as pd
+        from spotoptim.data.manydataset import ManyToManyDataset
+
+        df1 = pd.DataFrame({"x": [1.0, 2.0, 3.0], "y": [2.0, 4.0, 6.0]})
+        df2 = pd.DataFrame({"x": [4.0, 5.0], "y": [8.0, 10.0]})
+        ds = ManyToManyDataset([df1, df2], target="y")
+        print(len(ds))
+        features, targets = ds[0]
+        print(features.shape, targets.shape)
+        ```
+    """
+
+    def __init__(
+        self,
+        df_list: List[pd.DataFrame],
+        target: str,
+        drop: Optional[Union[str, List[str]]] = None,
+        dtype: torch.dtype = torch.float32,
+    ):
+        if drop is None:
+            self.data = list(df_list)
+        else:
+            try:
+                self.data = [df.drop(drop, axis=1) for df in df_list]
+            except KeyError:
+                self.data = df_list
+        self.target = [
+            torch.tensor(df[target].to_numpy(), dtype=dtype) for df in self.data
+        ]
+        self.features = [
+            torch.tensor(df.drop([target], axis=1).to_numpy(), dtype=dtype)
+            for df in self.data
+        ]
+
+    def __getitem__(self, index: int):
+        """Return the ``(features, targets)`` pair of sequence ``index``."""
+        x = self.features[index]
+        y = self.target[index]
+        return x, y
+
+    def __len__(self) -> int:
+        """Return the number of sequences."""
+        return len(self.data)
+
+
+class ManyToOneDataset(Dataset):
+    """Sequence dataset with a single target value per sequence.
+
+    Like `ManyToManyDataset`, but item ``i`` pairs the full feature sequence
+    with the scalar target taken from the first row of sequence ``i``.
+
+    Args:
+        df_list (List[pd.DataFrame]): List of pandas DataFrames, one per sequence.
+        target (str): The target column name.
+        drop (Optional[Union[str, List[str]]]): Column(s) to drop from the
+            DataFrames before extracting features. If a listed column is
+            missing, no column is dropped. Defaults to None.
+        dtype (torch.dtype): Data type for the tensors. Defaults to ``torch.float32``.
+
+    Attributes:
+        data (List[pd.DataFrame]): DataFrames with the ``drop`` columns removed.
+        target (List[torch.Tensor]): Per-sequence scalar target tensors.
+        features (List[torch.Tensor]): Per-sequence feature tensors, shape
+            ``(T_i, n_features)``.
+
+    Examples:
+        ```{python}
+        import pandas as pd
+        from spotoptim.data.manydataset import ManyToOneDataset
+
+        df1 = pd.DataFrame({"x": [1.0, 2.0, 3.0], "y": [5.0, 5.0, 5.0]})
+        df2 = pd.DataFrame({"x": [4.0, 5.0], "y": [7.0, 7.0]})
+        ds = ManyToOneDataset([df1, df2], target="y")
+        features, target = ds[1]
+        print(features.shape, target)
+        ```
+    """
+
+    def __init__(
+        self,
+        df_list: List[pd.DataFrame],
+        target: str,
+        drop: Optional[Union[str, List[str]]] = None,
+        dtype: torch.dtype = torch.float32,
+    ):
+        if drop is None:
+            self.data = list(df_list)
+        else:
+            try:
+                self.data = [df.drop(drop, axis=1) for df in df_list]
+            except KeyError:
+                self.data = df_list
+        self.target = [
+            torch.tensor(df[target].to_numpy()[0], dtype=dtype) for df in self.data
+        ]
+        self.features = [
+            torch.tensor(df.drop([target], axis=1).to_numpy(), dtype=dtype)
+            for df in self.data
+        ]
+
+    def __getitem__(self, index: int):
+        """Return the ``(features, target)`` pair of sequence ``index``."""
+        x = self.features[index]
+        y = self.target[index]
+        return x, y
+
+    def __len__(self) -> int:
+        """Return the number of sequences."""
+        return len(self.data)
+
+
+class PadSequenceManyToMany:
+    """Padding collate for `ManyToManyDataset` batches.
+
+    Pads features and targets of a batch of variable-length sequences with
+    zeros to the longest sequence in the batch and records the true lengths,
+    as required by ``torch.nn.utils.rnn.pack_padded_sequence``.
+
+    Examples:
+        ```{python}
+        import pandas as pd
+        from torch.utils.data import DataLoader
+        from spotoptim.data.manydataset import ManyToManyDataset, PadSequenceManyToMany
+
+        df1 = pd.DataFrame({"x": [1.0, 2.0, 3.0], "y": [2.0, 4.0, 6.0]})
+        df2 = pd.DataFrame({"x": [4.0, 5.0], "y": [8.0, 10.0]})
+        ds = ManyToManyDataset([df1, df2], target="y")
+        dl = DataLoader(ds, batch_size=2, shuffle=False, collate_fn=PadSequenceManyToMany())
+        x, lengths, y = next(iter(dl))
+        print(x.shape, lengths.tolist(), y.shape)
+        ```
+    """
+
+    def __call__(self, batch):
+        """Collate a batch into ``(padded_x, lengths, padded_y)``.
+
+        Args:
+            batch: Sequence of ``(features, targets)`` pairs as produced by
+                `ManyToManyDataset`.
+
+        Returns:
+            tuple: ``(padded_x, lengths, padded_y)`` where ``padded_x`` has
+                shape ``(B, T_max, n_features)``, ``lengths`` is an int tensor of
+                shape ``(B,)``, and ``padded_y`` has shape ``(B, T_max)``.
+        """
+        batch_x, batch_y = zip(*batch)
+        padded_batch_x = pad_sequence(list(batch_x), batch_first=True)
+        padded_batch_y = pad_sequence(list(batch_y), batch_first=True)
+        lengths = torch.tensor([len(x) for x in batch_x])
+
+        return padded_batch_x, lengths, padded_batch_y
+
+
+class PadSequenceManyToOne:
+    """Padding collate for `ManyToOneDataset` batches.
+
+    Pads the feature sequences with zeros and stacks the scalar targets.
+
+    Examples:
+        ```{python}
+        import pandas as pd
+        from torch.utils.data import DataLoader
+        from spotoptim.data.manydataset import ManyToOneDataset, PadSequenceManyToOne
+
+        df1 = pd.DataFrame({"x": [1.0, 2.0, 3.0], "y": [5.0, 5.0, 5.0]})
+        df2 = pd.DataFrame({"x": [4.0, 5.0], "y": [7.0, 7.0]})
+        ds = ManyToOneDataset([df1, df2], target="y")
+        dl = DataLoader(ds, batch_size=2, shuffle=False, collate_fn=PadSequenceManyToOne())
+        x, lengths, y = next(iter(dl))
+        print(x.shape, lengths.tolist(), y.shape)
+        ```
+    """
+
+    def __call__(self, batch):
+        """Collate a batch into ``(padded_x, lengths, y)``.
+
+        Args:
+            batch: Sequence of ``(features, target)`` pairs as produced by
+                `ManyToOneDataset`.
+
+        Returns:
+            tuple: ``(padded_x, lengths, y)`` where ``padded_x`` has shape
+                ``(B, T_max, n_features)``, ``lengths`` is an int tensor of shape
+                ``(B,)``, and ``y`` is a tensor of shape ``(B,)``.
+        """
+        batch_x, batch_y = zip(*batch)
+        padded_batch_x = pad_sequence(list(batch_x), batch_first=True)
+        lengths = torch.tensor([len(x) for x in batch_x])
+
+        return padded_batch_x, lengths, torch.tensor(batch_y)

{spotoptim-2.1.2 → spotoptim-3.1.0}/src/spotoptim/function/__init__.py

@@ -69,11 +69,16 @@ __all__ = [
     "branin",
     "onevar",
     "TorchObjective",
+    "SequenceCVObjective",
     "objective_remote",
 ]
 
 _lazy_map = {
     "TorchObjective": ("spotoptim.function.torch_objective", "TorchObjective"),
+    "SequenceCVObjective": (
+        "spotoptim.function.sequence_cv_objective",
+        "SequenceCVObjective",
+    ),
     "objective_remote": ("spotoptim.function.remote", "objective_remote"),
 }