braindecode 1.8.0.dev580__tar.gz → 1.8.0.dev1125__tar.gz

{braindecode-1.8.0.dev580/braindecode.egg-info → braindecode-1.8.0.dev1125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0.dev580
+Version: 1.8.0.dev1125
 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.0.dev580 → braindecode-1.8.0.dev1125}/braindecode/augmentation/base.py

@@ -3,6 +3,7 @@
 #          Bruno Aristimunha <b.aristimunha@gmail.com>
 #          Martin Wimpff <martin.wimpff@iss.uni-stuttgart.de>
 #          Valentin Iovene <val@too.gy>
+#          Sarthak Tayal <sarthaktayal2@gmail.com>
 # License: BSD (3-clause)
 
 from numbers import Real
@@ -176,6 +177,14 @@ class Compose(Transform):
         return X, y
 
 
+def _as_mixed_target(y, lam_dtype):
+    # an untouched target is the same as being mixed with itself with lam of one
+    if isinstance(y, (tuple, list)) and len(y) == 3:
+        return tuple(y)
+    lam = torch.ones(y.shape[0], device=y.device, dtype=lam_dtype)
+    return y, y, lam
+
+
 class _AugmentationCollate:
     """Collate that applies a transform to each batch, with optional expansion.
 
@@ -193,7 +202,10 @@ class _AugmentationCollate:
         ``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.
+        ``(1 + n_augmentation)`` times the original size. When the transform
+        mixes targets, as :class:`braindecode.augmentation.Mixup` does, ``y``
+        stays the ``(y_a, y_b, lam)`` triple and the clean originals get a
+        mixing coefficient of one.
     """
 
     def __init__(self, transform, device=None, n_augmentation=0):
@@ -216,6 +228,18 @@ class _AugmentationCollate:
             aug_X, aug_y = self.transform(X, y)
             xs.append(aug_X)
             ys.append(aug_y)
+        mixed_ys = [
+            aug_y
+            for aug_y in ys
+            if isinstance(aug_y, (tuple, list)) and len(aug_y) == 3
+        ]
+        if mixed_ys:
+            # a target-mixing transform such as Mixup returns (y_a, y_b, lam),
+            # so the parts are concatenated one by one and the untouched copies
+            # are given a mixing coefficient of one
+            lam_dtype = mixed_ys[0][2].dtype
+            ys = [_as_mixed_target(aug_y, lam_dtype) for aug_y in ys]
+            return torch.cat(xs), tuple(torch.cat(part) for part in zip(*ys))
         return torch.cat(xs), torch.cat(ys)
 
 

{braindecode-1.8.0.dev580 → braindecode-1.8.0.dev1125}/braindecode/augmentation/functional.py

@@ -1065,13 +1065,11 @@ def mixup(
     batch_size, n_channels, n_times = X.shape
 
     X_mix = torch.zeros((batch_size, n_channels, n_times)).to(device)
-    y_a = torch.arange(batch_size).to(device)
-    y_b = torch.arange(batch_size).to(device)
+    y_a = y.clone()
+    y_b = y[idx_perm].clone()
 
     for idx in range(batch_size):
         X_mix[idx] = lam[idx] * X[idx] + (1 - lam[idx]) * X[idx_perm[idx]]
-        y_a[idx] = y[idx]
-        y_b[idx] = y[idx_perm[idx]]
 
     return X_mix, (y_a, y_b, lam)
 

{braindecode-1.8.0.dev580 → braindecode-1.8.0.dev1125}/braindecode/augmentation/transforms.py

@@ -1068,16 +1068,18 @@ class Mixup(Transform):
         device = X.device
         batch_size, _, _ = X.shape
 
+        # lam follows the dtype of X, numpy draws float64 and that would leak
+        # into the mixed signal and into the loss returned by mixup_criterion
         if self.alpha > 0:
             if self.beta_per_sample:
                 lam = torch.as_tensor(
                     self.rng.beta(self.alpha, self.alpha, batch_size)
-                ).to(device)
+                ).to(device=device, dtype=X.dtype)
             else:
-                lam = torch.ones(batch_size).to(device)
+                lam = torch.ones(batch_size, dtype=X.dtype).to(device)
                 lam *= self.rng.beta(self.alpha, self.alpha)
         else:
-            lam = torch.ones(batch_size).to(device)
+            lam = torch.ones(batch_size, dtype=X.dtype).to(device)
 
         idx_perm = torch.as_tensor(
             self.rng.permutation(

{braindecode-1.8.0.dev580 → braindecode-1.8.0.dev1125}/braindecode/samplers/base.py

@@ -5,6 +5,7 @@ Sampler classes.
 # Authors: Hubert Banville <hubert.jbanville@gmail.com>
 #          Theo Gnassounou <>
 #          Young Truong <dt.young112@gmail.com>
+#          Sarthak Tayal <sarthaktayal2@gmail.com>
 #
 # License: BSD (3-clause)
 
@@ -219,6 +220,9 @@ class DistributedRecordingSampler(DistributedSampler):
 class SequenceSampler(RecordingSampler):
     """Sample sequences of consecutive windows.
 
+    Recordings holding fewer than ``n_windows`` windows cannot contain a full
+    sequence and contribute none.
+
     Parameters
     ----------
     metadata : pd.DataFrame
@@ -227,7 +231,7 @@ class SequenceSampler(RecordingSampler):
         Number of consecutive windows in a sequence.
     n_windows_stride : int
         Number of windows between two consecutive sequences.
-    random : bool
+    randomize : bool
         If True, sample sequences randomly. If False, sample sequences in
         order.
     random_state : np.random.RandomState | int | None
@@ -269,7 +273,10 @@ class SequenceSampler(RecordingSampler):
             .apply(lambda x: x[: end_offset : self.n_windows_stride])
             .values
         )
-        file_ids = [[i] * len(inds) for i, inds in enumerate(start_inds)]
+        # a typed array keeps the ids integer when a recording yields no sequence
+        file_ids = [
+            np.full(len(inds), i, dtype=np.int64) for i, inds in enumerate(start_inds)
+        ]
         return np.concatenate(start_inds), np.concatenate(file_ids)
 
     def __len__(self):
@@ -296,6 +303,10 @@ class BalancedSequenceSampler(RecordingSampler):
     3. Sample a window of the corresponding class in the selected recording.
     4. Extract a sequence of windows around the sampled window.
 
+    Recordings holding fewer than ``n_windows`` windows cannot contain a full
+    sequence and are left out of step 1, as they are in
+    :class:`SequenceSampler`.
+
     Parameters
     ----------
     metadata : pd.DataFrame
@@ -322,6 +333,33 @@ class BalancedSequenceSampler(RecordingSampler):
         self.n_windows = n_windows
         self.n_sequences = n_sequences
         self.info_class = self._init_info(metadata, required_keys=["target"])
+        self.long_enough_recordings = self._find_long_enough_recordings()
+
+    def _find_long_enough_recordings(self):
+        """Return the indices of the recordings that can hold a full sequence.
+
+        Returns
+        -------
+        np.ndarray :
+            Array of recording indices holding at least ``n_windows`` windows.
+        """
+        n_windows_per_rec = self.info["index"].apply(len).to_numpy()
+        if n_windows_per_rec.size == 0:
+            raise ValueError("Cannot build sequences from empty metadata.")
+
+        long_enough = np.flatnonzero(n_windows_per_rec >= self.n_windows)
+        if len(long_enough) == 0:
+            raise ValueError(
+                f"No recording holds enough windows to build a sequence of "
+                f"{self.n_windows} windows. The longest recording has "
+                f"{n_windows_per_rec.max()} windows. Reduce n_windows to at "
+                f"most that value."
+            )
+        return long_enough
+
+    def sample_recording(self):
+        """Return a random recording index among the ones long enough."""
+        return self.rng.choice(self.long_enough_recordings)
 
     def sample_class(self, rec_ind=None):
         """Return a random class.

{braindecode-1.8.0.dev580 → braindecode-1.8.0.dev1125}/braindecode/training/losses.py

@@ -1,6 +1,7 @@
 # Authors: Robin Schirrmeister <robintibor@gmail.com>
 #          Maciej Sliwowski <maciek.sliwowski@gmail.com>
 #          Mohammed Fattouh <mo.fattouh@gmail.com>
+#          Sarthak Tayal <sarthaktayal2@gmail.com>
 #
 # License: BSD (3-clause)
 
@@ -79,10 +80,11 @@ def mixup_criterion(preds, target):
     ----------
     preds : torch.Tensor
         Predictions from the model.
-    target : torch.Tensor | list of torch.Tensor
+    target : torch.Tensor | tuple of torch.Tensor | list of torch.Tensor
         For predictions without mixup, the targets as a tensor. If mixup has
-        been applied, a list containing the targets of the two mixed
-        samples and the mixing coefficients as tensors.
+        been applied, a tuple or list containing the targets of the two mixed
+        samples and the mixing coefficients as tensors. A plain tensor is
+        always read as targets, whatever the batch size is.
 
     Returns
     -------
@@ -96,7 +98,8 @@ def mixup_criterion(preds, target):
        Online: https://arxiv.org/abs/1710.09412
     .. [2] https://github.com/facebookresearch/mixup-cifar10/blob/master/train.py
     """
-    if len(target) == 3:
+    # only a mixup target is a container, a plain target tensor of length 3 is not
+    if isinstance(target, (tuple, list)) and len(target) == 3:
         # unpack target
         y_a, y_b, lam = target
         # compute loss per sample

{braindecode-1.8.0.dev580 → braindecode-1.8.0.dev1125}/braindecode/util.py

@@ -1,4 +1,5 @@
 # Authors: Robin Schirrmeister <robintibor@gmail.com>
+#          Sarthak Tayal <sarthaktayal2@gmail.com>
 #
 # License: BSD (3-clause)
 import glob
@@ -386,18 +387,23 @@ class ThrowAwayIndexLoader(object):
             if isinstance(x, dict):
                 if hasattr(x["x"], "type"):
                     x["x"] = x["x"].type(torch.float32)
-                if hasattr(y, "type"):
-                    y = (
-                        y.type(torch.float32)
-                        if self.is_regression
-                        else y.type(torch.int64)
-                    )
+                cast_target = True
             elif hasattr(x, "type"):
                 x = x.type(torch.float32)
-                if self.is_regression:
-                    y = y.type(torch.float32)
-                else:
-                    y = y.type(torch.int64)
+                cast_target = True
+            else:
+                cast_target = False
+            if cast_target:
+                target_dtype = torch.float32 if self.is_regression else torch.int64
+                if isinstance(y, (tuple, list)) and len(y) == 3:
+                    y_a, y_b, lam = y
+                    y = (
+                        y_a.type(target_dtype),
+                        y_b.type(target_dtype),
+                        lam.type(torch.float32),
+                    )
+                elif hasattr(y, "type"):
+                    y = y.type(target_dtype)
             yield x, y
 
 

braindecode-1.8.0.dev1125/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "1.8.0.dev1125"

{braindecode-1.8.0.dev580 → braindecode-1.8.0.dev1125/braindecode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0.dev580
+Version: 1.8.0.dev1125
 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.0.dev580 → braindecode-1.8.0.dev1125}/docs/whats_new.rst

@@ -48,10 +48,60 @@ Bug fixes
 - Make :class:`braindecode.datasets.SleepPhysionet` wake cropping retain the complete
   final sleep annotation without including an extra endpoint sample (:gh:`612` by
   `John Muradeli`_).
+
+- Fix :func:`braindecode.training.mixup_criterion` treating a plain target
+  tensor of three elements as a mixup ``(y_a, y_b, lam)`` triple. The branch
+  was selected on ``len(target) == 3``, which is also true for the targets of
+  any batch holding three windows, so a validation batch or a last partial
+  batch of that size failed with ``Expected input batch_size (3) to match
+  target batch_size (0)``. The mixup branch is now selected on the container
+  type. (:gh:`1122` by `Sarthak Tayal`_)
+
+- Keep the mixing coefficient of :class:`braindecode.augmentation.Mixup` on the
+  dtype of the batch. With ``beta_per_sample=True`` it came straight from numpy
+  as ``float64``, which upcast the loss returned by
+  :func:`braindecode.training.mixup_criterion` to ``float64`` while the model
+  stayed in ``float32``. (:gh:`1122` by `Sarthak Tayal`_)
+
+- Let :class:`braindecode.augmentation.AugmentedDataLoader` used with
+  ``n_augmentation`` greater than zero carry the targets of a transform that
+  mixes them. Batches were concatenated as plain tensors, so combining that
+  option with :class:`braindecode.augmentation.Mixup` raised ``expected Tensor
+  as element 1 in argument 0, but got tuple``. The triple parts are now
+  concatenated one by one and the clean originals get a mixing coefficient of
+  one. (:gh:`1122` by `Sarthak Tayal`_)
+
+- Let :class:`braindecode.EEGClassifier` and :class:`braindecode.EEGRegressor`
+  train with a transform that mixes targets. The loader wrapper cast every
+  target with ``y.type(...)``, so a batch carrying the ``(y_a, y_b, lam)``
+  triple of :class:`braindecode.augmentation.Mixup` stopped the fit with
+  ``'tuple' object has no attribute 'type'`` before the first batch was seen.
+  The triple parts now follow the same classification/regression dtype contract
+  as a plain target. (:gh:`1122` by `Sarthak Tayal`_).
+
 - Keep :class:`braindecode.preprocessing.EEGPrep` compatible with EEGPrep 0.3,
   which no longer exposes the ``eegprep.utils`` namespace used for sampling-rate
   validation (:gh:`1123` by `Bruno Aristimunha`_).
 
+- Leave recordings shorter than ``n_windows`` out of the draw in
+  :class:`braindecode.samplers.BalancedSequenceSampler` instead of failing on
+  them. Such a recording holds no valid sequence start, which made the sampling
+  range empty and raised ``ValueError: high <= 0`` on the first sequence that
+  landed there. :class:`braindecode.samplers.SequenceSampler` already skips
+  those recordings. A clear error now names the longest recording when none of
+  them can hold a sequence (:gh:`1125` by `Sarthak Tayal`_).
+
+- Keep ``file_ids`` of :class:`braindecode.samplers.SequenceSampler` integer.
+  The ids were built from untyped lists, so an empty list coming from a
+  recording too short for a sequence turned the concatenated array into
+  ``float64``, against the documented dtype and unusable as an index
+  (:gh:`1125` by `Sarthak Tayal`_).
+
+- Document the ``randomize`` parameter of
+  :class:`braindecode.samplers.SequenceSampler` under its own name. The
+  docstring described it as ``random``, which no signature accepts
+  (:gh:`1125` by `Sarthak Tayal`_).
+
 Code health
 ============
 

braindecode-1.8.0.dev580/braindecode/version.py

@@ -1 +0,0 @@
-__version__ = "1.8.0.dev580"