braindecode 1.8.1.dev177462534__tar.gz → 1.8.1.dev177618751__tar.gz

{braindecode-1.8.1.dev177462534 → braindecode-1.8.1.dev177618751}/NOTICE.txt

@@ -40,6 +40,7 @@ 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`
@@ -54,6 +55,8 @@ 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.dev177462534/braindecode.egg-info → braindecode-1.8.1.dev177618751}/PKG-INFO

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

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

{braindecode-1.8.1.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/augmentation/base.py

@@ -171,7 +171,13 @@ class Compose(Transform):
         self.transforms = transforms
         super().__init__()
 
-    def forward(self, X, y):
+    def forward(self, X, y=None):
+        # like Transform.forward, return only X when no target is given (each
+        # transform then returns a single tensor, not an (X, y) pair)
+        if y is None:
+            for transform in self.transforms:
+                X = transform(X)
+            return X
         for transform in self.transforms:
             X, y = transform(X, y)
         return X, y

{braindecode-1.8.1.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/augmentation/functional.py

@@ -22,6 +22,21 @@ from torch.fft import fft, ifft
 from torch.nn.functional import pad
 
 
+def _max_float_dtype(device: torch.device | str) -> torch.dtype:
+    """float64, or float32 on Apple MPS, which has no float64."""
+    return torch.float32 if torch.device(device).type == "mps" else torch.float64
+
+
+def _to_device(t: torch.Tensor, device: torch.device | str) -> torch.Tensor:
+    """Move ``t`` to ``device``, in single precision on MPS (no float64 there)."""
+    if torch.device(device).type == "mps":
+        if t.dtype == torch.float64:
+            return t.float().to(device)
+        if t.dtype == torch.complex128:
+            return t.to(torch.complex64).to(device)
+    return t.to(device)
+
+
 def identity(X: torch.Tensor, y: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
     """Identity operation.
 
@@ -92,10 +107,11 @@ def _new_random_fft_phase_odd(
     rng = check_random_state(random_state)
     random_phase = torch.from_numpy(
         2j * np.pi * rng.random((batch_size, c, (n - 1) // 2))
-    ).to(device)
+    )
+    random_phase = _to_device(random_phase, device)
     return torch.cat(
         [
-            torch.zeros((batch_size, c, 1), device=device),
+            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
             random_phase,
             -torch.flip(random_phase, [-1]),
         ],
@@ -113,12 +129,13 @@ def _new_random_fft_phase_even(
     rng = check_random_state(random_state)
     random_phase = torch.from_numpy(
         2j * np.pi * rng.random((batch_size, c, n // 2 - 1))
-    ).to(device)
+    )
+    random_phase = _to_device(random_phase, device)
     return torch.cat(
         [
-            torch.zeros((batch_size, c, 1), device=device),
+            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
             random_phase,
-            torch.zeros((batch_size, c, 1), device=device),
+            torch.zeros((batch_size, c, 1), device=device, dtype=random_phase.dtype),
             -torch.flip(random_phase, [-1]),
         ],
         dim=-1,
@@ -178,7 +195,7 @@ def ft_surrogate(
         and 0 <= phase_noise_magnitude <= 1
     ), f"eps must be a float between 0 and 1. Got {phase_noise_magnitude}."
 
-    f = fft(X.double(), dim=-1)
+    f = fft(X.to(_max_float_dtype(X.device)), dim=-1)
     device = X.device
 
     n = f.shape[-1]
@@ -580,6 +597,7 @@ 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)
@@ -911,7 +929,15 @@ def _rotate_signals(
     sensors_positions_matrix: torch.Tensor,
     spherical: bool = True,
 ) -> torch.Tensor:
-    sensors_positions_matrix = sensors_positions_matrix.to(X.device)
+    if X.device.type == "mps":
+        # MPS has no float64: compute the small (n_chans x n_chans) spherical
+        # spline matrices on CPU in double precision, only move the result
+        # (two separate steps: a combined device + dtype .to() from MPS
+        # returns zeros with some torch versions)
+        sensors_positions_matrix = sensors_positions_matrix.cpu().double()
+        rotations = [rotation.cpu().double() for rotation in rotations]
+    else:
+        sensors_positions_matrix = sensors_positions_matrix.to(X.device)
     rot_sensors_matrices = [
         rotation.matmul(sensors_positions_matrix) for rotation in rotations
     ]
@@ -921,9 +947,10 @@ def _rotate_signals(
                 torch.as_tensor(
                     _torch_make_interpolation_matrix(
                         sensors_positions_matrix.T, rot_sensors_matrix.T
-                    ),
-                    device=X.device,
-                ).float()
+                    )
+                )
+                .float()
+                .to(X.device)
                 for rot_sensors_matrix in rot_sensors_matrices
             ]
         )
@@ -1075,6 +1102,54 @@ 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.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/augmentation/transforms.py

@@ -3,6 +3,7 @@
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
 #          Bruna Lopes <brunajaflopes@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
+#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -17,6 +18,7 @@ from braindecode.util import resolve_montage_name
 
 from .base import Transform
 from .functional import (
+    _max_float_dtype,
     amplitude_scale,
     band_rotation,
     bandstop_filter,
@@ -24,6 +26,7 @@ from .functional import (
     channels_permute,
     channels_rereference,
     channels_shuffle,
+    cutmix,
     frequency_shift,
     ft_surrogate,
     gaussian_noise,
@@ -492,6 +495,7 @@ class SmoothTimeMask(Transform):
                 size=X.shape[0],
             ),
             device=X.device,
+            dtype=_max_float_dtype(X.device),
         ) * (seq_length - mask_len_samples)
         return {
             "mask_start_per_sample": mask_start,
@@ -673,7 +677,11 @@ class FrequencyShift(Transform):
             return super().get_augmentation_params(*batch)
         X = batch[0]
 
-        u = torch.as_tensor(self.rng.uniform(size=X.shape[0]), device=X.device)
+        u = torch.as_tensor(
+            self.rng.uniform(size=X.shape[0]),
+            device=X.device,
+            dtype=_max_float_dtype(X.device),
+        )
         max_delta_freq = self.max_delta_freq
         if isinstance(max_delta_freq, torch.Tensor):
             max_delta_freq = max_delta_freq.to(X.device)
@@ -831,7 +839,10 @@ class SensorsRotation(Transform):
         if isinstance(max_degrees, torch.Tensor):
             max_degrees = max_degrees.to(X.device)
         random_angles = (
-            torch.as_tensor(u, device=X.device) * 2 * max_degrees - max_degrees
+            torch.as_tensor(u, device=X.device, dtype=_max_float_dtype(X.device))
+            * 2
+            * max_degrees
+            - max_degrees
         )
         return {
             "sensors_positions_matrix": self.sensors_positions_matrix,
@@ -1095,6 +1106,55 @@ 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]_.
 
@@ -1283,7 +1343,7 @@ class MaskEncoding(Transform):
         )
 
         time_start = self.rng.randint(
-            0, n_times - segment_length, (batch_size, self.n_segments)
+            0, n_times - segment_length + 1, (batch_size, self.n_segments)
         )
         time_start = torch.from_numpy(time_start)
 

{braindecode-1.8.1.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/datasets/base.py

@@ -279,7 +279,7 @@ def _compact_fif_tags(inst):
     return inst
 
 
-def _read_fif_window(raw, start, stop):
+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
@@ -290,6 +290,10 @@ def _read_fif_window(raw, start, stop):
     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)
@@ -316,6 +320,18 @@ def _read_fif_window(raw, start, stop):
     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:
@@ -618,7 +634,9 @@ 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."
                     )
-                    self._description.pop(key)
+                    # 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 = pd.concat([self.description, description])
 
     @property
@@ -1265,6 +1283,49 @@ 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.
@@ -1362,7 +1423,8 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
     def __len__(self):
         return self._ensure_cumulative_sizes()[-1]
 
-    def _get_single_item(self, idx: int):
+    def _locate(self, idx: int):
+        """The dataset that holds item ``idx`` and the item's index in it."""
         if idx < 0:
             if -idx > len(self):
                 raise ValueError(
@@ -1376,7 +1438,33 @@ 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]
+        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]
 
     def __getitem__(self, idx: int | list):
         """
@@ -1475,7 +1563,9 @@ 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.
+            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.
         """
         if not all(
             [
@@ -1501,9 +1591,15 @@ 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 ds in self.datasets:
+        for i_ds, ds in enumerate(self.datasets):
             if hasattr(ds, "_windows") and ds._windows is not None:
                 df = ds._windows.metadata
             else:
@@ -1513,6 +1609,7 @@ 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)
@@ -1805,6 +1902,11 @@ 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)
@@ -1835,7 +1937,9 @@ 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.
+            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.
         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
@@ -1848,6 +1952,13 @@ 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.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/datasets/mne.py

@@ -159,6 +159,11 @@ 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.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/datasets/tuh.py

@@ -122,7 +122,8 @@ class TUH(BaseConcatDataset):
                 # Assume it is an integer specifying number
                 # of recordings to load
                 recording_ids = range(recording_ids)
-            descriptions = descriptions[recording_ids]
+            # select by chronological position, not by (file listing) label
+            descriptions = descriptions.iloc[:, list(recording_ids)]
 
         # workaround to ensure warnings are suppressed when running in parallel
         def create_dataset(*args, **kwargs):

{braindecode-1.8.1.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/datautil/serialization.py

@@ -140,15 +140,19 @@ def _load_signals(fif_file, preload, is_raw):
         with open(pkl_file, "rb") as f:
             signals = pickle.load(f)
 
-        if all(Path(f).exists() for f in signals.filenames):
+        # 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 preload:
                 signals.load_data()
             return _compact_fif_tags(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. Will read the fif file(s) directly "
-                "and re-create the pickle file.",
+                "file(s) do not exist or are not next to it. Will read the "
+                "fif file(s) directly and re-create the pickle file.",
                 UserWarning,
             )
 
@@ -220,7 +224,10 @@ 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:
-        ids_to_load = [p.name for p in path.iterdir()]
+        # 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 = 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"

{braindecode-1.8.1.dev177462534 → braindecode-1.8.1.dev177618751}/braindecode/eegneuralnet.py

@@ -201,12 +201,17 @@ class _EEGNeuralNet(NeuralNet, abc.ABC):
         if classes is None:
             classes = getattr(self, "classes", None)
         signal_kwargs = infer_signal_properties(X, y, mode=self.mode, classes=classes)
+        module = _get_model(self.module)
+        # Model-specific values computed from the data (e.g. GCNsNet's graph);
+        # the signal properties take precedence.
+        infer_model_kwargs = getattr(module, "_infer_model_kwargs", None)
+        if infer_model_kwargs is not None:
+            signal_kwargs = {**infer_model_kwargs(X, y), **signal_kwargs}
         if not signal_kwargs:
             return
 
         # kick out missing kwargs:
         module_kwargs = dict()
-        module = _get_model(self.module)
         all_module_kwargs = inspect.signature(module.__init__).parameters.keys()
         for k, v in signal_kwargs.items():
             if v is None: