braindecode 1.8.1.dev174129228__tar.gz → 1.8.1.dev174246559__tar.gz

{braindecode-1.8.1.dev174129228 → braindecode-1.8.1.dev174246559}/NOTICE.txt

@@ -16,6 +16,7 @@ The following components are licensed under the Creative Commons Attribution-Non
 - `braindecode/models/sleepfm.py`
 - `braindecode/models/brainmodule.py`
 - `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,

{braindecode-1.8.1.dev174129228/braindecode.egg-info → braindecode-1.8.1.dev174246559}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev174129228
+Version: 1.8.1.dev174246559
 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.dev174129228 → braindecode-1.8.1.dev174246559}/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.dev174129228 → braindecode-1.8.1.dev174246559}/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.dev174129228 → braindecode-1.8.1.dev174246559}/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.dev174129228 → braindecode-1.8.1.dev174246559}/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]

{braindecode-1.8.1.dev174129228 → braindecode-1.8.1.dev174246559}/braindecode/models/__init__.py

@@ -5,8 +5,8 @@ from .attentionbasenet import AttentionBaseNet
 from .attn_sleep import AttnSleep
 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
@@ -29,7 +29,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
@@ -39,8 +39,7 @@ 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
@@ -51,6 +50,7 @@ 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
@@ -59,7 +59,6 @@ from .seizure_transformer import SeizureTransformer
 from .sensingdynamics import SensingDynamics
 from .shallow_fbcsp import ShallowFBCSPNet
 from .signal_jepa import (
-    InterpolatedSignalJEPA,
     SignalJEPA,
     SignalJEPA_Contextual,
     SignalJEPA_PostLocal,
@@ -82,7 +81,6 @@ 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,
 )
@@ -118,7 +116,6 @@ __all__ = [
     "EEGConformer",
     "EEGDINO",
     "EEGPT",
-    "InterpolatedEEGPT",
     "EEGInceptionERP",
     "EEGInceptionMI",
     "EEGITNet",
@@ -139,11 +136,6 @@ __all__ = [
     "MetaNeuromotorHand",
     "HybridNet",
     "IFNet",
-    "InterpolatedBENDR",
-    "InterpolatedBIOT",
-    "InterpolatedLaBraM",
-    "InterpolatedModel",
-    "InterpolatedSignalJEPA",
     "Labram",
     "LUNA",
     "extract_channel_locations_from_chs_info",
@@ -153,6 +145,7 @@ __all__ = [
     "MIRepNet",
     "NeuroRVQ",
     "MSCFormer",
+    "NeuroRVQTokenizer",
     "MSVTNet",
     "MVPFormer",
     "PBT",
@@ -184,5 +177,4 @@ __all__ = [
     "build_model_config",
     "_init_models_dict",
     "models_mandatory_parameters",
-    "interpolated_models_dict",
 ]

{braindecode-1.8.1.dev174129228 → braindecode-1.8.1.dev174246559}/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)
 

{braindecode-1.8.1.dev174129228 → braindecode-1.8.1.dev174246559}/braindecode/models/barista.py

@@ -205,6 +205,8 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
         pooling: str = "learned",
         drop_prob: float = 0.1,
         activation: type[nn.Module] = nn.GELU,
+        channel_strategy: str = "native",
+        channel_strategy_kwargs: dict | None = None,
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -213,6 +215,8 @@ class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
             n_times=n_times,
             input_window_seconds=input_window_seconds,
             sfreq=sfreq,
+            channel_strategy=channel_strategy,
+            channel_strategy_kwargs=channel_strategy_kwargs,
         )
         del n_outputs, n_chans, chs_info, n_times, input_window_seconds, sfreq
 

{braindecode-1.8.1.dev174129228 → braindecode-1.8.1.dev174246559}/braindecode/models/base.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import inspect
 import json
 import warnings
 from collections import OrderedDict
@@ -24,6 +25,7 @@ from braindecode.models.util import (
     resolve_type_kwargs,
     track_model_init_kwargs,
 )
+from braindecode.modules.channels import ChannelLayer
 from braindecode.version import __version__
 
 huggingface_hub = _soft_import(
@@ -32,6 +34,16 @@ huggingface_hub = _soft_import(
 
 HAS_HF_HUB = huggingface_hub is not False
 
+# __init__ args that from_pretrained fills from config.json when not given.
+_GEOMETRY_KWARGS = (
+    "n_outputs",
+    "n_chans",
+    "chs_info",
+    "n_times",
+    "input_window_seconds",
+    "sfreq",
+)
+
 
 _HF_INSTALL_HINT = (
     "requires the `huggingface_hub` package. "
@@ -113,6 +125,17 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         Length of the input window in seconds.
     sfreq : float
         Sampling frequency of the EEG recordings.
+    channel_strategy : str, default="native"
+        How any montage reaches the backbone (pretrained models only; see
+        :doc:`/user_guide/channel_strategies`). ``"native"`` keeps the model as
+        it is. ``"exact"``, ``"zero"``, ``"nearest"``, ``"idw"``, ``"spline"``,
+        ``"field"``, ``"source"``, ``"region"``, ``"wiener"`` (call
+        ``model.channel_layer.fit`` first) or ``"latent"`` map the montage of ``chs_info`` (or of the
+        ``chs_info`` given to ``forward``) onto the backbone's channels with a
+        :class:`~braindecode.modules.ChannelLayer`. Saved in the config.
+        ``model(x)`` and ``model.forward(x)`` both apply the layer.
+    channel_strategy_kwargs : dict or None, default=None
+        Options of the strategy (e.g. ``{"reg": 1e-2}`` for ``"spline"``).
 
     Raises
     ------
@@ -286,6 +309,8 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         n_times: Optional[int] = None,  # type: ignore[assignment]
         input_window_seconds: Optional[float] = None,  # type: ignore[assignment]
         sfreq: Optional[float] = None,  # type: ignore[assignment]
+        channel_strategy: str = "native",
+        channel_strategy_kwargs: Optional[dict] = None,
     ):
         # Deserialize chs_info if it comes as a list of dicts (from Hub)
         if chs_info is not None and isinstance(chs_info, list):
@@ -308,6 +333,26 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
             raise ValueError(
                 f"{n_times=} different from {input_window_seconds=} * {sfreq=}"
             )
+        layer = None
+        if channel_strategy != "native":  # the backbone is built on the target
+            target = self._channel_target or chs_info
+            if target is None:
+                raise ValueError(
+                    f"channel_strategy={channel_strategy!r} needs chs_info."
+                )
+            target = [
+                c
+                if isinstance(c, dict)
+                else {"ch_name": c, "kind": "eeg", "loc": np.zeros(12)}
+                for c in target
+            ]
+            kwargs = channel_strategy_kwargs or {}
+            layer = ChannelLayer(target, channel_strategy, chs_info, **kwargs)
+            chs_info, n_chans = layer.target, None
+        elif channel_strategy_kwargs:
+            raise ValueError(
+                "channel_strategy='native' takes no channel_strategy_kwargs."
+            )
 
         self._input_window_seconds = input_window_seconds  # type: ignore[assignment]
         self._chs_info = chs_info  # type: ignore[assignment]
@@ -334,6 +379,22 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                 setattr(self, key, val)
 
         super().__init__()
+        if layer is not None:
+            self.channel_layer = layer
+            # Instance attribute: model(x) and model.forward(x) both map x.
+            setattr(self, "forward", self._channel_forward)
+
+    def _channel_forward(self, *args, chs_info=None, ch_names=None, **kwargs):
+        """``forward`` under a channel strategy: map ``x`` (recorded with
+        ``chs_info``, default the model's) onto the target, then run the backbone."""
+        if chs_info is None and ch_names is not None:  # LaBraM: names of x's channels
+            chs_info = [{"ch_name": n} for n in ch_names]
+        if args:
+            args = (self.channel_layer(args[0], chs_info)[0], *args[1:])
+        else:  # x by keyword: the backbone's first input (x, X, eeg...)
+            x = list(inspect.signature(type(self).forward).parameters)[1]
+            kwargs[x] = self.channel_layer(kwargs[x], chs_info)[0]
+        return type(self).forward(self, *args, **kwargs)
 
     @property
     def n_outputs(self) -> int:
@@ -424,13 +485,16 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         with torch.inference_mode():
             try:
                 return tuple(
-                    self.forward(  # type: ignore
+                    type(self)
+                    .forward(  # the backbone, on its own channels
+                        self,
                         torch.zeros(
                             self.input_shape,
                             dtype=next(self.parameters()).dtype,  # type: ignore
                             device=next(self.parameters()).device,  # type: ignore
-                        )
-                    ).shape
+                        ),
+                    )
+                    .shape
                 )
             except RuntimeError as exc:
                 if str(exc).endswith(
@@ -596,6 +660,9 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
         )
 
     mapping: Optional[Dict[str, str]] = None
+    #: Channels the backbone consumes under a ``channel_strategy`` (names or
+    #: ``chs_info``); ``None``: the model's own ``chs_info``.
+    _channel_target: Optional[list] = None
 
     def load_state_dict(self, state_dict, *args, **kwargs):
         mapping = self.mapping if self.mapping else {}
@@ -605,7 +672,10 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
                 new_state_dict[mapping[k]] = v
             else:
                 new_state_dict[k] = v
-
+        # A backbone checkpoint has no weights for a trainable channel layer.
+        for k, v in super().state_dict().items():
+            if k.startswith("channel_layer.") and k not in new_state_dict:
+                new_state_dict[k] = v
         return super().load_state_dict(new_state_dict, *args, **kwargs)
 
     def to_dense_prediction_model(self, axis: tuple[int, ...] | int = (2, 3)) -> None:
@@ -781,18 +851,20 @@ class EEGModuleMixin(_BaseHubMixin, metaclass=_BraindecodeDocstringMeta):
 
         @classmethod
         def from_pretrained(cls, *args, **kwargs):
-            # The Hub mixin fills omitted __init__ args from config.json; pin the
-            # derived geometry arg so it cannot clash with the caller's one
-            # (e.g. caller chs_info vs saved n_chans) in __init__'s checks.
-            if "chs_info" in kwargs and "n_chans" not in kwargs:
-                chs_info = kwargs["chs_info"]
-                kwargs["n_chans"] = None if chs_info is None else len(chs_info)
-            elif "n_chans" in kwargs and "chs_info" not in kwargs:
-                kwargs["chs_info"] = None
-            if ("n_times" in kwargs or "sfreq" in kwargs) and (
-                "input_window_seconds" not in kwargs
-            ):
-                kwargs["input_window_seconds"] = None
+            # The Hub mixin fills only the __init__ args whose keys are absent,
+            # so drop explicit Nones (e.g. forwarded by a wrapper) to let the
+            # saved values fill them. Then pin the derived geometry arg so it
+            # cannot clash with the caller's one (e.g. caller chs_info vs saved
+            # n_chans) in __init__'s checks.
+            for key in _GEOMETRY_KWARGS:
+                if key in kwargs and kwargs[key] is None:
+                    del kwargs[key]
+            if "chs_info" in kwargs:
+                kwargs.setdefault("n_chans", len(kwargs["chs_info"]))
+            elif "n_chans" in kwargs:
+                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)
 
         @classmethod

{braindecode-1.8.1.dev174129228 → braindecode-1.8.1.dev174246559}/braindecode/models/bendr.py

@@ -11,48 +11,48 @@ from einops.layers.torch import Rearrange
 from torch import nn
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.modules.channel_tokenizer import ChannelTokenizer
+from braindecode.modules.channels import ChannelLayer
 
 # 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).
+# Their positions come from MNE's ``standard_1005`` montage in the head
+# frame, as ``raw.set_montage`` gives them (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
+# the centroid of the 19 EEG positions — purely a placeholder for the
+# spline that ``channel_strategy="native"`` applies to other montages.
+# Any other ``channel_strategy`` leaves SCALE at zero unless the input has it. 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
+    ("FP1", (-0.0309026, +0.1145852, +0.0278666)),  # standard_1005
+    ("FP2", (+0.0284095, +0.1153463, +0.0277213)),  # standard_1005
+    ("F7", (-0.0718766, +0.0731035, +0.0257905)),  # standard_1005
+    ("F3", (-0.0518090, +0.0866879, +0.0787141)),  # standard_1005
+    ("FZ", (-0.0012293, +0.0932745, +0.1026393)),  # standard_1005
+    ("F4", (+0.0502743, +0.0874384, +0.0772707)),  # standard_1005
+    ("F8", (+0.0714353, +0.0745051, +0.0251010)),  # standard_1005
+    ("T7", (-0.0859821, +0.0148716, +0.0311734)),  # standard_1005
+    ("C3", (-0.0671487, +0.0233582, +0.1045107)),  # standard_1005
+    ("CZ", (-0.0013741, +0.0276171, +0.1401995)),  # standard_1005
+    ("C4", (+0.0653289, +0.0235731, +0.1036924)),  # standard_1005
+    ("T8", (+0.0832614, +0.0152582, +0.0309730)),  # standard_1005
+    ("T5", (-0.0744580, -0.0421232, +0.0412736)),  # standard_1005 (= P7)
+    ("P3", (-0.0550382, -0.0442103, +0.0999090)),  # standard_1005
+    ("PZ", (-0.0017095, -0.0452130, +0.1266729)),  # standard_1005
+    ("P4", (+0.0536360, -0.0443345, +0.1005160)),  # standard_1005
+    ("T6", (+0.0710325, -0.0422600, +0.0411989)),  # standard_1005 (= P8)
+    ("O1", (-0.0315736, -0.0805684, +0.0547896)),  # standard_1005
+    ("O2", (+0.0276831, -0.0804888, +0.0547341)),  # standard_1005
     (
         "SCALE",
-        (+0.0006439, -0.0131942, +0.0278448),
+        (-0.0011601, +0.0194958, +0.0681445),
     ),  # centroid of the 19 EEG positions (placeholder; see comment above)
 ]
 
@@ -251,6 +251,8 @@ class BENDR(EEGModuleMixin, nn.Module):
         ``4 * product(enc_downsample)`` samples (384 with default downsampling of 96x).
     """
 
+    _channel_target = BENDR_CHANNEL_ORDER
+
     def __init__(
         self,
         # Signal related parameters
@@ -276,6 +278,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
+        channel_strategy: str = "native",
+        channel_strategy_kwargs: dict | None = None,
     ):
         super().__init__(
             n_outputs=n_outputs,
@@ -284,6 +288,8 @@ class BENDR(EEGModuleMixin, nn.Module):
             n_times=n_times,
             input_window_seconds=input_window_seconds,
             sfreq=sfreq,
+            channel_strategy=channel_strategy,
+            channel_strategy_kwargs=channel_strategy_kwargs,
         )
 
         # Keep these parameters if needed later, otherwise they are captured by the mixin
@@ -302,10 +308,8 @@ class BENDR(EEGModuleMixin, nn.Module):
             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]:
-                self.channel_tokenizer = ChannelTokenizer(
-                    strategy="fixed_order",
-                    src_chs_info=_chs_info,
-                    target_chs_info=_BENDR_TARGET_CHS_INFO,
+                self.channel_tokenizer = ChannelLayer(
+                    _BENDR_TARGET_CHS_INFO, "spline", _chs_info, reg=0.0
                 )
                 backbone_n_chans = len(_BENDR_TARGET_CHS_INFO)
 
@@ -362,7 +366,7 @@ class BENDR(EEGModuleMixin, nn.Module):
 
     def forward(self, x, return_features=False):
         if self.channel_tokenizer is not None:
-            x = self.channel_tokenizer(x)
+            x = self.channel_tokenizer(x)[0]
         encoded = self.encoder(x)
         # encoded: [batch_size, encoder_h, n_encoded_times]
 
@@ -583,6 +587,7 @@ class _BENDRContextualizer(nn.Module):
                 (1, x.shape[1], x.shape[2]),
                 float(self.start_token),
                 device=x.device,
+                dtype=x.dtype,
                 requires_grad=False,
             )
             x = torch.cat([token_emb, x], dim=0)
@@ -607,23 +612,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)