Braindecode 1.2.0.dev168908090__tar.gz → 1.2.0.dev169062562__tar.gz

{braindecode-1.2.0.dev168908090/braindecode.egg-info → braindecode-1.2.0.dev169062562}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.2.0.dev168908090
+Version: 1.2.0.dev169062562
 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>

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/models/atcnet.py

@@ -13,154 +13,13 @@ from braindecode.modules import CausalConv1d, Ensure4d, MaxNormLinear
 
 
 class ATCNet(EEGModuleMixin, nn.Module):
-    """ATCNet from Altaheri et al. (2022) [1]_.
+    """ATCNet model from Altaheri et al. (2022) [1]_
 
-    :bdg-success:`Convolution` :bdg-info:`Small Attention`
+    Pytorch implementation based on official tensorflow code [2]_.
 
     .. figure:: https://user-images.githubusercontent.com/25565236/185449791-e8539453-d4fa-41e1-865a-2cf7e91f60ef.png
-        :align: center
-        :alt: ATCNet Architecture
-        :width: 650px
-
-    .. rubric:: Architectural Overview
-
-    ATCNet is a *convolution-first* architecture augmented with a *lightweight attention–TCN*
-    sequence module. The end-to-end flow is:
-
-    - (i) :class:`_ConvBlock` learns temporal filter-banks and spatial projections (EEGNet-style),
-      downsampling time to a compact feature map;
-
-    - (ii) Sliding Windows carve overlapping temporal windows from this map;
-
-    - (iii) for each window, :class:`_AttentionBlock` applies small multi-head self-attention
-      over time, followed by a :class:`_TCNResidualBlock` stack (causal, dilated);
-
-    - (iv) window-level features are aggregated (mean of window logits or concatenation)
-      and mapped via a max-norm–constrained linear layer.
-
-    Relative to ViT, ATCNet replaces linear patch projection with learned *temporal–spatial*
-    convolutions; it processes *parallel* window encoders (attention→TCN) instead of a deep
-    stack; and swaps the MLP head for a TCN suited to 1-D EEG sequences.
-
-    .. rubric:: Macro Components
-
-    - :class:`_ConvBlock` **(Shallow conv stem → feature map)**
-
-        - *Operations.*
-        - **Temporal conv** (:class:`torch.nn.Conv2d`) with kernel ``(L_t, 1)`` builds a
-            FIR-like filter bank (``F1`` maps).
-        - **Depthwise spatial conv** (:class:`torch.nn.Conv2d`, ``groups=F1``) with kernel
-          ``(1, n_chans)`` learns per-filter spatial projections (akin to EEGNet’s CSP-like step).
-        - **BN → ELU → AvgPool → Dropout** to stabilize and condense activations.
-        - **Refining temporal conv** (:class:`torch.nn.Conv2d`) with kernel ``(L_r, 1)`` +
-          **BN → ELU → AvgPool → Dropout**.
-
-    The output shape is ``(B, F2, T_c, 1)`` with ``F2 = F1·D`` and ``T_c = T/(P1·P2)``.
-    Temporal kernels behave as FIR filters; the depthwise-spatial conv yields frequency-specific
-    topographies. Pooling acts as a local integrator, reducing variance and imposing a
-    useful inductive bias on short EEG windows.
-
-    - **Sliding-Window Sequencer**
-
-      From the condensed time axis (length ``T_c``), ATCNet forms ``n`` overlapping windows
-      of width ``T_w = T_c - n + 1`` (one start per index). Each window produces a sequence
-      ``(B, F2, T_w)`` forwarded to its own attention–TCN branch. This creates *parallel*
-      encoders over shifted contexts and is key to robustness on nonstationary EEG.
-
-    - :class:`_AttentionBlock` **(small MHA on temporal positions)**
-
-        - *Operations.*
-        - Rearrange to ``(B, T_w, F2)``,
-        - Normalization :class:`torch.nn.LayerNorm`
-        - Custom MultiHeadAttention :class:`_MHA` (``num_heads=H``, per-head dim ``d_h``) + residual add,
-        - Dropout :class:`torch.nn.Dropout`
-        - Rearrange back to ``(B, F2, T_w)``.
-
-
-    **Note**: Attention is *local to a window* and purely temporal.
-
-    *Role.* Re-weights evidence across the window, letting the model emphasize informative
-    segments (onsets, bursts) before causal convolutions aggregate history.
-
-    - :class:`_TCNResidualBlock` **(causal dilated temporal CNN)**
-
-        - *Operations.*
-        - Two :class:`braindecode.modules.CausalConv1d` layers per block with dilation  ``1, 2, 4, …``
-        - Across blocks of `torch.nn.ELU` + `torch.nn.BatchNorm1d` + `torch.nn.Dropout`) +
-          a residual (identity or 1x1 mapping).
-        - The final feature used per window is the *last* causal step ``[..., -1]`` (forecast-style).
-
-    *Role.* Efficient long-range temporal integration with stable gradients; the dilated
-    receptive field complements attention’s soft selection.
-
-    - **Aggregation & Classifier**
-
-        - *Operations.*
-        - Either (a) map each window feature ``(B, F2)`` to logits via :class:`braindecode.modules.MaxNormLinear`
-        and **average** across windows (default, matching official code), or
-        - (b) **concatenate** all window features ``(B, n·F2)`` and apply a single :class:`MaxNormLinear`.
-        The max-norm constraint regularizes the readout.
-
-    .. rubric:: Convolutional Details
-
-    - **Temporal.** Temporal structure is learned in three places:
-        - (1) the stem’s wide ``(L_t, 1)`` conv (learned filter bank),
-        - (2) the refining ``(L_r, 1)`` conv after pooling (short-term dynamics), and
-        - (3) the TCN’s causal 1-D convolutions with exponentially increasing dilation
-          (long-range dependencies). The minimum sequence length required by the TCN stack is
-          ``(K_t - 1)·2^{L-1} + 1``; the implementation *auto-scales* kernels/pools/windows
-          when inputs are shorter to preserve feasibility.
-
-    - **Spatial.** A depthwise spatial conv spans the **full montage** (kernel ``(1, n_chans)``),
-        producing *per-temporal-filter* spatial projections (no cross-filter mixing at this step).
-        This mirrors EEGNet’s interpretability: each temporal filter has its own spatial pattern.
-
-
-    .. rubric:: Attention / Sequential Modules
-
-    - **Type.** Multi-head self-attention with ``H`` heads and per-head dim ``d_h`` implemented
-      in :class:`_MHA`, allowing ``embed_dim = H·d_h`` independent of input and output dims.
-    - **Shapes.** ``(B, F2, T_w) → (B, T_w, F2) → (B, F2, T_w)``. Attention operates along
-      the **temporal** axis within a window; channels/features stay in the embedding dim ``F2``.
-    - **Role.** Highlights salient temporal positions prior to causal convolution; small attention
-      keeps compute modest while improving context modeling over pooled features.
-
-    .. rubric:: Additional Mechanisms
-
-    - **Parallel encoders over shifted windows.** Improves montage/phase robustness by
-      ensembling nearby contexts rather than committing to a single segmentation.
-    - **Max-norm classifier.** Enforces weight norm constraints at the readout, a common
-      stabilization trick in EEG decoding.
-    - **ViT vs. ATCNet (design choices).** Convolutional *nonlinear* projection rather than
-      linear patchification; attention followed by **TCN** (not MLP); *parallel* window
-      encoders rather than stacked encoders.
-
-    .. 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 `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).
-        - ``att_num_heads``, ``att_head_dim`` set attention capacity; keep ``H·d_h ≈ F2``.
-        - ``tcn_depth``, ``tcn_kernel_size`` govern receptive field; larger values demand
-        longer inputs (see minimum length above). The implementation warns and *rescales*
-        kernels/pools/windows if inputs are too short.
-        - **Aggregation choice.** ``concat=False`` (default, average of per-window logits) matches
-        the official code; ``concat=True`` mirrors the paper’s concatenation variant.
-
-
-    Notes
-    -----
-    - Inputs substantially shorter than the implied minimum length trigger **automatic
-      downscaling** of kernels, pools, windows, and TCN kernel size to maintain validity.
-    - The attention–TCN sequence operates **per window**; the last causal step is used as the
-      window feature, aligning the temporal semantics across windows.
-
-    .. versionadded:: 1.1
-
-        - More detailed documentation of the model.
-
+       :align: center
+       :alt: ATCNet Architecture
 
     Parameters
     ----------
@@ -226,13 +85,15 @@ class ATCNet(EEGModuleMixin, nn.Module):
         Maximum L2-norm constraint imposed on weights of the last
         fully-connected layer. Defaults to 0.25.
 
+
     References
     ----------
-    .. [1] H. Altaheri, G. Muhammad, M. Alsulaiman (2022).
-        *Physics-informed attention temporal convolutional network for EEG-based motor imagery classification.*
-        IEEE Transactions on Industrial Informatics. doi:10.1109/TII.2022.3197419.
-    .. [2] Official EEG-ATCNet implementation (TensorFlow):
-        https://github.com/Altaheri/EEG-ATCNet/blob/main/models.py
+    .. [1] H. Altaheri, G. Muhammad and M. Alsulaiman,
+        Physics-informed attention temporal convolutional network for EEG-based
+        motor imagery classification in IEEE Transactions on Industrial Informatics,
+        2022, doi: 10.1109/TII.2022.3197419.
+    .. [2] EEE-ATCNet implementation.
+       https://github.com/Altaheri/EEG-ATCNet/blob/main/models.py
     """
 
     def __init__(
@@ -695,8 +556,7 @@ class _TCNResidualBlock(nn.Module):
         # Reshape the input for the residual connection when necessary
         if in_channels != n_filters:
             self.reshaping_conv = nn.Conv1d(
-                in_channels=in_channels,
-                out_channels=n_filters,
+                n_filters,
                 kernel_size=1,
                 padding="same",
             )

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/models/eegconformer.py

@@ -12,126 +12,33 @@ from braindecode.modules import FeedForwardBlock, MultiHeadAttention
 
 
 class EEGConformer(EEGModuleMixin, nn.Module):
-    """EEG Conformer from Song et al. (2022) [song2022]_.
+    """EEG Conformer from Song et al. (2022) from [song2022]_.
 
-    :bdg-success:`Convolution` :bdg-info:`Small Attention`
-
-    .. figure:: https://raw.githubusercontent.com/eeyhsong/EEG-Conformer/refs/heads/main/visualization/Fig1.png
+     .. figure:: https://raw.githubusercontent.com/eeyhsong/EEG-Conformer/refs/heads/main/visualization/Fig1.png
         :align: center
         :alt: EEGConformer Architecture
-        :width: 600px
-
-
-    .. rubric:: Architectural Overview
-
-    EEG-Conformer is a *convolution-first* model augmented with a *lightweight transformer
-    encoder*. The end-to-end flow is:
-
-    - (i) :class:`_PatchEmbedding` converts the continuous EEG into a compact sequence of tokens via a :class:`ShallowFBCSPNet` temporal–spatial conv stem and temporal pooling;
-    - (ii) :class:`_TransformerEncoder applies small multi-head self-attention to integrate longer-range temporal context across tokens;
-    - (iii) :class:`_ClassificationHead` aggregates the sequence and performs a linear readout.
-        This preserves the strong inductive biases of shallow CNN filter banks while adding
-        just enough attention to capture dependencies beyond the pooling horizon [song2022]_.
-
-    .. rubric:: Macro Components
-
-    - :class:`_PatchEmbedding` **(Shallow conv stem → tokens)**
-
-    - *Operations.*
-        - A temporal convolution (`:class:`torch.nn.Conv2d`) ``(1 x L_t)`` forms a data-driven "filter bank";
-        - A spatial convolution (`:class:`torch.nn.Conv2d`) (n_chans x 1)`` projects across electrodes, collapsing the channel axis into a virtual channel.
-        - **Normalization function** `:class:torch.nn.BatchNorm`
-        - **Activation function** `:class:torch.nn.ELU`
-        - **Average Pooling** `:class:torch.nn.AvgPool` along time (kernel ``(1, P)`` with stride ``(1, S)``)
-        -  final ``1x1`` :class:`torch.nn.Linear` projection.
-
-    The result is rearranged to a token sequence ``(B, S_tokens, D)``, where ``D = n_filters_time``.
-
-    *Interpretability/robustness.* Temporal kernels can be inspected as FIR filters;
-    the spatial conv yields channel projections analogous to :class:`ShallowFBCSPNet`’s learned
-    spatial filters. Temporal pooling stabilizes statistics and reduces sequence length.
-
-    - :class:`_TransformerEncoder` **(context over temporal tokens)**
-
-    - *Operations.*
-        - A stack of ``att_depth`` encoder blocks. :class:`_TransformerEncoderBlock`
-        - Each block applies LayerNorm :class:`torch.nn.LayerNorm`
-        - Multi-Head Self-Attention (``att_heads``) with dropout + residual :class:`MultiHeadAttention` (:class:`torch.nn.Dropout`)
-        - LayerNorm :class:`torch.nn.LayerNorm`
-        - 2-layer feed-forward (≈4x expansion, :class:`torch.nn.GELU`) with dropout + residual.
-
-    Shapes remain ``(B, S_tokens, D)`` throughout.
 
-    *Role.* Small attention focuses on interactions among *temporal patches* (not channels),
-    extending effective receptive fields at modest cost.
+    Convolutional Transformer for EEG decoding.
 
-    - :class:`ClassificationHead` **(aggregation + readout)**
+    The paper and original code with more details about the methodological
+    choices are available at the [song2022]_ and [ConformerCode]_.
 
-    - *Operations*.
-        - Flatten, :class:`torch.nn.Flatten` the sequence ``(B, S_tokens·D)`` -
-        - MLP (:class:`torch.nn.Linear` → activation (default: :class:`torch.nn.ELU`) → :class:`torch.nn.Dropout` → :class:`torch.nn.Linear`)
-        - final Linear to classes.
+    This neural network architecture receives a traditional braindecode input.
+    The input shape should be three-dimensional matrix representing the EEG
+    signals.
 
-    With ``return_features=True``, features before the last Linear can be exported for
-    linear probing or downstream tasks.
+         `(batch_size, n_channels, n_timesteps)`.
 
-    .. rubric:: Convolutional Details
-
-    - **Temporal (where time-domain patterns are learned).**
-        The initial ``(1 x L_t)`` conv per channel acts as a *learned filter bank* for oscillatory
-        bands and transients. Subsequent **AvgPool** along time performs local integration,
-        converting activations into “patches” (tokens). Pool length/stride control the
-        token rate and set the lower bound on temporal context within each token.
-
-    - **Spatial (how electrodes are processed).**
-        A single conv with kernel ``(n_chans x 1)`` spans the full montage to learn spatial
-        projections for each temporal feature map, collapsing the channel axis into a
-        virtual channel before tokenization. This mirrors the shallow spatial step in
-        :class:`ShallowFBCSPNet` (temporal filters → spatial projection → temporal condensation).
-
-    - **Spectral (how frequency content is captured).**
-        No explicit Fourier/wavelet stage is used. Spectral selectivity emerges implicitly
-        from the learned temporal kernels; pooling further smooths high-frequency noise.
-        The effective spectral resolution is thus governed by ``L_t`` and the pooling
-        configuration.
-
-    .. rubric:: Attention / Sequential Modules
-
-    - **Type.** Standard multi-head self-attention (MHA) with ``att_heads`` heads over the token sequence.
-    - **Shapes.** Input/Output: ``(B, S_tokens, D)``; attention operates along the ``S_tokens`` axis.
-    - **Role.** Re-weights and integrates evidence across pooled windows, capturing dependencies
-      longer than any single token while leaving channel relationships to the convolutional stem.
-      The design is intentionally *small*—attention refines rather than replaces convolutional feature extraction.
-
-    .. rubric:: Additional Mechanisms
-
-    - **Parallel with ShallowFBCSPNet.** Both begin with a learned temporal filter bank,
-        spatial projection across electrodes, and early temporal condensation.
-        :class:`ShallowFBCSPNet` then computes band-power (via squaring/log-variance), whereas
-        EEG-Conformer applies BN/ELU and **continues with attention** over tokens to
-        refine temporal context before classification.
-
-    - **Tokenization knob.** ``pool_time_length`` and especially ``pool_time_stride`` set
-        the number of tokens ``S_tokens``. Smaller strides → more tokens and higher attention
-        capacity (but higher compute); larger strides → fewer tokens and stronger inductive bias.
-
-    - **Embedding dimension = filters.** ``n_filters_time`` serves double duty as both the
-        number of temporal filters in the stem and the transformer’s embedding size ``D``,
-        simplifying dimensional alignment.
-
-    .. rubric:: Usage and Configuration
-
-    - **Instantiation.** Choose ``n_filters_time`` (embedding size ``D``) and
-        ``filter_time_length`` to match the rhythms of interest. Tune
-        ``pool_time_length/stride`` to trade temporal resolution for sequence length.
-        Keep ``att_depth`` modest (e.g., 4–6) and set ``att_heads`` to divide ``D``.
-        ``final_fc_length="auto"`` infers the flattened size from PatchEmbedding.
+    The EEG Conformer architecture is composed of three modules:
+        - PatchEmbedding
+        - TransformerEncoder
+        - ClassificationHead
 
     Notes
     -----
     The authors recommend using data augmentation before using Conformer,
     e.g. segmentation and recombination,
-    Please refer to the original paper and code for more details [ConformerCode]_.
+    Please refer to the original paper and code for more details.
 
     The model was initially tuned on 4 seconds of 250 Hz data.
     Please adjust the scale of the temporal convolutional layer,
@@ -140,10 +47,7 @@ class EEGConformer(EEGModuleMixin, nn.Module):
     .. versionadded:: 0.8
 
     We aggregate the parameters based on the parts of the models, or
-    when the parameters were used first, e.g. ``n_filters_time``.
-
-    .. versionadded:: 1.1
-
+    when the parameters were used first, e.g. n_filters_time.
 
     Parameters
     ----------

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/models/eegnet.py

@@ -20,60 +20,13 @@ from braindecode.modules import (
 
 
 class EEGNetv4(EEGModuleMixin, nn.Sequential):
-    """EEGNet v4 model from Lawhern et al. (2018) [Lawhern2018]_.
-
-    :bdg-success:`Convolution` :bdg-secondary:`Depthwise–Separable`
+    """EEGNet v4 model from Lawhern et al. (2018) [EEGNet4]_.
 
     .. figure:: https://content.cld.iop.org/journals/1741-2552/15/5/056013/revision2/jneaace8cf01_hr.jpg
        :align: center
-       :alt: EEGNetv4 Architecture
-       :width: 600px
-
-    .. rubric:: Architectural Overview
-
-    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.
-
-    The architecture is deliberately small (temporal convolutional and spatial patterns) [Lawhern2018]_.
-
-    .. rubric:: Macro Components
-
-    - **Temporal convolution**
-      Temporal convolution applied per channel; learns ``F1`` kernels that act as data-driven band-pass filters.
-    - **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).**
-      Batch normalization → ELU → temporal pooling, with dropout.
-    - **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.**
-      Lightweight 1x1 conv or dense layer (often with max-norm constraint).
+       :alt: EEGNet4 Architecture
 
-    .. 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]_.
-
-    **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.
-
-    .. rubric:: Additional Comments
-
-    - **Filter-bank structure:** Parallel temporal kernels (``F1``) emulate classical filter banks; pairing them with frequency-specific spatial filters
-      yields features mappable to rhythms and topographies.
-    - **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.
+    See details in [EEGNet4]_.
 
     Parameters
     ----------
@@ -115,13 +68,10 @@ class EEGNetv4(EEGModuleMixin, nn.Sequential):
 
     References
     ----------
-    .. [Lawhern2018] Lawhern, V. J., Solon, A. J., Waytowich, N. R., Gordon, S. M.,
+    .. [EEGNet4] Lawhern, V. J., Solon, A. J., Waytowich, N. R., Gordon, S. M.,
         Hung, C. P., & Lance, B. J. (2018). EEGNet: a compact convolutional
         neural network for EEG-based brain–computer interfaces. Journal of
         neural engineering, 15(5), 056013.
-    .. [Chollet2017] Chollet, F., *Xception: Deep Learning with Depthwise Separable
-        Convolutions*, CVPR, 2017.
-
     """
 
     def __init__(

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/modules/attention.py

@@ -157,8 +157,7 @@ class FCA(nn.Module):
     ):
         super(FCA, self).__init__()
         mapper_y = [freq_idx]
-        if in_channels % len(mapper_y) != 0:
-            raise ValueError("in_channels must be divisible by number of DCT filters")
+        assert in_channels % len(mapper_y) == 0
 
         self.weight = nn.Parameter(
             self.get_dct_filter(seq_len, mapper_y, in_channels), requires_grad=False
@@ -296,8 +295,7 @@ class ECA(nn.Module):
     def __init__(self, in_channels: int, kernel_size: int):
         super(ECA, self).__init__()
         self.gap = nn.AdaptiveAvgPool2d(1)
-        if kernel_size % 2 != 1:
-            raise ValueError("kernel size must be odd for same padding")
+        assert kernel_size % 2 == 1, "kernel size must be odd for same padding"
         self.conv = nn.Conv1d(
             1, 1, kernel_size=kernel_size, padding=kernel_size // 2, bias=False
         )
@@ -532,8 +530,7 @@ class CBAM(nn.Module):
             nn.ReLU(),
             nn.Conv2d(in_channels // reduction_rate, in_channels, 1, bias=False),
         )
-        if kernel_size % 2 != 1:
-            raise ValueError("kernel size must be odd for same padding")
+        assert kernel_size % 2 == 1, "kernel size must be odd for same padding"
         self.conv = nn.Conv2d(2, 1, (1, kernel_size), padding=(0, kernel_size // 2))
 
     def forward(self, x):

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/modules/convolution.py

@@ -136,8 +136,7 @@ class CombinedConv(nn.Module):
         # Calculate bias terms
         if self.bias_time:
             time_bias = self.conv_time.bias
-            if time_bias is None:
-                raise RuntimeError("conv_time.bias is None despite bias_time=True")
+            assert time_bias is not None
             calculated_bias = (
                 self.conv_spat.weight.squeeze()
                 .sum(-1)
@@ -146,8 +145,7 @@ class CombinedConv(nn.Module):
             )
         if self.bias_spat:
             spat_bias = self.conv_spat.bias
-            if spat_bias is None:
-                raise RuntimeError("conv_spat.bias is None despite bias_spat=True")
+            assert spat_bias is not None
             if calculated_bias is None:
                 calculated_bias = spat_bias
             else:
@@ -192,12 +190,11 @@ class CausalConv1d(nn.Conv1d):
         dilation=1,
         **kwargs,
     ):
-        if "padding" in kwargs:
-            raise ValueError(
-                "The padding parameter is controlled internally by "
-                f"{type(self).__name__} class. You should not try to override this"
-                " parameter."
-            )
+        assert "padding" not in kwargs, (
+            "The padding parameter is controlled internally by "
+            f"{type(self).__name__} class. You should not try to override this"
+            " parameter."
+        )
 
         super().__init__(
             in_channels=in_channels,

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/modules/filter.py

@@ -452,14 +452,12 @@ class GeneralizedGaussianFilter(nn.Module):
         self.inverse_fourier = inverse_fourier
         self.affine_group_delay = affine_group_delay
         self.clamp_f_mean = clamp_f_mean
-        if out_channels % in_channels != 0:
-            raise ValueError("out_channels has to be multiple of in_channels")
-        if len(f_mean) * in_channels != out_channels:
-            raise ValueError("len(f_mean) * in_channels must equal out_channels")
-        if len(bandwidth) * in_channels != out_channels:
-            raise ValueError("len(bandwidth) * in_channels must equal out_channels")
-        if len(shape) * in_channels != out_channels:
-            raise ValueError("len(shape) * in_channels must equal out_channels")
+        assert out_channels % in_channels == 0, (
+            "out_channels has to be multiple of in_channels"
+        )
+        assert len(f_mean) * in_channels == out_channels
+        assert len(bandwidth) * in_channels == out_channels
+        assert len(shape) * in_channels == out_channels
 
         # Range from 0 to half sample rate, normalized
         self.n_range = nn.Parameter(

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/training/scoring.py

@@ -11,6 +11,7 @@ from contextlib import contextmanager
 
 import numpy as np
 import torch
+from mne.utils.check import check_version
 from skorch.callbacks.scoring import EpochScoring
 from skorch.dataset import unpack_data
 from skorch.utils import to_numpy
@@ -369,8 +370,13 @@ class PostEpochTrainScoring(EpochScoring):
             y_preds = []
             y_test = []
             for batch in iterator:
-                _, batch_y = unpack_data(batch)
-                yp = net.evaluation_step(batch, training=False)
+                batch_X, batch_y = unpack_data(batch)
+                # TODO: remove after skorch 0.10 release
+                if not check_version("skorch", min_version="0.10.1"):
+                    yp = net.evaluation_step(batch_X, training=False)
+                # X, y unpacking has been pushed downstream in skorch 0.10
+                else:
+                    yp = net.evaluation_step(batch, training=False)
                 yp = yp.to(device="cpu")
                 y_test.append(self.target_extractor(batch_y))
                 y_preds.append(yp)

braindecode-1.2.0.dev169062562/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "1.2.0.dev169062562"

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/braindecode/visualization/gradients.py

@@ -6,13 +6,8 @@ import numpy as np
 import torch
 from skorch.utils import to_numpy, to_tensor
 
-from braindecode.util import set_random_seeds
 
-
-def compute_amplitude_gradients(model, dataset, batch_size, seed=20240205):
-    """Compute amplitude gradients after seeding for reproducibility."""
-    cuda = next(model.parameters()).is_cuda
-    set_random_seeds(seed=seed, cuda=cuda)
+def compute_amplitude_gradients(model, dataset, batch_size):
     loader = torch.utils.data.DataLoader(
         dataset, batch_size=batch_size, drop_last=False, shuffle=False
     )

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562/braindecode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.2.0.dev168908090
+Version: 1.2.0.dev169062562
 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>

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/docs/conf.py

@@ -166,9 +166,6 @@ templates_path = ["_templates"]
 # source_suffix = ['.rst', '.md']
 source_suffix = ".rst"
 
-rst_prolog = """
-.. role:: tag(bdg-success)
-"""
 # The master toctree document.
 master_doc = "index"
 

{braindecode-1.2.0.dev168908090 → braindecode-1.2.0.dev169062562}/docs/whats_new.rst

@@ -22,13 +22,6 @@ Current 1.2 (dev)
 
 Enhancements
 ~~~~~~~~~~~~
-- Improving the docstring for :class:`braindecode.models.EEGNetv4`  (:gh:`768` by `Bruno Aristimunha`_)
-- Improving the docstring for :class:`braindecode.models.EEGConformer`  (:gh:`769` by `Bruno Aristimunha`_)
-- Improving the docstring for :class:`braindecode.models.ATCNet`  (:gh:`771` by `Bruno Aristimunha`_)
-
-
-API changes
-~~~~~~~~~~~
 
 Bugs
 ~~~~

braindecode-1.2.0.dev168908090/braindecode/version.py

@@ -1 +0,0 @@
-__version__ = "1.2.0.dev168908090"