braindecode 0.8__tar.gz → 1.0.0__tar.gz

{braindecode-0.8 → braindecode-1.0.0}/LICENSE.txt

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2017-2020 Braindecode Developers
+Copyright (c) 2017-currently Braindecode Developers
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,

{braindecode-0.8 → braindecode-1.0.0}/MANIFEST.in

@@ -1,5 +1,8 @@
 include README.rst
 include LICENSE.txt
+include NOTICE.txt
+
+include braindecode/models/summary.csv
 
 recursive-include docs *.ipynb *.rst conf.py Makefile
 recursive-exclude docs *checkpoint.ipynb

braindecode-1.0.0/NOTICE.txt

@@ -0,0 +1,20 @@
+# BRAINDECODE Notice
+
+## Licensed Components
+
+### BSD-3-Clause Licensed Files
+
+All files within the `src/` directory are licensed under the BSD-3-Clause License.
+
+### CC BY-NC 4.0 Licensed Files
+
+The following components are licensed under the Creative Commons Attribution-NonCommercial 4.0 International License:
+
+- `braindecode/models/eegminer.py`
+
+As well as class later imported into the `braindecode.models.module` named as GeneralizedGaussianFilter.
+
+## License Links
+
+- [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
+- [CC BY-NC 4.0 License](https://creativecommons.org/licenses/by-nc/4.0/)

{braindecode-0.8/braindecode.egg-info → braindecode-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: braindecode
-Version: 0.8
+Version: 1.0.0
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>
@@ -15,14 +15,15 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: mne
+License-File: NOTICE.txt
+Requires-Dist: mne>=1.10.0
+Requires-Dist: mne_bids>=0.16
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: scipy
@@ -30,17 +31,22 @@ Requires-Dist: matplotlib
 Requires-Dist: h5py
 Requires-Dist: skorch
 Requires-Dist: torch
+Requires-Dist: torchaudio
 Requires-Dist: einops
 Requires-Dist: joblib
 Requires-Dist: torchinfo
+Requires-Dist: wfdb
+Requires-Dist: h5py
+Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
 Provides-Extra: moabb
-Requires-Dist: moabb>=1.0.0; extra == "moabb"
+Requires-Dist: moabb>=1.2.0; extra == "moabb"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
 Requires-Dist: codecov; extra == "tests"
 Requires-Dist: pytest_cases; extra == "tests"
+Requires-Dist: mypy; extra == "tests"
 Provides-Extra: docs
 Requires-Dist: sphinx_gallery; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
@@ -53,6 +59,8 @@ Requires-Dist: sphinx_design; extra == "docs"
 Requires-Dist: lightning; extra == "docs"
 Requires-Dist: seaborn; extra == "docs"
 Requires-Dist: pre-commit; extra == "docs"
+Requires-Dist: openneuro-py; extra == "docs"
+Dynamic: license-file
 
 .. image:: https://badges.gitter.im/braindecodechat/community.svg
    :alt: Join the chat at https://gitter.im/braindecodechat/community
@@ -166,37 +174,13 @@ as well as the `MNE-Python <https://mne.tools>`_ software that is used by braind
 Licensing
 ^^^^^^^^^
 
-Braindecode is **BSD-licenced** (BSD-3-Clause):
-
-    This software is OSI Certified Open Source Software.
-    OSI Certified is a certification mark of the Open Source Initiative.
-
-    Copyright (c) 2011-2022, authors of Braindecode.
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
+This project is primarily licensed under the BSD-3-Clause License.
 
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
+Additional Components
+~~~~~~~~~~~~~~~~~~~~~
 
-    * Neither the names of braindecode authors nor the names of any
-      contributors may be used to endorse or promote products derived from
-      this software without specific prior written permission.
+Some components within this repository are licensed under the Creative Commons Attribution-NonCommercial 4.0 International
+License.
 
-    **This software is provided by the copyright holders and contributors
-    "as is" and any express or implied warranties, including, but not
-    limited to, the implied warranties of merchantability and fitness for
-    a particular purpose are disclaimed. In no event shall the copyright
-    owner or contributors be liable for any direct, indirect, incidental,
-    special, exemplary, or consequential damages (including, but not
-    limited to, procurement of substitute goods or services; loss of use,
-    data, or profits; or business interruption) however caused and on any
-    theory of liability, whether in contract, strict liability, or tort
-    (including negligence or otherwise) arising in any way out of the use
-    of this software, even if advised of the possibility of such
-    damage.**
+Please refer to the ``LICENSE`` and ``NOTICE`` files for more detailed
+information.

{braindecode-0.8 → braindecode-1.0.0}/README.rst

@@ -110,37 +110,13 @@ as well as the `MNE-Python <https://mne.tools>`_ software that is used by braind
 Licensing
 ^^^^^^^^^
 
-Braindecode is **BSD-licenced** (BSD-3-Clause):
-
-    This software is OSI Certified Open Source Software.
-    OSI Certified is a certification mark of the Open Source Initiative.
-
-    Copyright (c) 2011-2022, authors of Braindecode.
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-
-    * Neither the names of braindecode authors nor the names of any
-      contributors may be used to endorse or promote products derived from
-      this software without specific prior written permission.
-
-    **This software is provided by the copyright holders and contributors
-    "as is" and any express or implied warranties, including, but not
-    limited to, the implied warranties of merchantability and fitness for
-    a particular purpose are disclaimed. In no event shall the copyright
-    owner or contributors be liable for any direct, indirect, incidental,
-    special, exemplary, or consequential damages (including, but not
-    limited to, procurement of substitute goods or services; loss of use,
-    data, or profits; or business interruption) however caused and on any
-    theory of liability, whether in contract, strict liability, or tort
-    (including negligence or otherwise) arising in any way out of the use
-    of this software, even if advised of the possibility of such
-    damage.**
+This project is primarily licensed under the BSD-3-Clause License.
+
+Additional Components
+~~~~~~~~~~~~~~~~~~~~~
+
+Some components within this repository are licensed under the Creative Commons Attribution-NonCommercial 4.0 International
+License.
+
+Please refer to the ``LICENSE`` and ``NOTICE`` files for more detailed
+information.

{braindecode-0.8 → braindecode-1.0.0}/braindecode/__init__.py

@@ -1,7 +1,6 @@
-from .version import __version__
-
 from .classifier import EEGClassifier
 from .regressor import EEGRegressor
+from .version import __version__
 
 __all__ = [
     "__version__",

braindecode-1.0.0/braindecode/augmentation/__init__.py

@@ -0,0 +1,50 @@
+"""
+Utilities for data augmentation.
+"""
+
+from . import functional
+from .base import AugmentedDataLoader, Compose, IdentityTransform, Transform
+from .transforms import (
+    BandstopFilter,
+    ChannelsDropout,
+    ChannelsShuffle,
+    ChannelsSymmetry,
+    FrequencyShift,
+    FTSurrogate,
+    GaussianNoise,
+    MaskEncoding,
+    Mixup,
+    SegmentationReconstruction,
+    SensorsRotation,
+    SensorsXRotation,
+    SensorsYRotation,
+    SensorsZRotation,
+    SignFlip,
+    SmoothTimeMask,
+    TimeReverse,
+)
+
+__all__ = [
+    "Transform",
+    "IdentityTransform",
+    "Compose",
+    "AugmentedDataLoader",
+    "TimeReverse",
+    "SignFlip",
+    "FTSurrogate",
+    "ChannelsShuffle",
+    "ChannelsDropout",
+    "GaussianNoise",
+    "ChannelsSymmetry",
+    "SmoothTimeMask",
+    "BandstopFilter",
+    "FrequencyShift",
+    "SensorsRotation",
+    "SensorsZRotation",
+    "SensorsYRotation",
+    "SensorsXRotation",
+    "Mixup",
+    "SegmentationReconstruction",
+    "MaskEncoding",
+    "functional",
+]

braindecode-1.0.0/braindecode/augmentation/base.py

@@ -0,0 +1,222 @@
+# Authors: Cédric Rommel <cedric.rommel@inria.fr>
+#          Alexandre Gramfort <alexandre.gramfort@inria.fr>
+#          Bruno Aristimunha <b.aristimunha@gmail.com>
+#          Martin Wimpff <martin.wimpff@iss.uni-stuttgart.de>
+#          Valentin Iovene <val@too.gy>
+# License: BSD (3-clause)
+
+from numbers import Real
+from typing import Any, Callable, Optional, Union
+
+import torch
+from sklearn.utils import check_random_state
+from torch import Tensor, nn
+from torch.utils.data import DataLoader
+from torch.utils.data._utils.collate import default_collate
+
+from .functional import identity
+
+Batch = list[tuple[torch.Tensor, int, Any]]
+Output = Union[
+    # just outputting X
+    torch.Tensor,
+    # outputting (X, y) where y can be a tensor or tuple of tensors
+    tuple[torch.Tensor, Union[torch.Tensor, tuple[torch.Tensor, ...]]],
+]
+# (X, y) -> (X', y') where y' can be a tensor or a tuple of tensors
+Operation = Callable[
+    [torch.Tensor, torch.Tensor],
+    tuple[torch.Tensor, Union[torch.Tensor, tuple[torch.Tensor, ...]]],
+]
+
+
+class Transform(torch.nn.Module):
+    """Basic transform class used for implementing data augmentation
+    operations.
+
+    Parameters
+    ----------
+    operation : callable
+        A function taking arrays X, y (inputs and targets resp.) and
+        other required arguments, and returning the transformed X and y.
+    probability : float, optional
+        Float between 0 and 1 defining the uniform probability of applying the
+        operation. Set to 1.0 by default (e.g always apply the operation).
+    random_state: int, optional
+        Seed to be used to instantiate numpy random number generator instance.
+        Used to decide whether or not to transform given the probability
+        argument. Defaults to None.
+    """
+
+    operation: Operation
+
+    def __init__(self, probability=1.0, random_state=None):
+        super().__init__()
+        if self.forward.__func__ is Transform.forward:
+            assert callable(self.operation), "operation should be a ``callable``. "
+
+        assert isinstance(probability, Real), (
+            f"probability should be a ``real``. Got {type(probability)}."
+        )
+        assert probability <= 1.0 and probability >= 0.0, (
+            "probability should be between 0 and 1."
+        )
+        self._probability = probability
+        self.rng = check_random_state(random_state)
+
+    def get_augmentation_params(self, *batch):
+        return dict()
+
+    def forward(self, X: Tensor, y: Optional[Tensor] = None) -> Output:
+        """General forward pass for an augmentation transform.
+
+        Parameters
+        ----------
+        X : torch.Tensor
+            EEG input example or batch.
+        y : torch.Tensor | None
+            EEG labels for the example or batch. Defaults to None.
+
+        Returns
+        -------
+        torch.Tensor
+            Transformed inputs.
+        torch.Tensor, optional
+            Transformed labels. Only returned when y is not None.
+        """
+        X = torch.as_tensor(X).float()
+
+        out_X = X.clone()
+        # check if input has a batch dimension
+        if len(out_X.shape) < 3:
+            out_X = out_X[None, ...]
+
+        if y is not None:
+            y = torch.as_tensor(y).to(out_X.device)
+            out_y = y.clone()
+            if len(out_y.shape) == 0:
+                out_y = out_y.reshape(1)
+        else:
+            out_y = torch.zeros(out_X.shape[0], device=out_X.device)
+
+        # Samples a mask setting for each example whether they should stay
+        # unchanged or not
+        mask = self._get_mask(out_X.shape[0], out_X.device)
+        num_valid = mask.sum().long()
+
+        if num_valid > 0:
+            # Uses the mask to define the output
+            out_X[mask, ...], tr_y = self.operation(
+                out_X[mask, ...],
+                out_y[mask],
+                **self.get_augmentation_params(out_X[mask, ...], out_y[mask]),
+            )
+            # Apply the operation defining the Transform to the whole batch
+            if isinstance(tr_y, tuple):
+                out_y = tuple(tmp_y[mask] for tmp_y in tr_y)
+            else:
+                out_y[mask] = tr_y
+
+        # potentially remove empty batch dimension again
+        out_X = out_X.reshape_as(X)
+        if y is not None:
+            return out_X, out_y
+        else:
+            return out_X
+
+    def _get_mask(self, batch_size, device) -> torch.Tensor:
+        """Samples whether to apply operation or not over the whole batch"""
+        return torch.as_tensor(self.probability > self.rng.uniform(size=batch_size)).to(
+            device
+        )
+
+    @property
+    def probability(self):
+        return self._probability
+
+
+class IdentityTransform(Transform):
+    """Identity transform.
+
+    Transform that does not change the input.
+    """
+
+    operation = staticmethod(identity)  # type: ignore[assignment]
+    # https://github.com/python/mypy/issues/4574
+
+
+class Compose(Transform):
+    """Transform composition.
+
+    Callable class allowing to cast a sequence of Transform objects into a
+    single one.
+
+    Parameters
+    ----------
+    transforms: list
+        Sequence of Transforms to be composed.
+    """
+
+    def __init__(self, transforms):
+        self.transforms = transforms
+        super().__init__()
+
+    def forward(self, X, y):
+        for transform in self.transforms:
+            X, y = transform(X, y)
+        return X, y
+
+
+def _make_collateable(transform, device=None):
+    """Wraps a transform to make it collateable.
+    with device control."""
+
+    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):
+    """A base dataloader class customized to applying augmentation Transforms.
+
+    Parameters
+    ----------
+    dataset : BaseDataset
+        The dataset containing the signals.
+    transforms : list | Transform, optional
+        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.
+    **kwargs : dict, optional
+        keyword arguments to pass to standard DataLoader class.
+    """
+
+    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 transforms is None or (
+            isinstance(transforms, list) and len(transforms) == 0
+        ):
+            self.collated_tr = _make_collateable(IdentityTransform(), device=device)
+        elif isinstance(transforms, (Transform, nn.Module)):
+            self.collated_tr = _make_collateable(transforms, device=device)
+        elif isinstance(transforms, list):
+            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."
+            )
+
+        super().__init__(dataset, collate_fn=self.collated_tr, **kwargs)