braindecode 1.3.0.dev177069446__py3-none-any.whl → 1.3.0.dev177628147__py3-none-any.whl

braindecode/models/summary.csv

@@ -1,13 +1,13 @@
 Model,Application,Type,Sampling Frequency (Hz),Hyperparameters,#Parameters,get_#Parameters,Categorization
-ATCNet,General,Classification,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Recurrent,Attention/Transformer"
-AttentionBaseNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",3692,"AttentionBaseNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer"
+ATCNet,General,Classification,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Recurrent,Small Attention"
+AttentionBaseNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",3692,"AttentionBaseNet(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
 BDTCN,Normal Abnormal,Classification,100,"n_chans, n_outputs, n_times",456502,"BDTCN(n_chans=21, n_outputs=2, n_times=6000, n_blocks=5, n_filters=55, kernel_size=16)","Convolution,Recurrent"
-BIOT,"Sleep Staging, Epilepsy",Classification,200,"n_chans, n_outputs",3183879,"BIOT(n_chans=2,  n_outputs=5,  n_times=6000)","Foundation Model"
+BIOT,"Sleep Staging, Epilepsy",Classification,200,"n_chans, n_outputs",3183879,"BIOT(n_chans=2,  n_outputs=5,  n_times=6000)","Large Brain Model"
 ContraWR,Sleep Staging,"Classification, Embedding",125,"n_chans, n_outputs, sfreq",1160165,"ContraWR(n_chans=2, n_outputs=5, n_times=3750, emb_size=256, sfreq=125)",Convolution
-CTNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",26900,"CTNet(n_chans=22, n_outputs=4, n_times=1000, n_filters_time=8, kernel_size=16, num_heads=2, embed_dim=16)","Convolution,Attention/Transformer"
+CTNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",26900,"CTNet(n_chans=22, n_outputs=4, n_times=1000, n_filters_time=8, kernel_size=16, heads=2, emb_size=16)","Convolution,Small Attention"
 Deep4Net,General,Classification,250,"n_chans, n_outputs, n_times",282879,"Deep4Net(n_chans=22, n_outputs=4, n_times=1000)","Convolution"
 DeepSleepNet,Sleep Staging,Classification,256,"n_chans, n_outputs",24744837,"DeepSleepNet(n_chans=1, n_outputs=5, n_times=7680, sfreq=256)","Convolution,Recurrent"
-EEGConformer,General,Classification,250,"n_chans, n_outputs, n_times",789572,"EEGConformer(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer"
+EEGConformer,General,Classification,250,"n_chans, n_outputs, n_times",789572,"EEGConformer(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
 EEGInceptionERP,"ERP, SSVEP",Classification,128,"n_chans, n_outputs",14926,"EEGInceptionERP(n_chans=8, n_outputs=2, n_times=128, sfreq=128)","Convolution"
 EEGInceptionMI,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",558028,"EEGInceptionMI(n_chans=22, n_outputs=4, n_times=1000, n_convs=5, n_filters=12)","Convolution"
 EEGITNet,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times",5212,"EEGITNet(n_chans=22,  n_outputs=4,  n_times=500)","Convolution,Recurrent"
@@ -17,18 +17,18 @@ EEGSym,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",299
 EEGMiner,Emotion Recognition,Classification,128,"n_chans, n_outputs, n_times, sfreq",7572,"EEGMiner(n_chans=62, n_outputs=2, n_times=2560, sfreq=128)","Convolution,Interpretability"
 EEGSimpleConv,Motor Imagery,Classification,80,"n_chans, n_outputs, sfreq",730404,"EEGSimpleConv(n_chans=22,  n_outputs=4,  n_times=320, sfreq=80)","Convolution"
 EEGTCNet,Motor Imagery,Classification,250,"n_chans, n_outputs",4516,"EEGTCNet(n_chans=22,  n_outputs=4,  n_times=1000, kern_length=32)","Convolution,Recurrent"
-Labram,General,"Classification, Embedding",200,"n_chans, n_outputs, n_times",5866180,"Labram(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Foundation Model"
-MSVTNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",75494," MSVTNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution,Recurrent,Attention/Transformer"
+Labram,General,"Classification, Embedding",200,"n_chans, n_outputs, n_times",5866180,"Labram(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Large Brain Model"
+MSVTNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",75494," MSVTNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution,Recurrent,Small Attention"
 SCCNet,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times, sfreq",12070,"SCCNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=125)","Convolution"
-SignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"n_times, chs_info",3456882,"SignalJEPA(n_times=512, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Foundation Model"
-SignalJEPA_Contextual,"Motor Imagery, ERP, SSVEP",Classification,128,"n_outputs, n_times, chs_info",3459184,"SignalJEPA_Contextual(n_outputs=2, input_window_seconds=4.19, sfreq=128, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Foundation Model"
-SignalJEPA_PostLocal,"Motor Imagery, ERP, SSVEP",Classification,128,"n_chans, n_outputs, n_times",16142,"SignalJEPA_PostLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Foundation Model"
-SignalJEPA_PreLocal,"Motor Imagery, ERP, SSVEP",Classification,128,"n_outputs, n_times, chs_info",16142,"SignalJEPA_PreLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Foundation Model"
+SignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"n_times, chs_info",3456882,"SignalJEPA(n_times=512, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Large Brain Model"
+SignalJEPA_Contextual,"Motor Imagery, ERP, SSVEP",Classification,128,"n_outputs, n_times, chs_info",3459184,"SignalJEPA_Contextual(n_outputs=2, input_window_seconds=4.19, sfreq=128, chs_info=Lee2019_MI().get_data(subjects=[1])[1]['0']['1train'].info[""chs""][:62])","Convolution,Channel,Large Brain Model"
+SignalJEPA_PostLocal,"Motor Imagery, ERP, SSVEP",Classification,128,"n_chans, n_outputs, n_times",16142,"SignalJEPA_PostLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Large Brain Model"
+SignalJEPA_PreLocal,"Motor Imagery, ERP, SSVEP",Classification,128,"n_outputs, n_times, chs_info",16142,"SignalJEPA_PreLocal(n_chans=62, n_outputs=2, input_window_seconds=4.19, sfreq=128)","Convolution,Channel,Large Brain Model"
 SincShallowNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",21892,"SincShallowNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution,Interpretability"
 ShallowFBCSPNet,General,Classification,250,"n_chans, n_outputs, n_times",46084,"ShallowFBCSPNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution"
 SleepStagerBlanco2020,Sleep Staging,Classification,100,"n_chans, n_outputs, n_times",2845,"SleepStagerBlanco2020(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution"
 SleepStagerChambon2018,Sleep Staging,Classification,128,"n_chans, n_outputs, n_times, sfreq",5835,"SleepStagerChambon2018(n_chans=2, n_outputs=5, n_times=3840, sfreq=128)","Convolution"
-AttnSleep,Sleep Staging,Classification,100,"n_chans, n_outputs, n_times, sfreq",719925,"AttnSleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Attention/Transformer"
+AttnSleep,Sleep Staging,Classification,100,"n_chans, n_outputs, n_times, sfreq",719925,"AttnSleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Small Attention"
 SPARCNet,Epilepsy,Classification,200,"n_chans, n_outputs, n_times",1141921,"SPARCNet(n_chans=16, n_outputs=6, n_times=2000, sfreq=200)","Convolution"
 SyncNet,"Emotion Recognition, Alcoholism",Classification,256,"n_chans, n_outputs, n_times",554,"SyncNet(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Interpretability"
 TSception,Emotion Recognition,Classification,256,"n_chans, n_outputs, n_times, sfreq",2187206,"TSception(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Convolution"
@@ -38,10 +38,8 @@ FBCNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",118
 FBMSNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",16231,"FBMSNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
 FBLightConvNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",6596,"FBLightConvNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
 IFNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",9860,"IFNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
-BrainModule,Speech Decoding,Classification,250,"n_chans, n_outputs, n_times, sfreq",6186909,"BrainModule(n_chans=64, n_outputs=29, n_times=160, sfreq=1000)","Convolution"
-PBT,General,Classification,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Foundation Model"
-SSTDPN,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",19502,"SSTDPN(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Attention/Transformer"
-BENDR,General,"Classification,Embedding",250,"n_chans, n_times, n_outputs",157141049,"BENDR(n_chans=22, n_outputs=4, n_times=1000)","Foundation Model,Convolution"
-LUNA,General,"Classification,Embedding",128,"n_chans, n_times, sfreq, chs_info",7100731,"LUNA(n_chans=22, n_times=512, sfreq=128)","Convolution,Channel,Foundation Model"
-MEDFormer,General,Classification,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Foundation Model,Convolution"
-REVE,General,Classification,200,"n_outputs, n_times, n_chans",69481476,"REVE(n_times=1000, n_outputs=4, n_chans=19)","Foundation Model,Attention/Transformer"
+PBT,General,Classification,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Large Brain Model"
+SSTDPN,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",19502,"SSTDPN(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
+BENDR,General,"Classification,Embedding",250,"n_chans, n_times, n_outputs",157141049,"BENDR(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"
+LUNA,General,"Classification,Embedding",128,"n_chans, n_times, sfreq, chs_info",7100731,"LUNA(n_chans=22, n_times=512, sfreq=128)","Convolution,Channel,Large Brain Model"
+MEDFormer,General,Classification,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"

braindecode/models/syncnet.py

@@ -8,7 +8,7 @@ from braindecode.models.base import EEGModuleMixin
 
 
 class SyncNet(EEGModuleMixin, nn.Module):
-    r"""Synchronization Network (SyncNet) from Li, Y et al (2017) [Li2017]_.
+    """Synchronization Network (SyncNet) from Li, Y et al (2017) [Li2017]_.
 
     :bdg-warning:`Interpretability`
 
@@ -89,7 +89,7 @@ class SyncNet(EEGModuleMixin, nn.Module):
         num_filters=1,
         filter_width=40,
         pool_size=40,
-        activation: type[nn.Module] = nn.ReLU,
+        activation: nn.Module = nn.ReLU,
         ampli_init_values: tuple[float, float] = (-0.05, 0.05),
         omega_init_values: tuple[float, float] = (0.0, 1.0),
         beta_init_values: tuple[float, float] = (0.0, 0.05),

braindecode/models/tcn.py

@@ -12,7 +12,7 @@ from braindecode.modules import Chomp1d, Ensure4d, SqueezeFinalOutput
 
 
 class BDTCN(EEGModuleMixin, nn.Module):
-    r"""Braindecode TCN from Gemein, L et al (2020) [gemein2020]_.
+    """Braindecode TCN from Gemein, L et al (2020) [gemein2020]_.
 
     :bdg-success:`Convolution` :bdg-secondary:`Recurrent`
 
@@ -57,7 +57,7 @@ class BDTCN(EEGModuleMixin, nn.Module):
         n_filters=30,
         kernel_size=5,
         drop_prob=0.5,
-        activation: type[nn.Module] = nn.ReLU,
+        activation: nn.Module = nn.ReLU,
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -90,7 +90,7 @@ class BDTCN(EEGModuleMixin, nn.Module):
 
 
 class TCN(nn.Module):
-    r"""Temporal Convolutional Network (TCN) from Bai et al. 2018 [Bai2018]_.
+    """Temporal Convolutional Network (TCN) from Bai et al. 2018 [Bai2018]_.
 
     See [Bai2018]_ for details.
 
@@ -126,7 +126,7 @@ class TCN(nn.Module):
         n_filters=30,
         kernel_size=5,
         drop_prob=0.5,
-        activation: type[nn.Module] = nn.ReLU,
+        activation: nn.Module = nn.ReLU,
     ):
         super().__init__()
         self.mapping = {
@@ -221,7 +221,7 @@ class _TemporalBlock(nn.Module):
         dilation,
         padding,
         drop_prob,
-        activation: type[nn.Module] = nn.ReLU,
+        activation: nn.Module = nn.ReLU,
     ):
         super().__init__()
         self.conv1 = weight_norm(

braindecode/models/tidnet.py

@@ -11,7 +11,7 @@ from braindecode.modules import Ensure4d
 
 
 class TIDNet(EEGModuleMixin, nn.Module):
-    r"""Thinker Invariance DenseNet model from Kostas et al (2020) [TIDNet]_.
+    """Thinker Invariance DenseNet model from Kostas et al. (2020) [TIDNet]_.
 
     :bdg-success:`Convolution`
 
@@ -85,7 +85,7 @@ class TIDNet(EEGModuleMixin, nn.Module):
         temp_span: float = 0.05,
         bottleneck: int = 3,
         summary: int = -1,
-        activation: type[nn.Module] = nn.LeakyReLU,
+        activation: nn.Module = nn.LeakyReLU,
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -157,7 +157,7 @@ class _BatchNormZG(nn.BatchNorm2d):
 
 
 class _ConvBlock2D(nn.Module):
-    r"""Implements Convolution block with order:
+    """Implements Convolution block with order:
     Convolution, dropout, activation, batch-norm
     """
 

braindecode/models/tsinception.py

@@ -13,7 +13,7 @@ from braindecode.models.base import EEGModuleMixin
 
 
 class TSception(EEGModuleMixin, nn.Module):
-    r"""TSception model from Ding et al. (2020) from [ding2020]_.
+    """TSception model from Ding et al. (2020) from [ding2020]_.
 
     :bdg-success:`Convolution`
 
@@ -78,7 +78,7 @@ class TSception(EEGModuleMixin, nn.Module):
         number_filter_spat: int = 6,
         hidden_size: int = 128,
         drop_prob: float = 0.5,
-        activation: type[nn.Module] = nn.LeakyReLU,
+        activation: nn.Module = nn.LeakyReLU,
         pool_size: int = 8,
         inception_windows: tuple[float, float, float] = (0.5, 0.25, 0.125),
     ):
@@ -290,6 +290,6 @@ class TSception(EEGModuleMixin, nn.Module):
     "this alias will be removed in v1.14."
 )
 class TSceptionV1(TSception):
-    r"""Deprecated alias for TSception."""
+    """Deprecated alias for TSception."""
 
     pass

braindecode/models/usleep.py

@@ -12,8 +12,8 @@ from braindecode.models.base import EEGModuleMixin
 
 
 class USleep(EEGModuleMixin, nn.Module):
-    r"""
-    Sleep staging architecture from Perslev et al (2021) [1]_.
+    """
+    Sleep staging architecture from Perslev et al. (2021) [1]_.
 
     :bdg-success:`Convolution`
 
@@ -182,7 +182,7 @@ class USleep(EEGModuleMixin, nn.Module):
         input_window_seconds=None,
         time_conv_size_s=9 / 128,
         ensure_odd_conv_size=False,
-        activation: type[nn.Module] = nn.ELU,
+        activation: nn.Module = nn.ELU,
         chs_info=None,
         n_times=None,
     ):
@@ -331,7 +331,7 @@ class USleep(EEGModuleMixin, nn.Module):
 
 
 class _EncoderBlock(nn.Module):
-    r"""Encoding block for a timeseries x of shape (B, C, T)."""
+    """Encoding block for a timeseries x of shape (B, C, T)."""
 
     def __init__(
         self,
@@ -339,7 +339,7 @@ class _EncoderBlock(nn.Module):
         out_channels=2,
         kernel_size=9,
         downsample=2,
-        activation: type[nn.Module] = nn.ELU,
+        activation: nn.Module = nn.ELU,
     ):
         super().__init__()
         self.in_channels = in_channels
@@ -371,7 +371,7 @@ class _EncoderBlock(nn.Module):
 
 
 class _DecoderBlock(nn.Module):
-    r"""Decoding block for a timeseries x of shape (B, C, T)."""
+    """Decoding block for a timeseries x of shape (B, C, T)."""
 
     def __init__(
         self,
@@ -380,7 +380,7 @@ class _DecoderBlock(nn.Module):
         kernel_size=9,
         upsample=2,
         with_skip_connection=True,
-        activation: type[nn.Module] = nn.ELU,
+        activation: nn.Module = nn.ELU,
     ):
         super().__init__()
         self.in_channels = in_channels

braindecode/models/util.py

@@ -3,9 +3,8 @@
 #
 # License: BSD (3-clause)
 import inspect
-from copy import deepcopy
 from pathlib import Path
-from typing import Any, Dict, Literal, Optional, Sequence
+from typing import Any, Dict, Optional, Sequence
 
 import numpy as np
 import pandas as pd
@@ -30,16 +29,6 @@ def _init_models_dict():
             models_dict[m[0]] = m[1]
 
 
-SigArgName = Literal[
-    "n_outputs",
-    "n_chans",
-    "chs_info",
-    "n_times",
-    "input_window_seconds",
-    "sfreq",
-]
-
-
 ################################################################
 # Test cases for models
 #
@@ -61,9 +50,7 @@ SigArgName = Literal[
 #   The keys of this dictionary can only be among those of
 #   default_signal_params.
 ################################################################
-models_mandatory_parameters: list[
-    tuple[str, list[SigArgName], dict[SigArgName, Any] | None]
-] = [
+models_mandatory_parameters = [
     ("ATCNet", ["n_chans", "n_outputs", "n_times"], None),
     ("BDTCN", ["n_chans", "n_outputs"], None),
     ("Deep4Net", ["n_chans", "n_outputs", "n_times"], None),
@@ -77,60 +64,45 @@ models_mandatory_parameters: list[
     (
         "SleepStagerBlanco2020",
         ["n_chans", "n_outputs", "n_times"],
-        {"n_chans": 4},  # n_chans dividable by n_groups=2
+        dict(n_chans=4),  # n_chans dividable by n_groups=2
     ),
     ("SleepStagerChambon2018", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     (
         "AttnSleep",
         ["n_outputs", "n_times", "sfreq"],
-        {
-            "sfreq": 100.0,
-            "n_times": 3000,
-            "chs_info": [{"ch_name": "C1", "kind": "eeg"}],
-        },
+        dict(sfreq=100.0, n_times=3000, chs_info=[dict(ch_name="C1", kind="eeg")]),
     ),  # 1 channel
     ("TIDNet", ["n_chans", "n_outputs", "n_times"], None),
-    ("USleep", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 128.0}),
+    ("USleep", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=128.0)),
     ("BIOT", ["n_chans", "n_outputs", "sfreq", "n_times"], None),
     ("AttentionBaseNet", ["n_chans", "n_outputs", "n_times"], None),
     ("Labram", ["n_chans", "n_outputs", "n_times"], None),
     ("EEGSimpleConv", ["n_chans", "n_outputs", "sfreq"], None),
     ("SPARCNet", ["n_chans", "n_outputs", "n_times"], None),
-    ("ContraWR", ["n_chans", "n_outputs", "sfreq", "n_times"], {"sfreq": 200.0}),
+    ("ContraWR", ["n_chans", "n_outputs", "sfreq", "n_times"], dict(sfreq=200.0)),
     ("EEGNeX", ["n_chans", "n_outputs", "n_times"], None),
     ("EEGSym", ["chs_info", "n_chans", "n_outputs", "n_times", "sfreq"], None),
-    ("TSception", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
+    ("TSception", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("EEGTCNet", ["n_chans", "n_outputs", "n_times"], None),
     ("SyncNet", ["n_chans", "n_outputs", "n_times"], None),
     ("MSVTNet", ["n_chans", "n_outputs", "n_times"], None),
-    ("EEGMiner", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
+    ("EEGMiner", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("CTNet", ["n_chans", "n_outputs", "n_times"], None),
-    ("SincShallowNet", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 250.0}),
-    ("SCCNet", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
+    ("SincShallowNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=250.0)),
+    ("SCCNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("SignalJEPA", ["chs_info"], None),
     ("SignalJEPA_Contextual", ["chs_info", "n_times", "n_outputs"], None),
     ("SignalJEPA_PostLocal", ["n_chans", "n_times", "n_outputs"], None),
     ("SignalJEPA_PreLocal", ["n_chans", "n_times", "n_outputs"], None),
-    ("FBCNet", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
-    ("FBMSNet", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
-    ("FBLightConvNet", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
-    ("IFNet", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
+    ("FBCNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
+    ("FBMSNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
+    ("FBLightConvNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
+    ("IFNet", ["n_chans", "n_outputs", "n_times", "sfreq"], dict(sfreq=200.0)),
     ("PBT", ["n_chans", "n_outputs", "n_times"], None),
     ("SSTDPN", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
-    ("BrainModule", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     ("BENDR", ["n_chans", "n_outputs", "n_times"], None),
     ("LUNA", ["n_chans", "n_times", "n_outputs"], None),
     ("MEDFormer", ["n_chans", "n_outputs", "n_times"], None),
-    (
-        "REVE",
-        ["n_times", "n_outputs", "n_chans", "chs_info"],
-        {
-            "sfreq": 200.0,
-            "n_chans": 19,
-            "n_times": 1_000,
-            "chs_info": [{"ch_name": f"E{i + 1}", "kind": "eeg"} for i in range(19)],
-        },
-    ),
 ]
 
 ################################################################
@@ -143,129 +115,6 @@ non_classification_models = [
     "SignalJEPA",
 ]
 
-################################################################
-
-rng = np.random.default_rng(12)
-# Generating the channel info
-chs_info = [
-    {
-        "ch_name": f"C{i}",
-        "kind": "eeg",
-        "loc": rng.random(12),
-    }
-    for i in range(1, 4)
-]
-default_signal_params: dict[SigArgName, Any] = {
-    "n_times": 1000,
-    "sfreq": 250.0,
-    "n_outputs": 2,
-    "chs_info": chs_info,
-    "n_chans": len(chs_info),
-    "input_window_seconds": 4.0,
-}
-
-
-def _get_signal_params(
-    signal_params: dict[SigArgName, Any] | None,
-    required_params: list[SigArgName] | None = None,
-) -> dict[SigArgName, Any]:
-    """Get signal parameters for model initialization in tests."""
-    sp = deepcopy(default_signal_params)
-    if signal_params is not None:
-        sp.update(signal_params)
-        if "chs_info" in signal_params and "n_chans" not in signal_params:
-            sp["n_chans"] = len(signal_params["chs_info"])
-        if "n_chans" in signal_params and "chs_info" not in signal_params:
-            sp["chs_info"] = [
-                {"ch_name": f"C{i}", "kind": "eeg", "loc": rng.random(12)}
-                for i in range(signal_params["n_chans"])
-            ]
-        assert isinstance(sp["n_times"], int)
-        assert isinstance(sp["sfreq"], float)
-        assert isinstance(sp["input_window_seconds"], float)
-        if "input_window_seconds" not in signal_params:
-            sp["input_window_seconds"] = sp["n_times"] / sp["sfreq"]
-        if "sfreq" not in signal_params:
-            sp["sfreq"] = sp["n_times"] / sp["input_window_seconds"]
-        if "n_times" not in signal_params:
-            sp["n_times"] = int(sp["input_window_seconds"] * sp["sfreq"])
-    if required_params is not None:
-        sp = {
-            k: sp[k] for k in set((signal_params or {}).keys()).union(required_params)
-        }
-    return sp
-
-
-def _get_possible_signal_params(
-    signal_params: dict[SigArgName, Any], required_params: list[SigArgName]
-):
-    sp = signal_params
-
-    # List possible model kwargs:
-    output_kwargs = []
-    output_kwargs.append(dict(n_outputs=sp["n_outputs"]))
-
-    if "n_outputs" not in required_params:
-        output_kwargs.append(dict(n_outputs=None))
-
-    channel_kwargs = []
-    channel_kwargs.append(dict(chs_info=sp["chs_info"], n_chans=None))
-    if "chs_info" not in required_params:
-        channel_kwargs.append(dict(n_chans=sp["n_chans"], chs_info=None))
-    if "n_chans" not in required_params and "chs_info" not in required_params:
-        channel_kwargs.append(dict(n_chans=None, chs_info=None))
-
-    time_kwargs = []
-    time_kwargs.append(
-        dict(n_times=sp["n_times"], sfreq=sp["sfreq"], input_window_seconds=None)
-    )
-    time_kwargs.append(
-        dict(
-            n_times=None,
-            sfreq=sp["sfreq"],
-            input_window_seconds=sp["input_window_seconds"],
-        )
-    )
-    time_kwargs.append(
-        dict(
-            n_times=sp["n_times"],
-            sfreq=None,
-            input_window_seconds=sp["input_window_seconds"],
-        )
-    )
-    if "n_times" not in required_params and "sfreq" not in required_params:
-        time_kwargs.append(
-            dict(
-                n_times=None,
-                sfreq=None,
-                input_window_seconds=sp["input_window_seconds"],
-            )
-        )
-    if (
-        "n_times" not in required_params
-        and "input_window_seconds" not in required_params
-    ):
-        time_kwargs.append(
-            dict(n_times=None, sfreq=sp["sfreq"], input_window_seconds=None)
-        )
-    if "sfreq" not in required_params and "input_window_seconds" not in required_params:
-        time_kwargs.append(
-            dict(n_times=sp["n_times"], sfreq=None, input_window_seconds=None)
-        )
-    if (
-        "n_times" not in required_params
-        and "sfreq" not in required_params
-        and "input_window_seconds" not in required_params
-    ):
-        time_kwargs.append(dict(n_times=None, sfreq=None, input_window_seconds=None))
-
-    return [
-        dict(**o, **c, **t)
-        for o in output_kwargs
-        for c in channel_kwargs
-        for t in time_kwargs
-    ]
-
 
 ################################################################
 def get_summary_table(dir_name=None):

braindecode/modules/__init__.py

@@ -22,14 +22,7 @@ from .convolution import (
     DepthwiseConv2d,
 )
 from .filter import FilterBankLayer, GeneralizedGaussianFilter
-from .layers import (
-    Chomp1d,
-    DropPath,
-    Ensure4d,
-    SqueezeFinalOutput,
-    SubjectLayers,
-    TimeDistributed,
-)
+from .layers import Chomp1d, DropPath, Ensure4d, SqueezeFinalOutput, TimeDistributed
 from .linear import LinearWithConstraint, MaxNormLinear
 from .parametrization import MaxNorm, MaxNormParametrize
 from .stats import (
@@ -72,7 +65,6 @@ __all__ = [
     "Chomp1d",
     "DropPath",
     "Ensure4d",
-    "SubjectLayers",
     "SqueezeFinalOutput",
     "TimeDistributed",
     "LinearWithConstraint",

braindecode/modules/activation.py

@@ -8,24 +8,14 @@ class SafeLog(nn.Module):
     r"""
     Safe logarithm activation function module.
 
-    :math:`\text{SafeLog}(x) = \log\left(\max(x, \epsilon)\right)`
+    :math:\text{SafeLog}(x) = \log\left(\max(x, \epsilon)\right)
 
     Parameters
     ----------
-    epsilon : float, optional
+    eps : float, optional
         A small value to clamp the input tensor to prevent computing log(0) or log of negative numbers.
         Default is 1e-6.
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import SafeLog
-    >>> module = SafeLog(epsilon=1e-6)
-    >>> inputs = torch.rand(2, 3)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 3])
-
     """
 
     def __init__(self, epsilon: float = 1e-6):
@@ -54,23 +44,7 @@ class SafeLog(nn.Module):
 
 
 class LogActivation(nn.Module):
-    """Logarithm activation function.
-
-    Parameters
-    ----------
-    epsilon : float, default=1e-6
-        Small float to adjust the activation.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import LogActivation
-    >>> module = LogActivation(epsilon=1e-6)
-    >>> inputs = torch.rand(2, 3)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 3])
-    """
+    """Logarithm activation function."""
 
     def __init__(self, epsilon: float = 1e-6, *args, **kwargs):
         """