Braindecode 1.5.0__tar.gz → 1.5.0.dev964__tar.gz

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/NOTICE.txt

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

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.5.0
+Version: 1.5.0.dev964
 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>
@@ -43,8 +43,6 @@ Requires-Dist: eegprep[eeglabio]>=0.2.23; extra == "eegprep"
 Provides-Extra: hub
 Requires-Dist: huggingface_hub[torch]>=0.20.0; extra == "hub"
 Requires-Dist: zarr>=3.0; extra == "hub"
-Provides-Extra: viz
-Requires-Dist: captum>=0.7.0; extra == "viz"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
@@ -63,7 +61,6 @@ Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
 Requires-Dist: sphinx-autobuild; extra == "docs"
 Requires-Dist: sphinxcontrib-bibtex; extra == "docs"
 Requires-Dist: sphinx_sitemap; extra == "docs"
-Requires-Dist: sphinxext-opengraph; extra == "docs"
 Requires-Dist: pydata_sphinx_theme; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
 Requires-Dist: memory_profiler; extra == "docs"
@@ -73,7 +70,7 @@ Requires-Dist: sphinx_design; extra == "docs"
 Requires-Dist: lightning; extra == "docs"
 Requires-Dist: seaborn; extra == "docs"
 Requires-Dist: pre-commit; extra == "docs"
-Requires-Dist: openneuro-py>=2026.4.0; extra == "docs"
+Requires-Dist: openneuro-py; extra == "docs"
 Requires-Dist: plotly; extra == "docs"
 Requires-Dist: shap; extra == "docs"
 Requires-Dist: nbformat; extra == "docs"
@@ -85,7 +82,6 @@ Requires-Dist: braindecode[docs]; extra == "all"
 Requires-Dist: braindecode[hub]; extra == "all"
 Requires-Dist: braindecode[eegprep]; extra == "all"
 Requires-Dist: braindecode[typing]; extra == "all"
-Requires-Dist: braindecode[viz]; extra == "all"
 Dynamic: license-file
 
 .. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17699192.svg

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/braindecode/datasets/base.py

@@ -18,7 +18,7 @@ import shutil
 import warnings
 from abc import abstractmethod
 from collections import Counter
-from collections.abc import Callable, Hashable
+from collections.abc import Callable
 from glob import glob
 from pathlib import Path
 from typing import Any, Generic, Iterable, no_type_check
@@ -1340,124 +1340,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             raise TypeError("target_transform must be a callable.")
         self._target_transform = fn
 
-    def set_target(self, column: Hashable) -> "BaseConcatDataset":
-        """Use ``column`` as the target ``y`` for every subdataset.
-
-        Dispatches on the subdataset type:
-
-        * For :class:`WindowsDataset` / :class:`EEGWindowsDataset`,
-          ``column`` is looked up in per-window ``metadata`` first, then in
-          the per-record ``description`` (broadcast to every window). The
-          resolved values overwrite ``ds.metadata['target']`` and ``ds.y``.
-          For :class:`WindowsDataset`, the underlying ``ds.windows.metadata``
-          is kept in sync so ``get_metadata()`` and the repr reflect the
-          new target.
-        * For :class:`RawDataset`, ``column`` must exist on the
-          ``description``. ``ds.target_name`` is set to ``column`` so
-          ``__getitem__`` reads ``description[column]`` as ``y`` on every
-          access — no rebuild needed.
-
-        Parameters
-        ----------
-        column : Hashable
-            Name of a metadata column or description field (BIDS entity,
-            participants.tsv extra, ...). Typically a string, but any
-            hashable that pandas accepts as a column label is allowed.
-
-        Returns
-        -------
-        self : BaseConcatDataset
-
-        Raises
-        ------
-        TypeError
-            If any subdataset is not a :class:`WindowsDataset`,
-            :class:`EEGWindowsDataset`, or :class:`RawDataset`, or if a
-            windowed subdataset has lazy (non-DataFrame) metadata.
-        ValueError
-            If ``column`` is not present on a subdataset's metadata or
-            description, or if a windowed subdataset has
-            ``targets_from='channels'`` (which would make this a silent
-            no-op since ``__getitem__`` reads y from misc channels, not
-            from ``metadata['target']``).
-        """
-        for i, ds in enumerate(self.datasets):
-            if isinstance(ds, (WindowsDataset, EEGWindowsDataset)):
-                if not isinstance(ds.metadata, pd.DataFrame):
-                    # _LazyDataFrame (lazy_metadata=True) does not implement
-                    # .copy()/__setitem__, so the in-place write below would
-                    # raise AttributeError. Surface the precondition cleanly.
-                    raise TypeError(
-                        "set_target requires a materialized metadata "
-                        f"DataFrame; datasets[{i}].metadata is "
-                        f"{type(ds.metadata).__name__}. Re-window with "
-                        "lazy_metadata=False to use set_target."
-                    )
-                if getattr(ds, "targets_from", "metadata") != "metadata":
-                    # __getitem__ would read y from misc channels; writing
-                    # metadata['target']/ds.y would be a silent no-op.
-                    raise ValueError(
-                        f"datasets[{i}] has targets_from="
-                        f"{ds.targets_from!r}; set_target only applies when "
-                        "targets_from='metadata' (otherwise __getitem__ "
-                        "derives y from misc channels and would ignore the "
-                        "rewritten target column)."
-                    )
-                n = len(ds)
-                md = ds.metadata
-                if column in md.columns:
-                    values = md[column].iloc[:n].to_list()
-                elif (
-                    isinstance(ds.description, pd.Series)
-                    and column in ds.description.index
-                ):
-                    values = [ds.description[column]] * n
-                else:
-                    desc_keys = (
-                        list(ds.description.index)
-                        if isinstance(ds.description, pd.Series)
-                        else []
-                    )
-                    raise ValueError(
-                        f"Column {column!r} not found on datasets[{i}]: "
-                        f"metadata cols={list(md.columns)}, "
-                        f"description keys={desc_keys}."
-                    )
-                # In-place write so the WindowsDataset's metadata and the
-                # underlying mne.Epochs.metadata (which start as the same
-                # object reference) both reflect the new target. Defensive
-                # second write covers the case where they got de-aliased
-                # earlier by a caller-side reassignment.
-                md["target"] = values
-                windows_obj = getattr(ds, "_windows", None)
-                if windows_obj is not None and windows_obj.metadata is not md:
-                    windows_obj.metadata["target"] = values
-                # values is already a fresh list (Series.to_list() / [x] * n);
-                # no defensive copy needed — pandas keeps its own representation
-                # for md["target"] so mutating ds.y won't reach back into it.
-                ds.y = values
-            elif isinstance(ds, RawDataset):
-                if (
-                    not isinstance(ds.description, pd.Series)
-                    or column not in ds.description.index
-                ):
-                    desc_keys = (
-                        list(ds.description.index)
-                        if isinstance(ds.description, pd.Series)
-                        else []
-                    )
-                    raise ValueError(
-                        f"Column {column!r} not found on datasets[{i}] "
-                        f"description (keys={desc_keys})."
-                    )
-                ds.target_name = column
-            else:
-                raise TypeError(
-                    "set_target requires WindowsDataset, EEGWindowsDataset, "
-                    f"or RawDataset; datasets[{i}] is {type(ds).__name__}."
-                )
-        return self
-
     def _outdated_save(self, path, overwrite=False):
         """This is a copy of the old saving function, that had inconsistent.
 

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/braindecode/datasets/sleep_physionet.py

@@ -6,12 +6,10 @@
 from __future__ import annotations
 
 import os
-import time
 
 import mne
 import numpy as np
 import pandas as pd
-import requests
 from mne.datasets.sleep_physionet.age import fetch_data
 
 from .base import BaseConcatDataset, RawDataset
@@ -61,19 +59,7 @@ class SleepPhysionet(BaseConcatDataset):
         if recording_ids is None:
             recording_ids = [1, 2]
 
-        max_attempts = 5
-        retry_delay_s = 10
-
-        for attempt in range(max_attempts):
-            try:
-                paths = fetch_data(
-                    subject_ids, recording=recording_ids, on_missing="warn"
-                )
-                break
-            except requests.exceptions.RequestException:
-                if attempt == max_attempts - 1:
-                    raise
-                time.sleep(retry_delay_s)
+        paths = fetch_data(subject_ids, recording=recording_ids, on_missing="warn")
 
         all_base_ds = list()
         for p in paths:

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/braindecode/models/__init__.py

@@ -4,8 +4,8 @@ from .atcnet import ATCNet
 from .attentionbasenet import AttentionBaseNet
 from .attn_sleep import AttnSleep
 from .base import EEGModuleMixin
-from .bendr import BENDR, InterpolatedBENDR
-from .biot import BIOT, InterpolatedBIOT
+from .bendr import BENDR
+from .biot import BIOT
 from .brainmodule import BrainModule
 from .cbramod import CBraMod
 from .codebrain import CodeBrain
@@ -25,24 +25,20 @@ from .eegpt import EEGPT
 from .eegsimpleconv import EEGSimpleConv
 from .eegsym import EEGSym
 from .eegtcnet import EEGTCNet
-from .emg2qwerty import EMG2QwertyNet
 from .fbcnet import FBCNet
 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 .medformer import MEDFormer
-from .meta_neuromotor import MetaNeuromotorHand
 from .msvtnet import MSVTNet
 from .patchedtransformer import PBT
 from .reve import REVE
 from .sccnet import SCCNet
 from .shallow_fbcsp import ShallowFBCSPNet
 from .signal_jepa import (
-    InterpolatedSignalJEPA,
     SignalJEPA,
     SignalJEPA_Contextual,
     SignalJEPA_PostLocal,
@@ -96,18 +92,11 @@ __all__ = [
     "EEGSimpleConv",
     "EEGTCNet",
     "DGCNN",
-    "EMG2QwertyNet",
     "FBCNet",
     "FBLightConvNet",
     "FBMSNet",
-    "MetaNeuromotorHand",
     "HybridNet",
     "IFNet",
-    "InterpolatedBENDR",
-    "InterpolatedBIOT",
-    "InterpolatedLaBraM",
-    "InterpolatedModel",
-    "InterpolatedSignalJEPA",
     "Labram",
     "LUNA",
     "extract_channel_locations_from_chs_info",

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/braindecode/models/base.py

@@ -33,25 +33,13 @@ huggingface_hub = _soft_import(
 HAS_HF_HUB = huggingface_hub is not False
 
 
-_HF_INSTALL_HINT = (
-    "requires the `huggingface_hub` package. "
-    "Install with: pip install 'braindecode[hub]'"
-)
-
-
-class _BaseHubMixinStub:
-    @classmethod
-    def from_pretrained(cls, *args, **kwargs):
-        raise ImportError(f"{cls.__name__}.from_pretrained() {_HF_INSTALL_HINT}")
-
-    def push_to_hub(self, *args, **kwargs):
-        raise ImportError(f"{type(self).__name__}.push_to_hub() {_HF_INSTALL_HINT}")
+class _BaseHubMixin:
+    pass
 
 
 # Define base class for hub mixin
-_BaseHubMixin: Type = (
-    huggingface_hub.PyTorchModelHubMixin if HAS_HF_HUB else _BaseHubMixinStub
-)
+if HAS_HF_HUB:
+    _BaseHubMixin: Type = huggingface_hub.PyTorchModelHubMixin  # type: ignore
 
 
 def deprecated_args(obj, *old_new_args):

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/braindecode/models/bendr.py

@@ -1,60 +1,12 @@
 import copy
 
-import numpy as np
 import torch
 from einops.layers.torch import Rearrange
 from torch import nn
+from torch.nn.utils.parametrize import register_parametrization
 
 from braindecode.models.base import EEGModuleMixin
-
-# The 20 channels used to pre-train BENDR, in the order expected by the
-# `braindecode/braindecode-bendr` checkpoint. The first 19 entries are the
-# EEG channels taken verbatim from `dn3.transforms.instance.To1020.EEG_20_div`
-# (https://github.com/SPOClab-ca/dn3/blob/master/dn3/transforms/instance.py).
-# Their positions come from MNE's ``standard_1005`` montage (T5/T6 are
-# legacy names that share positions with P7/P8 there).
-#
-# The 20th entry is ``SCALE``, a relative-amplitude statistic (not an
-# electrode) appended by ``To1020(include_scale_ch=True)`` during
-# pre-training. Since it has no physical position, the ``loc`` below is
-# the centroid of the 19 EEG positions — purely a placeholder so that
-# :class:`~braindecode.modules.ChannelInterpolationLayer` (used by
-# :class:`InterpolatedBENDR`) can build a valid spline interpolation
-# matrix. It is NOT the SCALE the pre-training pipeline computes
-# (which is an RMS-like amplitude via ``dn3.MappingDeep1010``); users
-# who need a faithful SCALE must compute it themselves and feed 20
-# channels to :class:`BENDR` directly.
-_BENDR_TARGET_CHS_TUPLES: list[tuple[str, tuple[float, float, float]]] = [
-    ("FP1", (-0.0294367, +0.0839171, -0.0069900)),  # standard_1005
-    ("FP2", (+0.0298723, +0.0848959, -0.0070800)),  # standard_1005
-    ("F7", (-0.0702629, +0.0424743, -0.0114200)),  # standard_1005
-    ("F3", (-0.0502438, +0.0531112, +0.0421920)),  # standard_1005
-    ("FZ", (+0.0003122, +0.0585120, +0.0664620)),  # standard_1005
-    ("F4", (+0.0518362, +0.0543048, +0.0408140)),  # standard_1005
-    ("F8", (+0.0730431, +0.0444217, -0.0120000)),  # standard_1005
-    ("T7", (-0.0841611, -0.0160187, -0.0093460)),  # standard_1005
-    ("C3", (-0.0653581, -0.0116317, +0.0643580)),  # standard_1005
-    ("CZ", (+0.0004009, -0.0091670, +0.1002440)),  # standard_1005
-    ("C4", (+0.0671179, -0.0109003, +0.0635800)),  # standard_1005
-    ("T8", (+0.0850799, -0.0150203, -0.0094900)),  # standard_1005
-    ("T5", (-0.0724343, -0.0734527, -0.0024870)),  # standard_1005 (= P7)
-    ("P3", (-0.0530073, -0.0787878, +0.0559400)),  # standard_1005
-    ("PZ", (+0.0003247, -0.0811150, +0.0826150)),  # standard_1005
-    ("P4", (+0.0556667, -0.0785602, +0.0565610)),  # standard_1005
-    ("T6", (+0.0730557, -0.0730683, -0.0025400)),  # standard_1005 (= P8)
-    ("O1", (-0.0294134, -0.1124490, +0.0088390)),  # standard_1005
-    ("O2", (+0.0298426, -0.1121560, +0.0088000)),  # standard_1005
-    (
-        "SCALE",
-        (+0.0006439, -0.0131942, +0.0278448),
-    ),  # centroid of the 19 EEG positions (placeholder; see comment above)
-]
-
-_BENDR_TARGET_CHS_INFO: list[dict] = [
-    {"ch_name": ch, "kind": "eeg", "loc": np.asarray(loc, dtype=float)}
-    for ch, loc in _BENDR_TARGET_CHS_TUPLES
-]
-BENDR_CHANNEL_ORDER: list[str] = [ch for ch, _ in _BENDR_TARGET_CHS_TUPLES]
+from braindecode.modules.parametrization import MaxNormParametrize
 
 
 class BENDR(EEGModuleMixin, nn.Module):
@@ -243,6 +195,15 @@ class BENDR(EEGModuleMixin, nn.Module):
         The contextualizer is still created (to allow loading pretrained weights) but is not
         used in the forward pass. Requires input length of at least
         ``4 * product(enc_downsample)`` samples (384 with default downsampling of 96x).
+    n_chans_pretrained : int or None, default=None
+        Number of input channels the pretrained weights expect (20 for the official BENDR
+        checkpoint). When set and ``n_chans != n_chans_pretrained``, a 1x1 Conv1d with
+        max-norm constraint projects from ``n_chans`` to ``n_chans_pretrained`` before the
+        encoder. This allows fine-tuning pretrained BENDR on datasets with arbitrary channel
+        counts. When using ``from_pretrained``, pass ``strict=False`` since the checkpoint
+        will not contain ``channel_projection`` weights.
+    chan_proj_max_norm : float, default=1.0
+        Max-norm constraint value for the channel projection weights.
     """
 
     def __init__(
@@ -270,6 +231,8 @@ class BENDR(EEGModuleMixin, nn.Module):
         start_token=-5,  # Value for start token embedding
         final_layer=True,  # Whether to include the final linear layer
         encoder_only=False,  # If True, bypass contextualizer and use 4-chunk pooling
+        n_chans_pretrained=None,  # Expected input channels of pretrained weights
+        chan_proj_max_norm=1.0,  # Max-norm for channel projection weights
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -283,34 +246,25 @@ class BENDR(EEGModuleMixin, nn.Module):
         # Keep these parameters if needed later, otherwise they are captured by the mixin
         del n_outputs, n_chans, chs_info, n_times, input_window_seconds, sfreq
 
-        # If the user supplies chs_info, require it to match BENDR_CHANNEL_ORDER
-        # exactly (case-insensitive). Arbitrary channel sets should go through
-        # InterpolatedBENDR — same pattern as Labram / InterpolatedLaBraM.
-        # When chs_info is absent (the usual n_chans=20 path, incl.
-        # from_pretrained), no check is performed.
-        try:
-            _chs_info = self.chs_info
-        except ValueError:
-            _chs_info = None
-        if _chs_info is not None:
-            user_names = [ch["ch_name"] for ch in _chs_info]  # type: ignore[index]
-            canonical = BENDR_CHANNEL_ORDER
-            if [n.lower() for n in user_names] != [n.lower() for n in canonical]:
-                raise ValueError(
-                    f"BENDR requires chs_info to match BENDR_CHANNEL_ORDER exactly "
-                    f"({len(canonical)} channels, specific order; last is 'SCALE'). "
-                    f"Got {len(user_names)} channel(s). For arbitrary channel sets, "
-                    f"use InterpolatedBENDR "
-                    f"(from braindecode.models import InterpolatedBENDR)."
-                )
-
         self.encoder_h = encoder_h
         self.contextualizer_hidden = contextualizer_hidden
         self.include_final_layer = final_layer
         self.encoder_only = encoder_only
 
+        # Channel projection for pretrained weight compatibility
+        encoder_n_chans = self.n_chans
+        if n_chans_pretrained is not None and self.n_chans != n_chans_pretrained:
+            conv = nn.Conv1d(self.n_chans, n_chans_pretrained, 1, bias=False)
+            register_parametrization(
+                conv, "weight", MaxNormParametrize(chan_proj_max_norm)
+            )
+            self.channel_projection = conv
+            encoder_n_chans = n_chans_pretrained
+        else:
+            self.channel_projection = None
+
         self.encoder = _ConvEncoderBENDR(
-            in_features=self.n_chans,
+            in_features=encoder_n_chans,
             encoder_h=encoder_h,
             dropout=drop_prob,
             projection_head=projection_head,
@@ -354,6 +308,8 @@ class BENDR(EEGModuleMixin, nn.Module):
         self._build_head(n_outputs)
 
     def forward(self, x, return_features=False):
+        if self.channel_projection is not None:
+            x = self.channel_projection(x)
         encoded = self.encoder(x)
         # encoded: [batch_size, encoder_h, n_encoded_times]
 
@@ -596,23 +552,3 @@ class _BENDRContextualizer(nn.Module):
         # x: [batch_size, in_features, seq_len + 1]
 
         return x
-
-
-# -----------------------------------------------------------------------------
-# InterpolatedBENDR — experimental channel-interpolation variant of BENDR
-# -----------------------------------------------------------------------------
-# Wraps :class:`BENDR` with an MNE-backed channel-interpolation layer that
-# projects arbitrary user ``chs_info`` to the canonical 20-channel BENDR
-# input (:data:`_BENDR_TARGET_CHS_INFO` — the 19 pre-training EEG channels
-# plus a ``SCALE`` placeholder at the centroid of those 19 positions).
-# Frozen by default; set ``trainable=True`` to fine-tune the projection.
-#
-# NOTE: the ``SCALE`` target has no physical position, so the row of the
-# interpolation matrix that produces it is a spatial spline of the user's
-# EEG channels — *not* the dn3 ``MappingDeep1010`` RMS statistic the
-# checkpoint saw during pre-training. Expect degraded zero-shot transfer
-# from the SCALE channel; downstream fine-tuning should still work.
-
-from braindecode.models.interpolated import InterpolatedModel  # noqa: E402
-
-InterpolatedBENDR = InterpolatedModel(BENDR, _BENDR_TARGET_CHS_INFO)

{braindecode-1.5.0 → braindecode-1.5.0.dev964}/braindecode/models/biot.py

@@ -1,57 +1,12 @@
 import math
 from warnings import warn
 
-import numpy as np
 import torch
 import torch.nn as nn
 from linear_attention_transformer import LinearAttentionTransformer
 
 from braindecode.models.base import EEGModuleMixin
 
-# -----------------------------------------------------------------------------
-# Canonical channel order for InterpolatedBIOT — the 18-channel TCP bipolar
-# montage used by BIOT's shhs-prest and six-datasets pretrained checkpoints.
-# Source: https://github.com/ycq091044/BIOT (README + datasets/TUAB/process.py
-# + datasets/SHHS/process.py). Indices 0-15 are the TCP 16-channel bipolar
-# derivations; indices 16-17 are SHHS differential channels.
-#
-# The `loc` values are only used to build an MNE interpolation matrix for
-# InterpolatedBIOT. All entries are bipolar / differential derivations.
-# TODO: positions are stored as the midpoint of the two constituent
-# electrodes. This is a simplification — a bipolar signal V(A)-V(B) cannot
-# be faithfully recovered by spatial interpolation at the midpoint. Revisit
-# in a follow-up PR (e.g. a dedicated BipolarDerivationLayer).
-# -----------------------------------------------------------------------------
-
-# fmt: off
-_BIOT_TARGET_CHS_TUPLES: list[tuple[str, tuple[float, float, float]]] = [
-    ("FP1-F7", (-0.04984980, 0.06319570, -0.00920500)),
-    ("F7-T7", (-0.07721200, 0.01322780, -0.01038300)),
-    ("T7-P7", (-0.07829770, -0.04473570, -0.00591650)),
-    ("P7-O1", (-0.05092385, -0.09295085, 0.00317600)),
-    ("FP2-F8", (0.05145770, 0.06465880, -0.00954000)),
-    ("F8-T8", (0.07906150, 0.01470070, -0.01074500)),
-    ("T8-P8", (0.07906780, -0.04404430, -0.00601500)),
-    ("P8-O2", (0.05144915, -0.09261215, 0.00313000)),
-    ("FP1-F3", (-0.03984025, 0.06851415, 0.01760100)),
-    ("F3-C3", (-0.05780095, 0.02073975, 0.05327500)),
-    ("C3-P3", (-0.05918270, -0.04520975, 0.06014900)),
-    ("P3-O1", (-0.04121035, -0.09561840, 0.03238950)),
-    ("FP2-F4", (0.04085425, 0.06960035, 0.01686700)),
-    ("F4-C4", (0.05947705, 0.02170225, 0.05219700)),
-    ("C4-P4", (0.06139230, -0.04473025, 0.06007050)),
-    ("P4-O2", (0.04275465, -0.09535810, 0.03268050)),
-    ("C3-A2", (0.01021790, -0.01832050, -0.00183650)),
-    ("C4-A1", (-0.00947910, -0.01794500, -0.00220300)),
-]
-# fmt: on
-
-_BIOT_TARGET_CHS_INFO = [
-    {"ch_name": ch, "kind": "eeg", "loc": np.asarray(loc, dtype=float)}
-    for ch, loc in _BIOT_TARGET_CHS_TUPLES
-]
-BIOT_CHANNEL_ORDER = [ch for ch, _ in _BIOT_TARGET_CHS_TUPLES]
-
 
 class BIOT(EEGModuleMixin, nn.Module):
     r"""BIOT from Yang et al (2023) [Yang2023]_
@@ -484,9 +439,7 @@ class _BIOTEncoder(nn.Module):
         self.channel_tokens = nn.Embedding(
             num_embeddings=n_chans, embedding_dim=emb_size
         )
-        self.register_buffer(
-            "index", torch.arange(n_chans, dtype=torch.long), persistent=False
-        )
+        self.register_buffer("index", torch.arange(n_chans, dtype=torch.long))
 
     def stft(self, sample):
         """
@@ -600,16 +553,3 @@ class _BIOTEncoder(nn.Module):
         # (batch_size, emb)
         emb = self.transformer(emb).mean(dim=1)
         return emb
-
-
-# -----------------------------------------------------------------------------
-# InterpolatedBIOT — experimental channel-interpolation variant of BIOT
-# -----------------------------------------------------------------------------
-# Wraps :class:`BIOT` with an MNE-backed channel-interpolation layer that
-# projects arbitrary user ``chs_info`` to the canonical 18-channel BIOT
-# montage (:data:`_BIOT_TARGET_CHS_INFO`). Frozen by default; set
-# ``trainable=True`` to fine-tune the projection matrix.
-
-from braindecode.models.interpolated import InterpolatedModel  # noqa: E402
-
-InterpolatedBIOT = InterpolatedModel(BIOT, _BIOT_TARGET_CHS_INFO)