Braindecode 1.8.1.dev183674431__tar.gz → 1.8.1.dev183849953__tar.gz

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/NOTICE.txt

@@ -52,7 +52,6 @@ The following components are licensed under the Apache License 2.0:
 - `braindecode/models/zuna.py`
 - `braindecode/models/luna.py`
 - `braindecode/models/brant.py`
-- `braindecode/models/diver1.py`
 - `braindecode/models/mscformer.py`
 
 ### USC Academic License Files

{braindecode-1.8.1.dev183674431/braindecode.egg-info → braindecode-1.8.1.dev183849953}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev183674431
+Version: 1.8.1.dev183849953
 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>
@@ -44,8 +44,6 @@ 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: sae
-Requires-Dist: sae-lens==6.51.3; extra == "sae"
 Provides-Extra: tests
 Requires-Dist: pytest<9.1; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
@@ -60,8 +58,6 @@ Provides-Extra: typing
 Requires-Dist: exca>=0.5.10; extra == "typing"
 Requires-Dist: numpydantic>=1.7; extra == "typing"
 Provides-Extra: docs
-Requires-Dist: pytest<9.1; extra == "docs"
-Requires-Dist: sphinx-markdown-builder==0.6.11; extra == "docs"
 Requires-Dist: sphinx_gallery>=0.17; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints; extra == "docs"

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/classifier.py

@@ -207,11 +207,10 @@ class EEGClassifier(_EEGNeuralNet, NeuralNetClassifier):
 
         Returns
         -------
-        trial_predictions : np.ndarray | list of np.ndarray
+        trial_predictions : np.ndarray
             3-dimensional array (n_trials x n_classes x n_predictions), where
             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.
+            receptive field of the network.
         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``.

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/datasets/tuh.py

@@ -815,8 +815,7 @@ def _get_header(*args, **kwargs):
     for paths_dict in [_TUH_EEG_PATHS, _TUH_EEG_ABNORMAL_PATHS, _TUH_EEG_EVENTS_PATHS]:
         for version_dict in paths_dict.values():
             all_paths.update(version_dict)
-    # Mock keys use POSIX separators; pathlib emits backslashes on Windows.
-    return all_paths[os.fspath(args[0]).replace("\\", "/")]
+    return all_paths[args[0]]
 
 
 _TUH_EEG_PATHS = {

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/functional/__init__.py

@@ -8,7 +8,6 @@ from .functions import (
     iou_1d,
     pairwise_iou_1d,
     plv_time,
-    rotate_pairs,
     safe_log,
     sinusoidal_positional_encoding,
     square,
@@ -26,7 +25,6 @@ __all__ = [
     "iou_1d",
     "pairwise_iou_1d",
     "plv_time",
-    "rotate_pairs",
     "safe_log",
     "sinusoidal_positional_encoding",
     "square",

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/functional/functions.py

@@ -470,21 +470,3 @@ def sinusoidal_positional_encoding(n_positions: int, dim: int) -> torch.Tensor:
     # ``.contiguous()`` so an odd-``dim`` truncation owns tight storage -- a
     # non-contiguous view over the padded width breaks safetensors buffer saving.
     return pe[:, :dim].contiguous()
-
-
-def rotate_pairs(x: torch.Tensor) -> torch.Tensor:
-    """Rotate adjacent feature pairs from ``(a, b)`` to ``(-b, a)``.
-
-    Parameters
-    ----------
-    x : torch.Tensor
-        Tensor of shape ``(..., features)`` with an even final dimension.
-
-    Returns
-    -------
-    torch.Tensor
-        Same shape, device and dtype as ``x``. Frequencies, positional indexing
-        and mixed-precision policy are left to the caller.
-    """
-    pairs = x.unflatten(-1, (-1, 2))
-    return torch.stack((-pairs[..., 1], pairs[..., 0]), dim=-1).flatten(-2)

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/models/__init__.py

@@ -18,7 +18,6 @@ from .dance import DANCE
 from .deep4 import Deep4Net
 from .deepsleepnet import DeepSleepNet
 from .dgcnn import DGCNN
-from .diver1 import DIVER1
 from .eegconformer import EEGConformer
 from .eegdino import EEGDINO
 from .eeginception_erp import EEGInceptionERP
@@ -102,7 +101,6 @@ __all__ = [
     "DANCE",
     "Deep4Net",
     "DeepSleepNet",
-    "DIVER1",
     "BrainModule",
     "Brant",
     "EEGConformer",

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/models/deep4.py

@@ -215,7 +215,6 @@ class Deep4Net(EEGModuleMixin, nn.Sequential):
                     filter_time_length=filter_time_length,
                     bias_time=True,
                     bias_spat=not self.batch_norm,
-                    stride=(conv_stride, 1),
                 ),
             )
             n_filters_conv = self.n_filters_spat

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/models/labram.py

@@ -191,11 +191,6 @@ _LABRAM_TARGET_CHS_INFO = [
     for ch, loc in _LABRAM_TARGET_CHS_TUPLES
 ]
 LABRAM_CHANNEL_ORDER = [ch for ch, _ in _LABRAM_TARGET_CHS_TUPLES]
-
-#: Absolute time slots of the original LaBraM (``time_embed`` in its
-#: ``modeling_finetune.py``), whatever the window length. A window of P patches
-#: uses slots 0..P-1, and the released weights hold all 16 of them.
-_LABRAM_N_TIME_SLOTS = 16
 _LABRAM_CANONICAL_INDEX = {n.upper(): i for i, n in enumerate(LABRAM_CHANNEL_ORDER)}
 
 
@@ -324,13 +319,7 @@ class Labram(EEGModuleMixin, nn.Module):
     use_abs_pos_emb : bool (default=True)
         If True, use absolute position embedding.
     use_mean_pooling : bool (default=True)
-        If True, the readout is ``fc_norm`` applied to the mean of the patch
-        tokens, as in the original fine-tuning. If False, the readout is the
-        [CLS] token after the final ``norm``; the original pretraining loss
-        never uses the [CLS] output. A pretraining checkpoint (with ``norm``
-        and without ``fc_norm`` or head, such as the released weights) loads
-        into a mean-pooling model as in the original fine-tuning script:
-        ``norm`` is unused and ``fc_norm`` keeps its initialization.
+        If True, use mean pooling.
     init_scale : float (default=0.001)
         The initial scale to be used in the parameters of the model.
     neural_tokenizer : bool (default=True)
@@ -382,7 +371,7 @@ class Labram(EEGModuleMixin, nn.Module):
         norm_layer: type[nn.Module] = nn.LayerNorm,
         init_values=0.1,
         use_abs_pos_emb=True,
-        use_mean_pooling=True,
+        use_mean_pooling=False,
         init_scale=0.001,
         neural_tokenizer=True,
         attn_head_dim=None,
@@ -509,15 +498,8 @@ class Labram(EEGModuleMixin, nn.Module):
         else:
             self.position_embedding = None
 
-        # The tokenizer keeps the original's absolute time slots, so the
-        # pretrained slots load at every window length; longer windows get
-        # extra slots. The decoder mode keeps one slot per patch plus one.
-        n_patches = self.patch_embed[0].n_patchs
-        n_time_slots = (
-            max(_LABRAM_N_TIME_SLOTS, n_patches) if neural_tokenizer else n_patches + 1
-        )
         self.temporal_embedding = nn.Parameter(
-            torch.zeros(1, n_time_slots, self.embed_dim),
+            torch.zeros(1, self.patch_embed[0].n_patchs + 1, self.embed_dim),
             requires_grad=True,
         )
         self.pos_drop = nn.Dropout(p=drop_prob)
@@ -656,11 +638,10 @@ class Labram(EEGModuleMixin, nn.Module):
             temporal = self.embed_dim
         else:
             # For neural decoder: input is (batch, n_chans, n_times)
-            # patch_embed returns one token per temporal patch:
-            # (batch, n_patches_per_channel, emb_dim)
+            # patch_embed returns (batch, n_patchs, emb_dim)
             x = self.patch_embed(x)
-            # x shape: (batch, n_patches_per_channel, emb_dim)
-            batch_size, n_patches_per_channel, temporal = x.shape
+            # x shape: (batch, n_patchs, emb_dim)
+            batch_size, n_patch, temporal = x.shape
 
         # add the [CLS] token to the embedded patch tokens
         cls_tokens = self.cls_token.expand(batch_size, -1, -1)
@@ -678,13 +659,10 @@ class Labram(EEGModuleMixin, nn.Module):
                     pos_embed_used=pos_embed_used, batch_size=batch_size
                 )
             else:
-                # In decoder mode, patch_embed already averages over the grouped
-                # channel dimension, so the token axis only indexes temporal
-                # patches.
-                n_pos = min(
-                    self.position_embedding.shape[1],
-                    n_patches_per_channel + 1,
-                )
+                # In decoder mode, we have different number of patches
+                # Adapt position embedding for n_patch patches
+                # Use the first n_patch+1 positions from position_embedding
+                n_pos = min(self.position_embedding.shape[1], n_patch + 1)
                 pos_embed_used = self.position_embedding[:, :n_pos, :]
                 pos_embed = pos_embed_used.expand(batch_size, -1, -1)
 
@@ -694,26 +672,23 @@ class Labram(EEGModuleMixin, nn.Module):
         if self.neural_tokenizer:
             num_ch = n_input_chans  # Use actual input channels
             time_embed = self._adj_temporal_embedding(
-                num_ch=num_ch,
-                batch_size=batch_size,
-                n_patches=self.patch_embed[0].n_patchs,
+                num_ch=num_ch, batch_size=batch_size, dim_embed=temporal
             )
             x[:, 1:, :] += time_embed
         else:
-            # In decoder mode, patch_embed returns one token per temporal patch,
-            # so we only need one temporal embedding per time slice.
+            # In decoder mode, we have n_patch patches and don't need to expand
+            # Just broadcast the temporal embedding
             if temporal is None:
                 temporal = self.embed_dim
 
-            n_time_tokens = min(
-                n_patches_per_channel, self.temporal_embedding.shape[1] - 1
-            )
+            # Get temporal embeddings for n_patch patches
+            n_time_tokens = min(n_patch, self.temporal_embedding.shape[1] - 1)
             time_embed = self.temporal_embedding[
                 :, 1 : n_time_tokens + 1, :
-            ]  # (1, n_patches_per_channel, emb_dim)
+            ]  # (1, n_patch, emb_dim)
             time_embed = time_embed.expand(
                 batch_size, -1, -1
-            )  # (batch, n_patches_per_channel, emb_dim)
+            )  # (batch, n_patch, emb_dim)
             x[:, 1:, :] += time_embed
 
         x = self.pos_drop(x)
@@ -851,20 +826,19 @@ class Labram(EEGModuleMixin, nn.Module):
         self._update_init_kwargs(n_outputs=n_outputs)
         self.reset_classifier(n_outputs)
 
-    def _adj_temporal_embedding(self, num_ch, batch_size, n_patches):
+    def _adj_temporal_embedding(self, num_ch, batch_size, dim_embed=None):
         """
         Adjust the dimensions of the time embedding to match the
-        number of channels and patches.
+        number of channels or patches.
 
         Parameters
         ----------
         num_ch : int
-            The number of channels.
+            The number of channels or number of patches.
         batch_size : int
             Batch size of the input data.
-        n_patches : int
-            The number of patches per channel. Patch ``p`` uses time slot
-            ``p``, as in the original implementation.
+        dim_embed : int
+            The embedding dimension (temporal feature dimension).
 
         Returns
         -------
@@ -872,9 +846,13 @@ class Labram(EEGModuleMixin, nn.Module):
             The adjusted time embedding to be added across the channels
             after the [CLS] token. (x[:, 1:, :] += time_embed)
         """
-        # Get the temporal embedding: (1, n_time_slots, emb_size)
-        # Keep the first n_patches slots: (1, n_patches, emb_size)
-        cut_dimension = n_patches
+        if dim_embed is None:
+            cut_dimension = self.patch_size
+        else:
+            cut_dimension = min(dim_embed, self.temporal_embedding.shape[1] - 1)
+
+        # Get the temporal embedding: (1, temporal_embedding_dim, emb_size)
+        # Slice to cut_dimension: (1, cut_dimension, emb_size)
         temporal_embedding = self.temporal_embedding[:, 0:cut_dimension, :]
 
         # Add a new dimension to the time embedding
@@ -891,70 +869,6 @@ class Labram(EEGModuleMixin, nn.Module):
 
         return temporal_embedding
 
-    def _load_from_state_dict(
-        self,
-        state_dict,
-        prefix,
-        local_metadata,
-        strict,
-        missing_keys,
-        unexpected_keys,
-        error_msgs,
-    ):
-        # Time slots are absolute positions: take every slot the checkpoint
-        # holds and keep the model's own values for the others. This loads the
-        # released 16 slots at any window length, and checkpoints saved when
-        # the embedding had one slot per patch plus one.
-        key = prefix + "temporal_embedding"
-        loaded = state_dict.get(key)
-        own = self.temporal_embedding
-        if (
-            self.neural_tokenizer
-            and isinstance(loaded, torch.Tensor)
-            and loaded.dim() == own.dim() == 3
-            and loaded.shape[0] == own.shape[0]
-            and loaded.shape[2] == own.shape[2]
-            and loaded.shape[1] != own.shape[1]
-        ):
-            n_copied = min(loaded.shape[1], own.shape[1])
-            resized = own.detach().clone()
-            resized[:, :n_copied] = loaded[:, :n_copied].to(resized)
-            n_used = self.patch_embed[0].n_patchs
-            if n_copied < n_used:
-                warn(
-                    f"The checkpoint holds {loaded.shape[1]} time slots but this "
-                    f"model uses {n_used} (one per patch); time slots "
-                    f"{n_copied} to {n_used - 1} keep their initialization.",
-                    UserWarning,
-                )
-            state_dict[key] = resized
-        # A pretraining checkpoint has the per-token final ``norm`` and no
-        # pooling ``fc_norm`` or head. As in the original fine-tuning script,
-        # a mean-pooling model leaves that ``norm`` unused and starts
-        # ``fc_norm`` from its initialization. A checkpoint with a head was
-        # fine-tuned with its own readout and is not converted.
-        if (
-            self.fc_norm is not None
-            and prefix + "cls_token" in state_dict
-            and not any(
-                k.startswith((prefix + "fc_norm.", prefix + "final_layer."))
-                for k in state_dict
-            )
-        ):
-            for k in [k for k in state_dict if k.startswith(prefix + "norm.")]:
-                del state_dict[k]
-            for name, value in self.fc_norm.state_dict().items():
-                state_dict[prefix + "fc_norm." + name] = value
-        super()._load_from_state_dict(
-            state_dict,
-            prefix,
-            local_metadata,
-            strict,
-            missing_keys,
-            unexpected_keys,
-            error_msgs,
-        )
-
     def _adj_position_embedding(self, pos_embed_used, batch_size):
         """Copy/pasted from https://github.com/935963004/LaBraM/blob/c431221e6cfd23dbfa9950e0180682fb322b0548/modeling_finetune.py#L358-L362"""
         input_time_window = self.patch_embed[0].n_patchs
@@ -1087,8 +1001,7 @@ class _PatchEmbed(nn.Module):
     but the original LaBraM expects pre-patched data (Batch, n_channels, n_patches, patch_size).
     This class reshapes the input to the pre-patched format, then applies a 2D
     convolution to project this pre-patched data to the embedding dimension,
-    and finally averages over grouped channels to produce one embedding per
-    temporal patch.
+    and finally flattens across channels to produce a unified embedding.
 
     Parameters:
     -----------

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/models/luna.py

@@ -22,7 +22,6 @@ import torch.nn as nn
 import torch.nn.functional as F
 from einops import rearrange
 
-from braindecode.functional import rotate_pairs
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
 from braindecode.modules.layers import DropPath
@@ -552,9 +551,8 @@ class _RotarySelfAttentionBlock(nn.Module):
         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).
         pairs = tensor.reshape(*tensor.shape[:-1], -1, 2)
-        rotated = rotate_pairs(pairs.flatten(-2))
+        rotated = torch.stack((-pairs[..., 1], pairs[..., 0]), dim=-1).flatten(-2)
         transformed = tensor * freqs.cos() + rotated * freqs.sin()
         return transformed.to(tensor.dtype)
 

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/models/summary.csv

@@ -58,7 +58,6 @@ LUNA,General,"Prediction, Embedding",128,"n_chans, n_times, sfreq, chs_info",710
 MEDFormer,General,Prediction,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Foundation Model,Convolution",EEG
 REVE,General,Prediction,200,"n_outputs, n_times, n_chans",69481476,"REVE(n_times=1000, n_outputs=4, n_chans=19)","Foundation Model,Attention/Transformer",EEG
 DGCNN,Emotion Recognition,Prediction,128,"n_chans, n_outputs, n_times, chs_info",1037385,"DGCNN(n_chans=62, n_outputs=4, n_times=128)","Graph Neural Network,Channel",EEG
-DIVER1,General,Prediction,500,"chs_info, n_outputs, n_times",12711366,"DIVER1(chs_info=<user>, n_outputs=4, n_times=1000, sfreq=500)","Attention/Transformer,Foundation Model,Channel",iEEG
 InterpolatedBENDR,General,"Prediction, Embedding",250,"chs_info, n_outputs, n_times",157143101,"InterpolatedBENDR(chs_info=<user>, n_outputs=4, n_times=1000)","Foundation Model,Convolution,Channel",EEG
 InterpolatedBIOT,"Sleep Staging, Epilepsy",Prediction,200,"chs_info, n_outputs, n_times, sfreq",3184101,"InterpolatedBIOT(chs_info=<user>, n_outputs=5, sfreq=200, n_times=6000)","Foundation Model,Channel",EEG
 InterpolatedEEGPT,General,Prediction,256,"chs_info, n_outputs, n_times",25323137,"InterpolatedEEGPT(chs_info=<user>, n_outputs=4, n_times=1024)","Foundation Model,Attention/Transformer,Channel",EEG

{braindecode-1.8.1.dev183674431 → braindecode-1.8.1.dev183849953}/braindecode/models/util.py

@@ -21,19 +21,6 @@ from torch import nn
 
 from braindecode.util import resolve_montage_name
 
-# Canonical MNE channel-type name for the electrode kinds braindecode models
-# tell apart.
-_KIND_TO_CH_TYPE = {
-    FIFF.FIFFV_EEG_CH: "eeg",
-    FIFF.FIFFV_SEEG_CH: "seeg",
-    FIFF.FIFFV_DBS_CH: "dbs",
-    FIFF.FIFFV_ECOG_CH: "ecog",
-}
-
-#: MNE channel types recorded from inside the skull.
-INTRACRANIAL_CH_TYPES = frozenset({"seeg", "dbs", "ecog"})
-
-
 models_dict = {}
 # Interpolated models are channel-interpolating wrappers around existing
 # braindecode backbones (see :func:`braindecode.models.InterpolatedModel`).
@@ -565,11 +552,6 @@ models_mandatory_parameters: list[
         {"n_chans": 19, "n_times": 6000},
     ),
     ("DGCNN", ["n_chans", "n_outputs", "n_times", "chs_info"], None),
-    (
-        "DIVER1",
-        ["chs_info", "n_outputs", "n_times"],
-        {"sfreq": 500.0},
-    ),
     ("EEGDINO", ["n_chans", "n_outputs", "n_times"], None),
     (
         "DANCE",
@@ -764,7 +746,6 @@ def get_summary_table(dir_name=None):
 def extract_channel_locations_from_chs_info(
     chs_info: Optional[Sequence[Dict[str, Any]]],
     num_channels: Optional[int] = None,
-    fill_missing: bool = False,
 ) -> Optional[np.ndarray]:
     """Extract 3D channel locations from MNE-style channel information.
 
@@ -781,31 +762,19 @@ def extract_channel_locations_from_chs_info(
     num_channels : int or None
         If specified, only extract the first ``num_channels`` channel locations.
         If None, extract all available channels.
-    fill_missing : bool
-        If False (default), extraction stops at the first channel whose location
-        is missing or malformed, so the result may be shorter than requested,
-        and an all-zero montage yields None. If True, each such channel
-        contributes a row of ``NaN`` instead, an all-zero montage yields all
-        ``NaN``, and the result always has one row per requested channel.
 
     Returns
     -------
     channel_locations : np.ndarray of shape (n_channels, 3) or None
         Array of 3D channel locations in cartesian coordinates. Returns None if
-        no valid locations are found, unless ``fill_missing=True``, in which
-        case missing locations are reported as ``NaN`` rows and None is only
-        returned when ``chs_info`` is None or no channel was requested.
+        no valid locations are found.
 
     Notes
     -----
     - This function handles both 12-element MNE location format (using indices 0:3)
       and 3-element location format (using directly).
-    - Invalid or missing locations cause extraction to stop at that point, unless
-      ``fill_missing=True``.
-    - An all-zero montage is treated as no montage at all, which is also how
-      :func:`has_valid_locations` reads it.
-    - Returns None if no valid locations can be extracted, except with
-      ``fill_missing=True`` as described above.
+    - Invalid or missing locations cause extraction to stop at that point.
+    - Returns None if no valid locations can be extracted.
     - This is a unified utility compatible with models like SignalJEPA and LUNA.
 
     Examples
@@ -823,22 +792,26 @@ def extract_channel_locations_from_chs_info(
     locations = []
     n_to_extract = num_channels if num_channels is not None else len(chs_info)
 
-    for i in range(n_to_extract):
-        ch_info = chs_info[i] if i < len(chs_info) else None
-        loc = ch_info.get("loc") if isinstance(ch_info, dict) else None
-        try:
-            coordinates = np.asarray(loc, dtype=np.float32)
-        except (ValueError, TypeError):
-            coordinates = np.asarray(np.nan, dtype=np.float32)
+    for i, ch_info in enumerate(chs_info[:n_to_extract]):
+        if not isinstance(ch_info, dict):
+            break
 
-        if coordinates.ndim == 1 and coordinates.size >= 3:
-            coordinates = coordinates[:3]
-        elif fill_missing:
-            coordinates = np.full(3, np.nan, dtype=np.float32)
-        else:
+        loc = ch_info.get("loc")
+        if loc is None:
             break
 
-        locations.append(coordinates)
+        try:
+            loc_array = np.asarray(loc, dtype=np.float32)
+
+            # MNE format: 12-element array with electrode position at indices 0:3
+            if loc_array.ndim == 1 and loc_array.size >= 3:
+                coordinates = loc_array[:3]
+            else:
+                break
+
+            locations.append(coordinates)
+        except (ValueError, TypeError):
+            break
 
     if len(locations) == 0:
         return None
@@ -847,10 +820,7 @@ def extract_channel_locations_from_chs_info(
 
     # Check positions are not all zero / degenerate
     if np.allclose(result, 0):
-        if not fill_missing:
-            return None
-        # An all-zero montage carries no position, just like an absent one
-        result = np.full_like(result, np.nan)
+        return None
 
     return result
 
@@ -958,7 +928,7 @@ def resolve_channel_indices(
     return cast(list[int], indices)
 
 
-def positions_from_chs_info(chs_info):
+def positions_from_chs_info(chs_info) -> np.ndarray:
     """``(n_chans, 2)`` electrode xy normalized to ``[0, 1]`` per axis.
 
     Takes the raw 3D sensor coordinates ``ch["loc"][:3]``, keeps ``xy`` and
@@ -970,26 +940,15 @@ def positions_from_chs_info(chs_info):
 
     Parameters
     ----------
-    chs_info : list of dict or torch.Tensor
+    chs_info : list of dict
         MNE-style channel info dicts, each with a ``"loc"`` array whose first
-        three entries are the head-frame ``x, y, z`` coordinates, or a floating
-        coordinate tensor of shape ``(n_chans, 3)`` in consistent units.
+        three entries are the head-frame ``x, y, z`` coordinates.
 
     Returns
     -------
-    numpy.ndarray or torch.Tensor
-        ``(n_chans, 2)`` float positions in ``[0, 1]``. Dictionary inputs retain
-        the NumPy float64 result. Tensor inputs preserve device and dtype and
-        support autograd and TorchScript. This does not return raw xyz or
-        convert metres to millimetres.
+    numpy.ndarray
+        ``(n_chans, 2)`` float positions in ``[0, 1]``.
     """
-    if isinstance(chs_info, torch.Tensor):
-        xy = chs_info[:, :2]
-        # Preserve the floor and backward intermediates at small half spans.
-        if xy.dtype == torch.float16 or xy.dtype == torch.bfloat16:
-            xy = xy.float()
-        mn, mx = xy.amin(dim=0), xy.amax(dim=0)
-        return ((xy - mn) / (mx - mn).clamp_min(1e-9)).to(chs_info.dtype)
     xyz = np.array([ch["loc"][:3] for ch in chs_info], dtype=float)
     xy = xyz[:, :2]
     mn, mx = xy.min(axis=0), xy.max(axis=0)
@@ -997,20 +956,7 @@ def positions_from_chs_info(chs_info):
 
 
 def has_valid_locations(chs_info) -> bool:
-    """Whether a montage has finite, not approximately all-zero locations.
-
-    ``chs_info`` accepts MNE channel dictionaries or a coordinate tensor of
-    shape ``(n_chans, 3)``. Coordinates retain their input units. The result is
-    a montage-wide Python bool, not a per-channel mask; zero rows are allowed
-    when another row is nonzero. The all-zero tolerance is ``1e-8``.
-    For a TorchScript-compatible per-row check, use :func:`valid_location_mask`.
-    """
-    if isinstance(chs_info, torch.Tensor):
-        return bool(
-            chs_info.numel() > 0
-            and torch.isfinite(chs_info).all()
-            and chs_info.abs().max().item() > 1e-8
-        )
+    """``True`` if ``chs_info`` carries finite, non-all-zero electrode locations."""
     if chs_info is None:
         return False
     try:
@@ -1024,72 +970,4 @@ def has_valid_locations(chs_info) -> bool:
     return True
 
 
-def valid_location_mask(locations: torch.Tensor) -> torch.Tensor:
-    """Flag finite, exactly nonzero coordinate rows without changing their units.
-
-    Parameters
-    ----------
-    locations : torch.Tensor
-        Coordinates of shape ``(..., 3)``, in any consistent coordinate frame
-        and units (e.g. xyz in metres or millimetres, not normalized xy).
-
-    Returns
-    -------
-    torch.Tensor
-        Boolean mask of shape ``(..., 1)`` on the input device. Unlike
-        :func:`has_valid_locations`, this tests each row against exact zero,
-        not an approximate montage-wide zero. Supports TorchScript.
-    """
-    return torch.isfinite(locations).all(dim=-1, keepdim=True) & (locations != 0).any(
-        dim=-1, keepdim=True
-    )
-
-
-def channel_types_from_chs_info(
-    chs_info: Optional[Sequence[Dict[str, Any]]],
-    num_channels: Optional[int] = None,
-) -> list[str]:
-    """Canonical MNE channel-type name for each channel of ``chs_info``.
-
-    Parameters
-    ----------
-    chs_info : list of dict or None
-        MNE-style channel info dicts, typically from ``mne.Info.chs``. Each
-        ``"kind"`` entry may be an MNE FIFF integer code or a plain type string.
-    num_channels : int or None
-        Number of channels to report. Channels beyond ``chs_info`` yield
-        ``"unknown"``, so the returned list always has this length. If None, one
-        entry per ``chs_info`` channel is returned (empty when it is None).
-
-    Returns
-    -------
-    list of str
-        Lowercase channel-type names such as ``"eeg"``, ``"seeg"``, ``"ecog"`` or
-        ``"dbs"``, and ``"unknown"`` where the kind is missing or is not one of
-        the electrode kinds resolved here.
-
-    Notes
-    -----
-    Only electrode kinds are resolved. An MNE ``"kind"`` code does not identify
-    every channel type on its own: code 2 is shared by ``"eeg"`` and ``"csd"``,
-    code 1 by ``"grad"`` and ``"mag"``, because MNE disambiguates those with
-    ``"unit"`` and ``"coil_type"``. Use :func:`mne.channel_type` with a full
-    :class:`mne.Info` when those channel types matter.
-    """
-    if num_channels is None:
-        num_channels = len(chs_info) if chs_info is not None else 0
-
-    types = []
-    for i in range(num_channels):
-        ch_info = chs_info[i] if chs_info is not None and i < len(chs_info) else None
-        kind = ch_info.get("kind") if isinstance(ch_info, dict) else None
-        if isinstance(kind, str):
-            types.append(kind.lower())
-        elif isinstance(kind, int):
-            types.append(_KIND_TO_CH_TYPE.get(kind, "unknown"))
-        else:
-            types.append("unknown")
-    return types
-
-
 _summary_table = get_summary_table()