braindecode 1.8.1.dev172484635__tar.gz → 1.8.1.dev172569382__tar.gz

{braindecode-1.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/NOTICE.txt

@@ -13,9 +13,10 @@ The following components are licensed under the Creative Commons Attribution-Non
 
 - `braindecode/models/eegminer.py`
 - `braindecode/models/meta_neuromotor.py`
+- `braindecode/models/sleepfm.py`
 - `braindecode/models/brainmodule.py`
-
-As well as class later imported into the `braindecode.models.module` named as GeneralizedGaussianFilter.
+- `braindecode/models/neurorvq.py`
+- `braindecode/models/neurorvq_tokenizer.py`
 
 The `meta_neuromotor.py` file is a derivative of
 `facebookresearch/generic-neuromotor-interface`, released by Meta Platforms,
@@ -44,15 +45,28 @@ The following components are licensed under the MIT License:
 - `braindecode/models/ifnet.py`
 - `braindecode/models/mirepnet.py`
 - `braindecode/models/popt.py`
+- `braindecode/models/tfm_tokenizer.py`
 - `braindecode/modules/popt_modules.py`
+- `braindecode/models/brainomni.py`
+- `braindecode/modules/quantization.py`
+- `braindecode/models/seizure_transformer.py`
+- `docs/_static/model/seizure_transformer_arch.png`
+- `braindecode/models/tmsanet.py`
+
+The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
+SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The
+`quantization.py` module holds the residual vector quantization derived from
+`lucidrains/vector-quantize-pytorch` (MIT) and the BrainOmni port.
 
 ### Apache-2.0 Licensed Files
 
 The following components are licensed under the Apache License 2.0:
 
+- `braindecode/models/axon.py`
 - `braindecode/models/mvpformer.py`
 - `braindecode/models/zuna.py`
 - `braindecode/models/luna.py`
+- `braindecode/models/mapa.py`
 - `braindecode/models/brant.py`
 - `braindecode/models/diver1.py`
 - `braindecode/models/mscformer.py`

{braindecode-1.8.1.dev172484635/braindecode.egg-info → braindecode-1.8.1.dev172569382}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev172484635
+Version: 1.8.1.dev172569382
 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.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/braindecode/classifier.py

@@ -212,11 +212,12 @@ class EEGClassifier(_EEGNeuralNet, NeuralNetClassifier):
             the number of predictions depend on the chosen window size and the
             receptive field of the network. If trials have different lengths,
             a list with one (n_classes x n_predictions) array per trial.
-        trial_targets : np.ndarray
-            Ground-truth targets from the dataset in a 2-dimensional array
-            (n_trials x n_targets). Only returned when ``return_targets=True``.
-            The number of targets depends on the decoding paradigm and can be
-            either a single value, multiple values, or a sequence.
+        trial_targets : np.ndarray | list of np.ndarray
+            Ground-truth targets from the dataset. Only returned when
+            ``return_targets=True``. An ``np.ndarray`` with a leading trial
+            dimension: ``(n_trials,)`` for scalar targets, with further
+            dimensions for multi-value or equal-length sequence targets. If
+            trial lengths differ, a list with one target array per trial.
         """
         if not self.cropped:
             warnings.warn(

{braindecode-1.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/braindecode/eegneuralnet.py

@@ -144,7 +144,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
             i_window_in_trials.append(i[0].cpu().numpy())
             i_window_stops.append(i[2].cpu().numpy())
             with torch.no_grad():
-                preds.append(to_numpy(self.module_.forward(X.to(self.device))))
+                preds.append(to_numpy(self.module_(X.to(self.device))))
             window_ys.append(y.cpu().numpy())
         preds = np.concatenate(preds)
         i_window_in_trials = np.concatenate(i_window_in_trials)

{braindecode-1.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/braindecode/functional/__init__.py

@@ -11,6 +11,7 @@ from .functions import (
     rotate_pairs,
     safe_log,
     sinusoidal_positional_encoding,
+    spectral_input,
     square,
     wavelet_decomposition,
 )
@@ -29,6 +30,7 @@ __all__ = [
     "rotate_pairs",
     "safe_log",
     "sinusoidal_positional_encoding",
+    "spectral_input",
     "square",
     "wavelet_decomposition",
     "glorot_weight_zero_bias",

{braindecode-1.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/braindecode/functional/functions.py

@@ -28,6 +28,32 @@ def identity(x):
     return x
 
 
+def spectral_input(x: torch.Tensor) -> torch.Tensor:
+    """Prepare ``x`` for an FFT, STFT or eigendecomposition.
+
+    PyTorch has no complex bfloat16 dtype: CPU and MPS FFTs reject
+    bfloat16/float16, and Intel Gaudi (HPU) has no complex tensors at all.
+    This returns ``x`` in at least float32, moved to the CPU when it lives on
+    an HPU; float32/float64 CPU/CUDA inputs are returned as they are. Cast a
+    real result back with ``.to(x)`` (the input's dtype and device)::
+
+        spectrum = torch.fft.rfft(spectral_input(x), dim=-1).abs().to(x)
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Real input of the spectral operation.
+
+    Returns
+    -------
+    torch.Tensor
+        ``x`` in ``promote_types(x.dtype, float32)``, on the CPU for HPU inputs.
+    """
+    if x.device.type == "hpu":
+        x = x.cpu()
+    return x.to(torch.promote_types(x.dtype, torch.float32))
+
+
 def drop_path(
     x, drop_prob: float = 0.0, training: bool = False, scale_by_keep: bool = True
 ):
@@ -176,8 +202,7 @@ def hilbert_freq(x: torch.Tensor, forward_fourier: bool = True) -> torch.Tensor:
     # the complex-valued part in float32 and restore the real-valued contract
     # at the boundary.  Promoting before the FFT also covers backends that do
     # not implement bfloat16 FFT kernels.
-    if input_dtype == torch.bfloat16:
-        x = x.float()
+    x = spectral_input(x)
 
     if forward_fourier:
         seq_len = x.shape[-1]
@@ -435,7 +460,12 @@ def wavelet_decomposition(
     return out.reshape(*leading, -1)
 
 
-def sinusoidal_positional_encoding(n_positions: int, dim: int) -> torch.Tensor:
+def sinusoidal_positional_encoding(
+    n_positions: int,
+    dim: int,
+    device: torch.device | None = None,
+    dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
     r"""Fixed sine/cosine positional-encoding table of shape ``(n_positions, dim)``.
 
     The standard encoding of Vaswani et al. (2017): for position :math:`p` and
@@ -452,6 +482,10 @@ def sinusoidal_positional_encoding(n_positions: int, dim: int) -> torch.Tensor:
         Number of positions (sequence length) to encode.
     dim : int
         Embedding dimension of each position.
+    device : torch.device or None
+        Device of the table (default: CPU), for tables built inside ``forward``.
+    dtype : torch.dtype
+        Floating dtype the table is computed in.
 
     Returns
     -------
@@ -460,11 +494,12 @@ def sinusoidal_positional_encoding(n_positions: int, dim: int) -> torch.Tensor:
         dropout, or offset.
     """
     dim_even = dim + (dim % 2)
-    position = torch.arange(n_positions).unsqueeze(1).float()
+    position = torch.arange(n_positions, device=device).unsqueeze(1).to(dtype)
     div_term = torch.exp(
-        torch.arange(0, dim_even, 2).float() * (-math.log(10000.0) / dim_even)
+        torch.arange(0, dim_even, 2, device=device).to(dtype)
+        * (-math.log(10000.0) / dim_even)
     )
-    pe = torch.zeros(n_positions, dim_even)
+    pe = torch.zeros(n_positions, dim_even, device=device, dtype=dtype)
     pe[:, 0::2] = torch.sin(position * div_term)
     pe[:, 1::2] = torch.cos(position * div_term)
     # ``.contiguous()`` so an odd-``dim`` truncation owns tight storage -- a

{braindecode-1.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/braindecode/models/__init__.py

@@ -3,22 +3,26 @@
 from .atcnet import ATCNet
 from .attentionbasenet import AttentionBaseNet
 from .attn_sleep import AttnSleep
+from .axon import AXON
 from .barista import BaRISTA
 from .base import EEGModuleMixin
-from .bendr import BENDR, InterpolatedBENDR
-from .biot import BIOT, InterpolatedBIOT
+from .bendr import BENDR
+from .biot import BIOT
 from .brainbert import BrainBERT
 from .brainmodule import BrainModule
+from .brainomni import BrainOmni, BrainTokenizer
 from .brant import Brant
 from .cbramod import CBraMod
 from .codebrain import CodeBrain
 from .contrawr import ContraWR
+from .csbrain import CSBrain
 from .ctnet import CTNet
 from .dance import DANCE
 from .deep4 import Deep4Net
 from .deepsleepnet import DeepSleepNet
 from .dgcnn import DGCNN
 from .diver1 import DIVER1
+from .eeg_clip import EEGCLIP
 from .eegconformer import EEGConformer
 from .eegdino import EEGDINO
 from .eeginception_erp import EEGInceptionERP
@@ -27,7 +31,7 @@ from .eegitnet import EEGITNet
 from .eegminer import EEGMiner
 from .eegnet import EEGNet
 from .eegnex import EEGNeX
-from .eegpt import EEGPT, InterpolatedEEGPT
+from .eegpt import EEGPT
 from .eegsimpleconv import EEGSimpleConv
 from .eegsym import EEGSym
 from .eegtcnet import EEGTCNet
@@ -37,9 +41,9 @@ from .fblightconvnet import FBLightConvNet
 from .fbmsnet import FBMSNet
 from .hybrid import HybridNet
 from .ifnet import IFNet
-from .interpolated import InterpolatedModel
-from .labram import InterpolatedLaBraM, Labram
+from .labram import Labram
 from .luna import LUNA
+from .mapa import MAPA
 from .medformer import MEDFormer
 from .meta_neuromotor import MetaNeuromotorHand
 from .mirepnet import MIRepNet
@@ -47,14 +51,16 @@ from .mscformer import MSCFormer
 from .msvtnet import MSVTNet
 from .mvpformer import MVPFormer
 from .neuropose import NeuroPose
+from .neurorvq import NeuroRVQ
+from .neurorvq_tokenizer import NeuroRVQTokenizer
 from .patchedtransformer import PBT
 from .popt import PopulationTransformer
 from .reve import REVE
 from .sccnet import SCCNet
+from .seizure_transformer import SeizureTransformer
 from .sensingdynamics import SensingDynamics
 from .shallow_fbcsp import ShallowFBCSPNet
 from .signal_jepa import (
-    InterpolatedSignalJEPA,
     SignalJEPA,
     SignalJEPA_Contextual,
     SignalJEPA_PostLocal,
@@ -63,20 +69,22 @@ from .signal_jepa import (
 from .sinc_shallow import SincShallowNet
 from .sleep_stager_blanco_2020 import SleepStagerBlanco2020
 from .sleep_stager_chambon_2018 import SleepStagerChambon2018
+from .sleepfm import SleepFM, SleepFMStager
 from .sparcnet import SPARCNet
 from .sstdpn import SSTDPN
 from .steegformer import STEEGFormer
 from .syncnet import SyncNet
 from .tcformer import TCFormer
 from .tcn import BDTCN, TCN
+from .tfm_tokenizer import TFMTokenizer, TFMTokenizerOutput
 from .tidnet import TIDNet
+from .tmsanet import TMSANet
 from .tsinception import TSception
 from .usleep import USleep
 from .util import (
     _init_models_dict,
     build_model_config,
     extract_channel_locations_from_chs_info,
-    interpolated_models_dict,
     models_mandatory_parameters,
     positions_from_chs_info,
 )
@@ -89,6 +97,7 @@ _init_models_dict()
 
 __all__ = [
     "ATCNet",
+    "AXON",
     "AttnSleep",
     "AttentionBaseNet",
     "BaRISTA",
@@ -96,9 +105,12 @@ __all__ = [
     "BIOT",
     "BENDR",
     "BrainBERT",
+    "BrainOmni",
+    "BrainTokenizer",
     "CBraMod",
     "CodeBrain",
     "ContraWR",
+    "CSBrain",
     "CTNet",
     "DANCE",
     "Deep4Net",
@@ -106,10 +118,10 @@ __all__ = [
     "DIVER1",
     "BrainModule",
     "Brant",
+    "EEGCLIP",
     "EEGConformer",
     "EEGDINO",
     "EEGPT",
-    "InterpolatedEEGPT",
     "EEGInceptionERP",
     "EEGInceptionMI",
     "EEGITNet",
@@ -130,24 +142,23 @@ __all__ = [
     "MetaNeuromotorHand",
     "HybridNet",
     "IFNet",
-    "InterpolatedBENDR",
-    "InterpolatedBIOT",
-    "InterpolatedLaBraM",
-    "InterpolatedModel",
-    "InterpolatedSignalJEPA",
     "Labram",
     "LUNA",
     "extract_channel_locations_from_chs_info",
     "positions_from_chs_info",
+    "MAPA",
     "MEDFormer",
     "MIRepNet",
+    "NeuroRVQ",
     "MSCFormer",
+    "NeuroRVQTokenizer",
     "MSVTNet",
     "MVPFormer",
     "PBT",
     "PopulationTransformer",
     "REVE",
     "SCCNet",
+    "SeizureTransformer",
     "ShallowFBCSPNet",
     "SignalJEPA",
     "SignalJEPA_Contextual",
@@ -155,20 +166,24 @@ __all__ = [
     "SignalJEPA_PreLocal",
     "SincShallowNet",
     "SSTDPN",
+    "SleepFM",
+    "SleepFMStager",
     "SleepStagerBlanco2020",
     "SleepStagerChambon2018",
     "SPARCNet",
     "STEEGFormer",
     "SyncNet",
     "BDTCN",
+    "TFMTokenizer",
+    "TFMTokenizerOutput",
     "TCFormer",
     "TCN",
     "TIDNet",
+    "TMSANet",
     "TSception",
     "USleep",
     "ZUNA",
     "build_model_config",
     "_init_models_dict",
     "models_mandatory_parameters",
-    "interpolated_models_dict",
 ]

{braindecode-1.8.1.dev172484635 → braindecode-1.8.1.dev172569382}/braindecode/models/attn_sleep.py

@@ -436,7 +436,6 @@ class _MultiHeadedAttention(nn.Module):
         h = int(h)
         self.d_per_head = d_model // h
         self.h = h
-        self.attn = torch.empty(0)
 
         base_conv = CausalConv1d(
             in_channels=after_reduced_cnn_size,
@@ -471,9 +470,6 @@ class _MultiHeadedAttention(nn.Module):
         # recompute the weighted sum with dropped weights
         x = torch.matmul(attn, value)
 
-        # stash the pre‑dropout weights if you need them
-        self.attn = attn_weights
-
         # merge heads and project
         x = x.transpose(1, 2).contiguous().view(nbatches, -1, self.h * self.d_per_head)