def test_no_raw_or_epochs():
class EmptyDataset(object):
def __init__(self):
self.datasets = [1, 2, 3]
ds = EmptyDataset()
with pytest.raises(AssertionError):
transform_concat_ds(ds, ["dummy", "dummy"])
def test_scale_windows(windows_concat_ds):
factor = 1e6
transforms = [
('pick_types', dict(eeg=True, meg=False, stim=False)),
(scale, dict(factor=factor))
]
raw_window = windows_concat_ds[0][0]
transform_concat_ds(windows_concat_ds, transforms)
expected = np.ones_like(raw_window) * factor
np.testing.assert_allclose(windows_concat_ds[0][0] / raw_window, expected,
rtol=1e-4, atol=1e-4)
def test_scale_continuous(base_concat_ds):
factor = 1e6
transforms = [
('pick_types', dict(eeg=True, meg=False, stim=False)),
('apply_function', dict(fun=scale, factor=factor))
]
raw_timepoint = base_concat_ds[0][0]
transform_concat_ds(base_concat_ds, transforms)
expected = np.ones_like(raw_timepoint) * factor
np.testing.assert_allclose(base_concat_ds[0][0] / raw_timepoint, expected,
rtol=1e-4, atol=1e-4)
def test_zscore_windows(windows_concat_ds):
transforms = [
('pick_types', dict(eeg=True, meg=False, stim=False)),
(zscore, dict())
]
transform_concat_ds(windows_concat_ds, transforms)
for ds in windows_concat_ds.datasets:
windowed_data = ds.windows.get_data()
shape = windowed_data.shape
# zero mean
expected = np.zeros(shape[:-1])
np.testing.assert_allclose(
windowed_data.mean(axis=-1), expected, rtol=1e-4, atol=1e-4)
# unit variance
expected = np.ones(shape[:-1])
np.testing.assert_allclose(
windowed_data.std(axis=-1), expected, rtol=1e-4, atol=1e-4)
def test_zscore_continuous(base_concat_ds):
transforms = [
('pick_types', dict(eeg=True, meg=False, stim=False)),
('apply_function', dict(fun=zscore, channel_wise=True))
]
transform_concat_ds(base_concat_ds, transforms)
for ds in base_concat_ds.datasets:
raw_data = ds.raw.get_data()
shape = raw_data.shape
# zero mean
expected = np.zeros(shape[:-1])
np.testing.assert_allclose(
raw_data.mean(axis=-1), expected, rtol=1e-4, atol=1e-4)
# unit variance
expected = np.ones(shape[:-1])
np.testing.assert_allclose(
raw_data.std(axis=-1), expected, rtol=1e-4, atol=1e-4)
def test_transform_windows_method(windows_concat_ds):
transforms = [("filter", {"l_freq": 7, "h_freq": 13})]
raw_window = windows_concat_ds[0][0]
transform_concat_ds(windows_concat_ds, transforms)
assert not np.array_equal(raw_window, windows_concat_ds[0][0])
def test_transform_base_method(base_concat_ds):
transforms = [("resample", {"sfreq": 50})]
transform_concat_ds(base_concat_ds, transforms)
assert base_concat_ds.datasets[0].raw.info['sfreq'] == 50
def test_method_not_available(base_concat_ds):
transforms = [('this_method_is_not_real', {'indeed': None})]
with pytest.raises(AttributeError):
transform_concat_ds(base_concat_ds, transforms)
def test_not_list():
with pytest.raises(AssertionError):
transform_concat_ds(None, {'test': 1})
##############################################################################
# We can apply preprocessing transforms that are defined in mne and work
# in-place, such as resampling, bandpass filtering, or electrode selection.
transform_list = [
("pick_types", {
"eeg": True,
"meg": False,
"stim": True
}),
("resample", {
"sfreq": 100
}),
]
print(ds.datasets[0].raw.info["sfreq"])
transform_concat_ds(ds, transform_list)
print(ds.datasets[0].raw.info["sfreq"])
###############################################################################
# We can easily split ds based on a criteria applied to the description
# DataFrame:
subsets = ds.split("session")
print({subset_name: len(subset) for subset_name, subset in subsets.items()})
###############################################################################
# Next, we use a windower to extract events from the dataset based on events:
windows_ds = create_windows_from_events(ds,
trial_start_offset_samples=0,
trial_stop_offset_samples=100,
supercrop_size_samples=400,
supercrop_stride_samples=100,
if cuda:
model.cuda()
dataset = MOABBDataset(dataset_name="BNCI2014001", subject_ids=[subject_id])
standardize_func = partial(exponential_running_standardize,
factor_new=factor_new,
init_block_size=init_block_size)
raw_transform_dict = [
("pick_types", dict(eeg=True, meg=False, stim=False)),
('apply_function', dict(fun=lambda x: x * 1e6, channel_wise=False)),
('filter', dict(l_freq=low_cut_hz, h_freq=high_cut_hz)),
('apply_function', dict(fun=standardize_func, channel_wise=False))
]
transform_concat_ds(dataset, raw_transform_dict)
sfreqs = [ds.raw.info['sfreq'] for ds in dataset.datasets]
assert len(np.unique(sfreqs)) == 1
trial_start_offset_samples = int(trial_start_offset_seconds * sfreqs[0])
windows_dataset = create_windows_from_events(
dataset,
trial_start_offset_samples=trial_start_offset_samples,
trial_stop_offset_samples=0,
supercrop_size_samples=input_time_length,
supercrop_stride_samples=input_time_length,
drop_samples=False,
preload=True,
)
