braindecode 1.3.0.dev180329405__py3-none-any.whl → 1.3.0.dev182330353__py3-none-any.whl

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

@@ -5,7 +5,8 @@ from __future__ import annotations
 
 import math
 from copy import deepcopy
-from typing import Any, Sequence
+from pathlib import Path
+from typing import Any, Optional, Sequence
 
 import torch
 from einops.layers.torch import Rearrange
@@ -145,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:
@@ -231,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.
 
@@ -319,25 +324,50 @@ class SignalJEPA_Contextual(_BaseSignalJEPA):
     @classmethod
     def from_pretrained(
         cls,
-        model: SignalJEPA,
-        n_outputs: int,
+        model: Optional[SignalJEPA | str | Path] = None,  # type: ignore
+        n_outputs: Optional[int] = None,  # type: ignore
         n_spat_filters: int = 4,
-        chs_info: list[dict[str, Any]] | None = None,
+        chs_info: Optional[list[dict[str, Any]]] = None,  # type: ignore
+        **kwargs,
     ):
-        """Instantiate a new model from a pre-trained :class:`SignalJEPA` model.
+        """Instantiate a new model from a pre-trained :class:`SignalJEPA` model or from Hub.
 
         Parameters
         ----------
-        model: SignalJEPA
-            Pre-trained model.
-        n_outputs: int
-            Number of classes for the new model.
+        model: SignalJEPA, str, Path, or None
+            Either a pre-trained :class:`SignalJEPA` model, a string/Path to a local directory
+            (for Hub-style loading), or None (for Hub loading via kwargs).
+        n_outputs: int or None
+            Number of classes for the new model. Required when loading from a SignalJEPA model,
+            optional when loading from Hub (will be read from config).
         n_spat_filters: int
             Number of spatial filters.
         chs_info: list of dict | None
             Information about each individual EEG channel. This should be filled with
             ``info["chs"]``. Refer to :class:`mne.Info` for more details.
+        **kwargs
+            Additional keyword arguments passed to the parent class for Hub loading.
         """
+        # Check if this is a Hub-style load (from a directory path)
+        if isinstance(model, (str, Path)) or (model is None and kwargs):
+            # This is a Hub load, delegate to parent class
+            if isinstance(model, (str, Path)):
+                # model is actually the repo_id or directory path
+                return super().from_pretrained(model, **kwargs)
+            else:
+                # model is None, treat as hub-style load
+                return super().from_pretrained(**kwargs)
+
+        # This is the original SignalJEPA transfer learning case
+        if not isinstance(model, SignalJEPA):
+            raise TypeError(
+                f"model must be a SignalJEPA instance, a path string, or Path object, got {type(model)}"
+            )
+        if n_outputs is None:
+            raise ValueError(
+                "n_outputs must be provided when loading from a SignalJEPA model"
+            )
+
         feature_encoder = model.feature_encoder
         pos_encoder = model.pos_encoder
         transformer = model.transformer
@@ -377,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.
 
@@ -463,22 +495,47 @@ class SignalJEPA_PostLocal(_BaseSignalJEPA):
 
     @classmethod
     def from_pretrained(
-        cls, model: SignalJEPA, n_outputs: int, n_spat_filters: int = 4
+        cls,
+        model: SignalJEPA | str | Path = None,  # type: ignore
+        n_outputs: int = None,  # type: ignore
+        n_spat_filters: int = 4,
+        **kwargs,
     ):
-        """Instantiate a new model from a pre-trained :class:`SignalJEPA` model.
+        """Instantiate a new model from a pre-trained :class:`SignalJEPA` model or from Hub.
 
         Parameters
         ----------
-        model: SignalJEPA
-            Pre-trained model.
-        n_outputs: int
-            Number of classes for the new model.
+        model: SignalJEPA, str, Path, or None
+            Either a pre-trained :class:`SignalJEPA` model, a string/Path to a local directory
+            (for Hub-style loading), or None (for Hub loading via kwargs).
+        n_outputs: int or None
+            Number of classes for the new model. Required when loading from a SignalJEPA model,
+            optional when loading from Hub (will be read from config).
         n_spat_filters: int
             Number of spatial filters.
-        chs_info: list of dict | None
-            Information about each individual EEG channel. This should be filled with
-            ``info["chs"]``. Refer to :class:`mne.Info` for more details.
+        **kwargs
+            Additional keyword arguments passed to the parent class for Hub loading.
         """
+        # Check if this is a Hub-style load (from a directory path)
+        if isinstance(model, (str, Path)) or (model is None and kwargs):
+            # This is a Hub load, delegate to parent class
+            if isinstance(model, (str, Path)):
+                # model is actually the repo_id or directory path
+                return super().from_pretrained(model, **kwargs)
+            else:
+                # model is None, treat as hub-style load
+                return super().from_pretrained(**kwargs)
+
+        # This is the original SignalJEPA transfer learning case
+        if not isinstance(model, SignalJEPA):
+            raise TypeError(
+                f"model must be a SignalJEPA instance, a path string, or Path object, got {type(model)}"
+            )
+        if n_outputs is None:
+            raise ValueError(
+                "n_outputs must be provided when loading from a SignalJEPA model"
+            )
+
         feature_encoder = model.feature_encoder
         assert feature_encoder is not None
         new_model = cls(
@@ -501,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.
 
@@ -597,22 +656,47 @@ class SignalJEPA_PreLocal(_BaseSignalJEPA):
 
     @classmethod
     def from_pretrained(
-        cls, model: SignalJEPA, n_outputs: int, n_spat_filters: int = 4
+        cls,
+        model: SignalJEPA | str | Path = None,  # type: ignore
+        n_outputs: int = None,  # type: ignore
+        n_spat_filters: int = 4,
+        **kwargs,
     ):
-        """Instantiate a new model from a pre-trained :class:`SignalJEPA` model.
+        """Instantiate a new model from a pre-trained :class:`SignalJEPA` model or from Hub.
 
         Parameters
         ----------
-        model: SignalJEPA
-            Pre-trained model.
-        n_outputs: int
-            Number of classes for the new model.
+        model: SignalJEPA, str, Path, or None
+            Either a pre-trained :class:`SignalJEPA` model, a string/Path to a local directory
+            (for Hub-style loading), or None (for Hub loading via kwargs).
+        n_outputs: int or None
+            Number of classes for the new model. Required when loading from a SignalJEPA model,
+            optional when loading from Hub (will be read from config).
         n_spat_filters: int
             Number of spatial filters.
-        chs_info: list of dict | None
-            Information about each individual EEG channel. This should be filled with
-            ``info["chs"]``. Refer to :class:`mne.Info` for more details.
+        **kwargs
+            Additional keyword arguments passed to the parent class for Hub loading.
         """
+        # Check if this is a Hub-style load (from a directory path)
+        if isinstance(model, (str, Path)) or (model is None and kwargs):
+            # This is a Hub load, delegate to parent class
+            if isinstance(model, (str, Path)):
+                # model is actually the repo_id or directory path
+                return super().from_pretrained(model, **kwargs)
+            else:
+                # model is None, treat as hub-style load
+                return super().from_pretrained(**kwargs)
+
+        # This is the original SignalJEPA transfer learning case
+        if not isinstance(model, SignalJEPA):
+            raise TypeError(
+                f"model must be a SignalJEPA instance, a path string, or Path object, got {type(model)}"
+            )
+        if n_outputs is None:
+            raise ValueError(
+                "n_outputs must be provided when loading from a SignalJEPA model"
+            )
+
         feature_encoder = model.feature_encoder
         assert feature_encoder is not None
         new_model = cls(

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

@@ -13,6 +13,7 @@ EEGInceptionMI,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",55
 EEGITNet,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times",5212,"EEGITNet(n_chans=22,  n_outputs=4,  n_times=500)","Convolution,Recurrent"
 EEGNet,General,Classification,128,"n_chans, n_outputs, n_times",2484,"EEGNet(n_chans=22,  n_outputs=4,  n_times=512)","Convolution"
 EEGNeX,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times",55940,"EEGNeX(n_chans=22,  n_outputs=4,  n_times=500)","Convolution"
+EEGSym,Motor Imagery,Classification,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,Classification,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,Classification,80,"n_chans, n_outputs, sfreq",730404,"EEGSimpleConv(n_chans=22,  n_outputs=4,  n_times=320, sfreq=80)","Convolution"
 EEGTCNet,Motor Imagery,Classification,250,"n_chans, n_outputs",4516,"EEGTCNet(n_chans=22,  n_outputs=4,  n_times=1000, kern_length=32)","Convolution,Recurrent"
@@ -39,3 +40,5 @@ 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"
+MEDFormer,General,Classification,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(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

@@ -79,6 +79,7 @@ models_mandatory_parameters = [
     ("SPARCNet", ["n_chans", "n_outputs", "n_times"], None),
     ("ContraWR", ["n_chans", "n_outputs", "sfreq", "n_times"], dict(sfreq=200.0)),
     ("EEGNeX", ["n_chans", "n_outputs", "n_times"], None),
+    ("EEGSym", ["chs_info", "n_chans", "n_outputs", "n_times", "sfreq"], None),
     ("TSception", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("EEGTCNet", ["n_chans", "n_outputs", "n_times"], None),
     ("SyncNet", ["n_chans", "n_outputs", "n_times"], None),
@@ -97,6 +98,8 @@ 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),
+    ("MEDFormer", ["n_chans", "n_outputs", "n_times"], None),
 ]
 
 ################################################################

braindecode/modules/attention.py

@@ -38,7 +38,7 @@ class SqueezeAndExcitation(nn.Module):
     References
     ----------
     .. [Hu2018] Hu, J., Albanie, S., Sun, G., Wu, E., 2018.
-    Squeeze-and-Excitation Networks. CVPR 2018.
+        Squeeze-and-Excitation Networks. CVPR 2018.
     """
 
     def __init__(self, in_channels: int, reduction_rate: int, bias: bool = False):
@@ -93,7 +93,7 @@ class GSoP(nn.Module):
     References
     ----------
     .. [Gao2018] Gao, Z., Jiangtao, X., Wang, Q., Li, P., 2018.
-    Global Second-order Pooling Convolutional Networks. CVPR 2018.
+        Global Second-order Pooling Convolutional Networks. CVPR 2018.
     """
 
     def __init__(self, in_channels: int, reduction_rate: int, bias: bool = True):
@@ -149,7 +149,7 @@ class FCA(nn.Module):
     References
     ----------
     .. [Qin2021] Qin, Z., Zhang, P., Wu, F., Li, X., 2021.
-    FcaNet: Frequency Channel Attention Networks. ICCV 2021.
+        FcaNet: Frequency Channel Attention Networks. ICCV 2021.
     """
 
     def __init__(
@@ -233,7 +233,7 @@ class EncNet(nn.Module):
     References
     ----------
     .. [Zhang2018] Zhang, H. et al. 2018.
-    Context Encoding for Semantic Segmentation. CVPR 2018.
+        Context Encoding for Semantic Segmentation. CVPR 2018.
     """
 
     def __init__(self, in_channels: int, n_codewords: int):
@@ -290,7 +290,7 @@ class ECA(nn.Module):
     References
     ----------
     .. [Wang2021] Wang, Q. et al., 2021. ECA-Net: Efficient Channel Attention
-    for Deep Convolutional Neural Networks. CVPR 2021.
+        for Deep Convolutional Neural Networks. CVPR 2021.
     """
 
     def __init__(self, in_channels: int, kernel_size: int):
@@ -341,8 +341,8 @@ class GatherExcite(nn.Module):
     References
     ----------
     .. [Hu2018b] Hu, J., Albanie, S., Sun, G., Vedaldi, A., 2018.
-    Gather-Excite: Exploiting Feature Context in Convolutional Neural Networks.
-    NeurIPS 2018.
+        Gather-Excite: Exploiting Feature Context in Convolutional Neural Networks.
+        NeurIPS 2018.
     """
 
     def __init__(
@@ -410,7 +410,7 @@ class GCT(nn.Module):
     References
     ----------
     .. [Yang2020] Yang, Z. Linchao, Z., Wu, Y., Yang, Y., 2020.
-    Gated Channel Transformation for Visual Recognition. CVPR 2020.
+        Gated Channel Transformation for Visual Recognition. CVPR 2020.
     """
 
     def __init__(self, in_channels: int):
@@ -455,7 +455,7 @@ class SRM(nn.Module):
     References
     ----------
     .. [Lee2019] Lee, H., Kim, H., Nam, H., 2019. SRM: A Style-based
-    Recalibration Module for Convolutional Neural Networks. ICCV 2019.
+        Recalibration Module for Convolutional Neural Networks. ICCV 2019.
     """
 
     def __init__(
@@ -520,7 +520,7 @@ class CBAM(nn.Module):
     References
     ----------
     .. [Woo2018] Woo, S., Park, J., Lee, J., Kweon, I., 2018.
-    CBAM: Convolutional Block Attention Module. ECCV 2018.
+        CBAM: Convolutional Block Attention Module. ECCV 2018.
     """
 
     def __init__(self, in_channels: int, reduction_rate: int, kernel_size: int):

braindecode/modules/blocks.py

@@ -37,8 +37,8 @@ class MLP(nn.Sequential):
     :math:`a_i` are called activation functions. The trainable parameters of an
     MLP are its weights and biases :math:`\\phi = \{W_i, b_i | i = 1, \dots, L\}`.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     in_features: int
         Number of input features.
     hidden_features: Sequential[int] (default=None)
@@ -49,7 +49,7 @@ class MLP(nn.Sequential):
     out_features: int (default=None)
         Number of output features, if None, set to in_features.
     act_layer: nn.GELU (default)
-        The activation function constructor. If :py:`None`, use
+        The activation function constructor. If ``None``, use
         :class:`torch.nn.GELU` instead.
     drop: float (default=0.0)
         Dropout rate.

braindecode/modules/filter.py

@@ -17,9 +17,8 @@ class FilterBankLayer(nn.Module):
     It uses MNE's `create_filter` function to create the band-specific filters and
     applies them to multi-channel time-series data. Each filter in the bank corresponds to a
     specific frequency band and is applied to all channels of the input data. The filtering is
-    performed using FFT-based convolution via the `fftconvolve` function from
-    :func:`torchaudio.functional if the method is FIR, and `filtfilt` function from
-    :func:`torchaudio.functional if the method is IIR.
+    performed using FFT-based convolution via the ``torchaudio.functional`` if the method is FIR,
+    and ``torchaudio.functional`` if the method is IIR.
 
     The default configuration creates 9 non-overlapping frequency bands with a 4 Hz bandwidth,
     spanning from 4 Hz to 40 Hz (i.e., 4-8 Hz, 8-12 Hz, ..., 36-40 Hz). This setup is based on the
@@ -110,11 +109,6 @@ class FilterBankLayer(nn.Module):
         or "firwin2" to use :func:`scipy.signal.firwin2`. "firwin" uses
         a time-domain design technique that generally gives improved
         attenuation using fewer samples than "firwin2".
-    pad : str, default='reflect_limited'
-        The type of padding to use. Supports all func:`numpy.pad()` mode options.
-        Can also be "reflect_limited", which pads with a reflected version of
-        each vector mirrored on the first and last values of the vector,
-        followed by zeros. Only used for ``method='fir'``.
     verbose: bool | str | int | None, default=True
         Control verbosity of the logging output. If ``None``, use the default
         verbosity level. See the func:`mne.verbose` for details.
@@ -184,7 +178,6 @@ class FilterBankLayer(nn.Module):
                     "The band_filters items should be splitable in 2 values."
                 )
 
-        # and we accepted as
         self.band_filters = band_filters
         self.n_bands = len(band_filters)
         self.phase = phase