def _get_single_subject_data(self, subject, stack_sessions): """return data for a single subject""" all_files = [] raw_fnames = eegbci.load_data( subject, runs=self.hand_runs, verbose='ERROR', base_url='http://www.physionet.org/pn4/eegmmidb/') raw_files = [ read_raw_edf(f, preload=True, verbose='ERROR') for f in raw_fnames ] # strip channel names of "." characters [raw.rename_channels(lambda x: x.strip('.')) for raw in raw_files] all_files.extend(raw_files) raw_feet_fnames = eegbci.load_data(subject, runs=self.feet_runs, verbose='ERROR') raw_feet_files = [ read_raw_edf(f, preload=True, verbose='ERROR') for f in raw_feet_fnames ] for raw in raw_feet_files: events = mne.find_events(raw) # Event values are added together, previous and current (1,2,3->1,4,5) events[events[:, 2] != 1, 2] = 2 events[events[:, 2] == 1, 2] = 0 raw.add_events(events) raw.rename_channels(lambda x: x.strip('.')) all_files.extend(raw_feet_files) if stack_sessions: return [all_files] else: return [[all_files]]
def _get_single_subject_data(self, subject, stack_sessions): """return data for a single subject""" all_files = [] raw_fnames = eegbci.load_data(subject, runs=self.hand_runs, verbose='ERROR') raw_files = [ read_raw_edf(f, preload=True, verbose='ERROR') for f in raw_fnames ] # strip channel names of "." characters [raw.rename_channels(lambda x: x.strip('.')) for raw in raw_files] all_files.extend(raw_files) raw_feet_fnames = eegbci.load_data(subject, runs=self.feet_runs, verbose='ERROR') raw_feet_files = [ read_raw_edf(f, preload=True, verbose='ERROR') for f in raw_feet_fnames ] for raw in raw_feet_files: events = mne.find_events(raw) events[events[:, 2] == 2, 2] = 2 events[events[:, 2] == 3, 2] = 2 events[events[:, 2] == 1, 2] = 0 raw.add_events(events) raw.rename_channels(lambda x: x.strip('.')) all_files.extend(raw_feet_files) if not stack_sessions: return [[all_files]] else: return [all_files]
def loadthings(subject): runs = [6, 10, 14] raw_fnames = eegbci.load_data(subject, runs) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) raw_fnames = eegbci.load_data(subject, runs) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) eegbci.standardize(raw) #create 10-05 system montage = make_standard_montage('standard_1005') raw.set_montage(montage) raw.filter(7, 13) events, _ = events_from_annotations(raw, event_id=dict(T1=0, T2=1)) #0: left, 1:right picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') tmin, tmax = -1, 4 epochs = Epochs(raw, events, None, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True) #epochs_train=epochs.copy().crop(0,2) epochs_train = epochs.copy().crop(0, 2) labels = epochs.events[:, -1] # %% epochs_train_data = epochs_train.get_data() labels = epochs_train.events[:, -1] ad = np.array(epochs_train_data) All_Data = ad.reshape( 64, epochs_train_data.shape[2] * epochs_train_data.shape[0]) labels = labels.reshape(45, 1) extended = [] for i in range(321): extended.append(labels) extended = np.array(extended) extended = extended.reshape(45, 321) extended = extended.T Labels = extended #np.savetxt("pythondata/extended.csv", extended) row, column = Labels.shape Labels = Labels.reshape(1, row * column) Labels = Labels.T return All_Data, Labels
def data_path(self, subject, path=None, force_update=False, update_path=None, verbose=None): if subject not in self.subject_list: raise(ValueError("Invalid subject number")) paths = [] paths += eegbci.load_data(subject, runs=self.feet_runs, verbose=verbose) paths += eegbci.load_data(subject, runs=self.hand_runs, verbose=verbose) return paths
def get_eeg_data(subject, runs, event_id): tmin, tmax = -1.0, 4.0 # Get and prepare the raw data raw_fnames = eegbci.load_data(subject, runs) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) eegbci.standardize(raw) montage = make_standard_montage('standard_1005') raw.set_montage(montage) raw.rename_channels(lambda x: x.strip('.')) raw.filter(7.0, 30.0, fir_design='firwin', skip_by_annotation='edge') events, _ = events_from_annotations(raw, event_id=event_id) picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True) labels = epochs.events[:, -1] epochs_data = epochs.get_data() return raw.info['sfreq'], epochs_data, labels
def get_real_eeg_data(start=0, stop=4, chans=4): """Get real EEG data for plotting. Keyword Args: start (float): start of the EEG segment, in seconds. stop (float): end of the EEG segment, in seconds. chans (int or list): number of channels to extract, or list of channel indices to be interpreted by MNE's get_data() function. """ raw_fnames = eegbci.load_data(1, 2) raws = [read_raw_edf(f, preload=True) for f in raw_fnames] raw = concatenate_raws(raws) fs = raw.info['sfreq'] start = int(fs * start) stop = int(fs * stop) if not isinstance(chans, list): chans = np.arange(chans) data, t = raw.get_data(picks=chans, start=start, stop=stop, return_times=True) data = data.T return data, t, fs
def _load_one_run(self, subject, run, preload=True): if get_config("MNE_DATASETS_EEGBCI_PATH") is None: set_config("MNE_DATASETS_EEGBCI_PATH", osp.join(osp.expanduser("~"), "mne_data")) raw_fname = eegbci.load_data(subject, runs=[run], verbose="ERROR", base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload, verbose="ERROR") raw.rename_channels(lambda x: x.strip(".")) raw.rename_channels(lambda x: x.upper()) # fmt: off renames = { "AFZ": "AFz", "PZ": "Pz", "FPZ": "Fpz", "FCZ": "FCz", "FP1": "Fp1", "CZ": "Cz", "OZ": "Oz", "POZ": "POz", "IZ": "Iz", "CPZ": "CPz", "FP2": "Fp2", "FZ": "Fz", } # fmt: on raw.rename_channels(renames) raw.set_montage(mne.channels.make_standard_montage("standard_1005")) return raw
def raw_clean(montage): """Return an `mne.io.Raw` object with no bad channels for use with tests. This fixture downloads and reads in subject 30, run 2 from the Physionet BCI2000 (eegbci) open dataset, which contains no bad channels on an initial pass of :class:`pyprep.NoisyChannels`. Intended for use with tests where channels are made artificially bad. File attributes: - Channels: 64 EEG - Sample rate: 160 Hz - Duration: 61 seconds This is only run once per session to save time downloading. """ mne.set_log_level("WARNING") # Download and read S030R02.edf from the BCI2000 dataset edf_fpath = eegbci.load_data(30, 2, update_path=True)[0] raw = mne.io.read_raw_edf(edf_fpath, preload=True) eegbci.standardize(raw) # Fix non-standard channel names # Set a montage for use with RANSAC raw.set_montage(montage) return raw
def _load_one_run(self, subject, run, preload=True): if get_config('MNE_DATASETS_EEGBCI_PATH') is None: set_config('MNE_DATASETS_EEGBCI_PATH', osp.join(osp.expanduser("~"), "mne_data")) raw_fname = eegbci.load_data(subject, runs=[run], verbose='ERROR', base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload, verbose='ERROR') raw.rename_channels(lambda x: x.strip('.')) raw.rename_channels(lambda x: x.upper()) raw.rename_channels({ 'AFZ': 'AFz', 'PZ': 'Pz', 'FPZ': 'Fpz', 'FCZ': 'FCz', 'FP1': 'Fp1', 'CZ': 'Cz', 'OZ': 'Oz', 'POZ': 'POz', 'IZ': 'Iz', 'CPZ': 'CPz', 'FP2': 'Fp2', 'FZ': 'Fz' }) raw.set_montage(mne.channels.make_standard_montage('standard_1005')) return raw
def _load_one_run(self, subject, run, preload=True): raw_fname = eegbci.load_data(subject, runs=[run], verbose='ERROR', base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload, verbose='ERROR') raw.rename_channels(lambda x: x.strip('.')) raw.set_montage(mne.channels.read_montage('standard_1005')) return raw
def _load_one_run(self, subject, run, preload=True): raw_fname = eegbci.load_data(subject, runs=[run], verbose="ERROR", base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload, verbose="ERROR") raw.rename_channels(lambda x: x.strip(".")) raw.rename_channels(lambda x: x.upper()) # fmt: off renames = { "AFZ": "AFz", "PZ": "Pz", "FPZ": "Fpz", "FCZ": "FCz", "FP1": "Fp1", "CZ": "Cz", "OZ": "Oz", "POZ": "POz", "IZ": "Iz", "CPZ": "CPz", "FP2": "Fp2", "FZ": "Fz", } # fmt: on raw.rename_channels(renames) raw.set_montage(mne.channels.make_standard_montage("standard_1005")) return raw
def get_data(): tmin, tmax = -1., 4. event_id = dict(hands=2, feet=3) subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_fnames = eegbci.load_data(subject, runs) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) # strip channel names of "." characters raw.rename_channels(lambda x: x.strip('.')) # Apply band-pass filter raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge') events, _ = events_from_annotations(raw) picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') # Read epochs (train will be done only between 1 and 2s) # Testing will be done with a running classifier epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True) epochs.crop(tmin=1., tmax=None) labels = epochs.events[:, 2] - 2 return epochs.get_data()[:, :, :256], labels
def load_data (): ls_run_tot = [] #list of lists, contains lists of Raw files to be concatenated # e.g. for subjects = [2, 45] #ls_run_tot = [[S2Raw03,S2Raw07,S2Raw11], # [S45Raw03,S45Raw07,S45Raw11]] for subj in subjects: ls_run = []#Lista dove inseriamo le run for run in runs: fname = eegbci.load_data(subj, runs=run)[0] #Prendo le run raw_run = read_raw_edf(fname, preload=True) #Le carico len_run = np.sum((raw_run._annotations).duration) #Controllo la durata if len_run > 123: raw_run.crop(tmax=124.4) #Taglio la parte finale ls_run.append(raw_run) ls_run_tot.append(ls_run) return ls_run_tot
def load_eeg_bci(targets=4, tmin=0, tlen=3, t_ev=0, t_sub=None, normalizer=zscore, low_f=None, high_f=None, alignment=True): paths = [eegbci.load_data(s+1, IMAGERY_FISTS, path=str(TOPLEVEL_EEGBCI), update_path=False) for s in SUBJECTS_EEGBCI] raws = [mne.io.concatenate_raws([mne.io.read_raw_edf(p, preload=True) for p in path]) for path in tqdm.tqdm(paths, unit='subj', desc='Loading')] datasets = OrderedDict() for i, raw in tqdm.tqdm(list(zip(SUBJECTS_EEGBCI, raws)), desc='Preprocessing'): if raw.info['sfreq'] != 160: tqdm.tqdm.write('Skipping..., sampling frequency: {}'.format(raw.info['sfreq'])) continue raw.rename_channels(lambda x: x.strip('.')) if low_f or high_f: raw.filter(low_f, high_f, fir_design='firwin', skip_by_annotation='edge') events, _ = mne.events_from_annotations(raw, event_id=dict(T1=0, T2=1)) picks = mne.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') epochs = mne.Epochs(raw, events[:41, ...], tmin=tmin, tmax=tmin + tlen - 1 / raw.info['sfreq'], picks=picks, baseline=None, reject_by_annotation=False)#.drop_bad() if targets > 2: paths = eegbci.load_data(i + 1, BASELINE_EYES_OPEN, path=str(TOPLEVEL_EEGBCI), update_path=False) raw = mne.io.concatenate_raws([mne.io.read_raw_edf(p, preload=True) for p in paths]) raw.rename_channels(lambda x: x.strip('.')) if low_f or high_f: raw.filter(low_f, high_f, fir_design='firwin', skip_by_annotation='edge') events = np.zeros((events.shape[0] // 2, 3)).astype('int') events[:, -1] = 2 events[:, 0] = np.linspace(0, raw.info['sfreq'] * (60 - 2 * tlen), num=events.shape[0]).astype(np.int) picks = mne.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') eyes_epochs = mne.Epochs(raw, events, tmin=tmin, tmax=tmin + tlen - 1 / raw.info['sfreq'], picks=picks, baseline=None, reject_by_annotation=False)#.drop_bad() epochs = mne.concatenate_epochs([eyes_epochs, epochs]) if targets > 3: paths = eegbci.load_data(i+1, IMAGERY_FEET_V_FISTS, path=str(TOPLEVEL_EEGBCI), update_path=False) raw = mne.io.concatenate_raws([mne.io.read_raw_edf(p, preload=True) for p in paths]) raw.rename_channels(lambda x: x.strip('.')) if low_f or high_f: raw.filter(low_f, high_f, fir_design='firwin', skip_by_annotation='edge') events, _ = mne.events_from_annotations(raw, event_id=dict(T2=3)) picks = mne.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') feet_epochs = mne.Epochs(raw, events[:20, ...], tmin=tmin, tmax=tmin + tlen - 1 / raw.info['sfreq'], picks=picks, baseline=None, reject_by_annotation=False)#.drop_bad() epochs = mne.concatenate_epochs([epochs, feet_epochs]) datasets[i] = EpochsDataset(epochs, preproccesors=EuclideanAlignment if alignment else [], normalizer=normalizer, runs=3) return datasets
def make_filepath(dir_save, subs): filepaths = [] for i in subs: load_path = eegbci.load_data(int(i), [4, 6, 8, 10, 12, 14]) filepaths.append( FilePath(subject='s{}'.format(int(i)), filetype='edf', load_path=load_path, save_path=dir_save)) return filepaths
def _get_single_subject_data(self, subject): """return data for a single subject""" raw_fnames = eegbci.load_data(subject, runs=self.selected_runs) raw_files = [ read_raw_edf(f, preload=True, verbose=False) for f in raw_fnames ] # strip channel names of "." characters [raw.rename_channels(lambda x: x.strip('.')) for raw in raw_files] return raw_files
def raw(): """Fixture for physionet EEG subject 4, dataset 1.""" mne.set_log_level("WARNING") # load in subject 1, run 1 dataset edf_fpath = eegbci.load_data(4, 1, update_path=True)[0] # using sample EEG data (https://physionet.org/content/eegmmidb/1.0.0/) raw = mne.io.read_raw_edf(edf_fpath, preload=True) # The eegbci data has non-standard channel names. We need to rename them: eegbci.standardize(raw) return raw
def data_path(self, subject, path=None, force_update=False, update_path=None, verbose=None): if subject not in self.subject_list: raise (ValueError("Invalid subject number")) paths = eegbci.load_data(subject, runs=[1, 2] + self.hand_runs + self.feet_runs, base_url=BASE_URL) return paths
def get_raw(subject, runs=[6, 10, 14]): raw_fnames = eegbci.load_data(subject, runs) raw_files = [ read_raw_edf(f, preload=True, stim_channel='auto') for f in raw_fnames ] raw = concatenate_raws(raw_files) raw.rename_channels(lambda x: x.strip('.')) raw.pick_channels(ch_names) raw.filter(low_freq, high_freq, fir_design='firwin', skip_by_annotation='edge') return raw
def raw(): """Fixture for physionet EEG subject 4, dataset 1.""" mne.set_log_level("WARNING") # load in subject 1, run 1 dataset edf_fpath = eegbci.load_data(4, 1, update_path=True)[0] # using sample EEG data (https://physionet.org/content/eegmmidb/1.0.0/) raw = mne.io.read_raw_edf(edf_fpath, preload=True) raw.rename_channels(lambda s: s.strip(".")) raw.rename_channels( lambda s: s.replace("c", "C").replace("o", "O").replace("f", "F"). replace("t", "T").replace("Tp", "TP").replace("Cp", "CP")) return raw
def get_classification_dataset(subject=1, typeInt=4): #TypeInt: #Task 1 (open and close left or right fist) #Task 2 (imagine opening and closing left or right fist) #Task 3 (open and close both fists or both feet) #Task 4 (imagine opening and closing both fists or both feet) assert (typeInt >= 1) assert (typeInt <= 4) from mne.io import concatenate_raws, read_raw_edf from mne.datasets import eegbci tmin, tmax = -1., 4. runs = [3, 7, 11] runs = [r + typeInt - 1 for r in runs] print("loading subject {} with runs {}".format(subject, runs)) if typeInt <= 1: event_id = dict(left=2, right=3) else: event_id = dict(hands=2, feet=3) raw_fnames = eegbci.load_data(subject, runs) raws = [read_raw_edf(f, preload=True) for f in raw_fnames] raw = concatenate_raws(raws) raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge') eegbci.standardize(raw) # set channel names montage = mne.channels.make_standard_montage('standard_1005') raw.set_montage(montage) raw.rename_channels(lambda x: x.strip('.')) events, _ = mne.events_from_annotations(raw, event_id=dict(T1=2, T2=3)) picks = mne.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') # Read epochs (train will be done only between 1 and 2s) # Testing will be done with a running classifier epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True) return (epochs)
def data_path(self, subject, path=None, force_update=False, update_path=None, verbose=None): if subject not in self.subject_list: raise (ValueError("Invalid subject number")) sign = "EEGBCI" get_dataset_path(sign, None) paths = eegbci.load_data(subject, runs=[1, 2] + self.hand_runs + self.feet_runs, verbose=verbose) return paths
def load_nme_data(self): raw_fnames = eegbci.load_data(1, self.RUNS) raw_files = [] raw_files.extend([ read_raw_edf(f, preload=True, stim_channel='auto') for f in raw_fnames ]) raw = concatenate_raws(raw_files) raw.rename_channels(lambda x: x.strip('.')) self.raw = raw self.data = raw.get_data() self.times = self.raw[-1, :][-1] * 1000
def data_path(self, subject, path=None, force_update=False, update_path=None, verbose=None): if subject not in self.subject_list: raise (ValueError("Invalid subject number")) if get_config('MNE_DATASETS_EEGBCI_PATH') is None: set_config('MNE_DATASETS_EEGBCI_PATH', osp.join(osp.expanduser("~"), "mne_data")) paths = eegbci.load_data(subject, runs=[1, 2] + self.hand_runs + self.feet_runs, verbose=verbose) return paths
def load_subject(id_num, runs): ''' Loads raw EEG recordings for one subject and at least one run of experiments. Arguments: id_num: int, the subject's ID number runs: int or list of ints -- which experiment(s) to read data from Returns: MNE Raw object ''' edf_files = load_data(id_num, runs) if len(edf_files) > 1: raw_objects = [read_raw_edf(file, preload=True) for file in edf_files] mne_raw = concatenate_raws(raw_objects, preload=True) else: mne_raw = read_raw_edf(edf_files[0], preload=True) return mne_raw
def _load_one_run(self, subject, run, preload=True): if get_config('MNE_DATASETS_EEGBCI_PATH') is None: set_config('MNE_DATASETS_EEGBCI_PATH', osp.join(osp.expanduser("~"), "mne_data")) raw_fname = eegbci.load_data(subject, runs=[run], verbose='ERROR', base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload, verbose='ERROR') raw.rename_channels(lambda x: x.strip('.')) raw.rename_channels(lambda x: x.upper()) raw.rename_channels({ 'AFZ': 'AFz', 'PZ': 'Pz', 'FPZ': 'Fpz', 'FCZ': 'FCz', 'FP1': 'Fp1', 'CZ': 'Cz', 'OZ': 'Oz', 'POZ': 'POz', 'IZ': 'Iz', 'CPZ': 'CPz', 'FP2': 'Fp2', 'FZ': 'Fz' }) raw.set_montage(mne.channels.make_standard_montage('standard_1005')) # creat simulate stim channel # mne >= 0.18 events, _ = mne.events_from_annotations(raw) stim_channel = np.zeros((1, raw.n_times)) for event in events: stim_channel[0, event[0]] = event[2] info = mne.create_info(['STI 014'], raw.info['sfreq'], ch_types=['stim']) raw = raw.add_channels([mne.io.RawArray(stim_channel, info)], force_update_info=True) return raw
def _load_one_run(self, subject, run, preload=True, verbose=None): raw_fname = eegbci.load_data(subject, runs=[run], base_url=BASE_URL)[0] raw = read_raw_edf(raw_fname, preload=preload) raw.rename_channels(lambda x: x.strip('.')) montage = make_standard_montage('standard_1005') # 0.19.2 can not guarante channel name case insensitive montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] raw = upper_ch_names(raw) raw.set_montage(montage) # creat simulate stim channel # mne >= 0.18 events, _ = mne.events_from_annotations(raw) stim_channel = np.zeros((1, raw.n_times)) for event in events: stim_channel[0, event[0]] = event[2] info = mne.create_info(['STI 014'], raw.info['sfreq'], ch_types=['stim']) raw = raw.add_channels([RawArray(stim_channel, info)], force_update_info=True) return raw
def raw(): """Return an `mne.io.Raw` object for use with unit tests. This fixture downloads and reads in subject 4, run 1 from the Physionet BCI2000 (eegbci) open dataset. This recording is quite noisy and is thus a good candidate for testing the PREP pipeline. File attributes: - Channels: 64 EEG - Sample rate: 160 Hz - Duration: 61 seconds This is only run once per session to save time downloading. """ mne.set_log_level("WARNING") # Download and read S004R01.edf from the BCI2000 dataset edf_fpath = eegbci.load_data(4, 1, update_path=True)[0] raw = mne.io.read_raw_edf(edf_fpath, preload=True) eegbci.standardize(raw) # Fix non-standard channel names return raw
from mne import Epochs, pick_types, events_from_annotations from mne.channels import read_layout from mne.io import concatenate_raws, read_raw_edf from mne.datasets import eegbci from mne.decoding import CSP from smica import ICA import pickle tmin, tmax = -1., 4. subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_fnames = eegbci.load_data(subject, runs) raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames]) # strip channel names of "." characters raw.rename_channels(lambda x: x.strip('.')) # Apply band-pass filter raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge') events, _ = events_from_annotations(raw) picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False,
from mne.event import find_events from pyriemann.stats import PermutationTest from pyriemann.estimation import Covariances ############################################################################### ## Set parameters and read data # avoid classification of evoked responses by using epochs that start 1s after # cue onset. tmin, tmax = 1., 3. event_id = dict(hands=2, feet=3) subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_files = [read_raw_edf(f, preload=True,verbose=False) for f in eegbci.load_data(subject, runs) ] raw = concatenate_raws(raw_files) # strip channel names raw.info['ch_names'] = [chn.strip('.') for chn in raw.info['ch_names']] # Apply band-pass filter raw.filter(7., 35., method='iir') events = find_events(raw, shortest_event=0, stim_channel='STI 014') picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') # Read epochs (train will be done only between 1 and 2s) # Testing will be done with a running classifier epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,
fs_dir = fetch_fsaverage(verbose=True) subjects_dir = op.dirname(fs_dir) # The files live in: subject = 'fsaverage' trans = op.join(fs_dir, 'bem', 'fsaverage-trans.fif') src = op.join(fs_dir, 'bem', 'fsaverage-ico-5-src.fif') bem = op.join(fs_dir, 'bem', 'fsaverage-5120-5120-5120-bem-sol.fif') ############################################################################## # Load the data # ------------- # # We use here EEG data from the BCI dataset. raw_fname, = eegbci.load_data(subject=1, runs=[6]) raw = mne.io.read_raw_edf(raw_fname, preload=True) # Clean channel names to be able to use a standard 1005 montage ch_names = [c.replace('.', '') for c in raw.ch_names] raw.rename_channels({old: new for old, new in zip(raw.ch_names, ch_names)}) # Read and set the EEG electrode locations montage = mne.channels.read_montage('standard_1005', ch_names=raw.ch_names, transform=True) raw.set_montage(montage) raw.set_eeg_reference(projection=True) # needed for inverse modeling # Check that the locations of EEG electrodes is correct with respect to MRI
from pyriemann.stats import PermutationTestTwoWay, PermutationTest from pyriemann.estimation import Covariances ############################################################################### ## Set parameters and read data # avoid classification of evoked responses by using epochs that start 1s after # cue onset. tmin, tmax = -2., 6. event_id = dict(hands=2, feet=3) subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_files = [ read_raw_edf(f, preload=True, verbose=False) for f in eegbci.load_data(subject, runs) ] raw = concatenate_raws(raw_files) # strip channel names raw.info['ch_names'] = [chn.strip('.') for chn in raw.info['ch_names']] events = find_events(raw, shortest_event=0, stim_channel='STI 014') picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') raw.filter(7., 35., method='iir', picks=picks)
from pyriemann.stats import PermutationTest from pyriemann.estimation import CospCovariances ############################################################################### # Set parameters and read data # avoid classification of evoked responses by using epochs that start 1s after # cue onset. tmin, tmax = 1., 3. event_id = dict(hands=2, feet=3) subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_files = [read_raw_edf(f, preload=True, verbose=False) for f in eegbci.load_data(subject, runs)] raw = concatenate_raws(raw_files) events = find_events(raw, shortest_event=0, stim_channel='STI 014') picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') # Read epochs (train will be done only between 1 and 2s) # Testing will be done with a running classifier epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True, add_eeg_ref=False, verbose=False) labels = epochs.events[:, -1] - 2 # get epochs epochs_data = epochs.get_data()
from mne.datasets import eegbci from mne.decoding import CSP print(__doc__) # ############################################################################# # # Set parameters and read data # avoid classification of evoked responses by using epochs that start 1s after # cue onset. tmin, tmax = -1., 4. event_id = dict(hands=2, feet=3) subject = 1 runs = [6, 10, 14] # motor imagery: hands vs feet raw_fnames = eegbci.load_data(subject, runs) raw_files = [read_raw_edf(f, preload=True) for f in raw_fnames] raw = concatenate_raws(raw_files) # strip channel names of "." characters raw.rename_channels(lambda x: x.strip('.')) # Apply band-pass filter raw.filter(7., 30., method='iir') events = find_events(raw, shortest_event=0, stim_channel='STI 014') picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads') # Read epochs (train will be done only between 1 and 2s)