braindecode 1.8.1.dev170153392__tar.gz → 1.8.1.dev170208067__tar.gz

{braindecode-1.8.1.dev170153392/braindecode.egg-info → braindecode-1.8.1.dev170208067}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev170153392
+Version: 1.8.1.dev170208067
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Alexandre Gramfort <agramfort@meta.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/augmentation/__init__.py

@@ -14,6 +14,7 @@ from .transforms import (
     FrequencyShift,
     FTSurrogate,
     GaussianNoise,
+    LabelSmoothing,
     MaskEncoding,
     Mixup,
     SegmentationReconstruction,
@@ -40,6 +41,7 @@ __all__ = [
     "CutMix",
     "ChannelsDropout",
     "GaussianNoise",
+    "LabelSmoothing",
     "ChannelsSymmetry",
     "SmoothTimeMask",
     "BandstopFilter",

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/augmentation/base.py

@@ -171,7 +171,13 @@ class Compose(Transform):
         self.transforms = transforms
         super().__init__()
 
-    def forward(self, X, y):
+    def forward(self, X, y=None):
+        # like Transform.forward, return only X when no target is given (each
+        # transform then returns a single tensor, not an (X, y) pair)
+        if y is None:
+            for transform in self.transforms:
+                X = transform(X)
+            return X
         for transform in self.transforms:
             X, y = transform(X, y)
         return X, y

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/augmentation/functional.py

@@ -19,7 +19,22 @@ from mne.filter import notch_filter
 from scipy.interpolate import Rbf
 from sklearn.utils import check_random_state
 from torch.fft import fft, ifft
-from torch.nn.functional import pad
+from torch.nn.functional import one_hot, pad
+
+
+def _max_float_dtype(device: torch.device | str) -> torch.dtype:
+    """float64, or float32 on Apple MPS, which has no float64."""
+    return torch.float32 if torch.device(device).type == "mps" else torch.float64
+
+
+def _to_device(t: torch.Tensor, device: torch.device | str) -> torch.Tensor:
+    """Move ``t`` to ``device``, in single precision on MPS (no float64 there)."""
+    if torch.device(device).type == "mps":
+        if t.dtype == torch.float64:
+            return t.float().to(device)
+        if t.dtype == torch.complex128:
+            return t.to(torch.complex64).to(device)
+    return t.to(device)
 
 
 def identity(X: torch.Tensor, y: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
@@ -92,10 +107,11 @@ def _new_random_fft_phase_odd(
     rng = check_random_state(random_state)
     random_phase = torch.from_numpy(
         2j * np.pi * rng.random((batch_size, c, (n - 1) // 2))
-    ).to(device)
+    )
+    random_phase = _to_device(random_phase, device)
     return torch.cat(
         [
-            torch.zeros((batch_size, c, 1), device=device),
+            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
             random_phase,
             -torch.flip(random_phase, [-1]),
         ],
@@ -113,12 +129,13 @@ def _new_random_fft_phase_even(
     rng = check_random_state(random_state)
     random_phase = torch.from_numpy(
         2j * np.pi * rng.random((batch_size, c, n // 2 - 1))
-    ).to(device)
+    )
+    random_phase = _to_device(random_phase, device)
     return torch.cat(
         [
-            torch.zeros((batch_size, c, 1), device=device),
+            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
             random_phase,
-            torch.zeros((batch_size, c, 1), device=device),
+            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
             -torch.flip(random_phase, [-1]),
         ],
         dim=-1,
@@ -178,7 +195,7 @@ def ft_surrogate(
         and 0 <= phase_noise_magnitude <= 1
     ), f"eps must be a float between 0 and 1. Got {phase_noise_magnitude}."
 
-    f = fft(X.double(), dim=-1)
+    f = fft(X.to(_max_float_dtype(X.device)), dim=-1)
     device = X.device
 
     n = f.shape[-1]
@@ -580,6 +597,7 @@ def _frequency_shift(X: torch.Tensor, fs: float, f_shift: float) -> torch.Tensor
         _f_shift = torch.as_tensor(f_shift).float()
     else:
         raise ValueError(f"Invalid f_shift type: {type(f_shift)}")
+    _f_shift = _f_shift.to(X.device)
     f_shift_stack = _f_shift.repeat(N_padded, n_channels, 1)
     reshaped_f_shift = f_shift_stack.permute(
         *torch.arange(f_shift_stack.ndim - 1, -1, -1)
@@ -911,7 +929,15 @@ def _rotate_signals(
     sensors_positions_matrix: torch.Tensor,
     spherical: bool = True,
 ) -> torch.Tensor:
-    sensors_positions_matrix = sensors_positions_matrix.to(X.device)
+    if X.device.type == "mps":
+        # MPS has no float64: compute the small (n_chans x n_chans) spherical
+        # spline matrices on CPU in double precision, only move the result
+        # (two separate steps: a combined device + dtype .to() from MPS
+        # returns zeros with some torch versions)
+        sensors_positions_matrix = sensors_positions_matrix.cpu().double()
+        rotations = [rotation.cpu().double() for rotation in rotations]
+    else:
+        sensors_positions_matrix = sensors_positions_matrix.to(X.device)
     rot_sensors_matrices = [
         rotation.matmul(sensors_positions_matrix) for rotation in rotations
     ]
@@ -921,9 +947,10 @@ def _rotate_signals(
                 torch.as_tensor(
                     _torch_make_interpolation_matrix(
                         sensors_positions_matrix.T, rot_sensors_matrix.T
-                    ),
-                    device=X.device,
-                ).float()
+                    )
+                )
+                .float()
+                .to(X.device)
                 for rot_sensors_matrix in rot_sensors_matrices
             ]
         )
@@ -1062,10 +1089,12 @@ def mixup(
         Online: https://arxiv.org/abs/1710.09412
     .. [2] https://github.com/facebookresearch/mixup-cifar10/blob/master/train.py
     """
-    device = X.device
     batch_size, n_channels, n_times = X.shape
 
-    X_mix = torch.zeros((batch_size, n_channels, n_times)).to(device)
+    X_mix = X.new_zeros(
+        (batch_size, n_channels, n_times),
+        dtype=X.dtype if X.is_floating_point() else torch.get_default_dtype(),
+    )
     y_a = y.clone()
     y_b = y[idx_perm].clone()
 
@@ -1123,6 +1152,97 @@ def cutmix(
     return X_mix, (y.clone(), y[idx_perm].clone(), lam)
 
 
+def label_smoothing(
+    X: torch.Tensor,
+    y: torch.Tensor,
+    epsilon: float,
+    num_classes: int | None = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Smooth targets toward the uniform distribution over the classes.
+
+    See [1]_ for details.
+
+    Parameters
+    ----------
+    X : torch.Tensor
+        EEG data in form ``batch_size, n_channels, n_times``. Returned
+        unchanged.
+    y : torch.Tensor
+        Target of length ``batch_size`` holding class indices (float values
+        are accepted when they are integral), or a floating-point tensor of
+        shape ``batch_size, num_classes`` holding target distributions.
+    epsilon : float
+        Smoothing parameter between 0 and 1: the weight of the uniform
+        distribution mixed into the targets. ``0`` returns the unsmoothed
+        targets.
+    num_classes : int | None, optional
+        Number of classes. Required when ``y`` holds class indices; when
+        ``y`` already holds distributions, it must match the size of the
+        last dimension of ``y``. Defaults to None.
+
+    Returns
+    -------
+    tuple
+        ``X``, ``y``. Where ``X`` is unchanged and ``y`` is a
+        floating-point tensor of shape ``batch_size, num_classes`` whose
+        rows sum to one.
+
+    References
+    ----------
+    .. [1] Christian Szegedy, Vincent Vanhoucke, Jonathon Shlens and
+        Zbigniew Wojna (2016). Rethinking the Inception Architecture for
+        Computer Vision. In 2016 IEEE Conference on Computer Vision and
+        Pattern Recognition (CVPR), pp. 2818-2826.
+        Online: https://arxiv.org/abs/1512.00567
+    """
+    if not isinstance(epsilon, Real) or not 0.0 <= float(epsilon) <= 1.0:
+        raise ValueError(
+            f"epsilon should be a real number between 0 and 1. Got {epsilon!r}."
+        )
+    if num_classes is not None and (
+        not isinstance(num_classes, int)
+        or isinstance(num_classes, bool)
+        or num_classes < 2
+    ):
+        raise ValueError(
+            f"num_classes should be an integer of at least 2. Got {num_classes!r}."
+        )
+
+    if y.dim() == 1:
+        # class-index targets: smooth their one-hot encoding
+        if num_classes is None:
+            raise ValueError("num_classes is required when y holds class indices.")
+        if not torch.all(y == y.floor()):
+            raise ValueError(
+                "y holds non-integral values; class-index targets should be "
+                "integers or integral floats."
+            )
+        if y.numel() > 0 and (y.min() < 0 or y.max() >= num_classes):
+            raise ValueError(f"y holds class indices outside [0, {num_classes}).")
+        one_hot_y = one_hot(y.long(), num_classes).to(dtype=X.dtype)
+        return X, one_hot_y * (1.0 - epsilon) + epsilon / num_classes
+
+    if y.is_floating_point() and y.dim() >= 2:
+        # target distributions: interpolate them toward the uniform one
+        n_classes = y.shape[-1]
+        if num_classes is not None and num_classes != n_classes:
+            raise ValueError(
+                f"num_classes ({num_classes}) does not match the size of the "
+                f"last dimension of y ({n_classes})."
+            )
+        if n_classes < 2:
+            raise ValueError(
+                f"y should hold distributions over at least 2 classes. Got {n_classes}."
+            )
+        return X, y * (1.0 - epsilon) + epsilon / n_classes
+
+    raise ValueError(
+        "y should hold class indices or floating-point target distributions "
+        f"with a class dimension; got dtype {y.dtype} and shape "
+        f"{tuple(y.shape)}."
+    )
+
+
 def segmentation_reconstruction(
     X: torch.Tensor,
     y: torch.Tensor,

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/augmentation/transforms.py

@@ -18,6 +18,7 @@ from braindecode.util import resolve_montage_name
 
 from .base import Transform
 from .functional import (
+    _max_float_dtype,
     amplitude_scale,
     band_rotation,
     bandstop_filter,
@@ -29,6 +30,7 @@ from .functional import (
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
+    label_smoothing,
     mask_encoding,
     mixup,
     segmentation_reconstruction,
@@ -494,6 +496,7 @@ class SmoothTimeMask(Transform):
                 size=X.shape[0],
             ),
             device=X.device,
+            dtype=_max_float_dtype(X.device),
         ) * (seq_length - mask_len_samples)
         return {
             "mask_start_per_sample": mask_start,
@@ -675,7 +678,11 @@ class FrequencyShift(Transform):
             return super().get_augmentation_params(*batch)
         X = batch[0]
 
-        u = torch.as_tensor(self.rng.uniform(size=X.shape[0]), device=X.device)
+        u = torch.as_tensor(
+            self.rng.uniform(size=X.shape[0]),
+            device=X.device,
+            dtype=_max_float_dtype(X.device),
+        )
         max_delta_freq = self.max_delta_freq
         if isinstance(max_delta_freq, torch.Tensor):
             max_delta_freq = max_delta_freq.to(X.device)
@@ -833,7 +840,10 @@ class SensorsRotation(Transform):
         if isinstance(max_degrees, torch.Tensor):
             max_degrees = max_degrees.to(X.device)
         random_angles = (
-            torch.as_tensor(u, device=X.device) * 2 * max_degrees - max_degrees
+            torch.as_tensor(u, device=X.device, dtype=_max_float_dtype(X.device))
+            * 2
+            * max_degrees
+            - max_degrees
         )
         return {
             "sensors_positions_matrix": self.sensors_positions_matrix,
@@ -1146,6 +1156,98 @@ class CutMix(Mixup):
         return dict(params, cut_t_start=start, cut_t_len=end - start)
 
 
+class LabelSmoothing(Transform):
+    """Label smoothing from Szegedy et al. (2016) [1]_.
+
+    Replaces each target with its convex combination with the uniform
+    distribution over the classes, penalizing over-confident predictions.
+    The signals are returned unchanged; only the targets change.
+
+    The smoothed targets are floating-point distributions of shape
+    ``batch_size, num_classes`` (each row sums to one), so the training
+    loss must accept target distributions, e.g. soft cross-entropy
+    ``-(y * torch.log_softmax(logits, dim=-1)).sum(-1).mean()`` or
+    ``torch.nn.KLDivLoss``. The transform composes before target-mixing
+    transforms such as :class:`braindecode.augmentation.Mixup`, whose
+    fractional-target path then mixes the smoothed distributions. The
+    fixed-expansion mode (``n_augmentation > 0``) of
+    :class:`braindecode.augmentation.AugmentedDataLoader` is not supported:
+    it cannot concatenate the unsmoothed original targets with the reshaped
+    smoothed copies.
+
+    Parameters
+    ----------
+    epsilon : float
+        Smoothing parameter between 0 and 1: the weight of the uniform
+        distribution mixed into the targets. ``0`` disables smoothing.
+    num_classes : int | None, optional
+        Number of classes. Required when the targets are class indices;
+        when the targets are already distributions of shape
+        ``batch_size, num_classes``, it must match their last dimension.
+        Defaults to None.
+    random_state : int | numpy.random.Generator, optional
+        Seed to be used to instantiate numpy random number generator
+        instance. The transform is deterministic, so the seed only feeds
+        the application-probability machinery, which is inactive here.
+        Defaults to None.
+
+    References
+    ----------
+    .. [1] Christian Szegedy, Vincent Vanhoucke, Jonathon Shlens and
+       Zbigniew Wojna (2016). Rethinking the Inception Architecture for
+       Computer Vision. In 2016 IEEE Conference on Computer Vision and
+       Pattern Recognition (CVPR), pp. 2818-2826.
+       Online: https://arxiv.org/abs/1512.00567
+    """
+
+    operation = staticmethod(label_smoothing)  # type: ignore[assignment]
+
+    def __init__(self, epsilon, num_classes=None, random_state=None):
+        super().__init__(
+            probability=1.0,  # LabelSmoothing has to be applied to whole batches
+            random_state=random_state,
+        )
+        if not isinstance(epsilon, Real) or not 0.0 <= float(epsilon) <= 1.0:
+            raise ValueError(
+                f"epsilon should be a real number between 0 and 1. Got {epsilon!r}."
+            )
+        if num_classes is not None and (
+            not isinstance(num_classes, int)
+            or isinstance(num_classes, bool)
+            or num_classes < 2
+        ):
+            raise ValueError(
+                f"num_classes should be an integer of at least 2. Got {num_classes!r}."
+            )
+        self.epsilon = epsilon
+        self.num_classes = num_classes
+
+    def get_augmentation_params(self, *batch):
+        """Return transform parameters.
+
+        Parameters
+        ----------
+        X : tensor.Tensor
+            The data.
+        y : tensor.Tensor
+            The labels.
+
+        Returns
+        -------
+        params : dict
+            Contains
+
+            * epsilon : float
+                Smoothing parameter between 0 and 1.
+            * num_classes : int | None
+                The number of classes.
+        """
+        return {
+            "epsilon": self.epsilon,
+            "num_classes": self.num_classes,
+        }
+
+
 class SegmentationReconstruction(Transform):
     """Segmentation Reconstruction from Lotte (2015) [Lotte2015]_.
 

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/datasets/base.py

@@ -634,7 +634,9 @@ class RecordDataset(Dataset[tuple[np.ndarray, int | str, tuple[int, int, int]]])
                         f"'{key}' already in description. Please "
                         f"rename or set overwrite to True."
                     )
-                    self._description.pop(key)
+                    # drop on a copy: windows datasets share the description
+                    # Series of the dataset they were created from
+                    self._description = self._description.drop(key)
             self._description = pd.concat([self.description, description])
 
     @property

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/datasets/mne.py

@@ -159,6 +159,11 @@ def create_from_mne_epochs(
 
     list_of_windows_ds = []
     for i, epochs in enumerate(list_of_epochs):
+        # drop rejected epochs first (on a copy) so that iterating over the
+        # epochs stays aligned with ``epochs.events``; preloaded epochs have
+        # already dropped them, so skip copying their data
+        if not epochs.preload:
+            epochs = epochs.copy().drop_bad()
         event_descriptions = epochs.events[:, 2]
         original_trial_starts = epochs.events[:, 0]
         stop = len(epochs.times) - window_size_samples

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/datasets/tuh.py

@@ -122,7 +122,8 @@ class TUH(BaseConcatDataset):
                 # Assume it is an integer specifying number
                 # of recordings to load
                 recording_ids = range(recording_ids)
-            descriptions = descriptions[recording_ids]
+            # select by chronological position, not by (file listing) label
+            descriptions = descriptions.iloc[:, list(recording_ids)]
 
         # workaround to ensure warnings are suppressed when running in parallel
         def create_dataset(*args, **kwargs):

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/datautil/serialization.py

@@ -140,15 +140,19 @@ def _load_signals(fif_file, preload, is_raw):
         with open(pkl_file, "rb") as f:
             signals = pickle.load(f)
 
-        if all(Path(f).exists() for f in signals.filenames):
+        # The pickle stores absolute paths: check that they exist and point to
+        # this fif file, not to the folder the dataset was copied from.
+        if all(Path(f).exists() for f in signals.filenames) and (
+            Path(signals.filenames[0]).resolve() == fif_file.resolve()
+        ):
             if preload:
                 signals.load_data()
             return _compact_fif_tags(signals)
         else:  # This may happen if the file has been moved together with the pickle file.
             warnings.warn(
                 f"Pickle file {pkl_file} exists, but the referenced fif "
-                "file(s) do not exist. Will read the fif file(s) directly "
-                "and re-create the pickle file.",
+                "file(s) do not exist or are not next to it. Will read the "
+                "fif file(s) directly and re-create the pickle file.",
                 UserWarning,
             )
 
@@ -220,7 +224,10 @@ def load_concat_dataset(path, preload, ids_to_load=None, target_name=None, n_job
     # target_name.json, raw_preproc_kwargs.json, window_kwargs.json,
     # window_preproc_kwargs.json
     if ids_to_load is None:
-        ids_to_load = [p.name for p in path.iterdir()]
+        # skip stray entries such as .DS_Store or a README next to the datasets
+        ids_to_load = [
+            p.name for p in path.iterdir() if p.is_dir() and p.name.isdigit()
+        ]
         ids_to_load = sorted(ids_to_load, key=lambda i: int(i))
     ids_to_load = [str(i) for i in ids_to_load]
     first_raw_fif_path = path / ids_to_load[0] / f"{ids_to_load[0]}-raw.fif"

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/functional/initialization.py

@@ -1,25 +1,30 @@
 import math
 
+import torch
 from torch import nn
 
 
 def glorot_weight_zero_bias(model):
-    """Initialize parameters of all modules by initializing weights with.
+    """Set the weights of BatchNorm layers to one and all biases to zero.
 
-    glorot uniform/xavier initialization, and setting biases to zero. Weights from
-    batch norm layers are set to 1.
+    Despite its name, this function does not apply the Glorot (Xavier)
+    initialization: other weights keep the initialization of their layer
+    (PyTorch's default, or Xavier uniform for the max-norm constrained layers
+    such as :class:`braindecode.modules.Conv2dWithConstraint`). The name is
+    kept for backward compatibility.
 
     Parameters
     ----------
     model : Module
     """
     for module in model.modules():
-        if hasattr(module, "weight"):
-            if "BatchNorm" in module.__class__.__name__:
-                nn.init.constant_(module.weight, 1)
-        if hasattr(module, "bias"):
-            if module.bias is not None:
-                nn.init.constant_(module.bias, 0)
+        # ``weight``/``bias`` can be None (e.g. BatchNorm with affine=False)
+        weight = getattr(module, "weight", None)
+        if isinstance(weight, torch.Tensor) and "BatchNorm" in type(module).__name__:
+            nn.init.constant_(weight, 1)
+        bias = getattr(module, "bias", None)
+        if isinstance(bias, torch.Tensor):
+            nn.init.constant_(bias, 0)
 
 
 def rescale_parameter(param, layer_id):

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/models/atcnet.py

@@ -444,8 +444,10 @@ class ATCNet(EEGModuleMixin, nn.Module):
         # ----- Sliding window -----
         sw_concat: list[torch.Tensor] = []  # to store sliding window outputs
         # for w in range(self.n_windows):
-        for idx, (attention, tcn_module, final_layer) in enumerate(
-            zip(self.attention_blocks, self.temporal_conv_nets, self.final_layer)
+        # (final_layer is not zipped in: with concat=True it holds a single
+        # layer, which would stop the loop after the first window)
+        for idx, (attention, tcn_module) in enumerate(
+            zip(self.attention_blocks, self.temporal_conv_nets)
         ):
             conv_feat_w = conv_feat[..., idx : idx + self.Tw]
             # Dimension: (batch_size, F2, Tw)
@@ -458,14 +460,15 @@ class ATCNet(EEGModuleMixin, nn.Module):
             tcn_feat = tcn_module(att_feat)[..., -1]
             # Dimension: (batch_size, F2)
 
-            # Outputs of sliding window can be either averaged after being
-            # mapped by dense layer or concatenated then mapped by a dense
-            # layer
-            if not self.concat:
-                tcn_feat = final_layer(tcn_feat)
-
             sw_concat.append(tcn_feat)
 
+        # Outputs of sliding window can be either averaged after being
+        # mapped by dense layer or concatenated then mapped by a dense
+        # layer
+        if not self.concat:
+            for idx, final_layer in enumerate(self.final_layer):
+                sw_concat[idx] = final_layer(sw_concat[idx])
+
         # ----- Aggregation and prediction -----
         if self.concat:
             sw_concat_agg = torch.cat(sw_concat, dim=1)

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/models/base.py

@@ -521,6 +521,11 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         output_shape : tuple[int, ...]
             shape of the network output for `batch_size==1` (1, ...)
         """
+        # Run in eval mode, so that the probe input does not update BatchNorm
+        # running stats or draw dropout masks; restore each module's own mode
+        # afterwards (some may have been put in eval mode on purpose).
+        modes = {module: module.training for module in self.modules()}
+        self.eval()
         with torch.inference_mode():
             try:
                 return tuple(
@@ -540,6 +545,9 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                 if error is None:
                     raise
                 raise error from exc
+            finally:
+                for module, training in modes.items():
+                    module.training = training
 
     def get_config(self) -> dict:
         """Return a JSON-serializable dict of all ``__init__`` parameters.
@@ -623,7 +631,11 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         ``"pad"``.
         """
         legacy = getattr(cls, "_legacy_on_non_divisible", None)
-        if legacy is not None and "on_non_divisible" not in kwargs:
+        if legacy is None or "on_non_divisible" in kwargs:
+            return
+        # A subclass with its own signature may not take the argument.
+        params = inspect.signature(cls.__init__).parameters.values()
+        if any(p.name == "on_non_divisible" or p.kind is p.VAR_KEYWORD for p in params):
             kwargs["on_non_divisible"] = legacy
 
     def _set_n_outputs(self, n_outputs: int) -> None:

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/models/biot.py

@@ -186,10 +186,12 @@ class BIOT(EEGModuleMixin, nn.Module):
             warn(
                 "The hop length is larger than the sampling frequency. "
                 + "This may cause aliasing. Consider using a smaller "
-                "hop length.",
+                "hop length. Using sfreq // 2 instead.",
                 UserWarning,
             )
-            hop_length = self.sfreq // 2
+            # torch.stft needs an int, and sfreq is usually a float
+            hop_length = int(self.sfreq // 2)
+            self.hop_length = hop_length
 
         if self.input_window_seconds < 1.0:
             warning_msg = (

{braindecode-1.8.1.dev170153392 → braindecode-1.8.1.dev170208067}/braindecode/models/ctnet.py

@@ -181,6 +181,7 @@ class CTNet(EEGModuleMixin, nn.Module, license="mit"):
             drop_prob=self.att_positional_drop_prob,
             n_times=self.n_times,
             pool_size=self.pool_size_1,
+            sequence_length=self.sequence_length,
         )
 
         self.trans = _TransformerEncoder(
@@ -220,7 +221,7 @@ class CTNet(EEGModuleMixin, nn.Module, license="mit"):
         cnn = self.position(cnn)
         trans = self.trans(cnn)
         features = cnn + trans
-        flatten_feature = self.flatten(features)
+        flatten_feature = self.flatten_drop_layer(features)
         out = self.final_layer(flatten_feature)
         return out
 
@@ -516,18 +517,23 @@ class _PositionalEncoding(nn.Module):
         length: int = 100,
         drop_prob: float = 0.1,
         pool_size: int = 8,
+        sequence_length: int | None = None,
     ):
         super().__init__()
         self.pool_size = pool_size
         self.n_times = n_times
 
-        if int(n_times / (pool_size * pool_size)) > length:
+        # n_times / pool_size**2 is the sequence length only when both pooling
+        # sizes are equal; also cover the actual length (e.g. pool_size_2 <
+        # pool_size_1), so that the encoding is never shorter than the input
+        needed = max(int(n_times / (pool_size * pool_size)), sequence_length or 0)
+        if needed > length:
             warn(
                 "the temporal dimensional is too long for this default length. "
                 "The length parameter will be automatically adjusted to "
                 "avoid inference issues."
             )
-            length = int(n_times / (pool_size * pool_size))
+            length = needed
 
         self.dropout = nn.Dropout(drop_prob)
         self.encoding = nn.Parameter(torch.randn(1, length, emb_size))