def test_filterbank(base_concat_ds): base_concat_ds = base_concat_ds.split([[0]])['0'] preprocessors = [ Preprocessor('pick_channels', ch_names=sorted(['C4', 'Cz']), ordered=True), Preprocessor(filterbank, frequency_bands=[(0, 4), (4, 8), (8, 13)], drop_original_signals=False, apply_on_array=False) ] preprocess(base_concat_ds, preprocessors) for x, y in base_concat_ds: break assert x.shape[0] == 8 freq_band_annots = [ ch.split('_')[-1] for ch in base_concat_ds.datasets[0].raw.ch_names if '_' in ch ] assert len(np.unique(freq_band_annots)) == 3 np.testing.assert_array_equal(base_concat_ds.datasets[0].raw.ch_names, [ 'C4', 'C4_0-4', 'C4_4-8', 'C4_8-13', 'Cz', 'Cz_0-4', 'Cz_4-8', 'Cz_8-13', ])
def bcic4_2a(subject, low_hz=None, high_hz=None, paradigm=None, phase=False): X = [] y = [] if isinstance(subject, int): subject = [subject] for subject_id in subject: # Load data print_off() dataset = MOABBDataset(dataset_name="BNCI2014001", subject_ids=[subject_id]) # Preprocess factor_new = 1e-3 init_block_size = 1000 preprocessors = [ # keep only EEG sensors MNEPreproc(fn='pick_types', eeg=True, meg=False, stim=False), # convert from volt to microvolt NumpyPreproc(fn=lambda x: x * 1e+06), # bandpass filter MNEPreproc(fn='filter', l_freq=low_hz, h_freq=high_hz), # exponential moving standardization NumpyPreproc(fn=exponential_moving_standardize, factor_new=factor_new, init_block_size=init_block_size) ] preprocess(dataset, preprocessors) # Divide data by trial # - Check sampling frequency sfreq = dataset.datasets[0].raw.info['sfreq'] assert all([ds.raw.info['sfreq'] == sfreq for ds in dataset.datasets]) trial_start_offset_seconds = -0.5 trial_start_offset_samples = int(trial_start_offset_seconds * sfreq) windows_dataset = create_windows_from_events( dataset, trial_start_offset_samples=trial_start_offset_samples, trial_stop_offset_samples=0, preload=True # verbose=True ) # If you need split data, try this. if paradigm == 'session': if phase == "train": windows_dataset = windows_dataset.split('session')['session_T'] else: windows_dataset = windows_dataset.split('session')['session_E'] # Merge subject for trial in windows_dataset: X.append(trial[0]) y.append(trial[1]) print_on() return np.array(X), np.array(y)
def test_filterbank(base_concat_ds): base_concat_ds = base_concat_ds.split([[0]])["0"] preprocessors = [ MNEPreproc('pick_channels', ch_names=sorted(["C4", "Cz"]), ordered=True), MNEPreproc(filterbank, frequency_bands=[(0, 4), (4, 8), (8, 13)], drop_original_signals=False), ] preprocess(base_concat_ds, preprocessors) for x, y in base_concat_ds: break assert x.shape[0] == 8 freq_band_annots = [ ch.split("_")[-1] for ch in base_concat_ds.datasets[0].raw.ch_names if '_' in ch ] assert len(np.unique(freq_band_annots)) == 3 np.testing.assert_array_equal(base_concat_ds.datasets[0].raw.ch_names, [ "C4", "C4_0-4", "C4_4-8", "C4_8-13", "Cz", "Cz_0-4", "Cz_4-8", "Cz_8-13", ])
def test_windows_fixed_length_cropped(lazy_loadable_dataset): """Test fixed length windowing on cropped data. Cropping raw data changes the `first_samp` attribute of the Raw object, and so it is important to test this is taken into account by the windowers. """ tmin, tmax = 100, 120 ds = copy.deepcopy(lazy_loadable_dataset) ds.datasets[0].raw.annotations.crop(tmin, tmax) crop_ds = copy.deepcopy(lazy_loadable_dataset) crop_transform = Preprocessor('crop', tmin=tmin, tmax=tmax) preprocess(crop_ds, [crop_transform]) # Extract windows sfreq = ds.datasets[0].raw.info['sfreq'] tmin_samples, tmax_samples = int(tmin * sfreq), int(tmax * sfreq) windows1 = create_fixed_length_windows( concat_ds=ds, start_offset_samples=tmin_samples, stop_offset_samples=tmax_samples, window_size_samples=100, window_stride_samples=100, drop_last_window=True) windows2 = create_fixed_length_windows( concat_ds=crop_ds, start_offset_samples=0, stop_offset_samples=None, window_size_samples=100, window_stride_samples=100, drop_last_window=True) assert (windows1[0][0] == windows2[0][0]).all()
def test_no_raw_or_epochs(): class EmptyDataset(object): def __init__(self): self.datasets = [1, 2, 3] ds = EmptyDataset() with pytest.raises(AssertionError): preprocess(ds, ["dummy", "dummy"])
def bandpass_window_BaseConcat(dataset, bandpass_range=(4, 38), window_start_offset=1.0, window_end_offset=-0.5): ''' For bandpass filtering and windowing to return in BaseConcatDataset form. :param dataset: :param bandpass_range: :param window_start_offset: :param window_end_offset: :return: ''' low_cut_hz = bandpass_range[0] high_cut_hz = bandpass_range[1] factor_new = 1e-3 init_block_size = 1000 preprocessors = [ # keep only EEG sensors MNEPreproc(fn='pick_types', eeg=True, meg=False, stim=False), # convert from volt to microvolt, directly modifying the numpy array NumpyPreproc(fn=lambda x: x * 1e6), # bandpass filter MNEPreproc(fn='filter', l_freq=low_cut_hz, h_freq=high_cut_hz), # exponential moving standardization NumpyPreproc(fn=exponential_moving_standardize, factor_new=factor_new, init_block_size=init_block_size) ] # Transform the data ds_copy = copy.deepcopy(dataset) preprocess(ds_copy, preprocessors) trial_start_offset_seconds = window_start_offset trial_stop_offset_seconds = window_end_offset # Extract sampling frequency, check that they are same in all datasets sfreq = ds_copy.datasets[0].raw.info['sfreq'] assert all( [ds_subj.raw.info['sfreq'] == sfreq for ds_subj in ds_copy.datasets]) # Calculate the trial start offset in samples. trial_start_offset_samples = int(trial_start_offset_seconds * sfreq) trial_stop_offset_samples = int(trial_stop_offset_seconds * sfreq) # Create windows using braindecode function for this. It needs parameters to define how # trials should be used. windows_dataset = create_windows_from_events( ds_copy, trial_start_offset_samples=trial_start_offset_samples, trial_stop_offset_samples=trial_stop_offset_samples, preload=True, ) return windows_dataset
def test_scale_windows(windows_concat_ds): factor = 1e6 preprocessors = [ MNEPreproc('pick_types', eeg=True, meg=False, stim=False), MNEPreproc(scale, factor=factor) ] raw_window = windows_concat_ds[0][0] preprocess(windows_concat_ds, preprocessors) 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 load_train_test_hgd(subject_id): hgd_names = [ 'Fp2', 'Fp1', 'F4', 'F3', 'C4', 'C3', 'P4', 'P3', 'O2', 'O1', 'F8', 'F7', 'T8', 'T7', 'P8', 'P7', 'M2', 'M1', 'Fz', 'Cz', 'Pz' ] log.info("Loading dataset..") # using the moabb dataset to load our data dataset = MOABBDataset(dataset_name="Schirrmeister2017", subject_ids=[subject_id]) sfreq = 32 train_whole_set = dataset.split('run')['train'] log.info("Preprocessing dataset..") # Define preprocessing steps preprocessors = [ # convert from volt to microvolt, directly modifying the numpy array MNEPreproc( fn='set_eeg_reference', ref_channels='average', ), MNEPreproc(fn='pick_channels', ch_names=hgd_names, ordered=True), NumpyPreproc(fn=lambda x: x * 1e6), NumpyPreproc(fn=lambda x: np.clip(x, -800, 800)), NumpyPreproc(fn=lambda x: x / 10), MNEPreproc(fn='resample', sfreq=sfreq), NumpyPreproc(fn=lambda x: np.clip(x, -80, 80)), NumpyPreproc(fn=lambda x: x / 3), NumpyPreproc(fn=exponential_moving_demean, init_block_size=int(sfreq * 10), factor_new=1 / (sfreq * 5)), # keep only EEG sensors # NumpyPreproc(fn=exponential_moving_demean, init_block_size=sfreq*10, factor_new=1/(sfreq*5)), ] # Preprocess the data preprocess(train_whole_set, preprocessors) # Next, extract the 4-second trials from the dataset. # Create windows using braindecode function for this. It needs parameters to define how # trials should be used. class_names = ['Right Hand', 'Rest'] # for later plotting class_mapping = {'right_hand': 0, 'rest': 1} windows_dataset = create_windows_from_events( train_whole_set, trial_start_offset_samples=0, trial_stop_offset_samples=0, preload=True, mapping=class_mapping, ) from torch.utils.data import Subset n_split = int(np.round(0.75 * len(windows_dataset))) valid_set = Subset(windows_dataset, range(n_split, len(windows_dataset))) train_set = Subset(windows_dataset, range(0, n_split)) return train_set, valid_set
def test_scale_continuous(base_concat_ds): factor = 1e6 preprocessors = [ MNEPreproc('pick_types', eeg=True, meg=False, stim=False), NumpyPreproc(scale, factor=factor) ] raw_timepoint = base_concat_ds[0][0] preprocess(base_concat_ds, preprocessors) 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_scale_continuous(base_concat_ds): factor = 1e6 preprocessors = [ Preprocessor('pick_types', eeg=True, meg=False, stim=False), Preprocessor(scale, factor=factor) ] raw_timepoint = base_concat_ds[0][0][:22] # only keep EEG channels preprocess(base_concat_ds, preprocessors) np.testing.assert_allclose(base_concat_ds[0][0], raw_timepoint * factor, rtol=1e-4, atol=1e-4)
def test_scale_windows(windows_concat_ds): factor = 1e6 preprocessors = [ Preprocessor('pick_types', eeg=True, meg=False, stim=False), Preprocessor(scale, factor=factor) ] raw_window = windows_concat_ds[0][0][:22] # only keep EEG channels preprocess(windows_concat_ds, preprocessors) np.testing.assert_allclose(windows_concat_ds[0][0], raw_window * factor, rtol=1e-4, atol=1e-4)
def test_preprocess_windows_callable_on_object(windows_concat_ds): factor = 10 preprocessors = [ Preprocessor(modify_windows_object, apply_on_array=False, factor=factor) ] raw_window = windows_concat_ds[0][0] preprocess(windows_concat_ds, preprocessors) np.testing.assert_allclose(windows_concat_ds[0][0], raw_window * factor, rtol=1e-4, atol=1e-4)
def load_train_valid_tuh(n_subjects, n_seconds, ids_to_load): path = '/home/schirrmr/data/preproced-tuh/all-sensors-32-hz/' log.info("Load concat dataset...") dataset = load_concat_dataset(path, preload=False, ids_to_load=ids_to_load) whole_train_set = dataset.split('session')['train'] n_max_minutes = int(np.ceil(n_seconds / 60) + 2) sfreq = whole_train_set.datasets[0].raw.info['sfreq'] log.info("Preprocess concat dataset...") preprocess(whole_train_set, [ MNEPreproc('crop', tmin=0, tmax=n_max_minutes * 60, include_tmax=True), NumpyPreproc(fn=lambda x: np.clip(x, -80, 80)), NumpyPreproc(fn=lambda x: x / 3), NumpyPreproc(fn=exponential_moving_demean, init_block_size=int(sfreq * 10), factor_new=1 / (sfreq * 5)), ]) subject_datasets = whole_train_set.split('subject') n_split = int(np.round(n_subjects * 0.75)) keys = list(subject_datasets.keys()) train_sets = [ d for i in range(n_split) for d in subject_datasets[keys[i]].datasets ] train_set = BaseConcatDataset(train_sets) valid_sets = [ d for i in range(n_split, n_subjects) for d in subject_datasets[keys[i]].datasets ] valid_set = BaseConcatDataset(valid_sets) train_set = create_fixed_length_windows( train_set, start_offset_samples=60 * 32, stop_offset_samples=60 * 32 + 32 * n_seconds, preload=True, window_size_samples=128, window_stride_samples=64, drop_last_window=True, ) valid_set = create_fixed_length_windows( valid_set, start_offset_samples=60 * 32, stop_offset_samples=60 * 32 + 32 * n_seconds, preload=True, window_size_samples=128, window_stride_samples=64, drop_last_window=True, ) return train_set, valid_set
def test_filterbank_order_channels_by_freq(base_concat_ds): base_concat_ds = base_concat_ds.split([[0]])["0"] preprocessors = [ MNEPreproc('pick_channels', ch_names=sorted(["C4", "Cz"]), ordered=True), MNEPreproc(filterbank, frequency_bands=[(0, 4), (4, 8), (8, 13)], drop_original_signals=False, order_by_frequency_band=True), ] preprocess(base_concat_ds, preprocessors) np.testing.assert_array_equal(base_concat_ds.datasets[0].raw.ch_names, [ "C4", "Cz", "C4_0-4", "Cz_0-4", "C4_4-8", "Cz_4-8", "C4_8-13", "Cz_8-13" ])
def test_windows_from_events_cropped(lazy_loadable_dataset): """Test windowing from events on cropped data. Cropping raw data changes the `first_samp` attribute of the Raw object, and so it is important to test this is taken into account by the windowers. """ tmin, tmax = 100, 120 ds = copy.deepcopy(lazy_loadable_dataset) ds.datasets[0].raw.annotations.crop(tmin, tmax) crop_ds = copy.deepcopy(lazy_loadable_dataset) crop_transform = MNEPreproc('crop', tmin=tmin, tmax=tmax) preprocess(crop_ds, [crop_transform]) # Extract windows windows1 = create_windows_from_events(concat_ds=ds, trial_start_offset_samples=0, trial_stop_offset_samples=0, window_size_samples=100, window_stride_samples=100, drop_last_window=False) windows2 = create_windows_from_events(concat_ds=crop_ds, trial_start_offset_samples=0, trial_stop_offset_samples=0, window_size_samples=100, window_stride_samples=100, drop_last_window=False) assert (windows1[0][0] == windows2[0][0]).all() # Make sure events that fall outside of recording will trigger an error with pytest.raises(ValueError, match='"trial_stop_offset_samples" too large'): create_windows_from_events(concat_ds=ds, trial_start_offset_samples=0, trial_stop_offset_samples=10000, window_size_samples=100, window_stride_samples=100, drop_last_window=False) with pytest.raises(ValueError, match='"trial_stop_offset_samples" too large'): create_windows_from_events(concat_ds=crop_ds, trial_start_offset_samples=0, trial_stop_offset_samples=2001, window_size_samples=100, window_stride_samples=100, drop_last_window=False)
def test_filterbank_order_channels_by_freq(base_concat_ds): base_concat_ds = base_concat_ds.split([[0]])['0'] preprocessors = [ Preprocessor('pick_channels', ch_names=sorted(['C4', 'Cz']), ordered=True), Preprocessor(filterbank, frequency_bands=[(0, 4), (4, 8), (8, 13)], drop_original_signals=False, order_by_frequency_band=True, apply_on_array=False) ] preprocess(base_concat_ds, preprocessors) np.testing.assert_array_equal(base_concat_ds.datasets[0].raw.ch_names, [ 'C4', 'Cz', 'C4_0-4', 'Cz_0-4', 'C4_4-8', 'Cz_4-8', 'C4_8-13', 'Cz_8-13' ])
def test_deprecated_preprocs(base_concat_ds): msg1 = 'MNEPreproc is deprecated. Use Preprocessor with ' \ '`apply_on_array=False` instead.' msg2 = 'NumpyPreproc is deprecated. Use Preprocessor with ' \ '`apply_on_array=True` instead.' with pytest.warns(UserWarning, match=msg1): mne_preproc = MNEPreproc('pick_types', eeg=True, meg=False, stim=False) factor = 1e6 with pytest.warns(UserWarning, match=msg2): np_preproc = NumpyPreproc(scale, factor=factor) raw_timepoint = base_concat_ds[0][0][:22] # only keep EEG channels preprocess(base_concat_ds, [mne_preproc, np_preproc]) np.testing.assert_allclose(base_concat_ds[0][0], raw_timepoint * factor, rtol=1e-4, atol=1e-4)
def test_zscore_windows(windows_concat_ds): preprocessors = [ MNEPreproc('pick_types', eeg=True, meg=False, stim=False), MNEPreproc(zscore, ) ] preprocess(windows_concat_ds, preprocessors) 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): preprocessors = [ MNEPreproc('pick_types', eeg=True, meg=False, stim=False), MNEPreproc('apply_function', fun=zscore, channel_wise=True) ] preprocess(base_concat_ds, preprocessors) 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 get_sleep_physionet(subject_ids=range(83), recording_ids=[1, 2]): bug_subjects = [13, 36, 39, 48, 52, 59, 65, 68, 69, 73, 75, 76, 78, 79] subject_ids = [id_ for id_ in subject_ids if id_ not in bug_subjects] dataset = SleepPhysionet(subject_ids=subject_ids, recording_ids=recording_ids, crop_wake_mins=30) high_cut_hz = 30 preprocessors = [ # convert from volt to microvolt, directly modifying the numpy array NumpyPreproc(fn=lambda x: x * 1e6), # bandpass filter MNEPreproc(fn='filter', l_freq=None, h_freq=high_cut_hz), ] # Transform the data preprocess(dataset, preprocessors) mapping = { # We merge stages 3 and 4 following AASM standards. 'Sleep stage W': 0, 'Sleep stage 1': 1, 'Sleep stage 2': 2, 'Sleep stage 3': 3, 'Sleep stage 4': 3, 'Sleep stage R': 4 } window_size_s = 30 sfreq = 100 window_size_samples = window_size_s * sfreq windows_dataset = create_windows_from_events( dataset, trial_start_offset_samples=0, trial_stop_offset_samples=0, window_size_samples=window_size_samples, window_stride_samples=window_size_samples, preload=True, mapping=mapping) preprocess(windows_dataset, [MNEPreproc(fn=zscore)]) info = pd.read_excel('SC-subjects.xls') return windows_dataset, info
def build_epoch(subjects, recording, crop_wake_mins, preprocessing, train=True): dataset = SleepPhysionet(subject_ids=subjects, recording_ids=recording, crop_wake_mins=crop_wake_mins) if preprocessing: preprocessors = [] if "microvolt_scaling" in preprocessing: preprocessors.append(NumpyPreproc(fn=lambda x: x * 1e6)) if "filtering" in preprocessing: high_cut_hz = 30 preprocessors.append( MNEPreproc(fn='filter', l_freq=None, h_freq=high_cut_hz)) # Transform the data preprocess(dataset, preprocessors) mapping = { # We merge stages 3 and 4 following AASM standards. 'Sleep stage W': 0, 'Sleep stage 1': 1, 'Sleep stage 2': 2, 'Sleep stage 3': 3, 'Sleep stage 4': 3, 'Sleep stage R': 4 } window_size_s = 30 sfreq = 100 window_size_samples = window_size_s * sfreq windows_dataset = create_windows_from_events( dataset, trial_start_offset_samples=0, trial_stop_offset_samples=0, window_size_samples=window_size_samples, window_stride_samples=window_size_samples, preload=True, mapping=mapping) return windows_dataset
def preprocess_data(dataset, low_cut_hz=4, high_cut_hz=38, factor_new=1e-3, init_block_size=1000): preprocessors = [ # keep only EEG sensors MNEPreproc(fn='pick_types', eeg=True, meg=False, stim=False), # convert from volt to microvolt, directly modifying the numpy array NumpyPreproc(fn=lambda x: x * 1e6), # bandpass filter MNEPreproc(fn='filter', l_freq=low_cut_hz, h_freq=high_cut_hz), # exponential moving standardization NumpyPreproc(fn=exponential_moving_standardize, factor_new=factor_new, init_block_size=init_block_size) ] # Transform the data preprocess(dataset, preprocessors) return dataset
def our_preprocess(dataset): low_cut_hz = 4. # low cut frequency for filtering high_cut_hz = 38. # high cut frequency for filtering # Parameters for exponential moving standardization factor_new = 1e-3 init_block_size = 1000 preprocessors = [ # keep only EEG sensors MNEPreproc(fn='pick_types', eeg=True, meg=False, stim=False), # convert from volt to microvolt, directly modifying the numpy array NumpyPreproc(fn=lambda x: x * 1e6), # bandpass filter MNEPreproc(fn='filter', l_freq=low_cut_hz, h_freq=high_cut_hz), # exponential moving standardization NumpyPreproc(fn=exponential_moving_standardize, factor_new=factor_new, init_block_size=init_block_size) ] # Transform the data preprocess(dataset, preprocessors)
from braindecode.datautil.serialization import load_concat_dataset from braindecode.datautil.windowers import create_windows_from_events ############################################################################### # First, we load some dataset using MOABB. ds = MOABBDataset( dataset_name='BNCI2014001', subject_ids=[1], ) ############################################################################### # We can apply preprocessing steps to the dataset. It is also possible to skip # this step and not apply any preprocessing. preprocess( concat_ds=ds, preprocessors=[MNEPreproc(fn='resample', sfreq=10)] ) ############################################################################### # We save the dataset to a an existing directory. It will create a '.fif' file # for every dataset in the concat dataset. Additionally it will create two # JSON files, the first holding the description of the dataset, the second # holding the name of the target. If you want to store to the same directory # several times, for example due to trying different preprocessing, you can # choose to overwrite the existing files. ds.save( path='./', overwrite=False, ) ##############################################################################
def train(subject_id): print('\n--------------------------------------------------\n') print( 'Training on BCI_IV_2a dataset | Cross-subject | ID: {:02d}\n'.format( subject_id)) ##### subject_range = [subject_id] subject_range = [x for x in range(1, 10)] dataset = MOABBDataset(dataset_name="BNCI2014001", subject_ids=subject_range) ###################################################################### # Preprocessing low_cut_hz = 4. # low cut frequency for filtering high_cut_hz = 38. # high cut frequency for filtering # Parameters for exponential moving standardization factor_new = 1e-3 init_block_size = 1000 preprocessors = [ Preprocessor('pick_types', eeg=True, eog=False, meg=False, stim=False), # Keep EEG sensors Preprocessor(lambda x: x * 1e6), # Convert from V to uV Preprocessor('filter', l_freq=low_cut_hz, h_freq=high_cut_hz), # Bandpass filter #Preprocessor('set_eeg_reference', ref_channels='average', ch_type='eeg'), Preprocessor('resample', sfreq=125), Preprocessor(covariance_align), ## Preprocessor(exponential_moving_standardize, # Exponential moving standardization ## factor_new=factor_new, init_block_size=init_block_size) ## Preprocessor('pick_channels', ch_names=short_ch_names, ordered=True), ] # Transform the data print('Preprocessing dataset\n') preprocess(dataset, preprocessors) ###################################################################### # Cut Compute Windows # ~~~~~~~~~~~~~~~~~~~ trial_start_offset_seconds = -0.5 trial_stop_offset_seconds = 0.0 # Extract sampling frequency, check that they are same in all datasets sfreq = dataset.datasets[0].raw.info['sfreq'] assert all([ds.raw.info['sfreq'] == sfreq for ds in dataset.datasets]) # Calculate the trial start offset in samples. trial_start_offset_samples = int(trial_start_offset_seconds * sfreq) trial_stop_offset_samples = int(trial_stop_offset_seconds * sfreq) # Create windows using braindecode function for this. It needs parameters to define how # trials should be used. print('Windowing dataset\n') windows_dataset = create_windows_from_events( dataset, # picks=["Fz", "FC3", "FC1", "FCz", "FC2", "FC4", "C5", "C3", "C1", "Cz", "C2", "C4", "C6", "CP3", "CP1", "CPz", "CP2", "CP4", "P1", "Pz", "P2", "POz"], trial_start_offset_samples=trial_start_offset_samples, trial_stop_offset_samples=trial_stop_offset_samples, preload=True, ) print('Computing covariances of each WindowsDataset') windows_dataset.compute_covariances_concat() # print(windows_dataset.datasets[0].windows) ###################################################################### # Merge multiple datasets into a single WindowDataset # metadata_all = [ds.windows.metadata for ds in windows_dataset.datasets] # metadata_full = pd.concat(metadata_all) """ epochs_all = [ds.windows for ds in windows_dataset.datasets] epochs_full = mne.concatenate_epochs(epochs_all) full_dataset = WindowsDataset(windows=epochs_full, description=None, transform=None) windows_dataset = full_dataset """ ###################################################################### # Split dataset into train and valid # keep only session 1: # temp = windows_dataset.split( 'session' ) # windows_dataset = temp['session_T'] # print(windows_dataset.datasets[0].windows) # print(windows_dataset.datasets[0].windows.get_data().shape) # quit() subject_column = windows_dataset.description['subject'].values inds_train = list(np.where(subject_column != subject_id)[0]) inds_valid = list(np.where(subject_column == subject_id)[0]) splitted = windows_dataset.split([inds_train, inds_valid]) train_set = splitted['0'] valid_set = splitted['1'] ####### epochs_all = [ds.windows for ds in train_set.datasets] epochs_full = mne.concatenate_epochs(epochs_all) trialwise_weights_all = [ds.trialwise_weights for ds in train_set.datasets] trialwise_weights_full = np.hstack(trialwise_weights_all) full_dataset = WindowsDataset(windows=epochs_full, description=None, transform=None) full_dataset.trialwise_weights = trialwise_weights_full train_set = full_dataset # print(train_set.windows.metadata) ###################################################################### # Create model cuda = torch.cuda.is_available( ) # check if GPU is available, if True chooses to use it device = 'cuda' if cuda else 'cpu' if cuda: torch.backends.cudnn.benchmark = True seed = 20200220 # random seed to make results reproducible # Set random seed to be able to reproduce results set_random_seeds(seed=seed, cuda=cuda) n_classes = 4 # Extract number of chans and time steps from dataset n_chans = train_set[0][0].shape[0] input_window_samples = train_set[0][0].shape[1] """ model = ShallowFBCSPNet( n_chans, n_classes, input_window_samples=input_window_samples, final_conv_length='auto') """ """ model = EEGNetv1( n_chans, n_classes, input_window_samples=input_window_samples, final_conv_length="auto", pool_mode="mean", second_kernel_size=(2, 32), third_kernel_size=(8, 4), drop_prob=0.25) """ """ model = HybridNet(n_chans, n_classes, input_window_samples=input_window_samples) """ """ model = TCN(n_chans, n_classes, n_blocks=6, n_filters=32, kernel_size=9, drop_prob=0.0, add_log_softmax=True) """ model = EEGNetv4( n_chans, n_classes, input_window_samples=input_window_samples, final_conv_length="auto", pool_mode="mean", F1=8, D=2, F2=16, # usually set to F1*D (?) kernel_length=64, third_kernel_size=(8, 4), drop_prob=0.2) if cuda: model.cuda() ###################################################################### # Training # These values we found good for shallow network: lr = 0.01 # 0.0625 * 0.01 weight_decay = 0.0005 # For deep4 they should be: # lr = 1 * 0.01 # weight_decay = 0.5 * 0.001 batch_size = 64 n_epochs = 100 # clf = EEGClassifier( clf = EEGClassifier_weighted( model, criterion=torch.nn.NLLLoss, optimizer=torch.optim.SGD, #AdamW, train_split=predefined_split( valid_set), # using valid_set for validation optimizer__lr=lr, optimizer__momentum=0.9, optimizer__weight_decay=weight_decay, batch_size=batch_size, callbacks=[ "accuracy", #("lr_scheduler", LRScheduler('CosineAnnealingLR', T_max=n_epochs - 1)), ], device=device, ) # Model training for a specified number of epochs. `y` is None as it is already supplied # in the dataset. clf.fit(train_set, y=None, epochs=n_epochs) results_columns = [ 'train_loss', 'valid_loss', 'train_accuracy', 'valid_accuracy' ] df = pd.DataFrame(clf.history[:, results_columns], columns=results_columns, index=clf.history[:, 'epoch']) val_accs = df['valid_accuracy'].values max_val_acc = 100.0 * np.max(val_accs) return max_val_acc
# from braindecode.datautil.preprocess import (MNEPreproc, NumpyPreproc, preprocess) high_cut_hz = 30 preprocessors = [ # convert from volt to microvolt, directly modifying the numpy array NumpyPreproc(fn=lambda x: x * 1e6), # bandpass filter MNEPreproc(fn='filter', l_freq=None, h_freq=high_cut_hz), ] # Transform the data preprocess(dataset, preprocessors) ###################################################################### # Extract windows # ~~~~~~~~~~~~~~~ # ###################################################################### # We extract 30-s windows to be used in the classification task. from braindecode.datautil.windowers import create_windows_from_events mapping = { # We merge stages 3 and 4 following AASM standards. 'Sleep stage W': 0, 'Sleep stage 1': 1, 'Sleep stage 2': 2,
def test_preprocess_windows_str(windows_concat_ds): preprocessors = [ Preprocessor('crop', tmin=0, tmax=0.1, include_tmax=False) ] preprocess(windows_concat_ds, preprocessors) assert windows_concat_ds[0][0].shape[1] == 25
def test_preprocess_raw_str(base_concat_ds): preprocessors = [Preprocessor('crop', tmax=10, include_tmax=False)] preprocess(base_concat_ds, preprocessors) assert len(base_concat_ds.datasets[0].raw.times) == 2500
def test_method_not_available(base_concat_ds): preprocessors = [Preprocessor('this_method_is_not_real', )] with pytest.raises(AttributeError): preprocess(base_concat_ds, preprocessors)
def test_not_list(): with pytest.raises(AssertionError): preprocess(None, {'test': 1})