braindecode 1.3.0.dev177628147__py3-none-any.whl → 1.3.0.dev182330353__py3-none-any.whl

braindecode/augmentation/functional.py

@@ -1,7 +1,6 @@
 # Authors: Cédric Rommel <cedric.rommel@inria.fr>
 #          Alexandre Gramfort <alexandre.gramfort@inria.fr>
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
-#          Bruna Lopes <brunajaflopes@gmail.com>
 #
 # License: BSD (3-clause)
 
@@ -1195,103 +1194,3 @@ def mask_encoding(
     X[mask] = 0
 
     return X, y  # Return the masked tensor and labels
-
-
-def channels_rereference(
-    X: torch.Tensor,
-    y: torch.Tensor,
-    random_state: int | np.random.RandomState | None = None,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Randomly re-reference channels in EEG data matrix.
-
-    Part of the augmentations proposed in [1]_
-
-    Parameters
-    ----------
-    X : torch.Tensor
-        EEG input example or batch.
-    y : torch.Tensor
-        EEG labels for the example or batch.
-    random_state: int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Defaults to None.
-
-    Returns
-    -------
-    torch.Tensor
-        Transformed inputs.
-    torch.Tensor
-        Transformed labels.
-
-    References
-    ----------
-    .. [1] Mohsenvand, M.N., Izadi, M.R. &amp; Maes, P.. (2020). Contrastive
-        Representation Learning for Electroencephalogram Classification. Proceedings
-        of the Machine Learning for Health NeurIPS Workshop, in Proceedings of Machine
-        Learning Research 136:238-253
-
-    """
-
-    rng = check_random_state(random_state)
-    batch_size, n_channels, _ = X.shape
-
-    ch = rng.randint(0, n_channels, size=batch_size)
-
-    X_ch = X[torch.arange(batch_size), ch, :]
-    X = X - X_ch.unsqueeze(1)
-    X[torch.arange(batch_size), ch, :] = -X_ch
-
-    return X, y
-
-
-def amplitude_scale(
-    X: torch.Tensor,
-    y: torch.Tensor,
-    scale: tuple,
-    random_state: int | np.random.RandomState | None = None,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Rescale amplitude of each channel based on a random sampled scaling value.
-
-    Part of the augmentations proposed in [1]_
-
-    Parameters
-    ----------
-    X : torch.Tensor
-        EEG input example or batch.
-    y : torch.Tensor
-        EEG labels for the example or batch.
-    scale : tuple of floats
-        Interval from which ypu sample the scaling value
-    random_state: int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Defaults to None.
-
-    Returns
-    -------
-    torch.Tensor
-        Transformed inputs.
-    torch.Tensor
-        Transformed labels.
-
-    References
-    ----------
-    .. [1] Mohsenvand, M.N., Izadi, M.R. &amp; Maes, P.. (2020). Contrastive
-        Representation Learning for Electroencephalogram Classification. Proceedings
-        of the Machine Learning for Health NeurIPS Workshop, in Proceedings of Machine
-        Learning Research 136:238-253
-
-    """
-
-    rng = torch.Generator()
-    rng.manual_seed(random_state)
-    batch_size, n_channels, _ = X.shape
-
-    # Parameter for scaling amplitude / channel / trial
-    l, h = scale
-    s = l + (h - l) * torch.rand(
-        batch_size, n_channels, 1, generator=rng, device=X.device, dtype=X.dtype
-    )
-
-    X = s * X
-
-    return X, y

braindecode/augmentation/transforms.py

@@ -1,7 +1,6 @@
 # Authors: Cédric Rommel <cedric.rommel@inria.fr>
 #          Alexandre Gramfort <alexandre.gramfort@inria.fr>
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
-#          Bruna Lopes <brunajaflopes@gmail.com>
 #
 # License: BSD (3-clause)
 
@@ -14,11 +13,9 @@ from mne.channels import make_standard_montage
 
 from .base import Transform
 from .functional import (
-    amplitude_scale,
     bandstop_filter,
     channels_dropout,
     channels_permute,
-    channels_rereference,
     channels_shuffle,
     frequency_shift,
     ft_surrogate,
@@ -1274,74 +1271,3 @@ class MaskEncoding(Transform):
             "segment_length": segment_length,
             "n_segments": self.n_segments,
         }
-
-
-class ChannelsReref(Transform):
-    """Randomly re-reference channels in EEG data matrix.
-
-    Part of the augmentations proposed in [1]_
-
-    Parameters
-    ----------
-    probability: float
-        Float setting the probability of applying the operation.
-    random_state: int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Used to decide whether or not to transform given the probability
-        argument, to sample which channels to shuffle and to carry the shuffle.
-        Defaults to None.
-
-    References
-    ----------
-    .. [1] Mohsenvand, M.N., Izadi, M.R. &amp; Maes, P.. (2020). Contrastive
-        Representation Learning for Electroencephalogram Classification. Proceedings
-        of the Machine Learning for Health NeurIPS Workshop, in Proceedings of Machine
-        Learning Research 136:238-253 Available from https://proceedings.mlr.press/v136/mohsenvand20a.html.
-
-    """
-
-    operation = staticmethod(channels_rereference)  # type: ignore[assignment]
-
-    def __init__(self, probability, random_state=None):
-        super().__init__(probability=probability, random_state=random_state)
-
-    def get_augmentation_params(self, *batch):
-        """Return transform parameters"""
-        return {
-            "random_state": self.rng,
-        }
-
-
-class AmplitudeScale(Transform):
-    """Rescale amplitude based on a random sampled scaling value.
-
-    Part of the augmentations proposed in [1]_
-
-    Parameters
-    ----------
-    probability: float
-        Float setting the probability of applying the operation.
-    random_state: int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Used to decide whether or not to transform given the probability
-        argument, to sample which channels to shuffle and to carry the shuffle.
-        Defaults to None.
-
-    References
-    ----------
-    .. [1] Mohsenvand, M.N., Izadi, M.R. &amp; Maes, P.. (2020). Contrastive
-        Representation Learning for Electroencephalogram Classification. Proceedings
-        of the Machine Learning for Health NeurIPS Workshop, in Proceedings of Machine
-        Learning Research 136:238-253 Available from https://proceedings.mlr.press/v136/mohsenvand20a.html.
-
-    """
-
-    operation = staticmethod(amplitude_scale)  # type: ignore[assignment]
-
-    def __init__(self, probability, interval=(0.5, 2), random_state=None):
-        super().__init__(probability=probability, random_state=random_state)
-        self.scale = interval
-
-    def get_augmentation_params(self, *batch):
-        """Return transform parameters"""
-        return {"random_state": self.rng, "scale": self.scale}

braindecode/datasets/base.py

@@ -19,7 +19,7 @@ import warnings
 from abc import abstractmethod
 from collections.abc import Callable
 from glob import glob
-from typing import Any, Generic, Iterable, no_type_check
+from typing import Generic, Iterable, no_type_check
 
 import mne.io
 import numpy as np
@@ -28,9 +28,6 @@ from mne.utils.docs import deprecated
 from torch.utils.data import ConcatDataset, Dataset
 from typing_extensions import TypeVar
 
-from .hub import HubDatasetMixin
-from .registry import register_dataset
-
 
 def _create_description(description) -> pd.Series:
     if description is not None:
@@ -100,7 +97,6 @@ class RecordDataset(Dataset[tuple[np.ndarray, int | str, tuple[int, int, int]]])
 T = TypeVar("T", bound=RecordDataset)
 
 
-@register_dataset
 class RawDataset(RecordDataset):
     """Returns samples from an mne.io.Raw object along with a target.
 
@@ -133,7 +129,6 @@ class RawDataset(RecordDataset):
 
         # save target name for load/save later
         self.target_name = self._target_name(target_name)
-        self.raw_preproc_kwargs: list[dict[str, Any]] = []
 
     def __getitem__(self, index):
         X = self.raw[:, index][0]
@@ -181,12 +176,10 @@ class RawDataset(RecordDataset):
     "If you want to type a Braindecode dataset (i.e. RawDataset|EEGWindowsDataset|WindowsDataset), "
     "use the RecordDataset class instead."
 )
-@register_dataset
 class BaseDataset(RawDataset):
     pass
 
 
-@register_dataset
 class EEGWindowsDataset(RecordDataset):
     """Returns windows from an mne.Raw object, its window indices, along with a target.
 
@@ -242,7 +235,6 @@ class EEGWindowsDataset(RecordDataset):
         ].to_numpy()
         if self.targets_from == "metadata":
             self.y = metadata.loc[:, "target"].to_list()
-        self.raw_preproc_kwargs: list[dict[str, Any]] = []
 
     def __getitem__(self, index: int):
         """Get a window and its target.
@@ -293,7 +285,6 @@ class EEGWindowsDataset(RecordDataset):
         return len(self.crop_inds)
 
 
-@register_dataset
 class WindowsDataset(RecordDataset):
     """Returns windows from an mne.Epochs object along with a target.
 
@@ -343,8 +334,6 @@ class WindowsDataset(RecordDataset):
         ].to_numpy()
         if self.targets_from == "metadata":
             self.y = metadata.loc[:, "target"].to_list()
-        self.raw_preproc_kwargs: list[dict[str, Any]] = []
-        self.window_preproc_kwargs: list[dict[str, Any]] = []
 
     def __getitem__(self, index: int):
         """Get a window and its target.
@@ -385,16 +374,12 @@ class WindowsDataset(RecordDataset):
         return len(self.windows.events)
 
 
-@register_dataset
-class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
+class BaseConcatDataset(ConcatDataset, Generic[T]):
     """A base class for concatenated datasets.
 
     Holds either mne.Raw or mne.Epoch in self.datasets and has
     a pandas DataFrame with additional description.
 
-    Includes Hugging Face Hub integration via HubDatasetMixin for
-    uploading and downloading datasets.
-
     Parameters
     ----------
     list_of_ds : list
@@ -809,7 +794,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 kwargs = getattr(ds, kwargs_name)
                 if kwargs is not None:
                     with open(kwargs_file_path, "w") as f:
-                        json.dump(kwargs, f, indent=2)
+                        json.dump(kwargs, f)
 
     @staticmethod
     def _save_target_name(sub_dir, ds):

braindecode/datautil/serialization.py

@@ -302,6 +302,7 @@ def _load_kwargs_json(kwargs_name, sub_dir):
     kwargs_file_path = os.path.join(sub_dir, kwargs_file_name)
     if os.path.exists(kwargs_file_path):
         kwargs = json.load(open(kwargs_file_path, "r"))
+        kwargs = [tuple(kwarg) for kwarg in kwargs]
         return kwargs
 
 

braindecode/models/__init__.py

@@ -28,7 +28,6 @@ from .fbmsnet import FBMSNet
 from .hybrid import HybridNet
 from .ifnet import IFNet
 from .labram import Labram
-from .luna import LUNA
 from .medformer import MEDFormer
 from .msvtnet import MSVTNet
 from .patchedtransformer import PBT
@@ -50,11 +49,7 @@ from .tcn import BDTCN, TCN
 from .tidnet import TIDNet
 from .tsinception import TSception
 from .usleep import USleep
-from .util import (
-    _init_models_dict,
-    extract_channel_locations_from_chs_info,
-    models_mandatory_parameters,
-)
+from .util import _init_models_dict, models_mandatory_parameters
 
 # Call this last in order to make sure the dataset list is populated with
 # the models imported in this file.
@@ -88,8 +83,6 @@ __all__ = [
     "HybridNet",
     "IFNet",
     "Labram",
-    "LUNA",
-    "extract_channel_locations_from_chs_info",
     "MEDFormer",
     "MSVTNet",
     "PBT",

braindecode/models/summary.csv

@@ -41,5 +41,4 @@ IFNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",9860
 PBT,General,Classification,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Large Brain Model"
 SSTDPN,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",19502,"SSTDPN(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
 BENDR,General,"Classification,Embedding",250,"n_chans, n_times, n_outputs",157141049,"BENDR(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"
-LUNA,General,"Classification,Embedding",128,"n_chans, n_times, sfreq, chs_info",7100731,"LUNA(n_chans=22, n_times=512, sfreq=128)","Convolution,Channel,Large Brain Model"
 MEDFormer,General,Classification,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"

braindecode/models/util.py

@@ -4,9 +4,7 @@
 # License: BSD (3-clause)
 import inspect
 from pathlib import Path
-from typing import Any, Dict, Optional, Sequence
 
-import numpy as np
 import pandas as pd
 
 import braindecode.models as models
@@ -101,7 +99,6 @@ models_mandatory_parameters = [
     ("PBT", ["n_chans", "n_outputs", "n_times"], None),
     ("SSTDPN", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     ("BENDR", ["n_chans", "n_outputs", "n_times"], None),
-    ("LUNA", ["n_chans", "n_times", "n_outputs"], None),
     ("MEDFormer", ["n_chans", "n_outputs", "n_times"], None),
 ]
 
@@ -134,85 +131,4 @@ def get_summary_table(dir_name=None):
     return df
 
 
-def extract_channel_locations_from_chs_info(
-    chs_info: Optional[Sequence[Dict[str, Any]]],
-    num_channels: Optional[int] = None,
-) -> Optional[np.ndarray]:
-    """Extract 3D channel locations from MNE-style channel information.
-
-    This function provides a unified approach to extract 3D channel locations
-    from MNE channel information. It's compatible with models like SignalJEPA
-    and LUNA that need to work with channel spatial information.
-
-    Parameters
-    ----------
-    chs_info : list of dict or None
-        Channel information, typically from ``mne.Info.chs``. Each dict should
-        contain a 'loc' key with a 12-element array (MNE format) where indices 3:6
-        represent the 3D cartesian coordinates.
-    num_channels : int or None
-        If specified, only extract the first ``num_channels`` channel locations.
-        If None, extract all available channels.
-
-    Returns
-    -------
-    channel_locations : np.ndarray of shape (n_channels, 3) or None
-        Array of 3D channel locations in cartesian coordinates. Returns None if
-        no valid locations are found.
-
-    Notes
-    -----
-    - This function handles both 12-element MNE location format (using indices 3:6)
-      and 3-element location format (using directly).
-    - Invalid or missing locations cause extraction to stop at that point.
-    - Returns None if no valid locations can be extracted.
-    - This is a unified utility compatible with models like SignalJEPA and LUNA.
-
-    Examples
-    --------
-    >>> import mne
-    >>> from braindecode.models.util import extract_channel_locations_from_chs_info
-    >>> raw = mne.io.read_raw_edf("sample.edf")
-    >>> locs = extract_channel_locations_from_chs_info(raw.info['chs'], num_channels=22)
-    >>> print(locs.shape)
-    (22, 3)
-    """
-    if chs_info is None:
-        return None
-
-    locations = []
-    n_to_extract = num_channels if num_channels is not None else len(chs_info)
-
-    for i, ch_info in enumerate(chs_info[:n_to_extract]):
-        if not isinstance(ch_info, dict):
-            break
-
-        loc = ch_info.get("loc")
-        if loc is None:
-            break
-
-        try:
-            loc_array = np.asarray(loc, dtype=np.float32)
-
-            # MNE format: 12-element array with coordinates at indices 3:6
-            if loc_array.ndim == 1 and loc_array.size >= 6:
-                if loc_array.size == 12:
-                    # Standard MNE format
-                    coordinates = loc_array[3:6]
-                else:
-                    # Assume first 3 elements are coordinates
-                    coordinates = loc_array[:3]
-            else:
-                break
-
-            locations.append(coordinates)
-        except (ValueError, TypeError):
-            break
-
-    if len(locations) == 0:
-        return None
-
-    return np.stack(locations, axis=0)
-
-
 _summary_table = get_summary_table()

braindecode/preprocessing/__init__.py

@@ -188,17 +188,12 @@ from .preprocess import (
     filterbank,
     preprocess,
 )
-from .util import _init_preprocessor_dict
 from .windowers import (
     create_fixed_length_windows,
     create_windows_from_events,
     create_windows_from_target_channels,
 )
 
-# Call this last in order to make sure the list is populated with
-# the preprocessors imported in this file.
-_init_preprocessor_dict()
-
 __all__ = [
     "exponential_moving_demean",
     "exponential_moving_standardize",