Braindecode 1.8.0__tar.gz → 1.8.0.dev580__tar.gz

braindecode-1.8.0.dev580/NOTICE.txt

@@ -0,0 +1,25 @@
+# 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`
+- `braindecode/models/meta_neuromotor.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,
+Inc. under CC BY-NC 4.0, and inherits the same noncommercial terms.
+
+## 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-1.8.0/braindecode.egg-info → braindecode-1.8.0.dev580}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.0
+Version: 1.8.0.dev580
 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>
@@ -34,6 +34,7 @@ Requires-Dist: pandas
 Requires-Dist: wfdb>=4.3.1
 Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
+Requires-Dist: rotary_embedding_torch
 Requires-Dist: pydantic>=2.0
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.4.3; extra == "moabb"
@@ -50,7 +51,6 @@ Requires-Dist: pytest-cov; extra == "tests"
 Requires-Dist: codecov; extra == "tests"
 Requires-Dist: pytest_cases; extra == "tests"
 Requires-Dist: mypy; extra == "tests"
-Requires-Dist: ipython; extra == "tests"
 Requires-Dist: transformers>=4.57.0; extra == "tests"
 Requires-Dist: bids_validator; extra == "tests"
 Provides-Extra: typing
@@ -260,10 +260,7 @@ This project is primarily licensed under the BSD-3-Clause License.
 Additional Components
 =====================
 
-Some components within this repository are licensed under other licenses, including
-Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0), Creative
-Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0), MIT
-and Apache-2.0.
+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 the per-file list and more
-detailed information.
+Please refer to the ``LICENSE`` and ``NOTICE`` files for more detailed information.

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/README.rst

@@ -170,10 +170,7 @@ This project is primarily licensed under the BSD-3-Clause License.
 Additional Components
 =====================
 
-Some components within this repository are licensed under other licenses, including
-Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0), Creative
-Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0), MIT
-and Apache-2.0.
+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 the per-file list and more
-detailed information.
+Please refer to the ``LICENSE`` and ``NOTICE`` files for more detailed information.

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/braindecode/augmentation/base.py

@@ -3,7 +3,6 @@
 #          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
@@ -177,14 +176,6 @@ 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.
 
@@ -202,10 +193,7 @@ 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. 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.
+        ``(1 + n_augmentation)`` times the original size.
     """
 
     def __init__(self, transform, device=None, n_augmentation=0):
@@ -228,18 +216,6 @@ 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 → braindecode-1.8.0.dev580}/braindecode/augmentation/functional.py

@@ -1065,11 +1065,13 @@ def mixup(
     batch_size, n_channels, n_times = X.shape
 
     X_mix = torch.zeros((batch_size, n_channels, n_times)).to(device)
-    y_a = y.clone()
-    y_b = y[idx_perm].clone()
+    y_a = torch.arange(batch_size).to(device)
+    y_b = torch.arange(batch_size).to(device)
 
     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 → braindecode-1.8.0.dev580}/braindecode/augmentation/transforms.py

@@ -1068,18 +1068,16 @@ 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=device, dtype=X.dtype)
+                ).to(device)
             else:
-                lam = torch.ones(batch_size, dtype=X.dtype).to(device)
+                lam = torch.ones(batch_size).to(device)
                 lam *= self.rng.beta(self.alpha, self.alpha)
         else:
-            lam = torch.ones(batch_size, dtype=X.dtype).to(device)
+            lam = torch.ones(batch_size).to(device)
 
         idx_perm = torch.as_tensor(
             self.rng.permutation(

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/braindecode/datasets/base.py

@@ -32,7 +32,6 @@ from mne.utils.docs import deprecated
 from torch.utils.data import ConcatDataset, Dataset, IterableDataset
 from typing_extensions import TypeVar
 
-from ._notebook_viewer import plot as _viewer_plot
 from .bids.hub import HubDatasetMixin
 from .bids.hub_io import _restore_nan_from_json
 from .registry import register_dataset
@@ -60,7 +59,6 @@ def _html_row(label, value):
 
 _METADATA_INTERNAL_COLS = {
     "i_window_in_trial",
-    "i_trial_in_dataset",
     "i_start_in_trial",
     "i_stop_in_trial",
     "target",
@@ -1175,8 +1173,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         If True, defer computing cumulative sizes until length or item access.
     """
 
-    plot = _viewer_plot  # eegdash-viewer embed; a direct member so the API docs list it
-
     datasets: list[T]
 
     def __init__(
@@ -1378,20 +1374,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 "datasets are WindowsDataset."
             )
 
-        for ds in self.datasets:
-            if hasattr(ds, "_windows") and ds._windows is not None:
-                df = ds._windows.metadata
-            else:
-                df = ds.metadata
-            if (
-                "i_trial_in_dataset" in df.columns
-                and "i_trial_in_dataset" in ds.description
-            ):
-                raise ValueError(
-                    "Dataset descriptions cannot contain the reserved window "
-                    "metadata key 'i_trial_in_dataset'."
-                )
-
         all_dfs = list()
         for ds in self.datasets:
             if hasattr(ds, "_windows") and ds._windows is not None:

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/braindecode/datasets/bids/hub.py

@@ -28,7 +28,6 @@ The format follows a BIDS-inspired sourcedata structure:
 # License: BSD (3-clause)
 
 import contextlib
-import copy
 import json
 import logging
 import tempfile
@@ -57,7 +56,6 @@ from .hub_io import (
     _load_eegwindows_from_zarr,
     _load_raw_from_zarr,
     _load_windows_from_zarr,
-    _prepare_info_for_json,
     _save_eegwindows_to_zarr,
     _save_raw_to_zarr,
     _save_windows_to_zarr,
@@ -74,33 +72,6 @@ log = logging.getLogger(__name__)
 _LOCK_FILE = "format_info.json"
 
 
-def _normalize_kwargs_for_json(value, field_name):
-    """Return one preprocessing-kwargs value as native strict JSON."""
-
-    def _convert(obj):
-        if isinstance(obj, np.ndarray):
-            return _convert(obj.tolist())
-        if isinstance(obj, dict):
-            return {key: _convert(item) for key, item in obj.items()}
-        if isinstance(obj, (list, tuple)):
-            return [_convert(item) for item in obj]
-        if isinstance(obj, np.generic):
-            return _convert(obj.item())
-        return obj
-
-    try:
-        converted = _convert(value)
-        if isinstance(converted, str):
-            raise ValueError(
-                "a root string is ambiguous with the legacy encoded format"
-            )
-        return json.loads(json.dumps(converted, allow_nan=False))
-    except (OverflowError, RecursionError, TypeError, ValueError) as error:
-        raise ValueError(
-            f"{field_name} must contain only finite JSON-serializable values"
-        ) from error
-
-
 class HubDatasetMixin:
     """
     Mixin class for Hugging Face Hub integration with EEG datasets.
@@ -714,57 +685,14 @@ class HubDatasetMixin:
                 f"{output_path} already exists. Set overwrite=True to replace it."
             )
 
+        # Create zarr store (zarr v3 API)
+        root = zarr.open(str(output_path), mode="w")
+
         # Validate uniformity across all datasets using shared validation
         dataset_type, _, _ = hub_validation.validate_dataset_uniformity(self.datasets)
 
-        # Normalize every JSON value before opening the output store. The cached
-        # values below are the exact values handed to the write helpers.
-        prepared_infos = []
-        for ds in self.datasets:
-            if dataset_type == "WindowsDataset":
-                info = ds.windows.info
-            elif dataset_type in ("EEGWindowsDataset", "RawDataset"):
-                info = ds.raw.info
-            prepared_infos.append(_prepare_info_for_json(info.to_json_dict()))
-
-        prepared_kwargs = {}
-        for kwarg_name in [
-            "raw_preproc_kwargs",
-            "window_kwargs",
-            "window_preproc_kwargs",
-        ]:
-            expected_present = hasattr(self.datasets[0], kwarg_name)
-            expected_value = None
-            expected_token = None
-            for i_ds, ds in enumerate(self.datasets):
-                present = hasattr(ds, kwarg_name)
-                if present != expected_present:
-                    raise ValueError(
-                        f"{kwarg_name} on dataset {i_ds} has inconsistent presence; "
-                        "the Zarr format stores one global value"
-                    )
-                if not present:
-                    continue
-                value = _normalize_kwargs_for_json(
-                    getattr(ds, kwarg_name), f"{kwarg_name} on dataset {i_ds}"
-                )
-                value_token = json.dumps(
-                    value, sort_keys=True, separators=(",", ":"), allow_nan=False
-                )
-                if i_ds == 0:
-                    expected_value = value
-                    expected_token = value_token
-                elif value_token != expected_token:
-                    raise ValueError(
-                        f"{kwarg_name} on dataset {i_ds} differs from dataset 0; "
-                        "the Zarr format stores one global value"
-                    )
-            if expected_present:
-                prepared_kwargs[kwarg_name] = expected_value
-
-        # Create compressor and zarr store (zarr v3 API) only after preflight.
-        compressor = _create_compressor(compression, compression_level)
-        root = zarr.open(str(output_path), mode="w")
+        # Keep reference to first dataset for preprocessing kwargs
+        first_ds = self.datasets[0]
 
         # Store global metadata
         root.attrs["n_datasets"] = len(self.datasets)
@@ -778,10 +706,21 @@ class HubDatasetMixin:
         root.attrs["zarr_version"] = zarr.__version__
         root.attrs["scipy_version"] = scipy.__version__
 
-        # Save preprocessing kwargs from the preflight cache. These are
-        # typically set by windowing functions on individual datasets.
-        for kwarg_name, kwargs in prepared_kwargs.items():
-            root.attrs[kwarg_name] = kwargs
+        # Save preprocessing kwargs (check first dataset, assuming uniform preprocessing)
+        # These are typically set by windowing functions on individual datasets
+        for kwarg_name in [
+            "raw_preproc_kwargs",
+            "window_kwargs",
+            "window_preproc_kwargs",
+        ]:
+            # Check first dataset for these attributes
+            if hasattr(first_ds, kwarg_name):
+                kwargs = getattr(first_ds, kwarg_name)
+                if kwargs:
+                    root.attrs[kwarg_name] = json.dumps(kwargs)
+
+        # Create compressor
+        compressor = _create_compressor(compression, compression_level)
 
         # Save each recording
         for i_ds, ds in enumerate(self.datasets):
@@ -792,7 +731,7 @@ class HubDatasetMixin:
                 data = ds.windows.get_data()
                 metadata = ds.windows.metadata
                 description = ds.description
-                info_dict = prepared_infos[i_ds]
+                info_dict = ds.windows.info.to_json_dict()
                 target_name = ds.target_name if hasattr(ds, "target_name") else None
 
                 # Save using inlined function
@@ -811,7 +750,7 @@ class HubDatasetMixin:
                 raw = ds.raw
                 metadata = ds.metadata
                 description = ds.description
-                info_dict = prepared_infos[i_ds]
+                info_dict = ds.raw.info.to_json_dict()
                 targets_from = ds.targets_from
                 last_target_only = ds.last_target_only
 
@@ -832,7 +771,7 @@ class HubDatasetMixin:
                 # Get continuous raw data from RawDataset
                 raw = ds.raw
                 description = ds.description
-                info_dict = prepared_infos[i_ds]
+                info_dict = ds.raw.info.to_json_dict()
                 target_name = ds.target_name if hasattr(ds, "target_name") else None
 
                 # Save using inlined function
@@ -1017,14 +956,10 @@ class HubDatasetMixin:
             "window_preproc_kwargs",
         ]:
             if kwarg_name in root.attrs:
-                kwargs = root.attrs[kwarg_name]
-                if isinstance(kwargs, str):
-                    # Stores written by older braindecode versions kept
-                    # these attributes as double-encoded JSON strings.
-                    kwargs = json.loads(kwargs)
+                kwargs = json.loads(root.attrs[kwarg_name])
                 # Set on each individual dataset (where they were originally stored)
                 for ds in datasets:
-                    setattr(ds, kwarg_name, copy.deepcopy(kwargs))
+                    setattr(ds, kwarg_name, kwargs)
 
         return concat_ds
 

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/braindecode/datasets/bids/hub_io.py

@@ -8,7 +8,6 @@ These functions keep the Zarr serialization details isolated from hub.py.
 from __future__ import annotations
 
 import json
-from numbers import Real
 from pathlib import Path
 
 import numpy as np
@@ -18,78 +17,17 @@ from mne.utils import _soft_import
 zarr = _soft_import("zarr", purpose="hugging face integration", strict=False)
 
 
-def _is_non_bool_real(value):
-    return not isinstance(value, (bool, np.bool_)) and isinstance(
-        value, (Real, np.integer, np.floating)
-    )
-
-
-def _prepare_info_for_json(obj, path="info", *, _in_numeric_sequence=False):
-    """Normalize an MNE Info value to strict JSON without losing sequence NaNs."""
-    if isinstance(obj, np.ndarray):
-        obj = obj.tolist()
-
-    if isinstance(obj, dict):
-        return {
-            key: _prepare_info_for_json(value, f"{path}.{key}")
-            for key, value in obj.items()
-        }
-
-    if isinstance(obj, (list, tuple)):
-        values = list(obj)
-        has_none = any(value is None for value in values)
-        has_number = any(_is_non_bool_real(value) for value in values)
-        all_none = bool(values) and all(value is None for value in values)
-        if all_none or (has_none and has_number):
-            raise ValueError(
-                f"{path} is ambiguous: numeric sequences cannot contain JSON null"
-            )
-
-        is_numeric_sequence = bool(values) and all(
-            _is_non_bool_real(value) for value in values
-        )
-        return [
-            _prepare_info_for_json(
-                value,
-                f"{path}[{index}]",
-                _in_numeric_sequence=is_numeric_sequence,
-            )
-            for index, value in enumerate(values)
-        ]
-
-    if isinstance(obj, (bool, np.bool_)):
-        return bool(obj)
-    if isinstance(obj, (int, np.integer)):
-        return int(obj)
-    if _is_non_bool_real(obj):
-        value = float(obj)
-        if np.isnan(value):
-            if _in_numeric_sequence:
-                return None
-            raise ValueError(f"{path} contains unsupported NaN")
-        if np.isposinf(value):
-            raise ValueError(f"{path} contains positive infinity")
-        if np.isneginf(value):
-            raise ValueError(f"{path} contains negative infinity")
-        return value
-    if obj is None or isinstance(obj, str):
-        return obj
-    raise ValueError(f"{path} contains a non-JSON-serializable value")
-
-
 def _restore_nan_from_json(obj):
-    """Restore NaN values from None in JSON-loaded attributes.
+    """Restore NaN values from None in legacy zarr stores.
 
-    JSON null is reserved for NaN only in non-boolean numeric sequences.
-    All-null lists are therefore the representation of validated all-NaN
-    sequences, while ordinary null values elsewhere remain unchanged.
+    Datasets saved before zarr v3 native NaN support used
+    ``_sanitize_for_json`` to convert NaN/Inf → None. This restores them
+    on load so ``mne.Info.from_json_dict`` gets proper NaN arrays.
     """
     if isinstance(obj, dict):
         return {k: _restore_nan_from_json(v) for k, v in obj.items()}
     if isinstance(obj, list):
-        if len(obj) > 0 and all(
-            value is None or _is_non_bool_real(value) for value in obj
-        ):
+        if len(obj) > 0 and all(isinstance(x, (int, float, type(None))) for x in obj):
             return [np.nan if x is None else x for x in obj]
         return [_restore_nan_from_json(v) for v in obj]
     return obj

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/braindecode/functional/functions.py

@@ -40,7 +40,7 @@ def drop_path(
     x : torch.Tensor
         input tensor
     drop_prob : float, optional
-        probability of dropping a path, by default 0.0
+        survival rate (i.e. probability of being kept), by default 0.0
     training : bool, optional
         whether the model is in training mode, by default False
     scale_by_keep : bool, optional
@@ -68,10 +68,9 @@ def drop_path(
     shape = (x.shape[0],) + (1,) * (
         x.ndim - 1
     )  # work with diff dim tensors, not just 2D ConvNets
-    probabilities = torch.full(shape, keep_prob, dtype=torch.float32, device=x.device)
-    random_tensor = torch.bernoulli(probabilities).to(dtype=x.dtype)
+    random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
     if keep_prob > 0.0 and scale_by_keep:
-        random_tensor = random_tensor / keep_prob
+        random_tensor.div_(keep_prob)
     return x * random_tensor
 
 

{braindecode-1.8.0 → braindecode-1.8.0.dev580}/braindecode/models/atcnet.py

@@ -196,7 +196,7 @@ class ATCNet(EEGModuleMixin, nn.Module):
     num_heads : int
         Number of attention heads, denoted H in table 1 of the paper [1]_.
         Defaults to 2 as in [1]_.
-    att_drop_prob : float
+    att_dropout : float
         Dropout probability used in the attention block, denoted pa in table 1
         of the paper [1]_. Defaults to 0.5 as in [1]_.
     tcn_depth : int
@@ -206,7 +206,7 @@ class ATCNet(EEGModuleMixin, nn.Module):
     tcn_kernel_size : int
         Temporal kernel size used in TCN block, denoted Kt in table 1 of the
         paper [1]_. Defaults to 4 as in [1]_.
-    tcn_drop_prob : float
+    tcn_dropout : float
         Dropout probability used in the TCN block, denoted pt in table 1
         of the paper [1]_. Defaults to 0.3 as in [1]_.
     tcn_activation : torch.nn.Module