def using_preprocessed_epochs(all_events, eventss, baseline, hcp_params): from collections import defaultdict evokeds_from_epochs_hcp = defaultdict(list) all_epochs_hcp = list() for run_index, events in zip([0, 1], all_events): unique_subset = np.nonzero(np.r_[1, np.diff(events[:, 0])])[0] epochs_hcp = hcp.read_epochs(run_index=run_index, **hcp_params) # subset epochs, add events and id subset = np.in1d(events[:, 2], list(eventss.values())) epochs_hcp = epochs_hcp[unique_subset][subset] epochs_hcp.events[:, 2] = events[subset, 2] epochs_hcp.event_id = eventss break # all_epochs_hcp.append(epochs_hcp) for event_name, event_id in eventss.items(): evoked = epochs_hcp[event_name].average() evoked.baseline = baseline evoked.apply_baseline() evoked = preproc.interpolate_missing(evoked, **hcp_params) evokeds_from_epochs_hcp[event_name].append(evoked) return epochs_hcp, evokeds_from_epochs_hcp
def using_preprocessed_epochs(all_events, events_ids): from collections import defaultdict evokeds_from_epochs_hcp = defaultdict(list) all_epochs_hcp = list() for run_index, events in zip([0, 1], all_events): unique_subset = np.nonzero(np.r_[1, np.diff(events[:, 0])])[0] # use diff to find first unique events # this_events = events[unique_subset] epochs_hcp = hcp.read_epochs(run_index=run_index, **hcp_params) # subset epochs, add events and id subset = np.in1d(events[:, 2], list(events_ids.values())) epochs_hcp = epochs_hcp[unique_subset][subset] epochs_hcp.events[:, 2] = events[subset, 2] epochs_hcp.event_id = events_ids break # all_epochs_hcp.append(epochs_hcp) # del epochs_hcp # These epochs have different channels. # We use a designated function to re-apply the channels and interpolate # them. for event_name, event_id in events_ids.items(): evoked = epochs_hcp[event_name].average() evoked.baseline = baseline evoked.apply_baseline() evoked = preproc.interpolate_missing(evoked, **hcp_params) evokeds_from_epochs_hcp[event_name].append(evoked) return epochs_hcp, evokeds_from_epochs_hcp
def test_interpolate_missing(): """Test interpolation of missing channels.""" data_type = 'task_working_memory' raw = hcp.read_raw(data_type='task_working_memory', run_index=0, **hcp_params) raw.load_data() n_chan = len(raw.ch_names) raw.drop_channels(['A1']) assert_equal(len(raw.ch_names), n_chan - 1) raw = interpolate_missing(raw, data_type=data_type, **hcp_params) assert_equal(len(raw.ch_names), n_chan) evoked = hcp.read_evokeds(data_type=data_type, **hcp_params)[0] assert_equal(len(evoked.ch_names), 243) evoked_int = interpolate_missing(evoked, data_type=data_type, **hcp_params) assert_equal(len(evoked_int.ch_names), 248)
def official_ERF(): hcp_evokeds = hcp.read_evokeds(onset='stim', **hcp_params) for ev in hcp_evokeds: if not ev.comment == 'Wrkmem_LM-TIM-face_BT-diff_MODE-mag': continue # Once more we add and interpolate missing channels evoked_hcp = preproc.interpolate_missing(ev, **hcp_params) return evoked_hcp
# and set the IO params storage_dir = op.expanduser('~') hcp_params = dict(hcp_path=op.join(storage_dir, 'mne-hcp-data', 'HCP'), subject='105923', data_type='task_working_memory') ############################################################################## # we take the some evoked and create an interpolated copy evoked = hcp.read_evokeds(**hcp_params)[0] # The HCP pipelines don't interpolate missing channels print('%i channels out of 248 expected' % len(evoked.ch_names)) evoked_interpolated = preproc.interpolate_missing(evoked, **hcp_params) ############################################################################## # Let's visualize what has changed! # we calculate the difference ... bads = set(evoked_interpolated.ch_names) - set(evoked.ch_names) print(bads) # ... and mark the respective channels as bad ... evoked_interpolated.info['bads'] += list(bads) # ... such that MNE is displaying the interpolated time series in red ... evoked_interpolated.plot(exclude=[])
def reprocess_the_data_from_scratch(all_events, event_id, tmin, tmax, baseline, decim): # now we can go ahead evokeds = list() all_epochs = list() for run_index, events in zip([0, 1], all_events): raw = hcp.read_raw(run_index=run_index, **hcp_params) raw.load_data() # apply ref channel correction and drop ref channels # preproc.apply_ref_correction(raw) annots = hcp.read_annot(run_index=run_index, **hcp_params) # construct MNE annotations bad_seg = (annots['segments']['all']) / raw.info['sfreq'] annotations = mne.Annotations(bad_seg[:, 0], (bad_seg[:, 1] - bad_seg[:, 0]), description='bad') raw.annotations = annotations raw.info['bads'].extend(annots['channels']['all']) raw.pick_types(meg=True, ref_meg=False) # Note: MNE complains on Python 2.7 raw.filter(0.50, None, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) raw.filter(None, 60, method='iir', iir_params=dict(order=4, ftype='butter'), n_jobs=1) # read ICA and remove EOG ECG # note that the HCP ICA assumes that bad channels have already been removed ica_mat = hcp.read_ica(run_index=run_index, **hcp_params) # We will select the brain ICs only exclude = annots['ica']['ecg_eog_ic'] preproc.apply_ica_hcp(raw, ica_mat=ica_mat, exclude=exclude) # now we can epoch events = np.sort(events, 0) epochs = mne.Epochs(raw, events=events[events[:, 2] == 1], event_id=event_id, tmin=tmin, tmax=tmax, reject=None, baseline=baseline, decim=decim, preload=True) all_epochs.append(epochs) evoked = epochs.average() # now we need to add back out channels for comparison across runs. evoked = preproc.interpolate_missing(evoked, **hcp_params) evokeds.append(evoked) return all_epochs, evokeds
ica_mat = hcp.read_ica(run_index=run_index, **hcp_params) # We will select the brain ICs only exclude = annots['ica']['ecg_eog_ic'] preproc.apply_ica_hcp(raw, ica_mat=ica_mat, exclude=exclude) # now we can epoch events = np.sort(events, 0) epochs = mne.Epochs(raw, events=events[events[:, 2] == 1], event_id=event_id, tmin=tmin, tmax=tmax, reject=None, baseline=baseline, decim=decim, preload=True) evoked = epochs.average() # now we need to add back out channels for comparison across runs. evoked = preproc.interpolate_missing(evoked, **hcp_params) evokeds.append(evoked) del epochs, raw ############################################################################## # Now we can compute the same ERF based on the preprocessed epochs # # These are obtained from the 'tmegpreproc' pipeline. # Things are pythonized and simplified however, so evokeds_from_epochs_hcp = list() for run_index, events in zip([0, 1], all_events): unique_subset = np.nonzero(np.r_[1, np.diff(events[:, 0])])[0] # use diff to find first unique events
events = np.c_[trial_info['stim']['codes'][:, 6] - 1, # time sample np.zeros(len(trial_info['stim']['codes'])), trial_info['stim']['codes'][:, 3] # event codes ].astype(int) # for some reason in the HCP data the time events may not always be unique unique_subset = np.nonzero(np.r_[1, np.diff(events[:, 0])])[0] events = events[unique_subset] # use diff to find first unique events subset = np.in1d(events[:, 2], event_id.values()) epochs_hcp = hcp.read_epochs(**hcp_params).decimate(decim) epochs_hcp = epochs_hcp[unique_subset][subset] epochs_hcp.events[:, 2] = events[subset, 2] epochs_hcp.event_id = event_id epochs_hcp.crop(-0.1, 0.5) epochs.append(preproc.interpolate_missing(epochs_hcp, **hcp_params)) epochs = mne.concatenate_epochs(epochs) del epochs_hcp ############################################################################## # Now we can proceed as shown in the MNE-Python decoding tutorials y = LabelBinarizer().fit_transform(epochs.events[:, 2]).ravel() cv = StratifiedKFold(y=y) # do a stratified cross-validation gat = GeneralizationAcrossTime(predict_mode='cross-validation', n_jobs=1, cv=cv, scorer=roc_auc_score)