braindecode 1.8.1.dev182727546__tar.gz → 1.8.1.dev183301946__tar.gz

{braindecode-1.8.1.dev182727546 → braindecode-1.8.1.dev183301946}/NOTICE.txt

@@ -49,14 +49,18 @@ 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/guetschel2026.py`
 - `braindecode/models/tmsanet.py`
 
 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.dev182727546/braindecode.egg-info → braindecode-1.8.1.dev183301946}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev182727546
+Version: 1.8.1.dev183301946
 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.dev182727546 → braindecode-1.8.1.dev183301946}/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.dev182727546 → braindecode-1.8.1.dev183301946}/braindecode/datasets/base.py

@@ -14,13 +14,16 @@ from __future__ import annotations
 import bisect
 import html as _html
 import json
+import mmap
 import os
 import shutil
 import warnings
 from abc import abstractmethod
 from collections import Counter
-from collections.abc import Callable, Hashable
+from collections.abc import Callable, Hashable, Sequence
 from glob import glob
+from itertools import chain
+from operator import attrgetter
 from pathlib import Path
 from typing import Any, Generic, Iterable, no_type_check
 
@@ -28,6 +31,7 @@ import mne
 import mne.io
 import numpy as np
 import pandas as pd
+from mne.io.constants import FIFF
 from mne.utils import _soft_import
 from mne.utils.docs import deprecated
 from torch.utils.data import ConcatDataset, Dataset, IterableDataset
@@ -220,6 +224,109 @@ def _compute_ch_pos(info, targets_from):
     return pos
 
 
+_TAG_ROW = attrgetter("kind", "type", "size", "next", "pos")
+
+
+def _tag_rows(tags):
+    """(kind, type, size, next, pos) of FIF tags as an int64 array (n, 5)."""
+    flat = chain.from_iterable(map(_TAG_ROW, tags))
+    return np.fromiter(flat, np.int64, 5 * len(tags)).reshape(-1, 5)
+
+
+class _FifTagTable(Sequence):
+    """The data-buffer tags of a lazy FIF raw as one int64 array.
+
+    mne's FIF reader keeps one ``Tag`` object per data buffer in
+    ``raw._raw_extras[i]["ent"]`` (one per second of signal with mne's default
+    buffers), each with its attribute dict and integers once unpickled. A lazy
+    dataset of many recordings holds millions of them in RAM, and every forked
+    DataLoader worker copies the memory pages of those it reads (reference
+    counts). This holds the same fields in 40 bytes per buffer and returns an
+    equal ``Tag`` on access, so mne's own reads are unchanged.
+    """
+
+    def __init__(self, tags):
+        self.tag_class = type(tags[0])
+        self.table = _tag_rows(tags)
+
+    def __len__(self):
+        return len(self.table)
+
+    def __getitem__(self, i):
+        if isinstance(i, slice):
+            return [self.tag_class(*row) for row in self.table[i].tolist()]
+        return self.tag_class(*self.table[i].tolist())
+
+
+_TAG_FIELDS = ("kind", "type", "size", "next", "pos", "data")
+
+
+def _compact_fif_tags(inst):
+    """Swap the ``Tag`` lists of a FIF raw for `_FifTagTable` (in place).
+
+    Only gap-free lists of directory tags (no ``None``, no ``data``) with mne's
+    ``Tag`` fields are swapped; anything else is left as mne built it.
+    """
+    for extra in getattr(inst, "_raw_extras", ()):
+        tags = extra.get("ent")
+        if not isinstance(tags, list) or not tags:
+            continue
+        cls = type(tags[0])
+        if tuple(getattr(cls, "__dataclass_fields__", ())) == _TAG_FIELDS and all(
+            type(t) is cls and t.data is None for t in tags
+        ):
+            extra["ent"] = _FifTagTable(tags)
+    return inst
+
+
+def _read_fif_window(raw, start, stop):
+    """Samples ``start:stop`` of a lazy FIF raw, copied from the file in one go.
+
+    mne reads, casts and calibrates the FIF data buffers of a range one at a
+    time (60 Python steps for a 60-s window saved with 1-s buffers, each through
+    a buffered file whose buffer is 4 MB on network file systems). Here one
+    slice of the memory-mapped file holds the bytes of every buffer in the
+    range and one multiply calibrates them, with mne's arithmetic (float64 data
+    times ``raw._cals``), so the values equal ``raw._getitem``'s. Returns None
+    (the caller uses mne) unless ``raw`` is a lazy, single-file, uncompressed
+    FIF raw of float32 buffers without projector, compensation or gaps.
+    """
+    if (
+        not isinstance(raw, mne.io.Raw)
+        or raw.preload
+        or len(raw._raw_extras) != 1
+        or raw._projector is not None
+        or raw._comp is not None
+    ):
+        return None
+    extra = raw._raw_extras[0]
+    fname, bounds = extra["filename"], extra["bounds"]
+    if not isinstance(fname, Path) or fname.suffix == ".gz":
+        return None
+    start, stop = start + raw._first_samps[0], stop + raw._first_samps[0]
+    first = np.searchsorted(bounds, start, side="right") - 1
+    tags = extra["ent"]
+    if isinstance(tags, _FifTagTable):
+        rows = tags.table[first : np.searchsorted(bounds, stop)]
+    else:
+        tags = tags[first : np.searchsorted(bounds, stop)]
+        if any(t is None for t in tags):
+            return None
+        rows = _tag_rows(tags)
+    if not len(rows) or (rows[:, 1] != FIFF.FIFFT_FLOAT).any():
+        return None
+    size, pos = rows[:, 2].tolist(), rows[:, 4].tolist()
+    # mmap: no copy through a 4 MB read buffer, and a cold file is read around
+    # the window by the kernel (as mne's 4 MB reads did), not window by window
+    with open(fname, "rb") as f, mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as m:
+        buf = m[pos[0] : pos[-1] + 16 + size[-1]]
+    one = np.concatenate(
+        [np.frombuffer(buf, ">f4", s // 4, p + 16 - pos[0]) for s, p in zip(size, pos)]
+    ).reshape(-1, extra["orig_nchan"])[start - bounds[first] : stop - bounds[first]]
+    picked = one[:, raw._read_picks[0]].T
+    return np.multiply(picked, raw._cals[:, np.newaxis], order="C")
+
+
 def _window_info(crop_inds, sfreq):
     """Extract window size from crop indices.
 
@@ -823,9 +930,11 @@ class EEGWindowsDataset(_ZarrMixin, RecordDataset):
         if self._zarr_data is not None:
             X = self._zarr_data[:, i_start:i_stop]
         else:
-            X = self.raw._getitem(
-                (slice(None), slice(i_start, i_stop)), return_times=False
-            )
+            X = _read_fif_window(self.raw, i_start, i_stop)
+            if X is None:
+                X = self.raw._getitem(
+                    (slice(None), slice(i_start, i_stop)), return_times=False
+                )
         X = np.array(X, dtype="float32")
         if self.transform is not None:
             X = self.transform(X)
@@ -1672,7 +1781,8 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 kwargs_path = os.path.join(path, ".".join([kwarg_name, "json"]))
                 kwargs = getattr(self, kwarg_name)
                 if kwargs is not None:
-                    json.dump(kwargs, open(kwargs_path, "w"))
+                    with open(kwargs_path, "w") as f:
+                        json.dump(kwargs, f)
 
     @property
     def description(self) -> pd.DataFrame:
@@ -1742,7 +1852,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.dev182727546 → braindecode-1.8.1.dev183301946}/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(
@@ -245,7 +241,11 @@ class TUH(BaseConcatDataset):
         # file paths, use this instead as before
         if "year" in description:
             meas_date = meas_date.replace(*description[["year", "month", "day"]])
-        raw.set_meas_date(meas_date)
+        # FIF (e.g. preprocess(..., save_dir=...)) stores dates from 1901-12-13 to
+        # 2038-01-19 only: undated recordings (year 1 above) and de-identified ones
+        # (TUAB has 1899-12-30) keep their date in the description only.
+        in_fif_range = -(2**31) <= meas_date.timestamp() < 2**31
+        raw.set_meas_date(meas_date if in_fif_range else None)
 
         d = {
             "age": int(age),
@@ -255,9 +255,9 @@ class TUH(BaseConcatDataset):
         # if not, get it from meas_date in raw.info and add to description
         # if meas_date is None, create fake one
         if "year" not in description:
-            d["year"] = raw.info["meas_date"].year
-            d["month"] = raw.info["meas_date"].month
-            d["day"] = raw.info["meas_date"].day
+            d["year"] = meas_date.year
+            d["month"] = meas_date.month
+            d["day"] = meas_date.day
 
         # read info relevant for preprocessing from raw without loading it
         if add_physician_reports:
@@ -269,6 +269,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 +295,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.dev182727546 → braindecode-1.8.1.dev183301946}/braindecode/datautil/serialization.py

@@ -21,6 +21,7 @@ from ..datasets.base import (
     EEGWindowsDataset,
     RawDataset,
     WindowsDataset,
+    _compact_fif_tags,
 )
 
 
@@ -79,7 +80,8 @@ def _outdated_load_concat_dataset(path, preload, ids_to_load=None, target_name=N
     for path in paths:
         if is_raw and target_name is None:
             target_file_name = path / "target_name.json"
-            target_name = json.load(open(target_file_name, "r"))["target_name"]
+            with open(target_file_name) as f:
+                target_name = json.load(f)["target_name"]
 
         all_signals, description = _load_signals_and_description(
             path=path, preload=preload, is_raw=is_raw, ids_to_load=ids_to_load
@@ -141,7 +143,7 @@ def _load_signals(fif_file, preload, is_raw):
         if all(Path(f).exists() for f in signals.filenames):
             if preload:
                 signals.load_data()
-            return signals
+            return _compact_fif_tags(signals)
         else:  # This may happen if the file has been moved together with the pickle file.
             warnings.warn(
                 f"Pickle file {pkl_file} exists, but the referenced fif "
@@ -171,7 +173,8 @@ def _load_signals(fif_file, preload, is_raw):
             if preload:
                 signals._data, signals.preload = data, True
 
-    return signals
+    # after the pickle above, which keeps mne's own layout on disk
+    return _compact_fif_tags(signals)
 
 
 def load_concat_dataset(path, preload, ids_to_load=None, target_name=None, n_jobs=1):
@@ -264,7 +267,8 @@ def _load_parallel(path, i, preload, is_raw, has_stored_windows):
     target_file_path = sub_dir / "target_name.json"
     target_name = None
     if target_file_path.exists():
-        target_name = json.load(open(target_file_path, "r"))["target_name"]
+        with open(target_file_path) as f:
+            target_name = json.load(f)["target_name"]
 
     if is_raw and (not has_stored_windows):
         dataset = RawDataset(signals, description, target_name)
@@ -304,8 +308,8 @@ def _load_kwargs_json(kwargs_name, sub_dir):
     kwargs_file_name = ".".join([kwargs_name, "json"])
     kwargs_file_path = os.path.join(sub_dir, kwargs_file_name)
     if os.path.exists(kwargs_file_path):
-        kwargs = json.load(open(kwargs_file_path, "r"))
-        return kwargs
+        with open(kwargs_file_path) as f:
+            return json.load(f)
 
 
 def _is_outdated_saved(path):

{braindecode-1.8.1.dev182727546 → braindecode-1.8.1.dev183301946}/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.dev182727546 → braindecode-1.8.1.dev183301946}/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
@@ -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.dev182727546 → braindecode-1.8.1.dev183301946}/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.dev182727546 → braindecode-1.8.1.dev183301946}/braindecode/models/attn_sleep.py

@@ -143,6 +143,10 @@ class AttnSleep(EEGModuleMixin, nn.Module):
             sfreq=sfreq,
         )
         del n_outputs, n_chans, chs_info, n_times, input_window_seconds, sfreq
+        if self._n_chans_for_jit not in (None, 1):
+            raise ValueError(
+                f"AttnSleep takes single-channel input; got n_chans={self._n_chans_for_jit}."
+            )
 
         self.mapping = {
             "fc.weight": "final_layer.weight",
@@ -407,16 +411,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 +464,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