Braindecode 1.8.1.dev172419947__tar.gz → 1.8.1.dev172484635__tar.gz

{braindecode-1.8.1.dev172419947 → braindecode-1.8.1.dev172484635}/NOTICE.txt

@@ -13,10 +13,9 @@ The following components are licensed under the Creative Commons Attribution-Non
 
 - `braindecode/models/eegminer.py`
 - `braindecode/models/meta_neuromotor.py`
-- `braindecode/models/sleepfm.py`
 - `braindecode/models/brainmodule.py`
-- `braindecode/models/neurorvq.py`
-- `braindecode/models/neurorvq_tokenizer.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,
@@ -45,32 +44,15 @@ The following components are licensed under the MIT License:
 - `braindecode/models/ifnet.py`
 - `braindecode/models/mirepnet.py`
 - `braindecode/models/popt.py`
-- `braindecode/models/tfm_tokenizer.py`
 - `braindecode/modules/popt_modules.py`
-- `braindecode/models/brainomni.py`
-- `braindecode/modules/quantization.py`
-- `braindecode/modules/linear_attention.py`
-- `braindecode/models/seizure_transformer.py`
-- `docs/_static/model/seizure_transformer_arch.png`
-- `braindecode/models/guetschel2026.py`
-- `braindecode/models/tmsanet.py`
-
-The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
-SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The
-`quantization.py` module holds the residual vector quantization derived from
-`lucidrains/vector-quantize-pytorch` (MIT) and the BrainOmni port.
-The `linear_attention.py` module is the part of
-`lucidrains/linear-attention-transformer` (MIT) that BIOT and TFMTokenizer run.
 
 ### Apache-2.0 Licensed Files
 
 The following components are licensed under the Apache License 2.0:
 
-- `braindecode/models/axon.py`
 - `braindecode/models/mvpformer.py`
 - `braindecode/models/zuna.py`
 - `braindecode/models/luna.py`
-- `braindecode/models/mapa.py`
 - `braindecode/models/brant.py`
 - `braindecode/models/diver1.py`
 - `braindecode/models/mscformer.py`

{braindecode-1.8.1.dev172419947/braindecode.egg-info → braindecode-1.8.1.dev172484635}/PKG-INFO

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

@@ -23,7 +23,6 @@ from .transforms import (
     SignFlip,
     SmoothTimeMask,
     TimeReverse,
-    TrivialAugment,
 )
 
 __all__ = [
@@ -31,7 +30,6 @@ __all__ = [
     "IdentityTransform",
     "Compose",
     "AugmentedDataLoader",
-    "TrivialAugment",
     "TimeReverse",
     "SignFlip",
     "FTSurrogate",

{braindecode-1.8.1.dev172419947 → braindecode-1.8.1.dev172484635}/braindecode/augmentation/functional.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)
 
@@ -932,7 +931,7 @@ def _rotate_signals(
         transformed_X = X.clone()
         sensors_positions = list(sensors_positions_matrix)
         for s, rot_sensors_matrix in enumerate(rot_sensors_matrices):
-            rot_sensors_positions = list(rot_sensors_matrix)
+            rot_sensors_positions = list(rot_sensors_matrix.T)
             for time in range(X.shape[-1]):
                 interpolator_t = Rbf(*sensors_positions, X[s, :, time])
                 transformed_X[s, :, time] = torch.from_numpy(
@@ -1094,8 +1093,7 @@ def segmentation_reconstruction(
     y : torch.Tensor
         EEG labels for the example or batch.
     n_segments : int
-        Number of segments to use in the batch. Any remaining samples are
-        included in the last segment.
+        Number of segments to use in the batch.
     data_classes : list[tuple[int, torch.Tensor]]
         List of tuples. Each tuple contains the class index and the corresponding EEG data.
     rand_indices : array-like
@@ -1135,8 +1133,6 @@ def segmentation_reconstruction(
         for idx_segment in range(n_segments):
             start = idx_segment * segment_size
             end = (idx_segment + 1) * segment_size
-            if idx_segment == n_segments - 1:
-                end = window_size
 
             # Perform the data augmentation
             X_aug[np.arange(n_trials), :, start:end] = X_class[

{braindecode-1.8.1.dev172419947 → braindecode-1.8.1.dev172484635}/braindecode/augmentation/transforms.py

@@ -1457,188 +1457,3 @@ class BandRotation(Transform):
             "circular_jitter": self.circular_jitter,
             "random_state": self.rng,
         }
-
-
-class TrivialAugment(Transform):
-    """Apply one randomly sampled label-preserving augmentation per example.
-
-    For every example, independently samples one transform from the pool
-    below and one of ``num_bins`` strengths evenly spaced between that
-    transform's bounds, as in TrivialAugment [1]_. Examples that draw the
-    same transform and strength are transformed in one call; each pooled
-    transform still draws its own randomness per example.
-
-    Default pool (no assumption on the signal's unit, sampling frequency or
-    montage):
-
-    * :class:`TimeReverse` — no strength parameter.
-    * :class:`SignFlip` — no strength parameter.
-    * :class:`FTSurrogate` — phase noise magnitude, 0.2 to 1.
-    * :class:`ChannelsDropout` — channel drop probability, 0.05 to 0.4.
-    * :class:`ChannelsShuffle` — shuffle probability, 0.1 to 0.75.
-    * :class:`SmoothTimeMask` — mask length as a fraction of the window
-      length, 0.05 to 0.25.
-    * :class:`GaussianNoise` — noise standard deviation as a fraction of the
-      sub-batch standard deviation (volts or microvolts alike), 0.02 to 0.3.
-    * :class:`AmplitudeScale` — scale interval ``(1/s, s)``, ``s`` from 1.25
-      to 2.5.
-
-    ``sfreq`` adds :class:`BandstopFilter` (bandwidth 0.5 to 4 Hz, capped
-    2.5 Hz below Nyquist) and :class:`FrequencyShift` (maximum shift 0.5 to
-    2 Hz); ``sensors_positions_matrix`` adds :class:`SensorsRotation` around
-    the z axis (5 to 25 degrees).
-
-    Parameters
-    ----------
-    probability : float, optional
-        Probability of augmenting each example. Defaults to 1.0.
-    sfreq : float | None, optional
-        Sampling frequency of the signals, in Hz. Defaults to None.
-    sensors_positions_matrix : array-like | None, optional
-        Sensor positions of shape ``(3, n_channels)`` (see
-        :class:`SensorsRotation`). Defaults to None.
-    num_bins : int, optional
-        Number of strength levels per transform. Defaults to 10.
-    random_state : int | numpy.random.RandomState, optional
-        Seed shared by the per-example sampler and every pooled transform.
-        Defaults to None.
-
-    Attributes
-    ----------
-    op_names : list of str
-        Names of the transforms in the pool, in sampling order.
-
-    References
-    ----------
-    .. [1] Müller, S. G., & Hutter, F. (2021). TrivialAugment:
-       Tuning-free Yet State-of-the-Art Data Augmentation. Proceedings of
-       the IEEE/CVF International Conference on Computer Vision (ICCV),
-       pp. 774-782.
-    """
-
-    def __init__(
-        self,
-        probability=1.0,
-        sfreq=None,
-        sensors_positions_matrix=None,
-        num_bins=10,
-        random_state=None,
-    ):
-        super().__init__(probability=probability, random_state=random_state)
-        if not isinstance(num_bins, (int, np.integer)) or num_bins < 1:
-            raise ValueError(f"num_bins must be a positive integer, got {num_bins}")
-        self.num_bins = int(num_bins)
-        rng = self.rng
-        # (name, strength bounds or None, make(strength) or None: built per call)
-        specs = [
-            ("TimeReverse", None, lambda s: TimeReverse(1.0, random_state=rng)),
-            ("SignFlip", None, lambda s: SignFlip(1.0, random_state=rng)),
-            (
-                "FTSurrogate",
-                (0.2, 1.0),
-                lambda s: FTSurrogate(1.0, phase_noise_magnitude=s, random_state=rng),
-            ),
-            (
-                "ChannelsDropout",
-                (0.05, 0.4),
-                lambda s: ChannelsDropout(1.0, p_drop=s, random_state=rng),
-            ),
-            (
-                "ChannelsShuffle",
-                (0.1, 0.75),
-                lambda s: ChannelsShuffle(1.0, p_shuffle=s, random_state=rng),
-            ),
-            ("SmoothTimeMask", (0.05, 0.25), None),
-            ("GaussianNoise", (0.02, 0.3), None),
-            (
-                "AmplitudeScale",
-                (1.25, 2.5),
-                lambda s: AmplitudeScale(1.0, interval=(1.0 / s, s), random_state=rng),
-            ),
-        ]
-        if sfreq is not None:
-            nyquist = sfreq / 2.0
-            # BandstopFilter needs bandwidth < nyquist - 2; keep a margin
-            max_bandwidth = min(4.0, nyquist - 2.5)
-            if max_bandwidth <= 0.5:
-                raise ValueError(
-                    f"sfreq={sfreq} is too small to sample valid band-stop "
-                    "bandwidths (needs at least 6.0 Hz)."
-                )
-            specs += [
-                (
-                    "BandstopFilter",
-                    (0.5, max_bandwidth),
-                    lambda s: BandstopFilter(
-                        1.0,
-                        sfreq=sfreq,
-                        bandwidth=s,
-                        max_freq=nyquist,
-                        random_state=rng,
-                    ),
-                ),
-                (
-                    "FrequencyShift",
-                    (0.5, 2.0),
-                    lambda s: FrequencyShift(
-                        1.0, sfreq=sfreq, max_delta_freq=s, random_state=rng
-                    ),
-                ),
-            ]
-        if sensors_positions_matrix is not None:
-            specs.append(
-                (
-                    "SensorsRotation",
-                    (5.0, 25.0),
-                    lambda s: SensorsRotation(
-                        1.0,
-                        sensors_positions_matrix=sensors_positions_matrix,
-                        max_degrees=s,
-                        random_state=rng,
-                    ),
-                )
-            )
-
-        self._pool = []
-        for name, bounds, make in specs:
-            if bounds is None:
-                strengths = [None]
-            else:
-                strengths = np.linspace(*bounds, self.num_bins).tolist()
-            variants = None if make is None else [make(s) for s in strengths]
-            self._pool.append((name, strengths, variants))
-        # pre-built transforms as submodules (pickle, ``.to()``)
-        self._static_transforms = torch.nn.ModuleList(
-            v for _, _, variants in self._pool if variants for v in variants
-        )
-        self.op_names = [name for name, _, _ in self._pool]
-
-    def operation(self, X, y):
-        """Apply one sampled transform and strength to each example of X."""
-        n_strengths = np.array([len(strengths) for _, strengths, _ in self._pool])
-        op_ids = self.rng.randint(0, len(self._pool), size=X.shape[0])
-        bin_ids = self.rng.randint(0, self.num_bins, size=X.shape[0])
-        # magnitude-free transforms collapse all examples onto bin 0
-        bin_ids[n_strengths[op_ids] == 1] = 0
-        keys = op_ids * self.num_bins + bin_ids
-
-        out_X, out_y = X.clone(), y.clone()
-        for key in np.unique(keys):
-            group = torch.from_numpy(np.flatnonzero(keys == key)).to(X.device)
-            op_i, bin_j = divmod(int(key), self.num_bins)
-            name, strengths, variants = self._pool[op_i]
-            X_sub = X[group]
-            if variants is not None:
-                transform = variants[bin_j]
-            elif name == "SmoothTimeMask":
-                n_mask = max(1, int(round(strengths[bin_j] * X.shape[-1])))
-                transform = SmoothTimeMask(
-                    1.0, mask_len_samples=n_mask, random_state=self.rng
-                )
-            else:  # GaussianNoise, std relative to the sub-batch (unit-free)
-                std = strengths[bin_j] * X_sub.std().item()
-                transform = GaussianNoise(1.0, std=std, random_state=self.rng)
-            tr_X, tr_y = transform(X_sub, y[group])
-            out_X[group] = tr_X.to(out_X.dtype)
-            out_y[group] = tr_y
-        return out_X, out_y

{braindecode-1.8.1.dev172419947 → braindecode-1.8.1.dev172484635}/braindecode/classifier.py

@@ -212,12 +212,11 @@ class EEGClassifier(_EEGNeuralNet, NeuralNetClassifier):
             the number of predictions depend on the chosen window size and the
             receptive field of the network. If trials have different lengths,
             a list with one (n_classes x n_predictions) array per trial.
-        trial_targets : np.ndarray | list of np.ndarray
-            Ground-truth targets from the dataset. Only returned when
-            ``return_targets=True``. An ``np.ndarray`` with a leading trial
-            dimension: ``(n_trials,)`` for scalar targets, with further
-            dimensions for multi-value or equal-length sequence targets. If
-            trial lengths differ, a list with one target array per trial.
+        trial_targets : np.ndarray
+            Ground-truth targets from the dataset in a 2-dimensional array
+            (n_trials x n_targets). Only returned when ``return_targets=True``.
+            The number of targets depends on the decoding paradigm and can be
+            either a single value, multiple values, or a sequence.
         """
         if not self.cropped:
             warnings.warn(

{braindecode-1.8.1.dev172419947 → braindecode-1.8.1.dev172484635}/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.
 
@@ -946,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)
@@ -1378,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(
@@ -1393,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):
         """
@@ -1824,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:
@@ -1895,10 +1742,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
         # Create path if it doesn't exist
         os.makedirs(path, exist_ok=True)
 
-        # With an offset the caller fills one directory piece by piece (preprocess
-        # saves each recording at its index), so the other entries are expected:
-        # skip the scan that would stat them all on every call and list them in a warning.
-        path_contents = os.listdir(path) if offset == 0 else []
+        path_contents = os.listdir(path)
         n_sub_dirs = len(
             [e for e in path_contents if os.path.isdir(os.path.join(path, e))]
         )

{braindecode-1.8.1.dev172419947 → braindecode-1.8.1.dev172484635}/braindecode/datasets/tuh.py

@@ -11,12 +11,10 @@ TUH Abnormal EEG Corpus.
 from __future__ import annotations
 
 import glob
-import json
 import os
 import re
 import warnings
 from datetime import datetime, timezone
-from functools import cache
 from pathlib import Path
 from typing import Iterable, Literal
 from unittest import mock
@@ -185,8 +183,11 @@ class TUH(BaseConcatDataset):
         }
         raw.rename_channels(mapping_strip)
 
+        montage1005 = mne.channels.make_standard_montage(
+            resolve_montage_name("standard_1005")
+        )
         mapping_eeg_names = {
-            c.upper(): c for c in _standard_1005().ch_names if c.upper() in raw.ch_names
+            c.upper(): c for c in montage1005.ch_names if c.upper() in raw.ch_names
         }
 
         # Set channels whose type could not be inferred (defaulted to "eeg") to "misc":
@@ -209,7 +210,10 @@ class TUH(BaseConcatDataset):
 
     @staticmethod
     def _set_montage(raw):
-        raw.set_montage(_standard_1005(), on_missing="ignore")
+        montage = mne.channels.make_standard_montage(
+            resolve_montage_name("standard_1005")
+        )
+        raw.set_montage(montage, on_missing="ignore")
 
     @staticmethod
     def _create_dataset(
@@ -241,11 +245,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),
@@ -255,9 +255,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:
@@ -269,12 +269,6 @@ class TUH(BaseConcatDataset):
         return base_dataset
 
 
-@cache
-def _standard_1005():
-    # Built once per process: set_montage copies the montage before using it.
-    return mne.channels.make_standard_montage(resolve_montage_name("standard_1005"))
-
-
 def _create_description(file_paths, version, ds_name):
     descriptions = [
         _parse_description_from_file_path(f, version, ds_name) for f in file_paths
@@ -295,8 +289,7 @@ def _read_date(file_path):
     date_path = file_path.replace(".edf", "_date.txt")
     # if date file exists, read it
     if os.path.exists(date_path):
-        with open(date_path) as f:
-            description = json.load(f)
+        description = pd.read_json(date_path, typ="series").to_dict()
     # otherwise read edf file, extract date and store to file
     else:
         raw = mne.io.read_raw_edf(file_path, preload=False, verbose="error")