braindecode 1.2.0.dev182094932__py3-none-any.whl → 1.3.0.dev173691341__py3-none-any.whl

braindecode/models/eeginception_mi.py

@@ -13,6 +13,8 @@ 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/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 warn
+from mne.utils import deprecated, warn
 from torch import nn
 
 from braindecode.functional import glorot_weight_zero_bias
@@ -19,23 +19,22 @@ from braindecode.modules import (
 )
 
 
-class EEGNetv4(EEGModuleMixin, nn.Sequential):
-    """EEGNet v4 model from Lawhern et al. (2018) [Lawhern2018]_.
+class EEGNet(EEGModuleMixin, nn.Sequential):
+    """EEGNet 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: EEGNetv4 Architecture
-       :width: 600px
+        :align: center
+        :alt: EEGNet Architecture
+        :width: 600px
 
     .. rubric:: Architectural Overview
 
-    EEGNetv4 is a compact convolutional network designed for EEG decoding with a
-    pipeline that mirrors classical EEG processing:
+    EEGNet 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]_.
 
@@ -46,9 +45,9 @@ class EEGNetv4(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.**
@@ -56,16 +55,16 @@ class EEGNetv4(EEGModuleMixin, nn.Sequential):
 
     .. rubric:: Convolutional Details
 
-    **Temporal.** The initial temporal convs serve as a *learned filter bank*:
-    long 1-D kernels (implemented as 2-D with singleton spatial extent) emphasize oscillatory bands and transients.
-    Because this stage is linear prior to BN/ELU, kernels can be analyzed as FIR filters to reveal each feature’s spectrum [Lawhern2018]_.
+    - **Temporal.** The initial temporal convs serve as a *learned filter bank*:
+      long 1-D kernels (implemented as 2-D with singleton spatial extent) emphasize oscillatory bands and transients.
+      Because this stage is linear prior to BN/ELU, kernels can be analyzed as FIR filters to reveal each feature’s spectrum [Lawhern2018]_.
 
-    **Spatial.** The depthwise spatial conv spans the full channel axis (kernel height = #electrodes; temporal size = 1).
-    With ``groups = F1``, each temporal filter learns its own set of ``D`` spatial projections—akin to CSP, learned end-to-end and
-    typically regularized with max-norm.
+    - **Spatial.** The depthwise spatial conv spans the full channel axis (kernel height = #electrodes; temporal size = 1).
+      With ``groups = F1``, each temporal filter learns its own set of ``D`` spatial projections—akin to CSP, learned end-to-end and
+      typically regularized with max-norm.
 
-    **Spectral.** No explicit Fourier/wavelet transform is used. Frequency structure
-    is captured implicitly by the temporal filter bank; later depthwise temporal kernels act as short-time integrators/refiners.
+    - **Spectral.** No explicit Fourier/wavelet transform is used. Frequency structure
+      is captured implicitly by the temporal filter bank; later depthwise temporal kernels act as short-time integrators/refiners.
 
     .. rubric:: Additional Comments
 
@@ -74,6 +73,8 @@ class EEGNetv4(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,174 +350,10 @@ class EEGNetv4(EEGModuleMixin, nn.Sequential):
         glorot_weight_zero_bias(self)
 
 
-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))
-
-        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)
+@deprecated(
+    "`EEGNetv4` was renamed to `EEGNet` in v1.12; this alias will be removed in v1.14."
+)
+class EEGNetv4(EEGNet):
+    """Deprecated alias for EEGNet."""
 
-        glorot_weight_zero_bias(self)
+    pass

braindecode/models/eegnex.py

@@ -16,9 +16,122 @@ from braindecode.modules import Conv2dWithConstraint, LinearWithConstraint
 class EEGNeX(EEGModuleMixin, nn.Module):
     """EEGNeX model from Chen et al. (2024) [eegnex]_.
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://braindecode.org/dev/_static/model/eegnex.jpg
         :align: center
         :alt: EEGNeX Architecture
+        :width: 620px
+
+    .. rubric:: Architectural Overview
+
+    EEGNeX is a **purely convolutional** architecture that refines the EEGNet-style stem
+    and deepens the temporal stack with **dilated temporal convolutions**. The end-to-end
+    flow is:
+
+    - (i) **Block-1/2**: two temporal convolutions ``(1 x L)`` with BN refine a
+      learned FIR-like *temporal filter bank* (no pooling yet);
+    - (ii) **Block-3**: depthwise **spatial** convolution across electrodes
+      ``(n_chans x 1)`` with max-norm constraint, followed by ELU → AvgPool (time) → Dropout;
+    - (iii) **Block-4/5**: two additional **temporal** convolutions with increasing **dilation**
+      to expand the receptive field; the last block applies ELU → AvgPool → Dropout → Flatten;
+    - (iv) **Classifier**: a max-norm–constrained linear layer.
+
+    The published work positions EEGNeX as a compact, conv-only alternative that consistently
+    outperforms prior baselines across MOABB-style benchmarks, with the popular
+    “EEGNeX-8,32” shorthand denoting *8 temporal filters* and *kernel length 32*.
+
+
+    .. rubric:: Macro Components
+
+    - **Block-1 / Block-2 — Temporal filter (learned).**
+
+       - *Operations.*
+       - :class:`torch.nn.Conv2d` with kernels ``(1, L)``
+       - :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.
+
+    - **Block-3 — Spatial projection + condensation.**
+
+        - *Operations.*
+        - :class:`braindecode.modules.Conv2dWithConstraint` with kernel``(n_chans, 1)``
+          and ``groups = filter_2`` (depthwise across filters)
+        - :class:`torch.nn.BatchNorm2d`
+        - :class:`torch.nn.ELU`
+        - :class:`torch.nn.AvgPool2d` (time)
+        - :class:`torch.nn.Dropout`.
+
+    **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.
+
+    - **Block-4 / Block-5 — Dilated temporal integration.**
+
+        - *Operations.*
+        - :class:`torch.nn.Conv2d` with kernels ``(1, k)`` and **dilations**
+          (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.
+
+    - **Final Classifier — Max-norm linear.**
+
+        - *Operations.*
+        - :class:`braindecode.modules.LinearWithConstraint` maps the flattened
+          vector to the target classes; the max-norm constraint regularizes the readout.
+
+
+    .. rubric:: Convolutional Details
+
+    - **Temporal (where time-domain patterns are learned).**
+      Blocks 1-2 learn the primary filter bank (oscillations/transients), while Blocks 4-5
+      use **dilation** to integrate over longer horizons without extra pooling. The final
+      AvgPool in Block-5 sets the output token rate and helps noise suppression.
+
+    - **Spatial (how electrodes are processed).**
+      A *single* depthwise spatial conv (Block-3) spans the entire electrode set
+      (kernel ``(n_chans, 1)``), producing per-temporal-filter topographies; no cross-filter
+      mixing occurs at this stage, aiding interpretability.
+
+    - **Spectral (how frequency content is captured).**
+      Frequency selectivity emerges from the learned temporal kernels; dilation broadens effective
+      bandwidth coverage by composing multiple scales.
+
+    .. rubric:: Additional Mechanisms
+
+    - **EEGNeX-8,32 naming.** “8,32” indicates *8 temporal filters* and *kernel length 32*,
+      reflecting the paper's ablation path from EEGNet-8,2 toward thicker temporal kernels
+      and a deeper conv stack.
+    - **Max-norm constraints.** Spatial (Block-3) and final linear layers use max-norm
+      regularization—standard in EEG CNNs—to reduce overfitting and encourage stable spatial
+      patterns.
+
+    .. rubric:: Usage and Configuration
+
+    - **Kernel schedule.** Start with the canonical **EEGNeX-8,32** (``filter_1=8``,
+      ``kernel_block_1_2=32``) and keep **Block-3** depth multiplier modest (e.g., 2) to match
+      the paper's “pure conv” profile.
+    - **Pooling vs. dilation.** Use pooling in Blocks 3 and 5 to control compute and variance;
+      increase dilations (Blocks 4-5) to widen temporal context when windows are short.
+    - **Regularization.** Combine dropout (Blocks 3 & 5) with max-norm on spatial and
+      classifier layers; prefer ELU activations for stable training on small EEG datasets.
+
+
+    - 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
+      original implementation at [EEGNexCode]_.
+
+    .. versionadded:: 1.1
+
 
     Parameters
     ----------
@@ -45,12 +158,6 @@ class EEGNeX(EEGModuleMixin, nn.Module):
     avg_pool_block5 : tuple[int, int], optional
         Pooling size for block 5. Default is (1, 8).
 
-    Notes
-    -----
-    This implementation is not guaranteed to be correct, has not been checked
-    by original authors, only reimplemented from the paper description and
-    source code in tensorflow [EEGNexCode]_.
-
     References
     ----------
     .. [eegnex] Chen, X., Teng, X., Chen, H., Pan, Y., & Geyer, P. (2024).

braindecode/models/eegsimpleconv.py

@@ -21,6 +21,8 @@ from braindecode.models.base import EEGModuleMixin
 class EEGSimpleConv(EEGModuleMixin, torch.nn.Module):
     """EEGSimpleConv from Ouahidi, YE et al. (2023) [Yassine2023]_.
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://raw.githubusercontent.com/elouayas/EEGSimpleConv/refs/heads/main/architecture.png
         :align: center
         :alt: EEGSimpleConv Architecture

braindecode/models/eegtcnet.py

@@ -157,7 +157,7 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
 class _EEGNetTC(nn.Module):
     """EEGNet Temporal Convolutional Network (TCN) block.
 
-    The main difference from our EEGNetV4 (braindecode) implementation is the
+    The main difference from our :class:`EEGNet` (braindecode) implementation is the
     kernel and dimensional order. Because of this, we decided to keep this
     implementation in a future issue; we will re-evaluate if it is necessary
     to maintain this separate implementation.

braindecode/models/sccnet.py

@@ -17,13 +17,21 @@ from braindecode.modules import LogActivation
 class SCCNet(EEGModuleMixin, nn.Module):
     """SCCNet from Wei, C S (2019) [sccnet]_.
 
+    :bdg-success:`Convolution`
+
     Spatial component-wise convolutional network (SCCNet) for motor-imagery EEG
     classification.
 
     .. figure:: https://dt5vp8kor0orz.cloudfront.net/6e3ec5d729cd51fe8acc5a978db27d02a5df9e05/2-Figure1-1.png
        :align: center
        :alt:  Spatial component-wise convolutional network
+       :width: 680px
+
+    .. rubric:: Architectural Overview
 
+    SCCNet is a spatial-first convolutional layer that fixes temporal kernels in seconds
+    to make its filters correspond to neurophysiologically aligned windows. The model
+    comprises four stages:
 
     1. **Spatial Component Analysis**: Performs convolution spatial filtering
         across all EEG channels to extract spatial components, effectively
@@ -35,11 +43,83 @@ class SCCNet(EEGModuleMixin, nn.Module):
     4. **Classification**: Flattens the features and applies a fully connected
        layer.
 
+    .. rubric:: Macro Components
+
+    - `SCCNet.spatial_conv` **(spatial component analysis)**
+
+        - *Operations.*
+        - :class:`~torch.nn.Conv2d` with kernel `(n_chans, N_t)` and stride `(1, 1)` on an input reshaped to `(B, 1, n_chans, T)`; typical choice `N_t=1` yields a pure across-channel projection (montage-wide linear spatial filter).
+        - Zero padding to preserve time, :class:`~torch.nn.BatchNorm2d`; output has `N_u` component signals shaped `(B, 1, N_u, T)` after a permute step.
+
+    *Interpretability/robustness.* Mimics CSP-like spatial filtering: each learned filter is a channel-weighted component, easing inspection and reducing channel noise.
+
+    - `SCCNet.spatial_filt_conv` **(spatio-temporal filtering)**
+
+        - *Operations.*
+        - :class:`~torch.nn.Conv2d` with kernel `(N_u, 12)` over components and time (12 samples ~ 0.1 s at 125 Hz),
+        - :class:`~torch.nn.BatchNorm2d`;
+        - Nonlinearity is **power-like**: the original paper uses **square** like :class:`~braindecode.models.ShallowFBCSPNet` with the class :class:`~braindecode.modules.LogActivation` as default.
+        - :class:`~torch.nn.Dropout` with rate `p=0.5`.
+
+    - *Role.* Learns frequency-selective energy features and inter-component interactions within a 0.1 s context (beta/alpha cycle scale).
+
+    - `SCCNet.temporal_smoothing` **(aggregation + readout)**
+
+        - *Operations.*
+        - :class:`~torch.nn.AvgPool2d` with size `(1, 62)` (~ 0.5 s) for temporal smoothing and downsampling
+        - :class:`~torch.nn.Flatten`
+        - :class:`~torch.nn.Linear` to `n_outputs`.
+
+
+    .. rubric:: Convolutional Details
+
+    * **Temporal (where time-domain patterns are learned).**
+        The second block's kernel length is fixed to 12 samples (≈ 100 ms) and slides with
+        stride 1; average pooling `(1, 62)` (≈ 500 ms) integrates power over longer spans.
+        These choices bake in short-cycle detection followed by half-second trend smoothing.
+
+    * **Spatial (how electrodes are processed).**
+        The first block's kernel spans **all electrodes** `(n_chans, N_t)`. With `N_t=1`,
+        it reduces to a montage-wide linear projection, mapping channels → `N_u` components.
+        The second block mixes **across components** via kernel height `N_u`.
+
+    * **Spectral (how frequency information is captured).**
+        No explicit transform is used; learned **temporal kernels** serve as bandpass-like
+        filters, and the **square/log power** nonlinearity plus 0.5 s averaging approximate
+        band-power estimation (ERD/ERS-style features).
+
+    .. rubric:: Attention / Sequential Modules
+
+    This model contains **no attention** and **no recurrent units**.
+
+    .. rubric:: Additional Mechanisms
+
+    - :class:`~torch.nn.BatchNorm2d` and zero-padding are applied to both convolutions;
+      L2 weight decay was used in the original paper; dropout `p=0.5` combats overfitting.
+    - Contrasting with other compact neural network, in EEGNet performs a temporal depthwise conv
+      followed by a **depthwise spatial** conv (separable), learning temporal filters first.
+      SCCNet inverts this order: it performs a **full spatial projection first** (CSP-like),
+      then a short **spatio-temporal** conv with an explicit 0.1 s kernel, followed by
+      **power-like** nonlinearity and longer temporal averaging. EEGNet's ELU and
+      separable design favor parameter efficiency; SCCNet's second-scale kernels and
+      square/log emphasize interpretable **band-power** features.
+
+    - Reference implementation: see [sccnetcode]_.
+
+    .. rubric:: Usage and Configuration
+
+    * **Training from the original authors.**
+
+    * Match window length so that `T` is comfortably larger than pooling length
+        (e.g., > 1.5-2 s for MI).
+    * Start with standard MI augmentations (channel dropout/shuffle, time reverse)
+        and tune `n_spatial_filters` before deeper changes.
 
     Parameters
     ----------
     n_spatial_filters : int, optional
-        Number of spatial filters in the first convolutional layer. Default is 22.
+        Number of spatial filters in the first convolutional layer, variable `N_u` from the
+        original paper. Default is 22.
     n_spatial_filters_smooth : int, optional
         Number of spatial filters used as filter in the second convolutional
         layer. Default is 20.
@@ -49,13 +129,6 @@ class SCCNet(EEGModuleMixin, nn.Module):
         Activation function after the second convolutional layer. Default is
         logarithm activation.
 
-    Notes
-    -----
-    This implementation is not guaranteed to be correct, has not been checked
-    by original authors, only reimplemented from the paper description and
-    the source that have not been tested [sccnetcode]_.
-
-
     References
     ----------
     .. [sccnet] Wei, C. S., Koike-Akino, T., & Wang, Y. (2019, March). Spatial

braindecode/models/shallow_fbcsp.py

@@ -20,6 +20,8 @@ from braindecode.modules import (
 class ShallowFBCSPNet(EEGModuleMixin, nn.Sequential):
     """Shallow ConvNet model from Schirrmeister et al (2017) [Schirrmeister2017]_.
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://onlinelibrary.wiley.com/cms/asset/221ea375-6701-40d3-ab3f-e411aad62d9e/hbm23730-fig-0002-m.jpg
         :align: center
         :alt: ShallowNet Architecture

braindecode/models/sleep_stager_blanco_2020.py

@@ -11,6 +11,8 @@ from braindecode.models.base import EEGModuleMixin
 class SleepStagerBlanco2020(EEGModuleMixin, nn.Module):
     """Sleep staging architecture from Blanco et al. (2020) from [Blanco2020]_
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://media.springernature.com/full/springer-static/image/art%3A10.1007%2Fs00500-019-04174-1/MediaObjects/500_2019_4174_Fig2_HTML.png
         :align: center
         :alt: SleepStagerBlanco2020 Architecture

braindecode/models/sleep_stager_chambon_2018.py

@@ -13,6 +13,8 @@ from braindecode.models.base import EEGModuleMixin
 class SleepStagerChambon2018(EEGModuleMixin, nn.Module):
     """Sleep staging architecture from Chambon et al. (2018) [Chambon2018]_.
 
+    :bdg-success:`Convolution`
+
     .. figure:: https://braindecode.org/dev/_static/model/SleepStagerChambon2018.jpg
         :align: center
         :alt: SleepStagerChambon2018 Architecture

braindecode/models/sparcnet.py

@@ -13,6 +13,8 @@ from braindecode.models.base import EEGModuleMixin
 class SPARCNet(EEGModuleMixin, nn.Module):
     """Seizures, Periodic and Rhythmic pattern Continuum Neural Network (SPaRCNet) from Jing et al. (2023) [jing2023]_.
 
+    :bdg-success:`Convolution`
+
     This is a temporal CNN model for biosignal classification based on the DenseNet
     architecture.