Braindecode 1.8.1.dev181458649__tar.gz → 1.8.1.dev181501004__tar.gz

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

@@ -40,6 +40,7 @@ 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`

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

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

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

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

@@ -1075,6 +1075,54 @@ 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.dev181458649 → braindecode-1.8.1.dev181501004}/braindecode/augmentation/transforms.py

@@ -3,6 +3,7 @@
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
 #          Bruna Lopes <brunajaflopes@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
+#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -24,6 +25,7 @@ from .functional import (
     channels_permute,
     channels_rereference,
     channels_shuffle,
+    cutmix,
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
@@ -1095,6 +1097,55 @@ 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]_.
 
@@ -1283,7 +1334,7 @@ class MaskEncoding(Transform):
         )
 
         time_start = self.rng.randint(
-            0, n_times - segment_length, (batch_size, self.n_segments)
+            0, n_times - segment_length + 1, (batch_size, self.n_segments)
         )
         time_start = torch.from_numpy(time_start)
 

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

@@ -1900,6 +1900,11 @@ 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)

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

@@ -22,6 +22,7 @@ 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
@@ -119,6 +120,7 @@ __all__ = [
     "Deep4Net",
     "DeepSleepNet",
     "DIVER1",
+    "DuIN",
     "BrainModule",
     "Brant",
     "EEGCLIP",

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

@@ -14,6 +14,7 @@ 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"):
@@ -77,7 +78,8 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
     .. rubric:: Temporal, Spatial, and Spectral Encoding
 
     - Temporal encoding uses non-overlapping patches and patch-index rotary
-      embeddings. Samples beyond the last complete patch are dropped.
+      embeddings. By default a trailing partial patch is right zero-padded;
+      ``on_non_divisible="crop"`` drops it, as the reference does.
     - 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.
@@ -94,7 +96,8 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
     Treebank's coordinate convention.
 
     With ``pooling="mean"``, channel counts and window lengths can vary between
-    batches, provided each window contains a full patch. Pass each recording's
+    batches (with ``on_non_divisible="crop"``, 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
@@ -141,9 +144,13 @@ 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). 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.
+        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``.
     d_model : int
         Token embedding dimension.
     n_layers : int
@@ -180,6 +187,9 @@ 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) ---
@@ -195,6 +205,7 @@ 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,
@@ -243,8 +254,7 @@ 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}.")
-        if self.n_times < patch_size:
-            raise ValueError("n_times must contain at least one full patch.")
+        _check_on_non_divisible(on_non_divisible)
         if d_model % num_heads:
             raise ValueError(
                 f"d_model ({d_model}) must be divisible by num_heads ({num_heads})."
@@ -258,6 +268,7 @@ 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
@@ -266,14 +277,15 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
         self.drop_prob = drop_prob
         self.activation = activation
 
-        # 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
+        # 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)
 
         self.patch_tokenizer = PatchTokenizer(
             patch_size=patch_size,
             n_times=self.n_times,
-            on_non_divisible="crop",
+            on_non_divisible=on_non_divisible,
             output_order="patch_channel",
         )
         # Every (patch, channel) pair is encoded independently, so the grid is

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

@@ -608,9 +608,24 @@ 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.
 
@@ -911,6 +926,9 @@ 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.dev181458649 → braindecode-1.8.1.dev181501004}/braindecode/models/brant.py

@@ -13,6 +13,7 @@ from einops.layers.torch import Rearrange, Reduce
 from braindecode.functional import spectral_input
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import PatchTokenizer
+from braindecode.modules.blocks import _check_on_non_divisible, _patch_count
 
 # Standard rhythmic-activity bands (Hz) used by Brant's frequency encoding,
 # from the paper (§ Frequency encoding): theta, alpha, beta, gamma1-5.
@@ -96,6 +97,8 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
     ``return_features=True`` returns ``cls_token=None``. The learned temporal
     positions require the runtime signal length to equal the configured
     ``n_times``, and the input must have the configured ``n_chans`` channels.
+    A window that is not a multiple of ``patch_size`` is right zero-padded to
+    ``ceil(n_times / patch_size)`` patches by default (``on_non_divisible``).
 
     The upstream model operates on signals down-sampled to **250 Hz**, but its
     band-power features are computed at a fixed 256 Hz (upstream
@@ -127,6 +130,11 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
     patch_size : int, optional
         Number of time samples per patch fed to the encoders. Default 250
         (1 s at 250 Hz). The paper's large architecture uses 1500 (see above).
+    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"``); both give the same
+        model and output when ``n_times`` is a multiple of ``patch_size``.
     embed_dim : int, optional
         Model width ``D`` (patch embedding size). Default 256.
     ffn_dim : int, optional
@@ -156,6 +164,9 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
        NeurIPS. Code: https://github.com/yzz673/Brant (Apache-2.0).
     """
 
+    # Configs and checkpoints saved before ``on_non_divisible`` existed cropped.
+    _legacy_on_non_divisible = "crop"
+
     def __init__(
         self,
         # braindecode parameters
@@ -168,6 +179,7 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
         *,
         # model-specific parameters
         patch_size: int = 250,
+        on_non_divisible: str = "pad",
         embed_dim: int = 256,
         ffn_dim: int = 384,
         temporal_n_layers: int = 4,
@@ -192,6 +204,7 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
         del n_outputs, n_chans, chs_info, n_times, input_window_seconds, sfreq
 
         self.patch_size = patch_size
+        self.on_non_divisible = on_non_divisible
         self.embed_dim = embed_dim
         self.ffn_dim = ffn_dim
         self.temporal_n_layers = temporal_n_layers
@@ -207,12 +220,10 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
             )
         # Number of patches per channel, fixed by the input length. The learnable
         # temporal positional encoding is sized to it, hence n_times is required.
-        self.seq_len = self.n_times // self.patch_size
-        if self.seq_len < 1:
-            raise ValueError(
-                f"n_times ({self.n_times}) must be >= patch_size "
-                f"({self.patch_size}) to form at least one patch."
-            )
+        # ceil for "pad", floor for "crop" (raises below one patch), exact for
+        # "error" (raises otherwise): the count the tokenizer produces.
+        _check_on_non_divisible(on_non_divisible)
+        self.seq_len = _patch_count(self.n_times, self.patch_size, on_non_divisible)
 
         # Shared non-overlapping patching (same tokenizer as the other
         # transformer foundation models); non-learnable, so it is a pure reshape
@@ -222,7 +233,7 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
             patch_size=self.patch_size,
             n_times=self.n_times,
             learnable=False,
-            on_non_divisible="crop",
+            on_non_divisible=on_non_divisible,
         )
         # braindecode-native: band-power computed inside forward (see module).
         self.band_power = _BandPowerFeatures(

{braindecode-1.8.1.dev181458649 → braindecode-1.8.1.dev181501004}/braindecode/models/codebrain.py

@@ -14,11 +14,15 @@ import torch.nn.functional as F
 from torch import nn
 from torch.nn.utils.parametrizations import weight_norm
 
-from braindecode.functional import spectral_input
+from braindecode.functional import _real_dft, spectral_input
 from braindecode.functional.functions import _next_fast_len
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules.attention import _hpu_lazy
 
+# Cache of one-sided DFT cosine/sine bases keyed by (device, n_fft): the TUEG
+# geometry reuses one basis for every block, forward and backward.
+_REAL_DFT_BASIS: Dict[Tuple[str, int], Tuple[torch.Tensor, torch.Tensor]] = {}
+
 
 class CodeBrain(EEGModuleMixin, nn.Module):
     r"""CodeBrain: Scalable Code EEG Pre-Training for Unified Downstream BCI Tasks.
@@ -528,16 +532,23 @@ class _GConv(nn.Module):
         # so any FFT length >= 2 * seq_len works: take a 5-smooth (fast) one.
         start = seq_len if self.bidirectional else 0
         n_fft = 2 * _next_fast_len(seq_len)
-        # kernel_freq: (channels, d_model, freq_bins)
-        # spectral_input(x) dtype: x's, at least float32 (the reference's .float()).
-        x_in = spectral_input(x)
-        kernel_freq = torch.fft.rfft(kernel.roll(start, -1).to(x_in), n=n_fft)
-        # x_freq: (batch, d_model, freq_bins)
-        x_freq = torch.fft.rfft(x_in, n=n_fft)
-        # out_freq: (batch, channels, d_model, freq_bins)
-        out_freq = torch.einsum("bhl,chl->bchl", x_freq, kernel_freq)
-        # out: (batch, channels, d_model, seq_len)
-        out = torch.fft.irfft(out_freq, n=n_fft)[..., start : start + seq_len].to(x)
+        if not torch.jit.is_scripting() and _real_dft.needs_real_dft(x):
+            # Intel Gaudi (HPU) has no complex tensors: the torch.fft path
+            # below is offloaded to the host (~120 ms/block/step in copies).
+            # The real-valued equivalent runs the DFT as MME matmuls on the
+            # device (~32 ms/block). CPU/CUDA keep the torch.fft path.
+            out = self._forward_real_dft(x, kernel, start, n_fft).to(x.dtype)
+        else:
+            # kernel_freq: (channels, d_model, freq_bins)
+            # spectral_input(x) dtype: x's, at least float32 (the reference's .float()).
+            x_in = spectral_input(x)
+            kernel_freq = torch.fft.rfft(kernel.roll(start, -1).to(x_in), n=n_fft)
+            # x_freq: (batch, d_model, freq_bins)
+            x_freq = torch.fft.rfft(x_in, n=n_fft)
+            # out_freq: (batch, channels, d_model, freq_bins)
+            out_freq = torch.einsum("bhl,chl->bchl", x_freq, kernel_freq)
+            # out: (batch, channels, d_model, seq_len)
+            out = torch.fft.irfft(out_freq, n=n_fft)[..., start : start + seq_len].to(x)
 
         # Skip connection via learnable D matrix
         # (batch, channels, d_model, seq_len)
@@ -562,6 +573,59 @@ class _GConv(nn.Module):
             return out, kernel
         return out, None
 
+    @torch.jit.unused
+    @_real_dft.fp32_island
+    def _forward_real_dft(self, x, kernel, start, n_fft):
+        # Real-valued equivalent of the torch.fft spectral section above, for
+        # devices without complex tensors (Intel Gaudi / HPU), in float32 with
+        # autocast disabled. The kernel is rolled to lags -L..L-1 exactly as
+        # above, so the bins match torch.fft.rfft(..., n=n_fft); the product
+        # is the complex multiplication as 4 real broadcast elementwise ops;
+        # the inverse is _real_dft.real_irfft and the [start:start+seq_len]
+        # read matches the torch path's window. ``torch.jit.unused`` keeps
+        # this branch out of the scripted graph: CPU/CUDA never take it, and
+        # HPU does not run under torch.jit.script. The cosine/sine basis is
+        # cached per (device, n_fft): one basis serves every block.
+        key = (str(x.device), n_fft)
+        basis = _REAL_DFT_BASIS.get(key)
+        if basis is None:
+            cosine, sine = _real_dft.real_dft_basis(
+                n_fft, device=x.device, dtype=torch.float32
+            )
+            basis = (cosine, sine)
+            _REAL_DFT_BASIS[key] = basis
+        cosine, sine = basis
+        seq_len = x.size(-1)
+        k_rolled = kernel.roll(start, -1)
+        # Re/Im of rfft(kernel, n=n_fft): pad/crop rows to n_fft, matmul.
+        # NOTE: after the bidirectional combine the kernel length is
+        # 2 * seq_len, not seq_len, so pad by its own length (torch.fft
+        # with n=n_fft pads/crops the same way).
+        k_len = k_rolled.size(-1)
+        if k_len < n_fft:
+            k_pad = F.pad(k_rolled.float(), (0, n_fft - k_len))
+        elif k_len > n_fft:
+            k_pad = k_rolled[..., :n_fft].float()
+        else:
+            k_pad = k_rolled.float()
+        k_re = k_pad @ cosine.transpose(0, 1)
+        k_im = -(k_pad @ sine.transpose(0, 1))
+        # Re/Im of rfft(x, n=n_fft) (x already padded below via the same op).
+        x_pad = F.pad(x.float(), (0, n_fft - seq_len))
+        x_re = x_pad @ cosine.transpose(0, 1)
+        x_im = -(x_pad @ sine.transpose(0, 1))
+        # Complex product as 4 real broadcast elementwise ops.
+        out_re = x_re.unsqueeze(1) * k_re.unsqueeze(0) - x_im.unsqueeze(
+            1
+        ) * k_im.unsqueeze(0)
+        out_im = x_re.unsqueeze(1) * k_im.unsqueeze(0) + x_im.unsqueeze(
+            1
+        ) * k_re.unsqueeze(0)
+        out = _real_dft.real_irfft(out_re, out_im, n=n_fft)[
+            ..., start : start + seq_len
+        ]
+        return out
+
 
 class _Conv(nn.Module):
     def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1):

{braindecode-1.8.1.dev181458649 → braindecode-1.8.1.dev181501004}/braindecode/models/csbrain.py

@@ -15,12 +15,12 @@ from typing import Dict, List, Optional, Tuple, Union
 
 import torch
 import torch.nn.functional as F
-from einops.layers.torch import Rearrange
 from torch import Tensor, nn
 
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.cbramod import _PatchEmbedding
 from braindecode.modules import FeedForwardBlock
+from braindecode.modules.blocks import PatchTokenizer, _patch_count
 
 log = logging.getLogger(__name__)
 
@@ -210,6 +210,9 @@ class CSBrain(EEGModuleMixin, nn.Module):
     ----------
     patch_size : int, default=200
         Temporal patch size in samples (200 samples = 1 second at 200 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).
     dim_feedforward : int, default=800
         Dimension of the feedforward network in the encoder layers.
     n_layer : int, default=12
@@ -292,6 +295,7 @@ class CSBrain(EEGModuleMixin, nn.Module):
         input_window_seconds=None,
         sfreq=None,
         patch_size: int = 200,
+        on_non_divisible: str = "pad",
         dim_feedforward: int = 800,
         n_layer: int = 12,
         nhead: int = 8,
@@ -314,16 +318,16 @@ class CSBrain(EEGModuleMixin, nn.Module):
             sfreq=sfreq,
         )
         del n_chans, chs_info, n_times, input_window_seconds, sfreq, n_outputs
-        n_times = self._n_times_or_none()
-        if n_times is not None and n_times % patch_size:
-            raise ValueError(
-                f"n_times ({n_times}) must be a multiple of patch_size ({patch_size})."
-            )
-
-        self.rearrange = Rearrange(
-            "batch n_chans (n_patch patch_size) -> batch n_chans n_patch patch_size",
+        try:
+            tokenizer_n_times = self.n_times
+        except ValueError:  # unknown length: nothing to check at construction
+            tokenizer_n_times = patch_size
+        self.rearrange = PatchTokenizer(
             patch_size=patch_size,
+            n_times=tokenizer_n_times,
+            on_non_divisible=on_non_divisible,
         )
+        self._on_non_divisible = on_non_divisible
         # CBraMod's patch encoder: conv stem + rFFT magnitude + depthwise-conv PE.
         # CBraMod creates the positional-encoding conv before the conv stem, so
         # build it with the RNG forked (CPU and the default device's generator
@@ -429,14 +433,23 @@ class CSBrain(EEGModuleMixin, nn.Module):
         except ValueError:
             return None
 
+    def _n_patch(self) -> int | None:
+        n_times = self._n_times_or_none()
+        if n_times is None:
+            return None
+        # ceil for "pad", floor for "crop" (raises below one patch): the count
+        # the tokenizer produces.
+        return _patch_count(n_times, self._patch_size, self._on_non_divisible)
+
     def _make_task_head(self) -> nn.Sequential:
         # Three-layer MLP head of the reference fine-tuning models: flatten
         # (chans, patches, emb_dim) -> n_patch * emb_dim -> emb_dim -> n_outputs.
         # n_chans / n_times may come from chs_info / input_window_seconds.
         # Without them the layers are lazy and the hidden width falls back to
         # 4 * emb_dim, the reference value for 4 s windows.
-        n_chans, n_times = self._n_chans_or_none(), self._n_times_or_none()
-        if n_times is None or n_chans is None:
+        n_chans = self._n_chans_or_none()
+        n_patch = self._n_patch()
+        if n_patch is None or n_chans is None:
             return nn.Sequential(
                 nn.Flatten(),
                 nn.LazyLinear(self._head_hidden_dim or 4 * self._emb_dim),
@@ -447,7 +460,6 @@ class CSBrain(EEGModuleMixin, nn.Module):
                 nn.Dropout(self._head_drop_prob),
                 nn.LazyLinear(self.n_outputs),
             )
-        n_patch = n_times // self._patch_size
         hidden = self._head_hidden_dim or n_patch * self._emb_dim
         return nn.Sequential(
             nn.Flatten(),