braindecode 1.3.0.dev175955015__py3-none-any.whl → 1.3.0.dev176481332__py3-none-any.whl

braindecode/models/eeginception_erp.py

@@ -35,51 +35,57 @@ class EEGInceptionERP(EEGModuleMixin, nn.Sequential):
     - :class:`_InceptionModule1` **(multi-scale temporal + spatial mixing)**
 
         - *Operations.*
-        - `EEGInceptionERP.c1`: :class:`torch.nn.Conv2d` ``k=(64,1)``, stride ``(1,1)``, *same* pad on input reshaped to ``(B,1,128,8)`` → BN → activation → dropout.
-        - `EEGInceptionERP.d1`: :class:`torch.nn.Conv2d` (depthwise) ``k=(1,8)``, *valid* pad over channels → BN → activation → dropout.
-        - `EEGInceptionERP.c2`: :class:`torch.nn.Conv2d` ``k=(32,1)`` → BN → activation → dropout; then `EEGInceptionERP.d2` depthwise ``k=(1,8)`` → BN → activation → dropout.
-        - `EEGInceptionERP.c3`: :class:`torch.nn.Conv2d` ``k=(16,1)`` → BN → activation → dropout; then `EEGInceptionERP.d3` depthwise ``k=(1,8)`` → BN → activation → dropout.
-        - `EEGInceptionERP.n1`: :class:`torch.nn.Concat` over branch features.
-        - `EEGInceptionERP.a1`: :class:`torch.nn.AvgPool2d` ``pool=(4,1)``, stride ``(4,1)`` for temporal downsampling.
+
+            - `EEGInceptionERP.c1`: :class:`torch.nn.Conv2d` ``k=(64,1)``, stride ``(1,1)``, *same* pad on input reshaped to ``(B,1,128,8)`` → BN → activation → dropout.
+            - `EEGInceptionERP.d1`: :class:`torch.nn.Conv2d` (depthwise) ``k=(1,8)``, *valid* pad over channels → BN → activation → dropout.
+            - `EEGInceptionERP.c2`: :class:`torch.nn.Conv2d` ``k=(32,1)`` → BN → activation → dropout; then `EEGInceptionERP.d2` depthwise ``k=(1,8)`` → BN → activation → dropout.
+            - `EEGInceptionERP.c3`: :class:`torch.nn.Conv2d` ``k=(16,1)`` → BN → activation → dropout; then `EEGInceptionERP.d3` depthwise ``k=(1,8)`` → BN → activation → dropout.
+            - `EEGInceptionERP.n1`: :class:`torch.nn.Concat` over branch features.
+            - `EEGInceptionERP.a1`: :class:`torch.nn.AvgPool2d` ``pool=(4,1)``, stride ``(4,1)`` for temporal downsampling.
 
     *Interpretability/robustness.* Depthwise `1 x n_chans` layers act as learnable montage-wide spatial filters per temporal scale; pooling stabilizes against jitter.
 
     - :class:`_InceptionModule2` **(refinement at coarser timebase)**
 
         - *Operations.*
-        - `EEGInceptionERP.c4`: :class:`torch.nn.Conv2d` ``k=(16,1)`` → BN → activation → dropout.
-        - `EEGInceptionERP.c5`: :class:`torch.nn.Conv2d` ``k=(8,1)`` → BN → activation → dropout.
-        - `EEGInceptionERP.c6`: :class:`torch.nn.Conv2d` ``k=(4,1)`` → BN → activation → dropout.
-        - `EEGInceptionERP.n2`: :class:`torch.nn.Concat` (merge C4-C6 outputs).
-        - `EEGInceptionERP.a2`: :class:`torch.nn.AvgPool2d` ``pool=(2,1)``, stride ``(2,1)``.
-        - `EEGInceptionERP.c7`: :class:`torch.nn.Conv2d` ``k=(8,1)`` → BN → activation → dropout; then `EEGInceptionERP.a3`: :class:`torch.nn.AvgPool2d` ``pool=(2,1)``.
-        - `EEGInceptionERP.c8`: :class:`torch.nn.Conv2d` ``k=(4,1)`` → BN → activation → dropout; then `EEGInceptionERP.a4`: :class:`torch.nn.AvgPool2d` ``pool=(2,1)``.
+
+            - `EEGInceptionERP.c4`: :class:`torch.nn.Conv2d` ``k=(16,1)`` → BN → activation → dropout.
+            - `EEGInceptionERP.c5`: :class:`torch.nn.Conv2d` ``k=(8,1)`` → BN → activation → dropout.
+            - `EEGInceptionERP.c6`: :class:`torch.nn.Conv2d` ``k=(4,1)`` → BN → activation → dropout.
+            - `EEGInceptionERP.n2`: :class:`torch.nn.Concat` (merge C4-C6 outputs).
+            - `EEGInceptionERP.a2`: :class:`torch.nn.AvgPool2d` ``pool=(2,1)``, stride ``(2,1)``.
+            - `EEGInceptionERP.c7`: :class:`torch.nn.Conv2d` ``k=(8,1)`` → BN → activation → dropout; then `EEGInceptionERP.a3`: :class:`torch.nn.AvgPool2d` ``pool=(2,1)``.
+            - `EEGInceptionERP.c8`: :class:`torch.nn.Conv2d` ``k=(4,1)`` → BN → activation → dropout; then `EEGInceptionERP.a4`: :class:`torch.nn.AvgPool2d` ``pool=(2,1)``.
 
     *Role.* Adds higher-level, shorter-window evidence while progressively compressing temporal dimension.
 
     - :class:`_OutputModule` **(aggregation + readout)**
 
         - *Operations.*
-        - :class:`torch.nn.Flatten`
-        - :class:`torch.nn.Linear` ``(features → 2)``
+
+            - :class:`torch.nn.Flatten`
+            - :class:`torch.nn.Linear` ``(features → 2)``
 
     .. rubric:: Convolutional Details
 
     - **Temporal (where time-domain patterns are learned).**
-    First module uses 1D temporal kernels along the 128-sample axis: ``64``, ``32``, ``16``
-    (≈500, 250, 125 ms at 128 Hz). After ``pool=(4,1)``, the second module applies ``16``,
-    ``8``, ``4`` (≈125, 62.5, 31.25 ms at the pooled rate). All strides are ``1`` in convs;
-    temporal resolution changes only via average pooling.
+
+      First module uses 1D temporal kernels along the 128-sample axis: ``64``, ``32``, ``16``
+      (≈500, 250, 125 ms at 128 Hz). After ``pool=(4,1)``, the second module applies ``16``,
+      ``8``, ``4`` (≈125, 62.5, 31.25 ms at the pooled rate). All strides are ``1`` in convs;
+      temporal resolution changes only via average pooling.
 
     - **Spatial (how electrodes are processed).**
-    Depthwise convs with ``k=(1,8)`` span all channels and are applied **per temporal branch**,
-    yielding scale-specific channel projections (no cross-branch mixing until concatenation).
-    There is no full 2D mixing kernel; spatial mixing is factorized and lightweight.
+
+      Depthwise convs with ``k=(1,8)`` span all channels and are applied **per temporal branch**,
+      yielding scale-specific channel projections (no cross-branch mixing until concatenation).
+      There is no full 2D mixing kernel; spatial mixing is factorized and lightweight.
 
     - **Spectral (how frequency information is captured).**
-    No explicit transform; multiple temporal kernels form a *learned filter bank* over
-    ERP-relevant bands. Successive pooling acts as low-pass integration to emphasize sustained
-    post-stimulus components.
+
+      No explicit transform; multiple temporal kernels form a *learned filter bank* over
+      ERP-relevant bands. Successive pooling acts as low-pass integration to emphasize sustained
+      post-stimulus components.
 
     .. rubric:: Additional Mechanisms
 

braindecode/models/eegitnet.py

@@ -11,6 +11,8 @@ from braindecode.modules import DepthwiseConv2d, Ensure4d, InceptionBlock
 class EEGITNet(EEGModuleMixin, nn.Sequential):
     """EEG-ITNet from Salami, et al (2022) [Salami2022]_
 
+    :bdg-success:`Convolution` :bdg-secondary:`Recurrent`
+
     .. figure:: https://braindecode.org/dev/_static/model/eegitnet.jpg
         :align: center
         :alt: EEG-ITNet Architecture

braindecode/models/eegminer.py

@@ -21,6 +21,8 @@ _eeg_miner_methods = ["mag", "corr", "plv"]
 class EEGMiner(EEGModuleMixin, nn.Module):
     """EEGMiner from Ludwig et al (2024) [eegminer]_.
 
+    :bdg-success:`Convolution` :bdg-warning:`Interpretability`
+
     .. figure:: https://content.cld.iop.org/journals/1741-2552/21/3/036010/revision2/jnead44d7f1_hr.jpg
        :align: center
        :alt: EEGMiner Architecture

braindecode/models/eegnet.py

@@ -57,7 +57,7 @@ class EEGNet(EEGModuleMixin, nn.Sequential):
 
     - **Temporal.** The initial temporal convs serve as a *learned filter bank*:
       long 1-D kernels (implemented as 2-D with singleton spatial extent) emphasize oscillatory bands and transients.
-      Because this stage is linear prior to BN/ELU, kernels can be analyzed as FIR filters to reveal each feature’s spectrum [Lawhern2018]_.
+      Because this stage is linear prior to BN/ELU, kernels can be analyzed as FIR filters to reveal each feature's spectrum [Lawhern2018]_.
 
     - **Spatial.** The depthwise spatial conv spans the full channel axis (kernel height = #electrodes; temporal size = 1).
       With ``groups = F1``, each temporal filter learns its own set of ``D`` spatial projections—akin to CSP, learned end-to-end and

braindecode/models/eegtcnet.py

@@ -15,6 +15,8 @@ from braindecode.modules import Chomp1d, MaxNormLinear
 class EEGTCNet(EEGModuleMixin, nn.Module):
     """EEGTCNet model from Ingolfsson et al. (2020) [ingolfsson2020]_.
 
+    :bdg-success:`Convolution` :bdg-secondary:`Recurrent`
+
     .. figure:: https://braindecode.org/dev/_static/model/eegtcnet.jpg
         :align: center
         :alt: EEGTCNet Architecture

braindecode/models/fbcnet.py

@@ -31,6 +31,8 @@ _valid_layers = {
 class FBCNet(EEGModuleMixin, nn.Module):
     """FBCNet from Mane, R et al (2021) [fbcnet2021]_.
 
+    :bdg-success:`Convolution` :bdg-primary:`Filterbank`
+
     .. figure:: https://raw.githubusercontent.com/ravikiran-mane/FBCNet/refs/heads/master/FBCNet-V2.png
         :align: center
         :alt: FBCNet Architecture

braindecode/models/fblightconvnet.py

@@ -18,6 +18,8 @@ from braindecode.modules import (
 class FBLightConvNet(EEGModuleMixin, nn.Module):
     """LightConvNet from Ma, X et al (2023) [lightconvnet]_.
 
+    :bdg-success:`Convolution` :bdg-primary:`Filterbank`
+
     .. figure:: https://raw.githubusercontent.com/Ma-Xinzhi/LightConvNet/refs/heads/main/network_architecture.png
         :align: center
         :alt: LightConvNet Neural Network

braindecode/models/fbmsnet.py

@@ -19,6 +19,8 @@ from braindecode.modules import (
 class FBMSNet(EEGModuleMixin, nn.Module):
     """FBMSNet from Liu et al (2022) [fbmsnet]_.
 
+    :bdg-success:`Convolution` :bdg-primary:`Filterbank`
+
     .. figure:: https://raw.githubusercontent.com/Want2Vanish/FBMSNet/refs/heads/main/FBMSNet.png
         :align: center
         :alt: FBMSNet Architecture

braindecode/models/ifnet.py

@@ -31,6 +31,8 @@ from braindecode.modules import (
 class IFNet(EEGModuleMixin, nn.Module):
     """IFNetV2 from Wang J et al (2023) [ifnet]_.
 
+    :bdg-success:`Convolution` :bdg-primary:`Filterbank`
+
     .. figure:: https://raw.githubusercontent.com/Jiaheng-Wang/IFNet/main/IFNet.png
         :align: center
         :alt: IFNetV2 Architecture

braindecode/models/labram.py

@@ -2,6 +2,7 @@
 Labram module.
 Authors: Wei-Bang Jiang
          Bruno Aristimunha <b.aristimunha@gmail.com>
+         Matthew Chen <matt.chen4260@gmail.com>
 License: BSD 3 clause
 """
 
@@ -22,12 +23,14 @@ from braindecode.modules import MLP, DropPath
 class Labram(EEGModuleMixin, nn.Module):
     """Labram from Jiang, W B et al (2024) [Jiang2024]_.
 
+    :bdg-success:`Convolution` :bdg-danger:`Large Brain Model`
+
     .. figure:: https://arxiv.org/html/2405.18765v1/x1.png
         :align: center
         :alt: Labram Architecture.
 
     Large Brain Model for Learning Generic Representations with Tremendous
-    EEG Data in BCI from [Jiang2024]_
+    EEG Data in BCI from [Jiang2024]_.
 
     This is an **adaptation** of the code [Code2024]_ from the Labram model.
 
@@ -35,7 +38,8 @@ class Labram(EEGModuleMixin, nn.Module):
     BEiTv2 [BeiTv2]_.
 
     The models can be used in two modes:
-    - Neural Tokenizor: Design to get an embedding layers (e.g. classification).
+
+    - Neural Tokenizer: Design to get an embedding layers (e.g. classification).
     - Neural Decoder: To extract the ampliture and phase outputs with a VQSNP.
 
     The braindecode's modification is to allow the model to be used in
@@ -43,33 +47,36 @@ class Labram(EEGModuleMixin, nn.Module):
     equals True. The original implementation uses (batch, n_chans, n_patches,
     patch_size) as input with static segmentation of the input data.
 
-    The models have the following sequence of steps:
-    if neural tokenizer:
-        - SegmentPatch: Segment the input data in patches;
-        - TemporalConv: Apply a temporal convolution to the segmented data;
-        - Residual adding cls, temporal and position embeddings (optional);
-        - WindowsAttentionBlock: Apply a windows attention block to the data;
-        - LayerNorm: Apply layer normalization to the data;
-        - Linear: An head linear layer to transformer the data into classes.
-
-    else:
-        - PatchEmbed: Apply a patch embedding to the input data;
-        - Residual adding cls, temporal and position embeddings (optional);
-        - WindowsAttentionBlock: Apply a windows attention block to the data;
-        - LayerNorm: Apply layer normalization to the data;
-        - Linear: An head linear layer to transformer the data into classes.
+    The models have the following sequence of steps::
+
+        if neural tokenizer:
+            - SegmentPatch: Segment the input data in patches;
+            - TemporalConv: Apply a temporal convolution to the segmented data;
+            - Residual adding cls, temporal and position embeddings (optional);
+            - WindowsAttentionBlock: Apply a windows attention block to the data;
+            - LayerNorm: Apply layer normalization to the data;
+            - Linear: An head linear layer to transformer the data into classes.
+
+        else:
+            - PatchEmbed: Apply a patch embedding to the input data;
+            - Residual adding cls, temporal and position embeddings (optional);
+            - WindowsAttentionBlock: Apply a windows attention block to the data;
+            - LayerNorm: Apply layer normalization to the data;
+            - Linear: An head linear layer to transformer the data into classes.
 
     .. versionadded:: 0.9
 
 
-    Examples on how to load pre-trained weights:
-    --------------------------------------------
-    >>> import torch
-    >>> from braindecode.models import Labram
-    >>> model = Labram(n_times=1600, n_chans=64, n_outputs=4)
-    >>> url = 'https://huggingface.co/braindecode/Labram-Braindecode/blob/main/braindecode_labram_base.pt'
-    >>> state = torch.hub.load_state_dict_from_url(url, progress=True)
-    >>> model.load_state_dict(state)
+    Examples
+    --------
+    Load pre-trained weights::
+
+        >>> import torch
+        >>> from braindecode.models import Labram
+        >>> model = Labram(n_times=1600, n_chans=64, n_outputs=4)
+        >>> url = "https://huggingface.co/braindecode/Labram-Braindecode/blob/main/braindecode_labram_base.pt"
+        >>> state = torch.hub.load_state_dict_from_url(url, progress=True)
+        >>> model.load_state_dict(state)
 
 
     Parameters
@@ -116,7 +123,7 @@ class Labram(EEGModuleMixin, nn.Module):
     init_scale : float (default=0.001)
         The initial scale to be used in the parameters of the model.
     neural_tokenizer : bool (default=True)
-        The model can be used in two modes: Neural Tokenizor or Neural Decoder.
+        The model can be used in two modes: Neural Tokenizer or Neural Decoder.
     attn_head_dim : bool (default=None)
         The head dimension to be used in the attention layer, to be used only
         during pre-training.

braindecode/models/msvtnet.py

@@ -13,6 +13,8 @@ from braindecode.models.base import EEGModuleMixin
 class MSVTNet(EEGModuleMixin, nn.Module):
     """MSVTNet model from Liu K et al (2024) from [msvt2024]_.
 
+    :bdg-success:`Convolution` :bdg-secondary:`Recurrent` :bdg-info:`Small Attention`
+
     This model implements a multi-scale convolutional transformer network
     for EEG signal classification, as described in [msvt2024]_.
 

braindecode/models/patchedtransformer.py

@@ -16,7 +16,7 @@ from braindecode.models.base import EEGModuleMixin
 class PBT(EEGModuleMixin, nn.Module):
     r"""Patched Brain Transformer (PBT) model from Klein et al. (2025) [pbt]_.
 
-    :bdg-danger:`Large Brain Models`
+    :bdg-danger:`Large Brain Model`
 
     This implementation was based in https://github.com/timonkl/PatchedBrainTransformer/
 

braindecode/models/signal_jepa.py

@@ -146,6 +146,8 @@ class _BaseSignalJEPA(EEGModuleMixin, nn.Module):
 class SignalJEPA(_BaseSignalJEPA):
     """Architecture introduced in signal-JEPA for self-supervised pre-training, Guetschel, P et al (2024) [1]_
 
+    :bdg-success:`Convolution` :bdg-dark-line:`Channel` :bdg-danger:`Large Brain Model`
+
     This model is not meant for classification but for SSL pre-training.
     Its output shape depends on the input shape.
     For classification purposes, three variants of this model are available:
@@ -232,6 +234,8 @@ class SignalJEPA(_BaseSignalJEPA):
 class SignalJEPA_Contextual(_BaseSignalJEPA):
     """Contextual downstream architecture introduced in signal-JEPA Guetschel, P et al (2024) [1]_.
 
+    :bdg-success:`Convolution` :bdg-dark-line:`Channel` :bdg-danger:`Large Brain Model`
+
     This architecture is one of the variants of :class:`SignalJEPA`
     that can be used for classification purposes.
 
@@ -403,6 +407,8 @@ class SignalJEPA_Contextual(_BaseSignalJEPA):
 class SignalJEPA_PostLocal(_BaseSignalJEPA):
     """Post-local downstream architecture introduced in signal-JEPA Guetschel, P et al (2024) [1]_.
 
+    :bdg-success:`Convolution` :bdg-dark-line:`Channel` :bdg-danger:`Large Brain Model`
+
     This architecture is one of the variants of :class:`SignalJEPA`
     that can be used for classification purposes.
 
@@ -552,6 +558,8 @@ class SignalJEPA_PostLocal(_BaseSignalJEPA):
 class SignalJEPA_PreLocal(_BaseSignalJEPA):
     """Pre-local downstream architecture introduced in signal-JEPA Guetschel, P et al (2024) [1]_.
 
+    :bdg-success:`Convolution` :bdg-dark-line:`Channel` :bdg-danger:`Large Brain Model`
+
     This architecture is one of the variants of :class:`SignalJEPA`
     that can be used for classification purposes.
 

braindecode/models/sinc_shallow.py

@@ -12,6 +12,8 @@ from braindecode.models.base import EEGModuleMixin
 class SincShallowNet(EEGModuleMixin, nn.Module):
     """Sinc-ShallowNet from Borra, D et al (2020) [borra2020]_.
 
+    :bdg-success:`Convolution` :bdg-warning:`Interpretability`
+
     .. figure:: https://ars.els-cdn.com/content/image/1-s2.0-S0893608020302021-gr2_lrg.jpg
         :align: center
         :alt: SincShallowNet Architecture
@@ -19,23 +21,24 @@ class SincShallowNet(EEGModuleMixin, nn.Module):
     The Sinc-ShallowNet architecture has these fundamental blocks:
 
     1. **Block 1: Spectral and Spatial Feature Extraction**
-        - *Temporal Sinc-Convolutional Layer*:
-            Uses parametrized sinc functions to learn band-pass filters,
-            significantly reducing the number of trainable parameters by only
-            learning the lower and upper cutoff frequencies for each filter.
-       - *Spatial Depthwise Convolutional Layer*:
-            Applies depthwise convolutions to learn spatial filters for
-            each temporal feature map independently, further reducing
-            parameters and enhancing interpretability.
-       - *Batch Normalization*
+
+        - *Temporal Sinc-Convolutional Layer*: Uses parametrized sinc functions to learn band-pass filters,
+          significantly reducing the number of trainable parameters by only
+          learning the lower and upper cutoff frequencies for each filter.
+        - *Spatial Depthwise Convolutional Layer*: Applies depthwise convolutions to learn spatial filters for
+          each temporal feature map independently, further reducing
+          parameters and enhancing interpretability.
+        - *Batch Normalization*
 
     2. **Block 2: Temporal Aggregation**
+
         - *Activation Function*: ELU
         - *Average Pooling Layer*: Aggregation by averaging spatial dim
         - *Dropout Layer*
         - *Flatten Layer*
 
     3. **Block 3: Classification**
+
         - *Fully Connected Layer*: Maps the feature vector to n_outputs.
 
     **Implementation Notes:**

braindecode/models/sstdpn.py

@@ -24,7 +24,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
         :alt: SSTDPN Architecture
         :width: 1000px
 
-    The **Spatial–Spectral** and **Temporal - Dual Prototype Network** (SST-DPN)
+    The **Spatial-Spectral** and **Temporal - Dual Prototype Network** (SST-DPN)
     is an end-to-end 1D convolutional architecture designed for motor imagery (MI) EEG decoding,
     aiming to address challenges related to discriminative feature extraction and
     small-sample sizes [Han2025]_.
@@ -37,9 +37,9 @@ class SSTDPN(EEGModuleMixin, nn.Module):
     SST-DPN consists of a feature extractor (_SSTEncoder, comprising Adaptive Spatial-Spectral
     Fusion and Multi-scale Variance Pooling) followed by Dual Prototype Learning classification [Han2025]_.
 
-    1. **Adaptive Spatial–Spectral Fusion (ASSF)**: Uses :class:`_DepthwiseTemporalConv1d` to generate a
-        multi-channel spatial–spectral representation, followed by :class:`_SpatSpectralAttn`
-        (Spatial-Spectral Attention) to model relationships and highlight key spatial–spectral
+    1. **Adaptive Spatial-Spectral Fusion (ASSF)**: Uses :class:`_DepthwiseTemporalConv1d` to generate a
+        multi-channel spatial-spectral representation, followed by :class:`_SpatSpectralAttn`
+        (Spatial-Spectral Attention) to model relationships and highlight key spatial-spectral
         channels [Han2025]_.
 
     2. **Multi-scale Variance Pooling (MVP)**: Applies :class:`_MultiScaleVarPooler` with variance pooling
@@ -57,7 +57,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
 
     - `SSTDPN.encoder` **(Feature Extractor)**
 
-        - *Operations.* Combines Adaptive Spatial–Spectral Fusion and Multi-scale Variance Pooling
+        - *Operations.* Combines Adaptive Spatial-Spectral Fusion and Multi-scale Variance Pooling
           via an internal :class:`_SSTEncoder`.
         - *Role.* Maps the raw MI-EEG trial :math:`X_i \in \mathbb{R}^{C \times T}` to the
           feature space :math:`z_i \in \mathbb{R}^d`.
@@ -69,11 +69,11 @@ class SSTDPN(EEGModuleMixin, nn.Module):
           depth multiplier `n_spectral_filters_temporal` (equivalent to :math:`F_1` in the paper).
         - *Role.* Extracts multiple distinct spectral bands from each EEG channel independently.
 
-    - `_SSTEncoder.spt_attn` **(Spatial–Spectral Attention for Channel Gating)**
+    - `_SSTEncoder.spt_attn` **(Spatial-Spectral Attention for Channel Gating)**
 
         - *Operations.* Internal :class:`_SpatSpectralAttn` module using Global Context Embedding
           via variance-based pooling, followed by adaptive channel normalization and gating.
-        - *Role.* Reweights channels in the spatial–spectral dimension to extract efficient and
+        - *Role.* Reweights channels in the spatial-spectral dimension to extract efficient and
           discriminative features by emphasizing task-relevant regions and frequency bands.
 
     - `_SSTEncoder.chan_conv` **(Pointwise Fusion across Channels)**
@@ -81,7 +81,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
         - *Operations.* A 1D pointwise convolution with `n_fused_filters` output channels
           (equivalent to :math:`F_2` in the paper), followed by BatchNorm and the specified
           `activation` function (default: ELU).
-        - *Role.* Fuses the weighted spatial–spectral features across all electrodes to produce
+        - *Role.* Fuses the weighted spatial-spectral features across all electrodes to produce
           a fused representation :math:`X_{fused} \in \mathbb{R}^{F_2 \times T}`.
 
     - `_SSTEncoder.mvp` **(Multi-scale Variance Pooling for Temporal Extraction)**
@@ -109,11 +109,11 @@ class SSTDPN(EEGModuleMixin, nn.Module):
     * **Spatial.**
        The initial convolution at the classes :class:`_DepthwiseTemporalConv1d` groups parameter :math:`h=1`,
        meaning :math:`F_1` temporal filters are shared across channels. The Spatial-Spectral Attention
-       mechanism explicitly models the relationships among these channels in the spatial–spectral
+       mechanism explicitly models the relationships among these channels in the spatial-spectral
        dimension, allowing for finer-grained spatial feature modeling compared to conventional
        GCNs according to the authors [Han2025]_.
        In other words, all electrode channels share :math:`F_1` temporal filters
-       independently to produce the spatial–spectral representation.
+       independently to produce the spatial-spectral representation.
 
     * **Spectral.**
        Spectral information is implicitly extracted via the :math:`F_1` filters in :class:`_DepthwiseTemporalConv1d`.
@@ -123,7 +123,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
 
     .. rubric:: Additional Mechanisms
 
-    - **Attention.** A lightweight Spatial-Spectral Attention mechanism models spatial–spectral relationships
+    - **Attention.** A lightweight Spatial-Spectral Attention mechanism models spatial-spectral relationships
         at the channel level, distinct from applying attention to deep feature dimensions,
         which is common in comparison methods like :class:`ATCNet`.
     - **Regularization.** Dual Prototype Learning acts as a regularization technique

braindecode/models/summary.csv

@@ -39,3 +39,4 @@ FBLightConvNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sf
 IFNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",9860,"IFNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
 PBT,General,Classification,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Large Brain Model"
 SSTDPN,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",19502,"SSTDPN(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
+BENDR,General,"Classification,Embedding",250,"n_chans, n_times, n_outputs",157141049,"BENDR(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"

braindecode/models/syncnet.py

@@ -10,6 +10,8 @@ from braindecode.models.base import EEGModuleMixin
 class SyncNet(EEGModuleMixin, nn.Module):
     """Synchronization Network (SyncNet) from Li, Y et al (2017) [Li2017]_.
 
+    :bdg-warning:`Interpretability`
+
     .. figure:: https://braindecode.org/dev/_static/model/SyncNet.png
         :align: center
         :alt: SyncNet Architecture

braindecode/models/tcn.py

@@ -14,6 +14,8 @@ from braindecode.modules import Chomp1d, Ensure4d, SqueezeFinalOutput
 class BDTCN(EEGModuleMixin, nn.Module):
     """Braindecode TCN from Gemein, L et al (2020) [gemein2020]_.
 
+    :bdg-success:`Convolution` :bdg-secondary:`Recurrent`
+
     .. figure:: https://ars.els-cdn.com/content/image/1-s2.0-S1053811920305073-gr3_lrg.jpg
        :align: center
        :alt: Braindecode TCN Architecture

braindecode/models/usleep.py

@@ -62,43 +62,48 @@ class USleep(EEGModuleMixin, nn.Module):
     - Decoder :class:`_DecoderBlock`  **(progressive upsampling + skip fusion to high-frequency map, 12 blocks; upsampling x2 per block)**
 
         - *Operations.*
-        - **Nearest-neighbor upsample**, :class:`nn.Upsample` (x2)
-        - **Convolution2d** (k=2), :class:`torch.nn.Conv2d`
-        - ELU, :class:`torch.nn.ELU`
-        - Batch Norm, :class:`torch.nn.BatchNorm2d`
-        - **Concatenate** with the encoder skip at the same temporal scale, :function:`torch.cat`
-        - **Convolution**, :class:`torch.nn.Conv2d`
-        - ELU, :class:`torch.nn.ELU`
-        - Batch Norm, :class:`torch.nn.BatchNorm2d`.
+
+            - **Nearest-neighbor upsample**, :class:`nn.Upsample` (x2)
+            - **Convolution2d** (k=2), :class:`torch.nn.Conv2d`
+            - ELU, :class:`torch.nn.ELU`
+            - Batch Norm, :class:`torch.nn.BatchNorm2d`
+            - **Concatenate** with the encoder skip at the same temporal scale, ``torch.cat``
+            - **Convolution**, :class:`torch.nn.Conv2d`
+            - ELU, :class:`torch.nn.ELU`
+            - Batch Norm, :class:`torch.nn.BatchNorm2d`.
 
     **Output**: A multi-class, **high-frequency** per-sample representation aligned to the input rate (128 Hz).
 
     - **Segment Classifier incorporate into :class:`braindecode.models.USleep` (aggregation to fixed epochs)**
 
         - *Operations.*
-        - **Mean-pool**, :class:`torch.nn.AvgPool2d` per class with kernel = epoch length *i* and stride *i*
-        - **1x1 conv**, :class:`torch.nn.Conv2d`
-        - ELU, :class:`torch.nn.ELU`
-        - **1x1 conv**, :class:`torch.nn.Conv2d` with ``(T, K)`` (epochs x stages).
+
+            - **Mean-pool**, :class:`torch.nn.AvgPool2d` per class with kernel = epoch length *i* and stride *i*
+            - **1x1 conv**, :class:`torch.nn.Conv2d`
+            - ELU, :class:`torch.nn.ELU`
+            - **1x1 conv**, :class:`torch.nn.Conv2d` with ``(T, K)`` (epochs x stages).
 
     **Role**: Learns a **non-linear** weighted combination over each 30-s window (unlike U-Time's linear combiner).
 
     .. rubric:: Convolutional Details
 
     - **Temporal (where time-domain patterns are learned).**
-    All convolutions are **1-D along time**; depth (12 levels) plus pooling yields an extensive receptive field
-    (reported sensitivity to ±6.75 min around each epoch; theoretical field ≈ 9.6 min at the deepest layer).
-    The decoder restores sample-level resolution before epoch aggregation.
+
+      All convolutions are **1-D along time**; depth (12 levels) plus pooling yields an extensive receptive field
+      (reported sensitivity to ±6.75 min around each epoch; theoretical field ≈ 9.6 min at the deepest layer).
+      The decoder restores sample-level resolution before epoch aggregation.
 
     - **Spatial (how channels are processed).**
-    Convolutions mix across the *channel* dimension jointly with time (no separate spatial operator). The system
-    is **montage-agnostic** (any reasonable EEG/EOG pair) and was trained across diverse cohorts/protocols,
-    supporting robustness to channel placement and hardware differences.
+
+      Convolutions mix across the *channel* dimension jointly with time (no separate spatial operator). The system
+      is **montage-agnostic** (any reasonable EEG/EOG pair) and was trained across diverse cohorts/protocols,
+      supporting robustness to channel placement and hardware differences.
 
     - **Spectral (how frequency content is captured).**
-    No explicit Fourier/wavelet transform is used; the **stack of temporal convolutions** acts as a learned
-    filter bank whose effective bandwidth grows with depth. The high-frequency decoder output (128 Hz)
-    retains fine temporal detail for the segment classifier.
+
+      No explicit Fourier/wavelet transform is used; the **stack of temporal convolutions** acts as a learned
+      filter bank whose effective bandwidth grows with depth. The high-frequency decoder output (128 Hz)
+      retains fine temporal detail for the segment classifier.
 
 
     .. rubric:: Attention / Sequential Modules

braindecode/models/util.py

@@ -97,6 +97,7 @@ models_mandatory_parameters = [
     ("IFNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("PBT", ["n_chans", "n_outputs", "n_times"], None),
     ("SSTDPN", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
+    ("BENDR", ["n_chans", "n_outputs", "n_times"], None),
 ]
 
 ################################################################