Braindecode 1.8.1.dev181543327__tar.gz → 1.8.1.dev181710643__tar.gz

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/NOTICE.txt

@@ -52,6 +52,7 @@ The following components are licensed under the MIT License:
 - `braindecode/modules/linear_attention.py`
 - `braindecode/models/seizure_transformer.py`
 - `docs/_static/model/seizure_transformer_arch.png`
+- `braindecode/models/guetschel2026.py`
 - `braindecode/models/tmsanet.py`
 
 The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose

{braindecode-1.8.1.dev181543327/braindecode.egg-info → braindecode-1.8.1.dev181710643}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev181543327
+Version: 1.8.1.dev181710643
 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.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/augmentation/functional.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)
 
@@ -931,7 +932,7 @@ def _rotate_signals(
         transformed_X = X.clone()
         sensors_positions = list(sensors_positions_matrix)
         for s, rot_sensors_matrix in enumerate(rot_sensors_matrices):
-            rot_sensors_positions = list(rot_sensors_matrix.T)
+            rot_sensors_positions = list(rot_sensors_matrix)
             for time in range(X.shape[-1]):
                 interpolator_t = Rbf(*sensors_positions, X[s, :, time])
                 transformed_X[s, :, time] = torch.from_numpy(
@@ -1093,7 +1094,8 @@ def segmentation_reconstruction(
     y : torch.Tensor
         EEG labels for the example or batch.
     n_segments : int
-        Number of segments to use in the batch.
+        Number of segments to use in the batch. Any remaining samples are
+        included in the last segment.
     data_classes : list[tuple[int, torch.Tensor]]
         List of tuples. Each tuple contains the class index and the corresponding EEG data.
     rand_indices : array-like
@@ -1133,6 +1135,8 @@ def segmentation_reconstruction(
         for idx_segment in range(n_segments):
             start = idx_segment * segment_size
             end = (idx_segment + 1) * segment_size
+            if idx_segment == n_segments - 1:
+                end = window_size
 
             # Perform the data augmentation
             X_aug[np.arange(n_trials), :, start:end] = X_class[

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/datasets/base.py

@@ -1742,7 +1742,10 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         # Create path if it doesn't exist
         os.makedirs(path, exist_ok=True)
 
-        path_contents = os.listdir(path)
+        # With an offset the caller fills one directory piece by piece (preprocess
+        # saves each recording at its index), so the other entries are expected:
+        # skip the scan that would stat them all on every call and list them in a warning.
+        path_contents = os.listdir(path) if offset == 0 else []
         n_sub_dirs = len(
             [e for e in path_contents if os.path.isdir(os.path.join(path, e))]
         )

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/datasets/tuh.py

@@ -11,10 +11,12 @@ TUH Abnormal EEG Corpus.
 from __future__ import annotations
 
 import glob
+import json
 import os
 import re
 import warnings
 from datetime import datetime, timezone
+from functools import cache
 from pathlib import Path
 from typing import Iterable, Literal
 from unittest import mock
@@ -183,11 +185,8 @@ class TUH(BaseConcatDataset):
         }
         raw.rename_channels(mapping_strip)
 
-        montage1005 = mne.channels.make_standard_montage(
-            resolve_montage_name("standard_1005")
-        )
         mapping_eeg_names = {
-            c.upper(): c for c in montage1005.ch_names if c.upper() in raw.ch_names
+            c.upper(): c for c in _standard_1005().ch_names if c.upper() in raw.ch_names
         }
 
         # Set channels whose type could not be inferred (defaulted to "eeg") to "misc":
@@ -210,10 +209,7 @@ class TUH(BaseConcatDataset):
 
     @staticmethod
     def _set_montage(raw):
-        montage = mne.channels.make_standard_montage(
-            resolve_montage_name("standard_1005")
-        )
-        raw.set_montage(montage, on_missing="ignore")
+        raw.set_montage(_standard_1005(), on_missing="ignore")
 
     @staticmethod
     def _create_dataset(
@@ -269,6 +265,12 @@ class TUH(BaseConcatDataset):
         return base_dataset
 
 
+@cache
+def _standard_1005():
+    # Built once per process: set_montage copies the montage before using it.
+    return mne.channels.make_standard_montage(resolve_montage_name("standard_1005"))
+
+
 def _create_description(file_paths, version, ds_name):
     descriptions = [
         _parse_description_from_file_path(f, version, ds_name) for f in file_paths
@@ -289,7 +291,8 @@ def _read_date(file_path):
     date_path = file_path.replace(".edf", "_date.txt")
     # if date file exists, read it
     if os.path.exists(date_path):
-        description = pd.read_json(date_path, typ="series").to_dict()
+        with open(date_path) as f:
+            description = json.load(f)
     # otherwise read edf file, extract date and store to file
     else:
         raw = mne.io.read_raw_edf(file_path, preload=False, verbose="error")

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/functional/__init__.py

@@ -3,11 +3,13 @@ from .functions import (
     daubechies_filters,
     drop_path,
     dwt_max_level,
+    fft_conv1d,
     hilbert_freq,
     identity,
     iou_1d,
     pairwise_iou_1d,
     plv_time,
+    prefer_fft_conv,
     rotate_pairs,
     safe_log,
     sinusoidal_positional_encoding,
@@ -22,11 +24,13 @@ __all__ = [
     "daubechies_filters",
     "drop_path",
     "dwt_max_level",
+    "fft_conv1d",
     "hilbert_freq",
     "identity",
     "iou_1d",
     "pairwise_iou_1d",
     "plv_time",
+    "prefer_fft_conv",
     "rotate_pairs",
     "safe_log",
     "sinusoidal_positional_encoding",

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/functional/functions.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import math
+from typing import Optional
 
 import numpy as np
 import torch
@@ -54,6 +55,95 @@ def spectral_input(x: torch.Tensor) -> torch.Tensor:
     return x.to(torch.promote_types(x.dtype, torch.float32))
 
 
+def fft_conv1d(
+    x: torch.Tensor, weight: torch.Tensor, bias: Optional[torch.Tensor] = None
+) -> torch.Tensor:
+    """``F.conv1d(x, weight, bias, padding="same")`` computed with FFTs.
+
+    Equal to the direct convolution up to float rounding: the FFT is long
+    enough for a linear (not circular) convolution. Its cost barely grows with
+    the kernel size, so it is faster than the direct one for long kernels on
+    CPU (see :func:`prefer_fft_conv`). float16/bfloat16 inputs are computed in
+    float32 (:func:`spectral_input`) and cast back.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Input of shape ``(batch, in_channels, n_times)``.
+    weight : torch.Tensor
+        Kernels of shape ``(out_channels, in_channels, kernel_size)``.
+    bias : torch.Tensor | None
+        Bias of shape ``(out_channels,)``.
+
+    Returns
+    -------
+    torch.Tensor
+        Output of shape ``(batch, out_channels, n_times)``, dtype and device of
+        ``x``. For an even ``kernel_size`` it is aligned like torch's
+        ``padding="same"`` (the extra zero padded on the right).
+    """
+    n_times, kernel_size = x.shape[-1], weight.shape[-1]
+    # >= n_times + kernel_size - 1 (no circular wrap-around), even and
+    # 5-smooth: the fast cases of a real FFT
+    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).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): [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]
+    if bias is not None:
+        y = y + bias.to(y).unsqueeze(-1)
+    return y.to(x)
+
+
+def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
+    """Whether :func:`fft_conv1d` is expected to beat a direct convolution.
+
+    Rule measured for :class:`~braindecode.models.EEGInceptionMI` (48 to 240
+    channels, 128-500 Hz, 2 CPU threads, oneDNN on and off): on CPU the FFT
+    wins for float16/bfloat16 inputs (no fast half-precision CPU convolution)
+    and from ``batch_size * kernel_size >= 600`` if also
+    ``in_channels * kernel_size >= 120``: with one or two input channels a
+    float32 direct convolution stays cheaper up to k = 85 / 31 (13 long
+    temporal convolutions of the model zoo, 22 channels x batch 32). GPUs and
+    HPUs (no complex dtype) keep the direct convolution.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Input of the convolution, ``(batch, in_channels, n_times)``.
+    kernel_size : int
+        Kernel length in samples.
+    """
+    return x.device.type == "cpu" and (
+        x.element_size() == 2
+        or (x.shape[0] * kernel_size >= 600 and x.shape[1] * kernel_size >= 120)
+    )
+
+
+def _next_fast_len(n: int) -> int:
+    """Smallest ``2^a 3^b 5^c >= n`` (scipy's ``next_fast_len(n, real=True)``)."""
+    n -= 1
+    m = 0
+    while m != 1:
+        n += 1
+        m = n
+        for p in [2, 3, 5]:
+            while m % p == 0:
+                m = m // p
+    return n
+
+
 def drop_path(
     x, drop_prob: float = 0.0, training: bool = False, scale_by_keep: bool = True
 ):
@@ -281,18 +371,24 @@ def plv_time(
     )
     # Normalize the analytic signal to obtain unit vectors (phasors).
     unit_phasor = analytic_signal / amplitude.unsqueeze(-1)
+    # The real/imaginary slices are strided (step 2): matmul copied each of
+    # them for every product, per batch matrix. Copy them once.
+    real = unit_phasor[..., 0].contiguous()
+    imag = unit_phasor[..., 1].contiguous()
+    real_t = real.transpose(-2, -1).contiguous()
+    imag_t = imag.transpose(-2, -1).contiguous()
 
     # Compute the real part of the outer product between phasors of
     # different channels.
-    real_real = torch.matmul(unit_phasor[..., 0], unit_phasor[..., 0].transpose(-2, -1))
+    real_real = torch.matmul(real, real_t)
 
     # Compute the imaginary part of the outer product between phasors of
     # different channels.
-    imag_imag = torch.matmul(unit_phasor[..., 1], unit_phasor[..., 1].transpose(-2, -1))
+    imag_imag = torch.matmul(imag, imag_t)
 
     # Compute the cross-terms for the real and imaginary parts.
-    real_imag = torch.matmul(unit_phasor[..., 0], unit_phasor[..., 1].transpose(-2, -1))
-    imag_real = torch.matmul(unit_phasor[..., 1], unit_phasor[..., 0].transpose(-2, -1))
+    real_imag = torch.matmul(real, imag_t)
+    imag_real = torch.matmul(imag, real_t)
 
     # Combine the real and imaginary parts to form the complex correlation.
     correlation_real = real_real + imag_imag

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/__init__.py

@@ -39,6 +39,7 @@ from .emg2qwerty import EMG2QwertyNet
 from .fbcnet import FBCNet
 from .fblightconvnet import FBLightConvNet
 from .fbmsnet import FBMSNet
+from .guetschel2026 import Guetschel2026
 from .hybrid import HybridNet
 from .ifnet import IFNet
 from .labram import Labram
@@ -139,6 +140,7 @@ __all__ = [
     "FBCNet",
     "FBLightConvNet",
     "FBMSNet",
+    "Guetschel2026",
     "MetaNeuromotorHand",
     "HybridNet",
     "IFNet",

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/attn_sleep.py

@@ -407,16 +407,12 @@ class _MRCNN(nn.Module):
 ##########################################################################################
 
 
-def _attention(
-    query: torch.Tensor, key: torch.Tensor, value: torch.Tensor
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Implementation of Scaled dot product attention."""
+def _attention(query: torch.Tensor, key: torch.Tensor) -> torch.Tensor:
+    """Scaled dot product attention weights."""
     # d_k - dimension of the query and key vectors
     d_k = query.size(-1)
     scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
-    p_attn = F.softmax(scores, dim=-1)  # attention weights
-    output = torch.matmul(p_attn, value)  # (B, h, T, d_k)
-    return output, p_attn
+    return F.softmax(scores, dim=-1)  # attention weights
 
 
 class _MultiHeadedAttention(nn.Module):
@@ -464,10 +460,8 @@ class _MultiHeadedAttention(nn.Module):
             .transpose(1, 2)
         )
 
-        x_raw, attn_weights = _attention(query, key, value)
-        # apply dropout to the *weights*
-        attn = self.dropout(attn_weights)
-        # recompute the weighted sum with dropped weights
+        # apply dropout to the *weights*, then the weighted sum
+        attn = self.dropout(_attention(query, key))
         x = torch.matmul(attn, value)
 
         # merge heads and project

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/axon.py

@@ -363,8 +363,11 @@ class _AXONEncoder(nn.Module):
         position = spatial.unsqueeze(1) + temporal.unsqueeze(0)  # (C, P, D)
         tokens = tokens + position.unsqueeze(0).to(tokens.dtype)
 
-        index = torch.arange(n_patches, device=tokens.device)
-        band = (index.unsqueeze(0) - index.unsqueeze(1)).abs() <= self.temporal_window
+        # Up to temporal_window + 1 patches the band covers every pair: no mask.
+        band: Optional[torch.Tensor] = None
+        if n_patches > self.temporal_window + 1:
+            index = torch.arange(n_patches, device=tokens.device)
+            band = (index[None] - index[:, None]).abs() <= self.temporal_window
 
         for block in self.blocks:
             tokens = block(tokens, band)
@@ -464,19 +467,23 @@ class _AxisAttention(nn.Module):
         )
         return attended.transpose(1, 2).reshape(n_seq, length, -1)
 
-    def forward(self, x: torch.Tensor, band: torch.Tensor) -> torch.Tensor:
+    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)
         scale_weights = self.scale_gate(x)  # (B, C, P, 2)
 
-        # Temporal path: one sequence of P tokens per electrode.
+        # Temporal path: one sequence of P tokens per electrode. Without a band
+        # 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))
         restricted = self.temporal_out(self._attend(per_channel, band)).reshape(
             batch, n_chans, n_patches, dim
         )
-        full = self.temporal_out(self._attend(per_channel, None)).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
+            )
         temporal = scale_weights[..., 0:1] * restricted + scale_weights[..., 1:2] * full
 
         # Spatial path: one sequence of C tokens per time step.
@@ -511,6 +518,6 @@ class _AXONBlock(nn.Module):
         self.norm_ffn = nn.RMSNorm(embed_dim, eps=1e-8)
         self.ffn = _GatedFeedForward(embed_dim, ffn_expansion)
 
-    def forward(self, x: torch.Tensor, band: torch.Tensor) -> torch.Tensor:
+    def forward(self, x: torch.Tensor, band: Optional[torch.Tensor]) -> torch.Tensor:
         x = x + self.attn(self.norm_attn(x), band)
         return x + self.ffn(self.norm_ffn(x))

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/biot.py

@@ -543,10 +543,15 @@ class _BIOTEncoder(nn.Module):
         emb: Tensor
             (batch_size, emb_size)
         """
+        batch_size, n_chans, n_times = x.shape
+        # One spectrogram for all channels, channel-major so that each
+        # channel's (batch, freq, ts) block is contiguous
+        spec = self.stft(x.transpose(0, 1).reshape(n_chans * batch_size, 1, n_times))
+        spec = spec.unflatten(0, [n_chans, batch_size])
         emb_seq = []
-        for i in range(x.shape[1]):
+        for i in range(n_chans):
             # Getting the spectrogram
-            channel_spec_emb = self.stft(x[:, i : i + 1, :])
+            channel_spec_emb = spec[i]
             # Linear layer to learn some representation over the frequency domain
             # with permutation
             channel_spec_emb = self.patch_embedding(channel_spec_emb)

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/brant.py

@@ -309,7 +309,7 @@ class Brant(EEGModuleMixin, nn.Module, license="apache-2.0"):
         time_z = self.temporal_encoder(tokens, power)
         # 4. spatial encoder over the channels of each patch
         time_z = self.split_time(time_z)  # (batch * seq_len, n_chans, embed_dim)
-        ch_z, _ = self.spatial_encoder(time_z)  # (batch * seq_len, n_chans, embed_dim)
+        ch_z = self.spatial_encoder(time_z)  # (batch * seq_len, n_chans, embed_dim)
         emb = self.merge_time(ch_z)  # (batch, n_chans, seq_len, embed_dim)
         # 5. pool over channels and patches, then classify
         pooled = self.pool(emb)  # (batch, embed_dim)
@@ -474,6 +474,7 @@ class _BrantSpatialEncoder(nn.Module):
         )
         self.trans_enc = nn.TransformerEncoder(encoder_layer, num_layers=n_layers)
 
-    def forward(self, time_z: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        ch_z = self.trans_enc(time_z)
-        return ch_z, self.proj_out(ch_z)
+    def forward(self, time_z: torch.Tensor) -> torch.Tensor:
+        # proj_out (the reconstruction head) is kept for checkpoints, not run:
+        # classification does not use its output.
+        return self.trans_enc(time_z)

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/codebrain.py

@@ -697,10 +697,35 @@ class _ResidualBlock(nn.Module):
         # Sliding-window attention branch
         # (batch, 2*res_channels, seq_len) -> (batch, seq_len, 2*res_channels)
         h_attn = h_ssm.transpose(1, 2)
-        swa_mask = self.generate_local_window_mask(
-            seq_len, self.swa_window_size, x.device, x.dtype
-        )
-        h_attn, _ = self.attention(h_attn, h_attn, h_attn, attn_mask=swa_mask)
+        if (
+            self.swa_window_size == 1
+            and not self.training
+            and not torch.is_grad_enabled()
+            and h_attn.device.type == "cpu"
+        ):
+            # A one-wide window keeps only the diagonal: the softmax weights are
+            # exactly 1 and 0, so the attention returns its value projection.
+            # Same projection calls as nn.MultiheadAttention (on its (seq,
+            # batch, embed) view), so the output is unchanged bit for bit. (In
+            # training the weights carry dropout; on Gaudi the full attention
+            # was faster.)
+            # ponytail: the unused query/key projections are computed too, to
+            # keep the rounding; in_proj_weight[2E:] alone is ~2x less GEMM.
+            embed_dim = self.attention.embed_dim
+            seq_first = h_attn.transpose(0, 1)
+            value = F.linear(
+                seq_first, self.attention.in_proj_weight, self.attention.in_proj_bias
+            )[..., 2 * embed_dim :]
+            h_attn = (
+                self.attention.out_proj(value.reshape(-1, embed_dim))
+                .view(seq_first.shape)
+                .transpose(0, 1)
+            )
+        else:
+            swa_mask = self.generate_local_window_mask(
+                seq_len, self.swa_window_size, x.device, x.dtype
+            )
+            h_attn, _ = self.attention(h_attn, h_attn, h_attn, attn_mask=swa_mask)
         # (batch, seq_len, 2*res_channels) -> (batch, 2*res_channels, seq_len)
         h_attn = h_attn.transpose(1, 2)
 

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/csbrain.py

@@ -710,8 +710,7 @@ class _CSBrainEncoderLayer(nn.Module):
         for start, stop in self.region_bounds:
             region_global = x[:, start:stop, :, :].mean(dim=1, keepdim=True)
             region_global = region_global.permute(0, 2, 1, 3).reshape(batch * T, 1, Fea)
-            for idx in range(start, stop):
-                global_features[:, idx : idx + 1, :] = region_global
+            global_features[:, start:stop, :] = region_global
         x_enhanced = x_flat + self.global_fc(global_features)
 
         attn_output = self.inter_region_attn(

{braindecode-1.8.1.dev181543327 → braindecode-1.8.1.dev181710643}/braindecode/models/eeginception_mi.py

@@ -7,7 +7,7 @@ import torch
 from einops.layers.torch import Rearrange
 from torch import nn
 
-from braindecode.functional import spectral_input
+from braindecode.functional import fft_conv1d, prefer_fft_conv
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import Ensure4d
 
@@ -57,11 +57,10 @@ class EEGInceptionMI(EEGModuleMixin, nn.Module):
         Activation function. Defaults to ReLU activation.
     fft_conv : bool | None, optional
         Compute the temporal convolutions of the inception modules with an FFT
-        (exact linear convolution, same parameters, equal up to float rounding)
-        instead of a direct convolution. ``None`` (default) uses the FFT on CPU
-        for float16/bfloat16 inputs or when ``batch_size * largest_kernel >= 600``
-        samples, where it was faster in CPU benchmarks, and the direct
-        convolution otherwise, including on GPU and HPU.
+        (:func:`~braindecode.functional.fft_conv1d`: same parameters, equal up
+        to float rounding) instead of a direct convolution. ``None`` (default)
+        decides per input with :func:`~braindecode.functional.prefer_fft_conv`
+        (FFT on CPU where it was faster in benchmarks, direct on GPU and HPU).
 
     References
     ----------
@@ -298,17 +297,13 @@ class _InceptionModuleMI(nn.Module):
             bias=True,
         )
 
-        # torch's "same" pads one extra zero on the right for even kernels; all
-        # kernels share kernel_unit's parity, so forward pads once for all convs.
-        self.pad_right = kernel_unit % 2 == 0
-        self.max_kernel = (2 * self.n_convs - 1) * kernel_unit
         self.conv_list = nn.ModuleList(
             [
                 nn.Conv2d(
                     in_channels=self.n_filters,
                     out_channels=self.n_filters,
                     kernel_size=(1, (n_units * 2 + 1) * kernel_unit),
-                    padding=(0, ((n_units * 2 + 1) * kernel_unit - 1) // 2),
+                    padding="same",
                     bias=True,
                 )
                 for n_units in range(self.n_convs)
@@ -324,100 +319,36 @@ class _InceptionModuleMI(nn.Module):
         X: torch.Tensor,
     ) -> torch.Tensor:
         X1 = self.bottleneck(X)
+        k_max = self.conv_list[-1].kernel_size[1]
         if self.fft_conv is None:
-            # Measured on CPU (2 threads, oneDNN on/off, eval/train): the FFT wins
-            # in half precision (11-113x) and from 600 samples of batch x kernel.
-            use_fft = X.device.type == "cpu" and (
-                X.element_size() == 2 or X.shape[0] * self.max_kernel >= 600
-            )
+            use_fft = prefer_fft_conv(X1, k_max)
         else:
             use_fft = self.fft_conv
         if use_fft:
-            branches = [self._conv_fft(X1)]
+            # The parallel convs as one: kernels zero-padded (centred) to the
+            # longest, stacked along the output channels.
+            weights, biases = [], []
+            for conv in self.conv_list:
+                pad = (k_max - conv.kernel_size[1]) // 2
+                weights.append(nn.functional.pad(conv.weight.squeeze(2), [pad, pad]))
+                bias = conv.bias
+                if bias is not None:
+                    biases.append(bias)
+            X1 = fft_conv1d(X1.squeeze(2), torch.cat(weights), torch.cat(biases))
+            X1 = X1.unsqueeze(2)
         else:
-            if self.pad_right:
-                X1 = nn.functional.pad(X1, (0, 1))
-            branches = [conv(X1) for conv in self.conv_list]
+            X1 = torch.cat([conv(X1) for conv in self.conv_list], 1)
 
-        # channels_last: same values and indices, but torch's CPU max pool
-        # vectorises over channels instead of looping over them.
+        # channels_last: same values, but torch's CPU max pool then vectorises
+        # over channels instead of looping over them.
         X2 = self.pooling(X.contiguous(memory_format=torch.channels_last))
-        X2 = self.pooling_conv(X2.contiguous())
-        # Get the target length from one of the conv branches
-        target_len = branches[0].shape[-1]
-
-        # Crop the pooling output if its length does not match
-        if X2.shape[-1] != target_len:
-            X2 = X2[..., :target_len]
-
-        out = torch.cat(branches + [X2], 1)
+        # An even kernel_unit pools n_times + 1 samples: drop the last one.
+        X2 = self.pooling_conv(X2.contiguous())[..., : X.shape[-1]]
 
+        out = torch.cat([X1, X2], 1)
         out = self.bn(out)
         return self.activation(out)
 
-    def _conv_fft(self, X: torch.Tensor) -> torch.Tensor:
-        """Every conv of ``conv_list`` through one rFFT, outputs concatenated.
-
-        Exact linear convolution (``n_fft >= n_times + k - 1``), aligned like
-        torch's "same" padding (for even ``k`` the extra zero is on the right).
-        """
-        xs = spectral_input(X.squeeze(2)).permute(2, 0, 1)  # (time, batch, in)
-        n_times, n_batch = xs.shape[0], xs.shape[1]
-        n_fft = _next_fast_len(n_times + self.max_kernel - 1)
-        # A conv layer is a cross-correlation, i.e. a convolution with the
-        # flipped kernel. Spectra are laid out (freq, in, out).
-        kernels = torch.cat(
-            [
-                torch.fft.rfft(
-                    conv.weight.squeeze(2).permute(2, 1, 0).flip(0).to(xs),
-                    n=n_fft,
-                    dim=0,
-                )
-                for conv in self.conv_list
-            ],
-            dim=2,
-        )
-        spec = torch.fft.rfft(xs, n=n_fft, dim=0)  # (freq, batch, in)
-        # Complex matmul as one real bmm ([re; im] rows times interleaved re/im
-        # columns): torch's CPU complex bmm loops over the frequencies.
-        prod = torch.bmm(
-            torch.cat([torch.real(spec), torch.imag(spec)], 1),
-            torch.view_as_real(kernels).flatten(2),
-        )
-        prod = prod.unflatten(1, [2, n_batch]).unflatten(3, [-1, 2])
-        spec = torch.complex(
-            prod[:, 0, :, :, 0] - prod[:, 1, :, :, 1],
-            prod[:, 0, :, :, 1] + prod[:, 1, :, :, 0],
-        )
-        full = torch.fft.irfft(spec, n=n_fft, dim=0)  # (time, batch, out)
-        out = []
-        start = 0
-        for conv in self.conv_list:
-            # "same" output t of a size-k kernel is sample t + k // 2 of the full one
-            k = conv.kernel_size[1]
-            branch = full[
-                k // 2 : k // 2 + n_times, :, start : start + conv.out_channels
-            ]
-            bias = conv.bias
-            if bias is not None:
-                branch = branch + bias.to(xs)
-            out.append(branch)
-            start += conv.out_channels
-        return torch.cat(out, 2).permute(1, 2, 0).unsqueeze(2).to(X)
-
-
-def _next_fast_len(n: int) -> int:
-    """Smallest ``2^a 3^b 5^c >= n`` (scipy's ``next_fast_len(n, real=True)``)."""
-    n -= 1
-    m = 0
-    while m != 1:
-        n += 1
-        m = n
-        for p in [2, 3, 5]:
-            while m % p == 0:
-                m = m // p
-    return n
-
 
 class _ResidualModuleMI(nn.Module):
     r"""