braindecode.models.EEGNet#

class braindecode.models.EEGNet(n_chans=None, n_outputs=None, n_times=None, final_conv_length='auto', pool_mode='mean', F1=8, D=2, F2=None, kernel_length=64, *, depthwise_kernel_length=16, pool1_kernel_size=4, pool2_kernel_size=8, conv_spatial_max_norm=1, activation=<class 'torch.nn.modules.activation.ELU'>, batch_norm_momentum=0.01, batch_norm_affine=True, batch_norm_eps=0.001, drop_prob=0.25, final_layer_with_constraint=False, norm_rate=0.25, chs_info=None, input_window_seconds=None, sfreq=None, **kwargs)[source]#

EEGNet model from Lawhern et al. (2018) [Lawhern2018].

Convolution

EEGNet Architecture

Architectural Overview

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.

The architecture is deliberately small (temporal convolutional and spatial patterns) [Lawhern2018].

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).

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.

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.

  • The v4 means the version 4 at the arxiv paper [Lawhern2018].

Parameters:

  • n_chans (int) – Number of EEG channels.

  • n_outputs (int) – Number of outputs of the model. This is the number of classes in the case of classification.

  • n_times (int) – Number of time samples of the input window.

  • final_conv_length (int or "auto", default="auto") – Length of the final convolution layer. If “auto”, it is set based on n_times.

  • pool_mode ({"mean", "max"}, default="mean") – Pooling method to use in pooling layers.

  • F1 (int, default=8) – Number of temporal filters in the first convolutional layer.

  • D (int, default=2) – Depth multiplier for the depthwise convolution.

  • F2 (int or None, default=None) – Number of pointwise filters in the separable convolution. Usually set to F1 * D.

  • kernel_length (int, default=64) – Length of the temporal convolution kernel.

  • depthwise_kernel_length (int, default=16) – Length of the depthwise convolution kernel in the separable convolution.

  • pool1_kernel_size (int, default=4) – Kernel size of the first pooling layer.

  • pool2_kernel_size (int, default=8) – Kernel size of the second pooling layer.

  • conv_spatial_max_norm (float, default=1) – Maximum norm constraint for the spatial (depthwise) convolution.

  • activation (nn.Module, default=nn.ELU) – Non-linear activation function to be used in the layers.

  • batch_norm_momentum (float, default=0.01) – Momentum for instance normalization in batch norm layers.

  • batch_norm_affine (bool, default=True) – If True, batch norm has learnable affine parameters.

  • batch_norm_eps (float, default=1e-3) – Epsilon for numeric stability in batch norm layers.

  • drop_prob (float, default=0.25) – Dropout probability.

  • final_layer_with_constraint (bool, default=False) – If False, uses a convolution-based classification layer. If True, apply a flattened linear layer with constraint on the weights norm as the final classification step.

  • norm_rate (float, default=0.25) – Max-norm constraint value for the linear layer (used if final_layer_conv=False).

  • chs_info (list of dict) – Information about each individual EEG channel. This should be filled with info["chs"]. Refer to mne.Info for more details.

  • input_window_seconds (float) – Length of the input window in seconds.

  • sfreq (float) – Sampling frequency of the EEG recordings.

  • **kwargs – The description is missing.

Raises:

ValueError – If some input signal-related parameters are not specified: and can not be inferred.

Notes

If some input signal-related parameters are not specified, there will be an attempt to infer them from the other parameters.

References

[Lawhern2018] (1,2,3,4)

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.

Examples using braindecode.models.EEGNet#

Cross-session motor imagery with deep learning EEGNet v4 model

Cross-session motor imagery with deep learning EEGNet v4 model