Braindecode 1.3.1.dev177756420__tar.gz → 1.3.1.dev178641268__tar.gz

{braindecode-1.3.1.dev177756420/braindecode.egg-info → braindecode-1.3.1.dev178641268}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.3.1.dev177756420
+Version: 1.3.1.dev178641268
 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.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode/models/__init__.py

@@ -7,7 +7,6 @@ from .base import EEGModuleMixin
 from .bendr import BENDR
 from .biot import BIOT
 from .brainmodule import BrainModule
-from .cbramod import CBraMod
 from .contrawr import ContraWR
 from .ctnet import CTNet
 from .deep4 import Deep4Net
@@ -69,7 +68,6 @@ __all__ = [
     "EEGModuleMixin",
     "BIOT",
     "BENDR",
-    "CBraMod",
     "ContraWR",
     "CTNet",
     "Deep4Net",

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode/models/base.py

@@ -397,18 +397,9 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=NumpyDocstringInheritanceInitMeta)
         torchinfo.ModelStatistics
             ModelStatistics generated by torchinfo.summary.
         """
-        try:
-            n_chans = self.n_chans
-        except ValueError:
-            n_chans = 1
-        try:
-            n_times = self.n_times
-        except ValueError:
-            n_times = 200
-
         return summary(
             self,
-            input_size=(1, n_chans, n_times),
+            input_size=(1, self.n_chans, self.n_times),
             col_names=col_names,
             row_settings=row_settings,
             verbose=0,

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode/models/summary.csv

@@ -3,7 +3,6 @@ ATCNet,General,Classification,250,"n_chans, n_outputs, n_times",113732,"ATCNet(n
 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"
 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"

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode/models/util.py

@@ -132,7 +132,6 @@ models_mandatory_parameters: list[
             "chs_info": [{"ch_name": f"E{i + 1}", "kind": "eeg"} for i in range(19)],
         },
     ),
-    ("CBraMod", ["n_outputs"], None),
 ]
 
 ################################################################

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode/modules/__init__.py

@@ -7,7 +7,6 @@ from .attention import (
     GCT,
     SRM,
     CATLite,
-    CrissCrossTransformerEncoderLayer,
     EncNet,
     GatherExcite,
     GSoP,
@@ -60,7 +59,6 @@ __all__ = [
     "GSoP",
     "MultiHeadAttention",
     "SqueezeAndExcitation",
-    "CrissCrossTransformerEncoderLayer",
     "MLP",
     "FeedForwardBlock",
     "InceptionBlock",

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode/modules/attention.py

@@ -881,137 +881,3 @@ class MultiHeadAttention(nn.Module):
         out = self.rearrange_unstack(out)
         out = self.projection(out)
         return out
-
-
-class CrissCrossTransformerEncoderLayer(nn.Module):
-    """
-    **Criss-Cross Transformer Encoder Layer** implementing the criss-cross attention mechanism
-    proposed in Wang et al. (2025) [cbramod]_.
-
-    This layer models spatial and temporal dependencies in EEG signals through parallel
-    **Spatial Attention** (S-Attention) and **Temporal Attention** (T-Attention). Unlike
-    standard Transformer layers that model all spatial-temporal dependencies together,
-    this layer separates these heterogeneous dependencies:
-
-    - **S-Attention**: Captures dependencies between EEG channels within a fixed time interval.
-      For each temporal stripe across all channels, it applies self-attention independently,
-      learning channel interactions while keeping time steps separate.
-
-    - **T-Attention**: Captures dependencies between temporal patches within a fixed channel.
-      For each channel across all time intervals, it applies self-attention independently,
-      learning temporal dynamics while keeping channels separate.
-
-    The attention heads are split equally between S-Attention and T-Attention, and their
-    outputs are concatenated. This criss-cross design effectively captures EEG's unique
-    structural characteristics—EEG signals exhibit heterogeneous spatial and temporal
-    dependencies that differ from images (which have only spatial dependencies).
-
-    Input shape: ``(batch, channels, n_patches, patch_size)``
-    Output shape: ``(batch, channels, n_patches, patch_size)``
-
-    .. figure:: https://braindecode.org/dev/_static/model/criss-cross-attention.png
-       :align: center
-       :alt: Criss-Cross Attention Mechanism
-
-    References
-    ----------
-    .. [cbramod] Wang, J., Zhao, S., Luo, Z., Zhou, Y., Jiang, H., Li, S., Li, T., & Pan, G. (2025).
-       CBraMod: A Criss-Cross Brain Foundation Model for EEG Decoding.
-       In The Thirteenth International Conference on Learning Representations (ICLR 2025).
-       https://arxiv.org/abs/2412.07236
-    """
-
-    __constants__ = ["norm_first"]
-
-    def __init__(
-        self,
-        d_model: int,
-        nhead: int,
-        dim_feedforward: int = 2048,
-        dropout: float = 0.1,
-        activation: type[nn.Module] = nn.GELU,
-        layer_norm_eps: float = 1e-5,
-        batch_first: bool = False,
-        norm_first: bool = False,
-        bias: bool = True,
-    ) -> None:
-        super().__init__()
-        self.self_attn_s = nn.MultiheadAttention(
-            d_model // 2,
-            nhead // 2,
-            dropout=dropout,
-            bias=bias,
-            batch_first=batch_first,
-        )
-        self.self_attn_t = nn.MultiheadAttention(
-            d_model // 2,
-            nhead // 2,
-            dropout=dropout,
-            bias=bias,
-            batch_first=batch_first,
-        )
-
-        # Implementation of Feedforward model
-        self.linear1 = nn.Linear(d_model, dim_feedforward, bias=bias)
-        self.dropout = nn.Dropout(dropout)
-        self.linear2 = nn.Linear(dim_feedforward, d_model, bias=bias)
-
-        self.norm_first = norm_first
-        self.norm1 = nn.LayerNorm(d_model, eps=layer_norm_eps)
-        self.norm2 = nn.LayerNorm(d_model, eps=layer_norm_eps)
-        self.dropout1 = nn.Dropout(dropout)
-        self.dropout2 = nn.Dropout(dropout)
-        self.activation = activation()
-
-    def forward(
-        self,
-        src: Tensor,
-        src_mask: Optional[Tensor] = None,
-        src_key_padding_mask: Optional[Tensor] = None,
-        is_causal: bool = False,
-    ) -> Tensor:
-        x = src
-        x = x + self._sa_block(
-            self.norm1(x), src_mask, src_key_padding_mask, is_causal=is_causal
-        )
-        x = x + self._ff_block(self.norm2(x))
-        return x
-
-    # self-attention block
-    def _sa_block(
-        self,
-        x: Tensor,
-        attn_mask: Optional[Tensor],
-        key_padding_mask: Optional[Tensor],
-        is_causal: bool = False,
-    ) -> Tensor:
-        bz, ch_num, patch_num, patch_size = x.shape
-        xs = x[:, :, :, : patch_size // 2]
-        xt = x[:, :, :, patch_size // 2 :]
-        xs = rearrange(xs, "b c n p2 -> (b n) c p2")
-        xt = rearrange(xt, "b c n p2 -> (b c) n p2")
-        xs = self.self_attn_s(
-            xs,
-            xs,
-            xs,
-            attn_mask=attn_mask,
-            key_padding_mask=key_padding_mask,
-            need_weights=False,
-        )[0]
-        xs = rearrange(xs, "(b n) c p2 -> b c n p2", b=bz, n=patch_num)
-        xt = self.self_attn_t(
-            xt,
-            xt,
-            xt,
-            attn_mask=attn_mask,
-            key_padding_mask=key_padding_mask,
-            need_weights=False,
-        )[0]
-        xt = rearrange(xt, "(b c) n p2 -> b c n p2", b=bz, c=ch_num)
-        x = torch.concat((xs, xt), dim=3)
-        return self.dropout1(x)
-
-    # feed forward block
-    def _ff_block(self, x: Tensor) -> Tensor:
-        x = self.linear2(self.dropout(self.activation(self.linear1(x))))
-        return self.dropout2(x)

braindecode-1.3.1.dev178641268/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "1.3.1.dev178641268"

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268/braindecode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.3.1.dev177756420
+Version: 1.3.1.dev178641268
 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.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/braindecode.egg-info/SOURCES.txt

@@ -58,7 +58,6 @@ braindecode/models/base.py
 braindecode/models/bendr.py
 braindecode/models/biot.py
 braindecode/models/brainmodule.py
-braindecode/models/cbramod.py
 braindecode/models/config.py
 braindecode/models/contrawr.py
 braindecode/models/ctnet.py

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/docs/api.rst

@@ -62,16 +62,16 @@ a common interface for all EEG models and derivate variables names if necessary.
     Some models have pre-trained weights available on the Hugging Face BrainDecode
     organization:
 
-    .. currentmodule:: braindecode.models
-
-    - :class:`BIOT` - Foundation model with pre-trained weights
-    - :class:`CBraMod` - Criss-Cross Transformer model with pre-trained weights
-    - :class:`Labram` - Large Brain Model with pre-trained weights
-    - :class:`REVE` - EEG foundation model with pre-trained weights
-    - :class:`LUNA` - Universal EEG embedding model with pre-trained weights
-    - :class:`BENDR` - Foundation model with pre-trained weights
-    - :class:`SignalJEPA` - Self-supervised learning model with pre-trained weights
-    - :class:`EEGPT` - Pretrained transformer for universal EEG
+    - :class:`~braindecode.models.BIOT` - Foundation model with pre-trained weights
+    - :class:`~braindecode.models.Labram` - Large Brain Model with pre-trained weights
+    - :class:`~braindecode.models.REVE` - EEG foundation model with pre-trained weights
+    - :class:`~braindecode.models.LUNA` - Universal EEG embedding model with pre-trained
+      weights
+    - :class:`~braindecode.models.BENDR` - Foundation model with pre-trained weights
+    - :class:`~braindecode.models.SignalJEPA` - Self-supervised learning model with
+      pre-trained weights
+    - :class:`~braindecode.models.EEGPT` - Pretrained transformer for universal EEG
+      representation
 
     **Example - Loading a pre-trained model:**
 
@@ -132,7 +132,6 @@ a common interface for all EEG models and derivate variables names if necessary.
      BENDR
      BIOT
      BrainModule
-     CBraMod
      ContraWR
      CTNet
      Deep4Net

{braindecode-1.3.1.dev177756420 → braindecode-1.3.1.dev178641268}/docs/whats_new.rst

@@ -33,7 +33,6 @@ Enhancements
 - Adding :class:`braindecode.models.EEGPT` with HuggingFace Hub integration and
   pretrained weights available at `braindecode/eegpt-pretrained <https://huggingface.co/braindecode/eegpt-pretrained>`_
   (:gh:`908` by `Young Truong`_ and `Kuntal Kokate`_)
-- Add :class:`braindecode.models.CBraMod` model (:gh:`914` by `Pierre Guetschel`_)
 
 API changes
 ============

braindecode-1.3.1.dev177756420/braindecode/models/cbramod.py

@@ -1,350 +0,0 @@
-# Authors: Pierre Guetschel
-#
-# Code adapted from https://github.com/wjq-learning/CBraMod
-#
-# License: BSD (3-clause)
-
-
-import copy
-import logging
-from typing import Optional, Sequence
-
-import torch
-from einops import rearrange
-from einops.layers.torch import Rearrange
-from torch import Tensor, nn
-
-from braindecode.models.base import EEGModuleMixin
-from braindecode.modules import CrissCrossTransformerEncoderLayer
-
-logger = logging.getLogger(__name__)
-
-
-class CBraMod(EEGModuleMixin, nn.Module):
-    r"""
-    **C**\ riss-\ **C**\ ross **Bra**\ in **Mod**\ el for EEG Decoding from Wang et al. (2025) [cbramod]_.
-
-    :bdg-danger:`Foundation Model` :bdg-info:`Attention/Transformer`
-
-    .. figure:: https://raw.githubusercontent.com/wjq-learning/CBraMod/refs/heads/main/figure/model.png
-        :align: center
-        :alt:  CBraMod pre-training overview
-        :width: 1000px
-
-    CBraMod is a foundation model for EEG decoding that leverages a novel criss-cross transformer
-    architecture to effectively model the unique spatial and temporal characteristics of EEG signals.
-    Pre-trained on the Temple University Hospital EEG Corpus (TUEG)—the largest public EEG corpus—
-    using masked EEG patch reconstruction, CBraMod achieves state-of-the-art performance across
-    diverse downstream BCI and clinical applications.
-
-    .. rubric:: Key Innovation: Criss-Cross Attention
-
-    Unlike existing EEG foundation models that use full attention to model all spatial and temporal
-    dependencies together, CBraMod separates spatial and temporal dependencies through a
-    **criss-cross transformer** architecture:
-
-    - **Spatial Attention**: Models dependencies between channels while keeping patches separate
-    - **Temporal Attention**: Models dependencies between temporal patches while keeping channels separate
-
-    This design is inspired by criss-cross strategies from computer vision and effectively
-    leverages the inherent structural characteristics of EEG signals. The criss-cross approach
-    reduces computational complexity (FLOPs reduced by ~32% compared to full attention) while
-    improving performance and enabling faster convergence.
-
-    .. rubric:: Asymmetric Conditional Positional Encoding (ACPE)
-
-    Rather than using fixed positional embeddings, CBraMod employs **Asymmetric Conditional
-    Positional Encoding** that dynamically generates positional embeddings using a convolutional
-    network. This enables the model to:
-
-    - Capture relative positional information adaptively
-    - Handle diverse EEG channel formats (different channel counts and reference schemes)
-    - Generalize to arbitrary downstream EEG formats without retraining
-    - Support various reference schemes (earlobe, average, REST, bipolar)
-
-    .. rubric:: Pretraining Highlights
-
-    - **Pretraining Dataset**: Temple University Hospital EEG Corpus (TUEG), the largest public EEG corpus
-    - **Pretraining Task**: Self-supervised masked EEG patch reconstruction from both time-domain
-      and frequency-domain EEG signals
-    - **Model Parameters**: ~4.0M parameters (very compact compared to other foundation models)
-    - **Fast Convergence**: Achieves decent results in first epoch on downstream tasks,
-      full convergence within ~10 epochs (vs. ~30 for supervised models like EEGConformer)
-
-    .. rubric:: Macro Components
-
-    - **Patch Encoding Network**: Converts raw EEG patches into embeddings
-    - **Asymmetric Conditional Positional Encoding (ACPE)**: Generates spatial-temporal positional
-      embeddings adaptively from input EEG format
-    - **Criss-Cross Transformer Blocks** (12 layers): Alternates spatial and temporal attention
-      to learn EEG representations
-    - **Reconstruction Head**: Reconstructs masked EEG patches during pretraining
-    - **Task head** (``final_layer``): flatten summary tokens across patches and map to
-       ``n_outputs``; if ``return_encoder_output=True``, return the encoder features instead.
-
-    The model is highly efficient, requiring only ~318.9M FLOPs on a typical 16-channel, 10-second
-    EEG recording (significantly lower than full attention baselines).
-
-    .. rubric:: Known Limitations
-
-    - **Data Quality**: TUEG corpus contains "dirty data"; pretraining used crude filtering,
-      reducing available pre-training data
-    - **Channel Dependency**: Performance degrades with very sparse electrode setups (e.g., <4 channels)
-    - **Computational Resources**: While efficient, foundation models have higher deployment
-      requirements than lightweight models
-    - **Limited Scaling Exploration**: Future work should explore scaling laws at billion-parameter levels
-      and integration with large pre-trained vision/language models
-
-    .. important::
-       **Pre-trained Weights Available**
-
-       This model has pre-trained weights available on the Hugging Face Hub.
-       You can load them using:
-
-       .. code-block:: python
-
-           from braindecode.models import CBraMod
-
-           # Load pre-trained model from Hugging Face Hub
-           model = CBraMod.from_pretrained(
-               "braindecode/cbramod-pretrained", return_encoder_output=True
-           )
-
-       To push your own trained model to the Hub:
-
-       .. code-block:: python
-
-           # After training your model
-           model.push_to_hub(
-               repo_id="username/my-cbramod-model", commit_message="Upload trained CBraMod model"
-           )
-
-       Requires installing ``braindecode[hug]`` for Hub integration.
-
-    Parameters
-    ----------
-    patch_size : int, default=200
-        Temporal patch size in samples (200 samples = 1 second at 200 Hz).
-    dim_feedforward : int, default=800
-        Dimension of the feedforward network in Transformer layers.
-    n_layer : int, default=12
-        Number of Transformer layers.
-    nhead : int, default=8
-        Number of attention heads.
-    activation : type[nn.Module], default=nn.GELU
-        Activation function used in Transformer feedforward layers.
-    emb_dim : int, default=200
-        Output embedding dimension.
-    drop_prob : float, default=0.1
-        Dropout probability.
-    return_encoder_output : bool, default=False
-        If false (default), the features are flattened and passed through a final linear layer
-        to produce class logits of size ``n_outputs``.
-        If True, the model returns the encoder output features.
-
-    References
-    ----------
-    .. [cbramod] Wang, J., Zhao, S., Luo, Z., Zhou, Y., Jiang, H., Li, S., Li, T., & Pan, G. (2025).
-       CBraMod: A Criss-Cross Brain Foundation Model for EEG Decoding.
-       In The Thirteenth International Conference on Learning Representations (ICLR 2025).
-       https://arxiv.org/abs/2412.07236
-    """
-
-    def __init__(
-        self,
-        n_outputs=None,
-        n_chans=None,
-        chs_info=None,
-        n_times=None,
-        input_window_seconds=None,
-        sfreq=None,
-        patch_size: int = 200,
-        dim_feedforward: int = 800,
-        n_layer: int = 12,
-        nhead: int = 8,
-        activation: type[nn.Module] = nn.GELU,
-        emb_dim: int = 200,
-        channels_kernel_stride_padding_norm: Sequence[
-            tuple[int, int, int, int, tuple[int, int]]
-        ] = (
-            (25, 49, 25, 24, (5, 25)),
-            (25, 3, 1, 1, (5, 25)),
-            (25, 3, 1, 1, (5, 25)),
-        ),
-        drop_prob: float = 0.1,
-        return_encoder_output: bool = False,
-    ):
-        super().__init__(
-            n_outputs=n_outputs,
-            n_chans=n_chans,
-            chs_info=chs_info,
-            n_times=n_times,
-            input_window_seconds=input_window_seconds,
-            sfreq=sfreq,
-        )
-        del n_chans, chs_info, n_times, input_window_seconds, sfreq, n_outputs
-        self.rearrange = Rearrange(
-            "batch n_chans (n_patch patch_size) -> batch n_chans n_patch patch_size",
-            patch_size=patch_size,
-        )
-        self.patch_embedding = _PatchEmbedding(
-            patch_size,
-            channels_kernel_stride_padding_norm,
-            drop_prob=drop_prob,
-        )
-        d_model = self.patch_embedding.d_model
-        encoder_layer = CrissCrossTransformerEncoderLayer(
-            d_model=d_model,
-            nhead=nhead,
-            dim_feedforward=dim_feedforward,
-            batch_first=True,
-            norm_first=True,
-            activation=activation,
-            dropout=drop_prob,
-        )
-        self.encoder = _TransformerEncoder(encoder_layer, num_layers=n_layer)
-        self.proj_out = nn.Sequential(nn.Linear(d_model, emb_dim))
-
-        self._weights_init()
-
-        self.final_layer = (
-            nn.Identity()
-            if return_encoder_output
-            else nn.Sequential(nn.Flatten(), nn.LazyLinear(self.n_outputs))
-        )
-
-    def _weights_init(self):
-        for m in self.modules():
-            if isinstance(m, nn.Linear):
-                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
-            elif isinstance(m, nn.Conv1d):
-                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
-            elif isinstance(m, nn.BatchNorm1d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-
-    def forward(self, x, mask=None):
-        x = self.rearrange(x)
-        patch_emb = self.patch_embedding(x, mask)
-        feats = self.encoder(patch_emb)
-        out = self.proj_out(feats)
-        return self.final_layer(out)
-
-
-class _PatchEmbedding(nn.Module):
-    def __init__(
-        self,
-        patch_size,
-        channels_kernel_stride_padding_norm,
-        drop_prob=0.1,
-    ):
-        super().__init__()
-        self.patch_size = patch_size
-        self.channels_kernel_stride_padding_norm = channels_kernel_stride_padding_norm
-        self.positional_encoding = nn.Sequential(
-            nn.Conv2d(
-                in_channels=self.d_model,
-                out_channels=self.d_model,
-                kernel_size=(19, 7),
-                stride=(1, 1),
-                padding=(9, 3),
-                groups=self.d_model,
-            ),
-        )
-        self.mask_encoding = nn.Parameter(torch.zeros(patch_size), requires_grad=False)
-
-        last_channels = 1
-        proj_in_layers = []
-        for (
-            channels,
-            kernel,
-            stride,
-            padding,
-            norm,
-        ) in channels_kernel_stride_padding_norm:
-            proj_in_layers.extend(
-                [
-                    nn.Conv2d(
-                        in_channels=last_channels,
-                        out_channels=channels,
-                        kernel_size=(1, kernel),
-                        stride=(1, stride),
-                        padding=(0, padding),
-                    ),
-                    nn.GroupNorm(*norm),
-                    nn.GELU(),
-                ]
-            )
-            last_channels = channels
-        self.proj_in = nn.Sequential(*proj_in_layers)
-        self.spectral_proj = nn.Sequential(
-            nn.Linear(patch_size // 2 + 1, self.d_model),
-            nn.Dropout(drop_prob),
-        )
-
-    @property
-    def d_model(self):
-        last_channels = self.channels_kernel_stride_padding_norm[-1][0]
-        patch_size = self.patch_size
-        for _, kernel, stride, padding, _ in self.channels_kernel_stride_padding_norm:
-            patch_size = int((patch_size + 2 * padding - kernel) / stride + 1)
-        return last_channels * patch_size
-
-    def forward(self, x, mask=None):
-        bz, ch_num, patch_num, patch_size = x.shape
-        if mask is None:
-            mask_x = x
-        else:
-            mask_x = x.clone()
-            mask_x[mask == 1] = self.mask_encoding
-
-        mask_x = rearrange(mask_x, "b c n p -> b 1 (c n) p")
-        patch_emb = self.proj_in(mask_x)
-        patch_emb = rearrange(patch_emb, "b d (c n) p2 -> b c n (d p2)", c=ch_num)
-
-        mask_x = rearrange(mask_x, "b 1 (c n) p -> (b c n) p", c=ch_num)
-        spectral = torch.fft.rfft(mask_x, dim=-1, norm="forward")
-        spectral = rearrange(
-            torch.abs(spectral), "(b c n) p -> b c n p", b=bz, c=ch_num, p=101
-        )
-        spectral_emb = self.spectral_proj(spectral)
-
-        patch_emb = patch_emb + spectral_emb
-
-        positional_embedding = self.positional_encoding(
-            rearrange(patch_emb, "b c n p -> b p c n", p=self.d_model)
-        )  # d for sanity check
-        positional_embedding = rearrange(positional_embedding, "b p c n -> b c n p")
-
-        patch_emb = patch_emb + positional_embedding
-
-        return patch_emb
-
-
-class _TransformerEncoder(nn.Module):
-    def __init__(
-        self,
-        encoder_layer,
-        num_layers,
-        norm=None,
-    ):
-        super().__init__()
-        self.layers = nn.ModuleList(
-            [copy.deepcopy(encoder_layer) for i in range(num_layers)]
-        )
-        self.num_layers = num_layers
-        self.norm = norm
-
-    def forward(
-        self,
-        src: Tensor,
-        mask: Optional[Tensor] = None,
-        src_key_padding_mask: Optional[Tensor] = None,
-        is_causal: Optional[bool] = None,
-    ) -> Tensor:
-        output = src
-        for mod in self.layers:
-            output = mod(output, src_mask=mask)
-        if self.norm is not None:
-            output = self.norm(output)
-        return output

braindecode-1.3.1.dev177756420/braindecode/version.py

@@ -1 +0,0 @@
-__version__ = "1.3.1.dev177756420"