braindecode 1.8.1.dev183052608__tar.gz → 1.8.1.dev183240691__tar.gz

{braindecode-1.8.1.dev183052608/braindecode.egg-info → braindecode-1.8.1.dev183240691}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev183052608
+Version: 1.8.1.dev183240691
 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.dev183240691/braindecode/__init__.py

@@ -0,0 +1,53 @@
+import importlib
+from typing import TYPE_CHECKING
+
+from .version import __version__
+
+if TYPE_CHECKING:  # type checkers and IDEs see the classes; runtime uses __getattr__
+    from .classifier import EEGClassifier
+    from .regressor import EEGRegressor
+
+__all__ = [
+    "__version__",
+    "EEGClassifier",
+    "EEGRegressor",
+]
+
+# Subpackages reachable as ``braindecode.<name>`` after a bare ``import braindecode``.
+_SUBMODULES = frozenset(
+    {
+        "augmentation",
+        "classifier",
+        "datasets",
+        "datautil",
+        "eegneuralnet",
+        "functional",
+        "models",
+        "modules",
+        "preprocessing",
+        "regressor",
+        "samplers",
+        "training",
+        "util",
+        "visualization",
+    }
+)
+
+if not TYPE_CHECKING:  # hidden from checkers so misspelled names stay errors
+
+    def __getattr__(name):
+        # PEP 562: skorch, the datasets and the models load on first use.
+        if name == "EEGClassifier":
+            from .classifier import EEGClassifier
+
+            return EEGClassifier
+        if name == "EEGRegressor":
+            from .regressor import EEGRegressor
+
+            return EEGRegressor
+        if name in _SUBMODULES:
+            return importlib.import_module(f".{name}", __name__)
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    def __dir__():
+        return sorted(set(globals()) | set(__all__) | _SUBMODULES)

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/datasets/base.py

@@ -26,6 +26,7 @@ from itertools import chain
 from operator import attrgetter
 from pathlib import Path
 from typing import Any, Generic, Iterable, no_type_check
+from uuid import uuid4
 
 import mne
 import mne.io
@@ -479,14 +480,14 @@ def _zarr_to_memmap(zarr_path, group_name):
     ``SIGBUS`` when workers page-faulted on the unlinked inode.
 
     Under ``N`` concurrent writers, every racer materialises the data
-    into its own per-pid temp file and then tries to publish it; at
+    into its own per-call temp file and then tries to publish it; at
     most one ``os.link`` wins, and the losers silently ``unlink``
     their temp file in a ``finally`` block.  The wasted I/O scales
     with the number of racers; for the workloads braindecode targets
     (a handful of concurrent workers per group) it is negligible.
 
     Crash recovery: if a writer dies mid-run the only debris is a
-    ``<group>.<pid>.tmp.npy`` file.  Such files are namespaced by pid
+    ``<group>.<uuid>.tmp.npy`` file.  Such files are unique per call
     so they can never collide with a live writer, they are never
     read by the fast path, and they do not prevent subsequent
     callers from producing a correct result.  Caches written by
@@ -504,7 +505,10 @@ def _zarr_to_memmap(zarr_path, group_name):
 
     cache_dir.mkdir(parents=True, exist_ok=True)
     arr = zarr.open(zarr_path, mode="r")[group_name]["data"]
-    tmp_path = cache_dir / f"{group_name}.{os.getpid()}.tmp.npy"
+    # Unique per call, not per pid: threads of one process must not share it.
+    # Exclusive creation, not tempfile.mkstemp, which would make it 0600.
+    tmp_path = cache_dir / f"{group_name}.{uuid4().hex}.tmp.npy"
+    tmp_path.open("xb").close()
     try:
         # Write chunk-by-chunk to avoid materialising the whole zarr
         # array in RAM.
@@ -531,9 +535,9 @@ def _zarr_to_memmap(zarr_path, group_name):
             # canonical one; ours is discarded in the finally block.
             pass
     finally:
-        # Always remove our private per-pid temp file.  It is
-        # namespaced by pid so this cannot clobber a concurrent
-        # writer's in-progress tmp file.
+        # Always remove our private per-call temp file.  Its name is
+        # unique per call so this cannot clobber a concurrent writer's
+        # in-progress tmp file.
         try:
             os.unlink(tmp_path)
         except FileNotFoundError:

braindecode-1.8.1.dev183240691/braindecode/models/__init__.py

@@ -0,0 +1,133 @@
+"""Some predefined network architectures for EEG decoding."""
+
+import ast
+import importlib
+from typing import TYPE_CHECKING
+
+_LAZY: dict[str, str]  # public name -> submodule, read below from the imports
+
+# A new model needs one import line here. It gives type checkers the class and,
+# read back at runtime, the lazy name -> submodule map and ``__all__``; so these
+# imports are used although no code names them.
+# ruff: noqa: F401
+if TYPE_CHECKING:
+    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
+    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 .duin import DuIN
+    from .eeg_clip import EEGCLIP
+    from .eegconformer import EEGConformer
+    from .eegdino import EEGDINO
+    from .eeginception_erp import EEGInceptionERP
+    from .eeginception_mi import EEGInceptionMI
+    from .eegitnet import EEGITNet
+    from .eegminer import EEGMiner
+    from .eegnet import EEGNet
+    from .eegnex import EEGNeX
+    from .eegpt import EEGPT
+    from .eegsimpleconv import EEGSimpleConv
+    from .eegsym import EEGSym
+    from .eegtcnet import EEGTCNet
+    from .emg2qwerty import EMG2QwertyNet
+    from .epint import EpiNT
+    from .fbcnet import FBCNet
+    from .fblightconvnet import FBLightConvNet
+    from .fbmsnet import FBMSNet
+    from .gcnsnet import GCNsNet
+    from .guetschel2026 import Guetschel2026
+    from .hybrid import HybridNet
+    from .ifnet import IFNet
+    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
+    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 (
+        SignalJEPA,
+        SignalJEPA_Contextual,
+        SignalJEPA_PostLocal,
+        SignalJEPA_PreLocal,
+    )
+    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,
+        models_mandatory_parameters,
+        positions_from_chs_info,
+    )
+    from .vemg2pose import VEMG2Pose
+    from .zuna import ZUNA
+else:  # hidden from checkers so misspelled names stay errors
+
+    def _type_checking_imports():
+        # ponytail: needs this file's source, as get_summary_table needs summary.csv.
+        with open(__file__, "rb") as source:
+            tree = ast.parse(source.read())
+        block = next(node for node in tree.body if isinstance(node, ast.If))
+        return {alias.name: imp.module for imp in block.body for alias in imp.names}
+
+    # Each submodule is imported on first attribute access (PEP 562), so
+    # ``import braindecode`` does not load every model.
+    _LAZY = _type_checking_imports()
+    __all__ = list(_LAZY)
+
+    def __getattr__(name):
+        if name in _LAZY:
+            value = getattr(importlib.import_module(f".{_LAZY[name]}", __name__), name)
+        elif name in _LAZY.values():
+            value = importlib.import_module(f".{name}", __name__)
+        else:
+            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+        globals()[name] = value
+        return value
+
+    def __dir__():
+        return sorted(set(globals()) | set(__all__))

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/models/config.py

@@ -12,8 +12,6 @@ from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import (
     SigArgName,
     _get_model_class,
-    _init_models_dict,
-    models_dict,
     models_mandatory_parameters,
     resolve_config_type,
 )
@@ -216,9 +214,6 @@ def make_model_config(
 # and define __all__ based on generated classes
 __all__ = ["make_model_config"]
 
-if not models_dict:
-    _init_models_dict()
-
 models_configs: list[type[BaseBraindecodeModelConfig]] = []
 for model_name, req, _ in models_mandatory_parameters:
     model_cls = _get_model_class(model_name)

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/models/eegconformer.py

@@ -7,6 +7,7 @@ import torch
 import torch.nn.functional as F
 from einops.layers.torch import Rearrange
 from torch import Tensor, nn
+from torch.utils.checkpoint import checkpoint
 
 from braindecode.models.base import EEGModuleMixin, _too_short_input_error
 from braindecode.modules import (
@@ -181,6 +182,15 @@ class EEGConformer(EEGModuleMixin, nn.Module):
     activation_transfor: nn.Module
         Activation function as parameter, applied at the FeedForwardBlock module
         inside the transformer. Default is nn.GeLU
+    activation_checkpointing : bool, default=False
+        Recompute the transformer blocks during backward (non-reentrant, RNG
+        preserved) to save training memory at the cost of extra compute.
+        Outputs and gradients were bit-identical to ``False`` in eager tests on
+        PyTorch 2.14.1 CPU. Only eager, gradient-enabled training is
+        checkpointed; the BatchNorm stem is never recomputed. There, hooks
+        (module or global) and buffers inside the transformer raise an error,
+        since recomputation would run them twice. Scripting, tracing, export
+        and compilation require ``False``.
 
     References
     ----------
@@ -193,6 +203,9 @@ class EEGConformer(EEGModuleMixin, nn.Module):
        https://github.com/eeyhsong/EEG-Conformer
     """
 
+    # Old full-object checkpoints restore state without calling __init__.
+    activation_checkpointing = False
+
     def __init__(
         self,
         n_outputs=None,
@@ -213,6 +226,8 @@ class EEGConformer(EEGModuleMixin, nn.Module):
         chs_info=None,
         input_window_seconds=None,
         sfreq=None,
+        *,
+        activation_checkpointing=False,
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -237,6 +252,7 @@ class EEGConformer(EEGModuleMixin, nn.Module):
             )
 
         self.return_features = return_features
+        self.activation_checkpointing = activation_checkpointing
 
         self.patch_embedding = _PatchEmbedding(
             n_filters_time=n_filters_time,
@@ -277,10 +293,24 @@ class EEGConformer(EEGModuleMixin, nn.Module):
 
         self.final_layer = nn.Linear(self.fc.hidden_channels, self.n_outputs)
 
+    def compile(self, *args, **kwargs):
+        # Reject before installing a native compiled call (including estimator
+        # ownership). Explicit disable=True still selects ordinary eager math.
+        if self.activation_checkpointing and not kwargs.get("disable", False):
+            raise RuntimeError("activation_checkpointing requires eager execution")
+        return super().compile(*args, **kwargs)
+
     def forward(self, x: Tensor) -> Tensor:
+        if self.activation_checkpointing:
+            if torch.jit.is_scripting():
+                raise RuntimeError("activation_checkpointing requires eager execution")
+            self._activation_checkpointing_requires_eager_execution()
         x = torch.unsqueeze(x, dim=1)  # add one extra dimension
         x = self.patch_embedding(x)
-        feature = self.transformer(x)
+        if self.activation_checkpointing and self.training and torch.is_grad_enabled():
+            feature = self._checkpoint_transformer(x)
+        else:
+            feature = self.transformer(x)
 
         if self.return_features:
             return feature
@@ -289,6 +319,41 @@ class EEGConformer(EEGModuleMixin, nn.Module):
         x = self.final_layer(x)
         return x
 
+    @torch.jit.unused
+    def _activation_checkpointing_requires_eager_execution(self):
+        if torch.jit.is_tracing() or torch.compiler.is_compiling():
+            raise RuntimeError("activation_checkpointing requires eager execution")
+
+    # torch._dynamo.forbid_in_graph without importing Dynamo: torch.compile
+    # fails here instead of falling back to eager checkpointing.
+    _activation_checkpointing_requires_eager_execution._dynamo_forbidden = True  # type: ignore[attr-defined]
+
+    @torch.jit.unused
+    def _checkpoint_transformer(self, x: Tensor) -> Tensor:
+        from torch.nn.modules import module as global_hooks
+
+        hooks = (
+            "_forward_hooks",
+            "_forward_pre_hooks",
+            "_backward_hooks",
+            "_backward_pre_hooks",
+        )
+        if any(getattr(global_hooks, "_global" + name) for name in hooks):
+            raise RuntimeError(
+                "activation_checkpointing requires pure execution without global hooks"
+            )
+
+        # Recheck: users can attach hooks or replace children after construction.
+        for module in self.transformer.modules():
+            if module._buffers or any(getattr(module, name) for name in hooks):
+                raise RuntimeError(
+                    "activation_checkpointing requires pure transformer blocks "
+                    "without hooks or buffers"
+                )
+        for block in self.transformer:
+            x = checkpoint(block, x, use_reentrant=False, preserve_rng_state=True)
+        return x
+
     def get_fc_size(self):
         try:
             out = self.patch_embedding(torch.ones((1, 1, self.n_chans, self.n_times)))

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/models/labram.py

@@ -1392,11 +1392,7 @@ class _Attention(nn.Module):
         if qkv_bias is not None:
             qkv = qkv + qkv_bias.to(qkv.dtype)  # keep autocast dtype
         qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
-        q, k, v = (
-            qkv[0],
-            qkv[1],
-            qkv[2],
-        )  # make torchscript happy (cannot use tensor as tuple) (B, H, N, C)
+        q, k, v = qkv.unbind(0)  # (B, H, N, C); TorchScript cannot unpack qkv
         if self.q_norm is not None:
             q = self.q_norm(q).type_as(v)
         if self.k_norm is not None:

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/models/luna.py

@@ -594,16 +594,15 @@ 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."""
+    def _rotary_tables(self, tensor: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """Build RoPE tables for one forward; no cache, the frequencies may train."""
         seq_len = tensor.shape[-2]
         positions = torch.arange(seq_len, device=tensor.device, dtype=tensor.dtype)
         freqs = self.rotary_emb(positions)
 
         # Keep the full-head reshape (including its empty-input boundary).
         tensor.reshape(list(tensor.shape[:-1]) + [-1, 2])
-        transformed = apply_rotary(tensor, freqs.cos(), freqs.sin())
-        return transformed.to(tensor.dtype)
+        return freqs.cos(), freqs.sin()
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         B, N, C = x.shape
@@ -615,8 +614,9 @@ class _RotarySelfAttentionBlock(nn.Module):
         # unbind, not qkv[0..2]: the backward of three selects writes three
         # zero-filled copies of the whole qkv tensor and sums them.
         q, k, v = qkv.unbind(0)
-        q = self._rotate_queries_or_keys(q)
-        k = self._rotate_queries_or_keys(k)
+        cos, sin = self._rotary_tables(q)  # k has the shape of q
+        q = apply_rotary(q, cos, sin).to(q.dtype)
+        k = apply_rotary(k, cos, sin).to(k.dtype)
         attn = F.scaled_dot_product_attention(
             q,
             k,

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/models/util.py

@@ -5,6 +5,7 @@
 # License: BSD (3-clause)
 import inspect
 import math
+import sys
 import warnings
 from collections.abc import Callable as CallableABC
 from copy import deepcopy
@@ -12,6 +13,7 @@ from functools import lru_cache, wraps
 from pathlib import Path
 from types import SimpleNamespace
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -26,10 +28,8 @@ from typing import (
 
 import mne
 import numpy as np
-import pandas as pd
 import torch  # noqa: F401  # exposed so TorchScript can resolve ``torch`` through the BatchNorm-guard wrapper's __globals__
 from mne.io.constants import FIFF
-from sklearn.metrics import pairwise_distances_argmin
 from torch import nn
 from torchaudio.transforms import Resample
 
@@ -49,7 +49,27 @@ _KIND_TO_CH_TYPE = {
 INTRACRANIAL_CH_TYPES = frozenset({"seeg", "dbs", "ecog"})
 
 
-models_dict = {}
+# Read through ``models_dict`` (module ``__getattr__`` below), which fills it on
+# first access so importing braindecode does not import every model.
+_models_dict: dict[str, Any] = {}
+# Annotations only, for type checkers; the values come from ``__getattr__``.
+models_dict: dict[str, Any]
+_summary_table: "pd.DataFrame"
+
+if TYPE_CHECKING:
+    import pandas as pd
+else:  # hidden from checkers so misspelled names stay errors
+
+    def __getattr__(name):
+        if name == "models_dict":
+            if not _models_dict:
+                _init_models_dict()
+            return _models_dict
+        if name == "_summary_table":  # read summary.csv once, on first access
+            table = globals()[name] = get_summary_table()
+            return table
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 # Resolve serialized classes by exact lookup, never by importing a config path.
 # Include public aliases and the defining paths emitted by get_config().
@@ -261,14 +281,18 @@ def resolve_type_kwargs(cls, kwargs):
 
 
 def _init_models_dict():
-    import braindecode.models as models
+    from braindecode import models
+    from braindecode.models.base import EEGModuleMixin
 
-    for m in inspect.getmembers(models, inspect.isclass):
-        if (
-            issubclass(m[1], models.base.EEGModuleMixin)
-            and m[1] != models.base.EEGModuleMixin
-        ):
-            models_dict[m[0]] = m[1]
+    # Plain getattr over every public name: a model that fails to import raises here.
+    found = {}
+    for name in sorted(models._LAZY):
+        obj = getattr(models, name)
+        is_model = inspect.isclass(obj) and issubclass(obj, EEGModuleMixin)
+        if is_model and obj is not EEGModuleMixin:
+            found[name] = obj
+    # One update() publishes every entry at once, so no thread sees a partial dict.
+    _models_dict.update(found)
 
 
 def _get_model_class(model_name: str):
@@ -292,10 +316,9 @@ def _get_model_class(model_name: str):
     ValueError
         If ``model_name`` is not a registered model.
     """
-    if not models_dict:
-        _init_models_dict()
-    if model_name in models_dict:
-        return models_dict[model_name]
+    registry = sys.modules[__name__].models_dict  # also honours a patched models_dict
+    if model_name in registry:
+        return registry[model_name]
     raise ValueError(f"Unknown model name {model_name!r}.")
 
 
@@ -897,6 +920,8 @@ def get_summary_table(dir_name=None):
 
     path = dir_path / "summary.csv"
 
+    import pandas as pd
+
     df = pd.read_csv(
         path,
         header=0,
@@ -1095,6 +1120,8 @@ def resolve_channel_indices(
     if not np.isfinite(norms).all() or np.any(norms <= 1e-7):
         return None
     directions = radial / norms
+    from sklearn.metrics import pairwise_distances_argmin
+
     nearest = pairwise_distances_argmin(
         directions[: len(locations)], directions[len(locations) :], metric=metric
     )
@@ -1274,6 +1301,3 @@ def channel_types_from_chs_info(
         else:
             types.append("unknown")
     return types
-
-
-_summary_table = get_summary_table()

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691}/braindecode/util.py

@@ -12,7 +12,6 @@ import h5py
 import mne
 import numpy as np
 import torch
-from sklearn.utils import check_random_state
 from torch import Tensor
 
 
@@ -299,6 +298,8 @@ def create_mne_dummy_raw(
     save_fname : dict | None
         Dictionary containing the name the raw data was saved to.
     """
+    from sklearn.utils import check_random_state
+
     random_state = check_random_state(random_state)
     data = random_state.rand(n_channels, n_times)
     ch_names = [f"ch{i}" for i in range(n_channels)]

braindecode-1.8.1.dev183240691/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "1.8.1.dev183240691"

{braindecode-1.8.1.dev183052608 → braindecode-1.8.1.dev183240691/braindecode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev183052608
+Version: 1.8.1.dev183240691
 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.dev183052608 → braindecode-1.8.1.dev183240691}/docs/whats_new.rst

@@ -28,6 +28,39 @@ Current 1.8.1 (2026-08-31)
 Enhancements
 ============
 
+- ``import braindecode`` and ``import braindecode.models`` no longer import
+  every model, the estimators, scikit-learn and pandas up front: the model
+  classes, :class:`braindecode.EEGClassifier`, :class:`~braindecode.EEGRegressor`,
+  the subpackages and ``models_dict`` load on first access (PEP 562 module
+  ``__getattr__``), with the same names, ``__all__`` and model registry. On
+  CPU with torch 2.14.1, ``import braindecode`` took 5 ms instead of 3.1 s and
+  ``from braindecode.models import EEGNet`` 1.6 s instead of 3.1 s. A new model
+  needs one import line, in the ``if TYPE_CHECKING:`` block of
+  ``braindecode/models/__init__.py``, as the new-model checklist says (by
+  `Bruno Aristimunha`_).
+- :class:`braindecode.models.LUNA` reuses differentiable rotary tables within
+  each attention forward (no persistent cache); :class:`braindecode.models.Labram`
+  splits its fused qkv projection with ``unbind`` instead of three selects.
+  Parameters, checkpoint keys and numerical computations are preserved; LUNA
+  trainable-frequency gradients can differ by floating-point accumulation
+  rounding, and rotary-module hooks run once rather than twice per forward
+  (by `Bruno Aristimunha`_).
+- :class:`braindecode.models.EEGConformer` takes the opt-in, keyword-only
+  ``activation_checkpointing=False``: non-reentrant activation checkpointing
+  recomputes pure transformer blocks during backward with RNG preservation.
+  Outputs, gradients and an optimizer step were bit-identical to checkpointing
+  off in eager tests on PyTorch 2.14.1 CPU; old pickled models still load.
+  Checkpointing requires eager execution; unsupported configurations are
+  explicitly rejected (see the parameter documentation). On an Intel Xeon
+  Gold 6230R CPU with four PyTorch/BLAS threads,
+  FP32, embedding dimension 64, eight heads, six layers and dropout, five paired
+  fresh processes at input shape ``[8, 22, 8192]`` measured 55.39% lower peak
+  process RSS (median paired ratio 0.446142) and 73.14% extra train-step time
+  (median paired ratio 1.731425) at equal batch. The largest passing integer
+  batch under a 4 GiB peak process RSS budget increased from 17 to 68 in a
+  fresh-process capacity search; this machine/runtime-qualified, one-run
+  boundary is a memory-capacity result, not an equal-batch speed improvement
+  (by `Bruno Aristimunha`_).
 - Add :func:`braindecode.training.iter_trial_predictions`,
   :func:`~braindecode.training.iter_trial_prediction_chunks` and
   :class:`~braindecode.training.TrialPredictionChunk` to stream cropped
@@ -524,6 +557,9 @@ Requirements
 Bug fixes
 ==========
 
+- Zarr cache creation reserves a unique temporary file per call (exclusive
+  creation), so threads of one process no longer share one; permissions and
+  existing caches are unchanged (by `Bruno Aristimunha`_).
 - :class:`braindecode.training.PostEpochTrainScoring` restores the saved CPU
   Torch RNG state even when its reevaluation fails (by `Bruno Aristimunha`_).
 - :class:`braindecode.modules.FilterBankLayer`, and so :class:`braindecode.models.FBCNet`, :class:`braindecode.models.FBMSNet`, :class:`braindecode.models.FBLightConvNet` and :class:`braindecode.models.IFNet`, script again with PyTorch 2.15, where ``torch.jit.script`` failed inside :func:`torchaudio.functional.lfilter` ("Expression of type dots cannot be used in a type expression"). Eager filtering still calls torchaudio; the scripted graph runs the same operations as before, so outputs are unchanged (:gh:`1501` by `Bruno Aristimunha`_).

braindecode-1.8.1.dev183052608/braindecode/__init__.py

@@ -1,9 +0,0 @@
-from .classifier import EEGClassifier
-from .regressor import EEGRegressor
-from .version import __version__
-
-__all__ = [
-    "__version__",
-    "EEGClassifier",
-    "EEGRegressor",
-]