braindecode 0.8.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

braindecode/datasets/bbci.py

@@ -2,6 +2,8 @@
 #
 # License: BSD (3-clause)
 
+from __future__ import annotations
+
 import logging
 import os.path
 import re
@@ -16,7 +18,8 @@ log = logging.getLogger(__name__)
 
 
 class BBCIDataset(object):
-    """
+    """BBCIDataset.
+
     Loader class for files created by saving BBCI files in matlab (make
     sure to save with '-v7.3' in matlab, see
     https://de.mathworks.com/help/matlab/import_export/mat-file-versions.html#buk6i87
@@ -34,12 +37,14 @@ class BBCIDataset(object):
     """
 
     def __init__(
-        self, filename, load_sensor_names=None, check_class_names=False
+        self,
+        filename: str,
+        load_sensor_names: list[str] | None = None,
+        check_class_names: bool = False,
     ):
         self.__dict__.update(locals())
-        del self.self
 
-    def load(self):
+    def load(self) -> mne.io.RawArray:
         cnt = self._load_continuous_signal()
         cnt = self._add_markers(cnt)
         return cnt
@@ -50,9 +55,7 @@ class BBCIDataset(object):
         with h5py.File(self.filename, "r") as h5file:
             samples = int(h5file["nfo"]["T"][0, 0])
             cnt_signal_shape = (samples, len(wanted_chan_inds))
-            continuous_signal = (
-                np.ones(cnt_signal_shape, dtype=np.float32) * np.nan
-            )
+            continuous_signal = np.ones(cnt_signal_shape, dtype=np.float32) * np.nan
             for chan_ind_arr, chan_ind_set in enumerate(wanted_chan_inds):
                 # + 1 because matlab/this hdf5-naming logic
                 # has 1-based indexing
@@ -63,9 +66,7 @@ class BBCIDataset(object):
                     :
                 ].squeeze()  # already load into memory
                 continuous_signal[:, chan_ind_arr] = chan_signal
-            assert not np.any(
-                np.isnan(continuous_signal)
-            ), "No NaNs expected in signal"
+            assert not np.any(np.isnan(continuous_signal)), "No NaNs expected in signal"
 
         if self.load_sensor_names is None:
             ch_types = ["eeg"] * len(wanted_chan_inds)
@@ -83,15 +84,12 @@ class BBCIDataset(object):
     def _determine_sensors(self):
         all_sensor_names = self.get_all_sensors(self.filename, pattern=None)
         if self.load_sensor_names is None:
-
             # if no sensor names given, take all EEG-chans
             eeg_sensor_names = all_sensor_names
             eeg_sensor_names = filter(
                 lambda s: not s.startswith("BIP"), eeg_sensor_names
             )
-            eeg_sensor_names = filter(
-                lambda s: not s.startswith("E"), eeg_sensor_names
-            )
+            eeg_sensor_names = filter(lambda s: not s.startswith("E"), eeg_sensor_names)
             eeg_sensor_names = filter(
                 lambda s: not s.startswith("Microphone"), eeg_sensor_names
             )
@@ -103,17 +101,15 @@ class BBCIDataset(object):
             )
             eeg_sensor_names = list(eeg_sensor_names)
             assert (
-                len(eeg_sensor_names) == 128 or
-                len(eeg_sensor_names) == 64 or
-                len(eeg_sensor_names) == 32 or
-                len(eeg_sensor_names) == 16
+                len(eeg_sensor_names) == 128
+                or len(eeg_sensor_names) == 64
+                or len(eeg_sensor_names) == 32
+                or len(eeg_sensor_names) == 16
             ), "Recheck this code if you have different sensors..."
             wanted_sensor_names = eeg_sensor_names
         else:
             wanted_sensor_names = self.load_sensor_names
-        chan_inds = self._determine_chan_inds(
-            all_sensor_names, wanted_sensor_names
-        )
+        chan_inds = self._determine_chan_inds(all_sensor_names, wanted_sensor_names)
         return chan_inds, wanted_sensor_names
 
     def _determine_samplingrate(self):
@@ -127,16 +123,12 @@ class BBCIDataset(object):
     def _determine_chan_inds(all_sensor_names, sensor_names):
         assert sensor_names is not None
         chan_inds = [all_sensor_names.index(s) for s in sensor_names]
-        assert len(chan_inds) == len(sensor_names), (
-            "All" "sensors should be there."
-        )
-        assert len(set(chan_inds)) == len(chan_inds), (
-            "No duplicated sensors wanted."
-        )
+        assert len(chan_inds) == len(sensor_names), "Allsensors should be there."
+        assert len(set(chan_inds)) == len(chan_inds), "No duplicated sensors wanted."
         return chan_inds
 
     @staticmethod
-    def get_all_sensors(filename, pattern=None):
+    def get_all_sensors(filename: str, pattern: str | None = None) -> list[str]:
         """
         Get all sensors that exist in the given file.
 
@@ -157,17 +149,15 @@ class BBCIDataset(object):
                 "".join(chr(c.item()) for c in h5file[obj_ref]) for obj_ref in clab_set
             ]
             if pattern is not None:
-                all_sensor_names = filter(
-                    lambda sname: re.search(pattern, sname), all_sensor_names
+                all_sensor_names = list(
+                    filter(lambda sname: re.search(pattern, sname), all_sensor_names)
                 )
         return all_sensor_names
 
     def _add_markers(self, cnt):
         with h5py.File(self.filename, "r") as h5file:
             event_times_in_ms = h5file["mrk"]["time"][:].squeeze()
-            event_classes = (
-                h5file["mrk"]["event"]["desc"][:].squeeze().astype(np.int64)
-            )
+            event_classes = h5file["mrk"]["event"]["desc"][:].squeeze().astype(np.int64)
 
             # Check whether class names known and correct order
             class_name_set = h5file["nfo"]["className"][:].squeeze()
@@ -177,9 +167,7 @@ class BBCIDataset(object):
             ]
 
             if self.check_class_names:
-                _check_class_names(
-                    all_class_names, event_times_in_ms, event_classes
-                )
+                _check_class_names(all_class_names, event_times_in_ms, event_classes)
 
         event_times_in_samples = event_times_in_ms * cnt.info["sfreq"] / 1000.0
         event_times_in_samples = np.uint32(np.round(event_times_in_samples))
@@ -196,8 +184,8 @@ class BBCIDataset(object):
                         i_sample,
                         event_classes[i_event - 1],
                         event_classes[i_event],
-                    ) +
-                    "Marker codes will be summed."
+                    )
+                    + "Marker codes will be summed."
                 )
             previous_i_sample = i_sample
 
@@ -222,7 +210,7 @@ class BBCIDataset(object):
         # Hacky way to try to find out class names for each event
         # h5file['mrk']['y'] y contains one-hot label for event name
         with h5py.File(self.filename, "r") as h5file:
-            y = h5file['mrk']['y'][:]
+            y = h5file["mrk"]["y"][:]
             # seems that there are cases where for last class
             # y is just all zero for some reason?
             # and seems then it is last of the class names
@@ -233,7 +221,7 @@ class BBCIDataset(object):
             event_i_classes = np.argmax(y, axis=1)
 
         # 4 second trials for High-Gamma dataset, otherwise how to know?
-        if all_class_names == ['Right Hand', 'Left Hand', 'Rest', 'Feet']:
+        if all_class_names == ["Right Hand", "Left Hand", "Rest", "Feet"]:
             durations = np.full(event_times_in_ms.shape, 4)
         else:
             warnings.warn("Unknown event durations set to 0")
@@ -265,8 +253,8 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
         pass
     elif (
         (
-            all_class_names ==
-            [
+            all_class_names
+            == [
                 "1",
                 "10",
                 "11",
@@ -285,9 +273,10 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
                 "44",
                 "99",
             ]
-        ) or (
-            all_class_names ==
-            [
+        )
+        or (
+            all_class_names
+            == [
                 "1",
                 "10",
                 "11",
@@ -305,8 +294,8 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
                 "44",
                 "99",
             ]
-        ) or (
-            all_class_names == ["1", "2", "3", "4"])
+        )
+        or (all_class_names == ["1", "2", "3", "4"])
     ):
         pass  # Semantic classes
     elif all_class_names == ["Rest", "Feet", "Left Hand", "Right Hand"]:
@@ -668,7 +657,9 @@ def _check_class_names(all_class_names, event_times_in_ms, event_classes):
         log.warn("Unknown class names {:s}".format(all_class_names))
 
 
-def load_bbci_sets_from_folder(folder, runs="all"):
+def load_bbci_sets_from_folder(
+    folder: str, runs: list[int] | str = "all"
+) -> list[mne.io.RawArray]:
     """
     Load bbci datasets from files in given folder.
 
@@ -687,10 +678,10 @@ def load_bbci_sets_from_folder(folder, runs="all"):
     """
     bbci_mat_files = sorted(glob(os.path.join(folder, "*.BBCI.mat")))
     if runs != "all":
-        file_run_numbers = [
-            int(re.search("S[0-9]{3,3}R[0-9]{2,2}_", f).group()[5:7])
-            for f in bbci_mat_files
-        ]
+        assert isinstance(runs, list), "runs should be list[int] or 'all'"
+        matches = [re.search("S[0-9]{3,3}R[0-9]{2,2}_", f) for f in bbci_mat_files]
+        file_run_numbers = [int(m.group()[5:7]) for m in matches if m is not None]
+        assert len(file_run_numbers) == len(bbci_mat_files), "Some files don't match"
         indices = [file_run_numbers.index(num) for num in runs]
 
         wanted_files = np.array(bbci_mat_files)[indices]

braindecode/datasets/bcicomp.py

@@ -3,6 +3,8 @@
 #
 # License: BSD (3-clause)
 
+from __future__ import annotations
+
 import glob
 import os
 import os.path as osp
@@ -14,10 +16,12 @@ import numpy as np
 from mne.utils import verbose
 from scipy.io import loadmat
 
-from braindecode.datasets import BaseDataset, BaseConcatDataset
+from braindecode.datasets import BaseConcatDataset, BaseDataset
 
-DATASET_URL = 'https://stacks.stanford.edu/file/druid:zk881ps0522/' \
-              'BCI_Competion4_dataset4_data_fingerflexions.zip'
+DATASET_URL = (
+    "https://stacks.stanford.edu/file/druid:zk881ps0522/"
+    "BCI_Competion4_dataset4_data_fingerflexions.zip"
+)
 
 
 class BCICompetitionIVDataset4(BaseConcatDataset):
@@ -42,30 +46,32 @@ class BCICompetitionIVDataset4(BaseConcatDataset):
     References
     ----------
     .. [1] Miller, Kai J. "A library of human electrocorticographic data and analyses."
-    Nature human behaviour 3, no. 11 (2019): 1225-1235. https://doi.org/10.1038/s41562-019-0678-3
+       Nature human behaviour 3, no. 11 (2019): 1225-1235.
+       https://doi.org/10.1038/s41562-019-0678-3
     """
+
     possible_subjects = [1, 2, 3]
 
-    def __init__(self, subject_ids=None):
+    def __init__(self, subject_ids: list[int] | int | None = None):
         data_path = self.download()
         if isinstance(subject_ids, int):
             subject_ids = [subject_ids]
         if subject_ids is None:
             subject_ids = self.possible_subjects
         self._validate_subjects(subject_ids)
-        files_list = [f'{data_path}/sub{i}_comp.mat' for i in subject_ids]
+        files_list = [f"{data_path}/sub{i}_comp.mat" for i in subject_ids]
         datasets = []
         for file_path in files_list:
             raw_train, raw_test = self._load_data_to_mne(file_path)
             desc_train = dict(
-                subject=file_path.split('/')[-1].split('sub')[1][0],
-                file_name=file_path.split('/')[-1],
-                session='train'
+                subject=file_path.split("/")[-1].split("sub")[1][0],
+                file_name=file_path.split("/")[-1],
+                session="train",
             )
             desc_test = dict(
-                subject=file_path.split('/')[-1].split('sub')[1][0],
-                file_name=file_path.split('/')[-1],
-                session='test'
+                subject=file_path.split("/")[-1].split("sub")[1][0],
+                file_name=file_path.split("/")[-1],
+                session="test",
             )
             datasets.append(BaseDataset(raw_train, description=desc_train))
             datasets.append(BaseDataset(raw_test, description=desc_test))
@@ -90,20 +96,24 @@ class BCICompetitionIVDataset4(BaseConcatDataset):
         -------
 
         """
-        signature = 'BCICompetitionIVDataset4'
-        folder_name = 'BCI_Competion4_dataset4_data_fingerflexions'
+        signature = "BCICompetitionIVDataset4"
+        folder_name = "BCI_Competion4_dataset4_data_fingerflexions"
         # Check if the dataset already exists (unpacked). We have to do that manually
         # because we are removing .zip file from disk to save disk space.
 
         from moabb.datasets.download import get_dataset_path  # keep soft dependency
+
         path = get_dataset_path(signature, path)
         key_dest = "MNE-{:s}-data".format(signature.lower())
         # We do not use mne _url_to_local_path due to ':' in the url that causes problems on Windows
         destination = osp.join(path, key_dest, folder_name)
-        if len(list(glob.glob(osp.join(destination, '*.mat')))) == 6:
+        if len(list(glob.glob(osp.join(destination, "*.mat")))) == 6:
             return destination
-        data_path = _data_dl(DATASET_URL, osp.join(destination, folder_name, signature),
-                             force_update=force_update)
+        data_path = _data_dl(
+            DATASET_URL,
+            osp.join(destination, folder_name, signature),
+            force_update=force_update,
+        )
         unpack_archive(data_path, osp.dirname(destination))
         # removes .zip file that the data was unpacked from
         remove(data_path)
@@ -117,26 +127,30 @@ class BCICompetitionIVDataset4(BaseConcatDataset):
 
     def _load_data_to_mne(self, file_path):
         data = loadmat(file_path)
-        test_labels = loadmat(file_path.replace('comp.mat', 'testlabels.mat'))
-        train_data = data['train_data']
-        test_data = data['test_data']
-        upsampled_train_targets = data['train_dg']
-        upsampled_test_targets = test_labels['test_dg']
+        test_labels = loadmat(file_path.replace("comp.mat", "testlabels.mat"))
+        train_data = data["train_data"]
+        test_data = data["test_data"]
+        upsampled_train_targets = data["train_dg"]
+        upsampled_test_targets = test_labels["test_dg"]
 
         signal_sfreq = 1000
         original_target_sfreq = 25
         targets_stride = int(signal_sfreq / original_target_sfreq)
 
-        original_targets = self._prepare_targets(upsampled_train_targets, targets_stride)
-        original_test_targets = self._prepare_targets(upsampled_test_targets, targets_stride)
+        original_targets = self._prepare_targets(
+            upsampled_train_targets, targets_stride
+        )
+        original_test_targets = self._prepare_targets(
+            upsampled_test_targets, targets_stride
+        )
 
-        ch_names = [f'{i}' for i in range(train_data.shape[1])]
-        ch_names += [f'target_{i}' for i in range(original_targets.shape[1])]
-        ch_types = ['ecog' for _ in range(train_data.shape[1])]
-        ch_types += ['misc' for _ in range(original_targets.shape[1])]
+        ch_names = [f"{i}" for i in range(train_data.shape[1])]
+        ch_names += [f"target_{i}" for i in range(original_targets.shape[1])]
+        ch_types = ["ecog" for _ in range(train_data.shape[1])]
+        ch_types += ["misc" for _ in range(original_targets.shape[1])]
 
         info = mne.create_info(sfreq=signal_sfreq, ch_names=ch_names, ch_types=ch_types)
-        info['temp'] = dict(target_sfreq=original_target_sfreq)
+        info["temp"] = dict(target_sfreq=original_target_sfreq)
         train_data = np.concatenate([train_data, original_targets], axis=1)
         test_data = np.concatenate([test_data, original_test_targets], axis=1)
 
@@ -149,12 +163,12 @@ class BCICompetitionIVDataset4(BaseConcatDataset):
         if isinstance(subject_ids, (list, tuple)):
             if not all((subject in self.possible_subjects for subject in subject_ids)):
                 raise ValueError(
-                    f'Wrong subject_ids parameter. Possible values: {self.possible_subjects}. '
-                    f'Provided {subject_ids}.'
+                    f"Wrong subject_ids parameter. Possible values: {self.possible_subjects}. "
+                    f"Provided {subject_ids}."
                 )
         else:
             raise ValueError(
-                'Wrong subject_ids format. Expected types: None, list, tuple, int.'
+                "Wrong subject_ids format. Expected types: None, list, tuple, int."
             )
 
 
@@ -165,6 +179,7 @@ def _data_dl(url, destination, force_update=False, verbose=None):
     # moabb/datasets/download.py
 
     from pooch import file_hash, retrieve  # keep soft dependency
+
     if not osp.isfile(destination) or force_update:
         if osp.isfile(destination):
             os.remove(destination)

braindecode/datasets/bids.py

@@ -0,0 +1,245 @@
+"""Dataset for loading BIDS.
+
+More information on BIDS (Brain Imaging Data Structure) can be found at https://bids.neuroimaging.io
+"""
+
+# Authors: Pierre Guetschel <pierre.guetschel@gmail.com>
+#
+# License: BSD (3-clause)
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import mne
+import mne_bids
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed
+
+from .base import BaseConcatDataset, BaseDataset, WindowsDataset
+
+
+def _description_from_bids_path(bids_path: mne_bids.BIDSPath) -> dict[str, Any]:
+    return {
+        "path": bids_path.fpath,
+        "subject": bids_path.subject,
+        "session": bids_path.session,
+        "task": bids_path.task,
+        "acquisition": bids_path.acquisition,
+        "run": bids_path.run,
+        "processing": bids_path.processing,
+        "recording": bids_path.recording,
+        "space": bids_path.space,
+        "split": bids_path.split,
+        "description": bids_path.description,
+        "suffix": bids_path.suffix,
+        "extension": bids_path.extension,
+        "datatype": bids_path.datatype,
+    }
+
+
+@dataclass
+class BIDSDataset(BaseConcatDataset):
+    """Dataset for loading BIDS.
+
+    This class has the same parameters as the :func:`mne_bids.find_matching_paths` function
+    as it will be used to find the files to load. The default ``extensions`` parameter was changed.
+
+    More information on BIDS (Brain Imaging Data Structure)
+    can be found at https://bids.neuroimaging.io
+
+    .. Note::
+        For loading "unofficial" BIDS datasets containing epoched data,
+        you can use :class:`BIDSEpochsDataset`.
+
+    Parameters
+    ----------
+    root : pathlib.Path | str
+        The root of the BIDS path.
+    subjects : str | array-like of str | None
+        The subject ID. Corresponds to "sub".
+    sessions : str | array-like of str | None
+        The acquisition session. Corresponds to "ses".
+    tasks : str | array-like of str | None
+        The experimental task. Corresponds to "task".
+    acquisitions: str | array-like of str | None
+        The acquisition parameters. Corresponds to "acq".
+    runs : str | array-like of str | None
+        The run number. Corresponds to "run".
+    processings : str | array-like of str | None
+        The processing label. Corresponds to "proc".
+    recordings : str | array-like of str | None
+        The recording name. Corresponds to "rec".
+    spaces : str | array-like of str | None
+        The coordinate space for anatomical and sensor location
+        files (e.g., ``*_electrodes.tsv``, ``*_markers.mrk``).
+        Corresponds to "space".
+        Note that valid values for ``space`` must come from a list
+        of BIDS keywords as described in the BIDS specification.
+    splits : str | array-like of str | None
+        The split of the continuous recording file for ``.fif`` data.
+        Corresponds to "split".
+    descriptions : str | array-like of str | None
+        This corresponds to the BIDS entity ``desc``. It is used to provide
+        additional information for derivative data, e.g., preprocessed data
+        may be assigned ``description='cleaned'``.
+    suffixes : str | array-like of str | None
+        The filename suffix. This is the entity after the
+        last ``_`` before the extension. E.g., ``'channels'``.
+        The following filename suffix's are accepted:
+        'meg', 'markers', 'eeg', 'ieeg', 'T1w',
+        'participants', 'scans', 'electrodes', 'coordsystem',
+        'channels', 'events', 'headshape', 'digitizer',
+        'beh', 'physio', 'stim'
+    extensions : str | array-like of str | None
+        The extension of the filename. E.g., ``'.json'``.
+        By default, uses the ones accepted by :func:`mne_bids.read_raw_bids`.
+    datatypes : str | array-like of str | None
+        The BIDS data type, e.g., ``'anat'``, ``'func'``, ``'eeg'``, ``'meg'``,
+        ``'ieeg'``.
+    check : bool
+        If ``True``, only returns paths that conform to BIDS. If ``False``
+        (default), the ``.check`` attribute of the returned
+        :class:`mne_bids.BIDSPath` object will be set to ``True`` for paths that
+        do conform to BIDS, and to ``False`` for those that don't.
+    preload : bool
+        If True, preload the data. Defaults to False.
+    n_jobs : int
+        Number of jobs to run in parallel. Defaults to 1.
+    """
+
+    root: Path | str
+    subjects: str | list[str] | None = None
+    sessions: str | list[str] | None = None
+    tasks: str | list[str] | None = None
+    acquisitions: str | list[str] | None = None
+    runs: str | list[str] | None = None
+    processings: str | list[str] | None = None
+    recordings: str | list[str] | None = None
+    spaces: str | list[str] | None = None
+    splits: str | list[str] | None = None
+    descriptions: str | list[str] | None = None
+    suffixes: str | list[str] | None = None
+    extensions: str | list[str] | None = field(
+        default_factory=lambda: [
+            ".con",
+            ".sqd",
+            ".pdf",
+            ".fif",
+            ".ds",
+            ".vhdr",
+            ".set",
+            ".edf",
+            ".bdf",
+            ".EDF",
+            ".snirf",
+            ".cdt",
+            ".mef",
+            ".nwb",
+        ]
+    )
+    datatypes: str | list[str] | None = None
+    check: bool = False
+    preload: bool = False
+    n_jobs: int = 1
+
+    @property
+    def _filter_out_epochs(self):
+        return True
+
+    def __post_init__(self):
+        bids_paths = mne_bids.find_matching_paths(
+            root=self.root,
+            subjects=self.subjects,
+            sessions=self.sessions,
+            tasks=self.tasks,
+            acquisitions=self.acquisitions,
+            runs=self.runs,
+            processings=self.processings,
+            recordings=self.recordings,
+            spaces=self.spaces,
+            splits=self.splits,
+            descriptions=self.descriptions,
+            suffixes=self.suffixes,
+            extensions=self.extensions,
+            datatypes=self.datatypes,
+            check=self.check,
+        )
+        # Filter out .json files files:
+        # (argument ignore_json only available in mne-bids>=0.16)
+        bids_paths = [
+            bids_path for bids_path in bids_paths if bids_path.extension != ".json"
+        ]
+        # Filter out _epo.fif files:
+        if self._filter_out_epochs:
+            bids_paths = [
+                bids_path
+                for bids_path in bids_paths
+                if not (bids_path.suffix == "epo" and bids_path.extension == ".fif")
+            ]
+
+        all_base_ds = Parallel(n_jobs=self.n_jobs)(
+            delayed(self._get_dataset)(bids_path) for bids_path in bids_paths
+        )
+        super().__init__(all_base_ds)
+
+    def _get_dataset(self, bids_path: mne_bids.BIDSPath) -> BaseDataset:
+        description = _description_from_bids_path(bids_path)
+        raw = mne_bids.read_raw_bids(bids_path, verbose=False)
+        if self.preload:
+            raw.load_data()
+        return BaseDataset(raw, description)
+
+
+class BIDSEpochsDataset(BIDSDataset):
+    """**Experimental** dataset for loading :class:`mne.Epochs` organised in BIDS.
+
+    The files must end with ``_epo.fif``.
+
+    .. Warning::
+        Epoched data is not officially supported in BIDS.
+
+    .. Note::
+        **Parameters:** This class has the same parameters as :class:`BIDSDataset` except
+        for arguments ``datatypes``, ``extensions`` and ``check`` which are fixed.
+    """
+
+    @property
+    def _filter_out_epochs(self):
+        return False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            extensions=".fif",
+            suffixes="epo",
+            check=False,
+            **kwargs,
+        )
+
+    def _set_metadata(self, epochs: mne.BaseEpochs) -> None:
+        # events = mne.events_from_annotations(epochs
+        n_times = epochs.times.shape[0]
+        # id_event = {v: k for k, v in epochs.event_id.items()}
+        annotations = epochs.annotations
+        if annotations is not None:
+            target = annotations.description
+        else:
+            id_events = {v: k for k, v in epochs.event_id.items()}
+            target = [id_events[event_id] for event_id in epochs.events[:, -1]]
+        metadata_dict = {
+            "i_window_in_trial": np.zeros(len(epochs)),
+            "i_start_in_trial": np.zeros(len(epochs)),
+            "i_stop_in_trial": np.zeros(len(epochs)) + n_times,
+            "target": target,
+        }
+        epochs.metadata = pd.DataFrame(metadata_dict)
+
+    def _get_dataset(self, bids_path):
+        description = _description_from_bids_path(bids_path)
+        epochs = mne.read_epochs(bids_path.fpath)
+        self._set_metadata(epochs)
+        return WindowsDataset(epochs, description=description, targets_from="metadata")