Braindecode 1.8.1.dev183670874__tar.gz → 1.8.1.dev183674431__tar.gz

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

@@ -13,10 +13,9 @@ The following components are licensed under the Creative Commons Attribution-Non
 
 - `braindecode/models/eegminer.py`
 - `braindecode/models/meta_neuromotor.py`
-- `braindecode/models/sleepfm.py`
 - `braindecode/models/brainmodule.py`
-- `braindecode/models/neurorvq.py`
-- `braindecode/models/neurorvq_tokenizer.py`
+
+As well as class later imported into the `braindecode.models.module` named as GeneralizedGaussianFilter.
 
 The `meta_neuromotor.py` file is a derivative of
 `facebookresearch/generic-neuromotor-interface`, released by Meta Platforms,
@@ -40,40 +39,18 @@ 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
-`quantization.py` module holds the residual vector quantization derived from
-`lucidrains/vector-quantize-pytorch` (MIT) and the BrainOmni port.
-The `linear_attention.py` module is the part of
-`lucidrains/linear-attention-transformer` (MIT) that BIOT and TFMTokenizer run.
 
 ### Apache-2.0 Licensed Files
 
 The following components are licensed under the Apache License 2.0:
 
-- `braindecode/models/axon.py`
 - `braindecode/models/mvpformer.py`
 - `braindecode/models/zuna.py`
 - `braindecode/models/luna.py`
-- `braindecode/models/mapa.py`
 - `braindecode/models/brant.py`
 - `braindecode/models/diver1.py`
 - `braindecode/models/mscformer.py`

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev183670874
+Version: 1.8.1.dev183674431
 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.dev183670874 → braindecode-1.8.1.dev183674431}/braindecode/augmentation/__init__.py

@@ -10,7 +10,6 @@ from .transforms import (
     ChannelsReref,
     ChannelsShuffle,
     ChannelsSymmetry,
-    CutMix,
     FrequencyShift,
     FTSurrogate,
     GaussianNoise,
@@ -24,7 +23,6 @@ from .transforms import (
     SignFlip,
     SmoothTimeMask,
     TimeReverse,
-    TrivialAugment,
 )
 
 __all__ = [
@@ -32,12 +30,10 @@ __all__ = [
     "IdentityTransform",
     "Compose",
     "AugmentedDataLoader",
-    "TrivialAugment",
     "TimeReverse",
     "SignFlip",
     "FTSurrogate",
     "ChannelsShuffle",
-    "CutMix",
     "ChannelsDropout",
     "GaussianNoise",
     "ChannelsSymmetry",

{braindecode-1.8.1.dev183670874 → braindecode-1.8.1.dev183674431}/braindecode/augmentation/functional.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)
 
@@ -580,7 +579,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)
@@ -933,7 +931,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(
@@ -1076,54 +1074,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 segmentation_reconstruction(
     X: torch.Tensor,
     y: torch.Tensor,
@@ -1143,8 +1093,7 @@ def segmentation_reconstruction(
     y : torch.Tensor
         EEG labels for the example or batch.
     n_segments : int
-        Number of segments to use in the batch. Any remaining samples are
-        included in the last segment.
+        Number of segments to use in the batch.
     data_classes : list[tuple[int, torch.Tensor]]
         List of tuples. Each tuple contains the class index and the corresponding EEG data.
     rand_indices : array-like
@@ -1184,8 +1133,6 @@ def segmentation_reconstruction(
         for idx_segment in range(n_segments):
             start = idx_segment * segment_size
             end = (idx_segment + 1) * segment_size
-            if idx_segment == n_segments - 1:
-                end = window_size
 
             # Perform the data augmentation
             X_aug[np.arange(n_trials), :, start:end] = X_class[

{braindecode-1.8.1.dev183670874 → braindecode-1.8.1.dev183674431}/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)
 
@@ -25,7 +24,6 @@ from .functional import (
     channels_permute,
     channels_rereference,
     channels_shuffle,
-    cutmix,
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
@@ -1097,55 +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 SegmentationReconstruction(Transform):
     """Segmentation Reconstruction from Lotte (2015) [Lotte2015]_.
 
@@ -1334,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)
 
@@ -1508,188 +1457,3 @@ class BandRotation(Transform):
             "circular_jitter": self.circular_jitter,
             "random_state": self.rng,
         }
-
-
-class TrivialAugment(Transform):
-    """Apply one randomly sampled label-preserving augmentation per example.
-
-    For every example, independently samples one transform from the pool
-    below and one of ``num_bins`` strengths evenly spaced between that
-    transform's bounds, as in TrivialAugment [1]_. Examples that draw the
-    same transform and strength are transformed in one call; each pooled
-    transform still draws its own randomness per example.
-
-    Default pool (no assumption on the signal's unit, sampling frequency or
-    montage):
-
-    * :class:`TimeReverse` — no strength parameter.
-    * :class:`SignFlip` — no strength parameter.
-    * :class:`FTSurrogate` — phase noise magnitude, 0.2 to 1.
-    * :class:`ChannelsDropout` — channel drop probability, 0.05 to 0.4.
-    * :class:`ChannelsShuffle` — shuffle probability, 0.1 to 0.75.
-    * :class:`SmoothTimeMask` — mask length as a fraction of the window
-      length, 0.05 to 0.25.
-    * :class:`GaussianNoise` — noise standard deviation as a fraction of the
-      sub-batch standard deviation (volts or microvolts alike), 0.02 to 0.3.
-    * :class:`AmplitudeScale` — scale interval ``(1/s, s)``, ``s`` from 1.25
-      to 2.5.
-
-    ``sfreq`` adds :class:`BandstopFilter` (bandwidth 0.5 to 4 Hz, capped
-    2.5 Hz below Nyquist) and :class:`FrequencyShift` (maximum shift 0.5 to
-    2 Hz); ``sensors_positions_matrix`` adds :class:`SensorsRotation` around
-    the z axis (5 to 25 degrees).
-
-    Parameters
-    ----------
-    probability : float, optional
-        Probability of augmenting each example. Defaults to 1.0.
-    sfreq : float | None, optional
-        Sampling frequency of the signals, in Hz. Defaults to None.
-    sensors_positions_matrix : array-like | None, optional
-        Sensor positions of shape ``(3, n_channels)`` (see
-        :class:`SensorsRotation`). Defaults to None.
-    num_bins : int, optional
-        Number of strength levels per transform. Defaults to 10.
-    random_state : int | numpy.random.RandomState, optional
-        Seed shared by the per-example sampler and every pooled transform.
-        Defaults to None.
-
-    Attributes
-    ----------
-    op_names : list of str
-        Names of the transforms in the pool, in sampling order.
-
-    References
-    ----------
-    .. [1] Müller, S. G., & Hutter, F. (2021). TrivialAugment:
-       Tuning-free Yet State-of-the-Art Data Augmentation. Proceedings of
-       the IEEE/CVF International Conference on Computer Vision (ICCV),
-       pp. 774-782.
-    """
-
-    def __init__(
-        self,
-        probability=1.0,
-        sfreq=None,
-        sensors_positions_matrix=None,
-        num_bins=10,
-        random_state=None,
-    ):
-        super().__init__(probability=probability, random_state=random_state)
-        if not isinstance(num_bins, (int, np.integer)) or num_bins < 1:
-            raise ValueError(f"num_bins must be a positive integer, got {num_bins}")
-        self.num_bins = int(num_bins)
-        rng = self.rng
-        # (name, strength bounds or None, make(strength) or None: built per call)
-        specs = [
-            ("TimeReverse", None, lambda s: TimeReverse(1.0, random_state=rng)),
-            ("SignFlip", None, lambda s: SignFlip(1.0, random_state=rng)),
-            (
-                "FTSurrogate",
-                (0.2, 1.0),
-                lambda s: FTSurrogate(1.0, phase_noise_magnitude=s, random_state=rng),
-            ),
-            (
-                "ChannelsDropout",
-                (0.05, 0.4),
-                lambda s: ChannelsDropout(1.0, p_drop=s, random_state=rng),
-            ),
-            (
-                "ChannelsShuffle",
-                (0.1, 0.75),
-                lambda s: ChannelsShuffle(1.0, p_shuffle=s, random_state=rng),
-            ),
-            ("SmoothTimeMask", (0.05, 0.25), None),
-            ("GaussianNoise", (0.02, 0.3), None),
-            (
-                "AmplitudeScale",
-                (1.25, 2.5),
-                lambda s: AmplitudeScale(1.0, interval=(1.0 / s, s), random_state=rng),
-            ),
-        ]
-        if sfreq is not None:
-            nyquist = sfreq / 2.0
-            # BandstopFilter needs bandwidth < nyquist - 2; keep a margin
-            max_bandwidth = min(4.0, nyquist - 2.5)
-            if max_bandwidth <= 0.5:
-                raise ValueError(
-                    f"sfreq={sfreq} is too small to sample valid band-stop "
-                    "bandwidths (needs at least 6.0 Hz)."
-                )
-            specs += [
-                (
-                    "BandstopFilter",
-                    (0.5, max_bandwidth),
-                    lambda s: BandstopFilter(
-                        1.0,
-                        sfreq=sfreq,
-                        bandwidth=s,
-                        max_freq=nyquist,
-                        random_state=rng,
-                    ),
-                ),
-                (
-                    "FrequencyShift",
-                    (0.5, 2.0),
-                    lambda s: FrequencyShift(
-                        1.0, sfreq=sfreq, max_delta_freq=s, random_state=rng
-                    ),
-                ),
-            ]
-        if sensors_positions_matrix is not None:
-            specs.append(
-                (
-                    "SensorsRotation",
-                    (5.0, 25.0),
-                    lambda s: SensorsRotation(
-                        1.0,
-                        sensors_positions_matrix=sensors_positions_matrix,
-                        max_degrees=s,
-                        random_state=rng,
-                    ),
-                )
-            )
-
-        self._pool = []
-        for name, bounds, make in specs:
-            if bounds is None:
-                strengths = [None]
-            else:
-                strengths = np.linspace(*bounds, self.num_bins).tolist()
-            variants = None if make is None else [make(s) for s in strengths]
-            self._pool.append((name, strengths, variants))
-        # pre-built transforms as submodules (pickle, ``.to()``)
-        self._static_transforms = torch.nn.ModuleList(
-            v for _, _, variants in self._pool if variants for v in variants
-        )
-        self.op_names = [name for name, _, _ in self._pool]
-
-    def operation(self, X, y):
-        """Apply one sampled transform and strength to each example of X."""
-        n_strengths = np.array([len(strengths) for _, strengths, _ in self._pool])
-        op_ids = self.rng.randint(0, len(self._pool), size=X.shape[0])
-        bin_ids = self.rng.randint(0, self.num_bins, size=X.shape[0])
-        # magnitude-free transforms collapse all examples onto bin 0
-        bin_ids[n_strengths[op_ids] == 1] = 0
-        keys = op_ids * self.num_bins + bin_ids
-
-        out_X, out_y = X.clone(), y.clone()
-        for key in np.unique(keys):
-            group = torch.from_numpy(np.flatnonzero(keys == key)).to(X.device)
-            op_i, bin_j = divmod(int(key), self.num_bins)
-            name, strengths, variants = self._pool[op_i]
-            X_sub = X[group]
-            if variants is not None:
-                transform = variants[bin_j]
-            elif name == "SmoothTimeMask":
-                n_mask = max(1, int(round(strengths[bin_j] * X.shape[-1])))
-                transform = SmoothTimeMask(
-                    1.0, mask_len_samples=n_mask, random_state=self.rng
-                )
-            else:  # GaussianNoise, std relative to the sub-batch (unit-free)
-                std = strengths[bin_j] * X_sub.std().item()
-                transform = GaussianNoise(1.0, std=std, random_state=self.rng)
-            tr_X, tr_y = transform(X_sub, y[group])
-            out_X[group] = tr_X.to(out_X.dtype)
-            out_y[group] = tr_y
-        return out_X, out_y

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

@@ -212,12 +212,11 @@ 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 | 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.
+        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.
         """
         if not self.cropped:
             warnings.warn(