braindecode 1.8.1.dev178155531__tar.gz → 1.8.1.dev178237886__tar.gz

{braindecode-1.8.1.dev178155531 → braindecode-1.8.1.dev178237886}/NOTICE.txt

@@ -49,6 +49,7 @@ The following components are licensed under the MIT License:
 - `braindecode/modules/popt_modules.py`
 - `braindecode/models/brainomni.py`
 - `braindecode/modules/quantization.py`
+- `braindecode/modules/linear_attention.py`
 - `braindecode/models/seizure_transformer.py`
 - `docs/_static/model/seizure_transformer_arch.png`
 - `braindecode/models/tmsanet.py`
@@ -57,6 +58,8 @@ The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
 SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The
 `quantization.py` module holds the residual vector quantization derived from
 `lucidrains/vector-quantize-pytorch` (MIT) and the BrainOmni port.
+The `linear_attention.py` module is the part of
+`lucidrains/linear-attention-transformer` (MIT) that BIOT and TFMTokenizer run.
 
 ### Apache-2.0 Licensed Files
 

{braindecode-1.8.1.dev178155531/braindecode.egg-info → braindecode-1.8.1.dev178237886}/PKG-INFO

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

@@ -23,6 +23,7 @@ from .transforms import (
     SignFlip,
     SmoothTimeMask,
     TimeReverse,
+    TrivialAugment,
 )
 
 __all__ = [
@@ -30,6 +31,7 @@ __all__ = [
     "IdentityTransform",
     "Compose",
     "AugmentedDataLoader",
+    "TrivialAugment",
     "TimeReverse",
     "SignFlip",
     "FTSurrogate",

{braindecode-1.8.1.dev178155531 → braindecode-1.8.1.dev178237886}/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)
 
@@ -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.dev178155531 → braindecode-1.8.1.dev178237886}/braindecode/augmentation/transforms.py

@@ -1457,3 +1457,188 @@ class BandRotation(Transform):
             "circular_jitter": self.circular_jitter,
             "random_state": self.rng,
         }
+
+
+class TrivialAugment(Transform):
+    """Apply one randomly sampled label-preserving augmentation per example.
+
+    For every example, independently samples one transform from the pool
+    below and one of ``num_bins`` strengths evenly spaced between that
+    transform's bounds, as in TrivialAugment [1]_. Examples that draw the
+    same transform and strength are transformed in one call; each pooled
+    transform still draws its own randomness per example.
+
+    Default pool (no assumption on the signal's unit, sampling frequency or
+    montage):
+
+    * :class:`TimeReverse` — no strength parameter.
+    * :class:`SignFlip` — no strength parameter.
+    * :class:`FTSurrogate` — phase noise magnitude, 0.2 to 1.
+    * :class:`ChannelsDropout` — channel drop probability, 0.05 to 0.4.
+    * :class:`ChannelsShuffle` — shuffle probability, 0.1 to 0.75.
+    * :class:`SmoothTimeMask` — mask length as a fraction of the window
+      length, 0.05 to 0.25.
+    * :class:`GaussianNoise` — noise standard deviation as a fraction of the
+      sub-batch standard deviation (volts or microvolts alike), 0.02 to 0.3.
+    * :class:`AmplitudeScale` — scale interval ``(1/s, s)``, ``s`` from 1.25
+      to 2.5.
+
+    ``sfreq`` adds :class:`BandstopFilter` (bandwidth 0.5 to 4 Hz, capped
+    2.5 Hz below Nyquist) and :class:`FrequencyShift` (maximum shift 0.5 to
+    2 Hz); ``sensors_positions_matrix`` adds :class:`SensorsRotation` around
+    the z axis (5 to 25 degrees).
+
+    Parameters
+    ----------
+    probability : float, optional
+        Probability of augmenting each example. Defaults to 1.0.
+    sfreq : float | None, optional
+        Sampling frequency of the signals, in Hz. Defaults to None.
+    sensors_positions_matrix : array-like | None, optional
+        Sensor positions of shape ``(3, n_channels)`` (see
+        :class:`SensorsRotation`). Defaults to None.
+    num_bins : int, optional
+        Number of strength levels per transform. Defaults to 10.
+    random_state : int | numpy.random.RandomState, optional
+        Seed shared by the per-example sampler and every pooled transform.
+        Defaults to None.
+
+    Attributes
+    ----------
+    op_names : list of str
+        Names of the transforms in the pool, in sampling order.
+
+    References
+    ----------
+    .. [1] Müller, S. G., & Hutter, F. (2021). TrivialAugment:
+       Tuning-free Yet State-of-the-Art Data Augmentation. Proceedings of
+       the IEEE/CVF International Conference on Computer Vision (ICCV),
+       pp. 774-782.
+    """
+
+    def __init__(
+        self,
+        probability=1.0,
+        sfreq=None,
+        sensors_positions_matrix=None,
+        num_bins=10,
+        random_state=None,
+    ):
+        super().__init__(probability=probability, random_state=random_state)
+        if not isinstance(num_bins, (int, np.integer)) or num_bins < 1:
+            raise ValueError(f"num_bins must be a positive integer, got {num_bins}")
+        self.num_bins = int(num_bins)
+        rng = self.rng
+        # (name, strength bounds or None, make(strength) or None: built per call)
+        specs = [
+            ("TimeReverse", None, lambda s: TimeReverse(1.0, random_state=rng)),
+            ("SignFlip", None, lambda s: SignFlip(1.0, random_state=rng)),
+            (
+                "FTSurrogate",
+                (0.2, 1.0),
+                lambda s: FTSurrogate(1.0, phase_noise_magnitude=s, random_state=rng),
+            ),
+            (
+                "ChannelsDropout",
+                (0.05, 0.4),
+                lambda s: ChannelsDropout(1.0, p_drop=s, random_state=rng),
+            ),
+            (
+                "ChannelsShuffle",
+                (0.1, 0.75),
+                lambda s: ChannelsShuffle(1.0, p_shuffle=s, random_state=rng),
+            ),
+            ("SmoothTimeMask", (0.05, 0.25), None),
+            ("GaussianNoise", (0.02, 0.3), None),
+            (
+                "AmplitudeScale",
+                (1.25, 2.5),
+                lambda s: AmplitudeScale(1.0, interval=(1.0 / s, s), random_state=rng),
+            ),
+        ]
+        if sfreq is not None:
+            nyquist = sfreq / 2.0
+            # BandstopFilter needs bandwidth < nyquist - 2; keep a margin
+            max_bandwidth = min(4.0, nyquist - 2.5)
+            if max_bandwidth <= 0.5:
+                raise ValueError(
+                    f"sfreq={sfreq} is too small to sample valid band-stop "
+                    "bandwidths (needs at least 6.0 Hz)."
+                )
+            specs += [
+                (
+                    "BandstopFilter",
+                    (0.5, max_bandwidth),
+                    lambda s: BandstopFilter(
+                        1.0,
+                        sfreq=sfreq,
+                        bandwidth=s,
+                        max_freq=nyquist,
+                        random_state=rng,
+                    ),
+                ),
+                (
+                    "FrequencyShift",
+                    (0.5, 2.0),
+                    lambda s: FrequencyShift(
+                        1.0, sfreq=sfreq, max_delta_freq=s, random_state=rng
+                    ),
+                ),
+            ]
+        if sensors_positions_matrix is not None:
+            specs.append(
+                (
+                    "SensorsRotation",
+                    (5.0, 25.0),
+                    lambda s: SensorsRotation(
+                        1.0,
+                        sensors_positions_matrix=sensors_positions_matrix,
+                        max_degrees=s,
+                        random_state=rng,
+                    ),
+                )
+            )
+
+        self._pool = []
+        for name, bounds, make in specs:
+            if bounds is None:
+                strengths = [None]
+            else:
+                strengths = np.linspace(*bounds, self.num_bins).tolist()
+            variants = None if make is None else [make(s) for s in strengths]
+            self._pool.append((name, strengths, variants))
+        # pre-built transforms as submodules (pickle, ``.to()``)
+        self._static_transforms = torch.nn.ModuleList(
+            v for _, _, variants in self._pool if variants for v in variants
+        )
+        self.op_names = [name for name, _, _ in self._pool]
+
+    def operation(self, X, y):
+        """Apply one sampled transform and strength to each example of X."""
+        n_strengths = np.array([len(strengths) for _, strengths, _ in self._pool])
+        op_ids = self.rng.randint(0, len(self._pool), size=X.shape[0])
+        bin_ids = self.rng.randint(0, self.num_bins, size=X.shape[0])
+        # magnitude-free transforms collapse all examples onto bin 0
+        bin_ids[n_strengths[op_ids] == 1] = 0
+        keys = op_ids * self.num_bins + bin_ids
+
+        out_X, out_y = X.clone(), y.clone()
+        for key in np.unique(keys):
+            group = torch.from_numpy(np.flatnonzero(keys == key)).to(X.device)
+            op_i, bin_j = divmod(int(key), self.num_bins)
+            name, strengths, variants = self._pool[op_i]
+            X_sub = X[group]
+            if variants is not None:
+                transform = variants[bin_j]
+            elif name == "SmoothTimeMask":
+                n_mask = max(1, int(round(strengths[bin_j] * X.shape[-1])))
+                transform = SmoothTimeMask(
+                    1.0, mask_len_samples=n_mask, random_state=self.rng
+                )
+            else:  # GaussianNoise, std relative to the sub-batch (unit-free)
+                std = strengths[bin_j] * X_sub.std().item()
+                transform = GaussianNoise(1.0, std=std, random_state=self.rng)
+            tr_X, tr_y = transform(X_sub, y[group])
+            out_X[group] = tr_X.to(out_X.dtype)
+            out_y[group] = tr_y
+        return out_X, out_y

{braindecode-1.8.1.dev178155531 → braindecode-1.8.1.dev178237886}/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.dev178155531 → braindecode-1.8.1.dev178237886}/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
 ):
@@ -197,6 +287,7 @@ def hilbert_freq(x: torch.Tensor, forward_fourier: bool = True) -> torch.Tensor:
         return _real_dft.hilbert_freq_real(x, forward_fourier).to(x.dtype)
 
     input_dtype = x.dtype
+    cast_back = x.is_floating_point()
     # ``view_as_complex`` does not accept bfloat16 real/imaginary pairs.  The
     # HPU path can produce bfloat16 Fourier coefficients under autocast, so do
     # the complex-valued part in float32 and restore the real-valued contract
@@ -224,9 +315,8 @@ def hilbert_freq(x: torch.Tensor, forward_fourier: bool = True) -> torch.Tensor:
     x = torch.fft.ifft(x, norm=None, dim=-1)  # returns complex signal
     x = torch.view_as_real(x)
 
-    if input_dtype == torch.bfloat16:
-        x = x.to(input_dtype)
-    return x
+    # Integer input stays float (casting back would truncate the analytic signal).
+    return x.to(input_dtype) if cast_back else x
 
 
 def plv_time(
@@ -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
@@ -412,7 +508,14 @@ def dwt_max_level(n_times: int, filter_len: int) -> int:
     """
     if n_times < filter_len:
         return 0
-    return max(0, int(math.floor(math.log2(n_times / (filter_len - 1)))))
+    # floor(log2(n_times / (filter_len - 1))) in integers (TorchScript has no
+    # math.log2): the largest level with (filter_len - 1) * 2**level <= n_times.
+    ratio = n_times // (filter_len - 1)
+    level = 0
+    while ratio >= 2:
+        ratio = ratio // 2
+        level += 1
+    return level
 
 
 def wavelet_decomposition(
@@ -456,8 +559,9 @@ def wavelet_decomposition(
         )
         approx, detail = F.conv1d(padded, weight, stride=2).unbind(dim=1)
         details.append(detail)
-    out = torch.cat([approx, *reversed(details)], dim=-1)
-    return out.reshape(*leading, -1)
+    details.reverse()  # [cD_n, ..., cD_1]
+    out = torch.cat([approx] + details, dim=-1)
+    return out.reshape(list(leading) + [-1])
 
 
 def sinusoidal_positional_encoding(

{braindecode-1.8.1.dev178155531 → braindecode-1.8.1.dev178237886}/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.dev178155531 → braindecode-1.8.1.dev178237886}/braindecode/models/base.py

@@ -26,6 +26,7 @@ from braindecode.models.util import (
     track_model_init_kwargs,
 )
 from braindecode.modules.channels import ChannelLayer
+from braindecode.modules.parametrization import make_parametrizations_scriptable
 from braindecode.version import __version__
 
 huggingface_hub = _soft_import(
@@ -431,7 +432,7 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
             and self._input_window_seconds is not None
             and self._sfreq is not None
         ):
-            return round(self._input_window_seconds * self._sfreq)
+            return int(round(self._input_window_seconds * self._sfreq))
         elif self._n_times is None:
             raise ValueError(
                 "n_times could not be inferred. "
@@ -452,6 +453,8 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                 "input_window_seconds could not be inferred. "
                 "Either specify input_window_seconds or n_times and sfreq."
             )
+        if torch.jit.is_scripting():  # may be an int, e.g. from a Hub config
+            return float(self._input_window_seconds)
         return self._input_window_seconds
 
     @property
@@ -467,6 +470,8 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                 "sfreq could not be inferred. "
                 "Either specify sfreq or input_window_seconds and n_times."
             )
+        if torch.jit.is_scripting():  # may be an int, e.g. from a Hub config
+            return float(self._sfreq)
         return self._sfreq
 
     @property
@@ -474,6 +479,10 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         """Input data shape."""
         return (1, self.n_chans, self.n_times)
 
+    def __prepare_scriptable__(self):
+        # Called by torch.jit.script before compiling the model.
+        return make_parametrizations_scriptable(self)
+
     def get_output_shape(self) -> tuple[int, ...]:
         """Returns shape of neural network output for batch size equal 1.
 

{braindecode-1.8.1.dev178155531 → braindecode-1.8.1.dev178237886}/braindecode/models/bendr.py

@@ -4,6 +4,7 @@
 # License: BSD (3-clause)
 
 import copy
+from typing import Dict, Optional, Union
 
 import numpy as np
 import torch
@@ -364,7 +365,9 @@ class BENDR(EEGModuleMixin, nn.Module):
         self._update_init_kwargs(final_layer=True)
         self._build_head(n_outputs)
 
-    def forward(self, x, return_features=False):
+    def forward(
+        self, x: torch.Tensor, return_features: bool = False
+    ) -> Union[torch.Tensor, Dict[str, Optional[torch.Tensor]]]:
         if self.channel_tokenizer is not None:
             x = self.channel_tokenizer(x)[0]
         encoded = self.encoder(x)
@@ -394,7 +397,11 @@ class BENDR(EEGModuleMixin, nn.Module):
             # feature: [batch_size, encoder_h]
 
         if return_features:
-            return {"features": feature, "cls_token": None}
+            out: Dict[str, Optional[torch.Tensor]] = {
+                "features": feature,
+                "cls_token": None,
+            }
+            return out
 
         if self.final_layer is not None:
             feature = self.final_layer(feature)
@@ -468,6 +475,23 @@ class _ConvEncoderBENDR(nn.Module):
         return self.encoder(x)
 
 
+class _TFixupEncoderLayer(nn.TransformerEncoderLayer):
+    """Post-norm layer without the fast path (never taken: ``batch_first=False``),
+    which reads ``norm1.weight``, an Identity under T-Fixup, and cannot be scripted."""
+
+    def forward(
+        self,
+        src: torch.Tensor,
+        src_mask: Optional[torch.Tensor] = None,
+        src_key_padding_mask: Optional[torch.Tensor] = None,
+        is_causal: bool = False,
+    ) -> torch.Tensor:
+        x = self.norm1(
+            src + self._sa_block(src, src_mask, src_key_padding_mask, is_causal)
+        )
+        return self.norm2(x + self._ff_block(x))
+
+
 class _BENDRContextualizer(nn.Module):
     r"""Transformer-based contextualizer for BENDR."""
 
@@ -526,7 +550,7 @@ class _BENDRContextualizer(nn.Module):
         # --- Transformer Encoder Layers ---
         # Paper uses T-Fixup: remove internal LayerNorm layers
 
-        encoder_layer = nn.TransformerEncoderLayer(
+        encoder_layer = _TFixupEncoderLayer(
             d_model=self.transformer_dim,  # Use projected dimension
             nhead=heads,
             dim_feedforward=hidden_feedforward,
@@ -588,7 +612,6 @@ class _BENDRContextualizer(nn.Module):
                 float(self.start_token),
                 device=x.device,
                 dtype=x.dtype,
-                requires_grad=False,
             )
             x = torch.cat([token_emb, x], dim=0)
         # x: [seq_len + 1, batch_size, transformer_dim]
@@ -604,7 +627,7 @@ class _BENDRContextualizer(nn.Module):
         # x: [seq_len + 1, batch_size, transformer_dim]
 
         # Permute to (B, C, T) format for Conv1d output layer
-        x = Rearrange("time batch channel -> batch channel time")(x)
+        x = x.permute(1, 2, 0)
         # x: [batch_size, transformer_dim, seq_len + 1]
 
         # Apply output projection (Conv1d expects B, C, T)