spotoptim 3.0.0__tar.gz → 3.1.0__tar.gz

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

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

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

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

{spotoptim-3.0.0 → 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-3.0.0 → 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"),
 }
 

spotoptim-3.1.0/src/spotoptim/function/sequence_cv_objective.py

@@ -0,0 +1,278 @@
+# SPDX-FileCopyrightText: 2026 bartzbeielstein
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Leave-one-sequence-out cross-validation objective for sequence regression.
+
+Ported from the training path used by ``spotpython.fun.hyperlight.HyperLight``
+with ``fun_control["hacky"]=True`` (``spotpython.light.trainmodel``), without
+Lightning: for every sequence of a `spotoptim.data.manydataset.ManyToManyDataset`,
+a fresh model is trained on all remaining sequences for the full number of
+epochs and evaluated on the held-out sequence; the objective value is the mean
+of the held-out losses. As in spotPython, training runs the complete epoch
+budget (the ``patience`` hyperparameter is accepted but has no effect, because
+the reference implementation never attached a validation loader during
+fitting) and the loss is computed on zero-padded batches without masking.
+
+Requires the ``torch`` optional extra (``pip install 'spotoptim[torch]'``).
+"""
+
+import logging
+from typing import Any, Callable, Dict, Optional
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.optim.lr_scheduler import MultiStepLR
+from torch.utils.data import DataLoader, Subset
+
+from spotoptim.core.experiment import ExperimentControl
+from spotoptim.function.torch_objective import TorchObjective
+from spotoptim.nn.optimizer import optimizer_handler
+
+logger = logging.getLogger(__name__)
+
+
+class SequenceCVObjective(TorchObjective):
+    """Callable SpotOptim objective running leave-one-sequence-out CV.
+
+    The experiment's dataset must be a
+    `spotoptim.core.data.SpotDataFromTorchDataset` whose training dataset
+    yields variable-length ``(features, targets)`` sequence pairs (e.g. a
+    `spotoptim.data.manydataset.ManyToManyDataset`). For each hyperparameter
+    configuration, every sequence is held out once: a fresh model is trained
+    on the remaining sequences and scored on the held-out one, and the mean
+    held-out loss is returned. A configuration whose training fails (e.g. an
+    optimizer incompatible with dense gradients) evaluates to ``np.nan``, to
+    be repaired by SpotOptim's ``penalty`` handling.
+
+    The tuned hyperparameters follow the spotPython ``ManyToManyRNNRegressor``
+    convention: ``epochs``, ``batch_size``, ``optimizer``, and ``lr_mult``
+    drive training via `spotoptim.nn.optimizer.optimizer_handler` and a
+    ``MultiStepLR`` schedule (three milestones at 1/4, 2/4, and 3/4 of the
+    epoch budget, decay factor 0.1); all remaining parameters are passed to
+    the model constructor.
+
+    Args:
+        experiment (ExperimentControl): Experiment configuration; its
+            ``dataset`` wraps the sequence dataset and its ``model_class`` is
+            instantiated once per fold.
+        seed (Optional[int]): Random seed applied before each configuration
+            evaluation. Falls back to ``experiment.seed`` when None.
+            Defaults to None.
+        collate_fn (Optional[Callable]): Batch collate producing
+            ``(padded_x, lengths, padded_y)``. Defaults to
+            `spotoptim.data.manydataset.PadSequenceManyToMany`.
+        param_mappers (Optional[Dict[str, Callable]]): Per-parameter functions
+            applied to the decoded hyperparameter values before training,
+            e.g. ``{"epochs": lambda v: 2 ** int(v)}`` to reproduce
+            spotPython's ``transform_power_2_int``. Defaults to None.
+
+    Examples:
+        ```{python}
+        import numpy as np
+        import pandas as pd
+        from spotoptim.core.data import SpotDataFromTorchDataset
+        from spotoptim.core.experiment import ExperimentControl
+        from spotoptim.data.manydataset import ManyToManyDataset
+        from spotoptim.function.sequence_cv_objective import SequenceCVObjective
+        from spotoptim.hyperparameters import ParameterSet
+        from spotoptim.nn.many_to_many_rnn import ManyToManyRNNRegressor
+
+        rng = np.random.default_rng(0)
+        frames = [
+            pd.DataFrame({"x": rng.random(4), "y": rng.random(4)})
+            for _ in range(3)
+        ]
+        ds = ManyToManyDataset(frames, target="y")
+        params = ParameterSet()
+        params.add_int("epochs", 1, 2)
+        params.add_float("lr_mult", 0.1, 1.0)
+        exp = ExperimentControl(
+            dataset=SpotDataFromTorchDataset(ds, input_dim=1, output_dim=1),
+            model_class=ManyToManyRNNRegressor,
+            hyperparameters=params,
+            seed=42,
+        )
+        objective = SequenceCVObjective(exp)
+        y = objective(np.array([[2, 1.0]]))
+        print(y.shape)
+        ```
+    """
+
+    def __init__(
+        self,
+        experiment: ExperimentControl,
+        seed: Optional[int] = None,
+        collate_fn: Optional[Callable] = None,
+        param_mappers: Optional[Dict[str, Callable]] = None,
+    ):
+        super().__init__(experiment=experiment, seed=seed)
+        if collate_fn is None:
+            from spotoptim.data.manydataset import PadSequenceManyToMany
+
+            collate_fn = PadSequenceManyToMany()
+        self.collate_fn = collate_fn
+        self.param_mappers = param_mappers or {}
+
+    def decode_params(self, X_row: np.ndarray) -> Dict[str, Any]:
+        """Decode one parameter vector and apply the configured mappers.
+
+        Args:
+            X_row (np.ndarray): One row of the optimizer's input array, in
+                natural scale with factor levels as strings.
+
+        Returns:
+            Dict[str, Any]: Hyperparameter dictionary ready for training.
+        """
+        params = self._get_hyperparameters(X_row)
+        for name, mapper in self.param_mappers.items():
+            if name in params:
+                params[name] = mapper(params[name])
+        return params
+
+    def _build_model(self, params: Dict[str, Any]) -> nn.Module:
+        """Instantiate a fresh model for one fold.
+
+        Args:
+            params (Dict[str, Any]): Decoded hyperparameters.
+
+        Returns:
+            nn.Module: The model instance.
+        """
+        dataset = self.experiment.dataset
+        model_kwargs = {
+            "input_dim": dataset.input_dim,
+            "output_dim": dataset.output_dim,
+        }
+        model_kwargs.update(params)
+        return self.experiment.model_class(**model_kwargs)
+
+    def _train_fold(
+        self, model: nn.Module, train_loader: DataLoader, params: Dict[str, Any]
+    ) -> None:
+        """Train one fold for the full epoch budget.
+
+        Replicates the spotPython reference: one optimizer step per batch, one
+        ``MultiStepLR`` scheduler step per epoch, and the loss computed on the
+        zero-padded targets reshaped to the prediction shape.
+
+        Args:
+            model (nn.Module): The model to train (modified in place).
+            train_loader (DataLoader): Loader over the training sequences.
+            params (Dict[str, Any]): Decoded hyperparameters; consumes
+                ``epochs``, ``optimizer``, and ``lr_mult``.
+        """
+        epochs = int(params.get("epochs", self.experiment.epochs or 100))
+        optimizer = optimizer_handler(
+            optimizer_name=str(params.get("optimizer", "SGD")),
+            params=model.parameters(),
+            lr_mult=float(params.get("lr_mult", 1.0)),
+        )
+        num_milestones = 3
+        milestones = [
+            int(epochs / (num_milestones + 1) * (i + 1)) for i in range(num_milestones)
+        ]
+        scheduler = MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
+        criterion = self.experiment.loss_function or nn.MSELoss()
+
+        model.to(self.device)
+        model.train()
+        for _ in range(epochs):
+            for x, lengths, y in train_loader:
+                x, y = x.to(self.device), y.to(self.device)
+                optimizer.zero_grad()
+                y_hat = model(x, lengths)
+                loss = criterion(y_hat, y.view_as(y_hat))
+                loss.backward()
+                optimizer.step()
+            scheduler.step()
+
+    def _validate_fold(self, model: nn.Module, val_loader: DataLoader) -> float:
+        """Compute the mean loss of one fold's held-out data.
+
+        Args:
+            model (nn.Module): The trained model.
+            val_loader (DataLoader): Loader over the held-out sequence(s).
+
+        Returns:
+            float: Mean loss over the loader's batches.
+        """
+        criterion = self.experiment.loss_function or nn.MSELoss()
+        model.eval()
+        losses = []
+        with torch.no_grad():
+            for x, lengths, y in val_loader:
+                x, y = x.to(self.device), y.to(self.device)
+                y_hat = model(x, lengths)
+                losses.append(criterion(y_hat, y.view_as(y_hat)).item())
+        return float(np.mean(losses))
+
+    def _evaluate_config(self, params: Dict[str, Any]) -> float:
+        """Run the full leave-one-sequence-out CV for one configuration.
+
+        Args:
+            params (Dict[str, Any]): Decoded hyperparameters.
+
+        Returns:
+            float: Mean held-out loss across all folds.
+        """
+        dataset = self.experiment.dataset.get_train_data()
+        batch_size = int(params.get("batch_size", self.experiment.batch_size))
+        indices = list(range(len(dataset)))
+        fold_losses = []
+        for i in indices:
+            train_indices = [j for j in indices if j != i]
+            train_loader = DataLoader(
+                Subset(dataset, train_indices),
+                batch_size=batch_size,
+                shuffle=False,
+                collate_fn=self.collate_fn,
+                num_workers=self.experiment.num_workers,
+            )
+            val_loader = DataLoader(
+                Subset(dataset, [i]),
+                batch_size=batch_size,
+                shuffle=False,
+                collate_fn=self.collate_fn,
+                num_workers=self.experiment.num_workers,
+            )
+            model = self._build_model(params)
+            self._train_fold(model, train_loader, params)
+            fold_loss = self._validate_fold(model, val_loader)
+            fold_losses.append(fold_loss)
+            if self.experiment.verbosity > 0:
+                print(f"SequenceCVObjective: fold {i} val_loss: {fold_loss}")
+        return float(np.mean(fold_losses))
+
+    def __call__(self, X: np.ndarray) -> np.ndarray:
+        """Evaluate the objective for an array of configurations.
+
+        Args:
+            X (np.ndarray): Input array of shape ``(n_samples, n_params)`` or
+                ``(n_params,)``, in natural scale with factor levels as strings.
+
+        Returns:
+            np.ndarray: Array of shape ``(n_samples, 1)`` with the mean
+                held-out loss per configuration; ``np.nan`` where the
+                evaluation failed.
+        """
+        X = np.atleast_2d(X)
+        results = []
+        for i in range(X.shape[0]):
+            if self.seed is not None:
+                self._set_seed(self.seed)
+            params = self.decode_params(X[i])
+            if self.experiment.verbosity > 0:
+                print(f"SequenceCVObjective: config: {params}")
+            try:
+                value = self._evaluate_config(params)
+            except Exception as err:
+                logger.error(
+                    "SequenceCVObjective: evaluation failed (%s: %s); returning nan",
+                    type(err).__name__,
+                    err,
+                )
+                value = float("nan")
+            results.append([value])
+        return np.array(results)

{spotoptim-3.0.0 → spotoptim-3.1.0}/src/spotoptim/nn/__init__.py

@@ -4,11 +4,25 @@
 
 """Neural network models for spotoptim."""
 
-__all__ = ["LinearRegressor", "MLP"]
+__all__ = [
+    "LinearRegressor",
+    "MLP",
+    "ManyToManyRNN",
+    "ManyToManyRNNRegressor",
+    "get_activation",
+    "optimizer_handler",
+]
 
 _lazy_map = {
     "LinearRegressor": ("spotoptim.nn.linear_regressor", "LinearRegressor"),
     "MLP": ("spotoptim.nn.mlp", "MLP"),
+    "ManyToManyRNN": ("spotoptim.nn.many_to_many_rnn", "ManyToManyRNN"),
+    "ManyToManyRNNRegressor": (
+        "spotoptim.nn.many_to_many_rnn",
+        "ManyToManyRNNRegressor",
+    ),
+    "get_activation": ("spotoptim.nn.many_to_many_rnn", "get_activation"),
+    "optimizer_handler": ("spotoptim.nn.optimizer", "optimizer_handler"),
 }