Braindecode 1.6.1.dev1014__tar.gz → 1.6.1.dev1037__tar.gz

{braindecode-1.6.1.dev1014/braindecode.egg-info → braindecode-1.6.1.dev1037}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.6.1.dev1014
+Version: 1.6.1.dev1037
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Alexandre Gramfort <agramfort@meta.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/datasets/bids/hub.py

@@ -327,7 +327,6 @@ class HubDatasetMixin:
 
         n_recordings = len(self.datasets)
         first_ds = self.datasets[0]
-        descriptions = [ds.description for ds in self.datasets]
 
         # Get dataset-specific info based on type using registry
         dataset_type = get_dataset_type(first_ds)
@@ -359,9 +358,6 @@ class HubDatasetMixin:
             raise TypeError(f"Unsupported dataset type: {dataset_type}")
 
         # Create README content and save
-        license_value, license_needs_update = _infer_license_from_descriptions(
-            descriptions
-        )
         readme_content = _generate_readme_content(
             format_info=format_info,
             n_recordings=n_recordings,
@@ -370,8 +366,6 @@ class HubDatasetMixin:
             data_type=data_type,
             n_windows=n_windows,
             total_duration=total_duration,
-            license=license_value,
-            license_needs_update=license_needs_update,
         )
 
         # Save README
@@ -973,8 +967,6 @@ def _generate_readme_content(
     n_windows: int,
     total_duration: float | None = None,
     format: str = "zarr",
-    license: str = "please-specify",
-    license_needs_update: bool = True,
 ):
     """Generate README.md content for a dataset uploaded to the Hub.
 
@@ -996,10 +988,6 @@ def _generate_readme_content(
         Total duration in seconds across all recordings.
     format : str
         Storage format (default: "zarr").
-    license : str
-        Dataset license string to write in YAML front matter.
-    license_needs_update : bool
-        Whether to append a reminder comment next to the license field.
 
     Returns
     -------
@@ -1015,10 +1003,6 @@ def _generate_readme_content(
         str(timedelta(seconds=int(total_duration))) if total_duration else "N/A"
     )
 
-    license_line = f"license: {license}"
-    if license_needs_update:
-        license_line += "  # Please update this field to reflect your dataset's license"
-
     return f"""---
 tags:
 - braindecode
@@ -1026,7 +1010,7 @@ tags:
 - neuroscience
 - brain-computer-interface
 - deep-learning
-{license_line}
+license: unknown
 ---
 
 # EEG Dataset
@@ -1122,27 +1106,3 @@ if hasattr(dataset.datasets[0], "bids_channels"):
 
 *Created with [braindecode](https://braindecode.org)*
 """
-
-
-def _infer_license_from_descriptions(
-    descriptions: list[pd.Series | None],
-) -> tuple[str, bool]:
-    """Infer a single dataset license from descriptions.
-
-    Returns inferred license and whether a manual update reminder is needed.
-    """
-    licenses = set()
-    for description in descriptions:
-        if description is None:
-            continue
-        raw_license = description.get("license", None)
-        if raw_license is None:
-            continue
-        normalized = str(raw_license).strip()
-        if normalized and normalized.lower() != "nan":
-            licenses.add(normalized)
-
-    if len(licenses) == 1:
-        return next(iter(licenses)), False
-
-    return "please-specify", True

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/eegneuralnet.py

@@ -7,7 +7,6 @@
 import abc
 import inspect
 import logging
-import warnings
 from typing import Literal
 
 import mne
@@ -42,7 +41,6 @@ def _get_model(model: str):
 
 class _EEGNeuralNet(NeuralNet, abc.ABC):
     signal_args_set_ = False
-    _warned_drop_last_ = False
 
     @property
     def log(self):
@@ -269,44 +267,6 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
             X = X.get_data(units="uV")
         return super().get_dataset(X, y)
 
-    def get_iterator(self, dataset, training=False):
-        iterator = super().get_iterator(dataset, training=training)
-        # Warn (once per fit) if drop_last would discard every training batch,
-        # e.g. a training set smaller than batch_size. This silently skips
-        # training without raising any error, which is hard to diagnose.
-        if training and not self._warned_drop_last_:
-            self._warn_if_training_batches_dropped(iterator)
-        return iterator
-
-    def _warn_if_training_batches_dropped(self, loader):
-        """Warn if ``drop_last`` discards all training batches.
-
-        With ``iterator_train__drop_last=True`` (the braindecode default), a
-        training set smaller than ``batch_size`` yields zero batches, so no
-        forward/backward pass runs and the model is left untrained without any
-        error. We inspect the resolved training ``DataLoader`` (after
-        ``train_split`` has been applied), so the count reflects the actual
-        number of training examples.
-        """
-        self._warned_drop_last_ = True
-        if not getattr(loader, "drop_last", False):
-            return
-        batch_size = getattr(loader, "batch_size", None)
-        try:
-            n_train = len(loader.dataset)
-        except TypeError:
-            return  # e.g. an IterableDataset whose length is unknown
-        if not batch_size or n_train == 0 or n_train >= batch_size:
-            return
-        warnings.warn(
-            f"The training set has {n_train} example(s), which is smaller than "
-            f"batch_size={batch_size}. With iterator_train__drop_last=True "
-            f"(the braindecode default), all training batches are dropped and "
-            f"the model is not trained. Reduce batch_size to at most {n_train}, "
-            f"or pass iterator_train__drop_last=False.",
-            UserWarning,
-        )
-
     def partial_fit(self, X, y=None, classes=None, **fit_params):
         """Fit the module.
 
@@ -406,7 +366,6 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
           the module and to the ``self.train_split`` call.
         """
         # this needs to be executed before the net is initialized:
-        self._warned_drop_last_ = False  # re-check on every fresh fit
         if not self.signal_args_set_:
             self._set_signal_args(X, y, classes=None)
             self.signal_args_set_ = True

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/models/__init__.py

@@ -55,7 +55,6 @@ from .sleep_stager_chambon_2018 import SleepStagerChambon2018
 from .sparcnet import SPARCNet
 from .sstdpn import SSTDPN
 from .syncnet import SyncNet
-from .tcformer import TCFormer
 from .tcn import BDTCN, TCN
 from .tidnet import TIDNet
 from .tsinception import TSception
@@ -131,7 +130,6 @@ __all__ = [
     "SPARCNet",
     "SyncNet",
     "BDTCN",
-    "TCFormer",
     "TCN",
     "TIDNet",
     "TSception",

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/models/atcnet.py

@@ -2,21 +2,14 @@
 #
 # License: BSD (3-clause)
 import math
-from typing import Optional
 
 import torch
 from einops.layers.torch import Rearrange
 from mne.utils import warn
 from torch import nn
-from torch.nn.utils.parametrize import is_parametrized, register_parametrization
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.modules import (
-    CausalConv1d,
-    Ensure4d,
-    MaxNormLinear,
-    MaxNormParametrize,
-)
+from braindecode.modules import CausalConv1d, Ensure4d, MaxNormLinear
 
 
 class ATCNet(EEGModuleMixin, nn.Module):
@@ -220,16 +213,6 @@ class ATCNet(EEGModuleMixin, nn.Module):
     max_norm_const : float
         Maximum L2-norm constraint imposed on weights of the last
         fully-connected layer. Defaults to 0.25.
-    conv_max_norm_const : float | None
-        If not ``None``, applies a max-norm constraint (via a weight
-        parametrization) to the convolution kernels of :class:`_ConvBlock` and
-        :class:`_TCNResidualBlock`, matching the official implementation which
-        uses ``0.6``. When ``None`` (default), no constraint is applied to those
-        layers, preserving the previous behavior. The complementary ``L2``
-        weight decay of the official code can be obtained from
-        :meth:`source_optimizer_param_groups`.
-
-        .. versionadded:: 1.6.1
 
     Notes
     -----
@@ -274,7 +257,6 @@ class ATCNet(EEGModuleMixin, nn.Module):
         tcn_activation: type[nn.Module] = nn.ELU,
         concat=False,
         max_norm_const=0.25,
-        conv_max_norm_const: Optional[float] = None,
         chs_info=None,
         n_times=None,
     ):
@@ -343,7 +325,6 @@ class ATCNet(EEGModuleMixin, nn.Module):
         self.tcn_activation = tcn_activation
         self.concat = concat
         self.max_norm_const = max_norm_const
-        self.conv_max_norm_const = conv_max_norm_const
         self.tcn_n_filters = int(self.conv_block_depth_mult * self.conv_block_n_filters)
         map = dict()
         for w in range(self.n_windows):
@@ -365,7 +346,6 @@ class ATCNet(EEGModuleMixin, nn.Module):
             pool_size_2=conv_block_pool_size_2,
             depth_mult=conv_block_depth_mult,
             dropout=conv_block_dropout,
-            conv_max_norm=self.conv_max_norm_const,
         )
 
         self.F2 = int(conv_block_depth_mult * conv_block_n_filters)
@@ -395,7 +375,6 @@ class ATCNet(EEGModuleMixin, nn.Module):
                             dropout=self.tcn_dropout,
                             activation=self.tcn_activation,
                             dilation=2**i,
-                            conv_max_norm=self.conv_max_norm_const,
                         )
                         for i in range(self.tcn_depth)
                     ]
@@ -479,93 +458,6 @@ class ATCNet(EEGModuleMixin, nn.Module):
 
         return self.out_fun(sw_concat_agg)
 
-    def source_optimizer_param_groups(
-        self,
-        conv_weight_decay: float = 0.009,
-        dense_weight_decay: float = 0.5,
-    ) -> list[dict]:
-        r"""Source-faithful optimizer parameter groups for ATCNet.
-
-        The official Keras implementation applies ``L2`` weight decay only to the
-        convolution / TCN kernels (``conv_weightDecay = 0.009``) and to the final
-        dense layer (``dense_weightDecay = 0.5``); biases, BatchNorm and attention
-        weights are left undecayed. This reproduces the Keras ``L2`` kernel penalty
-        only for optimizers that implement ``weight_decay`` as a coupled L2 term,
-        e.g. :class:`torch.optim.SGD` or :class:`torch.optim.Adam` (as used by the
-        official code). For decoupled-weight-decay optimizers such as
-        :class:`torch.optim.AdamW`, ``weight_decay`` is *not* equivalent to a Keras
-        ``L2`` penalty.
-
-        Parameters
-        ----------
-        conv_weight_decay : float
-            Weight decay applied to the convolution and TCN kernels. Defaults to
-            ``0.009`` as in the official code.
-        dense_weight_decay : float
-            Weight decay applied to the final (dense) layer weights. Defaults to
-            ``0.5`` as in the official code.
-
-        Returns
-        -------
-        list of dict
-            Parameter groups ready to be passed to a ``torch.optim`` optimizer:
-            convolution/TCN kernels, final dense weights, and everything else
-            (no decay).
-
-        Examples
-        --------
-        >>> model = ATCNet(n_chans=22, n_outputs=4, n_times=1125)  # doctest: +SKIP
-        >>> opt = torch.optim.Adam(model.source_optimizer_param_groups())  # doctest: +SKIP
-        """
-
-        def weight_leaf(module):
-            # Return the leaf weight Parameter, accounting for a registered
-            # max-norm parametrization (``conv_max_norm_const`` / MaxNormLinear).
-            if is_parametrized(module, "weight"):
-                return module.parametrizations.weight.original
-            return module.weight
-
-        conv_weights: list[nn.Parameter] = []
-        dense_weights: list[nn.Parameter] = []
-        decayed_ids: set[int] = set()
-
-        # Convolution / TCN kernels (Keras L2 = 0.009).
-        for parent in (self.conv_block, self.temporal_conv_nets):
-            for module in parent.modules():
-                if isinstance(module, (nn.Conv1d, nn.Conv2d)):
-                    weight = weight_leaf(module)
-                    conv_weights.append(weight)
-                    decayed_ids.add(id(weight))
-
-        # Final dense / readout weights (Keras L2 = 0.5).
-        for module in self.final_layer.modules():
-            if isinstance(module, nn.Linear):
-                weight = weight_leaf(module)
-                dense_weights.append(weight)
-                decayed_ids.add(id(weight))
-
-        # Everything else (biases, BatchNorm, attention) is left undecayed.
-        other = [p for p in self.parameters() if id(p) not in decayed_ids]
-
-        return [
-            {"params": conv_weights, "weight_decay": conv_weight_decay},
-            {"params": dense_weights, "weight_decay": dense_weight_decay},
-            {"params": other, "weight_decay": 0.0},
-        ]
-
-
-def _register_max_norm(max_norm, *convs):
-    """Register a max-norm weight parametrization on each given convolution.
-
-    No-op when ``max_norm`` is ``None`` or a passed layer is not a convolution
-    (e.g. an ``nn.Identity`` residual shortcut).
-    """
-    if max_norm is None:
-        return
-    for conv in convs:
-        if isinstance(conv, (nn.Conv1d, nn.Conv2d)):
-            register_parametrization(conv, "weight", MaxNormParametrize(max_norm))
-
 
 class _ConvBlock(nn.Module):
     r"""Convolutional block proposed in ATCNet [1]_, inspired by the EEGNet.
@@ -595,7 +487,6 @@ class _ConvBlock(nn.Module):
         pool_size_2=7,
         depth_mult=2,
         dropout=0.3,
-        conv_max_norm: Optional[float] = None,
     ):
         super().__init__()
 
@@ -643,9 +534,6 @@ class _ConvBlock(nn.Module):
 
         self.drop3 = nn.Dropout2d(dropout)
 
-        # Optional source-faithful max-norm constraint on the conv kernels.
-        _register_max_norm(conv_max_norm, self.conv1, self.conv2, self.conv3)
-
     def forward(self, X):
         # ----- Temporal convolution -----
         # Dimension: (batch_size, 1, T, C)
@@ -774,7 +662,6 @@ class _TCNResidualBlock(nn.Module):
         dropout=0.3,
         activation: type[nn.Module] = nn.ELU,
         dilation=1,
-        conv_max_norm: Optional[float] = None,
     ):
         super().__init__()
         self.activation = activation()
@@ -819,10 +706,6 @@ class _TCNResidualBlock(nn.Module):
         else:
             self.reshaping_conv = nn.Identity()
 
-        # Optional source-faithful max-norm constraint on the conv kernels
-        # (reshaping_conv may be nn.Identity, which the helper skips).
-        _register_max_norm(conv_max_norm, self.conv1, self.conv2, self.reshaping_conv)
-
     def forward(self, X):
         # Dimension: (batch_size, F2, Tw)
         # ----- Double dilated convolutions -----

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/models/eegtcnet.py

@@ -9,7 +9,6 @@ import torch.nn as nn
 from einops.layers.torch import Rearrange
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.models.util import _disable_batch_norm_training_if_batch_size_one
 from braindecode.modules import Chomp1d, MaxNormLinear
 
 
@@ -34,10 +33,8 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
         Number of temporal filters in the first convolutional layer. Default is 8.
     kern_length : int, optional
         Length of the temporal kernel in the first convolutional layer. Default is 64.
-    drop_prob : float, optional
-        Default dropout rate, used for both the EEGNet front-end and the TCN
-        block unless overridden by ``drop_prob_eeg`` / ``drop_prob_tcn``.
-        Default is 0.5.
+    dropout : float, optional
+        Dropout rate. Default is 0.5.
     depth : int, optional
         Number of residual blocks in the TCN. Default is 2.
     kernel_size : int, optional
@@ -47,20 +44,6 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
     max_norm_const : float
         Maximum L2-norm constraint imposed on weights of the last
         fully-connected layer. Defaults to 0.25.
-    drop_prob_eeg : float | None, optional
-        Dropout rate for the EEGNet front-end. If ``None`` (default), falls back
-        to ``drop_prob``. The source/paper uses ``0.2`` for BCI IV 2a.
-    drop_prob_tcn : float | None, optional
-        Dropout rate for the TCN block. If ``None`` (default), falls back to
-        ``drop_prob``. The source/paper uses ``0.3`` for BCI IV 2a.
-    tcn_batch_norm : bool, optional
-        If ``True`` (default), insert a :class:`~torch.nn.BatchNorm1d` after each
-        TCN convolution and use a bias in the residual ``1x1`` downsample, matching
-        the original Keras source. Set to ``False`` to recover the previous
-        braindecode architecture (e.g. to load checkpoints trained before this
-        change). Default is ``True``.
-
-        .. versionadded:: 1.6.1
 
     References
     ----------
@@ -89,9 +72,6 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
         kernel_size: int = 4,
         filters: int = 12,
         max_norm_const: float = 0.25,
-        drop_prob_eeg: float | None = None,
-        drop_prob_tcn: float | None = None,
-        tcn_batch_norm: bool = True,
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -105,11 +85,6 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
 
         self.activation = activation
         self.drop_prob = drop_prob
-        # Separate dropout rates for the EEGNet front-end and the TCN block;
-        # fall back to ``drop_prob`` when not explicitly set.
-        self.drop_prob_eeg = drop_prob if drop_prob_eeg is None else drop_prob_eeg
-        self.drop_prob_tcn = drop_prob if drop_prob_tcn is None else drop_prob_tcn
-        self.tcn_batch_norm = tcn_batch_norm
         self.depth_multiplier = depth_multiplier
         self.filter_1 = filter_1
         self.kern_length = kern_length
@@ -128,7 +103,7 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
             filter_1=self.filter_1,
             kern_length=self.kern_length,
             depth_multiplier=self.depth_multiplier,
-            drop_prob=self.drop_prob_eeg,
+            drop_prob=self.drop_prob,
             activation=self.activation,
         )
         self.arrange_dim_eegnet = Rearrange(
@@ -141,9 +116,8 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
             depth=self.depth,
             kernel_size=self.kernel_size,
             filters=self.filters,
-            drop_prob=self.drop_prob_tcn,
+            drop_prob=self.drop_prob,
             activation=self.activation,
-            batch_norm=self.tcn_batch_norm,
         )
 
         # Classification Block
@@ -153,7 +127,6 @@ class EEGTCNet(EEGModuleMixin, nn.Module):
             max_norm_val=self.max_norm_const,
         )
 
-    @_disable_batch_norm_training_if_batch_size_one
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         """
         Forward pass of the EEGTCNet model.
@@ -304,7 +277,6 @@ class _TCNBlock(nn.Module):
         filters: int,
         drop_prob: float,
         activation: type[nn.Module] = nn.ELU,
-        batch_norm: bool = True,
     ):
         super().__init__()
         self.activation = activation()
@@ -312,15 +284,10 @@ class _TCNBlock(nn.Module):
         self.depth = depth
         self.filters = filters
         self.kernel_size = kernel_size
-        self.batch_norm = batch_norm
 
         self.layers = nn.ModuleList()
-        # The Keras source uses a bias on the residual 1x1 downsample, paired
-        # with the per-conv BatchNorm; the previous braindecode default omitted
-        # both. Keeping them on the same flag makes ``batch_norm=False`` reproduce
-        # the legacy architecture exactly.
         self.downsample = (
-            nn.Conv1d(input_dimension, filters, kernel_size=1, bias=batch_norm)
+            nn.Conv1d(input_dimension, filters, kernel_size=1, bias=False)
             if input_dimension != filters
             else None
         )
@@ -328,34 +295,32 @@ class _TCNBlock(nn.Module):
         for i in range(depth):
             dilation = 2**i
             padding = (kernel_size - 1) * dilation
-            in_dim = input_dimension if i == 0 else filters
             conv_block = nn.Sequential(
-                *self._conv_unit(in_dim, dilation, padding),
-                *self._conv_unit(filters, dilation, padding),
+                nn.Conv1d(
+                    in_channels=input_dimension if i == 0 else filters,
+                    out_channels=filters,
+                    kernel_size=kernel_size,
+                    dilation=dilation,
+                    padding=padding,
+                    bias=False,
+                ),
+                Chomp1d(padding),
+                self.activation,
+                nn.Dropout(self.drop_prob),
+                nn.Conv1d(
+                    in_channels=filters,
+                    out_channels=filters,
+                    kernel_size=kernel_size,
+                    dilation=dilation,
+                    padding=padding,
+                    bias=False,
+                ),
+                Chomp1d(padding),
+                self.activation,
+                nn.Dropout(self.drop_prob),
             )
             self.layers.append(conv_block)
 
-    def _conv_unit(self, in_channels: int, dilation: int, padding: int):
-        # Conv -> Chomp -> [BatchNorm] -> activation -> Dropout, as in the
-        # original EEG-TCNet Keras implementation.
-        unit = [
-            nn.Conv1d(
-                in_channels=in_channels,
-                out_channels=self.filters,
-                kernel_size=self.kernel_size,
-                dilation=dilation,
-                padding=padding,
-                bias=False,
-            ),
-            Chomp1d(padding),
-        ]
-        if self.batch_norm:
-            # Keras BatchNormalization defaults: momentum=0.99 (-> 0.01 in
-            # PyTorch convention) and epsilon=1e-3.
-            unit.append(nn.BatchNorm1d(self.filters, momentum=0.01, eps=1e-3))
-        unit += [self.activation, nn.Dropout(self.drop_prob)]
-        return unit
-
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         # x shape: (batch_size, time_steps, input_dimension)
         x = x.permute(0, 2, 1)  # (batch_size, input_dimension, time_steps)

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/models/sstdpn.py

@@ -183,11 +183,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
         This constraint acts as an implicit force to push features away from the origin. Default is 1.0.
 
     proto_cpt_std : float, optional
-        Standard deviation for Intra-class Compactness Prototype initialization. Default is 1.0,
-        matching the source ``torch.randn`` initialization.
-
-        .. versionchanged:: 1.6.1
-            Default changed from ``0.01`` to ``1.0`` to match the original implementation.
+        Standard deviation for Intra-class Compactness Prototype initialization. Default is 0.01.
 
     spt_attn_global_context_kernel : int, optional
         Kernel size for global context embedding in Spatial-Spectral Attention module.
@@ -235,7 +231,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
         mvp_kernel_sizes: Optional[List[int]] = None,
         return_features: bool = False,
         proto_sep_maxnorm: float = 1.0,
-        proto_cpt_std: float = 1.0,
+        proto_cpt_std: float = 0.01,
         spt_attn_global_context_kernel: int = 250,
         spt_attn_epsilon: float = 1e-5,
         spt_attn_mode: str = "var",
@@ -331,11 +327,9 @@ class SSTDPN(EEGModuleMixin, nn.Module):
         """
 
         features = self.encoder(x)  # (b, feat_dim)
-        # Renormalize inter-class separation prototypes. ``proto_sep`` has shape
-        # (n_outputs, feat_dim); the source constrains each class-row prototype
-        # vector (``||s_i|| <= S``), i.e. renorm along dim=0.
+        # Renormalize inter-class separation prototypes
         self.proto_sep.data = torch.renorm(
-            self.proto_sep.data, p=2, dim=0, maxnorm=self.proto_sep_maxnorm
+            self.proto_sep.data, p=2, dim=1, maxnorm=self.proto_sep_maxnorm
         )
         logits = torch.einsum("bd,cd->bc", features, self.proto_sep)  # (b, n_outputs)
         logits = self.final_layer(logits)

braindecode-1.6.1.dev1037/braindecode/models/summary.csv

@@ -0,0 +1,59 @@
+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"
+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"
+CBraMod,General,"Classification,Embedding",200,"n_outputs",4924000,"CBraMod(n_outputs=2)","Foundation Model"
+CodeBrain,General,"Classification,Embedding",200,"n_chans, n_outputs, n_times",15238802,"CodeBrain(n_chans=19, n_outputs=2, n_times=6000)","Foundation Model,Attention/Transformer"
+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"
+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"
+EEGPT,General,Classification,256,"n_chans, n_outputs, n_times",25477635,"EEGPT(n_chans=58, n_outputs=4, n_times=1024)","Foundation Model,Attention/Transformer"
+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"
+EEGNet,General,Classification,128,"n_chans, n_outputs, n_times",2484,"EEGNet(n_chans=22,  n_outputs=4,  n_times=512)","Convolution"
+EEGNeX,Motor Imagery,Classification,125,"n_chans, n_outputs, n_times",55940,"EEGNeX(n_chans=22,  n_outputs=4,  n_times=500)","Convolution"
+EEGSym,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",299218,"EEGSym(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,Channel"
+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"
+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"
+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"
+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"
+TIDNet,General,Classification,250,"n_chans, n_outputs, n_times",240404,"TIDNet(n_chans=22,  n_outputs=4,  n_times=1000)","Convolution"
+USleep,Sleep Staging,Classification,128,"n_chans, n_outputs, n_times, sfreq",2482011,"USleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution"
+FBCNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",11812,"FCNet(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Convolution,FilterBank"
+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"
+MetaNeuromotorHand,Handwriting (sEMG),CTC Sequence,2000,"n_chans, n_outputs, n_times, sfreq",1021284,"MetaNeuromotorHand(n_chans=16, n_outputs=100, n_times=32000, sfreq=2000)","Convolution,Attention/Transformer"
+EMG2QwertyNet,Touch typing (sEMG),CTC Sequence,2000,"n_chans, n_outputs, n_times, sfreq",5293315,"EMG2QwertyNet(n_chans=32, n_outputs=99, n_times=8000, sfreq=2000)","Convolution"
+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"
+DGCNN,Emotion Recognition,Classification,128,"n_chans, n_outputs, n_times, chs_info",1037385,"DGCNN(n_chans=62, n_outputs=4, n_times=128)","Graph Neural Network,Channel"
+InterpolatedBENDR,General,"Classification,Embedding",250,"chs_info, n_outputs, n_times",157143101,"InterpolatedBENDR(chs_info=<user>, n_outputs=4, n_times=1000)","Foundation Model,Convolution,Channel"
+InterpolatedBIOT,"Sleep Staging, Epilepsy",Classification,200,"chs_info, n_outputs, n_times, sfreq",3184101,"InterpolatedBIOT(chs_info=<user>, n_outputs=5, sfreq=200, n_times=6000)","Foundation Model,Channel"
+InterpolatedEEGPT,General,Classification,256,"chs_info, n_outputs, n_times",25323137,"InterpolatedEEGPT(chs_info=<user>, n_outputs=4, n_times=1024)","Foundation Model,Attention/Transformer,Channel"
+InterpolatedLaBraM,General,"Classification, Embedding",200,"chs_info, n_outputs, n_times",5866196,"InterpolatedLaBraM(chs_info=<user>, n_outputs=4, n_times=1000)","Convolution,Foundation Model,Channel"
+InterpolatedSignalJEPA,"Motor Imagery, ERP, SSVEP",Embedding,128,"chs_info",3456882,"InterpolatedSignalJEPA(chs_info=<user>)","Convolution,Channel,Foundation Model"
+EEGDINO,General,Classification,200,"n_chans, n_outputs, n_times",4539698,"EEGDINO(n_chans=19, n_outputs=4, n_times=1000)","Foundation Model,Attention/Transformer"

{braindecode-1.6.1.dev1014 → braindecode-1.6.1.dev1037}/braindecode/models/util.py

@@ -360,7 +360,6 @@ models_mandatory_parameters: list[
     ("MSVTNet", ["n_chans", "n_outputs", "n_times"], None),
     ("EEGMiner", ["n_chans", "n_outputs", "n_times", "sfreq"], {"sfreq": 200.0}),
     ("CTNet", ["n_chans", "n_outputs", "n_times"], None),
-    ("TCFormer", ["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}),
     ("SignalJEPA", ["chs_info"], None),