Braindecode 1.8.1.dev169869285__tar.gz → 1.8.1.dev169883370__tar.gz

{braindecode-1.8.1.dev169869285 → braindecode-1.8.1.dev169883370}/NOTICE.txt

@@ -40,22 +40,19 @@ The following components are licensed under the MIT License:
 
 - `braindecode/models/ctnet.py`
 - `braindecode/models/dance.py`
-- `braindecode/models/duin.py`
 - `braindecode/models/medformer.py`
 - `braindecode/models/tcformer.py`
 - `braindecode/models/ifnet.py`
 - `braindecode/models/mirepnet.py`
 - `braindecode/models/popt.py`
 - `braindecode/models/tfm_tokenizer.py`
+- `braindecode/modules/popt_modules.py`
 - `braindecode/models/brainomni.py`
 - `braindecode/modules/quantization.py`
 - `braindecode/modules/linear_attention.py`
 - `braindecode/models/seizure_transformer.py`
 - `docs/_static/model/seizure_transformer_arch.png`
-- `braindecode/models/guetschel2026.py`
 - `braindecode/models/tmsanet.py`
-- `braindecode/models/epint.py`
-- `braindecode/models/gcnsnet.py`
 
 The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
 SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The

{braindecode-1.8.1.dev169869285/braindecode.egg-info → braindecode-1.8.1.dev169883370}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev169869285
+Version: 1.8.1.dev169883370
 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>
@@ -32,8 +32,8 @@ Requires-Dist: joblib
 Requires-Dist: torchinfo
 Requires-Dist: pandas
 Requires-Dist: wfdb>=4.3.1
+Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
-Requires-Dist: einops
 Requires-Dist: pydantic>=2.0
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.4.3; extra == "moabb"

{braindecode-1.8.1.dev169869285 → braindecode-1.8.1.dev169883370}/braindecode/augmentation/__init__.py

@@ -10,11 +10,9 @@ from .transforms import (
     ChannelsReref,
     ChannelsShuffle,
     ChannelsSymmetry,
-    CutMix,
     FrequencyShift,
     FTSurrogate,
     GaussianNoise,
-    LabelSmoothing,
     MaskEncoding,
     Mixup,
     SegmentationReconstruction,
@@ -38,10 +36,8 @@ __all__ = [
     "SignFlip",
     "FTSurrogate",
     "ChannelsShuffle",
-    "CutMix",
     "ChannelsDropout",
     "GaussianNoise",
-    "LabelSmoothing",
     "ChannelsSymmetry",
     "SmoothTimeMask",
     "BandstopFilter",

{braindecode-1.8.1.dev169869285 → braindecode-1.8.1.dev169883370}/braindecode/augmentation/base.py

@@ -171,13 +171,7 @@ class Compose(Transform):
         self.transforms = transforms
         super().__init__()
 
-    def forward(self, X, y=None):
-        # like Transform.forward, return only X when no target is given (each
-        # transform then returns a single tensor, not an (X, y) pair)
-        if y is None:
-            for transform in self.transforms:
-                X = transform(X)
-            return X
+    def forward(self, X, y):
         for transform in self.transforms:
             X, y = transform(X, y)
         return X, y

{braindecode-1.8.1.dev169869285 → braindecode-1.8.1.dev169883370}/braindecode/augmentation/functional.py

@@ -19,22 +19,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 one_hot, pad
-
-
-def _max_float_dtype(device: torch.device | str) -> torch.dtype:
-    """float64, or float32 on Apple MPS, which has no float64."""
-    return torch.float32 if torch.device(device).type == "mps" else torch.float64
-
-
-def _to_device(t: torch.Tensor, device: torch.device | str) -> torch.Tensor:
-    """Move ``t`` to ``device``, in single precision on MPS (no float64 there)."""
-    if torch.device(device).type == "mps":
-        if t.dtype == torch.float64:
-            return t.float().to(device)
-        if t.dtype == torch.complex128:
-            return t.to(torch.complex64).to(device)
-    return t.to(device)
+from torch.nn.functional import pad
 
 
 def identity(X: torch.Tensor, y: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
@@ -107,11 +92,10 @@ def _new_random_fft_phase_odd(
     rng = check_random_state(random_state)
     random_phase = torch.from_numpy(
         2j * np.pi * rng.random((batch_size, c, (n - 1) // 2))
-    )
-    random_phase = _to_device(random_phase, device)
+    ).to(device)
     return torch.cat(
         [
-            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
+            torch.zeros((batch_size, c, 1), device=device),
             random_phase,
             -torch.flip(random_phase, [-1]),
         ],
@@ -129,13 +113,12 @@ def _new_random_fft_phase_even(
     rng = check_random_state(random_state)
     random_phase = torch.from_numpy(
         2j * np.pi * rng.random((batch_size, c, n // 2 - 1))
-    )
-    random_phase = _to_device(random_phase, device)
+    ).to(device)
     return torch.cat(
         [
-            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
+            torch.zeros((batch_size, c, 1), device=device),
             random_phase,
-            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
+            torch.zeros((batch_size, c, 1), device=device),
             -torch.flip(random_phase, [-1]),
         ],
         dim=-1,
@@ -195,7 +178,7 @@ def ft_surrogate(
         and 0 <= phase_noise_magnitude <= 1
     ), f"eps must be a float between 0 and 1. Got {phase_noise_magnitude}."
 
-    f = fft(X.to(_max_float_dtype(X.device)), dim=-1)
+    f = fft(X.double(), dim=-1)
     device = X.device
 
     n = f.shape[-1]
@@ -597,7 +580,6 @@ def _frequency_shift(X: torch.Tensor, fs: float, f_shift: float) -> torch.Tensor
         _f_shift = torch.as_tensor(f_shift).float()
     else:
         raise ValueError(f"Invalid f_shift type: {type(f_shift)}")
-    _f_shift = _f_shift.to(X.device)
     f_shift_stack = _f_shift.repeat(N_padded, n_channels, 1)
     reshaped_f_shift = f_shift_stack.permute(
         *torch.arange(f_shift_stack.ndim - 1, -1, -1)
@@ -929,15 +911,7 @@ def _rotate_signals(
     sensors_positions_matrix: torch.Tensor,
     spherical: bool = True,
 ) -> torch.Tensor:
-    if X.device.type == "mps":
-        # MPS has no float64: compute the small (n_chans x n_chans) spherical
-        # spline matrices on CPU in double precision, only move the result
-        # (two separate steps: a combined device + dtype .to() from MPS
-        # returns zeros with some torch versions)
-        sensors_positions_matrix = sensors_positions_matrix.cpu().double()
-        rotations = [rotation.cpu().double() for rotation in rotations]
-    else:
-        sensors_positions_matrix = sensors_positions_matrix.to(X.device)
+    sensors_positions_matrix = sensors_positions_matrix.to(X.device)
     rot_sensors_matrices = [
         rotation.matmul(sensors_positions_matrix) for rotation in rotations
     ]
@@ -947,10 +921,9 @@ def _rotate_signals(
                 torch.as_tensor(
                     _torch_make_interpolation_matrix(
                         sensors_positions_matrix.T, rot_sensors_matrix.T
-                    )
-                )
-                .float()
-                .to(X.device)
+                    ),
+                    device=X.device,
+                ).float()
                 for rot_sensors_matrix in rot_sensors_matrices
             ]
         )
@@ -959,7 +932,7 @@ def _rotate_signals(
         transformed_X = X.clone()
         sensors_positions = list(sensors_positions_matrix)
         for s, rot_sensors_matrix in enumerate(rot_sensors_matrices):
-            rot_sensors_positions = list(rot_sensors_matrix)
+            rot_sensors_positions = list(rot_sensors_matrix.T)
             for time in range(X.shape[-1]):
                 interpolator_t = Rbf(*sensors_positions, X[s, :, time])
                 transformed_X[s, :, time] = torch.from_numpy(
@@ -1089,12 +1062,10 @@ def mixup(
         Online: https://arxiv.org/abs/1710.09412
     .. [2] https://github.com/facebookresearch/mixup-cifar10/blob/master/train.py
     """
+    device = X.device
     batch_size, n_channels, n_times = X.shape
 
-    X_mix = X.new_zeros(
-        (batch_size, n_channels, n_times),
-        dtype=X.dtype if X.is_floating_point() else torch.get_default_dtype(),
-    )
+    X_mix = torch.zeros((batch_size, n_channels, n_times)).to(device)
     y_a = y.clone()
     y_b = y[idx_perm].clone()
 
@@ -1104,145 +1075,6 @@ def mixup(
     return X_mix, (y_a, y_b, lam)
 
 
-def cutmix(
-    X: torch.Tensor,
-    y: torch.Tensor,
-    idx_perm: torch.Tensor,
-    cut_t_start: torch.Tensor,
-    cut_t_len: torch.Tensor,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Paste a time region of shuffled examples into the original examples.
-
-    See [1]_ for details.
-
-    Parameters
-    ----------
-    X : torch.Tensor
-        EEG data in form ``batch_size, n_channels, n_times``
-    y : torch.Tensor
-        Target of length ``batch_size``
-    idx_perm : torch.Tensor
-        Permuted indices of example that are mixed into original examples.
-    cut_t_start : torch.Tensor
-        Start index of the pasted time region for each example.
-    cut_t_len : torch.Tensor
-        Length of the pasted time region for each example.
-
-    Returns
-    -------
-    tuple
-        ``X``, ``y``. Where ``X`` is augmented and ``y`` is a tuple of length
-        3 containing the labels of the two mixed examples and the fraction of
-        each example kept from the original, ``1 - cut_t_len / n_times``.
-
-    References
-    ----------
-    .. [1] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun,
-        Junsuk Choe, Youngjoon Yoo (2019). CutMix: Regularization Strategy
-        to Train Strong Classifiers with Localizable Features. In 2019
-        IEEE/CVF International Conference on Computer Vision (ICCV)
-        Online: https://arxiv.org/abs/1905.04899
-    """
-    n_times = X.shape[-1]
-    t = torch.arange(n_times, device=X.device)
-    start = cut_t_start[:, None]
-    in_cut = (t >= start) & (t < start + cut_t_len[:, None])
-    X_mix = torch.where(in_cut[:, None], X[idx_perm], X)
-    lam = (n_times - cut_t_len).to(X.dtype) / n_times
-    return X_mix, (y.clone(), y[idx_perm].clone(), lam)
-
-
-def label_smoothing(
-    X: torch.Tensor,
-    y: torch.Tensor,
-    epsilon: float,
-    num_classes: int | None = None,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Smooth targets toward the uniform distribution over the classes.
-
-    See [1]_ for details.
-
-    Parameters
-    ----------
-    X : torch.Tensor
-        EEG data in form ``batch_size, n_channels, n_times``. Returned
-        unchanged.
-    y : torch.Tensor
-        Target of length ``batch_size`` holding class indices (float values
-        are accepted when they are integral), or a floating-point tensor of
-        shape ``batch_size, num_classes`` holding target distributions.
-    epsilon : float
-        Smoothing parameter between 0 and 1: the weight of the uniform
-        distribution mixed into the targets. ``0`` returns the unsmoothed
-        targets.
-    num_classes : int | None, optional
-        Number of classes. Required when ``y`` holds class indices; when
-        ``y`` already holds distributions, it must match the size of the
-        last dimension of ``y``. Defaults to None.
-
-    Returns
-    -------
-    tuple
-        ``X``, ``y``. Where ``X`` is unchanged and ``y`` is a
-        floating-point tensor of shape ``batch_size, num_classes`` whose
-        rows sum to one.
-
-    References
-    ----------
-    .. [1] Christian Szegedy, Vincent Vanhoucke, Jonathon Shlens and
-        Zbigniew Wojna (2016). Rethinking the Inception Architecture for
-        Computer Vision. In 2016 IEEE Conference on Computer Vision and
-        Pattern Recognition (CVPR), pp. 2818-2826.
-        Online: https://arxiv.org/abs/1512.00567
-    """
-    if not isinstance(epsilon, Real) or not 0.0 <= float(epsilon) <= 1.0:
-        raise ValueError(
-            f"epsilon should be a real number between 0 and 1. Got {epsilon!r}."
-        )
-    if num_classes is not None and (
-        not isinstance(num_classes, int)
-        or isinstance(num_classes, bool)
-        or num_classes < 2
-    ):
-        raise ValueError(
-            f"num_classes should be an integer of at least 2. Got {num_classes!r}."
-        )
-
-    if y.dim() == 1:
-        # class-index targets: smooth their one-hot encoding
-        if num_classes is None:
-            raise ValueError("num_classes is required when y holds class indices.")
-        if not torch.all(y == y.floor()):
-            raise ValueError(
-                "y holds non-integral values; class-index targets should be "
-                "integers or integral floats."
-            )
-        if y.numel() > 0 and (y.min() < 0 or y.max() >= num_classes):
-            raise ValueError(f"y holds class indices outside [0, {num_classes}).")
-        one_hot_y = one_hot(y.long(), num_classes).to(dtype=X.dtype)
-        return X, one_hot_y * (1.0 - epsilon) + epsilon / num_classes
-
-    if y.is_floating_point() and y.dim() >= 2:
-        # target distributions: interpolate them toward the uniform one
-        n_classes = y.shape[-1]
-        if num_classes is not None and num_classes != n_classes:
-            raise ValueError(
-                f"num_classes ({num_classes}) does not match the size of the "
-                f"last dimension of y ({n_classes})."
-            )
-        if n_classes < 2:
-            raise ValueError(
-                f"y should hold distributions over at least 2 classes. Got {n_classes}."
-            )
-        return X, y * (1.0 - epsilon) + epsilon / n_classes
-
-    raise ValueError(
-        "y should hold class indices or floating-point target distributions "
-        f"with a class dimension; got dtype {y.dtype} and shape "
-        f"{tuple(y.shape)}."
-    )
-
-
 def segmentation_reconstruction(
     X: torch.Tensor,
     y: torch.Tensor,

{braindecode-1.8.1.dev169869285 → braindecode-1.8.1.dev169883370}/braindecode/augmentation/transforms.py

@@ -3,7 +3,6 @@
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
 #          Bruna Lopes <brunajaflopes@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
-#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -18,7 +17,6 @@ from braindecode.util import resolve_montage_name
 
 from .base import Transform
 from .functional import (
-    _max_float_dtype,
     amplitude_scale,
     band_rotation,
     bandstop_filter,
@@ -26,11 +24,9 @@ from .functional import (
     channels_permute,
     channels_rereference,
     channels_shuffle,
-    cutmix,
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
-    label_smoothing,
     mask_encoding,
     mixup,
     segmentation_reconstruction,
@@ -496,7 +492,6 @@ class SmoothTimeMask(Transform):
                 size=X.shape[0],
             ),
             device=X.device,
-            dtype=_max_float_dtype(X.device),
         ) * (seq_length - mask_len_samples)
         return {
             "mask_start_per_sample": mask_start,
@@ -678,11 +673,7 @@ class FrequencyShift(Transform):
             return super().get_augmentation_params(*batch)
         X = batch[0]
 
-        u = torch.as_tensor(
-            self.rng.uniform(size=X.shape[0]),
-            device=X.device,
-            dtype=_max_float_dtype(X.device),
-        )
+        u = torch.as_tensor(self.rng.uniform(size=X.shape[0]), device=X.device)
         max_delta_freq = self.max_delta_freq
         if isinstance(max_delta_freq, torch.Tensor):
             max_delta_freq = max_delta_freq.to(X.device)
@@ -840,10 +831,7 @@ class SensorsRotation(Transform):
         if isinstance(max_degrees, torch.Tensor):
             max_degrees = max_degrees.to(X.device)
         random_angles = (
-            torch.as_tensor(u, device=X.device, dtype=_max_float_dtype(X.device))
-            * 2
-            * max_degrees
-            - max_degrees
+            torch.as_tensor(u, device=X.device) * 2 * max_degrees - max_degrees
         )
         return {
             "sensors_positions_matrix": self.sensors_positions_matrix,
@@ -1107,147 +1095,6 @@ class Mixup(Transform):
         }
 
 
-class CutMix(Mixup):
-    """Implements CutMix for EEG data.
-
-    A random time region of each example is replaced by the same region of
-    a shuffled example of the batch, see [1]_. As in the reference code [2]_,
-    a coefficient ``lam`` is drawn from a Beta distribution, the region is
-    ``(1 - lam) * n_times`` long (the 1-D analogue of the cut area ratio
-    ``1 - lam``) around a uniformly drawn center, it is clipped at the trial
-    boundaries, and ``lam`` is then recomputed from the pasted length.
-
-    Like :class:`Mixup`, it applies to whole batches and returns targets
-    ``(y_a, y_b, lam)`` for :func:`braindecode.training.mixup_criterion`.
-
-    Parameters
-    ----------
-    alpha : float
-        Parameter of the Beta distribution of ``lam``. ``alpha <= 0`` cuts
-        nothing.
-    beta_per_sample : bool (default=False)
-        By default, one ``lam`` per batch is drawn. If True, one per sample.
-    random_state : int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Defaults to None.
-
-    References
-    ----------
-    .. [1] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun,
-       Junsuk Choe, Youngjoon Yoo (2019). CutMix: Regularization Strategy
-       to Train Strong Classifiers with Localizable Features. In 2019
-       IEEE/CVF International Conference on Computer Vision (ICCV)
-       Online: https://arxiv.org/abs/1905.04899
-    .. [2] https://github.com/clovaai/CutMix-PyTorch/blob/master/train.py
-    """
-
-    operation = staticmethod(cutmix)  # type: ignore[assignment]
-
-    def get_augmentation_params(self, *batch):
-        """Return idx_perm and the cut_t_start, cut_t_len of each region."""
-        params = super().get_augmentation_params(*batch)
-        lam = params.pop("lam")
-        n_times = batch[0].shape[-1]
-        half = ((1 - lam) * n_times).long() // 2
-        center = torch.as_tensor(self.rng.randint(n_times, size=len(lam)))
-        center = center.to(lam.device)
-        start = (center - half).clamp(min=0)
-        end = (center + half).clamp(max=n_times)
-        return dict(params, cut_t_start=start, cut_t_len=end - start)
-
-
-class LabelSmoothing(Transform):
-    """Label smoothing from Szegedy et al. (2016) [1]_.
-
-    Replaces each target with its convex combination with the uniform
-    distribution over the classes, penalizing over-confident predictions.
-    The signals are returned unchanged; only the targets change.
-
-    The smoothed targets are floating-point distributions of shape
-    ``batch_size, num_classes`` (each row sums to one), so the training
-    loss must accept target distributions, e.g. soft cross-entropy
-    ``-(y * torch.log_softmax(logits, dim=-1)).sum(-1).mean()`` or
-    ``torch.nn.KLDivLoss``. The transform composes before target-mixing
-    transforms such as :class:`braindecode.augmentation.Mixup`, whose
-    fractional-target path then mixes the smoothed distributions. The
-    fixed-expansion mode (``n_augmentation > 0``) of
-    :class:`braindecode.augmentation.AugmentedDataLoader` is not supported:
-    it cannot concatenate the unsmoothed original targets with the reshaped
-    smoothed copies.
-
-    Parameters
-    ----------
-    epsilon : float
-        Smoothing parameter between 0 and 1: the weight of the uniform
-        distribution mixed into the targets. ``0`` disables smoothing.
-    num_classes : int | None, optional
-        Number of classes. Required when the targets are class indices;
-        when the targets are already distributions of shape
-        ``batch_size, num_classes``, it must match their last dimension.
-        Defaults to None.
-    random_state : int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator
-        instance. The transform is deterministic, so the seed only feeds
-        the application-probability machinery, which is inactive here.
-        Defaults to None.
-
-    References
-    ----------
-    .. [1] Christian Szegedy, Vincent Vanhoucke, Jonathon Shlens and
-       Zbigniew Wojna (2016). Rethinking the Inception Architecture for
-       Computer Vision. In 2016 IEEE Conference on Computer Vision and
-       Pattern Recognition (CVPR), pp. 2818-2826.
-       Online: https://arxiv.org/abs/1512.00567
-    """
-
-    operation = staticmethod(label_smoothing)  # type: ignore[assignment]
-
-    def __init__(self, epsilon, num_classes=None, random_state=None):
-        super().__init__(
-            probability=1.0,  # LabelSmoothing has to be applied to whole batches
-            random_state=random_state,
-        )
-        if not isinstance(epsilon, Real) or not 0.0 <= float(epsilon) <= 1.0:
-            raise ValueError(
-                f"epsilon should be a real number between 0 and 1. Got {epsilon!r}."
-            )
-        if num_classes is not None and (
-            not isinstance(num_classes, int)
-            or isinstance(num_classes, bool)
-            or num_classes < 2
-        ):
-            raise ValueError(
-                f"num_classes should be an integer of at least 2. Got {num_classes!r}."
-            )
-        self.epsilon = epsilon
-        self.num_classes = num_classes
-
-    def get_augmentation_params(self, *batch):
-        """Return transform parameters.
-
-        Parameters
-        ----------
-        X : tensor.Tensor
-            The data.
-        y : tensor.Tensor
-            The labels.
-
-        Returns
-        -------
-        params : dict
-            Contains
-
-            * epsilon : float
-                Smoothing parameter between 0 and 1.
-            * num_classes : int | None
-                The number of classes.
-        """
-        return {
-            "epsilon": self.epsilon,
-            "num_classes": self.num_classes,
-        }
-
-
 class SegmentationReconstruction(Transform):
     """Segmentation Reconstruction from Lotte (2015) [Lotte2015]_.
 
@@ -1436,7 +1283,7 @@ class MaskEncoding(Transform):
         )
 
         time_start = self.rng.randint(
-            0, n_times - segment_length + 1, (batch_size, self.n_segments)
+            0, n_times - segment_length, (batch_size, self.n_segments)
         )
         time_start = torch.from_numpy(time_start)