braindecode 0.5.1__py3-none-any.whl

test/unit_tests/datasets/test_dataset.py

@@ -0,0 +1,227 @@
+# Authors: Maciej Sliwowski <maciek.sliwowski@gmail.com>
+#          Lukas Gemein <l.gemein@gmail.com>
+#
+# License: BSD (3-clause)
+
+import mne
+import numpy as np
+import pandas as pd
+import pytest
+
+from braindecode.datasets import WindowsDataset, BaseDataset, BaseConcatDataset
+from braindecode.datasets.moabb import fetch_data_with_moabb
+from braindecode.datautil.windowers import create_windows_from_events
+
+# TODO: split file up into files with proper matching names
+@pytest.fixture(scope="module")
+# TODO: add test for transformers and case when subject_info is used
+def set_up():
+    rng = np.random.RandomState(42)
+    info = mne.create_info(ch_names=['0', '1'], sfreq=50, ch_types='eeg')
+    raw = mne.io.RawArray(data=rng.randn(2, 1000), info=info)
+    desc = pd.Series({'pathological': True, 'gender': 'M', 'age': 48})
+    base_dataset = BaseDataset(raw, desc, target_name='age')
+
+    events = np.array([[100, 0, 1],
+                       [200, 0, 2],
+                       [300, 0, 1],
+                       [400, 0, 4],
+                       [500, 0, 3]])
+    window_idxs = [(0, 0, 100),
+                   (0, 100, 200),
+                   (1, 0, 100),
+                   (2, 0, 100),
+                   (2, 50, 150)]
+    i_window_in_trial, i_start_in_trial, i_stop_in_trial = list(
+        zip(*window_idxs))
+    metadata = pd.DataFrame(
+        {'sample': events[:, 0],
+         'x': events[:, 1],
+         'target': events[:, 2],
+         'i_window_in_trial': i_window_in_trial,
+         'i_start_in_trial': i_start_in_trial,
+         'i_stop_in_trial': i_stop_in_trial})
+
+    mne_epochs = mne.Epochs(raw=raw, events=events, metadata=metadata)
+    windows_dataset = WindowsDataset(mne_epochs, desc)
+
+    return raw, base_dataset, mne_epochs, windows_dataset, events, window_idxs
+
+
+@pytest.fixture(scope="module")
+def concat_ds_targets():
+    raws, description = fetch_data_with_moabb(
+        dataset_name="BNCI2014001", subject_ids=4)
+    events, _ = mne.events_from_annotations(raws[0])
+    targets = events[:, -1] - 1
+    ds = [BaseDataset(raws[i], description.iloc[i]) for i in range(3)]
+    concat_ds = BaseConcatDataset(ds)
+    return concat_ds, targets
+
+
+@pytest.fixture(scope='module')
+def concat_windows_dataset(concat_ds_targets):
+    concat_ds, targets = concat_ds_targets
+    windows_ds = create_windows_from_events(
+        concat_ds=concat_ds, trial_start_offset_samples=0,
+        trial_stop_offset_samples=0, window_size_samples=100,
+        window_stride_samples=100, drop_last_window=False)
+
+    return windows_ds
+
+
+def test_get_item(set_up):
+    _, _, mne_epochs, windows_dataset, events, window_idxs = set_up
+    for i, epoch in enumerate(mne_epochs.get_data()):
+        x, y, inds = windows_dataset[i]
+        np.testing.assert_allclose(epoch, x)
+        assert events[i, 2] == y, f'Y not equal for epoch {i}'
+        np.testing.assert_array_equal(window_idxs[i], inds,
+                                      f'window inds not equal for epoch {i}')
+
+
+def test_len_windows_dataset(set_up):
+    _, _, mne_epochs, windows_dataset, _, _  = set_up
+    assert len(mne_epochs.events) == len(windows_dataset)
+
+
+def test_len_base_dataset(set_up):
+    raw, base_dataset, _, _, _, _ = set_up
+    assert len(raw) == len(base_dataset)
+
+
+def test_len_concat_dataset(concat_ds_targets):
+    concat_ds = concat_ds_targets[0]
+    assert len(concat_ds) == sum([len(c) for c in concat_ds.datasets])
+
+
+def test_target_in_subject_info(set_up):
+    raw, _, _, _, _, _ = set_up
+    desc = pd.Series({'pathological': True, 'gender': 'M', 'age': 48})
+    with pytest.raises(ValueError, match="'does_not_exist' not in description"):
+        BaseDataset(raw, desc, target_name='does_not_exist')
+
+
+def test_description_concat_dataset(concat_ds_targets):
+    concat_ds = concat_ds_targets[0]
+    assert isinstance(concat_ds.description, pd.DataFrame)
+    assert concat_ds.description.shape[0] == len(concat_ds.datasets)
+
+
+def test_split_concat_dataset(concat_ds_targets):
+    concat_ds = concat_ds_targets[0]
+    splits = concat_ds.split('run')
+
+    for k, v in splits.items():
+        assert k == v.description['run'].values
+        assert isinstance(v, BaseConcatDataset)
+
+    assert len(concat_ds) == sum([len(v) for v in splits.values()])
+
+
+def test_concat_concat_dataset(concat_ds_targets):
+    concat_ds, targets = concat_ds_targets
+    concat_ds1 = BaseConcatDataset(concat_ds.datasets[:2])
+    concat_ds2 = BaseConcatDataset(concat_ds.datasets[2:])
+    list_of_concat_ds = [concat_ds1, concat_ds2]
+    descriptions = pd.concat([ds.description for ds in list_of_concat_ds])
+    descriptions.reset_index(inplace=True, drop=True)
+    lens = [0] + [len(ds) for ds in list_of_concat_ds]
+    cumsums = [ds.cumulative_sizes for ds in list_of_concat_ds]
+    cumsums = [l
+               for i, cumsum in enumerate(cumsums)
+               for l in np.array(cumsum) + lens[i]]
+    concat_concat_ds = BaseConcatDataset(list_of_concat_ds)
+    assert len(concat_concat_ds) == sum(lens)
+    assert len(concat_concat_ds) == concat_concat_ds.cumulative_sizes[-1]
+    assert len(concat_concat_ds.datasets) == len(descriptions)
+    assert len(concat_concat_ds.description) == len(descriptions)
+    np.testing.assert_array_equal(cumsums, concat_concat_ds.cumulative_sizes)
+    pd.testing.assert_frame_equal(descriptions, concat_concat_ds.description)
+
+
+def test_split_dataset_failure(concat_ds_targets):
+    concat_ds = concat_ds_targets[0]
+    with pytest.raises(KeyError):
+        concat_ds.split("test")
+
+    with pytest.raises(IndexError):
+        concat_ds.split([])
+
+    with pytest.raises(
+            AssertionError, match="datasets should not be an empty iterable"):
+        concat_ds.split([[]])
+
+    with pytest.raises(TypeError):
+        concat_ds.split([[[]]])
+
+    with pytest.raises(IndexError):
+        concat_ds.split([len(concat_ds.description)])
+
+
+def test_split_dataset(concat_ds_targets):
+    concat_ds = concat_ds_targets[0]
+    splits = concat_ds.split("run")
+    assert len(splits) == len(concat_ds.description["run"].unique())
+
+    splits = concat_ds.split([1])
+    assert len(splits) == 1
+    assert len(splits["0"].datasets) == 1
+
+    splits = concat_ds.split([[2]])
+    assert len(splits) == 1
+    assert len(splits["0"].datasets) == 1
+
+    original_ids = [1, 2]
+    splits = concat_ds.split([[0], original_ids])
+    assert len(splits) == 2
+    assert list(splits["0"].description.index) == [0]
+    assert len(splits["0"].datasets) == 1
+    # when creating new BaseConcatDataset, index is reset
+    split_ids = [0, 1]
+    assert list(splits["1"].description.index) == split_ids
+    assert len(splits["1"].datasets) == 2
+
+    for i, ds in enumerate(splits["1"].datasets):
+        np.testing.assert_array_equal(
+            ds.raw.get_data(), concat_ds.datasets[original_ids[i]].raw.get_data())
+
+
+def test_metadata(concat_windows_dataset):
+    md = concat_windows_dataset.get_metadata()
+    assert isinstance(md, pd.DataFrame)
+    assert all([c in md.columns
+                for c in concat_windows_dataset.description.columns])
+    assert md.shape[0] == len(concat_windows_dataset)
+
+
+def test_no_metadata(concat_ds_targets):
+    with pytest.raises(TypeError, match='Metadata dataframe can only be'):
+        concat_ds_targets[0].get_metadata()
+
+
+def test_on_the_fly_transforms_base_dataset(concat_ds_targets):
+    concat_ds, targets = concat_ds_targets
+    original_X = concat_ds[0][0]
+    factor = 10
+    transform = lambda x: x * factor
+    concat_ds.transform = transform
+    transformed_X = concat_ds[0][0]
+
+    assert (factor * original_X == transformed_X).all()
+
+    with pytest.raises(ValueError):
+        concat_ds.transform = 0
+
+
+def test_on_the_fly_transforms_windows_dataset(concat_windows_dataset):
+    original_X = concat_windows_dataset[0][0]
+    factor = 10
+    transform = lambda x: x * factor
+    concat_windows_dataset.transform = transform
+    transformed_X = concat_windows_dataset[0][0]
+
+    assert (factor * original_X == transformed_X).all()
+
+    with pytest.raises(ValueError):
+        concat_windows_dataset.transform = 0

test/unit_tests/datasets/test_mne.py

@@ -0,0 +1,145 @@
+# Authors: Lukas Gemein <l.gemein@gmail.com>
+#
+# License: BSD-3
+
+
+import numpy as np
+import mne
+
+from braindecode.datautil.mne import  (
+    create_from_mne_raw, create_from_mne_epochs)
+
+def test_create_from_single_raw():
+    n_channels = 50
+    n_times = 500
+    sfreq = 100
+
+    rng = np.random.RandomState(34834)
+    data = rng.rand(n_channels, n_times)
+    ch_names = [f'ch{i}' for i in range(n_channels)]
+    ch_types = ['eeg'] * n_channels
+    info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
+    raw = mne.io.RawArray(data, info)
+
+    n_anns = 10
+    inds = np.linspace(0, n_times, n_anns, endpoint=False).astype(int)
+    onsets = raw.times[inds]
+    durations = np.ones(n_anns) * 0.2
+    descriptions = ['test_trial'] * len(durations)
+    anns = mne.Annotations(onsets, durations, descriptions)
+    raw = raw.set_annotations(anns)
+
+    windows = create_from_mne_raw([raw], 0, 0, 5, 2, False)
+
+    # windows per trial: 0-5,2-7,4-9,6-11,...,14-19,15-20
+    assert len(windows) == 9 * n_anns
+    for i_w, (x, y, (i_w_in_t, i_start, i_stop)) in enumerate(windows):
+        assert i_w_in_t == i_w % 9
+        i_t = i_w // 9
+        assert i_start == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 8)
+        assert i_stop == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 8) + 5
+        np.testing.assert_allclose(x, data[:, i_start:i_stop],
+                                   atol=1e-5, rtol=1e-5)
+
+
+def test_create_from_two_raws_with_varying_trial_lengths():
+    n_channels = 50
+    n_times = 500
+    sfreq = 100
+    rng = np.random.RandomState(34834)
+    raws = []
+    datas = []
+    for i_raw in range(2):
+        data = rng.rand(n_channels, n_times)
+        ch_names = [f'ch{i}' for i in range(n_channels)]
+        ch_types = ['eeg'] * n_channels
+        info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
+        raw = mne.io.RawArray(data, info)
+
+        n_anns = 10
+        inds = np.linspace(0, n_times, n_anns, endpoint=False).astype(int)
+        onsets = raw.times[inds]
+        if i_raw == 0:
+            trial_dur = 0.2  # in sec
+        else:
+            trial_dur = 0.1
+        durations = np.ones(n_anns) * trial_dur
+        descriptions = ['test_trial'] * len(durations)
+        anns = mne.Annotations(onsets, durations, descriptions)
+        raw = raw.set_annotations(anns)
+        raws.append(raw)
+        datas.append(data)
+
+    windows = create_from_mne_raw(raws, 0, 0, 5, 2, False)
+
+    # windows per trial: 0-5,2-7,4-9,6-11,...,14-19,15-20
+    # and then: 0-5,2-7,4-9,5-10
+    assert len(windows) == 9 * n_anns + 4 * n_anns
+    for i_w, (x, y, (i_w_in_t, i_start, i_stop)) in enumerate(windows):
+        if i_w < 9 * n_anns:
+            assert i_w_in_t == i_w % 9
+            i_t = i_w // 9
+            assert i_start == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 8)
+            assert i_stop == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 8) + 5
+            np.testing.assert_allclose(x, datas[0][:, i_start:i_stop],
+                                       atol=1e-5, rtol=1e-5)
+        else:
+            assert i_w_in_t == (i_w - n_anns * 9) % 4
+            i_t = ((i_w - n_anns * 9) // 4)
+            assert i_start == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 3)
+            assert i_stop == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 3) + 5
+
+
+def test_create_from_mne_epochs():
+    n_channels = 50
+    n_times = 500
+    sfreq = 100
+    rng = np.random.RandomState(34834)
+    all_epochs = []
+    datas = []
+    for i_raw in range(2):
+        data = rng.rand(n_channels, n_times)
+        ch_names = [f'ch{i}' for i in range(n_channels)]
+        ch_types = ['eeg'] * n_channels
+        info = mne.create_info(ch_names=ch_names, sfreq=sfreq,
+                               ch_types=ch_types)
+        raw = mne.io.RawArray(data, info)
+
+        n_anns = 10
+        inds = np.linspace(0, n_times, n_anns, endpoint=False).astype(int)
+        onsets = raw.times[inds]
+        if i_raw == 0:
+            trial_dur = 0.2  # in sec
+        else:
+            trial_dur = 0.1
+        durations = np.ones(n_anns) * trial_dur
+        descriptions = ['test_trial'] * len(durations)
+        anns = mne.Annotations(onsets, durations, descriptions)
+        raw = raw.set_annotations(anns)
+        events, event_id = mne.events_from_annotations(raw, )
+        epochs = mne.Epochs(raw, events, event_id=event_id, preload=True,
+                            baseline=None,
+                            tmin=0, tmax=trial_dur - 1e-2)
+        all_epochs.append(epochs)
+        datas.append(data)
+
+    windows = create_from_mne_epochs(all_epochs, window_size_samples=5,
+                                     window_stride_samples=2,
+                                     drop_last_window=False)
+
+    # windows per trial: 0-5,2-7,4-9,6-11,...,14-19,15-20
+    # and then: 0-5,2-7,4-9,5-10
+    assert len(windows) == 9 * n_anns + 4 * n_anns
+    for i_w, (x, y, (i_w_in_t, i_start, i_stop)) in enumerate(windows):
+        if i_w < 9 * n_anns:
+            assert i_w_in_t == i_w % 9
+            i_t = i_w // 9
+            assert i_start == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 8)
+            assert i_stop == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 8) + 5
+            np.testing.assert_allclose(x, datas[0][:, i_start:i_stop],
+                                       atol=1e-5, rtol=1e-5)
+        else:
+            assert i_w_in_t == (i_w - n_anns * 9) % 4
+            i_t = ((i_w - n_anns * 9) // 4)
+            assert i_start == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 3)
+            assert i_stop == inds[i_t] + i_w_in_t * 2 - (i_w_in_t == 3) + 5

test/unit_tests/datasets/test_sleep_physionet.py

@@ -0,0 +1,23 @@
+from braindecode.datasets.sleep_physionet import SleepPhysionet
+from braindecode.datasets.base import BaseConcatDataset
+
+
+def test_sleep_physionet():
+    sp = SleepPhysionet(
+        subject_ids=[0], recording_ids=[1], preload=True, load_eeg_only=True)
+    assert isinstance(sp, BaseConcatDataset)
+
+
+def test_all_signals():
+    sp = SleepPhysionet(
+        subject_ids=[0], recording_ids=[1], preload=True, load_eeg_only=False)
+    assert len(sp.datasets[0].raw.ch_names) == 7
+
+
+def test_crop_wake():
+    sp = SleepPhysionet(
+        subject_ids=[0], recording_ids=[1], preload=True, load_eeg_only=True,
+        crop_wake_mins=30)
+    sfreq = sp.datasets[0].raw.info['sfreq']
+    duration_h = len(sp) / (3600 * sfreq)
+    assert duration_h < 7 and duration_h > 6

test/unit_tests/datasets/test_tuh.py

@@ -0,0 +1,97 @@
+# Authors: Lukas Gemein <l.gemein@gmail.com>
+#
+# License: BSD-3
+
+from braindecode.datasets.tuh import (
+    _parse_description_from_file_path, _create_chronological_description,
+    TUHAbnormal)
+
+
+def test_parse_from_tuh_file_path():
+    file_path = ("v2.0.0/edf/01_tcp_ar/000/00000021/"
+                 "s004_2013_08_15/00000021_s004_t000.edf")
+    description = _parse_description_from_file_path(file_path)
+    assert len(description) == 9
+    assert description['path'] == file_path
+    assert description['year'] == 2013
+    assert description['month'] == 8
+    assert description['day'] == 15
+    assert description['subject'] == 21
+    assert description['session'] == 4
+    assert description['segment'] == 0
+    assert description['reference'] == 'ar'
+    assert description['version'] == 'v2.0.0'
+
+
+def test_parse_from_tuh_abnormal_file_path():
+    file_path = ("v2.0.0/edf/eval/abnormal/01_tcp_ar/107/00010782/"
+                 "s002_2013_10_05/00010782_s002_t001.edf")
+    additional_description = (
+        TUHAbnormal._parse_additional_description_from_file_path(file_path))
+    assert len(additional_description) == 2
+    assert additional_description['pathological']
+    assert not additional_description['train']
+
+    file_path = ("v2.0.0/edf/train/normal/01_tcp_ar/107/00010782/"
+                 "s002_2013_10_05/00010782_s002_t001.edf")
+    additional_description = (
+        TUHAbnormal._parse_additional_description_from_file_path(file_path))
+    assert len(additional_description) == 2
+    assert not additional_description['pathological']
+    assert additional_description['train']
+
+
+def test_sort_chronologically():
+    file_paths = [
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010832/s001_2013_10_03/"
+        "00010831_s002_t001.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000068/s009_2011_09_12/"
+        "00000068_s009_t000.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000016/s004_2012_02_08/"
+        "00000016_s004_t000.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010839/s001_2013_11_22/"
+        "00010839_s001_t000.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000068/s008_2010_09_28/"
+        "00000068_s008_t001.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010832/s001_2013_10_03/"
+        "00010831_s002_t000.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000016/s005_2013_07_12/"
+        "00000016_s005_t001.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010810/s001_2013_10_03/"
+        "00010810_s001_t000.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010831/s001_2013_10_03/"
+        "00010831_s001_t000.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000019/s002_2013_07_18/"
+        "00000019_s002_t001.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010816/s001_2013_10_03/"
+        "00010816_s001_t001.edf",
+    ]
+    description = _create_chronological_description(file_paths)
+    expected = [
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000068/s008_2010_09_28/"
+        "00000068_s008_t001.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000068/s009_2011_09_12/"
+        "00000068_s009_t000.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000016/s004_2012_02_08/"
+        "00000016_s004_t000.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000016/s005_2013_07_12/"
+        "00000016_s005_t001.edf",
+        "v2.0.0/edf/train/abnormal/01_tcp_ar/000/00000019/s002_2013_07_18/"
+        "00000019_s002_t001.edf",
+
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010810/s001_2013_10_03/"
+        "00010810_s001_t000.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010816/s001_2013_10_03/"
+        "00010816_s001_t001.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010831/s001_2013_10_03/"
+        "00010831_s001_t000.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010832/s001_2013_10_03/"
+        "00010831_s002_t000.edf",
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010832/s001_2013_10_03/"
+        "00010831_s002_t001.edf",
+
+        "v2.0.0/edf/train/normal/01_tcp_ar/108/00010839/s001_2013_11_22/"
+        "00010839_s001_t000.edf",
+    ]
+    for p1, p2 in zip(expected, description.T.path):
+        assert p1 == p2

test/unit_tests/datasets/test_xy.py

@@ -0,0 +1,31 @@
+# Authors: Lukas Gemein <l.gemein@gmail.com>
+#
+# License: BSD-3
+
+import numpy as np
+from braindecode.datautil.xy import create_from_X_y
+
+
+def test_crops_data_loader_explicit():
+
+    X = np.arange(0, 15)
+    y = [0]
+
+    n_time_in = 10
+    n_time_out = 4
+
+    expected_crops = [np.arange(0, 10), np.arange(4, 14), np.arange(5, 15)]
+
+    dataset = create_from_X_y(
+        X[None, None], y,
+        window_size_samples=n_time_in,
+        window_stride_samples=n_time_out,
+        drop_last_window=False
+    )
+
+    Xs, ys, i_s = zip(*list(dataset))
+
+    assert len(Xs) == len(ys) == 3
+
+    for actual, expected,  in zip(Xs, expected_crops):
+        np.testing.assert_array_equal(actual.squeeze(), expected)