def test_morph_labels(): """Test morph_labels.""" # Just process the first 5 labels for speed parc_fsaverage = read_labels_from_annot('fsaverage', 'aparc', subjects_dir=subjects_dir)[:5] parc_sample = read_labels_from_annot('sample', 'aparc', subjects_dir=subjects_dir)[:5] parc_fssamp = morph_labels(parc_fsaverage, 'sample', subjects_dir=subjects_dir) for lf, ls, lfs in zip(parc_fsaverage, parc_sample, parc_fssamp): assert lf.hemi == ls.hemi == lfs.hemi assert lf.name == ls.name == lfs.name perc_1 = np.in1d(lfs.vertices, ls.vertices).mean() * 100 perc_2 = np.in1d(ls.vertices, lfs.vertices).mean() * 100 # Ideally this would be 100%, but we do not use the same algorithm # as FreeSurfer ... assert perc_1 > 92 assert perc_2 > 88 with pytest.raises(ValueError, match='wrong and fsaverage'): morph_labels(parc_fsaverage, 'sample', subjects_dir=subjects_dir, subject_from='wrong') with pytest.raises(RuntimeError, match='Number of surface vertices'): _load_vert_pos('sample', subjects_dir, 'white', 'lh', 1) for label in parc_fsaverage: label.subject = None with pytest.raises(ValueError, match='subject_from must be provided'): morph_labels(parc_fsaverage, 'sample', subjects_dir=subjects_dir)
def test_morph_labels(): """Test morph_labels.""" # Just process the first 5 labels for speed parc_fsaverage = read_labels_from_annot( 'fsaverage', 'aparc', subjects_dir=subjects_dir)[:5] parc_sample = read_labels_from_annot( 'sample', 'aparc', subjects_dir=subjects_dir)[:5] parc_fssamp = morph_labels( parc_fsaverage, 'sample', subjects_dir=subjects_dir) for lf, ls, lfs in zip(parc_fsaverage, parc_sample, parc_fssamp): assert lf.hemi == ls.hemi == lfs.hemi assert lf.name == ls.name == lfs.name perc_1 = np.in1d(lfs.vertices, ls.vertices).mean() * 100 perc_2 = np.in1d(ls.vertices, lfs.vertices).mean() * 100 # Ideally this would be 100%, but we do not use the same algorithm # as FreeSurfer ... assert perc_1 > 92 assert perc_2 > 88 with pytest.raises(ValueError, match='wrong and fsaverage'): morph_labels(parc_fsaverage, 'sample', subjects_dir=subjects_dir, subject_from='wrong') with pytest.raises(RuntimeError, match='Number of surface vertices'): _load_vert_pos('sample', subjects_dir, 'white', 'lh', 1) for label in parc_fsaverage: label.subject = None with pytest.raises(ValueError, match='subject_from must be provided'): morph_labels(parc_fsaverage, 'sample', subjects_dir=subjects_dir)
def mvgc_main(cond, i, d, normalize): meg = subjects[i] sub_to = MRI_sub[i][1:15] # morph labels from fsaverage to each subject morphed_labels = mne.morph_labels(SN_ROI, subject_to=data_path+sub_to, subject_from='fsaverage', subjects_dir=data_path) # read epochs epo_name = data_path + meg + 'block_'+cond+'_words_epochs-epo.fif' epochs_cond = mne.read_epochs(epo_name, preload=True) # crop epochs epochs = epochs_cond['words'].copy( ).crop(-.200, .900).resample(f_down_sampling) inv_fname_epoch = data_path + meg + 'InvOp_'+cond+'_EMEG-inv.fif' output_roi = mvgc_roi(epochs, inv_fname_epoch, morphed_labels, sub_to) for roi_x in C.rois_labels: for roi_y in C.rois_labels: mvgc_parallel(epochs, output_roi, roi_x, roi_y, d, i, cond, normalize)
def morph_labels_from_fsaverage(mri_sub): parcellations = ['aparc_sub', 'HCPMMP1_combined', 'HCPMMP1'] if not isfile(join(mri_sub.subjects_dir, 'fsaverage/label', 'lh.' + parcellations[0] + '.annot')): mne.datasets.fetch_hcp_mmp_parcellation(subjects_dir=mri_sub.subjects_dir, verbose=True) mne.datasets.fetch_aparc_sub_parcellation(subjects_dir=mri_sub.subjects_dir, verbose=True) else: print('You\'ve already downloaded the parcellations, splendid!') if not isfile(join(mri_sub.subjects_dir, mri_sub.name, 'label', 'lh.' + parcellations[0] + '.annot')): for pc in parcellations: labels = mne.read_labels_from_annot('fsaverage', pc, hemi='both') m_labels = mne.morph_labels(labels, mri_sub.name, 'fsaverage', mri_sub.subjects_dir, surf_name='pial') mne.write_labels_to_annot(m_labels, subject=mri_sub.name, parc=pc, subjects_dir=mri_sub.subjects_dir, overwrite=True) else: print(f'{parcellations} already exist')
def write_aparc_sub(subjid=None, subjects_dir=None): '''Check for fsaverage and aparc_sub and download Morph fsaverage aparc_sub labels to single subject data https://mne.tools/stable/auto_examples/visualization/plot_parcellation.html ''' mne.datasets.fetch_fsaverage(verbose='ERROR') #True requires TQDM mne.datasets.fetch_aparc_sub_parcellation(subjects_dir=subjects_dir, verbose='ERROR') sub_labels = mne.read_labels_from_annot('fsaverage', parc='aparc_sub', subjects_dir=subjects_dir) subject_labels = mne.morph_labels(sub_labels, subject_to=subjid, subjects_dir=subjects_dir) mne.write_labels_to_annot(subject_labels, subject=subjid, parc='aparc_sub', subjects_dir=subjects_dir, overwrite=True)
def tfr_roi(i, subjects, MRI_sub, roi, freq, n_cycles): X = np.zeros([2 * len(roi), len(freq), 600]) meg = subjects[i] sub_to = MRI_sub[i][1:15] print('Participant : ', i) # morphing ROIs from fsaverage to each individual morphed_labels = mne.morph_labels(roi, subject_to=sub_to, subject_from='fsaverage', subjects_dir=data_path) # Reading epochs for SD(n=0)/LD(n=1) for n in np.array([0, 1]): epo_name = data_path + meg + epochs_names[n] epochs = mne.read_epochs(epo_name, preload=True) epochs = epochs['words'].resample(500) # Reading inverse operator inv_fname = data_path + meg + inv_op_name[n] inv_op = read_inverse_operator(inv_fname) # Computing the power and phase lock value for each ROI for j in np.arange(0, len(morphed_labels)): print('Participant: ', i, '/ condition: ', n, '/ ROI: ', j) power, itc = source_induced_power(epochs, inverse_operator=inv_op, freqs=freq, label=morphed_labels[j], lambda2=C.lambda2, method='MNE', baseline=(-.300, 0), baseline_mode='percent', n_jobs=-1, n_cycles=n_cycles, zero_mean=True) # Averaging across vertices # Power X[i, n * len(morphed_labels) + j, :, :] = power.copy().mean(0) return X
def method_linear_transformation_main(cond, roi_y, roi_x, i, normalize): print('***Running sn_transformation_main...') meg = subjects[i] sub_to = mri_sub[i][1:15] # file_name to save the output file_name = os.path.expanduser('~') + \ '/my_semnet/json_files/transformation/trans_' + cond + '_x' + \ str(roi_x) + '-y' + str(roi_y) + '_sub_' + str(i) + '_' + \ str(t_down_sampling) + '_bl.json' # morph labels from fsaverage to each subject morphed_labels = mne.morph_labels(roi, subject_to=data_path + sub_to, subject_from='fsaverage', subjects_dir=data_path) # read,crop and resample epochs epoch_name = data_path + meg + 'block_' + cond + '_words_epochs-epo.fif' epoch_condition = mne.read_epochs(epoch_name, preload=True) epochs = epoch_condition['words'].copy().crop(-.200, .900) \ .resample(f_down_sampling) # inverse operator inverse_fname_epoch = data_path + meg + 'InvOp_' + cond + '_EMEG-inv.fif' print('***Running SN_transformation_io...') # prepares the patterns of roi_x and roi_y over time output = method_linear_transformation_io(epochs, inverse_fname_epoch, morphed_labels, sub_to, roi_x, roi_y) print('***Running SN_transformation...') # computes the connectivity (explained_variance) of the patterns of roi_x # and roi_y over time: roi_x patterns= output[0], roi_y patterns= output[1] gof = method_linear_transformation(output[0], output[1], normalize) with open(file_name, "wb") as fp: # Pickling pickle.dump(gof, fp) return gof
def _compute_rest_psd(subject, kind, freqs): ########################################################################### # Compute source space # ------------------- src = mne.setup_source_space(subject, spacing='oct6', add_dist=False, subjects_dir=cfg.mne_camcan_freesurfer_path) trans = trans_map[subject] bem = cfg.mne_camcan_freesurfer_path + \ "/%s/bem/%s-meg-bem.fif" % (subject, subject) ########################################################################### # Compute handle MEG data # ----------------------- fname = op.join(cfg.camcan_meg_raw_path, subject, kind, '%s_raw.fif' % kind) raw = mne.io.read_raw_fif(fname) mne.channels.fix_mag_coil_types(raw.info) if DEBUG: # raw.crop(0, 180) raw.crop(0, 120) else: raw.crop(0, 300) raw = _run_maxfilter(raw, subject, kind) _compute_add_ssp_exg(raw) # get empty room fname_er = op.join(cfg.camcan_meg_path, "emptyroom", subject, "emptyroom_%s.fif" % subject) raw_er = mne.io.read_raw_fif(fname_er) mne.channels.fix_mag_coil_types(raw.info) raw_er = _run_maxfilter(raw_er, subject, kind, coord_frame="meg") raw_er.info["projs"] += raw.info["projs"] cov = mne.compute_raw_covariance(raw_er, method='oas') # compute before band-pass of interest event_length = 5. event_overlap = 0. raw_length = raw.times[-1] events = mne.make_fixed_length_events(raw, duration=event_length, start=0, stop=raw_length - event_length) ####################################################################### # Compute the forward and inverse # ------------------------------- info = mne.Epochs(raw, events=events, tmin=0, tmax=event_length, baseline=None, reject=None, preload=False, decim=10).info fwd = mne.make_forward_solution(info, trans, src, bem) inv = make_inverse_operator(info, fwd, cov) del fwd ####################################################################### # Compute label time series and do envelope correlation # ----------------------------------------------------- mne_subjects_dir = "/storage/inria/agramfor/MNE-sample-data/subjects" labels = mne.read_labels_from_annot('fsaverage', 'aparc_sub', subjects_dir=mne_subjects_dir) labels = mne.morph_labels(labels, subject_from='fsaverage', subject_to=subject, subjects_dir=cfg.mne_camcan_freesurfer_path) labels = [ll for ll in labels if 'unknown' not in ll.name] for fmin, fmax, band in freqs: print(f"computing {subject}: {fmin} - {fmax} Hz") this_raw = raw.copy() this_raw.filter(fmin, fmax, n_jobs=1) reject = _get_global_reject_epochs(this_raw, decim=5) epochs = mne.Epochs(this_raw, events=events, tmin=0, tmax=event_length, baseline=None, reject=reject, preload=True, decim=5) if DEBUG: epochs = epochs[:3] data_cov = mne.compute_covariance(epochs, method='oas') stc = _apply_inverse_cov(cov=data_cov, info=epochs.info, nave=1, inverse_operator=inv, lambda2=1. / 9., pick_ori=None, method='MNE') assert np.all(stc.data < 0) label_power = mne.extract_label_time_course( stc, labels, inv['src'], mode="mean") # XXX signal should be positive out_fname = op.join( cfg.derivative_path, f'{subject + ("-debug" if DEBUG else "")}_' f'cov_mne_{band}.h5') mne.externals.h5io.write_hdf5(out_fname, { 'power': label_power, 'subject': subject, 'fmin': fmin, 'fmax': fmax, "band": band, 'label_names': [ll.name for ll in labels] }, overwrite=True)
def SN_functional_connectivity_betweenROIs_runs_BL(i, method): s = time.time() meg = subjects[i] sub_to = MRI_sub[i][1:15] # stc_SD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/con_labels_'+method+'_bl_bands_SD_sub'+str(i)+'.json' # stc_LD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/con_labels_'+method+'_bl_bands_LD_sub'+str(i)+'.json' stc_F_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bl_bands_F_sub' + str( i) + '.json' stc_M_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bl_bands_M_sub' + str( i) + '.json' stc_O_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bl_bands_O_sub' + str( i) + '.json' morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\ subject_from='fsaverage',subjects_dir=data_path) # Reading epochs epoch_fname_fruit = data_path + meg + 'block_fruit_epochs-epo.fif' epoch_fname_odour = data_path + meg + 'block_odour_epochs-epo.fif' epoch_fname_milk = data_path + meg + 'block_milk_epochs-epo.fif' epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif' epochs_fruit = mne.read_epochs(epoch_fname_fruit, preload=True) epochs_odour = mne.read_epochs(epoch_fname_odour, preload=True) epochs_milk = mne.read_epochs(epoch_fname_milk, preload=True) epochs_ld = mne.read_epochs(epo_name_LD, preload=True) epochs_f = mne.epochs.combine_event_ids( epochs_fruit, ['visual', 'hear', 'hand', 'neutral', 'emotional'], {'words': 15}) epochs_o = mne.epochs.combine_event_ids( epochs_odour, ['visual', 'hear', 'hand', 'neutral', 'emotional'], {'words': 15}) epochs_m = mne.epochs.combine_event_ids( epochs_milk, ['visual', 'hear', 'hand', 'neutral', 'emotional'], {'words': 15}) epochs_f = epochs_f['words'].copy().crop(-.200, 0).resample(500) epochs_o = epochs_o['words'].copy().crop(-.200, 0).resample(500) epochs_m = epochs_m['words'].copy().crop(-.200, 0).resample(500) epochs_LD = epochs_ld['words'].copy().crop(-.200, 0).resample(500) # Reading inverse operator inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif' inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif' inv_op_SD = read_inverse_operator(inv_fname_SD) inv_op_LD = read_inverse_operator(inv_fname_LD) stc_F = apply_inverse_epochs(epochs_f, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_O = apply_inverse_epochs(epochs_o, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_M = apply_inverse_epochs(epochs_m, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_LD = apply_inverse_epochs(epochs_LD, inv_op_LD, lambda2, method='MNE', pick_ori="normal", return_generator=False) src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] for k in np.arange(0, 6): # print('[i,win,k]: ',i,win,k) morphed_labels[k].name = C.rois_labels[k] for f in np.arange(0, len(C.con_freq_band) - 1): print('[i,k,f]: ', i, k, f) f_min = C.con_freq_band[f] f_max = C.con_freq_band[f + 1] print(f_min, f_max) labels_ts_f = mne.extract_label_time_course(stc_F, morphed_labels, \ src_SD, mode='mean_flip',return_generator=False) labels_ts_o = mne.extract_label_time_course(stc_O, morphed_labels, \ src_SD, mode='mean_flip',return_generator=False) labels_ts_m = mne.extract_label_time_course(stc_M, morphed_labels, \ src_SD, mode='mean_flip',return_generator=False) labels_ts_ld= mne.extract_label_time_course(stc_LD, morphed_labels, \ src_LD, mode='mean_flip',return_generator=False) con_F, freqs, times, n_epochs, n_tapers = spectral_connectivity( labels_ts_f, method=method, mode='fourier', sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_O, freqs, times, n_epochs, n_tapers = spectral_connectivity( labels_ts_o, method=method, mode='fourier', sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_M, freqs, times, n_epochs, n_tapers = spectral_connectivity( labels_ts_m, method=method, mode='fourier', sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) # con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity( # labels_ts_ld, method=method, mode='fourier', # sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) # con_SD=(con_F+ con_O+ con_M)/3 # con_labels_SD[f]= con_SD.reshape(6,6) # con_labels_LD[f]= con_LD.reshape(6,6) con_labels_F[f] = con_F.reshape(6, 6) con_labels_M[f] = con_M.reshape(6, 6) con_labels_O[f] = con_O.reshape(6, 6) # with open(stc_SD_file_name, "wb") as fp: #Pickling # pickle.dump(con_labels_SD, fp) # with open(stc_LD_file_name, "wb") as fp: #Pickling # pickle.dump(con_labels_LD, fp) with open(stc_F_file_name, "wb") as fp: #Pickling pickle.dump(con_labels_F, fp) with open(stc_M_file_name, "wb") as fp: #Pickling pickle.dump(con_labels_M, fp) with open(stc_O_file_name, "wb") as fp: #Pickling pickle.dump(con_labels_O, fp) e = time.time() print(e - s)
def SN_functional_connectivity_bands(i, method): s = time.time() meg = subjects[i] sub_to = MRI_sub[i][1:15] stc_SD_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/stc_' + method + '200_equalized_bands_SD_sub' + str( i) + '.json' stc_LD_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/stc_' + method + '200_equalized_bands_LD_sub' + str( i) + '.json' # stc_SD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/stc_'+method+'bl_bands_SD_sub'+str(i)+'.json' # stc_LD_file_name=os.path.expanduser('~') +'/my_semnet/json_files/connectivity/stc_'+method+'bl_bands_LD_sub'+str(i)+'.json' morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\ subject_from='fsaverage',subjects_dir=data_path) # Reading epochs epo_name_SD = data_path + meg + 'block_SD_words_epochs-epo.fif' epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif' epochs_sd = mne.read_epochs(epo_name_SD, preload=True) epochs_ld = mne.read_epochs(epo_name_LD, preload=True) epochs_SD = epochs_sd['words'].copy().resample(500) epochs_LD = epochs_ld['words'].copy().resample(500) equalize_epoch_counts([epochs_SD, epochs_LD]) # Reading inverse operator inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif' inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif' inv_op_SD = read_inverse_operator(inv_fname_SD) inv_op_LD = read_inverse_operator(inv_fname_LD) stc_sd = apply_inverse_epochs(epochs_SD, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_ld = apply_inverse_epochs(epochs_LD, inv_op_LD, lambda2, method='MNE', pick_ori="normal", return_generator=False) src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] # Construct indices to estimate connectivity between the label time course # and all source space time courses vertices_SD = [src_SD[j]['vertno'] for j in range(2)] n_signals_tot = 1 + len(vertices_SD[0]) + len(vertices_SD[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) morph_SD = mne.compute_source_morph(src=inv_op_SD['src'],\ subject_from=sub_to, subject_to=C.subject_to,\ spacing=C.spacing_morph, subjects_dir=C.data_path) morph_LD = mne.compute_source_morph(src= inv_op_LD['src'],\ subject_from=sub_to, subject_to=C.subject_to,\ spacing=C.spacing_morph, subjects_dir=C.data_path) for win in np.arange(0, len(C.con_time_window) - 1): print('[i,win]: ', i, win) t_min = C.con_time_window[win] t_max = C.con_time_window[win + 1] stc_SD = [] stc_LD = [] for n in np.arange(0, len(stc_sd)): stc_SD.append(stc_sd[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for n in np.arange(0, len(stc_ld)): stc_LD.append(stc_ld[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for k in np.arange(0, 6): print('[i,win,k]: ', i, win, k) morphed_labels[k].name = C.rois_labels[k] seed_ts_sd = mne.extract_label_time_course(stc_SD, morphed_labels[k], \ src_SD, mode='mean_flip',return_generator=False) seed_ts_ld = mne.extract_label_time_course(stc_LD, morphed_labels[k], \ src_LD, mode='mean_flip',return_generator=False) for f in np.arange(0, len(C.con_freq_band) - 1): print('[i,win,k,f]: ', i, win, k, f) f_min = C.con_freq_band[f] f_max = C.con_freq_band[f + 1] print(f_min, f_max) comb_ts_sd = zip(seed_ts_sd, stc_SD) comb_ts_ld = zip(seed_ts_ld, stc_LD) con_SD, freqs, times, n_epochs, n_tapers = spectral_connectivity( comb_ts_sd, method=method, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity( comb_ts_ld, method=method, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_stc_SD = mne.SourceEstimate(con_SD, vertices=vertices_SD,\ tmin=t_min*1e-3, tstep=2e-3,subject=sub_to) con_stc_LD = mne.SourceEstimate(con_LD, vertices=vertices_SD,\ tmin=t_min*1e-3, tstep=2e-3,subject=sub_to) stc_total_SD[win][k][f] = morph_SD.apply(con_stc_SD) stc_total_LD[win][k][f] = morph_LD.apply(con_stc_LD) with open(stc_SD_file_name, "wb") as fp: #Pickling pickle.dump(stc_total_SD, fp) with open(stc_LD_file_name, "wb") as fp: #Pickling pickle.dump(stc_total_LD, fp) e = time.time() print(e - s)
evoked_LD = epochs_LD.average().set_eeg_reference(ref_channels = \ 'average',projection=True) # Applying inverse solution to get sourse signals stc_sd = apply_inverse(evoked_SD, inv_op_SD,lambda2,method ='MNE', pick_ori=None) stc_ld = apply_inverse(evoked_LD, inv_op_LD,lambda2,method ='MNE', pick_ori=None) # stc_sd_corrected = stc_baseline_correction(stc_sd) # stc_ld_corrected = stc_baseline_correction(stc_ld) src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] morphed_labels = mne.morph_labels(SN_ROI,subject_to=sub_to,\ subject_from='fsaverage',subjects_dir=C.data_path) # label_ts_SD = mne.extract_label_time_course(stc_SD, morphed_labels,\ # src_SD, mode='mean_flip') # label_ts_LD = mne.extract_label_time_course(stc_LD, morphed_labels,\ # src_LD,mode='mean_flip') # X[i,0:6,:] = label_ts_SD[:,0:850] # Y[i,0:6,:] = label_ts_LD[:,0:850] for j in np.arange(0,6): morphed_labels[j].subject = sub_to label_vertices = stc_sd.in_label(morphed_labels[j]) stc_sd_corrected = stc_baseline_correction(label_vertices)
epochs = mne.Epochs( raw_use, events=events, tmin=0, tmax=tmax, baseline=None, reject=None, flat=None, preload=True, decim=decim, ) epochs.apply_hilbert(envelope=False) # Compute ROI time series and do envelope correlation inv = mne.minimum_norm.read_inverse_operator(inv_fname) these_rois = mne.morph_labels(all_rois, subject, "fsaverage", defaults.subjects_dir) these_rois = [ roi for roi in these_rois if not roi.name.startswith("unknown") ] stcs = apply_inverse_epochs( epochs, inv, lambda2=1.0 / 9.0, pick_ori="normal", return_generator=True, ) label_ts = mne.extract_label_time_course(stcs, these_rois, inv["src"], return_generator=True)
lambda2, method='MNE', pick_ori="normal") stc_ld = apply_inverse(evoked_LD, inv_op_LD, lambda2, method='MNE', pick_ori="normal") stc_SD = stc_baseline_correction(stc_sd, -300, 0) stc_LD = stc_baseline_correction(stc_ld, -300, 0) src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] # Average the source estimates within each label using sign-flips to reduce # signal cancellations, also here we return a generator morphed_labels = mne.morph_labels(labels,subject_to=data_path+sub_to,\ subject_from='fsaverage',subjects_dir=data_path) label_ts_SD = mne.extract_label_time_course(stc_SD, morphed_labels, src_SD,\ mode='mean_flip') label_ts_LD = mne.extract_label_time_course(stc_LD, morphed_labels, src_LD,\ mode='mean_flip') X_SD[i, :, :] = label_ts_SD X_LD[i, :, :] = label_ts_LD # for i in np.arange(0,len(labels)-5): my_colors = ['b', 'r', 'y', 'g', 'black', 'c'] labless = ['lATL', 'rATL', 'TG', 'IFG', 'AG', 'V'] t_value, p_value = stats.ttest_rel(X_SD, X_LD) y = np.arange(0, 600) fig, ax = plt.subplots(4, figsize=(10, 40))
def SN_effective_connectivity_bands(i, method): n_subjects = len(subjects) meg = subjects[i] sub_to = MRI_sub[i][1:15] print('Participant : ', i) stc_SD_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/stc_' + method + '200_bands_SD_sub' + str( i) + '.json' stc_LD_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/stc_' + method + '200_bands_LD_sub' + str( i) + '.json' morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\ subject_from='fsaverage',subjects_dir=data_path) # Reading epochs epo_name_SD = data_path + meg + 'block_SD_words_epochs-epo.fif' epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif' epochs_sd = mne.read_epochs(epo_name_SD, preload=True) epochs_ld = mne.read_epochs(epo_name_LD, preload=True) epochs_SD = epochs_sd['words'].copy().resample(500) epochs_LD = epochs_ld['words'].copy().resample(500) # Equalize trial counts to eliminate bias (which would otherwise be # introduced by the abs() performed below) equalize_epoch_counts([epochs_SD, epochs_LD]) # Reading inverse operator inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif' inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif' inv_op_SD = read_inverse_operator(inv_fname_SD) inv_op_LD = read_inverse_operator(inv_fname_LD) stc_sd = apply_inverse_epochs(epochs_SD, inv_op_SD, C.lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_ld = apply_inverse_epochs(epochs_LD, inv_op_LD, C.lambda2, method='MNE', pick_ori="normal", return_generator=False) times = epochs_SD.times stc_SD_t = [] stc_LD_t = [] src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] # Construct indices to estimate connectivity between the label time course # and all source space time courses vertices_SD = [src_SD[j]['vertno'] for j in range(2)] n_signals_tot = 1 + len(vertices_SD[0]) + len(vertices_SD[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) morph_SD = mne.compute_source_morph(src=inv_op_SD['src'],\ subject_from=sub_to, subject_to=C.subject_to,\ spacing=C.spacing_morph, subjects_dir=C.data_path) morph_LD = mne.compute_source_morph(src= inv_op_LD['src'],\ subject_from=sub_to, subject_to=C.subject_to,\ spacing=C.spacing_morph, subjects_dir=C.data_path) for n in np.arange(0, len(stc_sd)): stc_SD_t.append(stc_baseline_correction(stc_sd[n], times)) stc_LD_t.append(stc_baseline_correction(stc_ld[n], times)) for win in np.arange(0, len(C.con_time_window)): t_min = C.con_time_window[win] t_max = C.con_time_window[win] + C.con_time_window_len stc_SD = [] stc_LD = [] for n in np.arange(0, len(stc_sd)): stc_SD.append(stc_SD_t[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) stc_LD.append(stc_LD_t[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for k in np.arange(0, 6): print('Participant : ', i, '/ ROI: ', k) morphed_labels[k].name = C.rois_labels[k] seed_ts_sd = mne.extract_label_time_course(stc_SD, morphed_labels[k], \ src_SD, mode='mean_flip',return_generator=False) seed_ts_ld = mne.extract_label_time_course(stc_LD, morphed_labels[k], \ src_LD, mode='mean_flip',return_generator=False) for f in np.arange(0, len(C.con_freq_band_psi) - 1): f_min = C.con_freq_band_psi[f] f_max = C.con_freq_band_psi[f + 1] print('Participant : ' , i, '/ ROI: ',k,' win:', win,\ ' freq: ',f) comb_ts_sd = zip(seed_ts_sd, stc_SD) comb_ts_ld = zip(seed_ts_ld, stc_LD) psi_SD, freqs, times, n_epochs, _ = phase_slope_index( comb_ts_sd, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, n_jobs=15) psi_LD, freqs, times, n_epochs, _ = phase_slope_index( comb_ts_ld, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, n_jobs=15) psi_stc_SD = mne.SourceEstimate(psi_SD, vertices=vertices_SD,\ tmin=t_min*1e-3, tstep=2e-3,subject=sub_to) psi_stc_LD = mne.SourceEstimate(psi_LD, vertices=vertices_SD,\ tmin=t_min*1e-3, tstep=2e-3,subject=sub_to) stc_total_SD[win][k][f] = morph_SD.apply(psi_stc_SD) stc_total_LD[win][k][f] = morph_LD.apply(psi_stc_LD) with open(stc_SD_file_name, "wb") as fp: #Pickling pickle.dump(stc_total_SD, fp) with open(stc_LD_file_name, "wb") as fp: #Pickling pickle.dump(stc_total_LD, fp) e = time.time() print(e - s)
def SN_functional_connectivity_betweenROIs(i, method): s = time.time() meg = subjects[i] sub_to = MRI_sub[i][1:15] con_SD_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bands_SD_sub' + str( i) + '.json' con_LD_file_name = os.path.expanduser( '~' ) + '/my_semnet/json_files/connectivity/con_labels_' + method + '_bands_LD_sub' + str( i) + '.json' morphed_labels = mne.morph_labels(SN_ROI,subject_to=data_path+sub_to,\ subject_from='fsaverage',subjects_dir=data_path) # Reading epochs epo_name_SD = data_path + meg + 'block_SD_words_epochs-epo.fif' epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif' epochs_sd = mne.read_epochs(epo_name_SD, preload=True) epochs_ld = mne.read_epochs(epo_name_LD, preload=True) epochs_SD = epochs_sd['words'].copy().resample(500) epochs_LD = epochs_ld['words'].copy().resample(500) # Equalize trial counts to eliminate bias equalize_epoch_counts([epochs_SD, epochs_LD]) # Reading inverse operator inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif' inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif' inv_op_SD = read_inverse_operator(inv_fname_SD) inv_op_LD = read_inverse_operator(inv_fname_LD) stc_sd = apply_inverse_epochs(epochs_SD, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_ld = apply_inverse_epochs(epochs_LD, inv_op_LD, lambda2, method='MNE', pick_ori="normal", return_generator=False) times = epochs_SD.times stc_SD_t = [] stc_LD_t = [] src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] for n in np.arange(0, len(stc_sd)): stc_SD_t.append(stc_baseline_correction(stc_sd[n], times)) stc_LD_t.append(stc_baseline_correction(stc_ld[n], times)) for win in np.arange(0, len(C.con_time_window) - 1): print('[i,win]: ', i, win) t_min = C.con_time_window[win] t_max = C.con_time_window[win + 1] stc_SD = [] stc_LD = [] for n in np.arange(0, len(stc_sd)): stc_SD.append(stc_SD_t[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) stc_LD.append(stc_LD_t[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for k in np.arange(0, 6): # print('[i,win,k]: ',i,win,k) morphed_labels[k].name = C.rois_labels[k] labels_ts_sd = mne.extract_label_time_course(stc_SD, morphed_labels, \ src_SD, mode='mean_flip',return_generator=False) labels_ts_ld = mne.extract_label_time_course(stc_LD, morphed_labels, \ src_LD, mode='mean_flip',return_generator=False) for f in np.arange(0, len(C.con_freq_band) - 1): print('[i,win,k,f]: ', i, win, k, f) f_min = C.con_freq_band[f] f_max = C.con_freq_band[f + 1] print(f_min, f_max) con_SD, freqs, times, n_epochs, n_tapers = spectral_connectivity( labels_ts_sd, method=method, mode='fourier', sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity( labels_ts_ld, method=method, mode='fourier', sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_labels_SD[win][f] = con_SD.reshape(6, 6) con_labels_LD[win][f] = con_LD.reshape(6, 6) with open(con_SD_file_name, "wb") as fp: #Pickling pickle.dump(con_labels_SD, fp) with open(con_LD_file_name, "wb") as fp: #Pickling pickle.dump(con_labels_LD, fp) e = time.time() print(e - s)
# ROI_x=1 # ROI_y=0 s = time.time() fs = 1000 f_down_sampling = 100 # 100Hz, 20Hz t_down_sampling = fs / f_down_sampling # 10ms, 50ms i = 0 ROI_x, ROI_y = 0, 2 cond = 'fruit' normalize = True meg = subjects[i] sub_to = MRI_sub[i][1:15] # morph labels from fsaverage to each subject labels = mne.morph_labels(SN_ROI, subject_to=data_path + sub_to, subject_from='fsaverage', subjects_dir=data_path) # read epochs epo_name = data_path + meg + 'block_' + cond + '_words_epochs-epo.fif' epochs_cond = mne.read_epochs(epo_name, preload=True) # crop epochs epochs = epochs_cond['words'].copy().crop(-.200, .900).resample(f_down_sampling) # equalize trial counts to eliminate bias # equalize_epoch_counts([epochs_SD, epochs_LD]) inv_fname_epoch = data_path + meg + 'InvOp_' + cond + '_EMEG-inv.fif'
def SN_functional_connectivity_bands_runs(i, method, SN_ROI): s = time.time() meg = subjects[i] sub_to = MRI_sub[i][1:15] stc_F_file_name = os.path.expanduser( '~' ) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_F_bands_SD_sub' + str( i) + '.json' stc_O_file_name = os.path.expanduser( '~' ) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_O_bands_LD_sub' + str( i) + '.json' stc_M_file_name = os.path.expanduser( '~' ) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_M_bands_SD_sub' + str( i) + '.json' stc_SD_file_name = os.path.expanduser( '~' ) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_mean_bands_SD_sub' + str( i) + '.json' stc_LD_file_name = os.path.expanduser( '~' ) + '/old_semnet/my_semnet/json_files/connectivity/stc_' + method + '200_mean_bands_LD_sub' + str( i) + '.json' morphed_labels = mne.morph_labels(SN_ROI, subject_to=sub_to, subject_from='fsaverage', subjects_dir=data_path) # Reading epochs # Reading epochs epo_name_LD = data_path + meg + 'block_LD_words_epochs-epo.fif' epochs_ld = mne.read_epochs(epo_name_LD, preload=True) epochs_LD = epochs_ld['words'].copy().resample(500) epoch_fname_fruit = data_path + meg + 'block_fruit_epochs-epo.fif' epoch_fname_odour = data_path + meg + 'block_odour_epochs-epo.fif' epoch_fname_milk = data_path + meg + 'block_milk_epochs-epo.fif' epochs_fruit = mne.read_epochs(epoch_fname_fruit, preload=True) epochs_odour = mne.read_epochs(epoch_fname_odour, preload=True) epochs_milk = mne.read_epochs(epoch_fname_milk, preload=True) epochs_f = mne.epochs.combine_event_ids( epochs_fruit, ['visual', 'hear', 'hand', 'neutral', 'emotional'], {'words': 15}) epochs_o = mne.epochs.combine_event_ids( epochs_odour, ['visual', 'hear', 'hand', 'neutral', 'emotional'], {'words': 15}) epochs_m = mne.epochs.combine_event_ids( epochs_milk, ['visual', 'hear', 'hand', 'neutral', 'emotional'], {'words': 15}) epochs_f = epochs_f['words'].copy().resample(500) epochs_o = epochs_o['words'].copy().resample(500) epochs_m = epochs_m['words'].copy().resample(500) # Reading inverse operator inv_fname_SD = data_path + meg + 'InvOp_SD_EMEG-inv.fif' inv_fname_LD = data_path + meg + 'InvOp_LD_EMEG-inv.fif' inv_op_SD = read_inverse_operator(inv_fname_SD) inv_op_LD = read_inverse_operator(inv_fname_LD) stc_f = apply_inverse_epochs(epochs_f, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_o = apply_inverse_epochs(epochs_o, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_m = apply_inverse_epochs(epochs_m, inv_op_SD, lambda2, method='MNE', pick_ori="normal", return_generator=False) stc_ld = apply_inverse_epochs(epochs_LD, inv_op_LD, lambda2, method='MNE', pick_ori="normal", return_generator=False) src_SD = inv_op_SD['src'] src_LD = inv_op_LD['src'] # Construct indices to estimate connectivity between the label time course # and all source space time courses vertices_SD = [src_SD[j]['vertno'] for j in range(2)] n_signals_tot = 1 + len(vertices_SD[0]) + len(vertices_SD[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) morph_SD = mne.compute_source_morph(src=inv_op_SD['src'], subject_from=sub_to, subject_to=C.subject_to, spacing=C.spacing_morph, subjects_dir=C.data_path) morph_LD = mne.compute_source_morph(src=inv_op_LD['src'], subject_from=sub_to, subject_to=C.subject_to, spacing=C.spacing_morph, subjects_dir=C.data_path) for win in np.arange(0, len(C.con_time_window) - 1): print('[i,win]: ', i, win) t_min = C.con_time_window[win] t_max = C.con_time_window[win + 1] stc_F = [] stc_O = [] stc_M = [] stc_LD = [] for n in np.arange(0, len(stc_f)): stc_F.append(stc_f[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for n in np.arange(0, len(stc_o)): stc_O.append(stc_o[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for n in np.arange(0, len(stc_m)): stc_M.append(stc_m[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for n in np.arange(0, len(stc_ld)): stc_LD.append(stc_ld[n].copy().crop(t_min * 1e-3, t_max * 1e-3)) for k in np.arange(0, 6): print('[i,win,k]: ', i, win, k) morphed_labels[k].name = C.rois_labels[k] seed_ts_f = mne.extract_label_time_course(stc_F, morphed_labels[k], src_SD, mode='mean_flip', return_generator=False) seed_ts_o = mne.extract_label_time_course(stc_O, morphed_labels[k], src_SD, mode='mean_flip', return_generator=False) seed_ts_m = mne.extract_label_time_course(stc_M, morphed_labels[k], src_SD, mode='mean_flip', return_generator=False) seed_ts_ld = mne.extract_label_time_course(stc_LD, morphed_labels[k], src_LD, mode='mean_flip', return_generator=False) for f in np.arange(0, len(C.con_freq_band) - 1): print('[i,win,k,f]: ', i, win, k, f) f_min = C.con_freq_band[f] f_max = C.con_freq_band[f + 1] print(f_min, f_max) comb_ts_f = zip(seed_ts_f, stc_F) comb_ts_o = zip(seed_ts_o, stc_O) comb_ts_m = zip(seed_ts_m, stc_M) comb_ts_ld = zip(seed_ts_ld, stc_LD) con_F, freqs, times, n_epochs, n_tapers = spectral_connectivity( comb_ts_f, method=method, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_O, freqs, times, n_epochs, n_tapers = spectral_connectivity( comb_ts_o, method=method, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_M, freqs, times, n_epochs, n_tapers = spectral_connectivity( comb_ts_m, method=method, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_LD, freqs, times, n_epochs, n_tapers = spectral_connectivity( comb_ts_ld, method=method, mode='fourier', indices=indices, sfreq=500, fmin=f_min, fmax=f_max, faverage=True, n_jobs=10) con_SD = (con_F + con_O + con_M) / 3 con_stc_F = mne.SourceEstimate(con_F, vertices=vertices_SD, tmin=t_min * 1e-3, tstep=2e-3, subject=sub_to) con_stc_O = mne.SourceEstimate(con_O, vertices=vertices_SD, tmin=t_min * 1e-3, tstep=2e-3, subject=sub_to) con_stc_M = mne.SourceEstimate(con_M, vertices=vertices_SD, tmin=t_min * 1e-3, tstep=2e-3, subject=sub_to) con_stc_SD = mne.SourceEstimate(con_SD, vertices=vertices_SD, tmin=t_min * 1e-3, tstep=2e-3, subject=sub_to) con_stc_LD = mne.SourceEstimate(con_LD, vertices=vertices_SD, tmin=t_min * 1e-3, tstep=2e-3, subject=sub_to) stc_total_F[win][k][f] = morph_SD.apply(con_stc_F) stc_total_O[win][k][f] = morph_SD.apply(con_stc_O) stc_total_M[win][k][f] = morph_SD.apply(con_stc_M) stc_total_SD[win][k][f] = morph_SD.apply(con_stc_SD) stc_total_LD[win][k][f] = morph_LD.apply(con_stc_LD) # with open(stc_F_file_name, "wb") as fp: #Pickling # pickle.dump(stc_total_F, fp) # with open(stc_O_file_name, "wb") as fp: #Pickling # pickle.dump(stc_total_O, fp) # with open(stc_M_file_name, "wb") as fp: #Pickling # pickle.dump(stc_total_M, fp) # with open(stc_SD_file_name, "wb") as fp: #Pickling # pickle.dump(stc_total_SD, fp) with open(stc_LD_file_name, "wb") as fp: # Pickling pickle.dump(stc_total_LD, fp) e = time.time() print(e - s)
cov = mne.read_cov("{}empty-cov.fif".format(proc_dir)) fs_labels = mne.read_labels_from_annot("fsaverage", "RegionGrowing_70", subjects_dir=subjects_dir) for sub in subjs: fwd_name = "{dir}nc_{sub}_{sp}-fwd.fif".format(dir=proc_dir, sub=sub, sp=spacing) fwd = mne.read_forward_solution(fwd_name) src_name = "{dir}{sub}_{sp}-src.fif".format(dir=proc_dir, sub=sub, sp=spacing) src = mne.read_source_spaces(src_name) labels = mne.morph_labels(fs_labels, sub_key[sub], subject_from="fsaverage", subjects_dir=subjects_dir) for run in runs: if run == "rest": epo_name = "{dir}nc_{sub}_{run}_hand-epo.fif".format(dir=proc_dir, sub=sub, run=run) epo = mne.read_epochs(epo_name) else: epos = [] for wav_idx, wav_name in enumerate(wavs): epo_name = "{dir}nc_{sub}_{run}_{wav}_hand-epo.fif".format( dir=proc_dir, sub=sub, run=run, wav=wav_name) temp_epo = mne.read_epochs(epo_name) temp_epo.interpolate_bads() epos.append(temp_epo)
def make_dataset_from_sample(): # assign paths data_path = mne.datasets.sample.data_path() subjects_dir = os.path.join(data_path, 'subjects') mne.datasets.fetch_hcp_mmp_parcellation(subjects_dir=subjects_dir, verbose=True) # get parcels and remove corpus callosum parcels = read_labels_from_annot('fsaverage', 'HCPMMP1_combined', 'both', subjects_dir=subjects_dir) # corpus callosum labels aparc_file_lh = os.path.join(subjects_dir, 'fsaverage', "label", 'lh.aparc.a2009s.annot') aparc_file_rh = os.path.join(subjects_dir, 'fsaverage', "label", 'rh.aparc.a2009s.annot') labels_corpus_lh = read_labels_from_annot(subject='fsaverage', annot_fname=aparc_file_lh, hemi='lh', subjects_dir=subjects_dir) labels_corpus_rh = read_labels_from_annot(subject='fsaverage', annot_fname=aparc_file_rh, hemi='rh', subjects_dir=subjects_dir) assert labels_corpus_lh[-1].name[:7] == 'Unknown' # corpus callosum assert labels_corpus_rh[-1].name[:7] == 'Unknown' # corpus callosum corpus_callosum = [labels_corpus_lh[-1], labels_corpus_rh[-1]] # remove from parcels all the vertices from corpus callosum to_remove = [] for idx, parcel in enumerate(parcels): if parcel.hemi == 'lh': cc_free = set(parcel.vertices) - set(corpus_callosum[0].vertices) elif parcel.hemi == 'rh': cc_free = set(parcel.vertices) - set(corpus_callosum[1].vertices) parcel.vertices = np.array(list(cc_free)) if len(parcel.vertices) == 0: to_remove.append(idx) [parcels.pop(idc) for idc in to_remove[::-1]] # morph from fsaverage to sample parcels = mne.morph_labels(parcels, 'sample', subjects_dir=subjects_dir) raw_fname = os.path.join(data_path, 'MEG', 'sample', 'sample_audvis_raw.fif') fwd_fname = os.path.join(data_path, 'MEG', 'sample', 'sample_audvis-meg-eeg-oct-6-fwd.fif') assert os.path.exists(raw_fname) assert os.path.exists(fwd_fname) info = mne.io.read_info(raw_fname) sel = mne.pick_types(info, meg='grad', eeg=False, stim=True, exclude=[]) sel_data = mne.pick_types(info, meg='grad', eeg=False, stim=False, exclude=[]) info_data = mne.pick_info(info, sel_data) info = mne.pick_info(info, sel) tstep = 1. / info['sfreq'] # read forward solution fwd = mne.read_forward_solution(fwd_fname) src = fwd['src'] fwd = mne.convert_forward_solution(fwd, force_fixed=True) fwd = mne.pick_channels_forward(fwd, include=info_data['ch_names'], ordered=True) lead_field = fwd['sol']['data'] rng = np.random.RandomState(42) n_samples = 3 signal_len = 20 n_events = 50 n_events = 2 add_noise = False source_time_series = np.sin( 2. * np.pi * 18. * np.arange(signal_len) * tstep) * 10e-9 events = np.zeros((n_events, 3), dtype=int) events[:, 0] = signal_len * len(parcels) + 200 * np.arange(n_events) events[:, 2] = 1 # All events have the sample id. signal_list = [] true_idx = np.empty(n_samples, dtype=np.int16) for idx, source in enumerate(range(n_samples)): idx_source = rng.choice(np.arange(len(parcels))) true_idx[idx] = idx_source source = parcels[idx_source] location = 'center' # Use the center of the region as a seed. extent = 0. source = mne.label.select_sources('sample', source, location=location, extent=extent, subjects_dir=subjects_dir) source_simulator = mne.simulation.SourceSimulator(src, tstep=tstep) source_simulator.add_data(source, source_time_series, events) raw = mne.simulation.simulate_raw(info, source_simulator, forward=fwd) if add_noise: cov = mne.make_ad_hoc_cov(raw.info) mne.simulation.add_noise(raw, cov, iir_filter=[0.2, -0.2, 0.02]) evoked = mne.Epochs(raw, events, tmax=0.3).average() data = evoked.data[:, np.argmax((evoked.data**2).sum(axis=0))] signal_list.append(data) signal_list = np.array(signal_list) # data_labels = [f'e{idx + 1}' for idx in range(signal_list.shape[1])] data_labels = evoked.ch_names X = pd.DataFrame(signal_list, columns=list(data_labels)) X['subject_id'] = 0 X['subject'] = '0' y = np.zeros((n_samples, len(parcels)), dtype=int) y[np.arange(n_samples), true_idx] = 1 parcel_vertices = {} for idx, parcel in enumerate(parcels, 1): parcel_name = str(idx) + parcel.name[-3:] parcel_vertices[parcel_name] = parcel.vertices parcel.name = parcel_name parcel_indices_lh = np.zeros(len(fwd['src'][0]['inuse']), dtype=int) parcel_indices_rh = np.zeros(len(fwd['src'][1]['inuse']), dtype=int) for label_name, label_idx in parcel_vertices.items(): label_id = int(label_name[:-3]) if '-lh' in label_name: parcel_indices_lh[label_idx] = label_id else: parcel_indices_rh[label_idx] = label_id # Make sure label numbers different for each hemisphere parcel_indices = np.concatenate((parcel_indices_lh, parcel_indices_rh), axis=0) # Now pick vertices that are actually used in the forward inuse = np.concatenate((fwd['src'][0]['inuse'], fwd['src'][1]['inuse']), axis=0) parcel_indices = parcel_indices[np.where(inuse)[0]] assert len(parcel_indices) == lead_field.shape[1] lead_field = lead_field[:, parcel_indices != 0] parcel_indices = parcel_indices[parcel_indices != 0] return X, y, [lead_field], [parcel_indices]
def _compute_power_envelopes(subject, kind, freqs): ########################################################################### # Compute source space # ------------------- src = mne.setup_source_space(subject, spacing='oct6', add_dist=False, subjects_dir=cfg.mne_camcan_freesurfer_path) trans = trans_map[subject] bem = cfg.mne_camcan_freesurfer_path + \ "/%s/bem/%s-meg-bem.fif" % (subject, subject) ########################################################################### # Compute handle MEG data # ----------------------- fname = op.join(cfg.camcan_meg_raw_path, subject, kind, '%s_raw.fif' % kind) raw = mne.io.read_raw_fif(fname) mne.channels.fix_mag_coil_types(raw.info) if DEBUG: # raw.crop(0, 180) raw.crop(0, 120) else: raw.crop(0, 300) raw = _run_maxfilter(raw, subject, kind) _compute_add_ssp_exg(raw) # get empty room fname_er = op.join(cfg.camcan_meg_path, "emptyroom", subject, "emptyroom_%s.fif" % subject) raw_er = mne.io.read_raw_fif(fname_er) mne.channels.fix_mag_coil_types(raw.info) raw_er = _run_maxfilter(raw_er, subject, kind, coord_frame="meg") raw_er.info["projs"] += raw.info["projs"] cov = mne.compute_raw_covariance(raw_er, method='oas') # compute before band-pass of interest event_length = 5. event_overlap = 0. raw_length = raw.times[-1] events = mne.make_fixed_length_events(raw, duration=event_length, start=0, stop=raw_length - event_length) ####################################################################### # Compute the forward and inverse # ------------------------------- info = mne.Epochs(raw, events=events, tmin=0, tmax=event_length, baseline=None, reject=None, preload=False, decim=10).info fwd = mne.make_forward_solution(info, trans, src, bem) inv = make_inverse_operator(info, fwd, cov) del fwd ####################################################################### # Compute label time series and do envelope correlation # ----------------------------------------------------- mne_subjects_dir = "/storage/inria/agramfor/MNE-sample-data/subjects" labels = mne.read_labels_from_annot('fsaverage', 'aparc_sub', subjects_dir=mne_subjects_dir) labels = mne.morph_labels(labels, subject_from='fsaverage', subject_to=subject, subjects_dir=cfg.mne_camcan_freesurfer_path) labels = [ll for ll in labels if 'unknown' not in ll.name] results = dict() for fmin, fmax, band in freqs: print(f"computing {subject}: {fmin} - {fmax} Hz") this_raw = raw.copy() this_raw.filter(fmin, fmax, n_jobs=1) reject = _get_global_reject_epochs(this_raw, decim=5) this_raw.apply_hilbert(envelope=False) epochs = mne.Epochs(this_raw, events=events, tmin=0, tmax=event_length, baseline=None, reject=reject, preload=True, decim=5) if DEBUG: epochs = epochs[:3] result = { 'subject': subject, 'fmin': fmin, 'fmax': fmax, 'band': band, 'label_names': [ll.name for ll in labels] } stcs = apply_inverse_epochs(epochs, inv, lambda2=1. / 9., pick_ori='normal', method='MNE', return_generator=True) label_ts = np.concatenate(mne.extract_label_time_course( stcs, labels, inv['src'], mode="pca_flip", return_generator=False), axis=-1) result['cov'], _ = oas(np.abs(label_ts).T, assume_centered=False) for orth in ("pairwise", False): corr = envelope_correlation(label_ts[np.newaxis], combine="mean", orthogonalize=orth) result[f"corr{'_orth' if orth else ''}"] = corr[np.triu_indices( len(corr))] results[band] = result if False: # failsafe mode with intermediate steps written out out_fname = op.join( cfg.derivative_path, f'{subject + ("-debug" if DEBUG else "")}_' f'power_envelopes_{band}.h5') mne.externals.h5io.write_hdf5(out_fname, result, overwrite=True) return results
'CC120008', 'CC110033', 'CC110101', 'CC110187', 'CC110411', 'CC110606', 'CC112141', 'CC120049', 'CC120061', 'CC120120' ] # for train else: data_dir = 'data/test' n_samples = 500 subject_names = [ 'CC120182', 'CC120264', 'CC120309', 'CC120313', 'CC120319', 'CC120376', 'CC120469', 'CC120550', 'CC120218', 'CC120166' ] for subject in subject_names: subjects_dir = config.get_subjects_dir_subj(subject) # morph fsaverage labels to the subject we are using parcels_subject = mne.morph_labels(parcels_fsaverage, subject, 'fsaverage', subjects_dir, 'white') # PATHS # make all the paths len_parcels = len(parcels_subject) case_specific = (signal_type + '_' + subject + '_' + str(len_parcels) + '_' + str(n_sources_max)) data_dir_specific = os.path.join(data_dir, 'data_' + case_specific) # check if the data directory for the subject already exists if not os.path.isdir(data_dir): os.mkdir(data_dir) if os.path.isdir(data_dir_specific) and not make_new: # path exists, skip it