def test_psi(): """Test Phase Slope Index (PSI) estimation""" psi, freqs, times, n_epochs, n_tapers = phase_slope_index(data, mode='fourier', sfreq=sfreq) assert_true(psi[1, 0, 0] < 0) assert_true(psi[2, 0, 0] > 0) indices = (np.array([0]), np.array([1])) psi_2, freqs, times, n_epochs, n_tapers = phase_slope_index( data, mode='fourier', sfreq=sfreq, indices=indices) # the measure is symmetric (sign flip) assert_array_almost_equal(psi_2[0, 0], -psi[1, 0, 0]) cwt_freqs = np.arange(5., 20, 0.5) psi_cwt, freqs, times, n_epochs, n_tapers = phase_slope_index( data, mode='cwt_morlet', sfreq=sfreq, cwt_frequencies=cwt_freqs, indices=indices) assert_true(np.all(psi_cwt > 0)) assert_true(psi_cwt.shape[-1] == n_times)
def test_psi(): """Test Phase Slope Index (PSI) estimation""" sfreq = 50. n_signals = 3 n_epochs = 10 n_times = 500 rng = np.random.RandomState(42) data = rng.randn(n_epochs, n_signals, n_times) # simulate time shifts for i in range(n_epochs): data[i, 1, 10:] = data[i, 0, :-10] # signal 0 is ahead data[i, 2, :-10] = data[i, 0, 10:] # signal 2 is ahead psi, freqs, times, n_epochs, n_tapers = phase_slope_index(data, mode='fourier', sfreq=sfreq) assert_true(psi[1, 0, 0] < 0) assert_true(psi[2, 0, 0] > 0) indices = (np.array([0]), np.array([1])) psi_2, freqs, times, n_epochs, n_tapers = phase_slope_index(data, mode='fourier', sfreq=sfreq, indices=indices) # the measure is symmetric (sign flip) assert_array_almost_equal(psi_2[0, 0], -psi[1, 0, 0]) cwt_freqs = np.arange(5., 20, 0.5) psi_cwt, freqs, times, n_epochs, n_tapers = phase_slope_index(data, mode='cwt_morlet', sfreq=sfreq, cwt_frequencies=cwt_freqs, indices=indices) assert_true(np.all(psi_cwt > 0)) assert_true(psi_cwt.shape[-1] == n_times)
def test_psi(): """Test Phase Slope Index (PSI) estimation""" psi, freqs, times, n_epochs, n_tapers = phase_slope_index(data, mode="fourier", sfreq=sfreq) assert_true(psi[1, 0, 0] < 0) assert_true(psi[2, 0, 0] > 0) indices = (np.array([0]), np.array([1])) psi_2, freqs, times, n_epochs, n_tapers = phase_slope_index(data, mode="fourier", sfreq=sfreq, indices=indices) # the measure is symmetric (sign flip) assert_array_almost_equal(psi_2[0, 0], -psi[1, 0, 0]) cwt_freqs = np.arange(5.0, 20, 0.5) psi_cwt, freqs, times, n_epochs, n_tapers = phase_slope_index( data, mode="cwt_morlet", sfreq=sfreq, cwt_frequencies=cwt_freqs, indices=indices ) assert_true(np.all(psi_cwt > 0)) assert_true(psi_cwt.shape[-1] == n_times)
def get_psi_feats(df, sfreq=125., band='alpha'): electrodes = df.columns df = df.copy() alpha_filter = get_filter(sfreq=sfreq, band=band) df = df[electrodes] for el in electrodes: df[el] = np.convolve(alpha_filter, df[el], 'same') vals = df.values vals = vals.transpose(1, 0) vals = vals[None, :, :] psi, freqs, times, n_epochs, _ = phase_slope_index(vals, sfreq=sfreq, verbose=False) d = {} for i in range(psi.shape[0]): for j in range(i): d[get_col_name('psi', band, electrodes[i], electrodes[j])] = psi[i, j, 0] return d
# Construct indices to estimate connectivity between the label time course # and all source space time courses vertices = [src[i]['vertno'] for i in range(2)] n_signals_tot = 1 + len(vertices[0]) + len(vertices[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) # Compute the PSI in the frequency range 8Hz..30Hz. We exclude the baseline # period from the connectivity estimation fmin = 8. fmax = 30. tmin_con = 0. sfreq = raw.info['sfreq'] # the sampling frequency psi, freqs, times, n_epochs, _ = phase_slope_index( comb_ts, mode='multitaper', indices=indices, sfreq=sfreq, fmin=fmin, fmax=fmax, tmin=tmin_con) # Generate a SourceEstimate with the PSI. This is simple since we used a single # seed (inspect the indices variable to see how the PSI scores are arranged in # the output) psi_stc = mne.SourceEstimate(psi, vertices=vertices, tmin=0, tstep=1, subject='sample') # Now we can visualize the PSI using the plot method. We use a custom colormap # to show signed values v_max = np.max(np.abs(psi)) brain = psi_stc.plot(surface='inflated', hemi='lh', time_label='Phase Slope Index (PSI)', subjects_dir=subjects_dir, clim=dict(kind='percent', pos_lims=(95, 97.5, 100)))
subjects_dir=subjects_dir) seed_ts_slow_mt = mne.extract_label_time_course(stcs_slow, vertex_mt, src, mode='mean_flip', verbose='error') # Combine the seed time course with the source estimates. comb_ts_slow = list(zip(seed_ts_slow_v1, seed_ts_slow_mt)) # Construct indices to estimate connectivity between the label time course # and all source space time courses vertices = [src[i]['vertno'] for i in range(2)] indices = (np.array([0]), np.array([1])) # Compute the PSI in the frequency range 11Hz-17Hz. fmin = 11. fmax = 17. sfreq = slow_epo_isi.info['sfreq'] # the sampling frequency psi_slow, freqs, times, n_epochs, _ = phase_slope_index( comb_ts_slow, mode='fourier', sfreq=sfreq, indices=indices, fmin=fmin, fmax=fmax) psi_slow_v1_mt[vert_num_mt] = np.array(psi_slow[0][0]) psi_slow_v1_mt_all[vert_num_v1] = psi_slow_v1_mt
# Construct indices to estimate connectivity between the label time course # and all source space time courses vertices = [src[i]['vertno'] for i in range(2)] n_signals_tot = 1 + len(vertices[0]) + len(vertices[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) # Compute the PSI in the frequency range 10Hz-20Hz. We exclude the baseline # period from the connectivity estimation. fmin = 10. fmax = 20. tmin_con = 0. sfreq = epochs.info['sfreq'] # the sampling frequency psi, freqs, times, n_epochs, _ = phase_slope_index( comb_ts, mode='multitaper', indices=indices, sfreq=sfreq, fmin=fmin, fmax=fmax, tmin=tmin_con) # Generate a SourceEstimate with the PSI. This is simple since we used a single # seed (inspect the indices variable to see how the PSI scores are arranged in # the output) psi_stc = mne.SourceEstimate(psi, vertices=vertices, tmin=0, tstep=1, subject='sample') # Now we can visualize the PSI using the :meth:`~mne.SourceEstimate.plot` # method. We use a custom colormap to show signed values v_max = np.max(np.abs(psi)) brain = psi_stc.plot(surface='inflated', hemi='lh', time_label='Phase Slope Index (PSI)', subjects_dir=subjects_dir, clim=dict(kind='percent', pos_lims=(95, 97.5, 100)))
idx_v1 = np.searchsorted(stcs[0].vertices[1], stcs_v1[0].vertices[1]) idx_mt = np.searchsorted(stcs[0].vertices[1], stcs_mt[0].vertices[1]) # Construct indices to estimate connectivity between the label time course indices = seed_target_indices([idx_v1], [idx_mt]) # Compute the WPLI2_debiased in the frequency range fmin = 8. fmax = 15. sfreq = fast_epo_isi.info['sfreq'] # the sampling frequency # Compute the PSI in the frequency range 8Hz-15Hz. psi, freqs, times, n_epochs, _ = phase_slope_index(stcs, mode='fourier', sfreq=sfreq, indices=indices, fmin=fmin, fmax=fmax, n_jobs=1) # Average over values between all vertices [v1_vertices * mt_vertices] psi_avg = psi.mean(0) all_v1_mt.append(psi_avg) stop = timeit.default_timer() time = stop - start # Save np.save(savepath + 'psi/' + 'all_v1_mt_vertices_fast_fastepo', all_v1_mt) all_subj = np.load(savepath + 'psi/' + 'all_v1_mt_vertices_fast_fastepo.npy') plt.scatter(np.arange(42), all_subj[:, 0]) plt.plot(np.arange(42), np.zeros(42), 'r--') plt.title('PSI between V1 and MT for all subjects')
vertices = [np.arange(10242), np.arange(10242)] n_signals_tot = 1 + len(vertices[0]) + len(vertices[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) fmin = 8. fmax = 12. tmin_con = 0. sfreq = C.sfreq # the sampling frequency psi, freqs, times, n_epochs, n_tapers = phase_slope_index( comb_ts_sd, indices=indices, sfreq=sfreq, mode='fourier', fmin=fmin, fmax=fmax, tmin=tmin, tmax=tmax, n_jobs=6) psi_stc = mne.SourceEstimate(psi, vertices=vertices, tmin=0, tstep=1, subject=sub_to) # Now we can visualize the PSI using the :meth:`~mne.SourceEstimate.plot` # method. We use a custom colormap to show signed values v_max = np.max(np.abs(psi)) brain = psi_stc.plot(surface='inflated',
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[i][k][f][win]= morph_SD.apply(psi_stc_SD)
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)
# Construct indices to estimate connectivity between the label time course # and all source space time courses vertices = [src[i]['vertno'] for i in range(2)] n_signals_tot = 1 + len(vertices[0]) + len(vertices[1]) indices = seed_target_indices([0], np.arange(1, n_signals_tot)) # Compute the PSI in the frequency range 11Hz-17Hz. fmin = 11. fmax = 17. sfreq = slow_epo_isi.info['sfreq'] # the sampling frequency psi_slow, freqs, times, n_epochs, _ = phase_slope_index(comb_ts_slow, mode='multitaper', indices=indices, sfreq=sfreq, fmin=fmin, fmax=fmax) psi_fast, freqs, times, n_epochs, _ = phase_slope_index(comb_ts_fast, mode='multitaper', indices=indices, sfreq=sfreq, fmin=fmin, fmax=fmax) # Generate a SourceEstimate with the PSI. This is simple since we used a single # seed (inspect the indices variable to see how the PSI scores are arranged in # the output) psi_slow_stc = mne.SourceEstimate(psi_slow, vertices=vertices,