Braindecode 1.8.1.dev181570120__tar.gz → 1.8.1.dev181710643__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev181570120
+Version: 1.8.1.dev181710643
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Alexandre Gramfort <agramfort@meta.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>

{braindecode-1.8.1.dev181570120 → braindecode-1.8.1.dev181710643}/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,109 +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):
-    """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.
 
@@ -930,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)
@@ -1781,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:

{braindecode-1.8.1.dev181570120 → braindecode-1.8.1.dev181710643}/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.dev181570120 → braindecode-1.8.1.dev181710643}/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.dev181570120 → braindecode-1.8.1.dev181710643}/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.dev181570120 → braindecode-1.8.1.dev181710643}/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.

{braindecode-1.8.1.dev181570120 → braindecode-1.8.1.dev181710643}/braindecode/models/brainomni.py

@@ -29,21 +29,15 @@ from braindecode.modules.quantization import ResidualVectorQuantizer
 
 
 class _SELU(nn.SELU):
-    """``nn.SELU`` as ``ELU(x, alpha * scale)`` times ``scale`` where ``x > 0``:
-    same values and gradients, and trainable on Gaudi, whose ELU backward only
-    supports ``scale == 1``."""
+    """``nn.SELU`` written as ``scale * x`` / ELU: same values and gradients, and
+    trainable on Gaudi, whose ELU backward only supports ``scale == 1``."""
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         alpha, scale = (
             1.6732632423543772848170429916717,
             1.0507009873554804934193349852946,
         )
-        # ELU is x on the positive side, so this equals the where(x > 0, x * scale,
-        # elu) form bit for bit, without its zero-filled where backward. The
-        # factor is at least float32, like the scalar multiply's compute type.
-        one = x.new_ones((), dtype=torch.promote_types(x.dtype, torch.float32))
-        factor = torch.where(x > 0, one * scale, one)
-        return (F.elu(x, alpha * scale) * factor).to(x.dtype)
+        return torch.where(x > 0, x * scale, F.elu(x, alpha * scale))
 
 
 class BrainTokenizer(EEGModuleMixin, nn.Module, license="mit"):
@@ -869,13 +863,9 @@ class _SEANetConv1d(nn.Module):
         extra = (kernel_size - padding_total - x.shape[-1]) % stride
         right = padding_total // 2
         padding = (padding_total - right, right + extra)
-        if max(padding) == 0:  # 1x1 convs: padding would only copy x
-            return self.conv(x)
         # Zero-extend a signal too short to reflect, as EnCodec does.
         short = max(max(padding) - x.shape[-1] + 1, 0)
-        if short > 0:  # F.pad with nothing to pad still copies x
-            x = F.pad(x, (0, short))
-        x = F.pad(x, padding, mode="reflect")
+        x = F.pad(F.pad(x, (0, short)), padding, mode="reflect")
         return self.conv(x[..., : x.shape[-1] - short])
 
 

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

@@ -15,7 +15,6 @@ from torch import nn
 from torch.nn.utils.parametrizations import weight_norm
 
 from braindecode.functional import spectral_input
-from braindecode.functional.functions import _next_fast_len
 from braindecode.models.base import EEGModuleMixin
 
 
@@ -522,21 +521,16 @@ class _GConv(nn.Module):
             kernel = F.pad(k_fwd, (0, seq_len)) + F.pad(k_bwd.flip(-1), (seq_len, 0))
 
         # FFT-based convolution: O(N log N)
-        # The bidirectional kernel is circular (lags 0..L-1, then -L..-1).
-        # Rolled to lags -L..L-1 it is a linear convolution read from lag 0,
-        # so any FFT length >= 2 * seq_len works: take a 5-smooth (fast) one.
-        start = seq_len if self.bidirectional else 0
-        n_fft = 2 * _next_fast_len(seq_len)
         # kernel_freq: (channels, d_model, freq_bins)
         # spectral_input(x) dtype: x's, at least float32 (the reference's .float()).
         x_in = spectral_input(x)
-        kernel_freq = torch.fft.rfft(kernel.roll(start, -1).to(x_in), n=n_fft)
+        kernel_freq = torch.fft.rfft(kernel.to(x_in), n=2 * seq_len)
         # x_freq: (batch, d_model, freq_bins)
-        x_freq = torch.fft.rfft(x_in, n=n_fft)
+        x_freq = torch.fft.rfft(x_in, n=2 * seq_len)
         # out_freq: (batch, channels, d_model, freq_bins)
         out_freq = torch.einsum("bhl,chl->bchl", x_freq, kernel_freq)
         # out: (batch, channels, d_model, seq_len)
-        out = torch.fft.irfft(out_freq, n=n_fft)[..., start : start + seq_len].to(x)
+        out = torch.fft.irfft(out_freq, n=2 * seq_len)[..., :seq_len].to(x)
 
         # Skip connection via learnable D matrix
         # (batch, channels, d_model, seq_len)

{braindecode-1.8.1.dev181570120 → braindecode-1.8.1.dev181710643}/braindecode/models/contrawr.py

@@ -4,7 +4,7 @@ import torch
 import torch.nn as nn
 from mne.utils import warn
 
-from braindecode.functional import _real_dft, spectral_input
+from braindecode.functional import spectral_input
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import _disable_batch_norm_training_if_batch_size_one
 
@@ -297,8 +297,6 @@ class _STFTModule(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         # x: (B, C, T)
-        if _real_dft.needs_real_dft(x) and self.center and self.one_sided:
-            return self._forward_real_dft(x).to(x)
         B, C, T = x.shape
         # flatten batch & channel into one dim
         x_flat = spectral_input(x.reshape(B * C, T))
@@ -321,23 +319,3 @@ class _STFTModule(nn.Module):
         spec = spec_flat.view(B, C, F, L)
 
         return torch.abs(spec).to(x)
-
-    @torch.jit.unused
-    @_real_dft.fp32_island
-    def _forward_real_dft(self, x):
-        # The magnitude above without complex tensors, on the device (Intel
-        # Gaudi / HPU), instead of a host STFT and a host-to-device copy of
-        # the whole spectrogram: reflect-padded frames (gathered, not a
-        # strided unfold) times the one-sided DFT basis. No annotations: with
-        # postponed annotations torch.jit.unused cannot resolve them.
-        pad = self.n_fft // 2
-        x = nn.functional.pad(x, (pad, pad), mode="reflect")
-        n_frames = 1 + (x.shape[-1] - self.n_fft) // self.hop_length
-        starts = torch.arange(n_frames, device=x.device) * self.hop_length
-        index = (starts[:, None] + torch.arange(self.n_fft, device=x.device)).flatten()
-        frames = x.index_select(-1, index).unflatten(-1, (n_frames, self.n_fft))
-        real, imag = _real_dft.real_rfft(frames)
-        magnitude = torch.sqrt(real * real + imag * imag)
-        if self.normalized:
-            magnitude = magnitude / self.n_fft**0.5
-        return magnitude.transpose(-1, -2)

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

@@ -314,11 +314,6 @@ class CSBrain(EEGModuleMixin, nn.Module):
             sfreq=sfreq,
         )
         del n_chans, chs_info, n_times, input_window_seconds, sfreq, n_outputs
-        n_times = self._n_times_or_none()
-        if n_times is not None and n_times % patch_size:
-            raise ValueError(
-                f"n_times ({n_times}) must be a multiple of patch_size ({patch_size})."
-            )
 
         self.rearrange = Rearrange(
             "batch n_chans (n_patch patch_size) -> batch n_chans n_patch patch_size",
@@ -541,7 +536,6 @@ class _RegionEmbedding(nn.Module):
     """
 
     region_bounds: List[Tuple[int, int]]
-    tap_starts: List[int]
 
     def __init__(
         self,
@@ -575,61 +569,42 @@ class _RegionEmbedding(nn.Module):
                 for region_key in area_config
             }
         )
-        # All regions in one pass: tap j of the widest kernel reads, for every
-        # electrode, the electrode at offset j - half on its region's ring
-        # (circular padding), or nothing (zero padding of a one-electrode
-        # region); kernel k uses the middle k taps. As a 0/1 matrix, so the
-        # gather and its backward are matmuls.
-        half = (max(kernel_sizes) - 1) // 2
-        n_taps = 2 * half + 1
-        self.tap_starts = [half - (k - 1) // 2 for k in kernel_sizes]
-        n_chans = self.region_bounds[-1][1] if self.region_bounds else 0
-        chan_region = []
-        tap_select = torch.zeros(n_chans * n_taps, n_chans)
-        for i, (start, stop) in enumerate(self.region_bounds):
-            n = stop - start
-            for p in range(n):
-                chan_region.append(i)
-                for d in range(-half, half + 1) if n > 1 else [0]:
-                    row = (start + p) * n_taps + d + half
-                    tap_select[row, start + (p + d) % n] = 1.0
-        self.register_buffer(
-            "chan_region", torch.tensor(chan_region, dtype=torch.long), False
-        )
-        self.register_buffer("tap_select", tap_select, False)
 
     def forward(self, x):
         batch, chans, T, dim_in = x.shape
-        if len(self.region_bounds) == 0:
-            return torch.zeros(
-                (batch, chans, T, self.dim_out), device=x.device, dtype=x.dtype
+        output = torch.zeros(
+            (batch, chans, T, self.dim_out), device=x.device, dtype=x.dtype
+        )
+        for i, blocks in enumerate(self.region_blocks.values()):
+            start, stop = self.region_bounds[i]
+            n_electrodes = stop - start
+            x_region = x[:, start:stop, :, :]
+            x_trans = (
+                x_region.permute(0, 2, 1, 3)
+                .reshape(-1, n_electrodes, dim_in)
+                .permute(0, 2, 1)
+                .unsqueeze(-1)
             )
-        # (batch, chans, n_taps, T, dim_in): every electrode's ring neighbours
-        taps = torch.matmul(self.tap_select, x.reshape(batch, chans, T * dim_in))
-        taps = taps.reshape(batch, chans, -1, T, dim_in)
-        # Per kernel, one batched matmul over electrodes, each with its
-        # region's weights: (chans, batch * T, k * dim_in) @ (chans, k * dim_in, out)
-        weights: List[List[Tensor]] = [[] for _ in self.tap_starts]
-        biases: List[List[Tensor]] = [[] for _ in self.tap_starts]
-        for blocks in self.region_blocks.values():
-            for j, conv in enumerate(blocks):
-                bias = conv.bias
-                assert bias is not None
-                weights[j].append(conv.weight)
-                biases[j].append(bias)
-        outs = []
-        for j, start in enumerate(self.tap_starts):
-            w = torch.stack(weights[j]).index_select(0, self.chan_region)
-            k = w.shape[3]
-            w = w.squeeze(-1).permute(0, 3, 2, 1).reshape(chans, k * dim_in, -1)
-            t = taps[:, :, start : start + k].permute(1, 0, 3, 2, 4)
-            b = torch.stack(biases[j]).index_select(0, self.chan_region)
-            outs.append(
-                torch.bmm(t.reshape(chans, batch * T, k * dim_in), w) + b.unsqueeze(1)
+            fmap_outputs = []
+            for conv in blocks:
+                k = conv.kernel_size[0]
+                pad = (k - 1) // 2
+                if n_electrodes == 1:
+                    x_padded = F.pad(
+                        x_trans, (0, 0, pad, pad), mode="constant", value=0.0
+                    )
+                else:
+                    x_padded = F.pad(x_trans, (0, 0, pad, pad), mode="circular")
+                fmap_outputs.append(conv(x_padded))
+            fmap_cat = torch.cat(fmap_outputs, dim=1)
+            fmap_out = (
+                fmap_cat.squeeze(-1)
+                .permute(0, 2, 1)
+                .reshape(batch, T, n_electrodes, self.dim_out)
+                .permute(0, 2, 1, 3)
             )
-        out = torch.cat(outs, dim=-1).view(chans, batch, T, self.dim_out)
-        # contiguous: the residual sum keeps this layout and the next layer views it
-        return out.permute(1, 0, 2, 3).contiguous()
+            output[:, start:stop, :, :] = fmap_out
+        return output
 
 
 class _CSBrainEncoderLayer(nn.Module):
@@ -695,17 +670,6 @@ class _CSBrainEncoderLayer(nn.Module):
             )
         else:
             self.region_attn_mask = None
-        # Region of every electrode and electrodes per region, for the
-        # region means of all regions at once (index_add_ sums in channel
-        # order, as the per-region mean did).
-        sizes = [stop - start for start, stop in self.region_bounds]
-        chan_region = [i for i, n in enumerate(sizes) for _ in range(n)]
-        self.register_buffer(
-            "chan_region", torch.tensor(chan_region, dtype=torch.long), False
-        )
-        self.register_buffer(
-            "region_sizes", torch.tensor(sizes, dtype=torch.long)[:, None], False
-        )
 
     def forward(self, src: Tensor) -> Tensor:
         x = src
@@ -742,13 +706,11 @@ class _CSBrainEncoderLayer(nn.Module):
     def _inter_region_attention(self, x: Tensor) -> Tensor:
         batch, chans, T, Fea = x.shape
         x_flat = x.permute(0, 2, 1, 3).reshape(batch * T, chans, Fea)
-        if len(self.region_bounds) == 0:
-            global_features = torch.zeros_like(x_flat)
-        else:
-            region_sum = x_flat.new_zeros(batch * T, len(self.region_bounds), Fea)
-            region_sum.index_add_(1, self.chan_region, x_flat)
-            region_mean = region_sum / self.region_sizes
-            global_features = region_mean.index_select(1, self.chan_region)
+        global_features = torch.zeros_like(x_flat)
+        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)
+            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.dev181570120 → braindecode-1.8.1.dev181710643}/braindecode/models/deep4.py

@@ -170,10 +170,6 @@ class Deep4Net(EEGModuleMixin, nn.Sequential):
         ):
             resolved_n_times = round(self._input_window_seconds * self._sfreq)
 
-        if resolved_n_times is not None and resolved_n_times >= min_n_times:
-            # The bound above ignores stride_before_pool and an integer
-            # final_conv_length; inputs it admits are checked with the exact one.
-            min_n_times = self._get_min_n_times(exact=True)
         if resolved_n_times is not None and resolved_n_times < min_n_times:
             scaling_factor = resolved_n_times / min_n_times
             warn(
@@ -367,15 +363,13 @@ class Deep4Net(EEGModuleMixin, nn.Sequential):
 
         self.train()
 
-    def _get_min_n_times(self, exact: bool = False) -> int:
+    def _get_min_n_times(self) -> int:
         """
         Calculate the minimum number of time samples required for the model
         to work with the given temporal parameters.
         """
         # Start with the minimum valid output length of the network (1)
         min_len = 1
-        if exact and isinstance(self.final_conv_length, int):
-            min_len = self.final_conv_length
 
         # List of conv kernel sizes and pool parameters for the 4 blocks, in reverse order
         # Each tuple: (filter_length, pool_length, pool_stride)
@@ -388,9 +382,6 @@ class Deep4Net(EEGModuleMixin, nn.Sequential):
 
         # Work backward from the last layer to the input
         for filter_len, pool_len, pool_stride in block_params:
-            if exact and self.stride_before_pool:  # strided conv, then pool stride 1
-                min_len = pool_stride * (min_len + pool_len - 2) + filter_len
-                continue
             # Reverse the pooling operation
             # L_in = stride * (L_out - 1) + kernel_size
             min_len = pool_stride * (min_len - 1) + pool_len

{braindecode-1.8.1.dev181570120 → braindecode-1.8.1.dev181710643}/braindecode/models/dgcnn.py

@@ -142,11 +142,6 @@ def _build_initial_adjacency(chs_info, n_chans, n_neighbors=5):
     electrode_positions = extract_channel_locations_from_chs_info(
         chs_info, num_channels=n_chans
     )
-    # MNE stores NaN for a channel without a position.
-    if electrode_positions is not None and not (
-        len(electrode_positions) == n_chans and np.isfinite(electrode_positions).all()
-    ):
-        electrode_positions = None
 
     if electrode_positions is None and chs_info is not None:
         # Try to infer positions from channel names via a standard montage
@@ -167,8 +162,6 @@ def _build_initial_adjacency(chs_info, n_chans, n_neighbors=5):
                 "with 3-D positions or that channel names match a standard montage."
             )
 
-    if n_chans < 2:
-        raise ValueError("DGCNN needs at least 2 channels to build its channel graph.")
     n_neighbors_capped = min(n_neighbors, n_chans - 1)
 
     # Pairwise Euclidean distances