Braindecode 1.8.1.dev181501004__tar.gz → 1.8.1.dev181512403__tar.gz

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/NOTICE.txt

@@ -40,7 +40,6 @@ The following components are licensed under the MIT License:
 
 - `braindecode/models/ctnet.py`
 - `braindecode/models/dance.py`
-- `braindecode/models/duin.py`
 - `braindecode/models/medformer.py`
 - `braindecode/models/tcformer.py`
 - `braindecode/models/ifnet.py`
@@ -55,8 +54,6 @@ The following components are licensed under the MIT License:
 - `docs/_static/model/seizure_transformer_arch.png`
 - `braindecode/models/guetschel2026.py`
 - `braindecode/models/tmsanet.py`
-- `braindecode/models/epint.py`
-- `braindecode/models/gcnsnet.py`
 
 The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
 SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The

{braindecode-1.8.1.dev181501004/braindecode.egg-info → braindecode-1.8.1.dev181512403}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev181501004
+Version: 1.8.1.dev181512403
 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.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/augmentation/__init__.py

@@ -10,7 +10,6 @@ from .transforms import (
     ChannelsReref,
     ChannelsShuffle,
     ChannelsSymmetry,
-    CutMix,
     FrequencyShift,
     FTSurrogate,
     GaussianNoise,
@@ -37,7 +36,6 @@ __all__ = [
     "SignFlip",
     "FTSurrogate",
     "ChannelsShuffle",
-    "CutMix",
     "ChannelsDropout",
     "GaussianNoise",
     "ChannelsSymmetry",

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/augmentation/functional.py

@@ -1075,54 +1075,6 @@ def mixup(
     return X_mix, (y_a, y_b, lam)
 
 
-def cutmix(
-    X: torch.Tensor,
-    y: torch.Tensor,
-    idx_perm: torch.Tensor,
-    cut_t_start: torch.Tensor,
-    cut_t_len: torch.Tensor,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Paste a time region of shuffled examples into the original examples.
-
-    See [1]_ for details.
-
-    Parameters
-    ----------
-    X : torch.Tensor
-        EEG data in form ``batch_size, n_channels, n_times``
-    y : torch.Tensor
-        Target of length ``batch_size``
-    idx_perm : torch.Tensor
-        Permuted indices of example that are mixed into original examples.
-    cut_t_start : torch.Tensor
-        Start index of the pasted time region for each example.
-    cut_t_len : torch.Tensor
-        Length of the pasted time region for each example.
-
-    Returns
-    -------
-    tuple
-        ``X``, ``y``. Where ``X`` is augmented and ``y`` is a tuple of length
-        3 containing the labels of the two mixed examples and the fraction of
-        each example kept from the original, ``1 - cut_t_len / n_times``.
-
-    References
-    ----------
-    .. [1] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun,
-        Junsuk Choe, Youngjoon Yoo (2019). CutMix: Regularization Strategy
-        to Train Strong Classifiers with Localizable Features. In 2019
-        IEEE/CVF International Conference on Computer Vision (ICCV)
-        Online: https://arxiv.org/abs/1905.04899
-    """
-    n_times = X.shape[-1]
-    t = torch.arange(n_times, device=X.device)
-    start = cut_t_start[:, None]
-    in_cut = (t >= start) & (t < start + cut_t_len[:, None])
-    X_mix = torch.where(in_cut[:, None], X[idx_perm], X)
-    lam = (n_times - cut_t_len).to(X.dtype) / n_times
-    return X_mix, (y.clone(), y[idx_perm].clone(), lam)
-
-
 def segmentation_reconstruction(
     X: torch.Tensor,
     y: torch.Tensor,

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/augmentation/transforms.py

@@ -3,7 +3,6 @@
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
 #          Bruna Lopes <brunajaflopes@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
-#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -25,7 +24,6 @@ from .functional import (
     channels_permute,
     channels_rereference,
     channels_shuffle,
-    cutmix,
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
@@ -1097,55 +1095,6 @@ class Mixup(Transform):
         }
 
 
-class CutMix(Mixup):
-    """Implements CutMix for EEG data.
-
-    A random time region of each example is replaced by the same region of
-    a shuffled example of the batch, see [1]_. As in the reference code [2]_,
-    a coefficient ``lam`` is drawn from a Beta distribution, the region is
-    ``(1 - lam) * n_times`` long (the 1-D analogue of the cut area ratio
-    ``1 - lam``) around a uniformly drawn center, it is clipped at the trial
-    boundaries, and ``lam`` is then recomputed from the pasted length.
-
-    Like :class:`Mixup`, it applies to whole batches and returns targets
-    ``(y_a, y_b, lam)`` for :func:`braindecode.training.mixup_criterion`.
-
-    Parameters
-    ----------
-    alpha : float
-        Parameter of the Beta distribution of ``lam``. ``alpha <= 0`` cuts
-        nothing.
-    beta_per_sample : bool (default=False)
-        By default, one ``lam`` per batch is drawn. If True, one per sample.
-    random_state : int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Defaults to None.
-
-    References
-    ----------
-    .. [1] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun,
-       Junsuk Choe, Youngjoon Yoo (2019). CutMix: Regularization Strategy
-       to Train Strong Classifiers with Localizable Features. In 2019
-       IEEE/CVF International Conference on Computer Vision (ICCV)
-       Online: https://arxiv.org/abs/1905.04899
-    .. [2] https://github.com/clovaai/CutMix-PyTorch/blob/master/train.py
-    """
-
-    operation = staticmethod(cutmix)  # type: ignore[assignment]
-
-    def get_augmentation_params(self, *batch):
-        """Return idx_perm and the cut_t_start, cut_t_len of each region."""
-        params = super().get_augmentation_params(*batch)
-        lam = params.pop("lam")
-        n_times = batch[0].shape[-1]
-        half = ((1 - lam) * n_times).long() // 2
-        center = torch.as_tensor(self.rng.randint(n_times, size=len(lam)))
-        center = center.to(lam.device)
-        start = (center - half).clamp(min=0)
-        end = (center + half).clamp(max=n_times)
-        return dict(params, cut_t_start=start, cut_t_len=end - start)
-
-
 class SegmentationReconstruction(Transform):
     """Segmentation Reconstruction from Lotte (2015) [Lotte2015]_.
 
@@ -1334,7 +1283,7 @@ class MaskEncoding(Transform):
         )
 
         time_start = self.rng.randint(
-            0, n_times - segment_length + 1, (batch_size, self.n_segments)
+            0, n_times - segment_length, (batch_size, self.n_segments)
         )
         time_start = torch.from_numpy(time_start)
 

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/datasets/base.py

@@ -1281,49 +1281,6 @@ class WindowsDataset(_ZarrMixin, RecordDataset):
         )
 
 
-def _lazy_source_files(ds) -> list:
-    """Return the files ``ds`` still reads its signal from (none once preloaded)."""
-    signal = ds.raw if hasattr(ds, "raw") else getattr(ds, "windows", None)
-    if signal is None or getattr(signal, "preload", True):
-        return []
-    files = list(
-        getattr(signal, "filenames", None) or [getattr(signal, "filename", None)]
-    )
-    raw = getattr(signal, "_raw", None)
-    if isinstance(raw, mne.io.BaseRaw) and not raw.preload:
-        files += raw.filenames  # mne.Epochs of a lazily read Raw read through it
-    return [f for f in files if f is not None]
-
-
-def _dir_key(directory):
-    """Identify a directory by device and inode, whatever its spelling."""
-    stat = os.stat(directory)
-    return stat.st_dev, stat.st_ino
-
-
-def _overwrite_conflicts(datasets, path, offset):
-    """Yield ``(i_ds, i_target, target_dir)`` for each dataset ``i_ds`` that
-    lazily reads from inside ``target_dir = path/<i_target + offset>``, which
-    ``save(overwrite=True)`` deletes before writing dataset ``i_target``.
-    """
-    targets = {}
-    for i in range(len(datasets)):
-        target_dir = os.path.join(path, str(i + offset))
-        if os.path.isdir(target_dir):
-            targets[_dir_key(target_dir)] = (i, target_dir)
-    if not targets:
-        return
-    for i_ds, ds in enumerate(datasets):
-        for file in _lazy_source_files(ds):
-            # ancestors of the name and of the file it links to (DataLad)
-            parents = {
-                *Path(os.path.abspath(file)).parents,
-                *Path(os.path.realpath(file)).parents,
-            }
-            for key in {_dir_key(p) for p in parents if p.is_dir()} & targets.keys():
-                yield (i_ds, *targets[key])
-
-
 @register_dataset
 class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
     """A base class for concatenated datasets.
@@ -1561,9 +1518,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         metadata : pd.DataFrame
             DataFrame containing as many rows as there are windows in the
             BaseConcatDataset, with the metadata and description information
-            for each window, and an ``i_dataset`` column giving the position
-            in ``datasets`` of the dataset (recording) each window comes from.
-            Samplers use it to keep recordings apart.
+            for each window.
         """
         if not all(
             [
@@ -1589,15 +1544,9 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                     "Dataset descriptions cannot contain the reserved window "
                     "metadata key 'i_trial_in_dataset'."
                 )
-            if "i_dataset" in df.columns or "i_dataset" in ds.description:
-                raise ValueError(
-                    "Window metadata and dataset descriptions cannot contain the "
-                    "key 'i_dataset', which get_metadata() reserves for the "
-                    "position of the dataset each window comes from. Rename it."
-                )
 
         all_dfs = list()
-        for i_ds, ds in enumerate(self.datasets):
+        for ds in self.datasets:
             if hasattr(ds, "_windows") and ds._windows is not None:
                 df = ds._windows.metadata
             else:
@@ -1607,7 +1556,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 df = df.copy()
             for k, v in ds.description.items():
                 df[k] = v
-            df["i_dataset"] = i_ds
             all_dfs.append(df)
 
         return pd.concat(all_dfs)
@@ -1900,11 +1848,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             dataset description.
         """
         description = pd.DataFrame(description)
-        if len(description.columns) and len(description) != len(self.datasets):
-            raise ValueError(
-                f"Length of values ({len(description)}) does not match "
-                f"number of datasets ({len(self.datasets)})."
-            )
         for key, value in description.items():
             for ds, value_ in zip(self.datasets, value):
                 ds.set_description({key: value_}, overwrite=overwrite)
@@ -1935,9 +1878,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
              -raw.fif | -epo.fif and .json files to.
         overwrite : bool
             Whether to delete old subdirectories that will be saved to in this
-            call. If a dataset still reads its data lazily from one of them, a
-            ``ValueError`` is raised before anything is deleted: load the data
-            into memory first (``preload=True``) or save to another directory.
+            call.
         offset : int
             If provided, the integer is added to the id of the dataset in the
             concat. This is useful in the setting of very large datasets, where
@@ -1950,13 +1891,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             hasattr(self.datasets[0], "raw") or hasattr(self.datasets[0], "windows")
         ):
             raise ValueError("dataset should have either raw or windows attribute")
-        if overwrite:
-            for _, _, target_dir in _overwrite_conflicts(self.datasets, path, offset):
-                raise ValueError(
-                    f"Saving with overwrite=True would delete {target_dir} while "
-                    "a dataset still reads its data from it. Load the data into "
-                    "memory first (preload=True) or save to another directory."
-                )
 
         # Create path if it doesn't exist
         os.makedirs(path, exist_ok=True)

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/eegneuralnet.py

@@ -201,17 +201,12 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         if classes is None:
             classes = getattr(self, "classes", None)
         signal_kwargs = infer_signal_properties(X, y, mode=self.mode, classes=classes)
-        module = _get_model(self.module)
-        # Model-specific values computed from the data (e.g. GCNsNet's graph);
-        # the signal properties take precedence.
-        infer_model_kwargs = getattr(module, "_infer_model_kwargs", None)
-        if infer_model_kwargs is not None:
-            signal_kwargs = {**infer_model_kwargs(X, y), **signal_kwargs}
         if not signal_kwargs:
             return
 
         # kick out missing kwargs:
         module_kwargs = dict()
+        module = _get_model(self.module)
         all_module_kwargs = inspect.signature(module.__init__).parameters.keys()
         for k, v in signal_kwargs.items():
             if v is None:

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/functional/functions.py

@@ -91,27 +91,16 @@ def fft_conv1d(
     n_fft = 2 * _next_fast_len((n_times + kernel_size) // 2)
     xs = spectral_input(x)
     # conv1d is a cross-correlation: a convolution with the flipped kernel
-    x_f = torch.fft.rfft(xs, n=n_fft)  # (batch, in, freq)
+    x_f = torch.fft.rfft(xs, n=n_fft).permute(2, 0, 1)  # (freq, batch, in)
     w_f = torch.fft.rfft(weight.to(xs).flip(-1), n=n_fft).permute(2, 1, 0)
     # Per frequency (batch, in) @ (in, out) in complex numbers, as one real
-    # matmul (a complex one is slower on CPU).
-    needs_grad = torch.is_grad_enabled() and (x.requires_grad or weight.requires_grad)
-    if needs_grad or x.shape[0] >= 2 * x.shape[1]:
-        # [Re x, Im x] @ [[Re w, Im w], [-Im w, Re w]] (rows of i * w): the
-        # output columns are the (Re, Im) pairs of the result, read as complex
-        # without a copy (and without a costly backward).
-        w_mat = torch.view_as_real(torch.stack([w_f, w_f * 1j], 1)).flatten(1, 2)
-        y_f = torch.view_as_real(x_f).permute(2, 0, 3, 1).flatten(2) @ w_mat.flatten(2)
-        y_f = torch.view_as_complex(y_f.unflatten(-1, [-1, 2]))
-    else:
-        # Forward only with fewer rows than twice the input channels: the
-        # doubled weight costs more than combining [Re x; Im x] @ [Re w, Im w].
-        x_f = x_f.permute(2, 0, 1)
-        p = torch.cat([x_f.real, x_f.imag], 1) @ torch.view_as_real(w_f).flatten(2)
-        p = p.unflatten(1, [2, x.shape[0]]).unflatten(3, [-1, 2])
-        y_f = torch.complex(
-            p[:, 0, :, :, 0] - p[:, 1, :, :, 1], p[:, 0, :, :, 1] + p[:, 1, :, :, 0]
-        )
+    # matmul (a complex one is slower on CPU): [Re x; Im x] @ [Re w, Im w]
+    # (columns interleaved) holds the four real products.
+    p = torch.cat([x_f.real, x_f.imag], 1) @ torch.view_as_real(w_f).flatten(2)
+    p = p.unflatten(1, [2, x.shape[0]]).unflatten(3, [-1, 2])  # x re/im, w re/im
+    y_f = torch.complex(
+        p[:, 0, :, :, 0] - p[:, 1, :, :, 1], p[:, 0, :, :, 1] + p[:, 1, :, :, 0]
+    )
     y = torch.fft.irfft(y_f.permute(1, 2, 0), n=n_fft)
     # "same" output t is sample t + kernel_size // 2 of the full convolution
     y = y[..., kernel_size // 2 : kernel_size // 2 + n_times]

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/models/__init__.py

@@ -22,7 +22,6 @@ from .deep4 import Deep4Net
 from .deepsleepnet import DeepSleepNet
 from .dgcnn import DGCNN
 from .diver1 import DIVER1
-from .duin import DuIN
 from .eeg_clip import EEGCLIP
 from .eegconformer import EEGConformer
 from .eegdino import EEGDINO
@@ -37,11 +36,9 @@ from .eegsimpleconv import EEGSimpleConv
 from .eegsym import EEGSym
 from .eegtcnet import EEGTCNet
 from .emg2qwerty import EMG2QwertyNet
-from .epint import EpiNT
 from .fbcnet import FBCNet
 from .fblightconvnet import FBLightConvNet
 from .fbmsnet import FBMSNet
-from .gcnsnet import GCNsNet
 from .guetschel2026 import Guetschel2026
 from .hybrid import HybridNet
 from .ifnet import IFNet
@@ -120,7 +117,6 @@ __all__ = [
     "Deep4Net",
     "DeepSleepNet",
     "DIVER1",
-    "DuIN",
     "BrainModule",
     "Brant",
     "EEGCLIP",
@@ -138,14 +134,12 @@ __all__ = [
     "EEGTCNet",
     "DGCNN",
     "EMG2QwertyNet",
-    "EpiNT",
     "NeuroPose",
     "SensingDynamics",
     "VEMG2Pose",
     "FBCNet",
     "FBLightConvNet",
     "FBMSNet",
-    "GCNsNet",
     "Guetschel2026",
     "MetaNeuromotorHand",
     "HybridNet",

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/models/axon.py

@@ -14,7 +14,6 @@ from torch import nn
 from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import warn_if_sfreq_differs
-from braindecode.modules.attention import _scaled_dot_product_attention
 from braindecode.modules.channels import _resolve
 
 
@@ -463,33 +462,11 @@ class _AxisAttention(nn.Module):
             .unbind(0)
         )
         drop = self.att_drop_prob if self.training else 0.0
-        attended = _scaled_dot_product_attention(
+        attended = F.scaled_dot_product_attention(
             query, key, value, attn_mask=mask, dropout_p=drop
         )
         return attended.transpose(1, 2).reshape(n_seq, length, -1)
 
-    def _attend_two_scales(
-        self, projected: torch.Tensor, band: torch.Tensor, weights: torch.Tensor
-    ) -> torch.Tensor:
-        """Banded and full attention from one score matrix, mixed per query.
-
-        ``weights`` (N, L, 2) are the scale-gate weights. Both softmaxes share
-        the scores and one product with the values serves the mixture.
-        """
-        n_seq, length, _ = projected.shape
-        query, key, value = (
-            projected.reshape(n_seq, length, 3, self.num_heads, self.head_dim)
-            .permute(2, 0, 3, 1, 4)
-            .unbind(0)
-        )
-        scores = torch.matmul(query, key.transpose(-2, -1)) * self.head_dim**-0.5
-        weights = weights.reshape(n_seq, 1, length, 2)
-        probs = weights[..., 0:1] * scores.masked_fill(~band, float("-inf")).softmax(
-            -1
-        ) + weights[..., 1:2] * scores.softmax(-1)
-        attended = torch.matmul(probs, value)
-        return attended.transpose(1, 2).reshape(n_seq, length, -1)
-
     def forward(self, x: torch.Tensor, band: Optional[torch.Tensor]) -> torch.Tensor:
         batch, n_chans, n_patches, dim = x.shape
         axis_weights = self.axis_gate(x)  # (B, C, P, 2)
@@ -499,26 +476,15 @@ class _AxisAttention(nn.Module):
         # the restricted branch is the full one; attend once unless the two
         # branches draw their own attention dropout.
         per_channel = self.temporal_qkv(x.reshape(batch * n_chans, n_patches, dim))
-        dropout = self.training and self.att_drop_prob > 0
-        if band is not None and not dropout:
-            # The scale-gate weights sum to one, so the two branches share the
-            # scores, the product with the values and temporal_out.
-            attended = self._attend_two_scales(per_channel, band, scale_weights)
-            temporal = self.temporal_out(attended).reshape(
-                batch, n_chans, n_patches, dim
-            )
-        else:
-            restricted = self.temporal_out(self._attend(per_channel, band)).reshape(
+        restricted = self.temporal_out(self._attend(per_channel, band)).reshape(
+            batch, n_chans, n_patches, dim
+        )
+        full = restricted
+        if band is not None or (self.training and self.att_drop_prob > 0):
+            full = self.temporal_out(self._attend(per_channel, None)).reshape(
                 batch, n_chans, n_patches, dim
             )
-            full = restricted
-            if dropout:
-                full = self.temporal_out(self._attend(per_channel, None)).reshape(
-                    batch, n_chans, n_patches, dim
-                )
-            temporal = (
-                scale_weights[..., 0:1] * restricted + scale_weights[..., 1:2] * full
-            )
+        temporal = scale_weights[..., 0:1] * restricted + scale_weights[..., 1:2] * full
 
         # Spatial path: one sequence of C tokens per time step.
         per_step = self.spatial_qkv(

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/models/barista.py

@@ -14,7 +14,6 @@ from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
 from braindecode.modules import GatedLinearUnit, PatchTokenizer
 from braindecode.modules.attention import _scaled_dot_product_attention
-from braindecode.modules.blocks import _check_on_non_divisible, _patch_count
 
 
 class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
@@ -78,8 +77,7 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
     .. rubric:: Temporal, Spatial, and Spectral Encoding
 
     - Temporal encoding uses non-overlapping patches and patch-index rotary
-      embeddings. By default a trailing partial patch is right zero-padded;
-      ``on_non_divisible="crop"`` drops it, as the reference does.
+      embeddings. Samples beyond the last complete patch are dropped.
     - Spatial encoding uses dataset-provided coordinate or region indices.
       ``spatial_scale="none"`` disables it.
     - The CNN operates on waveforms. There is no explicit spectral transform.
@@ -96,8 +94,7 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
     Treebank's coordinate convention.
 
     With ``pooling="mean"``, channel counts and window lengths can vary between
-    batches (with ``on_non_divisible="crop"``, provided each window contains a
-    full patch). Pass each recording's
+    batches, provided each window contains a full patch. Pass each recording's
     indices to :meth:`forward`; otherwise it uses the constructor's indices
     or MNE positions. All samples in one batch
     share a montage. The encoder uses PyTorch attention on separate batch
@@ -144,13 +141,9 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
         in millimetres when deriving indices from ``chs_info``.
     patch_size : int
         Number of samples per temporal patch, default 512 (250 ms at the
-        paper's 2048 Hz).
-    on_non_divisible : {"pad", "crop", "error"}, default="pad"
-        How :class:`~braindecode.modules.PatchTokenizer` treats a time axis that
-        is not a multiple of ``patch_size`` (right zero-pad, crop, or raise).
-        The reference implementation crops (``"crop"``: the trailing samples
-        are lost); both give the same model and output when ``n_times`` is a
-        multiple of ``patch_size``.
+        paper's 2048 Hz). Windows are tokenized into whole patches, so a window
+        that is not a multiple of ``patch_size`` loses its trailing samples, as
+        in the reference.
     d_model : int
         Token embedding dimension.
     n_layers : int
@@ -187,9 +180,6 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
        Systems 38. https://arxiv.org/abs/2512.12135
     """
 
-    # Configs and checkpoints saved before ``on_non_divisible`` existed cropped.
-    _legacy_on_non_divisible = "crop"
-
     def __init__(
         self,
         # --- signal-related (handled by EEGModuleMixin) ---
@@ -205,7 +195,6 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
         spatial_indices: list[int] | list[list[int]] | None = None,
         coord_bins: int = 200,
         patch_size: int = 512,
-        on_non_divisible: str = "pad",
         d_model: int = 64,
         n_layers: int = 12,
         num_heads: int = 4,
@@ -254,7 +243,8 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
                 raise ValueError(f"{name} must be positive, got {value}.")
         if cnn_depth < 0:
             raise ValueError(f"cnn_depth must be non-negative, got {cnn_depth}.")
-        _check_on_non_divisible(on_non_divisible)
+        if self.n_times < patch_size:
+            raise ValueError("n_times must contain at least one full patch.")
         if d_model % num_heads:
             raise ValueError(
                 f"d_model ({d_model}) must be divisible by num_heads ({num_heads})."
@@ -268,7 +258,6 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
         self.spatial_scale = spatial_scale
         self.coord_bins = coord_bins
         self.patch_size = patch_size
-        self.on_non_divisible = on_non_divisible
         self.d_model = d_model
         self.n_layers = n_layers
         self.num_heads = num_heads
@@ -277,15 +266,14 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
         self.drop_prob = drop_prob
         self.activation = activation
 
-        # ceil(n_times / patch_size) with "pad"; floor with "crop" (the
-        # reference: trailing samples dropped, raises below one patch); exact
-        # with "error" (raises otherwise). The learned pooling is sized to it.
-        self.n_patches = _patch_count(self.n_times, patch_size, on_non_divisible)
+        # The trailing samples are dropped when n_times is not a multiple of
+        # patch_size, as in the reference.
+        self.n_patches = self.n_times // patch_size
 
         self.patch_tokenizer = PatchTokenizer(
             patch_size=patch_size,
             n_times=self.n_times,
-            on_non_divisible=on_non_divisible,
+            on_non_divisible="crop",
             output_order="patch_channel",
         )
         # Every (patch, channel) pair is encoded independently, so the grid is

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/models/base.py

@@ -608,24 +608,9 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         """
         config = dict(config)  # shallow copy
         config.pop("braindecode_version", None)
-        cls._fill_legacy_defaults(config)
         resolve_type_kwargs(cls, config)
         return cls(**config)
 
-    @classmethod
-    def _fill_legacy_defaults(cls, kwargs: dict) -> None:
-        """Rebuild configs saved before ``on_non_divisible`` existed as they were.
-
-        Models that used to crop a time axis not divisible by their patch size
-        set ``_legacy_on_non_divisible = "crop"``. A saved config or checkpoint
-        without the ``on_non_divisible`` key then loads with ``"crop"``, so its
-        head and position tables keep their shapes; a new model defaults to
-        ``"pad"``.
-        """
-        legacy = getattr(cls, "_legacy_on_non_divisible", None)
-        if legacy is not None and "on_non_divisible" not in kwargs:
-            kwargs["on_non_divisible"] = legacy
-
     def _set_n_outputs(self, n_outputs: int) -> None:
         """Record a new ``n_outputs`` on the model and its saved configs.
 
@@ -926,9 +911,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         ):
             model_kwargs.pop("braindecode_version", None)
             filename = model_kwargs.pop("filename", None)
-            # The Hub mixin passes only the keys of config.json (plus the
-            # caller's), so a missing key means a pre-on_non_divisible save.
-            cls._fill_legacy_defaults(model_kwargs)
             resolve_type_kwargs(cls, model_kwargs)
 
             # Read saved n_outputs from config.json to detect when the

{braindecode-1.8.1.dev181501004 → braindecode-1.8.1.dev181512403}/braindecode/models/brainmodule.py

@@ -20,7 +20,6 @@ from torch.nn import functional as F
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import has_valid_locations, positions_from_chs_info
 from braindecode.modules import ChannelMerger
-from braindecode.modules.attention import _hpu_lazy
 from braindecode.modules.layers import SubjectLayers
 
 __all__ = ["BrainModule"]
@@ -713,7 +712,7 @@ class _ConvSequence(nn.Module):
                         nn.Conv1d(
                             chout, 2 * chout, 1 + 2 * glu_context, padding=glu_context
                         ),
-                        _GLU(dim=1),
+                        nn.GLU(dim=1),
                     )
                 )
             else:
@@ -728,17 +727,6 @@ class _ConvSequence(nn.Module):
         return x
 
 
-class _GLU(nn.GLU):
-    """``nn.GLU`` that Intel Gaudi's lazy mode can compile."""
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not torch.jit.is_scripting() and x.device.type == "hpu" and _hpu_lazy():
-            # Its graph compiler fails on ``aten.glu`` after a convolution.
-            a, b = x.chunk(2, dim=self.dim)
-            return a * torch.sigmoid(b)
-        return F.glu(x, self.dim)
-
-
 def _pad_multiple(x: torch.Tensor, base: int) -> torch.Tensor:
     """Pad tensor to be a multiple of base."""
     length = x.shape[-1]