Braindecode 1.8.0.dev179993000__tar.gz → 1.8.0.dev180935432__tar.gz

braindecode-1.8.0.dev180935432/NOTICE.txt

@@ -0,0 +1,25 @@
+# BRAINDECODE Notice
+
+## Licensed Components
+
+### BSD-3-Clause Licensed Files
+
+All files within the `src/` directory are licensed under the BSD-3-Clause License.
+
+### CC BY-NC 4.0 Licensed Files
+
+The following components are licensed under the Creative Commons Attribution-NonCommercial 4.0 International License:
+
+- `braindecode/models/eegminer.py`
+- `braindecode/models/meta_neuromotor.py`
+
+As well as class later imported into the `braindecode.models.module` named as GeneralizedGaussianFilter.
+
+The `meta_neuromotor.py` file is a derivative of
+`facebookresearch/generic-neuromotor-interface`, released by Meta Platforms,
+Inc. under CC BY-NC 4.0, and inherits the same noncommercial terms.
+
+## License Links
+
+- [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
+- [CC BY-NC 4.0 License](https://creativecommons.org/licenses/by-nc/4.0/)

{braindecode-1.8.0.dev179993000/braindecode.egg-info → braindecode-1.8.0.dev180935432}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0.dev179993000
+Version: 1.8.0.dev180935432
 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>
@@ -34,6 +34,7 @@ Requires-Dist: pandas
 Requires-Dist: wfdb>=4.3.1
 Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
+Requires-Dist: rotary_embedding_torch
 Requires-Dist: pydantic>=2.0
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.4.3; extra == "moabb"
@@ -50,7 +51,6 @@ Requires-Dist: pytest-cov; extra == "tests"
 Requires-Dist: codecov; extra == "tests"
 Requires-Dist: pytest_cases; extra == "tests"
 Requires-Dist: mypy; extra == "tests"
-Requires-Dist: ipython; extra == "tests"
 Requires-Dist: transformers>=4.57.0; extra == "tests"
 Requires-Dist: bids_validator; extra == "tests"
 Provides-Extra: typing
@@ -260,10 +260,7 @@ This project is primarily licensed under the BSD-3-Clause License.
 Additional Components
 =====================
 
-Some components within this repository are licensed under other licenses, including
-Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0), Creative
-Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0), MIT
-and Apache-2.0.
+Some components within this repository are licensed under the Creative Commons
+Attribution-NonCommercial 4.0 International License.
 
-Please refer to the ``LICENSE`` and ``NOTICE`` files for the per-file list and more
-detailed information.
+Please refer to the ``LICENSE`` and ``NOTICE`` files for more detailed information.

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/README.rst

@@ -170,10 +170,7 @@ This project is primarily licensed under the BSD-3-Clause License.
 Additional Components
 =====================
 
-Some components within this repository are licensed under other licenses, including
-Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0), Creative
-Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0), MIT
-and Apache-2.0.
+Some components within this repository are licensed under the Creative Commons
+Attribution-NonCommercial 4.0 International License.
 
-Please refer to the ``LICENSE`` and ``NOTICE`` files for the per-file list and more
-detailed information.
+Please refer to the ``LICENSE`` and ``NOTICE`` files for more detailed information.

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/datasets/base.py

@@ -32,7 +32,6 @@ from mne.utils.docs import deprecated
 from torch.utils.data import ConcatDataset, Dataset, IterableDataset
 from typing_extensions import TypeVar
 
-from ._notebook_viewer import plot as _viewer_plot
 from .bids.hub import HubDatasetMixin
 from .bids.hub_io import _restore_nan_from_json
 from .registry import register_dataset
@@ -1175,8 +1174,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         If True, defer computing cumulative sizes until length or item access.
     """
 
-    plot = _viewer_plot  # eegdash-viewer embed; a direct member so the API docs list it
-
     datasets: list[T]
 
     def __init__(

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/functional/functions.py

@@ -40,7 +40,7 @@ def drop_path(
     x : torch.Tensor
         input tensor
     drop_prob : float, optional
-        probability of dropping a path, by default 0.0
+        survival rate (i.e. probability of being kept), by default 0.0
     training : bool, optional
         whether the model is in training mode, by default False
     scale_by_keep : bool, optional
@@ -68,10 +68,9 @@ def drop_path(
     shape = (x.shape[0],) + (1,) * (
         x.ndim - 1
     )  # work with diff dim tensors, not just 2D ConvNets
-    probabilities = torch.full(shape, keep_prob, dtype=torch.float32, device=x.device)
-    random_tensor = torch.bernoulli(probabilities).to(dtype=x.dtype)
+    random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
     if keep_prob > 0.0 and scale_by_keep:
-        random_tensor = random_tensor / keep_prob
+        random_tensor.div_(keep_prob)
     return x * random_tensor
 
 

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/base.py

@@ -80,7 +80,7 @@ class _BraindecodeDocstringMeta(NumpyDocstringInheritanceInitMeta):
     unwrapped function and correctly inherits ``cls.__doc__``.
     """
 
-    def __init__(cls, class_name, class_bases, class_dict, **kwargs):
+    def __init__(cls, class_name, class_bases, class_dict):
         super().__init__(class_name, class_bases, class_dict)
         # Only wrap subclass __init__s, not EEGModuleMixin itself.
         # Wrapping the mixin would cause super().__init__() calls to
@@ -214,8 +214,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
     __jit_unused_properties__ = ["chs_info"]
 
     def __init_subclass__(cls, **kwargs):
-        license = kwargs.pop("license", "bsd-3-clause")
-
         # TorchScript only honours ``__jit_ignored_attributes__`` for
         # properties defined directly on the concrete class: it collects them
         # with ``vars(type(module))``, which skips inherited ones. Rebinding
@@ -255,6 +253,8 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         )
         repo_url = kwargs.pop("repo_url", "https://braindecode.org")
         library_name = kwargs.pop("library_name", "braindecode")
+        license = kwargs.pop("license", "bsd-3-clause")
+
         # Register a coder so that type[nn.Module] parameters
         # (e.g. activation=nn.ELU) are serialized as importable
         # strings in config.json and decoded back on load.
@@ -519,31 +519,6 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         resolve_type_kwargs(cls, config)
         return cls(**config)
 
-    def _set_n_outputs(self, n_outputs: int) -> None:
-        """Record a new ``n_outputs`` on the model and its saved configs.
-
-        Helper for :meth:`reset_head` implementations: validates the value,
-        then keeps the ``n_outputs`` property, the braindecode init kwargs
-        and the Hugging Face hub config in sync, so a re-serialized model
-        reports the head it actually has.
-
-        Parameters
-        ----------
-        n_outputs : int
-            New number of outputs. Must be positive.
-
-        .. versionadded:: 1.8
-        """
-        if n_outputs <= 0:
-            raise ValueError(f"n_outputs must be positive; got {n_outputs}.")
-        self._n_outputs = n_outputs
-        for config in (
-            getattr(self, "_braindecode_init_kwargs", None),
-            getattr(self, "_hub_mixin_config", None),
-        ):
-            if config is not None and "n_outputs" in config:
-                config["n_outputs"] = n_outputs
-
     def reset_head(self, n_outputs):
         """Replace the classification head for a new number of outputs.
 

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/brainmodule.py

@@ -25,7 +25,7 @@ from braindecode.modules.layers import SubjectLayers
 __all__ = ["BrainModule"]
 
 
-class BrainModule(EEGModuleMixin, nn.Module, license="cc-by-nc-4.0"):
+class BrainModule(EEGModuleMixin, nn.Module):
     r"""BrainModule from [brainmagick]_, also known as SimpleConv.
 
     A dilated convolutional encoder for EEG decoding, using residual

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/ctnet.py

@@ -24,7 +24,7 @@ from braindecode.modules import (
 )
 
 
-class CTNet(EEGModuleMixin, nn.Module, license="mit"):
+class CTNet(EEGModuleMixin, nn.Module):
     r"""CTNet from Zhao, W et al (2024) [ctnet]_.
 
     :bdg-success:`Convolution` :bdg-info:`Attention/Transformer`

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/dance.py

@@ -22,7 +22,7 @@ from braindecode.modules import ChannelMerger, Perceiver, SimpleConv
 from braindecode.modules.dance_modules import DanceDetrDecoder
 
 
-class DANCE(EEGModuleMixin, nn.Module, license="mit"):
+class DANCE(EEGModuleMixin, nn.Module):
     r"""DANCE from Lévy et al (2026) [dance]_.
 
     :bdg-success:`Convolution` :bdg-info:`Attention/Transformer` :bdg-dark-line:`Channel`
@@ -349,7 +349,8 @@ class DANCE(EEGModuleMixin, nn.Module, license="mit"):
 
     def reset_head(self, n_outputs: int) -> None:
         """Replace the dense head and the DETR class head for a new ``n_outputs``."""
-        self._set_n_outputs(n_outputs)
+        if n_outputs <= 0:
+            raise ValueError(f"n_outputs must be positive; got {n_outputs}.")
         old = self.final_layer
         self.final_layer = nn.Linear(old.in_features, n_outputs).to(
             device=old.weight.device, dtype=old.weight.dtype
@@ -358,3 +359,10 @@ class DANCE(EEGModuleMixin, nn.Module, license="mit"):
         self.decoder.class_head = nn.Linear(ch.in_features, n_outputs).to(
             device=ch.weight.device, dtype=ch.weight.dtype
         )
+        self._n_outputs = n_outputs
+        init_kwargs = getattr(self, "_braindecode_init_kwargs", None)
+        if init_kwargs is not None and "n_outputs" in init_kwargs:
+            init_kwargs["n_outputs"] = n_outputs
+        hub_config = getattr(self, "_hub_mixin_config", None)
+        if hub_config is not None and "n_outputs" in hub_config:
+            hub_config["n_outputs"] = n_outputs

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/eegconformer.py

@@ -185,7 +185,7 @@ class EEGConformer(EEGModuleMixin, nn.Module):
        31, pp.710-719. https://ieeexplore.ieee.org/document/9991178
     .. [ConformerCode] Song, Y., Zheng, Q., Liu, B. and Gao, X., 2022. EEG
        conformer: Convolutional transformer for EEG decoding and visualization.
-       https://github.com/eeyhsong/EEG-Conformer
+       https://github.com/eeyhsong/EEG-Conformer.
     """
 
     def __init__(

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/eegminer.py

@@ -6,7 +6,6 @@
 """
 
 # Authors: Sarthak Tayal <sarthaktayal2@gmail.com>
-# License: Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
 
 import torch
 from torch import nn
@@ -49,7 +48,7 @@ class _EEGMinerFeatures(nn.Module):
         return x[:, self.triu_row, self.triu_col, :]
 
 
-class EEGMiner(EEGModuleMixin, nn.Module, license="cc-by-nc-4.0"):
+class EEGMiner(EEGModuleMixin, nn.Module):
     r"""EEGMiner from Ludwig et al (2024) [eegminer]_.
 
     :bdg-success:`Convolution` :bdg-warning:`Interpretability`

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/eegsimpleconv.py

@@ -93,7 +93,7 @@ class EEGSimpleConv(EEGModuleMixin, torch.nn.Module):
     .. [Yassine2023Code] Yassine El Ouahidi, V. Gripon, B. Pasdeloup, G. Bouallegue
         N. Farrugia, G. Lioi, 2023. A Strong and Simple Deep Learning Baseline for
         BCI Motor Imagery Decoding. GitHub repository.
-        https://github.com/elouayas/EEGSimpleConv
+        https://github.com/elouayas/EEGSimpleConv.
 
     """
 

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/emg2qwerty.py

@@ -1,10 +1,9 @@
 # Authors: Meta Platforms, Inc. and affiliates (original emg2qwerty)
 #          Bruno Aristimunha <b.aristimunha@gmail.com> (Braindecode adaptation)
 #
-# License: Creative Commons Attribution-NonCommercial-ShareAlike 4.0
-#          International (CC BY-NC-SA 4.0)
+# License: Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
 # Adapted from https://github.com/facebookresearch/emg2qwerty (NeurIPS 2024).
-# Inherits CC BY-NC-SA 4.0; not covered by braindecode's BSD-3 license.
+# Inherits CC BY-NC 4.0; not covered by braindecode's BSD-3 license.
 """``EMG2QwertyNet``: TDS-Conv-CTC for sEMG-to-keystroke decoding."""
 
 from __future__ import annotations
@@ -17,10 +16,9 @@ import torchaudio.transforms as ta_transforms
 from torch import nn
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.modules import TDSConvEncoder
 
 
-class EMG2QwertyNet(EEGModuleMixin, nn.Module, license="cc-by-nc-sa-4.0"):
+class EMG2QwertyNet(EEGModuleMixin, nn.Module):
     r"""Decoder mapping surface electromyography (sEMG) to keystrokes
     (emg2qwerty) [emg2qwerty2024]_.
 
@@ -91,7 +89,7 @@ class EMG2QwertyNet(EEGModuleMixin, nn.Module, license="cc-by-nc-sa-4.0"):
     .. warning::
         **License: noncommercial use only.** This module is a derivative
         of Meta's reference implementation released under
-        `CC BY-NC-SA 4.0 <https://creativecommons.org/licenses/by-nc-sa/4.0/>`_,
+        `CC BY-NC 4.0 <https://creativecommons.org/licenses/by-nc/4.0/>`_,
         the same license as the upstream repository. Not covered by
         braindecode's BSD-3 license. Must not be used in commercial
         products or services. Pretrained weights from the upstream release
@@ -347,7 +345,7 @@ class EMG2QwertyNet(EEGModuleMixin, nn.Module, license="cc-by-nc-sa-4.0"):
                 activation=activation,
             ),
             nn.Flatten(start_dim=2),
-            TDSConvEncoder(
+            _TDSConvEncoder(
                 num_features=num_features,
                 block_channels=list(block_channels),
                 kernel_width=kernel_width,
@@ -358,7 +356,9 @@ class EMG2QwertyNet(EEGModuleMixin, nn.Module, license="cc-by-nc-sa-4.0"):
 
         self.final_layer = nn.Linear(num_features, self.n_outputs)
 
-        self._n_conv_blocks = len(block_channels)
+        self._n_conv_blocks = sum(
+            isinstance(m, _TDSConv2dBlock) for m in self.model[3].tds_conv_blocks
+        )
 
     def forward(
         self, x: torch.Tensor, return_features: bool = False
@@ -452,11 +452,22 @@ class EMG2QwertyNet(EEGModuleMixin, nn.Module, license="cc-by-nc-sa-4.0"):
         captured init config (``get_config()``) is also kept in sync so
         save/load round-trips rebuild the new head.
         """
-        self._set_n_outputs(n_outputs)
+        if n_outputs <= 0:
+            raise ValueError(f"n_outputs must be positive; got {n_outputs}.")
         old_head = self.final_layer
         self.final_layer = nn.Linear(old_head.in_features, n_outputs).to(
             device=old_head.weight.device, dtype=old_head.weight.dtype
         )
+        self._n_outputs = n_outputs
+        # Keep the init-kwargs snapshot used by ``get_config()`` aligned with
+        # the live head, so ``EMG2QwertyNet.from_config(m.get_config())``
+        # rebuilds the head with the new vocab size.
+        init_kwargs = getattr(self, "_braindecode_init_kwargs", None)
+        if init_kwargs is not None and "n_outputs" in init_kwargs:
+            init_kwargs["n_outputs"] = n_outputs
+        hub_config = getattr(self, "_hub_mixin_config", None)
+        if hub_config is not None and "n_outputs" in hub_config:
+            hub_config["n_outputs"] = n_outputs
 
     def compute_output_lengths(self, input_lengths: torch.Tensor) -> torch.Tensor:
         """Map per-sample input lengths to CTC emission lengths.
@@ -788,3 +799,116 @@ class _MultiBandRotationInvariantMLP(nn.Module):
         for band_idx, mlp in enumerate(self.mlps):
             band_outputs.append(mlp(per_band_inputs[band_idx]))
         return torch.stack(band_outputs, dim=self.stack_dim)
+
+
+class _TDSConv2dBlock(nn.Module):
+    r"""Time-Depth-Separable 2-D conv block ([hannun2019tds]_).
+
+    1×``kernel_width`` conv + activation + residual + LayerNorm. No
+    temporal padding: strips ``kernel_width - 1`` frames per block.
+    """
+
+    def __init__(
+        self,
+        channels: int,
+        width: int,
+        kernel_width: int,
+        activation: type[nn.Module] = nn.ReLU,
+    ) -> None:
+        super().__init__()
+        self.channels = channels
+        self.width = width
+        self.conv2d = nn.Conv2d(
+            in_channels=channels,
+            out_channels=channels,
+            kernel_size=(1, kernel_width),
+        )
+        self.activation = activation()
+        self.layer_norm = nn.LayerNorm(channels * width)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        n_in_frames, batch_size, n_features = inputs.shape
+        folded = inputs.movedim(0, -1).reshape(
+            batch_size, self.channels, self.width, n_in_frames
+        )
+        conv_out = self.activation(self.conv2d(folded))
+        conv_out = conv_out.reshape(batch_size, n_features, -1).movedim(-1, 0)
+        n_out_frames = conv_out.shape[0]
+        # Output frame i aligns with input frame i+(kernel_width-1), so
+        # the residual is the LAST n_out_frames input frames.
+        residual_added = conv_out + inputs[-n_out_frames:]
+        return self.layer_norm(residual_added)
+
+
+class _TDSFullyConnectedBlock(nn.Module):
+    r"""Two-layer FFN with residual skip, LayerNorm, and optional dropout."""
+
+    def __init__(
+        self,
+        num_features: int,
+        activation: type[nn.Module] = nn.ReLU,
+        drop_prob: float = 0.0,
+    ) -> None:
+        super().__init__()
+        layers: list[nn.Module] = [
+            nn.Linear(num_features, num_features),
+            activation(),
+        ]
+        if drop_prob > 0:
+            layers.append(nn.Dropout(drop_prob))
+        layers.append(nn.Linear(num_features, num_features))
+        if drop_prob > 0:
+            layers.append(nn.Dropout(drop_prob))
+        self.fc_block = nn.Sequential(*layers)
+        self.layer_norm = nn.LayerNorm(num_features)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.layer_norm(self.fc_block(inputs) + inputs)
+
+
+class _TDSConvEncoder(nn.Module):
+    r"""``_TDSConv2dBlock`` + ``_TDSFullyConnectedBlock`` stack.
+
+    With ``K = len(block_channels)`` blocks and no temporal padding, the
+    encoder strips ``K * (kernel_width - 1)`` frames in total. Each ``ch``
+    must evenly divide ``num_features`` so the conv block can fold features
+    as ``(channels=ch, width=num_features // ch)``.
+    """
+
+    def __init__(
+        self,
+        num_features: int,
+        block_channels: Sequence[int] = (24, 24, 24, 24),
+        kernel_width: int = 32,
+        activation: type[nn.Module] = nn.ReLU,
+        drop_prob: float = 0.0,
+    ) -> None:
+        super().__init__()
+        if not block_channels:
+            raise ValueError("block_channels must be non-empty.")
+        blocks: list[nn.Module] = []
+        for n_block_channels in block_channels:
+            if num_features % n_block_channels != 0:
+                raise ValueError(
+                    f"block_channels entry {n_block_channels} does not evenly "
+                    f"divide num_features={num_features}."
+                )
+            blocks.extend(
+                [
+                    _TDSConv2dBlock(
+                        n_block_channels,
+                        num_features // n_block_channels,
+                        kernel_width,
+                        activation=activation,
+                    ),
+                    _TDSFullyConnectedBlock(
+                        num_features,
+                        activation=activation,
+                        drop_prob=drop_prob,
+                    ),
+                ]
+            )
+        self.tds_conv_blocks = nn.Sequential(*blocks)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.tds_conv_blocks(inputs)

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/ifnet.py

@@ -1,4 +1,3 @@
-# License: MIT
 """IFNet Neural Network.
 
 Authors: Jiaheng Wang
@@ -29,7 +28,7 @@ from braindecode.modules import (
 )
 
 
-class IFNet(EEGModuleMixin, nn.Module, license="mit"):
+class IFNet(EEGModuleMixin, nn.Module):
     r"""IFNetV2 from Wang J et al (2023) [ifnet]_.
 
     :bdg-success:`Convolution` :bdg-primary:`Filterbank`

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/luna.py

@@ -1,4 +1,3 @@
-# License: Apache-2.0
 """This implementation is adapted from ETH Zurich's BioFoundation repository.
 
 Döner, B., Ingolfsson, T. M., Benini, L., & Li, Y. (2025).
@@ -21,13 +20,14 @@ import torch.fft as fft
 import torch.nn as nn
 import torch.nn.functional as F
 from einops import rearrange
+from rotary_embedding_torch import RotaryEmbedding
 
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
 from braindecode.modules.layers import DropPath
 
 
-class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
+class LUNA(EEGModuleMixin, nn.Module):
     r"""LUNA from Döner et al [LUNA]_.
 
     :bdg-success:`Convolution` :bdg-danger:`Foundation Model` :bdg-dark-line:`Channel`
@@ -535,7 +535,7 @@ class _RotarySelfAttentionBlock(nn.Module):
         self.dim = dim
         self.num_heads = num_heads
         head_dim = dim // num_heads
-        self.rotary_emb = _RotaryEmbedding(head_dim)
+        self.rotary_emb = RotaryEmbedding(dim=head_dim, learned_freq=False)
 
         self.scale = qk_scale or head_dim**-0.5
 
@@ -545,17 +545,6 @@ class _RotarySelfAttentionBlock(nn.Module):
         self.proj = nn.Linear(dim, dim)
         self.proj_drop = nn.Dropout(proj_drop)
 
-    def _rotate_queries_or_keys(self, tensor: torch.Tensor) -> torch.Tensor:
-        """Apply full-head RoPE without concatenating empty boundary views."""
-        seq_len = tensor.shape[-2]
-        positions = torch.arange(seq_len, device=tensor.device, dtype=tensor.dtype)
-        freqs = self.rotary_emb(positions)
-
-        pairs = tensor.reshape(*tensor.shape[:-1], -1, 2)
-        rotated = torch.stack((-pairs[..., 1], pairs[..., 0]), dim=-1).flatten(-2)
-        transformed = tensor * freqs.cos() + rotated * freqs.sin()
-        return transformed.to(tensor.dtype)
-
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         B, N, C = x.shape
         qkv = (
@@ -564,8 +553,8 @@ class _RotarySelfAttentionBlock(nn.Module):
             .permute(2, 0, 3, 1, 4)
         )  # (K, B, H, N, D)
         q, k, v = qkv[0], qkv[1], qkv[2]
-        q = self._rotate_queries_or_keys(q)
-        k = self._rotate_queries_or_keys(k)
+        q = self.rotary_emb.rotate_queries_or_keys(q)
+        k = self.rotary_emb.rotate_queries_or_keys(k)
         # Calculate attention scores
         attn_weights = (q @ k.transpose(-2, -1)) * self.scale  # (B, H, N, N)
 
@@ -581,21 +570,6 @@ class _RotarySelfAttentionBlock(nn.Module):
         return self.proj_drop(self.proj(attn))
 
 
-class _RotaryEmbedding(nn.Module):
-    """Minimal language RoPE frequency generator used by LUNA."""
-
-    def __init__(self, dim: int, theta: float = 10000.0) -> None:
-        super().__init__()
-        frequencies = 1.0 / (
-            theta ** (torch.arange(0, dim, 2, dtype=torch.float32) / dim)
-        )
-        self.freqs = nn.Parameter(frequencies, requires_grad=False)
-
-    def forward(self, positions: torch.Tensor) -> torch.Tensor:
-        angles = positions.to(self.freqs.dtype).unsqueeze(-1) * self.freqs
-        return angles.repeat_interleave(2, dim=-1)
-
-
 class _FeedForwardBlock(nn.Module):
     def __init__(self, dim: int, hidden_dim: int, dropout: float = 0.0) -> None:
         super().__init__()

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/medformer.py

@@ -17,7 +17,7 @@ from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.models.base import EEGModuleMixin
 
 
-class MEDFormer(EEGModuleMixin, nn.Module, license="mit"):
+class MEDFormer(EEGModuleMixin, nn.Module):
     r"""
     Medformer from Wang et al (2024) [Medformer2024]_.
 

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/meta_neuromotor.py

@@ -31,7 +31,7 @@ _LPadType = int | Literal["none", "steady", "full"]
 # ---------------------------------------------------------------------------
 
 
-class MetaNeuromotorHand(EEGModuleMixin, nn.Module, license="cc-by-nc-4.0"):
+class MetaNeuromotorHand(EEGModuleMixin, nn.Module):
     r"""Generic neuromotor interface for handwriting from Meta (2025) [gni2025]_.
 
     :bdg-info:`Attention/Transformer` :bdg-success:`Convolution`

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/mvpformer.py

@@ -26,7 +26,7 @@ from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import PatchTokenizer
 
 
-class MVPFormer(EEGModuleMixin, nn.Module, license="apache-2.0"):
+class MVPFormer(EEGModuleMixin, nn.Module):
     r"""MVPFormer from Carzaniga et al. (2026) [Carzaniga2026]_.
 
     :bdg-danger:`Foundation Model` :bdg-info:`Attention/Transformer`

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/sstdpn.py

@@ -216,7 +216,7 @@ class SSTDPN(EEGModuleMixin, nn.Module):
         temporal dual prototype network for motor imagery
         brain–computer interface. Knowledge-Based Systems,
         315, 113315. GitHub repository.
-        https://github.com/hancan16/SST-DPN
+        https://github.com/hancan16/SST-DPN.
     """
 
     def __init__(

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/summary.csv

@@ -31,7 +31,7 @@ SincShallowNet,Motor Imagery,Prediction,250,"n_chans, n_outputs, n_times, sfreq"
 ShallowFBCSPNet,General,Prediction,250,"n_chans, n_outputs, n_times",46084,"ShallowFBCSPNet(n_chans=22,  n_outputs=4,  n_times=1000, sfreq=250)","Convolution",EEG
 SleepStagerBlanco2020,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times",2845,"SleepStagerBlanco2020(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution",EEG
 SleepStagerChambon2018,Sleep Staging,Prediction,128,"n_chans, n_outputs, n_times, sfreq",5835,"SleepStagerChambon2018(n_chans=2, n_outputs=5, n_times=3840, sfreq=128)","Convolution",EEG
-AttnSleep,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times, sfreq",522805,"AttnSleep(n_chans=1, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Attention/Transformer",EEG
+AttnSleep,Sleep Staging,Prediction,100,"n_chans, n_outputs, n_times, sfreq",719925,"AttnSleep(n_chans=2, n_outputs=5, n_times=3000, sfreq=100)","Convolution, Attention/Transformer",EEG
 SPARCNet,Epilepsy,Prediction,200,"n_chans, n_outputs, n_times",1141921,"SPARCNet(n_chans=16, n_outputs=6, n_times=2000, sfreq=200)","Convolution",EEG
 SyncNet,"Emotion Recognition, Alcoholism",Prediction,256,"n_chans, n_outputs, n_times",554,"SyncNet(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Interpretability",EEG
 TSception,Emotion Recognition,Prediction,256,"n_chans, n_outputs, n_times, sfreq",2187206,"TSception(n_chans=62, n_outputs=3, n_times=5120, sfreq=256)","Convolution",EEG

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/tcformer.py

@@ -14,7 +14,7 @@ from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import CausalConv1d, Conv1dWithConstraint, DropPath
 
 
-class TCFormer(EEGModuleMixin, nn.Module, license="mit"):
+class TCFormer(EEGModuleMixin, nn.Module):
     r"""TCFormer from Altaheri et al (2025) [tcformer]_.
 
     :bdg-success:`Convolution` :bdg-info:`Attention/Transformer`

{braindecode-1.8.0.dev179993000 → braindecode-1.8.0.dev180935432}/braindecode/models/usleep.py

@@ -431,7 +431,11 @@ class _DecoderBlock(nn.Module):
     ) -> tuple[torch.Tensor, torch.Tensor]:
         """Crops two tensors to their lowest-common-dimension along an axis."""
         dim_cropped = min(x1.shape[axis], x2.shape[axis])
-        return (
-            x1.narrow(axis, 0, dim_cropped),
-            x2.narrow(axis, 0, dim_cropped),
+
+        x1_cropped = torch.index_select(
+            x1, dim=axis, index=torch.arange(dim_cropped).to(device=x1.device)
+        )
+        x2_cropped = torch.index_select(
+            x2, dim=axis, index=torch.arange(dim_cropped).to(device=x1.device)
         )
+        return x1_cropped, x2_cropped