Braindecode 1.8.1.dev182039595__tar.gz → 1.8.1.dev182199177__tar.gz

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/NOTICE.txt

@@ -40,7 +40,6 @@ The following components are licensed under the MIT License:
 
 - `braindecode/models/ctnet.py`
 - `braindecode/models/dance.py`
-- `braindecode/models/duin.py`
 - `braindecode/models/medformer.py`
 - `braindecode/models/tcformer.py`
 - `braindecode/models/ifnet.py`
@@ -55,8 +54,6 @@ The following components are licensed under the MIT License:
 - `docs/_static/model/seizure_transformer_arch.png`
 - `braindecode/models/guetschel2026.py`
 - `braindecode/models/tmsanet.py`
-- `braindecode/models/epint.py`
-- `braindecode/models/gcnsnet.py`
 
 The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
 SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The

{braindecode-1.8.1.dev182039595/braindecode.egg-info → braindecode-1.8.1.dev182199177}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev182039595
+Version: 1.8.1.dev182199177
 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.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/augmentation/__init__.py

@@ -10,7 +10,6 @@ from .transforms import (
     ChannelsReref,
     ChannelsShuffle,
     ChannelsSymmetry,
-    CutMix,
     FrequencyShift,
     FTSurrogate,
     GaussianNoise,
@@ -37,7 +36,6 @@ __all__ = [
     "SignFlip",
     "FTSurrogate",
     "ChannelsShuffle",
-    "CutMix",
     "ChannelsDropout",
     "GaussianNoise",
     "ChannelsSymmetry",

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/augmentation/functional.py

@@ -580,7 +580,6 @@ def _frequency_shift(X: torch.Tensor, fs: float, f_shift: float) -> torch.Tensor
         _f_shift = torch.as_tensor(f_shift).float()
     else:
         raise ValueError(f"Invalid f_shift type: {type(f_shift)}")
-    _f_shift = _f_shift.to(X.device)
     f_shift_stack = _f_shift.repeat(N_padded, n_channels, 1)
     reshaped_f_shift = f_shift_stack.permute(
         *torch.arange(f_shift_stack.ndim - 1, -1, -1)
@@ -1076,54 +1075,6 @@ def mixup(
     return X_mix, (y_a, y_b, lam)
 
 
-def cutmix(
-    X: torch.Tensor,
-    y: torch.Tensor,
-    idx_perm: torch.Tensor,
-    cut_t_start: torch.Tensor,
-    cut_t_len: torch.Tensor,
-) -> tuple[torch.Tensor, torch.Tensor]:
-    """Paste a time region of shuffled examples into the original examples.
-
-    See [1]_ for details.
-
-    Parameters
-    ----------
-    X : torch.Tensor
-        EEG data in form ``batch_size, n_channels, n_times``
-    y : torch.Tensor
-        Target of length ``batch_size``
-    idx_perm : torch.Tensor
-        Permuted indices of example that are mixed into original examples.
-    cut_t_start : torch.Tensor
-        Start index of the pasted time region for each example.
-    cut_t_len : torch.Tensor
-        Length of the pasted time region for each example.
-
-    Returns
-    -------
-    tuple
-        ``X``, ``y``. Where ``X`` is augmented and ``y`` is a tuple of length
-        3 containing the labels of the two mixed examples and the fraction of
-        each example kept from the original, ``1 - cut_t_len / n_times``.
-
-    References
-    ----------
-    .. [1] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun,
-        Junsuk Choe, Youngjoon Yoo (2019). CutMix: Regularization Strategy
-        to Train Strong Classifiers with Localizable Features. In 2019
-        IEEE/CVF International Conference on Computer Vision (ICCV)
-        Online: https://arxiv.org/abs/1905.04899
-    """
-    n_times = X.shape[-1]
-    t = torch.arange(n_times, device=X.device)
-    start = cut_t_start[:, None]
-    in_cut = (t >= start) & (t < start + cut_t_len[:, None])
-    X_mix = torch.where(in_cut[:, None], X[idx_perm], X)
-    lam = (n_times - cut_t_len).to(X.dtype) / n_times
-    return X_mix, (y.clone(), y[idx_perm].clone(), lam)
-
-
 def segmentation_reconstruction(
     X: torch.Tensor,
     y: torch.Tensor,

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/augmentation/transforms.py

@@ -3,7 +3,6 @@
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
 #          Bruna Lopes <brunajaflopes@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
-#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -25,7 +24,6 @@ from .functional import (
     channels_permute,
     channels_rereference,
     channels_shuffle,
-    cutmix,
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
@@ -1097,55 +1095,6 @@ class Mixup(Transform):
         }
 
 
-class CutMix(Mixup):
-    """Implements CutMix for EEG data.
-
-    A random time region of each example is replaced by the same region of
-    a shuffled example of the batch, see [1]_. As in the reference code [2]_,
-    a coefficient ``lam`` is drawn from a Beta distribution, the region is
-    ``(1 - lam) * n_times`` long (the 1-D analogue of the cut area ratio
-    ``1 - lam``) around a uniformly drawn center, it is clipped at the trial
-    boundaries, and ``lam`` is then recomputed from the pasted length.
-
-    Like :class:`Mixup`, it applies to whole batches and returns targets
-    ``(y_a, y_b, lam)`` for :func:`braindecode.training.mixup_criterion`.
-
-    Parameters
-    ----------
-    alpha : float
-        Parameter of the Beta distribution of ``lam``. ``alpha <= 0`` cuts
-        nothing.
-    beta_per_sample : bool (default=False)
-        By default, one ``lam`` per batch is drawn. If True, one per sample.
-    random_state : int | numpy.random.Generator, optional
-        Seed to be used to instantiate numpy random number generator instance.
-        Defaults to None.
-
-    References
-    ----------
-    .. [1] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun,
-       Junsuk Choe, Youngjoon Yoo (2019). CutMix: Regularization Strategy
-       to Train Strong Classifiers with Localizable Features. In 2019
-       IEEE/CVF International Conference on Computer Vision (ICCV)
-       Online: https://arxiv.org/abs/1905.04899
-    .. [2] https://github.com/clovaai/CutMix-PyTorch/blob/master/train.py
-    """
-
-    operation = staticmethod(cutmix)  # type: ignore[assignment]
-
-    def get_augmentation_params(self, *batch):
-        """Return idx_perm and the cut_t_start, cut_t_len of each region."""
-        params = super().get_augmentation_params(*batch)
-        lam = params.pop("lam")
-        n_times = batch[0].shape[-1]
-        half = ((1 - lam) * n_times).long() // 2
-        center = torch.as_tensor(self.rng.randint(n_times, size=len(lam)))
-        center = center.to(lam.device)
-        start = (center - half).clamp(min=0)
-        end = (center + half).clamp(max=n_times)
-        return dict(params, cut_t_start=start, cut_t_len=end - start)
-
-
 class SegmentationReconstruction(Transform):
     """Segmentation Reconstruction from Lotte (2015) [Lotte2015]_.
 
@@ -1334,7 +1283,7 @@ class MaskEncoding(Transform):
         )
 
         time_start = self.rng.randint(
-            0, n_times - segment_length + 1, (batch_size, self.n_segments)
+            0, n_times - segment_length, (batch_size, self.n_segments)
         )
         time_start = torch.from_numpy(time_start)
 

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/datasets/base.py

@@ -14,16 +14,13 @@ from __future__ import annotations
 import bisect
 import html as _html
 import json
-import mmap
 import os
 import shutil
 import warnings
 from abc import abstractmethod
 from collections import Counter
-from collections.abc import Callable, Hashable, Sequence
+from collections.abc import Callable, Hashable
 from glob import glob
-from itertools import chain
-from operator import attrgetter
 from pathlib import Path
 from typing import Any, Generic, Iterable, no_type_check
 
@@ -31,7 +28,6 @@ import mne
 import mne.io
 import numpy as np
 import pandas as pd
-from mne.io.constants import FIFF
 from mne.utils import _soft_import
 from mne.utils.docs import deprecated
 from torch.utils.data import ConcatDataset, Dataset, IterableDataset
@@ -224,125 +220,6 @@ def _compute_ch_pos(info, targets_from):
     return pos
 
 
-_TAG_ROW = attrgetter("kind", "type", "size", "next", "pos")
-
-
-def _tag_rows(tags):
-    """(kind, type, size, next, pos) of FIF tags as an int64 array (n, 5)."""
-    flat = chain.from_iterable(map(_TAG_ROW, tags))
-    return np.fromiter(flat, np.int64, 5 * len(tags)).reshape(-1, 5)
-
-
-class _FifTagTable(Sequence):
-    """The data-buffer tags of a lazy FIF raw as one int64 array.
-
-    mne's FIF reader keeps one ``Tag`` object per data buffer in
-    ``raw._raw_extras[i]["ent"]`` (one per second of signal with mne's default
-    buffers), each with its attribute dict and integers once unpickled. A lazy
-    dataset of many recordings holds millions of them in RAM, and every forked
-    DataLoader worker copies the memory pages of those it reads (reference
-    counts). This holds the same fields in 40 bytes per buffer and returns an
-    equal ``Tag`` on access, so mne's own reads are unchanged.
-    """
-
-    def __init__(self, tags):
-        self.tag_class = type(tags[0])
-        self.table = _tag_rows(tags)
-
-    def __len__(self):
-        return len(self.table)
-
-    def __getitem__(self, i):
-        if isinstance(i, slice):
-            return [self.tag_class(*row) for row in self.table[i].tolist()]
-        return self.tag_class(*self.table[i].tolist())
-
-
-_TAG_FIELDS = ("kind", "type", "size", "next", "pos", "data")
-
-
-def _compact_fif_tags(inst):
-    """Swap the ``Tag`` lists of a FIF raw for `_FifTagTable` (in place).
-
-    Only gap-free lists of directory tags (no ``None``, no ``data``) with mne's
-    ``Tag`` fields are swapped; anything else is left as mne built it.
-    """
-    for extra in getattr(inst, "_raw_extras", ()):
-        tags = extra.get("ent")
-        if not isinstance(tags, list) or not tags:
-            continue
-        cls = type(tags[0])
-        if tuple(getattr(cls, "__dataclass_fields__", ())) == _TAG_FIELDS and all(
-            type(t) is cls and t.data is None for t in tags
-        ):
-            extra["ent"] = _FifTagTable(tags)
-    return inst
-
-
-def _read_fif_window(raw, start, stop, willneed=False):
-    """Samples ``start:stop`` of a lazy FIF raw, copied from the file in one go.
-
-    mne reads, casts and calibrates the FIF data buffers of a range one at a
-    time (60 Python steps for a 60-s window saved with 1-s buffers, each through
-    a buffered file whose buffer is 4 MB on network file systems). Here one
-    slice of the memory-mapped file holds the bytes of every buffer in the
-    range and one multiply calibrates them, with mne's arithmetic (float64 data
-    times ``raw._cals``), so the values equal ``raw._getitem``'s. Returns None
-    (the caller uses mne) unless ``raw`` is a lazy, single-file, uncompressed
-    FIF raw of float32 buffers without projector, compensation or gaps.
-
-    With ``willneed=True`` nothing is read and None is returned: the OS is
-    only asked to start reading the window's bytes into the page cache in the
-    background (``posix_fadvise(POSIX_FADV_WILLNEED)``).
-    """
-    if (
-        not isinstance(raw, mne.io.Raw)
-        or raw.preload
-        or len(raw._raw_extras) != 1
-        or raw._projector is not None
-        or raw._comp is not None
-    ):
-        return None
-    extra = raw._raw_extras[0]
-    fname, bounds = extra["filename"], extra["bounds"]
-    if not isinstance(fname, Path) or fname.suffix == ".gz":
-        return None
-    start, stop = start + raw._first_samps[0], stop + raw._first_samps[0]
-    first = np.searchsorted(bounds, start, side="right") - 1
-    tags = extra["ent"]
-    if isinstance(tags, _FifTagTable):
-        rows = tags.table[first : np.searchsorted(bounds, stop)]
-    else:
-        tags = tags[first : np.searchsorted(bounds, stop)]
-        if any(t is None for t in tags):
-            return None
-        rows = _tag_rows(tags)
-    if not len(rows) or (rows[:, 1] != FIFF.FIFFT_FLOAT).any():
-        return None
-    size, pos = rows[:, 2].tolist(), rows[:, 4].tolist()
-    if willneed:  # only a hint: any error is left to the read itself
-        try:
-            with open(fname, "rb") as f:
-                os.posix_fadvise(
-                    f.fileno(),
-                    pos[0],
-                    pos[-1] + 16 + size[-1] - pos[0],
-                    os.POSIX_FADV_WILLNEED,
-                )
-        except OSError:
-            pass
-        return None
-    # mmap: no copy through a 4 MB read buffer, and a cold file is read around
-    # the window by the kernel (as mne's 4 MB reads did), not window by window
-    with open(fname, "rb") as f, mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as m:
-        buf = m[pos[0] : pos[-1] + 16 + size[-1]]
-    one = np.concatenate(
-        [np.frombuffer(buf, ">f4", s // 4, p + 16 - pos[0]) for s, p in zip(size, pos)]
-    ).reshape(-1, extra["orig_nchan"])[start - bounds[first] : stop - bounds[first]]
-    picked = one[:, raw._read_picks[0]].T
-    return np.multiply(picked, raw._cals[:, np.newaxis], order="C")
-
-
 def _window_info(crop_inds, sfreq):
     """Extract window size from crop indices.
 
@@ -634,9 +511,7 @@ class RecordDataset(Dataset[tuple[np.ndarray, int | str, tuple[int, int, int]]])
                         f"'{key}' already in description. Please "
                         f"rename or set overwrite to True."
                     )
-                    # drop on a copy: windows datasets share the description
-                    # Series of the dataset they were created from
-                    self._description = self._description.drop(key)
+                    self._description.pop(key)
             self._description = pd.concat([self.description, description])
 
     @property
@@ -948,11 +823,9 @@ class EEGWindowsDataset(_ZarrMixin, RecordDataset):
         if self._zarr_data is not None:
             X = self._zarr_data[:, i_start:i_stop]
         else:
-            X = _read_fif_window(self.raw, i_start, i_stop)
-            if X is None:
-                X = self.raw._getitem(
-                    (slice(None), slice(i_start, i_stop)), return_times=False
-                )
+            X = self.raw._getitem(
+                (slice(None), slice(i_start, i_stop)), return_times=False
+            )
         X = np.array(X, dtype="float32")
         if self.transform is not None:
             X = self.transform(X)
@@ -1283,49 +1156,6 @@ class WindowsDataset(_ZarrMixin, RecordDataset):
         )
 
 
-def _lazy_source_files(ds) -> list:
-    """Return the files ``ds`` still reads its signal from (none once preloaded)."""
-    signal = ds.raw if hasattr(ds, "raw") else getattr(ds, "windows", None)
-    if signal is None or getattr(signal, "preload", True):
-        return []
-    files = list(
-        getattr(signal, "filenames", None) or [getattr(signal, "filename", None)]
-    )
-    raw = getattr(signal, "_raw", None)
-    if isinstance(raw, mne.io.BaseRaw) and not raw.preload:
-        files += raw.filenames  # mne.Epochs of a lazily read Raw read through it
-    return [f for f in files if f is not None]
-
-
-def _dir_key(directory):
-    """Identify a directory by device and inode, whatever its spelling."""
-    stat = os.stat(directory)
-    return stat.st_dev, stat.st_ino
-
-
-def _overwrite_conflicts(datasets, path, offset):
-    """Yield ``(i_ds, i_target, target_dir)`` for each dataset ``i_ds`` that
-    lazily reads from inside ``target_dir = path/<i_target + offset>``, which
-    ``save(overwrite=True)`` deletes before writing dataset ``i_target``.
-    """
-    targets = {}
-    for i in range(len(datasets)):
-        target_dir = os.path.join(path, str(i + offset))
-        if os.path.isdir(target_dir):
-            targets[_dir_key(target_dir)] = (i, target_dir)
-    if not targets:
-        return
-    for i_ds, ds in enumerate(datasets):
-        for file in _lazy_source_files(ds):
-            # ancestors of the name and of the file it links to (DataLad)
-            parents = {
-                *Path(os.path.abspath(file)).parents,
-                *Path(os.path.realpath(file)).parents,
-            }
-            for key in {_dir_key(p) for p in parents if p.is_dir()} & targets.keys():
-                yield (i_ds, *targets[key])
-
-
 @register_dataset
 class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
     """A base class for concatenated datasets.
@@ -1423,8 +1253,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
     def __len__(self):
         return self._ensure_cumulative_sizes()[-1]
 
-    def _locate(self, idx: int):
-        """The dataset that holds item ``idx`` and the item's index in it."""
+    def _get_single_item(self, idx: int):
         if idx < 0:
             if -idx > len(self):
                 raise ValueError(
@@ -1438,33 +1267,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             sample_idx = idx
         else:
             sample_idx = idx - cumulative_sizes[dataset_idx - 1]
-        return self.datasets[dataset_idx], sample_idx
-
-    def _get_single_item(self, idx: int):
-        ds, i = self._locate(idx)
-        return ds[i]
-
-    def __getitems__(self, indices):
-        """Items ``indices``, as ``[self[i] for i in indices]``.
-
-        A :class:`~torch.utils.data.DataLoader` fetches each batch through
-        this. The lazy FIF windows of the batch are first requested from the
-        OS all at once (``posix_fadvise(POSIX_FADV_WILLNEED)``, where it
-        exists), so their reads from disk overlap instead of running one after
-        another: on a network file system a batch read from cold files then
-        costs about one round trip, not one per window.
-        """
-        # ponytail: advises the whole batch at once; chunk it if a batch's
-        # windows ever outgrow the page cache
-        if hasattr(os, "posix_fadvise"):
-            for idx in indices:
-                if not isinstance(idx, (int, np.integer)):
-                    continue  # e.g. a SequenceSampler tuple: read, not advised
-                ds, i = self._locate(idx)
-                if isinstance(ds, EEGWindowsDataset) and ds._zarr_data is None:
-                    _, start, stop = ds.crop_inds[i].tolist()
-                    _read_fif_window(ds.raw, start, stop, willneed=True)
-        return [self[idx] for idx in indices]
+        return self.datasets[dataset_idx][sample_idx]
 
     def __getitem__(self, idx: int | list):
         """
@@ -1563,9 +1366,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         metadata : pd.DataFrame
             DataFrame containing as many rows as there are windows in the
             BaseConcatDataset, with the metadata and description information
-            for each window, and an ``i_dataset`` column giving the position
-            in ``datasets`` of the dataset (recording) each window comes from.
-            Samplers use it to keep recordings apart.
+            for each window.
         """
         if not all(
             [
@@ -1591,15 +1392,9 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                     "Dataset descriptions cannot contain the reserved window "
                     "metadata key 'i_trial_in_dataset'."
                 )
-            if "i_dataset" in df.columns or "i_dataset" in ds.description:
-                raise ValueError(
-                    "Window metadata and dataset descriptions cannot contain the "
-                    "key 'i_dataset', which get_metadata() reserves for the "
-                    "position of the dataset each window comes from. Rename it."
-                )
 
         all_dfs = list()
-        for i_ds, ds in enumerate(self.datasets):
+        for ds in self.datasets:
             if hasattr(ds, "_windows") and ds._windows is not None:
                 df = ds._windows.metadata
             else:
@@ -1609,7 +1404,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 df = df.copy()
             for k, v in ds.description.items():
                 df[k] = v
-            df["i_dataset"] = i_ds
             all_dfs.append(df)
 
         return pd.concat(all_dfs)
@@ -1878,8 +1672,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
                 kwargs_path = os.path.join(path, ".".join([kwarg_name, "json"]))
                 kwargs = getattr(self, kwarg_name)
                 if kwargs is not None:
-                    with open(kwargs_path, "w") as f:
-                        json.dump(kwargs, f)
+                    json.dump(kwargs, open(kwargs_path, "w"))
 
     @property
     def description(self) -> pd.DataFrame:
@@ -1902,11 +1695,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             dataset description.
         """
         description = pd.DataFrame(description)
-        if len(description.columns) and len(description) != len(self.datasets):
-            raise ValueError(
-                f"Length of values ({len(description)}) does not match "
-                f"number of datasets ({len(self.datasets)})."
-            )
         for key, value in description.items():
             for ds, value_ in zip(self.datasets, value):
                 ds.set_description({key: value_}, overwrite=overwrite)
@@ -1937,9 +1725,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
              -raw.fif | -epo.fif and .json files to.
         overwrite : bool
             Whether to delete old subdirectories that will be saved to in this
-            call. If a dataset still reads its data lazily from one of them, a
-            ``ValueError`` is raised before anything is deleted: load the data
-            into memory first (``preload=True``) or save to another directory.
+            call.
         offset : int
             If provided, the integer is added to the id of the dataset in the
             concat. This is useful in the setting of very large datasets, where
@@ -1952,13 +1738,6 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             hasattr(self.datasets[0], "raw") or hasattr(self.datasets[0], "windows")
         ):
             raise ValueError("dataset should have either raw or windows attribute")
-        if overwrite:
-            for _, _, target_dir in _overwrite_conflicts(self.datasets, path, offset):
-                raise ValueError(
-                    f"Saving with overwrite=True would delete {target_dir} while "
-                    "a dataset still reads its data from it. Load the data into "
-                    "memory first (preload=True) or save to another directory."
-                )
 
         # Create path if it doesn't exist
         os.makedirs(path, exist_ok=True)

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/datasets/mne.py

@@ -159,11 +159,6 @@ def create_from_mne_epochs(
 
     list_of_windows_ds = []
     for i, epochs in enumerate(list_of_epochs):
-        # drop rejected epochs first (on a copy) so that iterating over the
-        # epochs stays aligned with ``epochs.events``; preloaded epochs have
-        # already dropped them, so skip copying their data
-        if not epochs.preload:
-            epochs = epochs.copy().drop_bad()
         event_descriptions = epochs.events[:, 2]
         original_trial_starts = epochs.events[:, 0]
         stop = len(epochs.times) - window_size_samples

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/datasets/tuh.py

@@ -122,8 +122,7 @@ class TUH(BaseConcatDataset):
                 # Assume it is an integer specifying number
                 # of recordings to load
                 recording_ids = range(recording_ids)
-            # select by chronological position, not by (file listing) label
-            descriptions = descriptions.iloc[:, list(recording_ids)]
+            descriptions = descriptions[recording_ids]
 
         # workaround to ensure warnings are suppressed when running in parallel
         def create_dataset(*args, **kwargs):
@@ -242,11 +241,7 @@ class TUH(BaseConcatDataset):
         # file paths, use this instead as before
         if "year" in description:
             meas_date = meas_date.replace(*description[["year", "month", "day"]])
-        # FIF (e.g. preprocess(..., save_dir=...)) stores dates from 1901-12-13 to
-        # 2038-01-19 only: undated recordings (year 1 above) and de-identified ones
-        # (TUAB has 1899-12-30) keep their date in the description only.
-        in_fif_range = -(2**31) <= meas_date.timestamp() < 2**31
-        raw.set_meas_date(meas_date if in_fif_range else None)
+        raw.set_meas_date(meas_date)
 
         d = {
             "age": int(age),
@@ -256,9 +251,9 @@ class TUH(BaseConcatDataset):
         # if not, get it from meas_date in raw.info and add to description
         # if meas_date is None, create fake one
         if "year" not in description:
-            d["year"] = meas_date.year
-            d["month"] = meas_date.month
-            d["day"] = meas_date.day
+            d["year"] = raw.info["meas_date"].year
+            d["month"] = raw.info["meas_date"].month
+            d["day"] = raw.info["meas_date"].day
 
         # read info relevant for preprocessing from raw without loading it
         if add_physician_reports:

{braindecode-1.8.1.dev182039595 → braindecode-1.8.1.dev182199177}/braindecode/datautil/serialization.py

@@ -21,7 +21,6 @@ from ..datasets.base import (
     EEGWindowsDataset,
     RawDataset,
     WindowsDataset,
-    _compact_fif_tags,
 )
 
 
@@ -80,8 +79,7 @@ def _outdated_load_concat_dataset(path, preload, ids_to_load=None, target_name=N
     for path in paths:
         if is_raw and target_name is None:
             target_file_name = path / "target_name.json"
-            with open(target_file_name) as f:
-                target_name = json.load(f)["target_name"]
+            target_name = json.load(open(target_file_name, "r"))["target_name"]
 
         all_signals, description = _load_signals_and_description(
             path=path, preload=preload, is_raw=is_raw, ids_to_load=ids_to_load
@@ -140,19 +138,15 @@ def _load_signals(fif_file, preload, is_raw):
         with open(pkl_file, "rb") as f:
             signals = pickle.load(f)
 
-        # The pickle stores absolute paths: check that they exist and point to
-        # this fif file, not to the folder the dataset was copied from.
-        if all(Path(f).exists() for f in signals.filenames) and (
-            Path(signals.filenames[0]).resolve() == fif_file.resolve()
-        ):
+        if all(Path(f).exists() for f in signals.filenames):
             if preload:
                 signals.load_data()
-            return _compact_fif_tags(signals)
+            return signals
         else:  # This may happen if the file has been moved together with the pickle file.
             warnings.warn(
                 f"Pickle file {pkl_file} exists, but the referenced fif "
-                "file(s) do not exist or are not next to it. Will read the "
-                "fif file(s) directly and re-create the pickle file.",
+                "file(s) do not exist. Will read the fif file(s) directly "
+                "and re-create the pickle file.",
                 UserWarning,
             )
 
@@ -177,8 +171,7 @@ def _load_signals(fif_file, preload, is_raw):
             if preload:
                 signals._data, signals.preload = data, True
 
-    # after the pickle above, which keeps mne's own layout on disk
-    return _compact_fif_tags(signals)
+    return signals
 
 
 def load_concat_dataset(path, preload, ids_to_load=None, target_name=None, n_jobs=1):
@@ -224,10 +217,7 @@ def load_concat_dataset(path, preload, ids_to_load=None, target_name=None, n_job
     # target_name.json, raw_preproc_kwargs.json, window_kwargs.json,
     # window_preproc_kwargs.json
     if ids_to_load is None:
-        # skip stray entries such as .DS_Store or a README next to the datasets
-        ids_to_load = [
-            p.name for p in path.iterdir() if p.is_dir() and p.name.isdigit()
-        ]
+        ids_to_load = [p.name for p in path.iterdir()]
         ids_to_load = sorted(ids_to_load, key=lambda i: int(i))
     ids_to_load = [str(i) for i in ids_to_load]
     first_raw_fif_path = path / ids_to_load[0] / f"{ids_to_load[0]}-raw.fif"
@@ -274,8 +264,7 @@ def _load_parallel(path, i, preload, is_raw, has_stored_windows):
     target_file_path = sub_dir / "target_name.json"
     target_name = None
     if target_file_path.exists():
-        with open(target_file_path) as f:
-            target_name = json.load(f)["target_name"]
+        target_name = json.load(open(target_file_path, "r"))["target_name"]
 
     if is_raw and (not has_stored_windows):
         dataset = RawDataset(signals, description, target_name)
@@ -315,8 +304,8 @@ def _load_kwargs_json(kwargs_name, sub_dir):
     kwargs_file_name = ".".join([kwargs_name, "json"])
     kwargs_file_path = os.path.join(sub_dir, kwargs_file_name)
     if os.path.exists(kwargs_file_path):
-        with open(kwargs_file_path) as f:
-            return json.load(f)
+        kwargs = json.load(open(kwargs_file_path, "r"))
+        return kwargs
 
 
 def _is_outdated_saved(path):