def test_compute_proj_epochs(): """Test SSP computation on epochs""" event_id, tmin, tmax = 1, -0.2, 0.3 raw = Raw(raw_fname, preload=True) events = read_events(event_fname) bad_ch = 'MEG 2443' picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=[]) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1) write_proj(op.join(tempdir, 'proj.fif.gz'), projs) for p_fname in [proj_fname, proj_gz_fname, op.join(tempdir, 'proj.fif.gz')]: projs2 = read_proj(p_fname) assert_true(len(projs) == len(projs2)) for p1, p2 in zip(projs, projs2): assert_true(p1['desc'] == p2['desc']) assert_true(p1['data']['col_names'] == p2['data']['col_names']) assert_true(p1['active'] == p2['active']) # compare with sign invariance p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0]) p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0]) if bad_ch in p1['data']['col_names']: bad = p1['data']['col_names'].index('MEG 2443') mask = np.ones(p1_data.size, dtype=np.bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 5) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them epochs.info['projs'] += projs evoked = epochs.average() evoked.save(op.join(tempdir, 'foo.fif')) projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0) assert_true(len(projs_evoked) == 2) # XXX : test something # test parallelization projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2) projs = activate_proj(projs) proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[]) assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16)
def computeSSP(EEG, info, threshold): ''' Computes SSP projections of epoched EEG data. # Arguments EEG: MNE EpochsArray data structure Epoched EEG data in MNE format. info: MNE info structure Threshold: float Value between 0 and 1. # Returns threshold_projs: list List of SSP projection vectors above the pre-defined threshold (variance explained). ''' projs = mne.compute_proj_epochs(EEG, n_eeg=10, n_jobs=1, verbose=True) p = [projs[i]['explained_var'] for i in range(10)] # If variance explained is above the pre-defined threshold, use the SSP projection vector threshold_idx = analyzeVar(p, threshold) threshold_projs = [] # List with projections above the threshold for idx in threshold_idx: threshold_projs.append(projs[idx]) return threshold_projs
def computeSSP(EEG, info, threshold): ''' Computes SSP projections of epoched EEG data (bandpass filtered and resampled to 100Hz). # Input - EEG: Epoched and processed EEG - info: mne info struct - threshold: Value between 0 and 1, only uses the SSP projection vector if it explains more than the pre-defined threshold. # Output - Array of SSP projection vectors above a pre-defined threshold (variance explained). ''' print('Computing SSP based on epochs') projs = mne.compute_proj_epochs(EEG, n_eeg=10, n_jobs=1, verbose=True) p = [projs[i]['explained_var'] for i in range(10)] # If variance explained is above a certain threshold, use the SSP vector for projection threshold_idx = analyzeVar(p, threshold) threshold_projs = [] # List with projections above a chosen threshold for idx in threshold_idx: threshold_projs.append(projs[idx]) return threshold_projs
def test_compute_proj(): """Test SSP computation""" event_id, tmin, tmax = 1, -0.2, 0.3 raw = Raw(raw_fname) events = read_events(event_fname) exclude = [] bad_ch = 'MEG 2443' picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=exclude) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0) projs2 = read_proj(proj_fname) assert_true(len(projs) == len(projs2)) for p1, p2 in zip(projs, projs2): assert_true(p1['desc'] == p2['desc']) assert_true(p1['data']['col_names'] == p2['data']['col_names']) assert_true(p1['active'] == p2['active']) # compare with sign invariance p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0]) p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0]) if bad_ch in p1['data']['col_names']: bad = p1['data']['col_names'].index('MEG 2443') mask = np.ones(p1_data.size, dtype=np.bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 7) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them epochs.info['projs'] += projs evoked = epochs.average() evoked.save('foo.fif') projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
def denoise_projs(epochs, apply=True): ''' # Estimate SSP denoise projectors for the [epochs] - @epochs: The epochs whose SSP projectors are computed and applied - @apply: Whether apply_proj to the epochs, default by True see 'https://mne.tools/stable/auto_tutorials/preprocessing/plot_45_projectors_background.html#computing-projectors' for detail ''' projs = mne.compute_proj_epochs(epochs) for p in projs: epochs.add_proj(p) if apply: epochs.apply_proj() return epochs
def compute_spatial_vectors(epochs, n_grad=2, n_mag=2, n_eeg=2): """Compute SSP (spatial space projection) vectors Parameters ---------- epochs : instance of Epochs The epochs containing the artifact. n_grad : int Number of vectors for gradiometers. n_mag : int Number of vectors for gradiometers. n_eeg : int Number of vectors for gradiometers. Returns ------- projs: list List of projection vectors. """ import mne # XXX : ugly due to circular mess in imports return mne.compute_proj_epochs(epochs, n_grad, n_mag, n_eeg)
def computeSSP(EEG, info, threshold): ''' Computes SSP projections of epoched EEG data. Returns a list of SSP projection vectors above the pre-defined threshold (variance explained). ''' projs = mne.compute_proj_epochs(EEG, n_grad=2, n_mag=2, n_eeg=20, n_jobs=1, verbose=True) p = [projs[i]['explained_var'] for i in range(20)] # If variance explained is above the pre-defined threshold, use the SSP projection vector threshold_idx = analyzeVar(p, threshold) threshold_projs = [] # List with projections above the threshold for idx in threshold_idx: threshold_projs.append(projs[idx]) return threshold_projs
# Conversion from samples to times: onsets = annotations_df['onset'].values / raw.info['sfreq'] durations = annotations_df['duration'].values / raw.info['sfreq'] descriptions = map(str, annotations_df['label'].values) annotations = mne.Annotations(onsets, durations, descriptions) raw.annotations = annotations del onsets, durations, descriptions ############################################################################### # Here we compute the saccade and EOG projectors for magnetometers and add # them to the raw data. The projectors are added to both runs. saccade_epochs = mne.Epochs(raw, saccades_events, 1, 0., 0.5, preload=True, reject_by_annotation=False) projs_saccade = mne.compute_proj_epochs(saccade_epochs, n_mag=1, n_eeg=0, desc_prefix='saccade') if use_precomputed: proj_fname = op.join(data_path, 'MEG', 'bst_auditory', 'bst_auditory-eog-proj.fif') projs_eog = mne.read_proj(proj_fname)[0] else: projs_eog, _ = mne.preprocessing.compute_proj_eog(raw.load_data(), n_mag=1, n_eeg=0) raw.add_proj(projs_saccade) raw.add_proj(projs_eog) del saccade_epochs, saccades_events, projs_eog, projs_saccade # To save memory ############################################################################### # Visually inspect the effects of projections. Click on 'proj' button at the # bottom right corner to toggle the projectors on/off. EOG events can be # plotted by adding the event list as a keyword argument. As the bad segments
def compute_proj_ecg(in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, preload, filter_length, n_jobs, ch_name, reject, avg_ref, bads): """Compute SSP/PCA projections for ECG artifacts Parameters ---------- in_fif_fname: string Raw fif File XXX """ # Reading fif File raw = mne.fiff.Raw(in_fif_fname, preload=preload) if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'): prefix = in_fif_fname[:-8] else: prefix = in_fif_fname[:-4] ecg_event_fname = prefix + '_ecg-eve.fif' if average: ecg_proj_fname = prefix + '_ecg_avg_proj.fif' else: ecg_proj_fname = prefix + '_ecg_proj.fif' print 'Running ECG SSP computation' ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name) print "Writing ECG events in %s" % ecg_event_fname mne.write_events(ecg_event_fname, ecg_events) if avg_ref: print "Adding average EEG reference projection." eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info) raw.info['projs'].append(eeg_proj) print 'Computing ECG projector' # Handler rejection parameters if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0: del reject['grad'] if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0: del reject['mag'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0: del reject['eeg'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0: del reject['eog'] picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True, exclude=raw.info['bads'] + bads) if l_freq is None and h_freq is not None: raw.high_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is None: raw.low_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is not None: raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs) epochs = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None, picks=picks, reject=reject, proj=True) projs_init = raw.info['projs'] if average: evoked = epochs.average() projs = mne.compute_proj_evoked(evoked, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) else: projs = mne.compute_proj_epochs(epochs, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) if preload is not None and os.path.exists(preload): os.remove(preload) print "Writing ECG projections in %s" % ecg_proj_fname mne.write_proj(ecg_proj_fname, projs + projs_init) print 'Done.'
del onsets, durations, descriptions ############################################################################### # Here we compute the saccade and EOG projectors for magnetometers and add # them to the raw data. The projectors are added to both runs. saccade_epochs = mne.Epochs(raw, saccades_events, 1, 0., 0.5, preload=True, baseline=(None, None), reject_by_annotation=False) projs_saccade = mne.compute_proj_epochs(saccade_epochs, n_mag=1, n_eeg=0, desc_prefix='saccade') if use_precomputed: proj_fname = op.join(data_path, 'MEG', 'bst_auditory', 'bst_auditory-eog-proj.fif') projs_eog = mne.read_proj(proj_fname)[0] else: projs_eog, _ = mne.preprocessing.compute_proj_eog(raw.load_data(), n_mag=1, n_eeg=0) raw.add_proj(projs_saccade) raw.add_proj(projs_eog) del saccade_epochs, saccades_events, projs_eog, projs_saccade # To save memory ############################################################################### # Visually inspect the effects of projections. Click on 'proj' button at the
def compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload, flat): """Compute SSP/PCA projections for ECG/EOG artifacts Parameters ---------- in_fif_fname: string Raw fif File XXX """ if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'): prefix = in_fif_fname[:-8] else: prefix = in_fif_fname[:-4] ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif' if average: ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj_raw.fif' else: ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_proj_raw.fif' print 'Reading fif File' in_fif_fname = in_path + in_fif_fname raw = mne.fiff.Raw(in_fif_fname, preload=preload) # if (in_path == '/cluster/kuperberg/SemPrMM/MEG/data/ya30/'): # save after 84s of MEG data in FIF file # raw = raw[: , 84:] #raw.save('sample_audvis_meg_raw.fif', tmin=84) print 'Running ECG SSP computation' ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name) print "Writing ECG events in %s" % ecg_event_fname mne.write_events(ecg_event_fname, ecg_events) make_lingua(ecg_event_fname) if avg_ref: print "Adding average EEG reference projection." eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info) raw.info['projs'].append(eeg_proj) print 'Computing ECG projector' # Handler rejection parameters if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0: del reject['grad'] if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0: del reject['mag'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0: del reject['eeg'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0: del reject['eog'] picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True, exclude=raw.info['bads'] + bads) if l_freq is None and h_freq is not None: raw.high_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is None: raw.low_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is not None: raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs) epochs_ecg = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None, picks=picks, reject=reject, proj=True) print epochs_ecg projs_init = raw.info['projs'] if average: evoked_ecg = epochs_ecg.average() projs_ecg = mne.compute_proj_evoked(evoked_ecg, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) else: print epochs_ecg, n_grad, n_mag, n_eeg projs_ecg = mne.compute_proj_epochs(epochs_ecg, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) print "Writing ECG projections in %s" % ecg_proj_fname mne.write_proj( ecg_proj_fname, projs_ecg + projs_init ) ## Original Projections written along with the ecg projections. print "Writing ECG projections in %s" % ecg_proj_fname mne.write_proj(ecg_proj_fname, projs_ecg) return in_fif_fname, ecg_proj_fname, out_fif_fname
def compute_proj_wrap(epochs, average, **kwargs): if average: return compute_proj_evoked(epochs.average(), **kwargs) else: return compute_proj_epochs(epochs, **kwargs)
def test_compute_proj_epochs(tmp_path): """Test SSP computation on epochs.""" tempdir = str(tmp_path) event_id, tmin, tmax = 1, -0.2, 0.3 raw = read_raw_fif(raw_fname, preload=True) events = read_events(event_fname) bad_ch = 'MEG 2443' picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=[]) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1) write_proj(op.join(tempdir, 'test-proj.fif.gz'), projs) for p_fname in [ proj_fname, proj_gz_fname, op.join(tempdir, 'test-proj.fif.gz') ]: projs2 = read_proj(p_fname) assert len(projs) == len(projs2) for p1, p2 in zip(projs, projs2): assert p1['desc'] == p2['desc'] assert p1['data']['col_names'] == p2['data']['col_names'] assert p1['active'] == p2['active'] # compare with sign invariance p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0]) p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0]) if bad_ch in p1['data']['col_names']: bad = p1['data']['col_names'].index('MEG 2443') mask = np.ones(p1_data.size, dtype=bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 5) if p2['explained_var']: assert_array_almost_equal(p1['explained_var'], p2['explained_var']) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert nproj == 2 assert U.shape[1] == 2 # test that you can save them with epochs.info._unlock(): epochs.info['projs'] += projs evoked = epochs.average() evoked.save(op.join(tempdir, 'foo-ave.fif')) projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0) assert len(projs_evoked) == 2 # XXX : test something # test parallelization projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1, desc_prefix='foobar') assert all('foobar' in x['desc'] for x in projs) projs = activate_proj(projs) proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[]) assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16) # test warnings on bad filenames proj_badname = op.join(tempdir, 'test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-proj.fif'): write_proj(proj_badname, projs) with pytest.warns(RuntimeWarning, match='-proj.fif'): read_proj(proj_badname) # bad inputs fname = op.join(tempdir, 'out-proj.fif') with pytest.raises(TypeError, match='projs'): write_proj(fname, 'foo') with pytest.raises(TypeError, match=r'projs\[0\] must be .*'): write_proj(fname, ['foo'])
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload): #####Defining filenames if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'): prefix = in_fif_fname[:-8] else: prefix = in_fif_fname[:-4] eog_event_fname = in_path + 'ssp/' + prefix + '_PYeog-eve.fif' if average: eog_proj_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj_raw.fif' else: eog_proj_fname = in_path + 'ssp/' + prefix + '_PYeog_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_PYeog_proj_raw.fif' ####Reading in raw data in_fif_fname = in_path + in_fif_fname raw = mne.fiff.Raw(in_fif_fname, preload=preload) print 'Running EOG SSP computation' eog_events, _ = mne.artifacts.find_eog_events( raw ) # since our copy of the mne.artifacts.events.py script returns two parameters. print "Writing EOG events in %s" % eog_event_fname mne.write_events(eog_event_fname, eog_events) make_lingua(eog_event_fname) print 'Computing EOG projector' # Handler rejection parameters if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, ecg=False)) == 0: del reject['grad'] if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, ecg=False)) == 0: del reject['mag'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, ecg=False)) == 0: del reject['eeg'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, ecg=True)) == 0: del reject['ecg'] picks_eog = mne.fiff.pick_types(raw.info, meg=True, eeg=True, ecg=True, exclude=raw.info['bads'] + bads) if l_freq is None and h_freq is not None: raw.high_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is None: raw.low_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is not None: raw.band_pass_filter(picks_eog, l_freq, h_freq, filter_length, n_jobs) epochs_eog = mne.Epochs(raw, eog_events, None, tmin, tmax, baseline=None, picks=picks_eog, reject=reject, proj=True) projs_init = raw.info['projs'] if average: evoked_eog = epochs_eog.average() projs_eog = mne.compute_proj_evoked(evoked_eog, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) else: print epochs_eog, n_grad, n_mag, n_eeg projs_eog = mne.compute_proj_epochs(epochs_eog, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) print "Writing EOG projections in %s" % eog_proj_fname mne.write_proj(eog_proj_fname, projs_eog) return in_fif_fname, eog_proj_fname, out_fif_fname
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload): #####Defining filenames if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'): prefix = in_fif_fname[:-8] else: prefix = in_fif_fname[:-4] eog_event_fname = in_path + 'ssp/'+ prefix + '_PYeog-eve.fif' if average: eog_proj_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj_raw.fif' else: eog_proj_fname = in_path + 'ssp/' + prefix + '_PYeog_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_PYeog_proj_raw.fif' ####Reading in raw data in_fif_fname = in_path + in_fif_fname raw = mne.fiff.Raw(in_fif_fname, preload=preload) print 'Running EOG SSP computation' eog_events, _= mne.artifacts.find_eog_events(raw) # since our copy of the mne.artifacts.events.py script returns two parameters. print "Writing EOG events in %s" % eog_event_fname mne.write_events(eog_event_fname, eog_events) make_lingua(eog_event_fname) print 'Computing EOG projector' # Handler rejection parameters if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, ecg=False)) == 0: del reject['grad'] if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, ecg=False)) == 0: del reject['mag'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, ecg=False)) == 0: del reject['eeg'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, ecg=True)) == 0: del reject['ecg'] picks_eog = mne.fiff.pick_types(raw.info, meg=True, eeg=True, ecg=True, exclude=raw.info['bads'] + bads) if l_freq is None and h_freq is not None: raw.high_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is None: raw.low_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is not None: raw.band_pass_filter(picks_eog, l_freq, h_freq, filter_length, n_jobs) epochs_eog = mne.Epochs(raw, eog_events, None, tmin, tmax, baseline=None, picks=picks_eog, reject=reject, proj=True) projs_init = raw.info['projs'] if average: evoked_eog = epochs_eog.average() projs_eog = mne.compute_proj_evoked(evoked_eog, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) else: print epochs_eog, n_grad, n_mag, n_eeg projs_eog = mne.compute_proj_epochs(epochs_eog, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) print "Writing EOG projections in %s" % eog_proj_fname mne.write_proj(eog_proj_fname, projs_eog) return in_fif_fname, eog_proj_fname, out_fif_fname
def test_compute_proj_epochs(): """Test SSP computation on epochs.""" tempdir = _TempDir() event_id, tmin, tmax = 1, -0.2, 0.3 raw = read_raw_fif(raw_fname, preload=True) events = read_events(event_fname) bad_ch = "MEG 2443" picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=[]) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1) write_proj(op.join(tempdir, "test-proj.fif.gz"), projs) for p_fname in [proj_fname, proj_gz_fname, op.join(tempdir, "test-proj.fif.gz")]: projs2 = read_proj(p_fname) assert_true(len(projs) == len(projs2)) for p1, p2 in zip(projs, projs2): assert_true(p1["desc"] == p2["desc"]) assert_true(p1["data"]["col_names"] == p2["data"]["col_names"]) assert_true(p1["active"] == p2["active"]) # compare with sign invariance p1_data = p1["data"]["data"] * np.sign(p1["data"]["data"][0, 0]) p2_data = p2["data"]["data"] * np.sign(p2["data"]["data"][0, 0]) if bad_ch in p1["data"]["col_names"]: bad = p1["data"]["col_names"].index("MEG 2443") mask = np.ones(p1_data.size, dtype=np.bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 5) if p2["explained_var"]: assert_array_almost_equal(p1["explained_var"], p2["explained_var"]) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them epochs.info["projs"] += projs evoked = epochs.average() evoked.save(op.join(tempdir, "foo-ave.fif")) projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0) assert_true(len(projs_evoked) == 2) # XXX : test something # test parallelization projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2, desc_prefix="foobar") assert_true(all("foobar" in x["desc"] for x in projs)) projs = activate_proj(projs) proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[]) assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") proj_badname = op.join(tempdir, "test-bad-name.fif.gz") write_proj(proj_badname, projs) read_proj(proj_badname) assert_naming(w, "test_proj.py", 2)
def test_compute_proj_epochs(): """Test SSP computation on epochs""" tempdir = _TempDir() event_id, tmin, tmax = 1, -0.2, 0.3 raw = Raw(raw_fname, preload=True) events = read_events(event_fname) bad_ch = 'MEG 2443' picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=[]) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1) write_proj(op.join(tempdir, 'test-proj.fif.gz'), projs) for p_fname in [ proj_fname, proj_gz_fname, op.join(tempdir, 'test-proj.fif.gz') ]: projs2 = read_proj(p_fname) assert_true(len(projs) == len(projs2)) for p1, p2 in zip(projs, projs2): assert_true(p1['desc'] == p2['desc']) assert_true(p1['data']['col_names'] == p2['data']['col_names']) assert_true(p1['active'] == p2['active']) # compare with sign invariance p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0]) p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0]) if bad_ch in p1['data']['col_names']: bad = p1['data']['col_names'].index('MEG 2443') mask = np.ones(p1_data.size, dtype=np.bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 5) if p2['explained_var']: assert_array_almost_equal(p1['explained_var'], p2['explained_var']) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them epochs.info['projs'] += projs evoked = epochs.average() evoked.save(op.join(tempdir, 'foo-ave.fif')) projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0) assert_true(len(projs_evoked) == 2) # XXX : test something # test parallelization projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2, desc_prefix='foobar') assert_true(all('foobar' in x['desc'] for x in projs)) projs = activate_proj(projs) proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[]) assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16) # test warnings on bad filenames clean_warning_registry() with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') proj_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_proj(proj_badname, projs) read_proj(proj_badname) print([ww.message for ww in w]) assert_equal(len(w), 2)
def compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload, flat): """Compute SSP/PCA projections for ECG/EOG artifacts Parameters ---------- in_fif_fname: string Raw fif File XXX """ if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'): prefix = in_fif_fname[:-8] else: prefix = in_fif_fname[:-4] ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif' if average: ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj_raw.fif' else: ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_proj.fif' out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_proj_raw.fif' print 'Reading fif File' in_fif_fname = in_path + in_fif_fname raw = mne.fiff.Raw(in_fif_fname, preload=preload) # if (in_path == '/cluster/kuperberg/SemPrMM/MEG/data/ya30/'): # save after 84s of MEG data in FIF file # raw = raw[: , 84:] #raw.save('sample_audvis_meg_raw.fif', tmin=84) print 'Running ECG SSP computation' ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name) print "Writing ECG events in %s" % ecg_event_fname mne.write_events(ecg_event_fname, ecg_events) make_lingua(ecg_event_fname) if avg_ref: print "Adding average EEG reference projection." eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info) raw.info['projs'].append(eeg_proj) print 'Computing ECG projector' # Handler rejection parameters if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0: del reject['grad'] if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0: del reject['mag'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0: del reject['eeg'] if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0: del reject['eog'] picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True, exclude=raw.info['bads'] + bads) if l_freq is None and h_freq is not None: raw.high_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is None: raw.low_pass_filter(picks, h_freq, filter_length, n_jobs) if l_freq is not None and h_freq is not None: raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs) epochs_ecg = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None, picks=picks, reject=reject, proj=True) print epochs_ecg projs_init = raw.info['projs'] if average: evoked_ecg = epochs_ecg.average() projs_ecg = mne.compute_proj_evoked(evoked_ecg, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) else: print epochs_ecg, n_grad, n_mag, n_eeg projs_ecg = mne.compute_proj_epochs(epochs_ecg, n_grad=n_grad, n_mag=n_mag, n_eeg=n_eeg) print "Writing ECG projections in %s" % ecg_proj_fname mne.write_proj(ecg_proj_fname, projs_ecg + projs_init) ## Original Projections written along with the ecg projections. print "Writing ECG projections in %s" % ecg_proj_fname mne.write_proj(ecg_proj_fname, projs_ecg) return in_fif_fname, ecg_proj_fname, out_fif_fname
def preprocEEG(eeg, EEGfile, SSP=True, threshold=0.1, SSP_start_end=None, reject=None, events_list=None, reject_ch=None, set_ref=1, prefilter=0, flat=None): ''' Preprocesses epoched EEG data. # Input - eeg: Epoched EEG data in the following format: (trials, time samples, channels). - EEGfile: .csv file with raw EEG recordings (for computing SSP projection vectors). If EEGfile == [], the SSP projection vectors are computed based on epochs. - SSP: Whether to apply SSP projections. - Threshold: Value between 0 and 1, only uses the SSP projection vector if it explains more than the pre-defined threshold. - SSP_start_end: Pre-defined "start" and "end" time points (array consisting of two floats) for the length of raw EEG to use for SSP projection vector analysis. Acquired from extractEpochs function. - reject_ch: Whether to reject pre-defined channels. - set_ref: Use average reference - prefilter: Filter before epoch extraction - flat: reject channels having close to no variation # Preprocessing - Linear detrending (channel-wise) - EpochsArray format in MNE - Reject channels (if reject_ch == True) - Bandpass filter - Resample to 100Hz - SSP (if ssp == True) - Reject bad channels/epochs (if ??) - Baseline correction - Rereference to average - Baseline correction # Output - epochs: Epoched EEG data in MNE EpochsArray - projs: SSP projection vectors ''' # INFO channel_names = [ 'P7', 'P4', 'Cz', 'Pz', 'P3', 'P8', 'O1', 'O2', 'T8', 'F8', 'C4', 'F4', 'Fp2', 'Fz', 'C3', 'F3', 'Fp1', 'T7', 'F7', 'Oz', 'PO3', 'AF3', 'FC5', 'FC1', 'CP5', 'CP1', 'CP2', 'CP6', 'AF4', 'FC2', 'FC6', 'PO4' ] channel_types = ['eeg'] * 32 sfreq = 500 # in Hertz montage = 'standard_1020' # Or 1010 info = mne.create_info(channel_names, sfreq, channel_types, montage) info['description'] = 'Enobio' #if reject_ch == 'true': # info['bads'] = ['Fp1','Fp2','Fz','AF3','AF4','T7','T8','F7','F8'] eeg = detrend(eeg, axis=1, type='linear') no_trials = eeg.shape[0] axis_move = np.moveaxis(eeg, [1, 2], [-1, -2]) # Rearrange into MNE format tmin = -0.1 if events_list is not None: # if categories are included event_id = dict(scene=0, face=1) n_epochs = len(events_list) events_list = [int(i) for i in events_list] events = np.c_[np.arange(n_epochs), np.zeros(n_epochs, int), events_list] else: event_id = None events = None epochs = mne.EpochsArray(axis_move, info, events=events, tmin=tmin, event_id=event_id, baseline=None) if reject_ch == True: bads = ['Fp1', 'Fp2', 'Fz', 'AF3', 'AF4', 'T7', 'T8', 'F7', 'F8'] epochs.drop_channels(bads) # Bandpass filtering epochs.filter(HP, LP, fir_design='firwin', phase=phase) # Resampling to 100 Hz epochs.resample(100, npad='auto') # Apply SSP (computed based on the raw/not epoched EEG) if SSP == True: if not EEGfile: print('Computing SSP based on epochs') all_projs = mne.compute_proj_epochs(epochs, n_eeg=10, n_jobs=1, verbose=True) p = [all_projs[i]['explained_var'] for i in range(10)] # If variance explained is above a certain threshold, use the SSP vector for projection threshold_idx = analyzeVar(p, threshold) projs = [] # List with projections above a chosen threshold for idx in threshold_idx: projs.append(all_projs[idx]) else: if reject_ch == None: projs = computeSSP(EEGfile, threshold, SSP_start_end, reject_ch=None) if reject_ch == True: projs = computeSSP(EEGfile, threshold, SSP_start_end, reject_ch=True) # Apply projection to the epochs already defined epochs.add_proj(projs) epochs.apply_proj() else: projs = [] if reject is not None: epochs_copy = epochs.copy() epochs_copy.drop_bad(reject=reject, flat=flat, verbose=None) log = epochs_copy.drop_log not_blank = np.concatenate([x for x in (log) if x]) bad_channels, bad_counts = np.unique(not_blank, return_counts=True) #bad_channels=[bad_channels[a] for a in range(len(bad_channels))] thres = 0.05 * no_trials bad_above_thres = bad_channels[bad_counts > thres] if len(bad_above_thres): print(1) epochs.info['bads'] = bad_above_thres print('Dropping channels:', bad_above_thres) epochs.interpolate_bads(reset_bads=True) # repeat looking for bad epochs epochs_copy = epochs.copy() epochs_copy.drop_bad(reject=reject, flat=flat, verbose=None) log = epochs_copy.drop_log bad_epochs = [i for i, x in enumerate(log) if x] epochs.drop(bad_epochs, reason='Reject') epochs.apply_baseline(baseline=(None, 0)) # Rereferencing epochs.set_eeg_reference() # Apply baseline after filtering epochs.apply_baseline(baseline=(None, 0)) return epochs, projs
def test_compute_proj_epochs(): """Test SSP computation on epochs.""" tempdir = _TempDir() event_id, tmin, tmax = 1, -0.2, 0.3 raw = read_raw_fif(raw_fname, preload=True) events = read_events(event_fname) bad_ch = 'MEG 2443' picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=[]) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1) write_proj(op.join(tempdir, 'test-proj.fif.gz'), projs) for p_fname in [proj_fname, proj_gz_fname, op.join(tempdir, 'test-proj.fif.gz')]: projs2 = read_proj(p_fname) assert len(projs) == len(projs2) for p1, p2 in zip(projs, projs2): assert p1['desc'] == p2['desc'] assert p1['data']['col_names'] == p2['data']['col_names'] assert p1['active'] == p2['active'] # compare with sign invariance p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0]) p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0]) if bad_ch in p1['data']['col_names']: bad = p1['data']['col_names'].index('MEG 2443') mask = np.ones(p1_data.size, dtype=np.bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 5) if p2['explained_var']: assert_array_almost_equal(p1['explained_var'], p2['explained_var']) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert nproj == 2 assert U.shape[1] == 2 # test that you can save them epochs.info['projs'] += projs evoked = epochs.average() evoked.save(op.join(tempdir, 'foo-ave.fif')) projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0) assert len(projs_evoked) == 2 # XXX : test something # test parallelization projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1, desc_prefix='foobar') assert all('foobar' in x['desc'] for x in projs) projs = activate_proj(projs) proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[]) assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16) # test warnings on bad filenames proj_badname = op.join(tempdir, 'test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-proj.fif'): write_proj(proj_badname, projs) with pytest.warns(RuntimeWarning, match='-proj.fif'): read_proj(proj_badname)
def test_compute_proj(): """Test SSP computation""" event_id, tmin, tmax = 1, -0.2, 0.3 raw = Raw(raw_fname, preload=True) events = read_events(event_fname) exclude = [] bad_ch = 'MEG 2443' picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=exclude) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False) evoked = epochs.average() projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1) write_proj('proj.fif.gz', projs) for p_fname in [proj_fname, proj_gz_fname, 'proj.fif.gz']: projs2 = read_proj(p_fname) assert_true(len(projs) == len(projs2)) for p1, p2 in zip(projs, projs2): assert_true(p1['desc'] == p2['desc']) assert_true(p1['data']['col_names'] == p2['data']['col_names']) assert_true(p1['active'] == p2['active']) # compare with sign invariance p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0]) p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0]) if bad_ch in p1['data']['col_names']: bad = p1['data']['col_names'].index('MEG 2443') mask = np.ones(p1_data.size, dtype=np.bool) mask[bad] = False p1_data = p1_data[:, mask] p2_data = p2_data[:, mask] corr = np.corrcoef(p1_data, p2_data)[0, 1] assert_array_almost_equal(corr, 1.0, 5) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them epochs.info['projs'] += projs evoked = epochs.average() evoked.save('foo.fif') projs = read_proj(proj_fname) projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0) # XXX : test something # test parallelization projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2) projs = activate_proj(projs) proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[]) assert_array_equal(proj, proj_par) # Test that the raw projectors work for ii in (1, 2, 4, 8, 12, 24): raw = Raw(raw_fname) projs = compute_proj_raw(raw, duration=ii-0.1, n_grad=1, n_mag=1, n_eeg=0) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them raw.info['projs'] += projs raw.save('foo_%d_raw.fif' % ii) # Test that purely continuous (no duration) raw projection works raw = Raw(raw_fname) projs = compute_proj_raw(raw, duration=None, n_grad=1, n_mag=1, n_eeg=0) # test that you can compute the projection matrix projs = activate_proj(projs) proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[]) assert_true(nproj == 2) assert_true(U.shape[1] == 2) # test that you can save them raw.info['projs'] += projs raw.save('foo_rawproj_continuous_raw.fif')