braindecode 1.8.1.dev177939635__tar.gz → 1.8.1.dev178224482__tar.gz

{braindecode-1.8.1.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635/braindecode.egg-info → braindecode-1.8.1.dev178224482}/PKG-INFO

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

@@ -932,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(

{braindecode-1.8.1.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/braindecode/functional/functions.py

@@ -112,8 +112,11 @@ def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
     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``. GPUs and HPUs (no complex
-    dtype) keep the direct 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
     ----------
@@ -123,7 +126,8 @@ def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
         Kernel length in samples.
     """
     return x.device.type == "cpu" and (
-        x.element_size() == 2 or x.shape[0] * kernel_size >= 600
+        x.element_size() == 2
+        or (x.shape[0] * kernel_size >= 600 and x.shape[1] * kernel_size >= 120)
     )
 
 

{braindecode-1.8.1.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/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.dev177939635 → braindecode-1.8.1.dev178224482}/braindecode/models/eegsym.py

@@ -441,6 +441,22 @@ class _AvgPoolTime(nn.Module):
         return y.reshape(b, c, d, y.shape[2], s)
 
 
+class _SpatialConv3d(nn.Conv3d):
+    """``nn.Conv3d`` with a ``(1, 1, k)`` kernel run as ``conv2d`` on the
+    ``(batch, ch, z * time, space)`` view; same parameters. The depthwise
+    ``conv3d`` backward segfaults on Gaudi (synapse 1.21)."""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        b, c, z, t, s = x.shape
+        y = nn.functional.conv2d(
+            x.reshape(b, c, z * t, s),
+            self.weight.squeeze(2),
+            self.bias,
+            groups=self.groups,
+        )
+        return y.reshape(b, -1, z, t, y.shape[-1])
+
+
 class _InceptionBlock(nn.Module):
     r"""Inception module used in EEGSym architecture.
 
@@ -500,7 +516,7 @@ class _InceptionBlock(nn.Module):
             for _ in range(spatial_resnet_repetitions):
                 self.spatial_convs.append(
                     nn.Sequential(
-                        nn.Conv3d(
+                        _SpatialConv3d(
                             in_channels=filters_per_branch * len(scales_samples),
                             out_channels=filters_per_branch * len(scales_samples),
                             kernel_size=(1, 1, ncha),