Braindecode 1.6.1__tar.gz → 1.6.1.dev1014__tar.gz

{braindecode-1.6.1/braindecode.egg-info → braindecode-1.6.1.dev1014}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.6.1
+Version: 1.6.1.dev1014
 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.6.1 → braindecode-1.6.1.dev1014}/braindecode/augmentation/base.py

@@ -105,15 +105,7 @@ class Transform(torch.nn.Module):
         mask = self._get_mask(out_X.shape[0], out_X.device)
         num_valid = mask.sum().long()
 
-        if num_valid == out_X.shape[0]:
-            # Fast path: every sample is augmented (e.g. ``probability=1.0``,
-            # the common case). Operate on the whole batch and skip the boolean
-            # gather/scatter (``out_X[mask]`` then ``out_X[mask] = ...``), which
-            # would otherwise copy the batch twice.
-            out_X, out_y = self.operation(
-                out_X, out_y, **self.get_augmentation_params(out_X, out_y)
-            )
-        elif num_valid > 0:
+        if num_valid > 0:
             # Uses the mask to define the output
             out_X[mask, ...], tr_y = self.operation(
                 out_X[mask, ...],
@@ -176,47 +168,23 @@ class Compose(Transform):
         return X, y
 
 
-class _AugmentationCollate:
-    """Collate that applies a transform to each batch, with optional expansion.
-
-    A picklable callable (so it works with ``num_workers > 0``, unlike a
-    closure) that collates the batch once and then either augments it in place
-    or grows it.
+def _make_collateable(transform, device=None):
+    """Wraps a transform to make it collateable.
 
-    Parameters
-    ----------
-    transform : Transform
-        Transform applied to the collated ``(X, y)``.
-    device : str | torch.device | None, optional
-        Device the batch is moved to before transforming. Defaults to None.
-    n_augmentation : int, optional
-        ``0`` (default) applies the transform in place (batch size unchanged).
-        ``> 0`` keeps the clean originals and appends ``n_augmentation``
-        independently transformed copies, returning ``(X, y)`` of
-        ``(1 + n_augmentation)`` times the original size.
+    with device control.
     """
 
-    def __init__(self, transform, device=None, n_augmentation=0):
-        self.transform = transform
-        self.device = device
-        self.n_augmentation = n_augmentation
-
-    def __call__(self, batch):
-        collated = default_collate(batch)
-        X, y = collated[:2]
-        if self.device is not None:
-            X = X.to(self.device)
-            y = y.to(self.device)
-        if self.n_augmentation == 0:
-            return (*self.transform(X, y), *collated[2:])
-        # Fixed expansion: keep the clean originals, then append
-        # ``n_augmentation`` independently transformed copies.
-        xs, ys = [X], [y]
-        for _ in range(self.n_augmentation):
-            aug_X, aug_y = self.transform(X, y)
-            xs.append(aug_X)
-            ys.append(aug_y)
-        return torch.cat(xs), torch.cat(ys)
+    def _collate_fn(batch):
+        collated_batch = default_collate(batch)
+        X, y = collated_batch[:2]
+
+        if device is not None:
+            X = X.to(device)
+            y = y.to(device)
+
+        return (*transform(X, y), *collated_batch[2:])
+
+    return _collate_fn
 
 
 class AugmentedDataLoader(DataLoader):
@@ -230,44 +198,28 @@ class AugmentedDataLoader(DataLoader):
         Transform or sequence of Transform to be applied to each batch.
     device : str | torch.device | None, optional
         Device on which to transform the data. Defaults to None.
-    n_augmentation : int, optional
-        Number of augmented copies to append to each batch (fixed expansion).
-        When ``0`` (default) the transforms are applied in place and the batch
-        keeps its size (stochastic-per-epoch augmentation, backwards-compatible).
-        When ``> 0`` each batch becomes ``(1 + n_augmentation)`` times larger:
-        the clean originals are kept and ``n_augmentation`` independently
-        transformed copies are appended. This expresses augmentations defined as
-        a fixed set-expansion (e.g. the EEG-Inception MI 6x training set,
-        ``n_augmentation=5``). In this mode batches are returned as ``(X, y)``.
     **kwargs : dict, optional
         keyword arguments to pass to standard DataLoader class.
     """
 
-    def __init__(
-        self, dataset, transforms=None, device=None, n_augmentation=0, **kwargs
-    ):
+    def __init__(self, dataset, transforms=None, device=None, **kwargs):
         if "collate_fn" in kwargs:
             raise ValueError(
                 "collate_fn cannot be used in this context because it is used "
                 "to pass transform"
             )
-        if n_augmentation < 0:
-            raise ValueError("n_augmentation must be a non-negative integer.")
         if transforms is None or (
             isinstance(transforms, list) and len(transforms) == 0
         ):
-            transform = IdentityTransform()
+            self.collated_tr = _make_collateable(IdentityTransform(), device=device)
         elif isinstance(transforms, (Transform, nn.Module)):
-            transform = transforms
+            self.collated_tr = _make_collateable(transforms, device=device)
         elif isinstance(transforms, list):
-            transform = Compose(transforms)
+            self.collated_tr = _make_collateable(Compose(transforms), device=device)
         else:
             raise TypeError(
                 "transforms can be either a Transform object "
                 "or a list of Transform objects."
             )
 
-        self.collated_tr = _AugmentationCollate(
-            transform, device=device, n_augmentation=n_augmentation
-        )
         super().__init__(dataset, collate_fn=self.collated_tr, **kwargs)

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/augmentation/functional.py

@@ -18,7 +18,7 @@ from mne.filter import notch_filter
 from scipy.interpolate import Rbf
 from sklearn.utils import check_random_state
 from torch.fft import fft, ifft
-from torch.nn.functional import pad
+from torch.nn.functional import one_hot, pad
 
 
 def identity(X: torch.Tensor, y: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
@@ -253,34 +253,25 @@ def channels_dropout(
     return X * mask.unsqueeze(-1), y
 
 
-def _make_channel_permutation(
+def _make_permutation_matrix(
     X: torch.Tensor, mask: torch.Tensor, random_state: int | np.random.Generator | None
 ) -> torch.Tensor:
-    """Per-sample channel permutation that shuffles only the masked channels.
-
-    Returns a ``(batch, n_channels)`` index permutation: output channel ``i`` is
-    taken from input channel ``perm[b, i]``. Masked channels are permuted among
-    their own positions; unmasked channels keep their place.
-
-    The per-sample ``rng.permutation`` is kept (rather than a vectorized random
-    draw) so the output is bit-for-bit identical to the previous one-hot/matmul
-    implementation — vectorizing the draw would change seeded results. The win
-    is downstream: the caller gathers with this index instead of building
-    ``(batch, n_channels, n_channels)`` one-hot matrices and a matmul.
-    """
     rng = check_random_state(random_state)
     batch_size, n_channels, _ = X.shape
-    hard_mask = mask.round().bool()
-    channels = torch.arange(n_channels, device=X.device)
-    perm = channels.repeat(batch_size, 1)
-    for b in range(batch_size):
-        channels_to_shuffle = channels[hard_mask[b]]
-        perm[b, channels_to_shuffle] = torch.tensor(
-            rng.permutation(channels_to_shuffle.cpu()),
-            device=X.device,
-            dtype=perm.dtype,
+    hard_mask = mask.round()
+    batch_permutations = torch.empty(
+        batch_size, n_channels, n_channels, device=X.device
+    )
+    for b, mask in enumerate(hard_mask):
+        channels_to_shuffle = torch.arange(n_channels, device=X.device)
+        channels_to_shuffle = channels_to_shuffle[mask.bool()]
+        reordered_channels = torch.tensor(
+            rng.permutation(channels_to_shuffle.cpu()), device=X.device
         )
-    return perm
+        channels_permutation = torch.arange(n_channels, device=X.device)
+        channels_permutation[channels_to_shuffle] = reordered_channels
+        batch_permutations[b, ...] = one_hot(channels_permutation)
+    return batch_permutations
 
 
 def channels_shuffle(
@@ -323,11 +314,8 @@ def channels_shuffle(
     if p_shuffle == 0:
         return X, y
     mask = _pick_channels_randomly(X, 1 - p_shuffle, random_state)
-    perm = _make_channel_permutation(X, mask, random_state)
-    # Gather channels (output[b, i] = X[b, perm[b, i]]) instead of building
-    # one-hot permutation matrices and a (batch, C, C) @ (batch, C, T) matmul.
-    perm = perm.unsqueeze(-1).expand(-1, -1, X.shape[-1])
-    return torch.gather(X, 1, perm), y
+    batch_permutations = _make_permutation_matrix(X, mask, random_state)
+    return torch.matmul(batch_permutations, X), y
 
 
 def gaussian_noise(
@@ -1200,21 +1188,19 @@ def mask_encoding(
        32 (2024): 875-886.
     """
 
-    # All channels are zeroed at the same time positions, so build a single
-    # (batch, n_times) time-mask and broadcast it over channels, vectorized
-    # (no Python loop over batch * n_segments).
-    device = X.device
-    batch_indices = torch.arange(X.shape[0], device=device).repeat_interleave(
-        n_segments * segment_length
-    )
-    seg_indices = (
-        time_start.flatten().to(device)[:, None]
-        + torch.arange(segment_length, device=device)
-    ).flatten()
-    time_mask = torch.zeros(X.shape[0], X.shape[-1], dtype=torch.bool, device=device)
-    time_mask[batch_indices, seg_indices] = True
-
-    return X.masked_fill(time_mask.unsqueeze(1), 0), y
+    batch_indices = torch.arange(X.shape[0]).repeat_interleave(n_segments)
+    start_indices = time_start.flatten()
+    mask_indices = start_indices[:, None] + torch.arange(segment_length)
+
+    # Create a boolean mask with the same shape as X
+    mask = torch.zeros_like(X, dtype=torch.bool)
+    for batch_index, grouped_mask_indices in zip(batch_indices, mask_indices):
+        mask[batch_index, :, grouped_mask_indices] = True
+
+    # Apply the mask to set the values to 0
+    X[mask] = 0
+
+    return X, y  # Return the masked tensor and labels
 
 
 def channels_rereference(

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/datasets/__init__.py

@@ -10,7 +10,6 @@ from .base import (
 from .bcicomp import BCICompetitionIVDataset4
 from .bids import BIDSDataset, BIDSEpochsDataset
 from .chb_mit import CHBMIT
-from .collate import pad_channels_collate
 from .mne import create_from_mne_epochs, create_from_mne_raw
 from .moabb import BNCI2014_001, HGD, MOABBDataset
 from .nmt import NMT
@@ -43,5 +42,4 @@ __all__ = [
     "SleepPhysionetChallenge2018",
     "create_from_X_y",
     "BCICompetitionIVDataset4",
-    "pad_channels_collate",
 ]

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/datasets/base.py

@@ -192,31 +192,6 @@ def _channel_info(mne_obj):
     return n_ch, type_str, sfreq
 
 
-def _compute_ch_pos(info, targets_from):
-    """Return ``(n_ch, 3)`` float32 electrode positions aligned to ``X``'s rows.
-
-    Positions are the MNE head-frame coordinates ``info["chs"][i]["loc"][:3]``
-    (meters) -- the same representation braindecode models already consume (see
-    e.g. ``signal_jepa``/``REVE``). When ``targets_from != "metadata"`` the
-    window's misc channels are dropped from ``X`` in ``__getitem__``, so the
-    matching misc rows are dropped here too. Emits a one-time ``UserWarning`` if
-    no channel carries a real position (no montage set).
-    """
-    pos = np.asarray([ch["loc"][:3] for ch in info["chs"]], dtype="float32")
-    if targets_from != "metadata":
-        misc_mask = np.asarray(info.get_channel_types()) == "misc"
-        pos = pos[~misc_mask]
-    has_pos = np.isfinite(pos).all(axis=1) & np.any(pos != 0, axis=1)
-    if pos.size and not has_pos.any():
-        warnings.warn(
-            "Returning channel positions but no montage is set: all positions "
-            "are zero/non-finite. Call ``raw.set_montage(...)`` (or set a "
-            "montage during preprocessing) before enabling ``return_ch_pos``.",
-            UserWarning,
-        )
-    return pos
-
-
 def _window_info(crop_inds, sfreq):
     """Extract window size from crop indices.
 
@@ -473,10 +448,6 @@ class RecordDataset(Dataset[tuple[np.ndarray, int | str, tuple[int, int, int]]])
     ):
         self._description = _create_description(description)
         self.transform = transform
-        # Opt-in: when True, ``__getitem__`` appends channel positions (n_ch, 3).
-        # Default off keeps the public ``(X, y, crop_inds)`` contract intact.
-        self.return_ch_pos = False
-        self._ch_pos = None
 
     @abstractmethod
     def __len__(self) -> int:
@@ -779,20 +750,6 @@ class EEGWindowsDataset(_ZarrMixin, RecordDataset):
     @raw.setter
     def raw(self, value):
         self._raw = value
-        self._ch_pos = None  # invalidate cached positions
-
-    @property
-    def ch_pos(self):
-        """Electrode positions ``(n_ch, 3)`` (x, y, z) aligned to ``X``'s channels.
-
-        Cached MNE head-frame coordinates in meters. Rows match the channels
-        returned by :meth:`__getitem__` (misc target channels excluded when
-        ``targets_from="channels"``). All-zero/NaN when no montage is set.
-        """
-        if self._ch_pos is None:
-            info = self._raw.info if self._raw is not None else self._make_mne_info()
-            self._ch_pos = _compute_ch_pos(info, self.targets_from)
-        return self._ch_pos
 
     def __getitem__(self, index: int):
         """Get a window and its target.
@@ -836,8 +793,6 @@ class EEGWindowsDataset(_ZarrMixin, RecordDataset):
                 y = X[misc_mask, :]
             y = y.copy()
             X = X[~misc_mask, :]
-        if self.return_ch_pos:
-            return X, y, crop_inds, self.ch_pos
         return X, y, crop_inds
 
     def __len__(self):
@@ -1061,24 +1016,6 @@ class WindowsDataset(_ZarrMixin, RecordDataset):
     @windows.setter
     def windows(self, value):
         self._windows = value
-        self._ch_pos = None  # invalidate cached positions
-
-    @property
-    def ch_pos(self):
-        """Electrode positions ``(n_ch, 3)`` (x, y, z) aligned to ``X``'s channels.
-
-        Cached MNE head-frame coordinates in meters. Rows match the channels
-        returned by :meth:`__getitem__` (misc target channels excluded when
-        ``targets_from="channels"``). All-zero/NaN when no montage is set.
-        """
-        if self._ch_pos is None:
-            info = (
-                self._windows.info
-                if self._windows is not None
-                else self._make_mne_info()
-            )
-            self._ch_pos = _compute_ch_pos(info, self.targets_from)
-        return self._ch_pos
 
     @staticmethod
     def _can_use_fast_get_epoch_from_raw(epochs: mne.BaseEpochs) -> bool:
@@ -1131,8 +1068,6 @@ class WindowsDataset(_ZarrMixin, RecordDataset):
         # necessary to cast as list to get list of three tensors from batch,
         # otherwise get single 2d-tensor...
         crop_inds = self.crop_inds[index].tolist()
-        if self.return_ch_pos:
-            return X, y, crop_inds, self.ch_pos
         return X, y, crop_inds
 
     def __len__(self) -> int:
@@ -1523,50 +1458,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 )
         return self
 
-    def set_return_ch_pos(self, value: bool = True) -> "BaseConcatDataset":
-        """Toggle returning electrode positions from every subdataset.
-
-        When enabled, each windowed subdataset's ``__getitem__`` appends a
-        ``(n_ch, 3)`` array of electrode positions (x, y, z), so a batch yields
-        ``(X, y, crop_inds, ch_pos)``. Heterogeneous (variable-channel)
-        collections additionally need
-        :func:`braindecode.datasets.pad_channels_collate` as the DataLoader
-        ``collate_fn``. Default-off: leaves the ``(X, y, crop_inds)`` contract
-        untouched.
-
-        Parameters
-        ----------
-        value : bool
-            Whether to return channel positions (default ``True``).
-
-        Returns
-        -------
-        self : BaseConcatDataset
-        """
-        for ds in self.datasets:
-            ds.return_ch_pos = value
-        return self
-
-    @property
-    def ch_pos(self):
-        """Electrode positions ``(n_ch, 3)`` from the first recording.
-
-        Convenience accessor mirroring how the repr reports channel info "from
-        first recording". For per-sample positions in a heterogeneous
-        collection, enable :meth:`set_return_ch_pos` and read them from the
-        batch instead.
-        """
-        if not self.datasets:
-            raise ValueError("Empty BaseConcatDataset has no channel positions.")
-        first = self.datasets[0]
-        if not hasattr(first, "ch_pos"):
-            raise AttributeError(
-                f"{type(first).__name__} does not expose channel positions; "
-                "ch_pos is available on windowed datasets (EEGWindowsDataset / "
-                "WindowsDataset)."
-            )
-        return first.ch_pos
-
     def _outdated_save(self, path, overwrite=False):
         """This is a copy of the old saving function, that had inconsistent.
 

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/eegneuralnet.py

@@ -134,14 +134,7 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         i_window_in_trials = []
         i_window_stops = []
         window_ys = []
-        for batch in self.get_iterator(dataset, drop_index=False):
-            if len(batch) > 3:
-                raise ValueError(
-                    "Cropped prediction does not support channel positions; "
-                    "disable return_ch_pos (set_return_ch_pos(False)) for cropped "
-                    "evaluation."
-                )
-            X, y, i = batch[0], batch[1], batch[2]
+        for X, y, i in self.get_iterator(dataset, drop_index=False):
             i_window_in_trials.append(i[0].cpu().numpy())
             i_window_stops.append(i[2].cpu().numpy())
             with torch.no_grad():

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/functional/__init__.py

@@ -1,30 +1,22 @@
 from .functions import (
     _get_gaussian_kernel1d,
-    daubechies_filters,
     drop_path,
-    dwt_max_level,
     hilbert_freq,
     identity,
     plv_time,
     safe_log,
-    sinusoidal_positional_encoding,
     square,
-    wavelet_decomposition,
 )
 from .initialization import glorot_weight_zero_bias, rescale_parameter
 
 __all__ = [
     "_get_gaussian_kernel1d",
-    "daubechies_filters",
     "drop_path",
-    "dwt_max_level",
     "hilbert_freq",
     "identity",
     "plv_time",
     "safe_log",
-    "sinusoidal_positional_encoding",
     "square",
-    "wavelet_decomposition",
     "glorot_weight_zero_bias",
     "rescale_parameter",
 ]

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/functional/functions.py

@@ -1,13 +1,7 @@
 # Authors: Robin Schirrmeister <robintibor@gmail.com>
-#          Bruno Aristimunha <b.aristimunha@gmail.com>
 #
 # License: BSD (3-clause)
 
-from __future__ import annotations
-
-import math
-
-import numpy as np
 import torch
 import torch.nn.functional as F
 
@@ -255,156 +249,3 @@ def plv_time(x, forward_fourier=True, epsilon: float = 1e-6):
     )
 
     return plv_matrix
-
-
-def daubechies_filters(n_vanishing: int) -> torch.Tensor:
-    r"""Daubechies ``db<n_vanishing>`` wavelet decomposition filters.
-
-    Computes the orthogonal decomposition (analysis) low-pass and high-pass
-    filters by spectral factorisation of the Daubechies half-band (Bezout)
-    polynomial, so no external wavelet library (PyWavelets, ptwt) is required.
-    For ``n_vanishing=4`` the result equals ``pywt.Wavelet("db4").dec_lo`` /
-    ``.dec_hi`` to machine precision (bit-identical once cast to ``float32``).
-
-    Parameters
-    ----------
-    n_vanishing : int
-        Number of vanishing moments (the ``N`` in ``dbN``). The filters have
-        ``2 * n_vanishing`` taps.
-
-    Returns
-    -------
-    torch.Tensor
-        Shape ``(2, 2 * n_vanishing)`` whose rows are the low-pass and high-pass
-        decomposition filters ``[dec_lo, dec_hi]``.
-
-    Notes
-    -----
-    Half-band polynomial :math:`P(y) = \sum_{k=0}^{N-1} \binom{N-1+k}{k} y^k`
-    with :math:`y = (1 - \cos\omega)/2`. Its roots are mapped to the
-    minimum-phase (:math:`|z| < 1`) roots of :math:`z^2 - 2(1-2y)z + 1`; the
-    analysis low-pass is :math:`H(z) = (1+z)^N` times that spectral factor
-    (normalised so it sums to :math:`\sqrt 2`), and the high-pass is the
-    quadrature mirror :math:`g_k = (-1)^{k+1} h_{L-1-k}`.
-    """
-    n = n_vanishing
-    poly = np.array([math.comb(n - 1 + k, k) for k in range(n)], dtype=float)
-    z_inside = []
-    for y in np.roots(poly[::-1]):
-        b = -2.0 * (1.0 - 2.0 * y)
-        disc = np.sqrt(b * b - 4.0 + 0j)
-        r1, r2 = (-b + disc) / 2.0, (-b - disc) / 2.0
-        z_inside.append(r1 if abs(r1) < 1.0 else r2)
-    low = np.poly([-1.0] * n + z_inside).real
-    low *= math.sqrt(2.0) / low.sum()
-    dec_lo = low[::-1]  # pywt stores the time-reversed decomposition low-pass
-    length = len(dec_lo)
-    dec_hi = np.array(
-        [(-1.0) ** (k + 1) * dec_lo[length - 1 - k] for k in range(length)]
-    )
-    return torch.tensor(np.stack([dec_lo, dec_hi]), dtype=torch.float32)
-
-
-def dwt_max_level(n_times: int, filter_len: int) -> int:
-    """Maximum number of discrete wavelet decomposition levels.
-
-    Matches ``pywt.dwt_max_level`` = ``floor(log2(n_times / (filter_len - 1)))``.
-
-    Parameters
-    ----------
-    n_times : int
-        Length of the signal.
-    filter_len : int
-        Number of wavelet filter taps.
-
-    Returns
-    -------
-    int
-        Maximum decomposition level (``0`` if the signal is shorter than the
-        filter).
-    """
-    if n_times < filter_len:
-        return 0
-    return max(0, int(math.floor(math.log2(n_times / (filter_len - 1)))))
-
-
-def wavelet_decomposition(
-    x: torch.Tensor, filters: torch.Tensor, n_levels: int | None = None
-) -> torch.Tensor:
-    r"""Multilevel discrete wavelet decomposition with periodic boundary.
-
-    A cascade of strided convolutions with circular padding, bit-identical to
-    ``pywt`` / ``ptwt`` ``wavedec(mode="periodic")``. The approximation and
-    detail coefficients of every level are concatenated along the last axis as
-    ``[cA_n, cD_n, cD_{n-1}, ..., cD_1]``.
-
-    Parameters
-    ----------
-    x : torch.Tensor
-        Input signal of shape ``(..., n_times)``.
-    filters : torch.Tensor
-        Decomposition filters of shape ``(2, filter_len)`` =
-        ``[low-pass, high-pass]`` (e.g. from :func:`daubechies_filters`).
-    n_levels : int, optional
-        Number of decomposition levels. Defaults to the maximum
-        (:func:`dwt_max_level`).
-
-    Returns
-    -------
-    torch.Tensor
-        Concatenated coefficients of shape ``(..., dwt_len)``.
-    """
-    filter_len = filters.shape[-1]
-    if n_levels is None:
-        n_levels = dwt_max_level(x.shape[-1], filter_len)
-    leading = x.shape[:-1]
-    approx = x.reshape(-1, x.shape[-1])
-    # Flip the taps so conv1d (cross-correlation) realises the wavelet convolution.
-    weight = filters.flip(-1).unsqueeze(1).to(device=approx.device, dtype=approx.dtype)
-    details = []
-    for _ in range(n_levels):
-        pad = (2 * filter_len - 3) // 2
-        padded = F.pad(
-            approx.unsqueeze(1), (pad, pad + approx.shape[-1] % 2), mode="circular"
-        )
-        approx, detail = F.conv1d(padded, weight, stride=2).unbind(dim=1)
-        details.append(detail)
-    out = torch.cat([approx, *reversed(details)], dim=-1)
-    return out.reshape(*leading, -1)
-
-
-def sinusoidal_positional_encoding(n_positions: int, dim: int) -> torch.Tensor:
-    r"""Fixed sine/cosine positional-encoding table of shape ``(n_positions, dim)``.
-
-    The standard encoding of Vaswani et al. (2017): for position :math:`p` and
-    channel :math:`i`, :math:`pe[p, 2i] = \sin(p / 10000^{2i/d})` and
-    :math:`pe[p, 2i+1] = \cos(p / 10000^{2i/d})`. PyTorch ships no sinusoidal
-    encoding (``nn.Embedding`` is a *learned* lookup), so braindecode models that
-    need one share this primitive instead of re-deriving it. An odd ``dim`` is
-    computed on the next even width and truncated, reproducing the per-model
-    wrappers (e.g. :class:`~braindecode.models.medformer` odd-``d_model``).
-
-    Parameters
-    ----------
-    n_positions : int
-        Number of positions (sequence length) to encode.
-    dim : int
-        Embedding dimension of each position.
-
-    Returns
-    -------
-    torch.Tensor
-        ``(n_positions, dim)`` float table; callers add their own batch axis,
-        dropout, or offset.
-    """
-    dim_even = dim + (dim % 2)
-    position = torch.arange(n_positions).unsqueeze(1).float()
-    div_term = torch.exp(
-        torch.arange(0, dim_even, 2).float() * (-math.log(10000.0) / dim_even)
-    )
-    pe = torch.zeros(n_positions, dim_even)
-    pe[:, 0::2] = torch.sin(position * div_term)
-    pe[:, 1::2] = torch.cos(position * div_term)
-    # ``.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()

{braindecode-1.6.1 → braindecode-1.6.1.dev1014}/braindecode/models/__init__.py

@@ -38,7 +38,6 @@ from .luna import LUNA
 from .medformer import MEDFormer
 from .meta_neuromotor import MetaNeuromotorHand
 from .msvtnet import MSVTNet
-from .mvpformer import MVPFormer
 from .patchedtransformer import PBT
 from .reve import REVE
 from .sccnet import SCCNet
@@ -55,7 +54,6 @@ from .sleep_stager_blanco_2020 import SleepStagerBlanco2020
 from .sleep_stager_chambon_2018 import SleepStagerChambon2018
 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
@@ -67,7 +65,6 @@ from .util import (
     build_model_config,
     extract_channel_locations_from_chs_info,
     models_mandatory_parameters,
-    positions_from_chs_info,
 )
 
 # Call this last in order to make sure the dataset list is populated with
@@ -117,10 +114,8 @@ __all__ = [
     "Labram",
     "LUNA",
     "extract_channel_locations_from_chs_info",
-    "positions_from_chs_info",
     "MEDFormer",
     "MSVTNet",
-    "MVPFormer",
     "PBT",
     "REVE",
     "SCCNet",
@@ -134,7 +129,6 @@ __all__ = [
     "SleepStagerBlanco2020",
     "SleepStagerChambon2018",
     "SPARCNet",
-    "STEEGFormer",
     "SyncNet",
     "BDTCN",
     "TCFormer",