Braindecode 1.8.1.dev174649576__tar.gz → 1.8.1.dev174671102__tar.gz

{braindecode-1.8.1.dev174649576/braindecode.egg-info → braindecode-1.8.1.dev174671102}/PKG-INFO

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

@@ -14,16 +14,13 @@ 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, Sequence
+from collections.abc import Callable, Hashable
 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
 
@@ -31,7 +28,6 @@ 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
@@ -224,125 +220,6 @@ 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, willneed=False):
-    """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.
-
-    With ``willneed=True`` nothing is read and None is returned: the OS is
-    only asked to start reading the window's bytes into the page cache in the
-    background (``posix_fadvise(POSIX_FADV_WILLNEED)``).
-    """
-    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()
-    if willneed:  # only a hint: any error is left to the read itself
-        try:
-            with open(fname, "rb") as f:
-                os.posix_fadvise(
-                    f.fileno(),
-                    pos[0],
-                    pos[-1] + 16 + size[-1] - pos[0],
-                    os.POSIX_FADV_WILLNEED,
-                )
-        except OSError:
-            pass
-        return None
-    # 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.
 
@@ -946,11 +823,9 @@ class EEGWindowsDataset(_ZarrMixin, RecordDataset):
         if self._zarr_data is not None:
             X = self._zarr_data[:, i_start:i_stop]
         else:
-            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 = 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)
@@ -1378,8 +1253,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
     def __len__(self):
         return self._ensure_cumulative_sizes()[-1]
 
-    def _locate(self, idx: int):
-        """The dataset that holds item ``idx`` and the item's index in it."""
+    def _get_single_item(self, idx: int):
         if idx < 0:
             if -idx > len(self):
                 raise ValueError(
@@ -1393,33 +1267,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             sample_idx = idx
         else:
             sample_idx = idx - cumulative_sizes[dataset_idx - 1]
-        return self.datasets[dataset_idx], sample_idx
-
-    def _get_single_item(self, idx: int):
-        ds, i = self._locate(idx)
-        return ds[i]
-
-    def __getitems__(self, indices):
-        """Items ``indices``, as ``[self[i] for i in indices]``.
-
-        A :class:`~torch.utils.data.DataLoader` fetches each batch through
-        this. The lazy FIF windows of the batch are first requested from the
-        OS all at once (``posix_fadvise(POSIX_FADV_WILLNEED)``, where it
-        exists), so their reads from disk overlap instead of running one after
-        another: on a network file system a batch read from cold files then
-        costs about one round trip, not one per window.
-        """
-        # ponytail: advises the whole batch at once; chunk it if a batch's
-        # windows ever outgrow the page cache
-        if hasattr(os, "posix_fadvise"):
-            for idx in indices:
-                if not isinstance(idx, (int, np.integer)):
-                    continue  # e.g. a SequenceSampler tuple: read, not advised
-                ds, i = self._locate(idx)
-                if isinstance(ds, EEGWindowsDataset) and ds._zarr_data is None:
-                    _, start, stop = ds.crop_inds[i].tolist()
-                    _read_fif_window(ds.raw, start, stop, willneed=True)
-        return [self[idx] for idx in indices]
+        return self.datasets[dataset_idx][sample_idx]
 
     def __getitem__(self, idx: int | list):
         """
@@ -1824,8 +1672,7 @@ 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:
-                    with open(kwargs_path, "w") as f:
-                        json.dump(kwargs, f)
+                    json.dump(kwargs, open(kwargs_path, "w"))
 
     @property
     def description(self) -> pd.DataFrame:
@@ -1895,10 +1742,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         # Create path if it doesn't exist
         os.makedirs(path, exist_ok=True)
 
-        # 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 []
+        path_contents = os.listdir(path)
         n_sub_dirs = len(
             [e for e in path_contents if os.path.isdir(os.path.join(path, e))]
         )

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/datasets/tuh.py

@@ -241,11 +241,7 @@ class TUH(BaseConcatDataset):
         # file paths, use this instead as before
         if "year" in description:
             meas_date = meas_date.replace(*description[["year", "month", "day"]])
-        # 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)
+        raw.set_meas_date(meas_date)
 
         d = {
             "age": int(age),
@@ -255,9 +251,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"] = meas_date.year
-            d["month"] = meas_date.month
-            d["day"] = meas_date.day
+            d["year"] = raw.info["meas_date"].year
+            d["month"] = raw.info["meas_date"].month
+            d["day"] = raw.info["meas_date"].day
 
         # read info relevant for preprocessing from raw without loading it
         if add_physician_reports:

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/datautil/serialization.py

@@ -21,7 +21,6 @@ from ..datasets.base import (
     EEGWindowsDataset,
     RawDataset,
     WindowsDataset,
-    _compact_fif_tags,
 )
 
 
@@ -80,8 +79,7 @@ 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"
-            with open(target_file_name) as f:
-                target_name = json.load(f)["target_name"]
+            target_name = json.load(open(target_file_name, "r"))["target_name"]
 
         all_signals, description = _load_signals_and_description(
             path=path, preload=preload, is_raw=is_raw, ids_to_load=ids_to_load
@@ -143,7 +141,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 _compact_fif_tags(signals)
+            return 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 "
@@ -173,8 +171,7 @@ def _load_signals(fif_file, preload, is_raw):
             if preload:
                 signals._data, signals.preload = data, True
 
-    # after the pickle above, which keeps mne's own layout on disk
-    return _compact_fif_tags(signals)
+    return signals
 
 
 def load_concat_dataset(path, preload, ids_to_load=None, target_name=None, n_jobs=1):
@@ -267,8 +264,7 @@ 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():
-        with open(target_file_path) as f:
-            target_name = json.load(f)["target_name"]
+        target_name = json.load(open(target_file_path, "r"))["target_name"]
 
     if is_raw and (not has_stored_windows):
         dataset = RawDataset(signals, description, target_name)
@@ -308,8 +304,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):
-        with open(kwargs_file_path) as f:
-            return json.load(f)
+        kwargs = json.load(open(kwargs_file_path, "r"))
+        return kwargs
 
 
 def _is_outdated_saved(path):

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/functional/_real_dft.py

@@ -12,10 +12,8 @@ never downcast, so callers wrap the numerically sensitive parts with
 #
 # License: BSD (3-clause)
 import functools
-from typing import Optional
 
 import torch
-from torch import nn
 
 
 def needs_real_dft(x: torch.Tensor) -> bool:
@@ -138,56 +136,3 @@ def hilbert_freq_real(x: torch.Tensor, forward_fourier: bool) -> torch.Tensor:
         return torch.stack((out_real, out_imag), dim=-1)
 
     return compute(x)
-
-
-@torch.jit.unused
-def fft_conv1d_real(
-    x: torch.Tensor, weight: torch.Tensor, bias: Optional[torch.Tensor]
-) -> torch.Tensor:
-    """Real-valued equivalent of :func:`braindecode.functional.fft_conv1d`.
-
-    Overlap-save: the input is cut into blocks of ``n`` samples (the power of
-    two ``>= 2 * kernel_size``) that advance by ``n - kernel_size + 1`` outputs,
-    each block's DFT is a matmul against the cosine/sine basis, and per
-    frequency the complex product with the kernels, summed over the input
-    channels, is one real matmul.
-    """
-
-    @fp32_island
-    def compute(x, weight):
-        n_times, kernel_size = x.shape[-1], weight.shape[-1]
-        n = 1 << (2 * kernel_size - 1).bit_length()
-        hop = n - kernel_size + 1
-        n_blocks = -(-n_times // hop)
-        n_freqs = n // 2 + 1
-        # "same" alignment: torch pads the extra zero of an even kernel on the right
-        left = (kernel_size - 1) // 2
-        x = nn.functional.pad(x, (left, (n_blocks + 1) * hop - n_times - left))
-        hops = x.unflatten(-1, (n_blocks + 1, hop))
-        # block i = hop i + the first kernel_size - 1 samples of hop i + 1
-        blocks = torch.cat([hops[:, :, :-1], hops[:, :, 1:, : kernel_size - 1]], -1)
-        cosine, sine = real_dft_basis(n, device=x.device, dtype=x.dtype)
-        basis = torch.cat([cosine, -sine]).transpose(0, 1)  # -> [Re | Im] of rfft
-        x_f = blocks @ basis  # (batch, in, blocks, 2 * n_freqs)
-        w_f = nn.functional.pad(weight.to(x), (0, n - kernel_size)) @ basis
-        w_re, w_im = w_f[..., :n_freqs], w_f[..., n_freqs:]
-        # conv1d is a cross-correlation: x_f * conj(w_f), summed over the input
-        # channels. Per frequency [Re x, Im x] @ [[Re w, -Im w], [Im w, Re w]].
-        w_f = torch.cat([torch.cat([w_re, -w_im]), torch.cat([w_im, w_re])], 1)
-        x_f = x_f.unflatten(-1, (2, n_freqs)).permute(4, 0, 2, 3, 1).flatten(1, 2)
-        y_f = torch.bmm(x_f.flatten(2), w_f.permute(2, 1, 0))  # (freq, ., 2 * out)
-        y_f = y_f.unflatten(1, (x.shape[0], n_blocks)).unflatten(-1, (2, -1))
-        y_f = y_f.permute(1, 4, 2, 3, 0).flatten(
-            -2
-        )  # (batch, out, blocks, 2 * n_freqs)
-        # inverse DFT of the first `hop` samples, the ones without wrap-around
-        scale = torch.full((n_freqs, 1), 2.0 / n, dtype=x.dtype, device=x.device)
-        scale[0] = 1.0 / n
-        scale[-1] = 1.0 / n  # Nyquist (n is even)
-        inverse = torch.cat([scale * cosine[:, :hop], -scale * sine[:, :hop]])
-        return (y_f @ inverse).flatten(-2)[..., :n_times]
-
-    y = compute(x, weight)
-    if bias is not None:
-        y = y + bias.to(y).unsqueeze(-1)
-    return y.to(x)

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/functional/functions.py

@@ -62,10 +62,9 @@ def fft_conv1d(
 
     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
-    (see :func:`prefer_fft_conv`). float16/bfloat16 inputs are computed in
-    float32 (:func:`spectral_input`) and cast back. On Intel Gaudi (HPU, no
-    complex dtype) the DFTs are real matmuls over overlapping blocks.
+    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
     ----------
@@ -83,35 +82,22 @@ def fft_conv1d(
         ``x``. For an even ``kernel_size`` it is aligned like torch's
         ``padding="same"`` (the extra zero padded on the right).
     """
-    if _real_dft.needs_real_dft(x):
-        return _real_dft.fft_conv1d_real(x, weight, bias)
     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)  # (batch, in, freq)
+    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).
-    needs_grad = torch.is_grad_enabled() and (x.requires_grad or weight.requires_grad)
-    if needs_grad or x.shape[0] >= 2 * x.shape[1]:
-        # [Re x, Im x] @ [[Re w, Im w], [-Im w, Re w]] (rows of i * w): the
-        # output columns are the (Re, Im) pairs of the result, read as complex
-        # without a copy (and without a costly backward).
-        w_mat = torch.view_as_real(torch.stack([w_f, w_f * 1j], 1)).flatten(1, 2)
-        y_f = torch.view_as_real(x_f).permute(2, 0, 3, 1).flatten(2) @ w_mat.flatten(2)
-        y_f = torch.view_as_complex(y_f.unflatten(-1, [-1, 2]))
-    else:
-        # Forward only with fewer rows than twice the input channels: the
-        # doubled weight costs more than combining [Re x; Im x] @ [Re w, Im w].
-        x_f = x_f.permute(2, 0, 1)
-        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])
-        y_f = torch.complex(
-            p[:, 0, :, :, 0] - p[:, 1, :, :, 1], p[:, 0, :, :, 1] + p[:, 1, :, :, 0]
-        )
+    # 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]
@@ -129,11 +115,8 @@ def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
     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). On Intel
-    Gaudi (HPU) a direct convolution costs about ``batch_size * n_times *
-    kernel_size`` and the FFT about a fixed few milliseconds in eager mode: the
-    FFT wins from 8 input channels and ``batch_size * n_times * kernel_size >=
-    8e6``. GPUs keep the direct convolution.
+    temporal convolutions of the model zoo, 22 channels x batch 32). GPUs and
+    HPUs (no complex dtype) keep the direct convolution.
 
     Parameters
     ----------
@@ -142,8 +125,6 @@ def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
     kernel_size : int
         Kernel length in samples.
     """
-    if x.device.type == "hpu":
-        return x.shape[1] >= 8 and x.shape[0] * x.shape[-1] * kernel_size >= 8e6
     return x.device.type == "cpu" and (
         x.element_size() == 2
         or (x.shape[0] * kernel_size >= 600 and x.shape[1] * kernel_size >= 120)

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/models/attn_sleep.py

@@ -143,10 +143,6 @@ 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",

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/models/axon.py

@@ -14,7 +14,6 @@ from torch import nn
 from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import warn_if_sfreq_differs
-from braindecode.modules.attention import _scaled_dot_product_attention
 from braindecode.modules.channels import _resolve
 
 
@@ -463,33 +462,11 @@ class _AxisAttention(nn.Module):
             .unbind(0)
         )
         drop = self.att_drop_prob if self.training else 0.0
-        attended = _scaled_dot_product_attention(
+        attended = F.scaled_dot_product_attention(
             query, key, value, attn_mask=mask, dropout_p=drop
         )
         return attended.transpose(1, 2).reshape(n_seq, length, -1)
 
-    def _attend_two_scales(
-        self, projected: torch.Tensor, band: torch.Tensor, weights: torch.Tensor
-    ) -> torch.Tensor:
-        """Banded and full attention from one score matrix, mixed per query.
-
-        ``weights`` (N, L, 2) are the scale-gate weights. Both softmaxes share
-        the scores and one product with the values serves the mixture.
-        """
-        n_seq, length, _ = projected.shape
-        query, key, value = (
-            projected.reshape(n_seq, length, 3, self.num_heads, self.head_dim)
-            .permute(2, 0, 3, 1, 4)
-            .unbind(0)
-        )
-        scores = torch.matmul(query, key.transpose(-2, -1)) * self.head_dim**-0.5
-        weights = weights.reshape(n_seq, 1, length, 2)
-        probs = weights[..., 0:1] * scores.masked_fill(~band, float("-inf")).softmax(
-            -1
-        ) + weights[..., 1:2] * scores.softmax(-1)
-        attended = torch.matmul(probs, value)
-        return attended.transpose(1, 2).reshape(n_seq, length, -1)
-
     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)
@@ -499,26 +476,15 @@ class _AxisAttention(nn.Module):
         # 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))
-        dropout = self.training and self.att_drop_prob > 0
-        if band is not None and not dropout:
-            # The scale-gate weights sum to one, so the two branches share the
-            # scores, the product with the values and temporal_out.
-            attended = self._attend_two_scales(per_channel, band, scale_weights)
-            temporal = self.temporal_out(attended).reshape(
-                batch, n_chans, n_patches, dim
-            )
-        else:
-            restricted = self.temporal_out(self._attend(per_channel, band)).reshape(
+        restricted = self.temporal_out(self._attend(per_channel, band)).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
             )
-            full = restricted
-            if dropout:
-                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
-            )
+        temporal = scale_weights[..., 0:1] * restricted + scale_weights[..., 1:2] * full
 
         # Spatial path: one sequence of C tokens per time step.
         per_step = self.spatial_qkv(

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/models/barista.py

@@ -7,13 +7,13 @@ from __future__ import annotations
 from typing import Optional
 
 import torch
+import torch.nn.functional as F
 from einops.layers.torch import Rearrange
 from torch import nn
 
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
 from braindecode.modules import GatedLinearUnit, PatchTokenizer
-from braindecode.modules.attention import _scaled_dot_product_attention
 
 
 class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
@@ -689,7 +689,7 @@ class _RotarySelfAttention(nn.Module):
 
         # Dropout falls on the attention output rather than on the weights,
         # through dropout_p, because the reference disables the latter outright.
-        attention = _scaled_dot_product_attention(query, key, value)
+        attention = F.scaled_dot_product_attention(query, key, value)
         attention = self.dropout(attention)
         attention = self.merge_heads(attention)
         return self.o_proj(attention)

{braindecode-1.8.1.dev174649576 → braindecode-1.8.1.dev174671102}/braindecode/models/base.py

@@ -46,24 +46,6 @@ _GEOMETRY_KWARGS = (
 )
 
 
-def _too_short_input_error(exc: RuntimeError, input_shape) -> Optional[ValueError]:
-    """ValueError for a layer that found the input too short, else None."""
-    if not str(exc).endswith(
-        (
-            "Output size is too small",
-            "Kernel size can't be greater than actual input size",
-        )
-    ):
-        return None
-    return ValueError(
-        "During model prediction RuntimeError was thrown showing that at some "
-        f"layer `{str(exc).split('.')[-1]}` (see above in the stacktrace). This "
-        "could be caused by providing too small `n_times`/`input_window_seconds`. "
-        "Model may require longer chunks of signal in the input than "
-        f"{input_shape}."
-    )
-
-
 _HF_INSTALL_HINT = (
     "requires the `huggingface_hub` package. "
     "Install with: pip install 'braindecode[hub]'"
@@ -501,18 +483,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         # Called by torch.jit.script before compiling the model.
         return make_parametrizations_scriptable(self)
 
-    def __call__(self, *args, **kwargs):
-        # An input shorter than the layers need raises ValueError, not a torch
-        # RuntimeError from deep inside forward.
-        try:
-            return super().__call__(*args, **kwargs)
-        except RuntimeError as exc:
-            shape = tuple(args[0].shape) if args and hasattr(args[0], "shape") else None
-            error = _too_short_input_error(exc, shape)
-            if error is None:
-                raise
-            raise error from exc
-
     def get_output_shape(self) -> tuple[int, ...]:
         """Returns shape of neural network output for batch size equal 1.
 
@@ -536,10 +506,21 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                     .shape
                 )
             except RuntimeError as exc:
-                error = _too_short_input_error(exc, self.input_shape)
-                if error is None:
-                    raise
-                raise error from exc
+                if str(exc).endswith(
+                    (
+                        "Output size is too small",
+                        "Kernel size can't be greater than actual input size",
+                    )
+                ):
+                    msg = (
+                        "During model prediction RuntimeError was thrown showing that at some "
+                        f"layer `{str(exc).split('.')[-1]}` (see above in the stacktrace). This "
+                        "could be caused by providing too small `n_times`/`input_window_seconds`. "
+                        "Model may require longer chunks of signal in the input than "
+                        f"{self.input_shape}."
+                    )
+                    raise ValueError(msg) from exc
+                raise exc
 
     def get_config(self) -> dict:
         """Return a JSON-serializable dict of all ``__init__`` parameters.