braindecode 1.8.1.dev168929986__tar.gz → 1.8.1.dev169077960__tar.gz

{braindecode-1.8.1.dev168929986/braindecode.egg-info → braindecode-1.8.1.dev169077960}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev168929986
+Version: 1.8.1.dev169077960
 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.dev169077960/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.dev168929986 → braindecode-1.8.1.dev169077960}/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
@@ -343,6 +344,9 @@ def _read_fif_window(raw, start, stop, willneed=False):
     return np.multiply(picked, raw._cals[:, np.newaxis], order="C")
 
 
+_COALESCED_MAX_BYTES = 2 * 1024 * 1024
+
+
 def _window_info(crop_inds, sfreq):
     """Extract window size from crop indices.
 
@@ -479,14 +483,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 +508,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 +538,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:
@@ -953,6 +960,10 @@ class EEGWindowsDataset(_ZarrMixin, RecordDataset):
                 X = self.raw._getitem(
                     (slice(None), slice(i_start, i_stop)), return_times=False
                 )
+        return self._finish_window(index, crop_inds, X)
+
+    def _finish_window(self, index, crop_inds, X):
+        """Item ``index`` from its raw samples ``X``, copied before the transform."""
         X = np.array(X, dtype="float32")
         if self.transform is not None:
             X = self.transform(X)
@@ -1344,11 +1355,24 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         Optional function to call on targets before returning them.
     lazy : bool, default False
         If True, defer computing cumulative sizes until length or item access.
+    coalesce_reads : bool, default False
+        Opt in to reading a :class:`~torch.utils.data.DataLoader` batch of
+        consecutive, overlapping windows of one lazy (``preload=False``) FIF
+        recording as one union of samples instead of one read per window.
+        Only a batch of consecutive ascending indices into one
+        :class:`~braindecode.datasets.EEGWindowsDataset` (not a subclass)
+        whose union is at most a third of the summed window samples and at
+        most 2 MiB as float64 is read this way; every other batch takes the
+        default path. Outputs, order and random number use equal the
+        default's. It was faster only for heavily overlapping windows and
+        slower for some other layouts (numbers in :ref:`whats_new`), so it is off
+        by default. Containers returned by ``split`` default to ``False``.
     """
 
     plot = _viewer_plot  # eegdash-viewer embed; a direct member so the API docs list it
 
     datasets: list[T]
+    coalesce_reads: bool = False  # default for pickles made before this option
 
     def __init__(
         self,
@@ -1358,6 +1382,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         target_transform: Callable | None = None,
         *,
         lazy: bool = False,
+        coalesce_reads: bool = False,
     ):
         # Adapted from torch.utils.data.ConcatDataset:
         # added lazy init to defer cumulative size computation until access,
@@ -1387,6 +1412,9 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
 
         self.target_transform = target_transform
         self._lazy = lazy
+        if type(coalesce_reads) is not bool:
+            raise TypeError("coalesce_reads must be a bool.")
+        self.coalesce_reads = coalesce_reads
 
     @property
     def cumulative_sizes(self) -> list[int]:
@@ -1454,6 +1482,10 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         another: on a network file system a batch read from cold files then
         costs about one round trip, not one per window.
         """
+        if self.coalesce_reads:
+            coalesced = self._get_coalesced_items(indices)
+            if coalesced is not None:
+                return coalesced
         # ponytail: advises the whole batch at once; chunk it if a batch's
         # windows ever outgrow the page cache
         if hasattr(os, "posix_fadvise"):
@@ -1466,6 +1498,52 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                     _read_fif_window(ds.raw, start, stop, willneed=True)
         return [self[idx] for idx in indices]
 
+    def _get_coalesced_items(self, indices):
+        """The items cut from one read of their union, or None if not eligible."""
+        n = len(indices)
+        if (
+            type(self) is not BaseConcatDataset  # subclasses may override items
+            or n < 2
+            or type(indices[0]) is not int
+            or indices[0] < 0
+            or indices != list(range(indices[0], indices[0] + n))
+        ):
+            return None
+        sizes = self._ensure_cumulative_sizes()
+        k = bisect.bisect_right(sizes, indices[0])
+        if k == len(sizes) or indices[-1] >= sizes[k]:
+            return None  # past the end, or across recordings
+        ds = self.datasets[k]
+        if (
+            type(ds) is not EEGWindowsDataset
+            or ds._zarr_data is not None
+            or not isinstance(ds.crop_inds, np.ndarray)  # lazy metadata
+            or ds.raw.preload
+        ):
+            return None
+        first = indices[0] - (sizes[k - 1] if k else 0)
+        crops = ds.crop_inds[first : first + n]
+        start, stop = int(crops[:, 1].min()), int(crops[:, 2].max())
+        if (
+            start < 0
+            or stop > ds.raw.n_times
+            or (crops[:, 2] <= crops[:, 1]).any()
+            or 3 * (stop - start) > (crops[:, 2] - crops[:, 1]).sum()
+            or (stop - start) * ds.raw.info["nchan"] * 8 > _COALESCED_MAX_BYTES
+        ):
+            return None
+        union = _read_fif_window(ds.raw, start, stop)
+        if union is None:
+            return None
+        items = []
+        for i, crop in enumerate(crops.tolist(), first):
+            X = union[:, crop[1] - start : crop[2] - start]
+            item = ds._finish_window(i, crop, X)
+            if self.target_transform is not None:
+                item = item[:1] + (self.target_transform(item[1]),) + item[2:]
+            items.append(item)
+        return items
+
     def __getitem__(self, idx: int | list):
         """
         ---
@@ -1583,15 +1661,17 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 df = ds._windows.metadata
             else:
                 df = ds.metadata
+            # a dataset built without description has description None
+            description = ds.description if ds.description is not None else {}
             if (
                 "i_trial_in_dataset" in df.columns
-                and "i_trial_in_dataset" in ds.description
+                and "i_trial_in_dataset" in description
             ):
                 raise ValueError(
                     "Dataset descriptions cannot contain the reserved window "
                     "metadata key 'i_trial_in_dataset'."
                 )
-            if "i_dataset" in df.columns or "i_dataset" in ds.description:
+            if "i_dataset" in df.columns or "i_dataset" in description:
                 raise ValueError(
                     "Window metadata and dataset descriptions cannot contain the "
                     "key 'i_dataset', which get_metadata() reserves for the "
@@ -1607,7 +1687,8 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             if isinstance(df, pd.DataFrame):
                 # copy so the description columns stay out of the dataset
                 df = df.copy()
-            for k, v in ds.description.items():
+            description = ds.description if ds.description is not None else {}
+            for k, v in description.items():
                 df[k] = v
             df["i_dataset"] = i_ds
             all_dfs.append(df)

braindecode-1.8.1.dev169077960/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.dev168929986 → braindecode-1.8.1.dev169077960}/braindecode/models/base.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import functools
 import inspect
 import json
+import logging
 import warnings
 from collections import OrderedDict
 from pathlib import Path, PurePosixPath, PureWindowsPath
@@ -35,6 +36,7 @@ huggingface_hub = _soft_import(
 )
 
 HAS_HF_HUB = huggingface_hub is not False
+log = logging.getLogger(__name__)
 
 # __init__ args that from_pretrained fills from config.json when not given.
 _GEOMETRY_KWARGS = (
@@ -61,6 +63,26 @@ def _validate_weights_filename(filename):
         raise ValueError("filename must be a relative weight path without traversal")
 
 
+def _load_card_data(pretrained_model_name_or_path, **kwargs):
+    """Metadata of a checkpoint's model card (``README.md``), or None.
+
+    Best effort: the card is informational, so a missing or unreadable card
+    (offline, no README, bad YAML) never blocks loading the weights.
+    """
+    keys = ("revision", "cache_dir", "force_download", "token", "local_files_only")
+    try:
+        card = Path(pretrained_model_name_or_path) / "README.md"
+        if not card.parent.is_dir():
+            card = huggingface_hub.hf_hub_download(
+                str(pretrained_model_name_or_path),
+                "README.md",
+                **{k: kwargs[k] for k in keys if k in kwargs},
+            )
+        return huggingface_hub.ModelCard.load(card, ignore_metadata_errors=True).data
+    except Exception:
+        return None
+
+
 def _local_weights_path(model_id, filename):
     """Reject local weight paths (including symlinks) outside the model folder."""
     root = Path(model_id).resolve()
@@ -212,6 +234,11 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
     there will be an attempt to infer them from the other parameters.
     """
 
+    #: Hub model card metadata (:class:`huggingface_hub.ModelCardData`) of the
+    #: checkpoint, set by :meth:`from_pretrained` when the card can be read,
+    #: e.g. ``model.card_data.datasets`` lists the data the weights saw.
+    card_data = None
+
     #: Template for model-specific Hub integration notes appended by
     #: ``__init_subclass__``.  ``{name}`` is replaced with the concrete
     #: model class name.
@@ -234,10 +261,11 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         model = {name}(n_chans=22, n_outputs=4, n_times=1000)
         # ... training code ...
 
-        # Push to the Hub
+        # Push to the Hub; ``datasets`` and ``base_model`` go to the card
         model.push_to_hub(
             repo_id="username/my-{name_lower}-model",
             commit_message="Initial model upload",
+            model_card_kwargs={{"datasets": ["BNCI2014_001"]}},
         )
 
     **Loading a model from the Hub:**
@@ -248,6 +276,8 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
 
         # Load pretrained model
         model = {name}.from_pretrained("username/my-{name_lower}-model")
+        # Data the weights were trained on, from the Hub model card
+        print(model.card_data.datasets if model.card_data else None)
 
         # Load with a different number of outputs (head is rebuilt automatically)
         model = {name}.from_pretrained("username/my-{name_lower}-model", n_outputs=4)
@@ -1015,7 +1045,26 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                 kwargs.setdefault("chs_info", None)
             if "n_times" in kwargs or "sfreq" in kwargs:
                 kwargs.setdefault("input_window_seconds", None)
-            return super().from_pretrained(*args, **kwargs)
+            model = super().from_pretrained(*args, **kwargs)
+            card_data = _load_card_data(*args, **kwargs)
+            if card_data is not None:
+                model.card_data = card_data
+                if card_data.datasets:
+                    log.info(
+                        "%s weights were trained on (model card): %s",
+                        cls.__name__,
+                        card_data.datasets,
+                    )
+            return model
+
+        def generate_model_card(self, *args, **kwargs):
+            # ``model_card_kwargs`` only fill the card's Jinja template; also
+            # write these two to its YAML header so the Hub indexes them.
+            card = super().generate_model_card(*args, **kwargs)
+            for key in ("datasets", "base_model"):
+                if key in kwargs:
+                    setattr(card.data, key, kwargs[key])
+            return card
 
         @classmethod
         def _from_pretrained(

{braindecode-1.8.1.dev168929986 → braindecode-1.8.1.dev169077960}/braindecode/models/bendr.py

@@ -1,5 +1,6 @@
 # Authors: Bruno Aristimunha <b.aristimunha@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
+#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -569,8 +570,9 @@ class _BENDRContextualizer(nn.Module):
             [copy.deepcopy(encoder_layer) for _ in range(layers)]
         )
 
-        # Add final LayerNorm after all transformer layers (paper specification)
-        self.norm = nn.LayerNorm(self.transformer_dim)
+        # Retained for compatibility with released state dicts. The original
+        # contextualizer defines this norm but does not apply it in forward.
+        self.norm = nn.LayerNorm(self.transformer_dim).requires_grad_(False)
 
         # --- Output Layer --- (Project back down to in_features)
         # Paper uses Conv1d with kernel=1 (equivalent to Linear but expects (B,C,T) input)
@@ -630,10 +632,6 @@ class _BENDRContextualizer(nn.Module):
                 x = layer(x)
         # x: [seq_len + 1, batch_size, transformer_dim]
 
-        # Apply final LayerNorm (T-Fixup: norm only at the end)
-        x = self.norm(x)
-        # x: [seq_len + 1, batch_size, transformer_dim]
-
         # Permute to (B, C, T) format for Conv1d output layer
         x = x.permute(1, 2, 0)
         # x: [batch_size, transformer_dim, seq_len + 1]

{braindecode-1.8.1.dev168929986 → braindecode-1.8.1.dev169077960}/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.dev168929986 → braindecode-1.8.1.dev169077960}/braindecode/models/luna.py

@@ -14,6 +14,7 @@ the LICENSE Of this file is APACHE-2.0.
 """
 
 import math
+import warnings
 from functools import partial
 from typing import Any, Dict, Optional, Tuple, Type
 
@@ -146,7 +147,6 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
         input_window_seconds: Optional[float] = None,
         # Model-specific parameters
         patch_size: int = 40,
-        on_non_divisible: str = "pad",
         num_queries: int = 4,
         embed_dim: int = 64,
         depth: int = 8,
@@ -157,6 +157,7 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
         drop_prob_chan: float = 0.0,
         attn_drop: float = 0.0,
         activation: Type[nn.Module] = nn.GELU,
+        on_non_divisible: str = "pad",
         channel_strategy: str = "native",
         channel_strategy_kwargs: dict | None = None,
     ):
@@ -284,6 +285,23 @@ class LUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
         self.apply(_init_weights)
         self.fix_init_weight()
 
+    def initialize_weights(self) -> None:
+        """Re-run LUNA's own weight initialization.
+
+        .. deprecated:: 2.0
+            ``initialize_weights`` was renamed to the private
+            ``_init_parameters`` and will be removed in a future release.
+            Use :meth:`reset_parameters`, which first resets every layer to
+            its PyTorch default and then applies this initialization.
+        """
+        warnings.warn(
+            "LUNA.initialize_weights() is deprecated and will be removed in a "
+            "future release; use LUNA.reset_parameters() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._init_parameters()
+
     def fix_init_weight(self) -> None:
         def rescale(param: torch.Tensor, layer_id: int) -> None:
             param.div_(math.sqrt(2.0 * layer_id))