Braindecode 1.6.1.dev169782001__tar.gz → 1.6.1.dev171935310__tar.gz

{braindecode-1.6.1.dev169782001/braindecode.egg-info → braindecode-1.6.1.dev171935310}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.6.1.dev169782001
+Version: 1.6.1.dev171935310
 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.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/functional/__init__.py

@@ -5,7 +5,6 @@ from .functions import (
     identity,
     plv_time,
     safe_log,
-    sinusoidal_positional_encoding,
     square,
 )
 from .initialization import glorot_weight_zero_bias, rescale_parameter
@@ -17,7 +16,6 @@ __all__ = [
     "identity",
     "plv_time",
     "safe_log",
-    "sinusoidal_positional_encoding",
     "square",
     "glorot_weight_zero_bias",
     "rescale_parameter",

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/functional/functions.py

@@ -2,8 +2,6 @@
 #
 # License: BSD (3-clause)
 
-import math
-
 import torch
 import torch.nn.functional as F
 
@@ -251,40 +249,3 @@ def plv_time(x, forward_fourier=True, epsilon: float = 1e-6):
     )
 
     return plv_matrix
-
-
-def sinusoidal_positional_encoding(n_positions: int, dim: int) -> torch.Tensor:
-    r"""Fixed sine/cosine positional-encoding table of shape ``(n_positions, dim)``.
-
-    The standard encoding of Vaswani et al. (2017): for position :math:`p` and
-    channel :math:`i`, :math:`pe[p, 2i] = \sin(p / 10000^{2i/d})` and
-    :math:`pe[p, 2i+1] = \cos(p / 10000^{2i/d})`. PyTorch ships no sinusoidal
-    encoding (``nn.Embedding`` is a *learned* lookup), so braindecode models that
-    need one share this primitive instead of re-deriving it. An odd ``dim`` is
-    computed on the next even width and truncated, reproducing the per-model
-    wrappers (e.g. :class:`~braindecode.models.medformer` odd-``d_model``).
-
-    Parameters
-    ----------
-    n_positions : int
-        Number of positions (sequence length) to encode.
-    dim : int
-        Embedding dimension of each position.
-
-    Returns
-    -------
-    torch.Tensor
-        ``(n_positions, dim)`` float table; callers add their own batch axis,
-        dropout, or offset.
-    """
-    dim_even = dim + (dim % 2)
-    position = torch.arange(n_positions).unsqueeze(1).float()
-    div_term = torch.exp(
-        torch.arange(0, dim_even, 2).float() * (-math.log(10000.0) / dim_even)
-    )
-    pe = torch.zeros(n_positions, dim_even)
-    pe[:, 0::2] = torch.sin(position * div_term)
-    pe[:, 1::2] = torch.cos(position * div_term)
-    # ``.contiguous()`` so an odd-``dim`` truncation owns tight storage -- a
-    # non-contiguous view over the padded width breaks safetensors buffer saving.
-    return pe[:, :dim].contiguous()

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/models/biot.py

@@ -1,3 +1,4 @@
+import math
 from warnings import warn
 
 import numpy as np
@@ -5,7 +6,6 @@ import torch
 import torch.nn as nn
 from linear_attention_transformer import LinearAttentionTransformer
 
-from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.models.base import EEGModuleMixin
 
 # -----------------------------------------------------------------------------
@@ -388,8 +388,15 @@ class _PositionalEncoding(nn.Module):
     def __init__(self, emb_size: int, drop_prob: float = 0.1, max_len: int = 1000):
         super(_PositionalEncoding, self).__init__()
 
-        # Compute the positional encodings once (shared sinusoidal primitive).
-        pe = sinusoidal_positional_encoding(max_len, emb_size).unsqueeze(0)
+        # Compute the positional encodings once in log space.
+        pe = torch.zeros(max_len, emb_size)
+        position = torch.arange(0, max_len).unsqueeze(1).float()
+        div_term = torch.exp(
+            torch.arange(0, emb_size, 2).float() * -(math.log(10000.0) / emb_size)
+        )
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0)
         self.register_buffer("pe", pe)
         self.dropout = nn.Dropout(p=drop_prob)
 

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/models/fbmsnet.py

@@ -75,9 +75,6 @@ class FBMSNet(EEGModuleMixin, nn.Module):
         Maximum norm constraint for the convolutional layers.
     linear_max_norm : float, default=0.5
         Maximum norm constraint for the linear layers.
-    return_features : bool, default=False
-        If True, the forward method returns the class logits and the flattened
-        features before the final classification layer.
     filter_parameters : dict, default=None
         Dictionary of parameters to use for the FilterBankLayer.
         If None, a default Chebyshev Type II filter with transition bandwidth of
@@ -119,7 +116,6 @@ class FBMSNet(EEGModuleMixin, nn.Module):
         linear_max_norm: float = 0.5,
         verbose: bool = False,
         filter_parameters: dict[Any, Any] | None = None,
-        return_features: bool = False,
     ):
         super().__init__(
             n_chans=n_chans,
@@ -141,7 +137,6 @@ class FBMSNet(EEGModuleMixin, nn.Module):
         self.kernels_weights = kernels_weights
         self.filter_parameters = filter_parameters or {}
         self.out_channels_spatial = self.n_filters_spat * self.dilatability
-        self.return_features = return_features
 
         # Checkers
         if temporal_layer not in _valid_layers:
@@ -228,12 +223,8 @@ class FBMSNet(EEGModuleMixin, nn.Module):
 
         Returns
         -------
-        torch.Tensor or tuple[torch.Tensor, torch.Tensor]
-            Output tensor with shape (batch_size, n_outputs). If
-            ``return_features`` is True, a tuple containing the output tensor
-            and flattened features with shape
-            (batch_size, out_channels_spatial * stride_factor) is returned.
-            In TorchScript mode, only the output tensor is returned.
+        torch.Tensor
+            Output tensor with shape (batch_size, n_outputs).
         """
         batch, _, _ = x.shape
 
@@ -262,16 +253,12 @@ class FBMSNet(EEGModuleMixin, nn.Module):
         # shape: (batch, self.out_channels_spatial, self.stride_factor, 1)
 
         # Flatten and classify
-        features = self.flatten_layer(x)
+        x = self.flatten_layer(x)
         # shape: (batch, self.out_channels_spatial*self.stride_factor)
 
-        logits = self.final_layer(features)
+        x = self.final_layer(x)
         # shape: (batch, n_outputs)
-        if torch.jit.is_scripting() or torch.jit.is_tracing():
-            return logits
-        if self.return_features:
-            return logits, features
-        return logits
+        return x
 
 
 class _MixedConv2d(nn.Module):

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/models/medformer.py

@@ -6,6 +6,7 @@
 
 """Medformer: A Multi-Granularity Patching Transformer for Medical Time-Series Classification."""
 
+import math
 from math import sqrt
 from typing import List, Optional, Tuple
 
@@ -13,7 +14,6 @@ import numpy as np
 import torch
 import torch.nn as nn
 
-from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.models.base import EEGModuleMixin
 
 
@@ -329,10 +329,28 @@ class MEDFormer(EEGModuleMixin, nn.Module):
 class _PositionalEmbedding(nn.Module):
     def __init__(self, d_model: int, max_len: int = 5000):
         super().__init__()
+        # If d_model is odd, temporarily work with d_model + 1.
+        if d_model % 2 == 1:
+            d_model_adj = d_model + 1
+        else:
+            d_model_adj = d_model
         self.d_model = d_model  # store the original dimension
-        # Odd d_model is handled inside the shared primitive (computed on the
-        # next even width and truncated), so no manual padding is needed here.
-        pe = sinusoidal_positional_encoding(max_len, d_model).unsqueeze(0)
+
+        # Create a pe tensor of size (max_len, d_model_adj)
+        pe = torch.zeros(max_len, d_model_adj).float()
+        pe.requires_grad = False
+
+        # Compute the sinusoidal factors.
+        position = torch.arange(0, max_len).float().unsqueeze(1)
+        # Use d_model_adj in the denominator so that the frequencies are computed over an even number.
+        div_term = torch.exp(
+            torch.arange(0, d_model_adj, 2).float() * (-math.log(10000.0) / d_model_adj)
+        )
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+
+        # Unsqueeze to shape (1, max_len, d_model_adj)
+        pe = pe.unsqueeze(0)
         self.register_buffer("pe", pe)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/models/steegformer.py

@@ -9,6 +9,7 @@ Port of Yang et al. (2026), https://github.com/LiuyinYang1101/STEEGFormer
 from __future__ import annotations
 
 import json
+import math
 import warnings
 from functools import lru_cache
 
@@ -17,7 +18,6 @@ from einops import rearrange
 from einops.layers.torch import Rearrange
 from torch import nn
 
-from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import (
     DropPath,
@@ -550,7 +550,13 @@ class _TemporalPositionalEncoding(nn.Module):
     def __init__(self, embed_dim: int, max_len: int = 2048):
         super().__init__()
         self.max_len = max_len
-        pe = sinusoidal_positional_encoding(max_len, embed_dim)
+        position = torch.arange(max_len).unsqueeze(1)
+        div_term = torch.exp(
+            torch.arange(0, embed_dim, 2) * (-math.log(10000.0) / embed_dim)
+        )
+        pe = torch.zeros(max_len, embed_dim)
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
         # Non-persistent: deterministic, regenerated identically at init.
         self.register_buffer("pe", pe, persistent=False)
 

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/models/summary.csv

@@ -1,61 +1,61 @@
-Model,Application,Type,Sampling Frequency (Hz),Hyperparameters,#Parameters,get_#Parameters,Categorization,Modality
-ATCNet,General,Prediction,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Recurrent,Attention/Transformer",EEG
-AttentionBaseNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",3692,"AttentionBaseNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer",EEG
-BDTCN,Normal Abnormal,Prediction,100,"n_chans, n_outputs, n_times",456502,"BDTCN(n_chans=21, n_outputs=2, n_times=6000, n_blocks=5, n_filters=55, kernel_size=16)","Convolution,Recurrent",EEG
-BIOT,"Sleep Staging, Epilepsy",Prediction,200,"n_chans, n_outputs",3183879,"BIOT(n_chans=2,  n_outputs=5,  n_times=6000)","Foundation Model",EEG
-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
-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
-DeepSleepNet,Sleep Staging,Prediction,256,"n_chans, n_outputs",24744837,"DeepSleepNet(n_chans=1, n_outputs=5, n_times=7680, sfreq=256)","Convolution,Recurrent",EEG
-EEGConformer,General,Prediction,250,"n_chans, n_outputs, n_times",789572,"EEGConformer(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer",EEG
-EEGPT,General,Prediction,256,"n_chans, n_outputs, n_times",25477635,"EEGPT(n_chans=58, n_outputs=4, n_times=1024)","Foundation Model,Attention/Transformer",EEG
-EEGInceptionERP,"ERP, SSVEP",Prediction,128,"n_chans, n_outputs",14926,"EEGInceptionERP(n_chans=8, n_outputs=2, n_times=128, sfreq=128)","Convolution",EEG
-EEGInceptionMI,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",558028,"EEGInceptionMI(n_chans=22, n_outputs=4, n_times=1000, n_convs=5, n_filters=12)","Convolution",EEG
-EEGITNet,Motor Imagery,Prediction,125,"n_chans, n_outputs, n_times",5212,"EEGITNet(n_chans=22,  n_outputs=4,  n_times=500)","Convolution,Recurrent",EEG
-EEGNet,General,Prediction,128,"n_chans, n_outputs, n_times",2484,"EEGNet(n_chans=22,  n_outputs=4,  n_times=512)","Convolution",EEG
-EEGNeX,Motor Imagery,Prediction,125,"n_chans, n_outputs, n_times",55940,"EEGNeX(n_chans=22,  n_outputs=4,  n_times=500)","Convolution",EEG
-EEGSym,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",299218,"EEGSym(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Channel",EEG
-EEGMiner,Emotion Recognition,Prediction,128,"n_chans, n_outputs, n_times, sfreq",7572,"EEGMiner(n_chans=62, n_outputs=2, n_times=2560, sfreq=128)","Convolution,Interpretability",EEG
-EEGSimpleConv,Motor Imagery,Prediction,80,"n_chans, n_outputs, sfreq",730404,"EEGSimpleConv(n_chans=22,  n_outputs=4,  n_times=320, sfreq=80)","Convolution",EEG
-EEGTCNet,Motor Imagery,Prediction,250,"n_chans, n_outputs",4516,"EEGTCNet(n_chans=22,  n_outputs=4,  n_times=1000, kern_length=32)","Convolution,Recurrent",EEG
-Labram,General,"Prediction, Embedding",200,"n_chans, n_outputs, n_times",5866180,"Labram(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Foundation Model",EEG
-MSVTNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",75494," MSVTNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution,Recurrent,Attention/Transformer",EEG
-SCCNet,Motor Imagery,Prediction,125,"n_chans, n_outputs, n_times, sfreq",12070,"SCCNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=125)","Convolution",EEG
-SignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"n_times, chs_info",3456882,"SignalJEPA(n_times=512, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Foundation Model",EEG
-SignalJEPA_Contextual,"Motor Imagery, ERP, SSVEP",Prediction,128,"n_outputs, n_times, chs_info",3459184,"SignalJEPA_Contextual(n_outputs=2, input_window_seconds=4.19, sfreq=128, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Foundation Model",EEG
-SignalJEPA_PostLocal,"Motor Imagery, ERP, SSVEP",Prediction,128,"n_chans, n_outputs, n_times",16142,"SignalJEPA_PostLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Foundation Model",EEG
-SignalJEPA_PreLocal,"Motor Imagery, ERP, SSVEP",Prediction,128,"n_outputs, n_times, chs_info",16142,"SignalJEPA_PreLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Foundation Model",EEG
-SincShallowNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",21892,"SincShallowNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution,Interpretability",EEG
-ShallowFBCSPNet,General,Prediction,250,"n_chans, n_outputs, n_times",46084,"ShallowFBCSPNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution",EEG
-SleepStagerBlanco2020,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times",2845,"SleepStagerBlanco2020(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution",EEG
-SleepStagerChambon2018,Sleep Staging,Prediction,128,"n_chans, n_outputs, n_times, sfreq",5835,"SleepStagerChambon2018(n_chans=2, n_outputs=5, n_times=3840, sfreq=128)","Convolution",EEG
-AttnSleep,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times, sfreq",719925,"AttnSleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Attention/Transformer",EEG
-SPARCNet,Epilepsy,Prediction,200,"n_chans, n_outputs, n_times",1141921,"SPARCNet(n_chans=16, n_outputs=6, n_times=2000, sfreq=200)","Convolution",EEG
-SyncNet,"Emotion Recognition, Alcoholism",Prediction,256,"n_chans, n_outputs, n_times",554,"SyncNet(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Interpretability",EEG
-TSception,Emotion Recognition,Prediction,256,"n_chans, n_outputs, n_times, sfreq",2187206,"TSception(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Convolution",EEG
-TIDNet,General,Prediction,250,"n_chans, n_outputs, n_times",240404,"TIDNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution",EEG
-USleep,Sleep Staging,Prediction,128,"n_chans, n_outputs, n_times, sfreq",2482011,"USleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution",EEG
-FBCNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",11812,"FCNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank",EEG
-FBMSNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",16231,"FBMSNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank",EEG
-MetaNeuromotorHand,Handwriting (sEMG),CTC Sequence,2000,"n_chans, n_outputs, n_times, sfreq",1021284,"MetaNeuromotorHand(n_chans=16, n_outputs=100, n_times=32000, sfreq=2000)","Convolution,Attention/Transformer",sEMG
-EMG2QwertyNet,Touch typing (sEMG),CTC Sequence,2000,"n_chans, n_outputs, n_times, sfreq",5293315,"EMG2QwertyNet(n_chans=32, n_outputs=99, n_times=8000, sfreq=2000)","Convolution",sEMG
-FBLightConvNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",6596,"FBLightConvNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank",EEG
-IFNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",9860,"IFNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank",EEG
-BrainModule,Speech Decoding,Prediction,250,"n_chans, n_outputs, n_times, sfreq",6186909,"BrainModule(n_chans=64, n_outputs=29, n_times=160, sfreq=1000)","Convolution","EEG, MEG"
-PBT,General,Prediction,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Foundation Model",EEG
-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
-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
-InterpolatedBENDR,General,"Prediction, Embedding",250,"chs_info, n_outputs, n_times",157143101,"InterpolatedBENDR(chs_info=<user>, n_outputs=4, n_times=1000)","Foundation Model,Convolution,Channel",EEG
-InterpolatedBIOT,"Sleep Staging, Epilepsy",Prediction,200,"chs_info, n_outputs, n_times, sfreq",3184101,"InterpolatedBIOT(chs_info=<user>, n_outputs=5, sfreq=200, n_times=6000)","Foundation Model,Channel",EEG
-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
-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
-STEEGFormer,General,Classification,250,"n_chans, n_outputs, n_times",25305604,"STEEGFormer(n_chans=22, n_outputs=4, n_times=1000)","Attention/Transformer,Foundation Model",EEG
+Model,Application,Type,Sampling Frequency (Hz),Hyperparameters,#Parameters,get_#Parameters,Categorization
+ATCNet,General,Prediction,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Recurrent,Attention/Transformer"
+AttentionBaseNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",3692,"AttentionBaseNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer"
+BDTCN,Normal Abnormal,Prediction,100,"n_chans, n_outputs, n_times",456502,"BDTCN(n_chans=21, n_outputs=2, n_times=6000, n_blocks=5, n_filters=55, kernel_size=16)","Convolution,Recurrent"
+BIOT,"Sleep Staging, Epilepsy",Prediction,200,"n_chans, n_outputs",3183879,"BIOT(n_chans=2,  n_outputs=5,  n_times=6000)","Foundation Model"
+CBraMod,General,"Prediction, Embedding",200,"n_outputs",4924000,"CBraMod(n_outputs=2)","Foundation Model"
+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"
+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
+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"
+Deep4Net,General,Prediction,250,"n_chans, n_outputs, n_times",282879,"Deep4Net(n_chans=22, n_outputs=4, n_times=1000)","Convolution"
+DeepSleepNet,Sleep Staging,Prediction,256,"n_chans, n_outputs",24744837,"DeepSleepNet(n_chans=1, n_outputs=5, n_times=7680, sfreq=256)","Convolution,Recurrent"
+EEGConformer,General,Prediction,250,"n_chans, n_outputs, n_times",789572,"EEGConformer(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer"
+EEGPT,General,Prediction,256,"n_chans, n_outputs, n_times",25477635,"EEGPT(n_chans=58, n_outputs=4, n_times=1024)","Foundation Model,Attention/Transformer"
+EEGInceptionERP,"ERP, SSVEP",Prediction,128,"n_chans, n_outputs",14926,"EEGInceptionERP(n_chans=8, n_outputs=2, n_times=128, sfreq=128)","Convolution"
+EEGInceptionMI,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",558028,"EEGInceptionMI(n_chans=22, n_outputs=4, n_times=1000, n_convs=5, n_filters=12)","Convolution"
+EEGITNet,Motor Imagery,Prediction,125,"n_chans, n_outputs, n_times",5212,"EEGITNet(n_chans=22,  n_outputs=4,  n_times=500)","Convolution,Recurrent"
+EEGNet,General,Prediction,128,"n_chans, n_outputs, n_times",2484,"EEGNet(n_chans=22,  n_outputs=4,  n_times=512)","Convolution"
+EEGNeX,Motor Imagery,Prediction,125,"n_chans, n_outputs, n_times",55940,"EEGNeX(n_chans=22,  n_outputs=4,  n_times=500)","Convolution"
+EEGSym,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",299218,"EEGSym(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Channel"
+EEGMiner,Emotion Recognition,Prediction,128,"n_chans, n_outputs, n_times, sfreq",7572,"EEGMiner(n_chans=62, n_outputs=2, n_times=2560, sfreq=128)","Convolution,Interpretability"
+EEGSimpleConv,Motor Imagery,Prediction,80,"n_chans, n_outputs, sfreq",730404,"EEGSimpleConv(n_chans=22,  n_outputs=4,  n_times=320, sfreq=80)","Convolution"
+EEGTCNet,Motor Imagery,Prediction,250,"n_chans, n_outputs",4516,"EEGTCNet(n_chans=22,  n_outputs=4,  n_times=1000, kern_length=32)","Convolution,Recurrent"
+Labram,General,"Prediction, Embedding",200,"n_chans, n_outputs, n_times",5866180,"Labram(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Foundation Model"
+MSVTNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times",75494," MSVTNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution,Recurrent,Attention/Transformer"
+SCCNet,Motor Imagery,Prediction,125,"n_chans, n_outputs, n_times, sfreq",12070,"SCCNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=125)","Convolution"
+SignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"n_times, chs_info",3456882,"SignalJEPA(n_times=512, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Foundation Model"
+SignalJEPA_Contextual,"Motor Imagery, ERP, SSVEP",Prediction,128,"n_outputs, n_times, chs_info",3459184,"SignalJEPA_Contextual(n_outputs=2, input_window_seconds=4.19, sfreq=128, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Foundation Model"
+SignalJEPA_PostLocal,"Motor Imagery, ERP, SSVEP",Prediction,128,"n_chans, n_outputs, n_times",16142,"SignalJEPA_PostLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Foundation Model"
+SignalJEPA_PreLocal,"Motor Imagery, ERP, SSVEP",Prediction,128,"n_outputs, n_times, chs_info",16142,"SignalJEPA_PreLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Foundation Model"
+SincShallowNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",21892,"SincShallowNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution,Interpretability"
+ShallowFBCSPNet,General,Prediction,250,"n_chans, n_outputs, n_times",46084,"ShallowFBCSPNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution"
+SleepStagerBlanco2020,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times",2845,"SleepStagerBlanco2020(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution"
+SleepStagerChambon2018,Sleep Staging,Prediction,128,"n_chans, n_outputs, n_times, sfreq",5835,"SleepStagerChambon2018(n_chans=2, n_outputs=5, n_times=3840, sfreq=128)","Convolution"
+AttnSleep,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times, sfreq",719925,"AttnSleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Attention/Transformer"
+SPARCNet,Epilepsy,Prediction,200,"n_chans, n_outputs, n_times",1141921,"SPARCNet(n_chans=16, n_outputs=6, n_times=2000, sfreq=200)","Convolution"
+SyncNet,"Emotion Recognition, Alcoholism",Prediction,256,"n_chans, n_outputs, n_times",554,"SyncNet(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Interpretability"
+TSception,Emotion Recognition,Prediction,256,"n_chans, n_outputs, n_times, sfreq",2187206,"TSception(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Convolution"
+TIDNet,General,Prediction,250,"n_chans, n_outputs, n_times",240404,"TIDNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution"
+USleep,Sleep Staging,Prediction,128,"n_chans, n_outputs, n_times, sfreq",2482011,"USleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution"
+FBCNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",11812,"FCNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
+FBMSNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",16231,"FBMSNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
+MetaNeuromotorHand,Handwriting (sEMG),CTC Sequence,2000,"n_chans, n_outputs, n_times, sfreq",1021284,"MetaNeuromotorHand(n_chans=16, n_outputs=100, n_times=32000, sfreq=2000)","Convolution,Attention/Transformer"
+EMG2QwertyNet,Touch typing (sEMG),CTC Sequence,2000,"n_chans, n_outputs, n_times, sfreq",5293315,"EMG2QwertyNet(n_chans=32, n_outputs=99, n_times=8000, sfreq=2000)","Convolution"
+FBLightConvNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",6596,"FBLightConvNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
+IFNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq",9860,"IFNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
+BrainModule,Speech Decoding,Prediction,250,"n_chans, n_outputs, n_times, sfreq",6186909,"BrainModule(n_chans=64, n_outputs=29, n_times=160, sfreq=1000)","Convolution"
+PBT,General,Prediction,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Foundation Model"
+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"
+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"
+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"
+MEDFormer,General,Prediction,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Foundation Model,Convolution"
+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"
+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"
+InterpolatedBENDR,General,"Prediction, Embedding",250,"chs_info, n_outputs, n_times",157143101,"InterpolatedBENDR(chs_info=<user>, n_outputs=4, n_times=1000)","Foundation Model,Convolution,Channel"
+InterpolatedBIOT,"Sleep Staging, Epilepsy",Prediction,200,"chs_info, n_outputs, n_times, sfreq",3184101,"InterpolatedBIOT(chs_info=<user>, n_outputs=5, sfreq=200, n_times=6000)","Foundation Model,Channel"
+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"
+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"
+InterpolatedSignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"chs_info",3456882,"InterpolatedSignalJEPA(chs_info=<user>)","Convolution,Channel,Foundation Model"
+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"
+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"
+STEEGFormer,General,Classification,250,"n_chans, n_outputs, n_times",25305604,"STEEGFormer(n_chans=22, n_outputs=4, n_times=1000)","Attention/Transformer,Foundation Model"

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/modules/__init__.py

@@ -1,4 +1,4 @@
-from .activation import GatedLinearUnit, LogActivation, SafeLog, Square
+from .activation import LogActivation, SafeLog, Square
 from .attention import (
     CAT,
     CBAM,
@@ -50,7 +50,6 @@ from .util import aggregate_probas
 from .wrapper import Expression, IntermediateOutputWrapper
 
 __all__ = [
-    "GatedLinearUnit",
     "LogActivation",
     "SafeLog",
     "Square",

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/braindecode/modules/activation.py

@@ -104,37 +104,3 @@ class LogActivation(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         return torch.log(x + self.epsilon)  # Adding epsilon to prevent log(0)
-
-
-class GatedLinearUnit(nn.Module):
-    r"""Generalized gated linear unit (GLU family).
-
-    Splits the last dimension in half into a ``value`` and a ``gate`` and
-    returns :math:`\text{value} \otimes \text{activation}(\text{gate})`. With the
-    default ``activation=nn.GELU`` this is **GEGLU** (Shazeer, 2020); ``nn.SiLU``
-    gives SwiGLU and ``nn.Sigmoid`` the original GLU. Unlike
-    :class:`torch.nn.GLU`, the gate nonlinearity is configurable (``torch.nn.GLU``
-    is hard-wired to the sigmoid).
-
-    Parameters
-    ----------
-    activation : type[nn.Module], default=nn.GELU
-        Constructor of the gate activation. The default yields GEGLU.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import GatedLinearUnit
-    >>> module = GatedLinearUnit()
-    >>> outputs = module(torch.randn(2, 10, 16))
-    >>> outputs.shape
-    torch.Size([2, 10, 8])
-    """
-
-    def __init__(self, activation: type[nn.Module] = nn.GELU):
-        super().__init__()
-        self.activation = activation()
-
-    def forward(self, x: Tensor) -> Tensor:
-        value, gate = x.chunk(2, dim=-1)
-        return value * self.activation(gate)

braindecode-1.6.1.dev171935310/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "1.6.1.dev171935310"

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310/braindecode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.6.1.dev169782001
+Version: 1.6.1.dev171935310
 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.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/docs/api.rst

@@ -215,7 +215,6 @@ stability.
     :template: class_in_subdir
     :recursive:
 
-    GatedLinearUnit
     LogActivation
     SafeLog
 
@@ -417,7 +416,6 @@ The functional module contains various functions that can be used like functiona
      plv_time
      rescale_parameter
      safe_log
-     sinusoidal_positional_encoding
      square
 
 **********

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/docs/conf.py

@@ -1,5 +1,3 @@
-# Authors: Fashad Ahmed <fashad.ahmed20@gmail.com>
-#
 """Our local Sphinx configuration file."""
 
 #!/usr/bin/env python3
@@ -284,17 +282,6 @@ intersphinx_mapping = {
     "spd_learn": ("https://spdlearn.org/", None),
 }
 
-if release.endswith("dev0"):
-    _pip_install_cell = (
-        "# Install the development version of braindecode\n"
-        "%pip install git+https://github.com/braindecode/braindecode.git"
-    )
-else:
-    _pip_install_cell = (
-        f"# Install braindecode (pinned to the version used to build this notebook)\n"
-        f"%pip install braindecode=={release}"
-    )
-
 sphinx_gallery_conf = {
     "examples_dirs": ["../examples"],
     "gallery_dirs": ["auto_examples"],
@@ -302,7 +289,6 @@ sphinx_gallery_conf = {
     "backreferences_dir": "generated",
     "show_memory": True,
     "reference_url": dict(braindecode=None),
-    "first_notebook_cell": _pip_install_cell,
     "subsection_order": ExplicitOrder(
         [
             "../examples/model_building",

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/docs/models/models_table.rst

@@ -45,9 +45,6 @@ Columns definitions:
     - **Application**: The application(s) the model is typically used for (e.g., Motor
       Imagery, P300, Sleep Staging). 'General' indicates applicability across multiple
       applications or no specific application focus.
-    - **Modality**: The recording modality (bio-signal type) the model is designed and
-      validated for, e.g. EEG, MEG, or sEMG. Most Braindecode models target EEG; a few
-      support more than one modality (e.g. EEG, MEG).
     - **Type**: The model's output interface. ``Prediction`` indicates a supervised head
       that can be used for classification or regression, depending on the wrapper, loss,
       and target. ``Embedding`` indicates a model that exposes an embedding
@@ -156,7 +153,7 @@ Braindecode.
       }
 
       /* --- DataTable: panes hidden until button click ---------------------- */
-      var FILTER_COLS = [1,2,3,4]; // Application, Modality, Type, Categorization
+      var FILTER_COLS = [1,2,3,4]; // Paradigm, Type, Categorization, Hyperparameters
       var table = $('.sortable').DataTable({
         dom: 'Blfrtip',                           // B = Buttons (no 'P' here)
         paging: false,

{braindecode-1.6.1.dev169782001 → braindecode-1.6.1.dev171935310}/docs/whats_new.rst

@@ -28,20 +28,6 @@ Current 1.6.1 (GitHub)
 Enhancements
 ============
 
-- Pin the ``%pip install braindecode`` cell in generated notebooks to the
-  version used to build them (``braindecode==X.Y.Z`` for stable releases,
-  ``git+https://github.com/braindecode/braindecode.git`` for dev builds),
-  so notebooks can be reproduced with a matching installation.
-  (:gh:`1080` by `Fashad Ahmed`_)
-- Add :func:`braindecode.functional.sinusoidal_positional_encoding`, a shared
-  sine/cosine positional-encoding primitive (handling odd dimensions), and reuse
-  it in :class:`braindecode.models.BIOT`, :class:`braindecode.models.MEDFormer`,
-  and :class:`braindecode.models.STEEGFormer` instead of re-deriving the table in
-  each. Encodings are bit-identical, so model behavior is unchanged. Also add
-  :class:`braindecode.modules.GatedLinearUnit`, a configurable GLU-family gate
-  (GEGLU with the default ``nn.GELU``, SwiGLU with ``nn.SiLU``; ``torch.nn.GLU``
-  is hard-wired to the sigmoid) for building gated transformer feed-forwards.
-  (:gh:`1078` by `Bruno Aristimunha`_)
 - Add an optional spatial Fourier :class:`braindecode.modules.ChannelMerger`
   (with :class:`braindecode.modules.FourierEmb`) to
   :class:`braindecode.models.BrainModule` via ``use_merger=True``, implementing
@@ -64,9 +50,6 @@ Enhancements
 - Clarify the model summary table's ``Type`` column by using ``Prediction`` for
   supervised heads instead of describing them as classification-only.
   By `Sarthak Tayal`_.
-- Add a ``Modality`` column (EEG, MEG, sEMG, ...) to the model summary table so
-  models can be filtered by the bio-signal they target, and validate it against a
-  controlled vocabulary. By `Bhargav Kowshik`_.
 - Add :class:`braindecode.models.InterpolatedEEGPT`, a channel-interpolation
   variant of :class:`braindecode.models.EEGPT` built with
   :func:`~braindecode.models.interpolated.InterpolatedModel`.
@@ -92,11 +75,6 @@ Enhancements
   grouped-query attention Transformer with rotary positional embeddings, and a
   grouped temporal convolutional network head. (:gh:`1065` by `Bruno
   Aristimunha`_)
-- Add a ``return_features`` option to :class:`braindecode.models.FBMSNet`: when
-  enabled, ``forward()`` returns ``(logits, features)`` where ``features`` is
-  the flattened pre-classifier vector (shape ``(batch, out_channels_spatial *
-  stride_factor)``), enabling center-loss training without subclassing.
-  (:gh:`1083` by `Bruno Aristimunha`_)
 - Add an ``n_augmentation`` argument to
   :class:`braindecode.augmentation.AugmentedDataLoader` for fixed set-expansion:
   each batch keeps its clean originals and appends ``n_augmentation``

braindecode-1.6.1.dev169782001/braindecode/version.py

@@ -1 +0,0 @@
-__version__ = "1.6.1.dev169782001"