Braindecode 1.2.0.dev175267687__tar.gz → 1.2.0.dev176281713__tar.gz

{braindecode-1.2.0.dev175267687/braindecode.egg-info → braindecode-1.2.0.dev176281713}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.2.0.dev175267687
+Version: 1.2.0.dev176281713
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Requires-Python: >3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: NOTICE.txt
@@ -52,7 +52,6 @@ Requires-Dist: sphinx_rtd_theme; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
 Requires-Dist: sphinx-autobuild; extra == "docs"
 Requires-Dist: sphinxcontrib-bibtex; extra == "docs"
-Requires-Dist: sphinx_sitemap; extra == "docs"
 Requires-Dist: pydata_sphinx_theme; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
 Requires-Dist: memory_profiler; extra == "docs"

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/__init__.py

@@ -4,7 +4,6 @@ Some predefined network architectures for EEG decoding.
 
 from .atcnet import ATCNet
 from .attentionbasenet import AttentionBaseNet
-from .attn_sleep import AttnSleep
 from .base import EEGModuleMixin
 from .biot import BIOT
 from .contrawr import ContraWR
@@ -16,8 +15,9 @@ from .eeginception_erp import EEGInceptionERP
 from .eeginception_mi import EEGInceptionMI
 from .eegitnet import EEGITNet
 from .eegminer import EEGMiner
-from .eegnet import EEGNet, EEGNetv4
+from .eegnet import EEGNetv4
 from .eegnex import EEGNeX
+from .eegresnet import EEGResNet
 from .eegsimpleconv import EEGSimpleConv
 from .eegtcnet import EEGTCNet
 from .fbcnet import FBCNet
@@ -38,11 +38,12 @@ from .signal_jepa import (
 from .sinc_shallow import SincShallowNet
 from .sleep_stager_blanco_2020 import SleepStagerBlanco2020
 from .sleep_stager_chambon_2018 import SleepStagerChambon2018
+from .sleep_stager_eldele_2021 import SleepStagerEldele2021
 from .sparcnet import SPARCNet
 from .syncnet import SyncNet
 from .tcn import BDTCN, TCN
 from .tidnet import TIDNet
-from .tsinception import TSception
+from .tsinception import TSceptionV1
 from .usleep import USleep
 from .util import _init_models_dict, models_mandatory_parameters
 
@@ -52,7 +53,6 @@ _init_models_dict()
 
 __all__ = [
     "ATCNet",
-    "AttnSleep",
     "AttentionBaseNet",
     "EEGModuleMixin",
     "BIOT",
@@ -65,9 +65,9 @@ __all__ = [
     "EEGInceptionMI",
     "EEGITNet",
     "EEGMiner",
-    "EEGNet",
     "EEGNetv4",
     "EEGNeX",
+    "EEGResNet",
     "EEGSimpleConv",
     "EEGTCNet",
     "FBCNet",
@@ -86,12 +86,13 @@ __all__ = [
     "SincShallowNet",
     "SleepStagerBlanco2020",
     "SleepStagerChambon2018",
+    "SleepStagerEldele2021",
     "SPARCNet",
     "SyncNet",
     "BDTCN",
     "TCN",
     "TIDNet",
-    "TSception",
+    "TSceptionV1",
     "USleep",
     "_init_models_dict",
     "models_mandatory_parameters",

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/atcnet.py

@@ -138,7 +138,7 @@ class ATCNet(EEGModuleMixin, nn.Module):
     .. rubric:: Usage and Configuration
 
         - ``conv_block_n_filters (F1)``, ``conv_block_depth_mult (D)`` → capacity of the stem
-        (with ``F2 = F1·D`` feeding attention/TCN), dimensions aligned to ``F2``, like :class:`EEGNet`.
+        (with ``F2 = F1·D`` feeding attention/TCN), dimensions aligned to ``F2``, like `EEGNetv4`.
         - Pool sizes ``P1,P2`` trade temporal resolution for stability/compute; they set
         ``T_c = T/(P1·P2)`` and thus window width ``T_w``.
         - ``n_windows`` controls the ensemble over shifts (compute ∝ windows).

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/ctnet.py

@@ -39,7 +39,7 @@ class CTNet(EEGModuleMixin, nn.Module):
     The architecture consists of three main components:
 
     1. **Convolutional Module**:
-        - Apply :class:`EEGNet` to perform some feature extraction, denoted here as
+        - Apply EEGNetV4 to perform some feature extraction, denoted here as
         _PatchEmbeddingEEGNet module.
 
     2. **Transformer Encoder Module**:

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/deep4.py

@@ -19,13 +19,9 @@ from braindecode.modules import (
 class Deep4Net(EEGModuleMixin, nn.Sequential):
     """Deep ConvNet model from Schirrmeister et al (2017) [Schirrmeister2017]_.
 
-    :bdg-success:`Convolution`
-
-    .. figure:: https://onlinelibrary.wiley.com/cms/asset/fc200ccc-d8c4-45b4-8577-56ce4d15999a/hbm23730-fig-0001-m.jpg
+     .. figure:: https://onlinelibrary.wiley.com/cms/asset/fc200ccc-d8c4-45b4-8577-56ce4d15999a/hbm23730-fig-0001-m.jpg
         :align: center
-        :alt: Deep4Net Architecture
-        :width: 600px
-
+        :alt: CTNet Architecture
 
     Model described in [Schirrmeister2017]_.
 

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/deepsleepnet.py

@@ -8,128 +8,14 @@ from braindecode.models.base import EEGModuleMixin
 
 
 class DeepSleepNet(EEGModuleMixin, nn.Module):
-    """DeepSleepNet from Supratak et al. (2017) [Supratak2017]_.
+    """Sleep staging architecture from Supratak et al. (2017) [Supratak2017]_.
 
-    :bdg-success:`Convolution` :bdg-info:`Recurrent`
-
-    .. figure:: https://raw.githubusercontent.com/akaraspt/deepsleepnet/master/img/deepsleepnet.png
+     .. figure:: https://raw.githubusercontent.com/akaraspt/deepsleepnet/refs/heads/master/img/deepsleepnet.png
         :align: center
         :alt: DeepSleepNet Architecture
-        :width: 700px
-
-    .. rubric:: Architectural Overview
-
-    DeepSleepNet couples **dual-path convolution neural network representation learning** with
-    **sequence residual learning** via bidirectional LSTMs.
-
-    The network have:
-
-    - (i) learns complementary, time-frequency features from each
-      30-s epoch using **two parallel CNNs** (small vs. large first-layer filters), then
-    - (ii) models **temporal dependencies across epochs** using **two-layer BiLSTMs**
-      with a **residual shortcut** from the CNN features, and finally
-    - (iii) outputs per-epoch sleep stages. This design encodes both
-      epoch-local patterns and longer-range transition rules used by human scorers.
-
-    In term of implementation:
-
-    - (i) :class:`_RepresentationLearning` two CNNs extract epoch-wise features
-      (small-filter path for temporal precision; large-filter path for frequency precision);
-    - (ii) :class:`_SequenceResidualLearning` stacked BiLSTMs with peepholes + residual shortcut
-      inject temporal context while preserving CNN evidence;
-    - (iii) :class:`_Classifier` linear readout (softmax) for the five sleep stages.
-
-    .. rubric:: Macro Components
-
-    - :class:`_RepresentationLearning` **(dual-path CNN → epoch feature)**
-
-       - *Operations.*
-       - **Small-filter CNN** 4 times:
-       - :class:`~torch.nn.Conv1d`
-       - :class:`~torch.nn.BatchNorm1d`
-       - :class:`~torch.nn.ReLU`
-       - :class:`~torch.nn.MaxPool1d` after.
-       First conv uses **filter length ≈ Fs/2** and **stride ≈ Fs/16** to emphasize *timing* of graphoelements.
-    - **Large-filter CNN**:
-        - Same stack but first conv uses **filter length ≈ 4·Fs** and
-        - **stride ≈ Fs/2** to emphasize *frequency* content.
-    - Outputs from both paths are **concatenated** into the epoch embedding ``a_t``.
-
-    - *Rationale.*
-      Two first-layer scales provide a **learned, dual-scale filter bank** that trades
-      temporal vs. frequency precision without hand-crafted features.
-
-    - :class:`_SequenceResidualLearning` (:class:`~torch.nn.BiLSTM` **context + residual fusion)**
-
-        - *Operations.*
-        - **Two-layer BiLSTM** with **peephole connections** processes the sequence of epoch embeddings
-          ``{a_t}`` forward and backward; hidden states from both directions are **concatenated**.
-        - A **shortcut MLP** (fully connected + :class:`~torch.nn.BatchNorm1d` + :class:`~torch.nn.ReLU`) projects ``a_t`` to the BiLSTM output
-          dimension and is **added** (residual) to the :class:`~torch.nn.BiLSTM` output at each time step.
-        - *Role.* Encodes **stage-transition rules** and smooths predictions over time while preserving
-          salient CNN features via the residual path.
-
-    - :class:`_Classifier` **(epoch-wise prediction)**
-
-        - *Operations.*
-        - :class:`~torch.nn.Linear` to produce per-epoch class probabilities.
 
-    Original training uses two-step optimization: CNN pretraining on class-balanced data,
-    then end-to-end fine-tuning with sequential batches.
-
-    .. rubric:: Convolutional Details
-
-    - **Temporal (where time-domain patterns are learned).**
-
-    Both CNN paths use **1-D temporal convolutions**. The *small-filter* path (first kernel ≈ Fs/2,
-    stride ≈ Fs/16) captures *when* characteristic transients occur; the *large-filter* path
-    (first kernel ≈ 4·Fs, stride ≈ Fs/2) captures *which* frequency components dominate over the
-    epoch. Deeper layers use **small kernels** to refine features with fewer parameters, interleaved
-    with **max pooling** for downsampling.
-
-    - **Spatial (how channels are processed).**
-    The original model operates on **single-channel** raw EEG; convolutions therefore mix only
-    along time (no spatial convolution across electrodes).
-
-    - **Spectral (how frequency information emerges).**
-    No explicit Fourier/wavelet transform is used. The **large-filter path** serves as a
-    *frequency-sensitive* analyzer, while the **small-filter path** remains *time-sensitive*,
-    together functioning as a **two-band learned filter bank** at the first layer.
-
-    .. rubric:: Attention / Sequential Modules
-
-    - **Type.** **Bidirectional LSTM** (two layers) with **peephole connections**; forward and
-      backward streams are independent and concatenated.
-    - **Shapes.** For a sequence of ``N`` epochs, the CNN produces ``{a_t} ∈ R^{D}``;
-      BiLSTM outputs ``h_t ∈ R^{2H}``; the shortcut MLP maps ``a_t → R^{2H}`` to enable
-      **element-wise residual addition**.
-    - **Role.** Models **long-range temporal dependencies** (e.g., persisting N2 without visible
-      K-complex/spindles), stabilizing per-epoch predictions.
-
-
-    .. rubric:: Additional Mechanisms
-
-    - **Residual shortcut over sequence encoder.** Adds projected CNN features to BiLSTM outputs,
-      improving gradient flow and retaining discriminative content from representation learning.
-    - **Two-step training.**
-        - (i) **Pretrain** the CNN paths with class-balanced sampling;
-        - (ii) **fine-tune** the full network with sequential batches, using **lower LR** for CNNs and **higher LR** for the
-        sequence encoder.
-    - **State handling.** BiLSTM states are **reinitialized per subject** so that temporal context
-      does not leak across recordings.
-
-
-    .. rubric:: Usage and Configuration
-
-    - **Epoch pipeline.** Use **two parallel CNNs** with the first conv sized to **Fs/2** (small path)
-      and **4·Fs** (large path), with strides **Fs/16** and **Fs/2**, respectively; stack three more
-      conv blocks with small kernels, plus **max pooling** in each path. Concatenate path outputs
-      to form epoch embeddings.
-    - **Sequence encoder.** Apply **two-layer BiLSTM (peepholes)** over the sequence of embeddings;
-      add a **projection MLP** on the CNN features and **sum** with BiLSTM outputs (residual).
-      Finish with :class:`~torch.nn.Linear` per epoch.
-    - **Reference implementation.** See the official repository for a faithful implementation and
-      training scripts.
+    Convolutional neural network and bidirectional-Long Short-Term
+    for single channels sleep staging described in [Supratak2017]_.
 
     Parameters
     ----------
@@ -146,6 +32,7 @@ class DeepSleepNet(EEGModuleMixin, nn.Module):
     drop_prob : float, default=0.5
         The dropout rate for regularization. Values should be between 0 and 1.
 
+
     References
     ----------
     .. [Supratak2017] Supratak, A., Dong, H., Wu, C., & Guo, Y. (2017).

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/eeginception_erp.py

@@ -15,84 +15,12 @@ from braindecode.modules import DepthwiseConv2d, Ensure4d, InceptionBlock
 class EEGInceptionERP(EEGModuleMixin, nn.Sequential):
     """EEG Inception for ERP-based from Santamaria-Vazquez et al (2020) [santamaria2020]_.
 
-    :bdg-success:`Convolution`
-
     .. figure:: https://braindecode.org/dev/_static/model/eeginceptionerp.jpg
         :align: center
         :alt: EEGInceptionERP Architecture
 
-        Figure: Overview of EEG-Inception architecture. 2D convolution blocks and depthwise 2D convolution blocks include batch normalization, activation and dropout regularization. The kernel size is displayed for convolutional and average pooling layers.
-
-    .. rubric:: Architectural Overview
-
-    A two-stage, multi-scale CNN tailored to ERP detection from short (0-1000 ms) single-trial epochs. Signals are mapped through
-    * (i) :class:`_InceptionModule1` multi-scale temporal feature extraction plus per-branch spatial mixing;
-    * (ii) :class:`_InceptionModule2` deeper multi-scale refinement at a reduced temporal resolution; and
-    * (iii) :class:`_OutputModule` compact aggregation and linear readout.
-
-    .. rubric:: Macro Components
-
-    - :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.
-
-    *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)``.
-
-    *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)``
-
-    .. 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.
-
-    - **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.
-
-    - **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.
-
-    .. rubric:: Additional Mechanisms
-
-    - Every conv/depthwise block includes **BatchNorm**, nonlinearity (paper used grid-searched activation), and **dropout**.
-    - Two Inception stages followed by short convs and pooling keep parameters small (≈15k reported) while preserving multi-scale evidence.
-    - Expected input: epochs of shape ``(B,1,128,8)`` (time x channels as a 2D map) or reshaped from ``(B,8,128)`` with an added singleton feature dimension.
-
-    .. rubric:: Usage and Configuration
-
-    - **Key knobs.** Number of filters per branch; kernel lengths in both Inception modules; depthwise kernel over channels (typically ``n_chans``); pooling lengths/strides; dropout rate; choice of activation.
-    - **Training tips.** Use 0-1000 ms windows at 128 Hz with CAR; tune activation and dropout (they strongly affect performance); early-stop on validation loss when overfitting emerges.
-
-    .. rubric:: Implementation Details
+    The code for the paper and this model is also available at [santamaria2020]_
+    and an adaptation for PyTorch [2]_.
 
     The model is strongly based on the original InceptionNet for an image. The main goal is
     to extract features in parallel with different scales. The authors extracted three scales
@@ -105,9 +33,12 @@ class EEGInceptionERP(EEGModuleMixin, nn.Sequential):
     The winners of BEETL Competition/NeurIps 2021 used parts of the
     model [beetl]_.
 
-    The code for the paper and this model is also available at [santamaria2020]_
-    and an adaptation for PyTorch [2]_.
+    The model is fully described in [santamaria2020]_.
 
+    Notes
+    -----
+    This implementation is not guaranteed to be correct, has not been checked
+    by original authors, only reimplemented from the paper based on [2]_.
 
     Parameters
     ----------

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/eeginception_mi.py

@@ -13,8 +13,6 @@ from braindecode.modules import Ensure4d
 class EEGInceptionMI(EEGModuleMixin, nn.Module):
     """EEG Inception for Motor Imagery, as proposed in Zhang et al. (2021) [1]_
 
-    :bdg-success:`Convolution`
-
     .. figure:: https://content.cld.iop.org/journals/1741-2552/18/4/046014/revision3/jneabed81f1_hr.jpg
         :align: center
         :alt: EEGInceptionMI Architecture

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/eegnet.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 from typing import Dict, Optional
 
 from einops.layers.torch import Rearrange
-from mne.utils import deprecated, warn
+from mne.utils import warn
 from torch import nn
 
 from braindecode.functional import glorot_weight_zero_bias
@@ -19,21 +19,22 @@ from braindecode.modules import (
 )
 
 
-class EEGNet(EEGModuleMixin, nn.Sequential):
-    """EEGNet model from Lawhern et al. (2018) [Lawhern2018]_.
+class EEGNetv4(EEGModuleMixin, nn.Sequential):
+    """EEGNet v4 model from Lawhern et al. (2018) [Lawhern2018]_.
+
+    :bdg-success:`Convolution` :bdg-secondary:`Depthwise–Separable`
 
-    :bdg-success:`Convolution`
     .. figure:: https://content.cld.iop.org/journals/1741-2552/15/5/056013/revision2/jneaace8cf01_hr.jpg
        :align: center
-       :alt: EEGNet Architecture
+       :alt: EEGNetv4 Architecture
        :width: 600px
 
     .. rubric:: Architectural Overview
 
-    EEGNet is a compact convolutional network designed for EEG decoding with a pipeline that mirrors classical EEG processing:
+    EEGNetv4 is a compact convolutional network designed for EEG decoding with a pipeline that mirrors classical EEG processing:
     - (i) learn temporal frequency-selective filters,
     - (ii) learn spatial filters for those frequencies, and
-    - (iii) condense features with depthwise-separable convolutions before a lightweight classifier.
+    - (iii) condense features with depthwise–separable convolutions before a lightweight classifier.
 
     The architecture is deliberately small (temporal convolutional and spatial patterns) [Lawhern2018]_.
 
@@ -44,9 +45,9 @@ class EEGNet(EEGModuleMixin, nn.Sequential):
     - **Depthwise Spatial Filtering.**
       Depthwise convolution spanning the channel dimension with ``groups = F1``,
       yielding ``D`` spatial filters for each temporal filter (no cross-filter mixing).
-    - **Norm-Nonlinearity-Pooling (+ dropout).**
+    - **Norm–Nonlinearity–Pooling (+ dropout).**
       Batch normalization → ELU → temporal pooling, with dropout.
-    - **Depthwise-Separable Convolution Block.**
+    - **Depthwise–Separable Convolution Block.**
       (a) depthwise temporal conv to refine temporal structure;
       (b) pointwise 1x1 conv to mix feature maps into ``F2`` combinations.
     - **Classifier Head.**
@@ -72,8 +73,6 @@ class EEGNet(EEGModuleMixin, nn.Sequential):
     - **Depthwise & separable convs:** Parameter-efficient decomposition (depthwise + pointwise) retains power while limiting overfitting
       [Chollet2017]_ and keeps temporal vs. mixing steps interpretable.
     - **Regularization:** Batch norm, dropout, pooling, and optional max-norm on spatial kernels aid stability on small EEG datasets.
-    - The v4 means the version 4 at the arxiv paper [Lawhern2018]_.
-
 
     Parameters
     ----------
@@ -349,10 +348,174 @@ class EEGNet(EEGModuleMixin, nn.Sequential):
         glorot_weight_zero_bias(self)
 
 
-@deprecated(
-    "`EEGNetv4` was renamed to `EEGNet` in v1.12; this alias will be removed in v1.14."
-)
-class EEGNetv4(EEGNet):
-    """Deprecated alias for EEGNet."""
+class EEGNetv1(EEGModuleMixin, nn.Sequential):
+    """EEGNet model from Lawhern et al. 2016 from [EEGNet]_.
+
+    See details in [EEGNet]_.
+
+    Parameters
+    ----------
+    in_chans :
+        Alias for n_chans.
+    n_classes:
+        Alias for n_outputs.
+    input_window_samples :
+        Alias for n_times.
+    activation: nn.Module, default=nn.ELU
+        Activation function class to apply. Should be a PyTorch activation
+        module class like ``nn.ReLU`` or ``nn.ELU``. Default is ``nn.ELU``.
+
+    Notes
+    -----
+    This implementation is not guaranteed to be correct, has not been checked
+    by original authors, only reimplemented from the paper description.
+
+    References
+    ----------
+    .. [EEGNet] Lawhern, V. J., Solon, A. J., Waytowich, N. R., Gordon,
+       S. M., Hung, C. P., & Lance, B. J. (2016).
+       EEGNet: A Compact Convolutional Network for EEG-based
+       Brain-Computer Interfaces.
+       arXiv preprint arXiv:1611.08024.
+    """
+
+    def __init__(
+        self,
+        n_chans=None,
+        n_outputs=None,
+        n_times=None,
+        final_conv_length="auto",
+        pool_mode="max",
+        second_kernel_size=(2, 32),
+        third_kernel_size=(8, 4),
+        drop_prob=0.25,
+        activation: nn.Module = nn.ELU,
+        chs_info=None,
+        input_window_seconds=None,
+        sfreq=None,
+    ):
+        super().__init__(
+            n_outputs=n_outputs,
+            n_chans=n_chans,
+            chs_info=chs_info,
+            n_times=n_times,
+            input_window_seconds=input_window_seconds,
+            sfreq=sfreq,
+        )
+        del n_outputs, n_chans, chs_info, n_times, input_window_seconds, sfreq
+        warn(
+            "The class EEGNetv1 is deprecated and will be removed in the "
+            "release 1.0 of braindecode. Please use "
+            "braindecode.models.EEGNetv4 instead in the future.",
+            DeprecationWarning,
+        )
+        if final_conv_length == "auto":
+            assert self.n_times is not None
+        self.final_conv_length = final_conv_length
+        self.pool_mode = pool_mode
+        self.second_kernel_size = second_kernel_size
+        self.third_kernel_size = third_kernel_size
+        self.drop_prob = drop_prob
+        # For the load_state_dict
+        # When padronize all layers,
+        # add the old's parameters here
+        self.mapping = {
+            "conv_classifier.weight": "final_layer.conv_classifier.weight",
+            "conv_classifier.bias": "final_layer.conv_classifier.bias",
+        }
+
+        pool_class = dict(max=nn.MaxPool2d, mean=nn.AvgPool2d)[self.pool_mode]
+        self.add_module("ensuredims", Ensure4d())
+        n_filters_1 = 16
+        self.add_module(
+            "conv_1",
+            nn.Conv2d(self.n_chans, n_filters_1, (1, 1), stride=1, bias=True),
+        )
+        self.add_module(
+            "bnorm_1",
+            nn.BatchNorm2d(n_filters_1, momentum=0.01, affine=True, eps=1e-3),
+        )
+        self.add_module("elu_1", activation())
+        # transpose to examples x 1 x (virtual, not EEG) channels x time
+        self.add_module("permute_1", Rearrange("batch x y z -> batch z x y"))
+
+        self.add_module("drop_1", nn.Dropout(p=self.drop_prob))
 
-    pass
+        n_filters_2 = 4
+        # keras pads unequal padding more in front, so padding
+        # too large should be ok.
+        # Not padding in time so that cropped training makes sense
+        # https://stackoverflow.com/questions/43994604/padding-with-even-kernel-size-in-a-convolutional-layer-in-keras-theano
+
+        self.add_module(
+            "conv_2",
+            nn.Conv2d(
+                1,
+                n_filters_2,
+                self.second_kernel_size,
+                stride=1,
+                padding=(self.second_kernel_size[0] // 2, 0),
+                bias=True,
+            ),
+        )
+        self.add_module(
+            "bnorm_2",
+            nn.BatchNorm2d(n_filters_2, momentum=0.01, affine=True, eps=1e-3),
+        )
+        self.add_module("elu_2", activation())
+        self.add_module("pool_2", pool_class(kernel_size=(2, 4), stride=(2, 4)))
+        self.add_module("drop_2", nn.Dropout(p=self.drop_prob))
+
+        n_filters_3 = 4
+        self.add_module(
+            "conv_3",
+            nn.Conv2d(
+                n_filters_2,
+                n_filters_3,
+                self.third_kernel_size,
+                stride=1,
+                padding=(self.third_kernel_size[0] // 2, 0),
+                bias=True,
+            ),
+        )
+        self.add_module(
+            "bnorm_3",
+            nn.BatchNorm2d(n_filters_3, momentum=0.01, affine=True, eps=1e-3),
+        )
+        self.add_module("elu_3", activation())
+        self.add_module("pool_3", pool_class(kernel_size=(2, 4), stride=(2, 4)))
+        self.add_module("drop_3", nn.Dropout(p=self.drop_prob))
+
+        output_shape = self.get_output_shape()
+        n_out_virtual_chans = output_shape[2]
+
+        if self.final_conv_length == "auto":
+            n_out_time = output_shape[3]
+            self.final_conv_length = n_out_time
+
+        # Incorporating classification module and subsequent ones in one final layer
+        module = nn.Sequential()
+
+        module.add_module(
+            "conv_classifier",
+            nn.Conv2d(
+                n_filters_3,
+                self.n_outputs,
+                (n_out_virtual_chans, self.final_conv_length),
+                bias=True,
+            ),
+        )
+
+        # Transpose back to the logic of braindecode,
+
+        # so time in third dimension (axis=2)
+        module.add_module(
+            "permute_2",
+            Rearrange("batch x y z -> batch x z y"),
+        )
+
+        module.add_module("squeeze", SqueezeFinalOutput())
+
+        self.add_module("final_layer", module)
+
+        glorot_weight_zero_bias(self)

{braindecode-1.2.0.dev175267687 → braindecode-1.2.0.dev176281713}/braindecode/models/eegnex.py

@@ -51,8 +51,8 @@ class EEGNeX(EEGModuleMixin, nn.Module):
        - :class:`torch.nn.BatchNorm2d` (no nonlinearity until Block-3, mirroring a linear FIR analysis stage).
          These layers set up frequency-selective detectors before spatial mixing.
 
-       - *Interpretability.* Kernels can be inspected as FIR filters; two stacked temporal
-         convs allow longer effective kernels without parameter blow-up.
+    - *Interpretability.* Kernels can be inspected as FIR filters; two stacked temporal
+      convs allow longer effective kernels without parameter blow-up.
 
     - **Block-3 — Spatial projection + condensation.**
 
@@ -64,7 +64,7 @@ class EEGNeX(EEGModuleMixin, nn.Module):
         - :class:`torch.nn.AvgPool2d` (time)
         - :class:`torch.nn.Dropout`.
 
-    **Role**: Learns per-filter spatial patterns over the **full montage** while temporal
+    *Role.* Learns per-filter spatial patterns over the **full montage** while temporal
       pooling stabilizes and compresses features; max-norm encourages well-behaved spatial
       weights similar to EEGNet practice.
 
@@ -72,15 +72,15 @@ class EEGNeX(EEGModuleMixin, nn.Module):
 
         - *Operations.*
         - :class:`torch.nn.Conv2d` with kernels ``(1, k)`` and **dilations**
-          (e.g., 2 then 4);
+        (e.g., 2 then 4);
         - :class:`torch.nn.BatchNorm2d`
         - :class:`torch.nn.ELU`
         - :class:`torch.nn.AvgPool2d` (time)
         - :class:`torch.nn.Dropout`
         - :class:`torch.nn.Flatten`.
 
-    **Role**: Expands the temporal receptive field efficiently to capture rhythms and
-    long-range context after condensation.
+    *Role.* Expands the temporal receptive field efficiently to capture rhythms and
+      long-range context after condensation.
 
     - **Final Classifier — Max-norm linear.**
 
@@ -125,6 +125,8 @@ class EEGNeX(EEGModuleMixin, nn.Module):
       classifier layers; prefer ELU activations for stable training on small EEG datasets.
 
 
+    Notes
+    -----
     - The braindecode implementation follows the paper's conv-only design with five blocks
       and reproduces the depthwise spatial step and dilated temporal stack. See the class
       reference for exact kernel sizes, dilations, and pooling defaults. You can check the