Braindecode 1.8.1.dev180519461__tar.gz → 1.8.1.dev180667301__tar.gz

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/NOTICE.txt

@@ -14,7 +14,8 @@ The following components are licensed under the Creative Commons Attribution-Non
 - `braindecode/models/eegminer.py`
 - `braindecode/models/meta_neuromotor.py`
 - `braindecode/models/brainmodule.py`
-- `braindecode/models/neurorvq.py`
+
+As well as class later imported into the `braindecode.models.module` named as GeneralizedGaussianFilter.
 
 The `meta_neuromotor.py` file is a derivative of
 `facebookresearch/generic-neuromotor-interface`, released by Meta Platforms,
@@ -44,15 +45,6 @@ The following components are licensed under the MIT License:
 - `braindecode/models/mirepnet.py`
 - `braindecode/models/popt.py`
 - `braindecode/modules/popt_modules.py`
-- `braindecode/models/brainomni.py`
-- `braindecode/modules/quantization.py`
-- `braindecode/models/seizure_transformer.py`
-- `docs/_static/model/seizure_transformer_arch.png`
-
-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.
 
 ### Apache-2.0 Licensed Files
 
@@ -61,7 +53,6 @@ The following components are licensed under the Apache License 2.0:
 - `braindecode/models/mvpformer.py`
 - `braindecode/models/zuna.py`
 - `braindecode/models/luna.py`
-- `braindecode/models/mapa.py`
 - `braindecode/models/brant.py`
 - `braindecode/models/diver1.py`
 - `braindecode/models/mscformer.py`

{braindecode-1.8.1.dev180519461/braindecode.egg-info → braindecode-1.8.1.dev180667301}/PKG-INFO

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

@@ -9,12 +9,10 @@ from .bendr import BENDR, InterpolatedBENDR
 from .biot import BIOT, InterpolatedBIOT
 from .brainbert import BrainBERT
 from .brainmodule import BrainModule
-from .brainomni import BrainOmni, BrainTokenizer
 from .brant import Brant
 from .cbramod import CBraMod
 from .codebrain import CodeBrain
 from .contrawr import ContraWR
-from .csbrain import CSBrain
 from .ctnet import CTNet
 from .dance import DANCE
 from .deep4 import Deep4Net
@@ -42,7 +40,6 @@ from .ifnet import IFNet
 from .interpolated import InterpolatedModel
 from .labram import InterpolatedLaBraM, Labram
 from .luna import LUNA
-from .mapa import MAPA
 from .medformer import MEDFormer
 from .meta_neuromotor import MetaNeuromotorHand
 from .mirepnet import MIRepNet
@@ -50,12 +47,10 @@ from .mscformer import MSCFormer
 from .msvtnet import MSVTNet
 from .mvpformer import MVPFormer
 from .neuropose import NeuroPose
-from .neurorvq import NeuroRVQ
 from .patchedtransformer import PBT
 from .popt import PopulationTransformer
 from .reve import REVE
 from .sccnet import SCCNet
-from .seizure_transformer import SeizureTransformer
 from .sensingdynamics import SensingDynamics
 from .shallow_fbcsp import ShallowFBCSPNet
 from .signal_jepa import (
@@ -101,12 +96,9 @@ __all__ = [
     "BIOT",
     "BENDR",
     "BrainBERT",
-    "BrainOmni",
-    "BrainTokenizer",
     "CBraMod",
     "CodeBrain",
     "ContraWR",
-    "CSBrain",
     "CTNet",
     "DANCE",
     "Deep4Net",
@@ -147,10 +139,8 @@ __all__ = [
     "LUNA",
     "extract_channel_locations_from_chs_info",
     "positions_from_chs_info",
-    "MAPA",
     "MEDFormer",
     "MIRepNet",
-    "NeuroRVQ",
     "MSCFormer",
     "MSVTNet",
     "MVPFormer",
@@ -158,7 +148,6 @@ __all__ = [
     "PopulationTransformer",
     "REVE",
     "SCCNet",
-    "SeizureTransformer",
     "ShallowFBCSPNet",
     "SignalJEPA",
     "SignalJEPA_Contextual",

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/base.py

@@ -779,22 +779,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
 
     if HAS_HF_HUB:
 
-        @classmethod
-        def from_pretrained(cls, *args, **kwargs):
-            # The Hub mixin fills omitted __init__ args from config.json; pin the
-            # derived geometry arg so it cannot clash with the caller's one
-            # (e.g. caller chs_info vs saved n_chans) in __init__'s checks.
-            if "chs_info" in kwargs and "n_chans" not in kwargs:
-                chs_info = kwargs["chs_info"]
-                kwargs["n_chans"] = None if chs_info is None else len(chs_info)
-            elif "n_chans" in kwargs and "chs_info" not in kwargs:
-                kwargs["chs_info"] = None
-            if ("n_times" in kwargs or "sfreq" in kwargs) and (
-                "input_window_seconds" not in kwargs
-            ):
-                kwargs["input_window_seconds"] = None
-            return super().from_pretrained(*args, **kwargs)
-
         @classmethod
         def _from_pretrained(
             cls,

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/bendr.py

@@ -11,7 +11,6 @@ from einops.layers.torch import Rearrange
 from torch import nn
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.modules.channel_tokenizer import ChannelTokenizer
 
 # The 20 channels used to pre-train BENDR, in the order expected by the
 # `braindecode/braindecode-bendr` checkpoint. The first 19 entries are the
@@ -289,25 +288,26 @@ class BENDR(EEGModuleMixin, nn.Module):
         # Keep these parameters if needed later, otherwise they are captured by the mixin
         del n_outputs, n_chans, chs_info, n_times, input_window_seconds, sfreq
 
-        # No chs_info (incl. from_pretrained) or the canonical order: no
-        # tokenizer, so released checkpoints stay bit-identical. Any other
-        # montage is projected onto the 20 canonical channels.
+        # If the user supplies chs_info, require it to match BENDR_CHANNEL_ORDER
+        # exactly (case-insensitive). Arbitrary channel sets should go through
+        # InterpolatedBENDR — same pattern as Labram / InterpolatedLaBraM.
+        # When chs_info is absent (the usual n_chans=20 path, incl.
+        # from_pretrained), no check is performed.
         try:
             _chs_info = self.chs_info
         except ValueError:
             _chs_info = None
-        self.channel_tokenizer = None
-        backbone_n_chans = self.n_chans
         if _chs_info is not None:
             user_names = [ch["ch_name"] for ch in _chs_info]  # type: ignore[index]
             canonical = BENDR_CHANNEL_ORDER
             if [n.lower() for n in user_names] != [n.lower() for n in canonical]:
-                self.channel_tokenizer = ChannelTokenizer(
-                    strategy="fixed_order",
-                    src_chs_info=_chs_info,
-                    target_chs_info=_BENDR_TARGET_CHS_INFO,
+                raise ValueError(
+                    f"BENDR requires chs_info to match BENDR_CHANNEL_ORDER exactly "
+                    f"({len(canonical)} channels, specific order; last is 'SCALE'). "
+                    f"Got {len(user_names)} channel(s). For arbitrary channel sets, "
+                    f"use InterpolatedBENDR "
+                    f"(from braindecode.models import InterpolatedBENDR)."
                 )
-                backbone_n_chans = len(_BENDR_TARGET_CHS_INFO)
 
         self.encoder_h = encoder_h
         self.contextualizer_hidden = contextualizer_hidden
@@ -315,7 +315,7 @@ class BENDR(EEGModuleMixin, nn.Module):
         self.encoder_only = encoder_only
 
         self.encoder = _ConvEncoderBENDR(
-            in_features=backbone_n_chans,
+            in_features=self.n_chans,
             encoder_h=encoder_h,
             dropout=drop_prob,
             projection_head=projection_head,
@@ -361,8 +361,6 @@ class BENDR(EEGModuleMixin, nn.Module):
         self._build_head(n_outputs)
 
     def forward(self, x, return_features=False):
-        if self.channel_tokenizer is not None:
-            x = self.channel_tokenizer(x)
         encoded = self.encoder(x)
         # encoded: [batch_size, encoder_h, n_encoded_times]
 

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/cbramod.py

@@ -11,11 +11,11 @@ from typing import Optional, Sequence
 
 import torch
 from einops import rearrange
+from einops.layers.torch import Rearrange
 from torch import Tensor, nn
 
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import CrissCrossTransformerEncoderLayer
-from braindecode.modules.blocks import PatchTokenizer
 
 logger = logging.getLogger(__name__)
 
@@ -123,9 +123,6 @@ class CBraMod(EEGModuleMixin, nn.Module):
 
     Parameters
     ----------
-    on_non_divisible : {"pad", "crop", "error"}, default="pad"
-        How :class:`~braindecode.modules.PatchTokenizer` treats a time axis that
-        is not a multiple of ``patch_size`` (right zero-pad, crop, or raise).
     patch_size : int, default=200
         Temporal patch size in samples (200 samples = 1 second at 200 Hz).
     dim_feedforward : int, default=800
@@ -162,7 +159,6 @@ class CBraMod(EEGModuleMixin, nn.Module):
         input_window_seconds=None,
         sfreq=None,
         patch_size: int = 200,
-        on_non_divisible: str = "pad",
         dim_feedforward: int = 800,
         n_layer: int = 12,
         nhead: int = 8,
@@ -187,18 +183,10 @@ class CBraMod(EEGModuleMixin, nn.Module):
             sfreq=sfreq,
         )
         del n_chans, chs_info, n_times, input_window_seconds, sfreq, n_outputs
-        # Shared tokenizer: (batch, n_chans, n_times) -> (batch, n_chans, n_patch, patch_size),
-        # padding/cropping a non-divisible time axis at forward time.
-        try:
-            tokenizer_n_times = self.n_times
-        except ValueError:  # unknown length: nothing to check at construction
-            tokenizer_n_times = patch_size
-        self.rearrange = PatchTokenizer(
+        self.rearrange = Rearrange(
+            "batch n_chans (n_patch patch_size) -> batch n_chans n_patch patch_size",
             patch_size=patch_size,
-            n_times=tokenizer_n_times,
-            on_non_divisible=on_non_divisible,
         )
-        self._on_non_divisible = on_non_divisible
         self.patch_embedding = _PatchEmbedding(
             patch_size,
             channels_kernel_stride_padding_norm,
@@ -223,9 +211,9 @@ class CBraMod(EEGModuleMixin, nn.Module):
 
         if return_encoder_output:
             self.final_layer = nn.Identity()
-        elif self._knows_geometry():
-            n_patch = self._n_patch()
-            flat_dim = self.n_chans * n_patch * emb_dim
+        elif self._n_times is not None and self._n_chans is not None:
+            n_patch = self._n_times // patch_size
+            flat_dim = self._n_chans * n_patch * emb_dim
             self.final_layer = nn.Sequential(
                 nn.Flatten(), nn.Linear(flat_dim, self.n_outputs)
             )
@@ -239,30 +227,15 @@ class CBraMod(EEGModuleMixin, nn.Module):
         self._update_init_kwargs(n_outputs=n_outputs)
         # A head implies a classifier, also when built with return_encoder_output.
         self._update_init_kwargs(return_encoder_output=False)
-        if self._knows_geometry():
-            n_patch = self._n_patch()
-            flat_dim = self.n_chans * n_patch * self._emb_dim
+        if self._n_times is not None and self._n_chans is not None:
+            n_patch = self._n_times // self._patch_size
+            flat_dim = self._n_chans * n_patch * self._emb_dim
             self.final_layer = nn.Sequential(
                 nn.Flatten(), nn.Linear(flat_dim, n_outputs)
             )
         else:
             self.final_layer = nn.Sequential(nn.Flatten(), nn.LazyLinear(n_outputs))
 
-    def _knows_geometry(self):
-        """True when n_chans and n_times are known (given or derivable), so the
-        head can be a real Linear instead of a LazyLinear that cannot be saved
-        or loaded before a forward pass."""
-        try:
-            self.n_chans, self.n_times
-        except ValueError:
-            return False
-        return True
-
-    def _n_patch(self):
-        if self._on_non_divisible == "pad":
-            return -(-self.n_times // self._patch_size)
-        return self.n_times // self._patch_size
-
     def _weights_init(self):
         for m in self.modules():
             if isinstance(m, nn.Linear):

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/deep4.py

@@ -162,18 +162,10 @@ class Deep4Net(EEGModuleMixin, nn.Sequential):
         self.stride_before_pool = stride_before_pool
 
         min_n_times = self._get_min_n_times()
-        resolved_n_times = self._n_times
-        if (
-            resolved_n_times is None
-            and self._input_window_seconds is not None
-            and self._sfreq is not None
-        ):
-            resolved_n_times = round(self._input_window_seconds * self._sfreq)
-
-        if resolved_n_times is not None and resolved_n_times < min_n_times:
-            scaling_factor = resolved_n_times / min_n_times
+        if self.n_times < min_n_times:
+            scaling_factor = self.n_times / min_n_times
             warn(
-                f"n_times ({resolved_n_times}) is smaller than the minimum required "
+                f"n_times ({self.n_times}) is smaller than the minimum required "
                 f"({min_n_times}) for the current model parameters configuration. "
                 "Adjusting parameters to ensure compatibility."
                 "Reducing the kernel, pooling, and stride sizes accordingly."
@@ -225,7 +217,7 @@ class Deep4Net(EEGModuleMixin, nn.Sequential):
                     in_chans=self.n_chans,
                     n_filters_time=self.n_filters_time,
                     n_filters_spat=self.n_filters_spat,
-                    filter_time_length=self.filter_time_length,
+                    filter_time_length=filter_time_length,
                     bias_time=True,
                     bias_spat=not self.batch_norm,
                     stride=(conv_stride, 1),

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/eegdino.py

@@ -477,10 +477,7 @@ class _Attention(nn.Module):
 
     def forward(self, x):
         bias = torch.cat((self.q_bias, torch.zeros_like(self.v_bias), self.v_bias))
-        # Call the ``qkv`` module rather than ``F.linear`` on its weight, so
-        # hooks and adapters attached to it (e.g. LoRA) take part in the forward.
-        qkv = self.qkv(x)
-        qkv = qkv + bias.to(qkv.dtype)  # keep autocast dtype
+        qkv = F.linear(x, self.qkv.weight, bias)
         batch, tokens, _ = qkv.shape
         query, key, value = (
             qkv.reshape(batch, tokens, 3, self.nhead, -1)

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/labram.py

@@ -19,7 +19,6 @@ from torch.nn.init import trunc_normal_
 from braindecode.functional import rescale_parameter
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import MLP, DropPath
-from braindecode.modules.blocks import PatchTokenizer
 
 # -----------------------------------------------------------------------------
 # Standard 10-20 system electrode positions used by LaBraM for position embeddings.
@@ -285,10 +284,6 @@ class Labram(EEGModuleMixin, nn.Module):
 
     Parameters
     ----------
-    on_non_divisible : {"pad", "crop", "error"}, default="pad"
-        How :class:`~braindecode.modules.PatchTokenizer` treats a time axis that
-        is not a multiple of ``patch_size``: right-pad with zeros (default),
-        crop the trailing samples, or raise.
     patch_size : int
         The size of the patch to be used in the patch embedding.
     learned_patcher : bool
@@ -372,7 +367,6 @@ class Labram(EEGModuleMixin, nn.Module):
         input_window_seconds=None,
         patch_size=200,
         learned_patcher=False,
-        on_non_divisible="pad",
         embed_dim=200,
         conv_in_channels=1,
         conv_out_channels=8,
@@ -437,12 +431,7 @@ class Labram(EEGModuleMixin, nn.Module):
             self.embed_dim = None
         else:
             self.patch_size = patch_size
-        self.on_non_divisible = on_non_divisible
-        self.n_path = (
-            -(-self.n_times // self.patch_size)
-            if on_non_divisible == "pad"
-            else self.n_times // self.patch_size
-        )
+        self.n_path = self.n_times // self.patch_size
 
         if neural_tokenizer and conv_in_channels != 1:
             warn(
@@ -467,7 +456,6 @@ class Labram(EEGModuleMixin, nn.Module):
                                 n_chans=self.n_chans,
                                 emb_dim=self.patch_size,
                                 learned_patcher=learned_patcher,
-                                on_non_divisible=on_non_divisible,
                             ),
                         ),
                         (
@@ -1018,28 +1006,13 @@ class _SegmentPatch(nn.Module):
     """
 
     def __init__(
-        self,
-        n_times=2000,
-        patch_size=200,
-        n_chans=1,
-        emb_dim=200,
-        learned_patcher=True,
-        on_non_divisible="pad",
+        self, n_times=2000, patch_size=200, n_chans=1, emb_dim=200, learned_patcher=True
     ):
         super().__init__()
 
         self.n_times = n_times
         self.patch_size = patch_size
-        # Single place that pads/crops/rejects a non-divisible time axis
-        # (no parameters, so checkpoints are unaffected).
-        self.tokenizer = PatchTokenizer(
-            patch_size=patch_size, n_times=n_times, on_non_divisible=on_non_divisible
-        )
-        self.n_patchs = (
-            -(-n_times // patch_size)
-            if on_non_divisible == "pad"
-            else n_times // patch_size
-        )
+        self.n_patchs = n_times // patch_size
         self.emb_dim = emb_dim
         self.n_chans = n_chans
         self.learned_patcher = learned_patcher
@@ -1069,7 +1042,6 @@ class _SegmentPatch(nn.Module):
         X_patch: Tensor
             [batch, n_chans, n_times//patch_size, patch_size]
         """
-        x = self.tokenizer._prepare_input(x)
         batch_size, n_chans_actual, n_times_actual = x.shape
         # Input shape: [batch, n_chs, n_times]
 
@@ -1131,12 +1103,7 @@ class _PatchEmbed(nn.Module):
     """
 
     def __init__(
-        self,
-        n_times=2000,
-        patch_size=200,
-        in_channels=1,
-        emb_dim=200,
-        n_codebooks=62,
+        self, n_times=2000, patch_size=200, in_channels=1, emb_dim=200, n_codebooks=62
     ):
         super().__init__()
         self.n_times = n_times
@@ -1188,6 +1155,10 @@ class _PatchEmbed(nn.Module):
                 "4D (batch, channels, n_patches, patch_size)."
             )
 
+        if n_times % self.patch_size != 0:
+            raise ValueError(
+                f"n_times ({n_times}) must be divisible by patch_size ({self.patch_size})."
+            )
         if n_channels % self.in_channels != 0:
             raise ValueError(
                 "The input channel dimension "
@@ -1366,11 +1337,7 @@ class _Attention(nn.Module):
                     self.v_bias,
                 )
             )
-        # Call the ``qkv`` module rather than ``linear`` on its weight, so hooks
-        # and adapters attached to it (e.g. LoRA) take part in the forward.
-        qkv = self.qkv(x)
-        if qkv_bias is not None:
-            qkv = qkv + qkv_bias.to(qkv.dtype)  # keep autocast dtype
+        qkv = nn.functional.linear(input=x, weight=self.qkv.weight, bias=qkv_bias)
         qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
         q, k, v = (
             qkv[0],

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/luna.py

@@ -25,7 +25,6 @@ from einops import rearrange
 from braindecode.functional import rotate_pairs
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
-from braindecode.modules.blocks import PatchTokenizer
 from braindecode.modules.layers import DropPath
 
 
@@ -90,9 +89,6 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
 
     Parameters
     ----------
-    on_non_divisible : {"pad", "crop", "error"}, default="pad"
-        How :class:`~braindecode.modules.PatchTokenizer` treats a time axis that
-        is not a multiple of ``patch_size`` (right zero-pad, crop, or raise).
     patch_size : int
         Number of time samples per patch. Default: 40.
     num_queries : int
@@ -133,7 +129,6 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
         input_window_seconds: Optional[float] = None,
         # Model-specific parameters
         patch_size: int = 40,
-        on_non_divisible: str = "pad",
         num_queries: int = 4,
         embed_dim: int = 64,
         depth: int = 8,
@@ -171,11 +166,6 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
         self.embed_dim = embed_dim
         self.num_queries = num_queries
         self.patch_size = patch_size
-        self.tokenizer = PatchTokenizer(
-            patch_size=patch_size,
-            n_times=self.n_times if self._n_times is not None else patch_size,
-            on_non_divisible=on_non_divisible,
-        )
         self.patch_embed_size = embed_dim
         self.num_heads = num_heads
         self.depth = depth
@@ -187,9 +177,7 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
 
         # Layers
         self.patch_embed = _PatchEmbedNetwork(
-            embed_dim=self.embed_dim,
-            patch_size=self.patch_size,
-            on_non_divisible=on_non_divisible,
+            embed_dim=self.embed_dim, patch_size=self.patch_size
         )
         self.freq_embed = _FrequencyFeatureEmbedder(
             embed_dim=self.embed_dim, patch_size=self.patch_size
@@ -281,9 +269,6 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
         mask: Optional[torch.Tensor] = None,
     ) -> Tuple[torch.Tensor, torch.Tensor]:
         num_channels = channel_locations.shape[1]
-        x_signal = self.tokenizer._prepare_input(x_signal)
-        if mask is not None:
-            mask = self.tokenizer._prepare_input(mask)
         num_patches_per_channel = x_signal.shape[-1] // self.patch_size
         x_patched = self.patch_embed(x_signal)
         freq_embed = self.freq_embed(x_signal)
@@ -843,15 +828,10 @@ class _CrossAttentionBlock(nn.Module):
 
 
 class _PatchEmbedNetwork(nn.Module):
-    def __init__(
-        self, embed_dim: int = 64, patch_size: int = 40, on_non_divisible: str = "pad"
-    ) -> None:
+    def __init__(self, embed_dim: int = 64, patch_size: int = 40) -> None:
         super().__init__()
         self.patch_size = patch_size
         self.embed_dim = embed_dim
-        self.tokenizer = PatchTokenizer(
-            patch_size=patch_size, n_times=patch_size, on_non_divisible=on_non_divisible
-        )
         self.in_channels = 1
         self.out_channels = int(embed_dim // 4)
         self.groups = 4
@@ -891,7 +871,7 @@ class _PatchEmbedNetwork(nn.Module):
         x: (B, C, T)
         output: (B, C*S, D) where S = T//patch_size, D = embed_dim
         """
-        x = rearrange(self.tokenizer(x), "B C S P -> B (C S) P")
+        x = rearrange(x, "B C (S P) -> B (C S) P", P=self.patch_size)
         x = x.unsqueeze(1)
         x = self.proj_in(x)
         x = rearrange(x, "B E CS D -> B CS (D E)")

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/shallow_fbcsp.py

@@ -124,18 +124,13 @@ class ShallowFBCSPNet(EEGModuleMixin, nn.Sequential):
         self.drop_prob = drop_prob
 
         self.mapping = {
+            "conv_time.weight": "conv_time_spat.conv_time.weight",
+            "conv_spat.weight": "conv_time_spat.conv_spat.weight",
+            "conv_time.bias": "conv_time_spat.conv_time.bias",
+            "conv_spat.bias": "conv_time_spat.conv_spat.bias",
             "conv_classifier.weight": "final_layer.conv_classifier.weight",
             "conv_classifier.bias": "final_layer.conv_classifier.bias",
         }
-        if self.split_first_layer:
-            self.mapping.update(
-                {
-                    "conv_time.weight": "conv_time_spat.conv_time.weight",
-                    "conv_spat.weight": "conv_time_spat.conv_spat.weight",
-                    "conv_time.bias": "conv_time_spat.conv_time.bias",
-                    "conv_spat.bias": "conv_time_spat.conv_spat.bias",
-                }
-            )
 
         self.add_module("ensuredims", Ensure4d())
         pool_class = dict(max=nn.MaxPool2d, mean=nn.AvgPool2d)[self.pool_mode]
@@ -208,16 +203,14 @@ class ShallowFBCSPNet(EEGModuleMixin, nn.Sequential):
         self.add_module("final_layer", module)
 
         # Initialization, xavier is same as in paper...
-        if self.split_first_layer:
-            init.xavier_uniform_(self.conv_time_spat.conv_time.weight, gain=1)
+        init.xavier_uniform_(self.conv_time_spat.conv_time.weight, gain=1)
+        # maybe no bias in case of no split layer and batch norm
+        if self.split_first_layer or (not self.batch_norm):
             init.constant_(self.conv_time_spat.conv_time.bias, 0)
+        if self.split_first_layer:
             init.xavier_uniform_(self.conv_time_spat.conv_spat.weight, gain=1)
             if not self.batch_norm:
                 init.constant_(self.conv_time_spat.conv_spat.bias, 0)
-        else:
-            init.xavier_uniform_(self.conv_time.weight, gain=1)
-            if not self.batch_norm:
-                init.constant_(self.conv_time.bias, 0)
         if self.batch_norm:
             init.constant_(self.bnorm.weight, 1)
             init.constant_(self.bnorm.bias, 0)

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/signal_jepa.py

@@ -1593,10 +1593,7 @@ def _pos_encode_contineous(
         (1 - torch.arange(0, n_dim, 2, device=device) / n_dim) * 2 * math.pi
     )
     pos_encoding = torch.empty((n_dim,), dtype=torch.float32, device=device)
-    # Zero span when every ``loc`` is zero (names without positions): encode
-    # xx = 0 instead of the NaN of 0/0.
-    span = x_max - x_min
-    xx = (x - x_min) / span if span != 0 else 0.0
+    xx = (x - x_min) / (x_max - x_min)
     pos_encoding[0::2] = torch.sin(xx * div_term)
     pos_encoding[1::2] = torch.cos(xx * div_term)
     return pos_encoding

{braindecode-1.8.1.dev180519461 → braindecode-1.8.1.dev180667301}/braindecode/models/summary.csv

@@ -7,7 +7,6 @@ BIOT,"Sleep Staging, Epilepsy",Prediction,200,"n_chans, n_outputs",3183879,"BIOT
 BrainBERT,General,"Prediction, Embedding",2048,"n_chans, n_outputs, n_times",603269,"BrainBERT(n_chans=2, n_outputs=5, n_times=2048)","Foundation Model,Attention/Transformer",iEEG
 CBraMod,General,"Prediction, Embedding",200,"n_outputs",4924000,"CBraMod(n_outputs=2)","Foundation Model",EEG
 CodeBrain,General,"Prediction, Embedding",200,"n_chans, n_outputs, n_times",15238802,"CodeBrain(n_chans=19, n_outputs=2, n_times=6000)","Foundation Model,Attention/Transformer",EEG
-CSBrain,General,"Prediction, Embedding",200,"n_outputs",10962402,"CSBrain(n_outputs=2)","Foundation Model,Attention/Transformer",EEG
 ContraWR,Sleep Staging,"Prediction, Embedding",125,"n_chans, n_outputs, sfreq",1160165,"ContraWR(n_chans=2, n_outputs=5, n_times=3750, emb_size=256, sfreq=125)",Convolution,EEG
 CTNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",26900,"CTNet(n_chans=22, n_outputs=4, n_times=1000, n_filters_time=8, kernel_size=16, num_heads=2, embed_dim=16)","Convolution,Attention/Transformer",EEG
 Deep4Net,General,Prediction,250,"n_chans, n_outputs, n_times",282879,"Deep4Net(n_chans=22, n_outputs=4, n_times=1000)","Convolution",EEG
@@ -57,7 +56,6 @@ PopulationTransformer,General,"Prediction, Embedding",2048,"n_chans, n_outputs,
 SSTDPN,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",19502,"SSTDPN(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer",EEG
 BENDR,General,"Prediction, Embedding",250,"n_chans, n_times, n_outputs",157141049,"BENDR(n_chans=22, n_outputs=4, n_times=1000)","Foundation Model,Convolution",EEG
 LUNA,General,"Prediction, Embedding",128,"n_chans, n_times, sfreq, chs_info",7100731,"LUNA(n_chans=22, n_times=512, sfreq=128)","Convolution,Channel,Foundation Model",EEG
-MAPA,General,"Prediction, Embedding",2048,"chs_info, n_outputs, n_times",21341572,"MAPA(chs_info=<user>, n_outputs=4, n_times=2048, sfreq=2048)","Attention/Transformer,Foundation Model,Channel",iEEG
 MEDFormer,General,Prediction,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Foundation Model,Convolution",EEG
 REVE,General,Prediction,200,"n_outputs, n_times, n_chans",69481476,"REVE(n_times=1000, n_outputs=4, n_chans=19)","Foundation Model,Attention/Transformer",EEG
 DGCNN,Emotion Recognition,Prediction,128,"n_chans, n_outputs, n_times, chs_info",1037385,"DGCNN(n_chans=62, n_outputs=4, n_times=128)","Graph Neural Network,Channel",EEG
@@ -67,8 +65,6 @@ InterpolatedBIOT,"Sleep Staging, Epilepsy",Prediction,200,"chs_info, n_outputs,
 InterpolatedEEGPT,General,Prediction,256,"chs_info, n_outputs, n_times",25323137,"InterpolatedEEGPT(chs_info=<user>, n_outputs=4, n_times=1024)","Foundation Model,Attention/Transformer,Channel",EEG
 InterpolatedLaBraM,General,"Prediction, Embedding",200,"chs_info, n_outputs, n_times",5866196,"InterpolatedLaBraM(chs_info=<user>, n_outputs=4, n_times=1000)","Convolution,Foundation Model,Channel",EEG
 InterpolatedSignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"chs_info",3456882,"InterpolatedSignalJEPA(chs_info=<user>)","Convolution,Channel,Foundation Model",EEG
-BrainOmni,General,"Prediction, Embedding",256,"chs_info, n_outputs, n_times, sfreq",13998310,"BrainOmni(chs_info=chs_info, n_outputs=4, n_times=1024, sfreq=256.0)","Foundation Model,Attention/Transformer","EEG, MEG"
-BrainTokenizer,General,Embedding,256,"chs_info, n_times, sfreq",5050338,"BrainTokenizer(chs_info=chs_info, n_times=1024, sfreq=256.0)","Foundation Model","EEG, MEG"
 TCFormer,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",77820,"TCFormer(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer",EEG
 EEGDINO,General,Classification,200,"n_chans, n_outputs, n_times",4539698,"EEGDINO(n_chans=19, n_outputs=4, n_times=1000)","Foundation Model,Attention/Transformer",EEG
 DANCE,General,Event Detection,200,"n_chans, n_outputs, n_times, sfreq, chs_info",29813542,"DANCE(n_chans=19, n_outputs=4, n_times=6400, sfreq=200, input_window_seconds=32.0, chs_info=[{'ch_name': f'E{i+1}', 'kind': 'eeg', 'loc': numpy.random.default_rng(2024).random(12)} for i in range(19)])","Convolution,Attention/Transformer,Channel",EEG
@@ -76,5 +72,3 @@ STEEGFormer,General,Classification,250,"n_chans, n_outputs, n_times",25305604,"S
 MVPFormer,General,"Prediction, Embedding",512,"n_chans, n_outputs, n_times, sfreq",3356978,"MVPFormer(n_chans=22, n_outputs=4, n_times=2000, sfreq=100)","Foundation Model,Attention/Transformer",EEG
 ZUNA,General,"Classification,Embedding",256,"chs_info, n_outputs, n_times",172104100,"ZUNA(chs_info=<user>, n_outputs=4, n_times=1280)","Foundation Model,Channel,Attention/Transformer",EEG
 MIRepNet,Motor Imagery,"Prediction, Embedding",250,"n_chans, n_outputs",5143300,"MIRepNet(n_chans=45, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer,Foundation Model",EEG
-NeuroRVQ,General,"Prediction, Embedding",200,"n_chans, n_outputs, n_times, sfreq, channel_names",7097892,"NeuroRVQ(n_chans=64, n_outputs=4, n_times=800, sfreq=200)","Convolution,Attention/Transformer,Foundation Model,Channel",EEG
-SeizureTransformer,Epilepsy,Event Detection,256,"n_chans, n_outputs, n_times",37848897,"SeizureTransformer(n_chans=19, n_outputs=1, n_times=15360)","Convolution,Attention/Transformer",EEG