braindecode 1.8.0.dev580__tar.gz → 1.8.0.dev1122__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0.dev580
+Version: 1.8.0.dev1122
 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.dev1122}/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.dev1122}/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.dev1122}/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.dev1122}/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.dev1122}/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.dev1122/braindecode/version.py

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

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

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

@@ -48,6 +48,37 @@ 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`_).

braindecode-1.8.0.dev580/braindecode/version.py

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