braindecode 1.2.0.dev184328194__py3-none-any.whl → 1.3.0.dev168496007__py3-none-any.whl

braindecode/models/summary.csv

@@ -1,41 +1,42 @@
-Model,Paradigm,Type,Freq(Hz),Hyperparameters,#Parameters,get_#Parameters
-ATCNet,General,Classification,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n_chans=22, n_outputs=4, n_times=1000)"
-AttentionBaseNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",3692,"AttentionBaseNet(n_chans=22, n_outputs=4, n_times=1000)"
-BDTCN,Normal/Abnormal,Classification,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)"
-BIOT,"Sleep Staging, Epilepsy",Classification,200,"n_chans, n_outputs",3183879,"BIOT(n_chans=2,  n_outputs=5,  n_times=6000)"
-ContraWR,Sleep Staging,"Classification, Embedding",125,"n_chans, n_outputs, sfreq",1160165,"ContraWR(n_chans=2, n_outputs=5, n_times=3750, emb_size=256, sfreq=125)"
-CTNet,Motor Imagery,Classification,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, heads=2, emb_size=16)"
-Deep4Net,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",282879,"Deep4Net(n_chans=22, n_outputs=4, n_times=1000)"
-DeepSleepNet,Sleep Staging,Classification,256,"n_chans, n_outputs",24744837,"DeepSleepNet(n_chans=1, n_outputs=5, n_times=7680, sfreq=256)"
-EEGConformer,General,Classification,250,"n_chans, n_outputs, n_times",789572,"EEGConformer(n_chans=22, n_outputs=4, n_times=1000)."
-EEGInceptionERP,"ERP, SSVEP",Classification,128,"n_chans, n_outputs",14926,"EEGInceptionERP(n_chans=8, n_outputs=2, n_times=128, sfreq=128)"
-EEGInceptionMI,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",558028,"EEGInceptionMI(n_chans=22, n_outputs=4, n_times=1000, n_convs=5, n_filters=12)"
-EEGITNet,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times",5212,"EEGITNet(n_chans=22,  n_outputs=4,  n_times=500)"
-EEGNetv1,General,Classification,128,"n_chans, n_outputs, n_times",3052,"EEGNetv1(n_chans=22,  n_outputs=4,  n_times=512)"
-EEGNetv4,General,Classification,128,"n_chans, n_outputs, n_times",2484,"EEGNetv4(n_chans=22,  n_outputs=4,  n_times=512)"
-EEGNeX,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times",55940,"EEGNeX(n_chans=22,  n_outputs=4,  n_times=500)"
-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)"
-EEGResNet,General,Classification,250,"n_chans, n_outputs, n_times",247484,"EEGResNet(n_chans=22,  n_outputs=4,  n_times=1000)"
-EEGSimpleConv,Motor Imagery,Classification,80,"n_chans, n_outputs, sfreq",730404,"EEGSimpleConv(n_chans=22,  n_outputs=4,  n_times=320, sfreq=80)"
-EEGTCNet,Motor Imagery,Classification,250,"n_chans, n_outputs",4516,"EEGTCNet(n_chans=22,  n_outputs=4,  n_times=1000, kern_length=32)"
-Labram,General,"Classification, Embedding",200,"n_chans, n_outputs, n_times",5866180,"Labram(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)"
-MSVTNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",75494," MSVTNet(n_chans=22,  n_outputs=4,  n_times=1000)"
-SCCNet,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times, sfreq",12070,"SCCNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=125)"
-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])"
-SignalJEPA_Contextual,"Motor Imagery, ERP, SSVEP",Classification,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])"
-SignalJEPA_PostLocal,"Motor Imagery, ERP, SSVEP",Classification,128,"n_chans, n_outputs, n_times",16142,"SignalJEPA_PostLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)"
-SignalJEPA_PreLocal,"Motor Imagery, ERP, SSVEP",Classification,128,"n_outputs, n_times, chs_info",16142,"SignalJEPA_PreLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)"
-SincShallowNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",21892,"SincShallowNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)"
-ShallowFBCSPNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",46084,"ShallowFBCSPNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)"
-SleepStagerBlanco2020,Sleep Staging,Classification,100,"n_chans, n_outputs, n_times",2845,"SleepStagerBlanco2020(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)"
-SleepStagerChambon2018,Sleep Staging,Classification,128,"n_chans, n_outputs, n_times, sfreq",5835,"SleepStagerChambon2018(n_chans=2, n_outputs=5, n_times=3840, sfreq=128)"
-SleepStagerEldele2021,Sleep Staging,Classification,100,"n_chans, n_outputs, n_times, sfreq",719925,"SleepStagerEldele2021(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)"
-SPARCNet,Epilepsy,Classification,200,"n_chans, n_outputs, n_times",1141921,"SPARCNet(n_chans=16, n_outputs=6, n_times=2000, sfreq=200)"
-SyncNet,"Emotion Recognition, Alcoholism",Classification,256,"n_chans, n_outputs, n_times",554,"SyncNet(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)"
-TSceptionV1,Emotion Recognition,Classification,256,"n_chans, n_outputs, n_times, sfreq",2187206,"TSceptionV1(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)"
-TIDNet,General,Classification,250,"n_chans, n_outputs, n_times",240404,"TIDNet(n_chans=22,  n_outputs=4,  n_times=1000)"
-USleep,Sleep Staging,Classification,128,"n_chans, n_outputs, n_times, sfreq",2482011,"USleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)"
-FBCNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",11812,"FCNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)"
-FBMSNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",16231,"FBMSNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)"
-FBLightConvNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",6596,"FBLightConvNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)"
-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)"
+Model,Application,Type,Sampling Frequency (Hz),Hyperparameters,#Parameters,get_#Parameters,Categorization
+ATCNet,General,Classification,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Recurrent,Small Attention"
+AttentionBaseNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",3692,"AttentionBaseNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
+BDTCN,Normal Abnormal,Classification,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",Classification,200,"n_chans, n_outputs",3183879,"BIOT(n_chans=2,  n_outputs=5,  n_times=6000)","Large Brain Model"
+ContraWR,Sleep Staging,"Classification, 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,Classification,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, heads=2, emb_size=16)","Convolution,Small Attention"
+Deep4Net,General,Classification,250,"n_chans, n_outputs, n_times",282879,"Deep4Net(n_chans=22, n_outputs=4, n_times=1000)","Convolution"
+DeepSleepNet,Sleep Staging,Classification,256,"n_chans, n_outputs",24744837,"DeepSleepNet(n_chans=1, n_outputs=5, n_times=7680, sfreq=256)","Convolution,Recurrent"
+EEGConformer,General,Classification,250,"n_chans, n_outputs, n_times",789572,"EEGConformer(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
+EEGInceptionERP,"ERP, SSVEP",Classification,128,"n_chans, n_outputs",14926,"EEGInceptionERP(n_chans=8, n_outputs=2, n_times=128, sfreq=128)","Convolution"
+EEGInceptionMI,Motor Imagery,Classification,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,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"
+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"
+Labram,General,"Classification, Embedding",200,"n_chans, n_outputs, n_times",5866180,"Labram(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Large Brain Model"
+MSVTNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",75494," MSVTNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution,Recurrent,Small Attention"
+SCCNet,Motor Imagery,Classification,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,Large Brain Model"
+SignalJEPA_Contextual,"Motor Imagery, ERP, SSVEP",Classification,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,Large Brain Model"
+SignalJEPA_PostLocal,"Motor Imagery, ERP, SSVEP",Classification,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,Large Brain Model"
+SignalJEPA_PreLocal,"Motor Imagery, ERP, SSVEP",Classification,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,Large Brain Model"
+SincShallowNet,Motor Imagery,Classification,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,Classification,250,"n_chans, n_outputs, n_times",46084,"ShallowFBCSPNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution"
+SleepStagerBlanco2020,Sleep Staging,Classification,100,"n_chans, n_outputs, n_times",2845,"SleepStagerBlanco2020(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution"
+SleepStagerChambon2018,Sleep Staging,Classification,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,Classification,100,"n_chans, n_outputs, n_times, sfreq",719925,"AttnSleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Small Attention"
+SPARCNet,Epilepsy,Classification,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",Classification,256,"n_chans, n_outputs, n_times",554,"SyncNet(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Interpretability"
+TSception,Emotion Recognition,Classification,256,"n_chans, n_outputs, n_times, sfreq",2187206,"TSception(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Convolution"
+TIDNet,General,Classification,250,"n_chans, n_outputs, n_times",240404,"TIDNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution"
+USleep,Sleep Staging,Classification,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,Classification,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,Classification,250,"n_chans, n_outputs, n_times, sfreq",16231,"FBMSNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
+FBLightConvNet,Motor Imagery,Classification,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,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/tidnet.py

@@ -13,6 +13,8 @@ from braindecode.modules import Ensure4d
 class TIDNet(EEGModuleMixin, nn.Module):
     """Thinker Invariance DenseNet model from Kostas et al. (2020) [TIDNet]_.
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://content.cld.iop.org/journals/1741-2552/17/5/056008/revision3/jneabb7a7f1_hr.jpg
         :align: center
         :alt: TIDNet Architecture

braindecode/models/tsinception.py

@@ -7,19 +7,21 @@ from __future__ import annotations
 import torch
 import torch.nn as nn
 from einops.layers.torch import Rearrange
-from mne.utils import warn
+from mne.utils import deprecated, warn
 
 from braindecode.models.base import EEGModuleMixin
 
 
-class TSceptionV1(EEGModuleMixin, nn.Module):
+class TSception(EEGModuleMixin, nn.Module):
     """TSception model from Ding et al. (2020) from [ding2020]_.
 
+    :bdg-success:`Convolution`
+
     TSception: A deep learning framework for emotion detection using EEG.
 
     .. figure:: https://user-images.githubusercontent.com/58539144/74716976-80415e00-526a-11ea-9433-02ab2b753f6b.PNG
         :align: center
-        :alt: TSceptionV1 Architecture
+        :alt: TSception Architecture
 
     The model consists of temporal and spatial convolutional layers
     (Tception and Sception) designed to learn temporal and spatial features
@@ -281,3 +283,13 @@ class TSceptionV1(EEGModuleMixin, nn.Module):
             activation(),
             nn.AvgPool2d(kernel_size=(1, pool_size), stride=(1, pool_size)),
         )
+
+
+@deprecated(
+    "`TSceptionV1` was renamed to `TSception` in v1.12; "
+    "this alias will be removed in v1.14."
+)
+class TSceptionV1(TSception):
+    """Deprecated alias for TSception."""
+
+    pass

braindecode/models/usleep.py

@@ -15,22 +15,121 @@ class USleep(EEGModuleMixin, nn.Module):
     """
     Sleep staging architecture from Perslev et al. (2021) [1]_.
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://media.springernature.com/full/springer-static/image/art%3A10.1038%2Fs41746-021-00440-5/MediaObjects/41746_2021_440_Fig2_HTML.png
         :align: center
         :alt: USleep Architecture
 
-    U-Net (autoencoder with skip connections) feature-extractor for sleep
-    staging described in [1]_.
+        Figure: U-Sleep consists of an encoder (left) which encodes the input signals into dense feature representations, a decoder (middle) which projects
+        the learned features into the input space to generate a dense sleep stage representation, and finally a specially designed segment
+        classifier (right) which generates sleep stages at a chosen temporal resolution.
+
+    .. rubric:: Architectural Overview
+
+    U-Sleep is a **fully convolutional**, feed-forward encoder-decoder with a *segment classifier* head for
+    time-series **segmentation** (sleep staging). It maps multi-channel PSG (EEG+EOG) to a *dense, high-frequency*
+    per-sample representation, then aggregates it into fixed-length stage labels (e.g., 30 s). The network
+    processes arbitrarily long inputs in **one forward pass** (resampling to 128 Hz), allowing whole-night
+    hypnograms in seconds.
+
+    - (i). :class:`_EncoderBlock` extracts progressively deeper temporal features at lower resolution;
+    - (ii). :class:`_Decoder` upsamples and fuses encoder features via U-Net-style skips to recover a per-sample stage map;
+    - (iii). Segment Classifier mean-pools over the target epoch length and applies two pointwise convs to yield
+      per-epoch probabilities. Integrates into the USleep class.
+
+    .. rubric:: Macro Components
+
+    - Encoder :class:`_EncoderBlock` **(multi-scale temporal feature extractor; downsampling x2 per block)**
+
+        - *Operations.*
+        - **Conv1d** (:class:`torch.nn.Conv1d`) with kernel ``9`` (stride ``1``, no dilation)
+        - **ELU** (:class:`torch.nn.ELU`)
+        - **Batch Norm** (:class:`torch.nn.BatchNorm1d`)
+        - **Max Pool 1d**, :class:`torch.nn.MaxPool1d` (``kernel=2, stride=2``).
+
+        Filters grow with depth by a factor of ``sqrt(2)`` (start ``c_1=5``); each block exposes a **skip**
+        (pre-pooling activation) to the matching decoder block.
+        *Role.* Slow, uniform downsampling preserves early information while expanding the effective temporal
+        context over minutes—foundational for robust cross-cohort staging.
+
+    The number of filters grows with depth (capacity scaling); each block also exposes a **skip** (pre-pool)
+    to the matching decoder block.
+
+    **Rationale.**
+        - Slow, uniform downsampling (x2 each level) preserves information in early layers while expanding the temporal receptive field over the minutes.
+
+    - 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, ``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).
+
+    **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.
+
+    - **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.
+
+    - **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.
+
+
+    .. rubric:: Attention / Sequential Modules
+
+    U-Sleep contains **no attention or recurrent units**; it is a *pure* feed-forward, fully convolutional
+    segmentation network inspired by U-Net/U-Time, favoring training stability and cross-dataset portability.
+
+
+    .. rubric:: Additional Mechanisms
+
+    - **U-Net lineage with task-specific head.** U-Sleep extends U-Time by being **deeper** (12 vs. 4 levels),
+      switching ReLU→**ELU**, using uniform pooling (2) at all depths, and replacing the linear combiner with a
+      **two-layer** pointwise head—improving capacity and resilience across datasets.
+    - **Arbitrary-length inference.** Thanks to full convolutionality and tiling-free design, entire nights can be
+      staged in a single pass on commodity hardware. Inputs shorter than ≈ 17.5 min may reduce performance by
+      limiting long-range context.
+    - **Complexity scaling (alpha).** Filter counts can be adjusted by a global **complexity factor** to trade accuracy
+      and memory (as described in the paper's topology table).
+
 
-    For the encoder ('down'):
-        - the temporal dimension shrinks (via maxpooling in the time-domain)
-        - the spatial dimension expands (via more conv1d filters in the time-domain)
+    .. rubric:: Usage and Configuration
 
-    For the decoder ('up'):
-        - the temporal dimension expands (via upsampling in the time-domain)
-        - the spatial dimension shrinks (via fewer conv1d filters in the time-domain)
+    - **Practice.** Resample PSG to **128 Hz** and provide at least two channels (one EEG, one EOG). Choose epoch
+      length *i* (often 30 s); ensure windows long enough to exploit the model's receptive field (e.g., training on
+      ≥ 17.5 min chunks).
 
-    Both do so at exponential rates.
 
     Parameters
     ----------

braindecode/models/util.py

@@ -22,6 +22,8 @@ def _init_models_dict():
             issubclass(m[1], models.base.EEGModuleMixin)
             and m[1] != models.base.EEGModuleMixin
         ):
+            if m[1].__name__ == "EEGNetv4":
+                continue
             models_dict[m[0]] = m[1]
 
 
@@ -55,9 +57,7 @@ models_mandatory_parameters = [
     ("EEGInceptionERP", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     ("EEGInceptionMI", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     ("EEGITNet", ["n_chans", "n_outputs", "n_times"], None),
-    ("EEGNetv1", ["n_chans", "n_outputs", "n_times"], None),
-    ("EEGNetv4", ["n_chans", "n_outputs", "n_times"], None),
-    ("EEGResNet", ["n_chans", "n_outputs", "n_times"], None),
+    ("EEGNet", ["n_chans", "n_outputs", "n_times"], None),
     ("ShallowFBCSPNet", ["n_chans", "n_outputs", "n_times"], None),
     (
         "SleepStagerBlanco2020",
@@ -66,7 +66,7 @@ models_mandatory_parameters = [
     ),
     ("SleepStagerChambon2018", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     (
-        "SleepStagerEldele2021",
+        "AttnSleep",
         ["n_outputs", "n_times", "sfreq"],
         dict(sfreq=100.0, n_times=3000, chs_info=[dict(ch_name="C1", kind="eeg")]),
     ),  # 1 channel
@@ -79,7 +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),
-    ("TSceptionV1", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
+    ("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),
     ("MSVTNet", ["n_chans", "n_outputs", "n_times"], None),
@@ -95,6 +95,9 @@ models_mandatory_parameters = [
     ("FBMSNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("FBLightConvNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("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),
 ]
 
 ################################################################

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

braindecode/modules/layers.py

@@ -70,26 +70,27 @@ class TimeDistributed(nn.Module):
 class DropPath(nn.Module):
     """Drop paths, also known as Stochastic Depth, per sample.
 
-        When applied in main path of residual blocks.
+    When applied in main path of residual blocks.
 
-        Parameters:
-        -----------
-        drop_prob: float (default=None)
-            Drop path probability (should be in range 0-1).
+    Parameters
+    ----------
+    drop_prob: float (default=None)
+        Drop path probability (should be in range 0-1).
 
-        Notes
-        -----
-        Code copied and modified from VISSL facebookresearch:
+    Notes
+    -----
+    Code copied and modified from VISSL facebookresearch:
     https://github.com/facebookresearch/vissl/blob/0b5d6a94437bc00baed112ca90c9d78c6ccfbafb/vissl/models/model_helpers.py#L676
-        All rights reserved.
-
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
+
+    All rights reserved.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
     """
 
     def __init__(self, drop_prob=None):

braindecode/preprocessing/__init__.py

@@ -1,3 +1,16 @@
+from .eegprep_preprocess import (
+    EEGPrep,
+    ReinterpolateRemovedChannels,
+    RemoveBadChannels,
+    RemoveBadChannelsNoLocs,
+    RemoveBadWindows,
+    RemoveBursts,
+    RemoveCommonAverageReference,
+    RemoveDCOffset,
+    RemoveDrifts,
+    RemoveFlatChannels,
+    Resampling,
+)
 from .mne_preprocess import (  # type: ignore[attr-defined]
     Crop,
     DropChannels,
@@ -31,6 +44,17 @@ __all__ = [
     "Filter",
     "Pick",
     "Crop",
+    "EEGPrep",
+    "RemoveDCOffset",
+    "Resampling",
+    "RemoveFlatChannels",
+    "RemoveDrifts",
+    "RemoveBadChannels",
+    "RemoveBadChannelsNoLocs",
+    "RemoveBursts",
+    "RemoveBadWindows",
+    "ReinterpolateRemovedChannels",
+    "RemoveCommonAverageReference",
     "create_windows_from_events",
     "create_fixed_length_windows",
     "create_windows_from_target_channels",