def grouplevel_Ttest2(ListSubj,condition,method,mod,twin,clust_p): wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG" # load a specific STC morphed on fsaverage to get shape info stc0_path = (wdir + '/' + ListSubj[0] + '/mne_python/STCS/IcaCorr_' + mod + '_' + ListSubj[0] + '_' + condition[0] + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc0 = mne.read_source_estimate(stc0_path) ncond = len(condition) nsub = len(ListSubj) ntimes = len(stc0.times) nvertices = stc0.data.shape[0] # average individual STCs morphed on fsaverage for each cond AVG_STC_cond = np.empty([nvertices, ntimes, nsub, ncond]) for s,subj in enumerate(ListSubj): # multfact = 0 # for c,cond in enumerate(condition): # stc_path = (wdir + '/' + subj + '/mne_python/STCS/IcaCorr_' + modality + # '_' + subj + '_' + cond + '_pick_oriNone_' + # method + '_ico-5-fwd-fsaverage.fif-rh.stc') # stc = mne.read_source_estimate(stc_path) # multfact = multfact + np.mean(np.mean(stc.data)) for c,cond in enumerate(condition): stc_path = (wdir + '/' + subj + '/mne_python/STCS/IcaCorr_' + modality + '_' + subj + '_' + cond + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc = mne.read_source_estimate(stc_path) # AVG_STC_cond[:,:,s,c] = stc.data/(multfact/2) AVG_STC_cond[:,:,s,c] = stc.data # Compute statistic np.random.seed(42) # compute subject-by-subject mean difference X = AVG_STC_cond[:,:,:,1] - AVG_STC_cond[:,:,:,0] # smooth the data (optional) #fsave_vertices = [np.arange(10242), np.arange(10242)] #morph_mat = compute_morph_matrix('sample', 'fsaverage', sample_vertices, # fsave_vertices, 20, subjects_dir) #n_vertices_fsave = morph_mat.shape[0] # optional: restrict computation to temporal window of interest lower_bound = np.where(stc0.times >= twin[0])[0][0] upper_bound = np.where(stc0.times >= twin[1])[0][0] X = X[:,lower_bound:upper_bound,:] con = mne.spatial_tris_connectivity(grade_to_tris(5)) X = np.transpose(X, [2, 1, 0]) p_threshold = clust_p t_threshold = -stats.distributions.t.ppf(p_threshold / 2., nsub -1) n_permutations = 1024 T_obs, clusters, cluster_p_values, H0 = mne.stats.spatio_temporal_cluster_1samp_test(X, connectivity=con, n_jobs=40, threshold=t_threshold, n_permutations=n_permutations, verbose=True) return T_obs, clusters, cluster_p_values, H0,stc0
def run_permutation_ttest(tmin=None, tmax=None, p_threshold = 0.05, n_permutations=1024, inverse_method='dSPM', n_jobs=1): for cond_id, cond_name in enumerate(events_id.keys()): #todo: calc the 36 controls_data = get_morphed_epochs_stcs(tmin, tmax, cond_name, get_healthy_controls(), 36, inverse_method) controls_data = abs(controls_data) for patient in get_patients(): try: print(patient, cond_name) patient_data = get_morphed_epochs_stcs(tmin, tmax, cond_name, [patient], None, inverse_method) patient_data = abs(patient_data) print(patient_data.shape, controls_data.shape) data = controls_data - patient_data del patient_data gc.collect() data = np.transpose(data, [2, 1, 0]) connectivity = spatial_tris_connectivity(grade_to_tris(5)) t_threshold = -stats.distributions.t.ppf(p_threshold / 2., data.shape[0] - 1) T_obs, clusters, cluster_p_values, H0 = \ spatio_temporal_cluster_1samp_test(data, connectivity=connectivity, n_jobs=n_jobs, threshold=t_threshold, n_permutations=n_permutations) results_file_name = op.join(LOCAL_ROOT_DIR, 'permutation_ttest_results', '{}_{}_{}'.format(patient, cond_name, inverse_method)) np.savez(results_file_name, T_obs=T_obs, clusters=clusters, cluster_p_values=cluster_p_values, H0=H0) good_cluster_inds = np.where(cluster_p_values < 0.05)[0] print('good_cluster_inds: {}'.format(good_cluster_inds)) except: print('bummer! {}, {}'.format(patient, cond_name)) print(traceback.format_exc())
def stat_clus(X, tstep, time_thre=0, n_per=8192, p_threshold=0.01, p=0.05, fn_clu_out=None): print('Computing connectivity.') connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Note that X needs to be a multi-dimensional array of shape # samples (subjects) x time x space, so we permute dimensions X = np.transpose(X, [2, 1, 0]) n_subjects = X.shape[0] fsave_vertices = [np.arange(X.shape[-1]/2), np.arange(X.shape[-1]/2)] # Now let's actually do the clustering. This can take a long time... # Here we set the threshold quite high to reduce computation. t_threshold = -stats.distributions.t.ppf(p_threshold / 2., n_subjects - 1) print('Clustering.') max_step = int(time_thre * 0.001 / tstep) + 1 T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_1samp_test(X, connectivity=connectivity, n_jobs=1, max_step=max_step, threshold=t_threshold, n_permutations=n_per) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < p)[0] print 'the amount of significant clusters are: %d' %good_cluster_inds.shape ############################################################################### # Save the clusters as stc file # ---------------------- assert good_cluster_inds.shape != 0, ('Current p_threshold is %f %p_thr,\ maybe you need to reset a lower p_threshold') np.savez(fn_clu_out, clu=clu, tstep=tstep, fsave_vertices=fsave_vertices)
def per2test(X1, X2, p_thr, p, tstep, n_per=8192, fn_clu_out=None): # Note that X needs to be a multi-dimensional array of shape # samples (subjects) x time x space, so we permute dimensions n_subjects1 = X1.shape[2] n_subjects2 = X2.shape[2] fsave_vertices = [np.arange(X1.shape[0]/2), np.arange(X1.shape[0]/2)] X1 = np.transpose(X1, [2, 1, 0]) X2 = np.transpose(X2, [2, 1, 0]) X = [X1, X2] # Now let's actually do the clustering. This can take a long time... # Here we set the threshold quite high to reduce computation. f_threshold = stats.distributions.f.ppf(1. - p_thr / 2., n_subjects1 - 1, n_subjects2 - 1) print('Clustering.') connectivity = spatial_tris_connectivity(grade_to_tris(5)) T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_test(X, n_permutations=n_per, connectivity=connectivity, n_jobs=1, threshold=f_threshold) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < p)[0] print 'the amount of significant clusters are: %d' %good_cluster_inds.shape ############################################################################### # Save the clusters as stc file # ---------------------- assert good_cluster_inds.shape != 0, ('Current p_threshold is %f %p_thr,\ maybe you need to reset a lower p_threshold') np.savez(fn_clu_out, clu=clu, tstep=tstep, fsave_vertices=fsave_vertices)
def grouplevel_spatial_linreg(ListSubj,condition,method,mod,twin,clust_p): wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG" # load a specific STC morphed on fsaverage to get shape info stc0_path = (wdir + '/' + ListSubj[0] + '/mne_python/STCS/IcaCorr_' + mod + '_' + ListSubj[0] + '_' + condition[0] + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc0 = mne.read_source_estimate(stc0_path) ncond = len(condition) nsub = len(ListSubj) ntimes = len(stc0.times) nvertices = stc0.data.shape[0] # average individual STCs morphed on fsaverage for each cond AVG_STC_cond = np.empty([nvertices, ntimes, nsub, ncond]) for s,subj in enumerate(ListSubj): for c,cond in enumerate(condition): stc_path = (wdir + '/' + subj + '/mne_python/STCS/IcaCorr_' + modality + '_' + subj + '_' + cond + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc = mne.read_source_estimate(stc_path) AVG_STC_cond[:,:,s,c] = stc.data # optional: restrict computation to temporal window of interest lower_bound = np.where(stc0.times >= twin[0])[0][0] upper_bound = np.where(stc0.times >= twin[1])[0][0] con = mne.spatial_tris_connectivity(grade_to_tris(5)) # array of shapes (obs, time, vertices) X, Xpred = [], [] for c,cond in enumerate(condition): X.append(np.mean(np.transpose(AVG_STC_cond[:,lower_bound: upper_bound,:,c], [2, 1, 0]),1)) Xpred.append(np.ones((nsub,nvertices))*(c+1)) X = np.array(X) Xpred = np.array(Xpred) Reg = np.zeros((nsub,nvertices)) # lienar regression per vertex for s in range(nsub): for v in range(nvertices): tmp = stats.linregress(X[:,s,v],Xpred[:,s,v]) Reg[s,v] = tmp.slope if clust_p == None: T_obs, clu, clu_p_val, H0 = mne.stats.permutation_cluster_1samp_test(Reg, None, connectivity=con, n_jobs=8, verbose=True, seed = 666) else: p_threshold = clust_p t_threshold = -stats.distributions.t.ppf(p_threshold / 2., nsub -1) T_obs, clu, clu_p_val, H0 = mne.stats.permutation_cluster_1samp_test(Reg, threshold=t_threshold, connectivity=con, n_jobs=8, verbose=True, seed = 666) return T_obs, clu, clu_p_val, H0,stc0
def test_stc_to_label(): """Test stc_to_label """ with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') src = read_source_spaces(fwd_fname) src_bad = read_source_spaces(src_bad_fname) stc = read_source_estimate(stc_fname, 'sample') os.environ['SUBJECTS_DIR'] = op.join(data_path, 'subjects') labels1 = _stc_to_label(stc, src='sample', smooth=3) labels2 = _stc_to_label(stc, src=src, smooth=3) assert_equal(len(labels1), len(labels2)) for l1, l2 in zip(labels1, labels2): assert_labels_equal(l1, l2, decimal=4) with warnings.catch_warnings(record=True) as w: # connectedness warning warnings.simplefilter('always') labels_lh, labels_rh = stc_to_label(stc, src=src, smooth=True, connected=True) assert_true(len(w) > 0) assert_raises(ValueError, stc_to_label, stc, 'sample', smooth=True, connected=True) assert_raises(RuntimeError, stc_to_label, stc, smooth=True, src=src_bad, connected=True) assert_equal(len(labels_lh), 1) assert_equal(len(labels_rh), 1) # test getting tris tris = labels_lh[0].get_tris(src[0]['use_tris'], vertices=stc.vertices[0]) assert_raises(ValueError, spatial_tris_connectivity, tris, remap_vertices=False) connectivity = spatial_tris_connectivity(tris, remap_vertices=True) assert_true(connectivity.shape[0] == len(stc.vertices[0])) # "src" as a subject name assert_raises(TypeError, stc_to_label, stc, src=1, smooth=False, connected=False, subjects_dir=subjects_dir) assert_raises(ValueError, stc_to_label, stc, src=SourceSpaces([src[0]]), smooth=False, connected=False, subjects_dir=subjects_dir) assert_raises(ValueError, stc_to_label, stc, src='sample', smooth=False, connected=True, subjects_dir=subjects_dir) assert_raises(ValueError, stc_to_label, stc, src='sample', smooth=True, connected=False, subjects_dir=subjects_dir) labels_lh, labels_rh = stc_to_label(stc, src='sample', smooth=False, connected=False, subjects_dir=subjects_dir) assert_true(len(labels_lh) > 1) assert_true(len(labels_rh) > 1) # with smooth='patch' with warnings.catch_warnings(record=True) as w: # connectedness warning warnings.simplefilter('always') labels_patch = stc_to_label(stc, src=src, smooth=True) assert_equal(len(w), 1) assert_equal(len(labels_patch), len(labels1)) for l1, l2 in zip(labels1, labels2): assert_labels_equal(l1, l2, decimal=4)
def test_stc_to_label(): """Test stc_to_label """ with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') src = read_source_spaces(fwd_fname) src_bad = read_source_spaces(src_bad_fname) stc = read_source_estimate(stc_fname, 'sample') os.environ['SUBJECTS_DIR'] = op.join(data_path, 'subjects') with warnings.catch_warnings(record=True) as w: # connectedness warning warnings.simplefilter('always') labels1 = stc_to_label(stc, src='sample', smooth=3) labels2 = stc_to_label(stc, src=src, smooth=3) assert_true(len(w) > 0) assert_equal(len(labels1), len(labels2)) for l1, l2 in zip(labels1, labels2): assert_labels_equal(l1, l2, decimal=4) with warnings.catch_warnings(record=True) as w: # connectedness warning warnings.simplefilter('always') labels_lh, labels_rh = stc_to_label(stc, src=src, smooth=True, connected=True) assert_true(len(w) > 0) assert_raises(ValueError, stc_to_label, stc, 'sample', smooth=True, connected=True) assert_raises(RuntimeError, stc_to_label, stc, smooth=True, src=src_bad, connected=True) assert_equal(len(labels_lh), 1) assert_equal(len(labels_rh), 1) # test getting tris tris = labels_lh[0].get_tris(src[0]['use_tris'], vertices=stc.vertno[0]) assert_raises(ValueError, spatial_tris_connectivity, tris, remap_vertices=False) connectivity = spatial_tris_connectivity(tris, remap_vertices=True) assert_true(connectivity.shape[0] == len(stc.vertno[0])) # with smooth='patch' with warnings.catch_warnings(record=True) as w: # connectedness warning warnings.simplefilter('always') labels_patch = stc_to_label(stc, src=src, smooth=True) assert_equal(len(w), 1) assert_equal(len(labels_patch), len(labels1)) for l1, l2 in zip(labels1, labels2): assert_labels_equal(l1, l2, decimal=4)
def grouplevel_stats(ListSubj,condition,method,mod,twin,clust_p): wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG" # load a specific STC morphed on fsaverage to get shape info stc0_path = (wdir + '/' + ListSubj[0] + '/mne_python/STCS/IcaCorr_' + mod + '_' + ListSubj[0] + '_' + condition[0] + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc0 = mne.read_source_estimate(stc0_path) stc0.crop(-0.2,5) ncond = len(condition) nsub = len(ListSubj) ntimes = len(stc0.times) nvertices = stc0.data.shape[0] # average individual STCs morphed on fsaverage for each cond AVG_STC_cond = np.empty([nvertices, ntimes, nsub, ncond]) for s,subj in enumerate(ListSubj): for c,cond in enumerate(condition): stc_path = (wdir + '/' + subj + '/mne_python/STCS/IcaCorr_' + modality + '_' + subj + '_' + cond + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc = mne.read_source_estimate(stc_path) stc0.crop(-0.2,5) AVG_STC_cond[:,:,s,c] = stc.data # optional: restrict computation to temporal window of interest lower_bound = np.where(stc0.times >= twin[0])[0][0] upper_bound = np.where(stc0.times >= twin[1])[0][0] con = mne.spatial_tris_connectivity(grade_to_tris(5)) # array of shapes (obs, time, vertices) X = [] for c,cond in enumerate(condition): X.append(np.transpose(AVG_STC_cond[:,lower_bound: upper_bound,:,c], [2, 1, 0])) effects = 'A' factor_levels = [3] # get f-values only. def mystat_fun(*args): return f_mway_rm(np.swapaxes(args, 1, 0), factor_levels=factor_levels, effects=effects, return_pvals=False)[0] p_threshold = clust_p f_threshold = mne.stats.f_threshold_mway_rm(nsub,factor_levels = factor_levels, effects = effects,pvalue= p_threshold) T_obs, clu, clu_p_val, H0 = mne.stats.spatio_temporal_cluster_test(X, threshold=f_threshold,stat_fun=mystat_fun, connectivity=con, n_jobs=1, verbose=True, seed = 666) return T_obs, clu, clu_p_val, H0,stc0
def per2test(X1, X2, p_thr, p, tstep, n_per=8192, fn_clu_out=None): ''' Calculate significant clusters using 2 sample ftest. Parameter --------- X1, X2: array The shape of X should be (Vertices, timepoints, subjects) tstep: float The interval between timepoints. n_per: int The permutation for ttest. p_thr: float The significant p_values. p: float The corrected p_values for comparisons. fn_clu_out: string The fnname for saving clusters. ''' # Note that X needs to be a multi-dimensional array of shape # samples (subjects) x time x space, so we permute dimensions n_subjects1 = X1.shape[2] n_subjects2 = X2.shape[2] fsave_vertices = [np.arange(X1.shape[0]/2), np.arange(X1.shape[0]/2)] X1 = np.transpose(X1, [2, 1, 0]) X2 = np.transpose(X2, [2, 1, 0]) X = [X1, X2] # Now let's actually do the clustering. This can take a long time... # Here we set the threshold quite high to reduce computation. f_threshold = stats.distributions.f.ppf(1. - p_thr / 2., n_subjects1 - 1, n_subjects2 - 1) # t_threshold = stats.distributions.t.ppf(1. - p_thr / 2., n_subjects1 - 1, # n_subjects2 - 1) print('Clustering...') connectivity = spatial_tris_connectivity(grade_to_tris(5)) T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_test(X, n_permutations=n_per, #step_down_p=0.001, connectivity=connectivity, n_jobs=1, # threshold=t_threshold, stat_fun=stats.ttest_ind) threshold=f_threshold) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < p)[0] print 'the amount of significant clusters are: %d' % good_cluster_inds.shape # Save the clusters as stc file np.savez(fn_clu_out, clu=clu, tstep=tstep, fsave_vertices=fsave_vertices) assert good_cluster_inds.shape != 0, ('Current p_threshold is %f %p_thr,\ maybe you need to reset a lower p_threshold')
def create_spatial_connectivity(subject): try: connectivity_per_hemi = {} for hemi in utils.HEMIS: d = np.load(op.join(SUBJECTS_DIR, subject, 'mmvt', '{}.pial.npz'.format(hemi))) connectivity_per_hemi[hemi] = mne.spatial_tris_connectivity(d['faces']) utils.save(connectivity_per_hemi, op.join(MMVT_DIR, subject, 'spatial_connectivity.pkl')) success = True except: print('Error in create_spatial_connectivity!') print(traceback.format_exc()) success = False return success
def test_stc_to_label(): """Test stc_to_label.""" src = read_source_spaces(fwd_fname) src_bad = read_source_spaces(src_bad_fname) stc = read_source_estimate(stc_fname, 'sample') os.environ['SUBJECTS_DIR'] = op.join(data_path, 'subjects') labels1 = _stc_to_label(stc, src='sample', smooth=3) labels2 = _stc_to_label(stc, src=src, smooth=3) assert_equal(len(labels1), len(labels2)) for l1, l2 in zip(labels1, labels2): assert_labels_equal(l1, l2, decimal=4) with pytest.warns(RuntimeWarning, match='have holes'): labels_lh, labels_rh = stc_to_label(stc, src=src, smooth=True, connected=True) pytest.raises(ValueError, stc_to_label, stc, 'sample', smooth=True, connected=True) pytest.raises(RuntimeError, stc_to_label, stc, smooth=True, src=src_bad, connected=True) assert_equal(len(labels_lh), 1) assert_equal(len(labels_rh), 1) # test getting tris tris = labels_lh[0].get_tris(src[0]['use_tris'], vertices=stc.vertices[0]) pytest.raises(ValueError, spatial_tris_connectivity, tris, remap_vertices=False) connectivity = spatial_tris_connectivity(tris, remap_vertices=True) assert (connectivity.shape[0] == len(stc.vertices[0])) # "src" as a subject name pytest.raises(TypeError, stc_to_label, stc, src=1, smooth=False, connected=False, subjects_dir=subjects_dir) pytest.raises(ValueError, stc_to_label, stc, src=SourceSpaces([src[0]]), smooth=False, connected=False, subjects_dir=subjects_dir) pytest.raises(ValueError, stc_to_label, stc, src='sample', smooth=False, connected=True, subjects_dir=subjects_dir) pytest.raises(ValueError, stc_to_label, stc, src='sample', smooth=True, connected=False, subjects_dir=subjects_dir) labels_lh, labels_rh = stc_to_label(stc, src='sample', smooth=False, connected=False, subjects_dir=subjects_dir) assert (len(labels_lh) > 1) assert (len(labels_rh) > 1) # with smooth='patch' with pytest.warns(RuntimeWarning, match='have holes'): labels_patch = stc_to_label(stc, src=src, smooth=True) assert len(labels_patch) == len(labels1) for l1, l2 in zip(labels1, labels2): assert_labels_equal(l1, l2, decimal=4)
def test_spatial_src_connectivity(): """Test spatial connectivity functionality.""" # oct src = read_source_spaces(fname_src) assert src[0]['dist'] is not None # distance info con = spatial_src_connectivity(src).toarray() con_dist = spatial_src_connectivity(src, dist=0.01).toarray() assert (con == con_dist).mean() > 0.75 # ico src = read_source_spaces(fname_src_fs) con = spatial_src_connectivity(src).tocsr() con_tris = spatial_tris_connectivity(grade_to_tris(5)).tocsr() assert con.shape == con_tris.shape assert_array_equal(con.data, con_tris.data) assert_array_equal(con.indptr, con_tris.indptr) assert_array_equal(con.indices, con_tris.indices) # one hemi con_lh = spatial_src_connectivity(src[:1]).tocsr() con_lh_tris = spatial_tris_connectivity(grade_to_tris(5)).tocsr() con_lh_tris = con_lh_tris[:10242, :10242].tocsr() assert_array_equal(con_lh.data, con_lh_tris.data) assert_array_equal(con_lh.indptr, con_lh_tris.indptr) assert_array_equal(con_lh.indices, con_lh_tris.indices)
def test_spatial_src_connectivity(): """Test spatial connectivity functionality.""" # oct src = read_source_spaces(fname_src) assert src[0]['dist'] is not None # distance info with pytest.warns(RuntimeWarning, match='will have holes'): con = spatial_src_connectivity(src).toarray() con_dist = spatial_src_connectivity(src, dist=0.01).toarray() assert (con == con_dist).mean() > 0.75 # ico src = read_source_spaces(fname_src_fs) con = spatial_src_connectivity(src).tocsr() con_tris = spatial_tris_connectivity(grade_to_tris(5)).tocsr() assert con.shape == con_tris.shape assert_array_equal(con.data, con_tris.data) assert_array_equal(con.indptr, con_tris.indptr) assert_array_equal(con.indices, con_tris.indices) # one hemi con_lh = spatial_src_connectivity(src[:1]).tocsr() con_lh_tris = spatial_tris_connectivity(grade_to_tris(5)).tocsr() con_lh_tris = con_lh_tris[:10242, :10242].tocsr() assert_array_equal(con_lh.data, con_lh_tris.data) assert_array_equal(con_lh.indptr, con_lh_tris.indptr) assert_array_equal(con_lh.indices, con_lh_tris.indices)
def permutation_test_on_source_data_with_spatio_temporal_clustering(controls_data, patient_data, patient, cond_name, tstep, n_permutations, inverse_method='dSPM', n_jobs=6): try: print('permutation_test: patient {}, cond {}'.format(patient, cond_name)) connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Note that X needs to be a list of multi-dimensional array of shape # samples (subjects_k) x time x space, so we permute dimensions print(controls_data.shape, patient_data.shape) X = [controls_data, patient_data] p_threshold = 0.05 f_threshold = stats.distributions.f.ppf(1. - p_threshold / 2., controls_data.shape[0] - 1, 1) print('Clustering. thtreshold = {}'.format(f_threshold)) T_obs, clusters, cluster_p_values, H0 = clu =\ spatio_temporal_cluster_test(X, connectivity=connectivity, n_jobs=n_jobs, threshold=10, n_permutations=n_permutations) results_file_name = op.join(LOCAL_ROOT_DIR, 'clusters_results', '{}_{}_{}'.format(patient, cond_name, inverse_method)) np.savez(results_file_name, T_obs=T_obs, clusters=clusters, cluster_p_values=cluster_p_values, H0=H0) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < 0.05)[0] ############################################################################### # Visualize the clusters print('Visualizing clusters.') # Now let's build a convenient representation of each cluster, where each # cluster becomes a "time point" in the SourceEstimate fsave_vertices = [np.arange(10242), np.arange(10242)] stc_all_cluster_vis = summarize_clusters_stc(clu, tstep=tstep, vertices=fsave_vertices, subject='fsaverage') stc_all_cluster_vis.save(op.join(LOCAL_ROOT_DIR, 'stc_clusters', '{}_{}_{}'.format(patient, cond_name, inverse_method)), ftype='h5') # # Let's actually plot the first "time point" in the SourceEstimate, which # # shows all the clusters, weighted by duration # # blue blobs are for condition A != condition B # brain = stc_all_cluster_vis.plot('fsaverage', 'inflated', 'both', # subjects_dir=subjects_dir, clim='auto', # time_label='Duration significant (ms)') # brain.set_data_time_index(0) # brain.show_view('lateral') # brain.save_image('clusters.png') except: print('bummer! {}, {}'.format(patient, cond_name)) print(traceback.format_exc())
def perform_statistics(morphed_data, parameter_cache, vector, p_value=None): """Performs the statistical analysis using spatial_tris_connectivity. :param morphed_data: Morphed data obtained from morph_data function :param parameter_cache: Morphed parameter cache obtained from morph_data function. :param vector: Method to perform modelling ('sLORETA' etc.) :param p_value: Statistical p-value :return: clu, good_cluster_inds """ # Unpack parameter cache dictionary n_subjects = parameter_cache['n_subjects'] n_times = parameter_cache['n_times'] # Take on the absolute X = np.abs(morphed_data) # Obtain the paired contrast if vector is False: X = X[:, :, :, 0] - X[:, :, :, 1] # Dimension is (space, time, subjects) else: X = X[:, :, :, :, 0] - X[:, :, :, :, 1] # Dimension is (space, vector, time, subjects) print('Computing connectivity... ') connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Note that X needs to be a multi-dimensional array of shape [samples (subjects) x time x space] if vector is False: X = np.transpose(X, [2, 1, 0]) else: X = np.transpose(X, [3, 2, 1, 0]) ##### TO DOUBLE CHECK ##### # Perform the clustering p_threshold = p_value # 0.001 t_threshold = -stats.distributions.t.ppf(p_threshold / 2., n_subjects - 1) print('Clustering... ') T_obs, clusters, cluster_p_values, H0 = spatio_temporal_cluster_1samp_test( X, connectivity=connectivity, n_jobs=1, threshold=t_threshold) # Pack the outputs into tuple clu = (T_obs, clusters, cluster_p_values, H0) # Select the clusters that are sig. at p < p_value (Note this value is multiple-comparisons corrected) good_cluster_inds = np.where(cluster_p_values < p_value)[0] return clu, good_cluster_inds
def stat_clus(X, tstep, n_per=8192, p_threshold=0.01, p=0.05, fn_clu_out=None): ''' Calculate significant clusters using 1sample ttest. Parameter --------- X: array The shape of X should be (Vertices, timepoints, subjects) tstep: float The interval between timepoints. n_per: int The permutation for ttest. p_threshold: float The significant p_values. p: float The corrected p_values for comparisons. fn_clu_out: string The fnname for saving clusters. ''' print('Computing connectivity.') connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Note that X needs to be a multi-dimensional array of shape # samples (subjects) x time x space, so we permute dimensions X = np.transpose(X, [2, 1, 0]) n_subjects = X.shape[0] fsave_vertices = [np.arange(X.shape[-1]/2), np.arange(X.shape[-1]/2)] # Now let's actually do the clustering. This can take a long time... # Here we set the threshold quite high to reduce computation. t_threshold = -stats.distributions.t.ppf(p_threshold / 2., n_subjects - 1) print('Clustering.') T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_1samp_test(X, connectivity=connectivity, n_jobs=1, threshold=t_threshold, n_permutations=n_per) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < p)[0] print 'the amount of significant clusters are: %d' %good_cluster_inds.shape # Save the clusters as stc file np.savez(fn_clu_out, clu=clu, tstep=tstep, fsave_vertices=fsave_vertices) assert good_cluster_inds.shape != 0, ('Current p_threshold is %f %p_thr,\ maybe you need to reset a lower p_threshold')
def cluster_test(scores, n_perm=10000, threshold=1.5, n_jobs=1, dimension='time'): '''perform 1-sample t-test over time or space to find clusters''' # dims n_obs, n_datapoints = scores.shape # connectivity map for spatial map if dimension == 'space': connectivity = mne.spatial_tris_connectivity(mne.grad_to_tris(4)) elif dimension == 'time': connectivity = None t_obs, clusters, cluster_pv, H0 = perm_1samp(scores, n_jobs=n_jobs, threshold=threshold, n_permutations=n_perm, connectivity=connectivity) return(t_obs, clusters, cluster_pv, H0)
def create_spatial_connectivity(subject): try: verts_neighbors_fname = op.join(MMVT_DIR, subject, 'verts_neighbors_{hemi}.pkl') connectivity_fname = op.join(MMVT_DIR, subject, 'spatial_connectivity.pkl') if utils.both_hemi_files_exist(verts_neighbors_fname) and op.isfile(verts_neighbors_fname): return True connectivity_per_hemi = {} for hemi in utils.HEMIS: neighbors = defaultdict(list) d = np.load(op.join(MMVT_DIR, subject, 'surf', '{}.pial.npz'.format(hemi))) connectivity_per_hemi[hemi] = mne.spatial_tris_connectivity(d['faces']) rows, cols = connectivity_per_hemi[hemi].nonzero() for ind in range(len(rows)): neighbors[rows[ind]].append(cols[ind]) utils.save(neighbors, verts_neighbors_fname.format(hemi=hemi)) utils.save(connectivity_per_hemi, connectivity_fname) success = True except: print('Error in create_spatial_connectivity!') print(traceback.format_exc()) success = False return success
print('Clustering: ', f_label[f], '/ k:', k, '/ w: ', w) X_SD = np.zeros([18, 20484]) X_LD = np.zeros([18, 20484]) for i in np.arange(0, 18): X_SD[i, :] = (abs( my_stc_coh_SD[i][w][k][f].data)).reshape(20484) X_LD[i, :] = (abs( my_stc_coh_LD[i][w][k][f].data)).reshape(20484) Y = X_SD - X_LD source_space = mne.grade_to_tris(5) adjacency = mne.spatial_tris_connectivity(source_space) # adjacency = None tstep = my_stc_coh_SD[i][w][k][f].tstep T_obs, clusters, cluster_p_values, H0 = clu = \ mne.stats.permutation_cluster_1samp_test(Y, connectivity=adjacency, n_jobs=-1, threshold=t_threshold, n_permutations=5000, step_down_p=0.05, t_power=1, tail=0) if len(np.where(cluster_p_values < p)[0]) != 0: print('significant!') sig.append([w, k, f])
X2 = np.random.randn(n_vertices_fsave, n_times, n_subjects2) * 10 X1[:, :, :] += stc.data[:, :, np.newaxis] # make the activity bigger for the second set of subjects X2[:, :, :] += 3 * stc.data[:, :, np.newaxis] # We want to compare the overall activity levels for each subject X1 = np.abs(X1) # only magnitude X2 = np.abs(X2) # only magnitude ############################################################################### # Compute statistic # To use an algorithm optimized for spatio-temporal clustering, we # just pass the spatial connectivity matrix (instead of spatio-temporal) print('Computing connectivity.') connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Note that X needs to be a list of multi-dimensional array of shape # samples (subjects_k) x time x space, so we permute dimensions X1 = np.transpose(X1, [2, 1, 0]) X2 = np.transpose(X2, [2, 1, 0]) X = [X1, X2] # Now let's actually do the clustering. This can take a long time... # Here we set the threshold quite high to reduce computation. p_threshold = 0.0001 f_threshold = stats.distributions.f.ppf(1. - p_threshold / 2., n_subjects1 - 1, n_subjects2 - 1) print('Clustering.') T_obs, clusters, cluster_p_values, H0 = clu =\ spatio_temporal_cluster_test(X, connectivity=connectivity, n_jobs=2,
def sample2_clus(fn_list, n_per=8192, pthr=0.01, p=0.05, tail=0, del_vers=None, n_jobs=1): ''' Calculate significant clusters using 2 sample ftest. Parameter --------- fn_list: list Paths of group arrays n_per: int The permutation for ttest. pct: int or float. The percentile of the baseline distribution. p: float The corrected p_values for comparisons. del_vers: None or _exclu_vers If is '_exclu_vers', delete the vertices in the medial wall. ''' for fn_npz in fn_list: fn_path = os.path.dirname(fn_npz) name = os.path.basename(fn_npz) #fn_out = fn_path + '/clu2sample_%s' %name[:name.rfind('.npz')] + '_%d_pct%.2f.npz' %(n_per, pct) fn_out = fn_path + '/clu2sample_%s' % name[:name.rfind( '.npz')] + '_%d_%dtail_pthr%.4f.npz' % (n_per, 1 + (tail == 0), pthr) npz = np.load(fn_npz) tstep = npz['tstep'].flatten()[0] # Note that X needs to be a multi-dimensional array of shape # samples (subjects) x time x space, so we permute dimensions X = npz['X'] ppf = stats.f.ppf tail = 1 # tail = we are interested in an increase of variance only p_thresh = pthr / ( 1 + (tail == 0) ) # we can also adapt this to p=0.01 if the cluster size is too large n_samples_per_group = [len(x) for x in X] f_threshold = ppf(1. - p_thresh, *n_samples_per_group) if np.sign(tail) < 0: f_threshold = -f_threshold fsave_vertices = [ np.arange(X.shape[-1] / 2), np.arange(X.shape[-1] / 2) ] print('Clustering...') connectivity = spatial_tris_connectivity(grade_to_tris(5)) T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_test(X, n_permutations=n_per, #step_down_p=0.001, connectivity=connectivity, n_jobs=n_jobs, # threshold=t_threshold, stat_fun=stats.ttest_ind) threshold=f_threshold, spatial_exclude=del_vers, tail=tail) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < p)[0] print 'the amount of significant clusters are: %d' % good_cluster_inds.shape # Save the clusters as stc file np.savez(fn_out, clu=clu, tstep=tstep, fsave_vertices=fsave_vertices) assert good_cluster_inds.shape != 0, ( 'Current p_threshold is %f %p_thr,\ maybe you need to reset a lower p_threshold' )
for fname in files: # exclude due to psychotropic factors if fname.find('WCEYBWMO') < 0: stc = mne.read_source_estimate(fname[:-7]) if after_zero: stc.crop(tmin=0) X.append(stc.data) subj = fname.split('/')[-1].split('_')[0] gf_loc.append(np.nonzero(gf.maskid == subj)[0][0]) if len(X) != len(gf_loc): print 'Mismatch between subject data and gf!' # re-sort subject order in gf to match X gf = gf.iloc[gf_loc] connectivity = mne.spatial_tris_connectivity(mne.grade_to_tris(5)) for thresh in p_threshold: if my_test == 'nvVSper': g0 = [X[i].T for i, group in enumerate(gf.group) if group == 'NV'] g1 = [ X[i].T for i, group in enumerate(gf.group) if group == 'persistent' ] data = [np.array(g0), np.array(g1)] stat_obs, clusters, p_values, H0 = \ mne.stats.spatio_temporal_cluster_test(data, n_jobs=njobs, threshold=thresh, connectivity=connectivity, stat_fun=group_comparison, tail=1, n_permutations=nperms,
def sample1_clus(fn_list, n_per=8192, pct=99, p=0.01, tail=1, del_vers=None, n_jobs=1): ''' Calculate significant clusters using 1sample ttest. Parameter --------- fn_list: list Paths of group arrays n_per: int The permutation for ttest. pct: int or float. The percentile of the baseline distribution. p: float The corrected p_values for comparisons. tail: 1 or 0 if tail=1, that is 1 tail test if tail=0, that is 2 tail test del_vers: None or _exclu_vers If is '_exclu_vers', delete the vertices in the medial wall. ''' print('Computing connectivity.') connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Using the percentile of baseline array as the distribution threshold for fn_npz in fn_list: npz = np.load(fn_npz) tstep = npz['tstep'].flatten()[0] # Note that X needs to be a multi-dimensional array of shape # samples (subjects) x time x space, so we permute dimensions X = npz['X'] X_b = X[1] X = X[0] fn_path = os.path.dirname(fn_npz) name = os.path.basename(fn_npz) if tail == 1: fn_out = fn_path + '/clu1sample_%s' % name[:name.rfind( '.npz')] + '_%d_%dtail_pct%.3f.npz' % (n_per, tail, pct) X = np.abs(X) t_threshold = np.percentile(np.abs(X_b), pct) elif tail == 0: fn_out = fn_path + '/clu1sample_%s' % name[:name.rfind( '.npz')] + '_%d_%dtail_pct%.3f.npz' % (n_per, tail + 2, pct) t_threshold = np.percentile(X_b, pct) fsave_vertices = [ np.arange(X.shape[-1] / 2), np.arange(X.shape[-1] / 2) ] #n_subjects = X.shape[0] #t_threshold = -stats.distributions.t.ppf(0.01/(1+(tail==0)), n_subjects-1) print('Clustering.') T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_1samp_test(X, connectivity=connectivity, n_jobs=n_jobs, threshold=t_threshold, n_permutations=n_per, tail=tail, spatial_exclude=del_vers) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). good_cluster_inds = np.where(cluster_p_values < p)[0] print 'the amount of significant clusters are: %d' % good_cluster_inds.shape # Save the clusters as stc file np.savez(fn_out, clu=clu, tstep=tstep, fsave_vertices=fsave_vertices) assert good_cluster_inds.shape != 0, ( 'Current p_threshold is %f %p_thr,\ maybe you need to reset a lower p_threshold' )
# drop p-values (empty array). # Note. for further details on this ANOVA function consider the # corresponding time frequency example. ############################################################################### # Compute clustering statistic # To use an algorithm optimized for spatio-temporal clustering, we # just pass the spatial connectivity matrix (instead of spatio-temporal) source_space = grade_to_tris(5) # as we only have one hemisphere we need only need half the connectivity lh_source_space = source_space[source_space[:, 0] < 10242] print('Computing connectivity.') connectivity = spatial_tris_connectivity(lh_source_space) # Now let's actually do the clustering. Please relax, on a small # notebook and one single thread only this will take a couple of minutes ... pthresh = 0.0005 f_thresh = f_threshold_twoway_rm(n_subjects, factor_levels, effects, pthresh) # To speed things up a bit we will ... n_permutations = 100 # ... run fewer permutations (reduces sensitivity) print('Clustering.') T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_test(X, connectivity=connectivity, n_jobs=1, threshold=f_thresh, stat_fun=stat_fun, n_permutations=n_permutations, buffer_size=None)
for fname in files: # exclude due to psychotropic factors if fname.find('WCEYBWMO') < 0: stc = mne.read_source_estimate(fname[:-7]) if after_zero: stc.crop(tmin=0) X.append(stc.data) subj = fname.split('/')[-1].split('_')[0] gf_loc.append(np.nonzero(gf.maskid == subj)[0][0]) if len(X) != len(gf_loc): print 'Mismatch between subject data and gf!' # re-sort subject order in gf to match X gf = gf.iloc[gf_loc] connectivity = mne.spatial_tris_connectivity(mne.grade_to_tris(5)) for thresh in p_threshold: if my_test == 'nvVSper': g0 = [X[i].T for i, group in enumerate(gf.group) if group == 'NV'] g1 = [X[i].T for i, group in enumerate(gf.group) if group == 'persistent'] data = [np.array(g0), np.array(g1)] stat_obs, clusters, p_values, H0 = \ mne.stats.spatio_temporal_cluster_test(data, n_jobs=njobs, threshold=thresh, connectivity=connectivity, stat_fun=group_comparison, tail=1, n_permutations=nperms, verbose=True) elif my_test == 'nvVSrem':
surf_connmat = normalize(surf_connmat, norm='l2') # read surface seed roi mask seedroi_gii = ng.read(seedroi_gii_path) seedroi_data = seedroi_gii.darrays[darrays_int].data # the values of seed vertex print seedroi_data.shape surfmask_inds = np.flatnonzero(seedroi_data) # return the indices that are non-zeros in seedroi_data print 'seed roi vertices ' + str(len(surfmask_inds)) # perform a hierarchical clustering considering spatial neighborhood (ward) print 'ward: number of clusters:{}'.format(nb_clusters) g = ng.read(mesh_path) triangles = g.darrays[1].data # compute the spatial neighbordhood over the seed surface adjacency = sparse.coo_matrix(sparse.csc_matrix(sparse.csr_matrix(spatial_tris_connectivity(triangles))[surfmask_inds, :]) [:, surfmask_inds]) print " adjacency matrix: {}".format(adjacency.shape) # ================================== ward clustering ==================================================== # ward = WardAgglomeration(n_clusters = nb_clusters, connectivity=connectivity, memory = 'nilearn_cache') ward = AgglomerativeClustering(n_clusters=nb_clusters, linkage='ward', connectivity=adjacency) ward.fit(surf_connmat) labelsf = ward.labels_ for i in range(len(np.unique(labelsf))): print 'label %d: %d' % (i, len(labelsf[labelsf == i])) # write the final gifti parcellation print 'write parcellation.gii' ii = 0
def apply_sigSTC(fn_list_v, vevent, mevent, method='dSPM', vtmin=0., vtmax=0.35, mtmin=-0.3, mtmax=0.05, radius=10.0): from mne import spatial_tris_connectivity, grade_to_tris from mne.stats import spatio_temporal_cluster_test from scipy import stats as stats X1, X2 = [], [] stcs_trial = [] for fn_v in fn_list_v: fn_m = fn_v[: fn_v.rfind('evtW')] + 'evtW_%s_bc_norm_1-lh.stc' %mevent stc_v = mne.read_source_estimate(fn_v) stcs_trial.append(stc_v.copy()) stc_m = mne.read_source_estimate(fn_m) stc_v.resample(200) stc_m.resample(200) X1.append(stc_v.copy().crop(vtmin, vtmax).data) X2.append(stc_m.copy().crop(mtmin, mtmax).data) stcs_path = subjects_dir+'/fsaverage/%s_ROIs/conditions/' %method reset_directory(stcs_path) fn_avg = stcs_path + '%s' %(vevent) stcs = np.array(stcs_trial) stc_avg = np.sum(stcs, axis=0)/stcs.shape[0] stc_avg.save(fn_avg, ftype='stc') X1 = np.array(X1).transpose(0, 2, 1) X2 = np.array(X2).transpose(0, 2, 1) ############################################################################### # Compute statistic # To use an algorithm optimized for spatio-temporal clustering, we # just pass the spatial connectivity matrix (instead of spatio-temporal) print('Computing connectivity.') connectivity = spatial_tris_connectivity(grade_to_tris(5)) # Note that X needs to be a list of multi-dimensional array of shape # samples (subjects_k) x time x space, so we permute dimensions X = [X1, X2] # Now let's actually do the clustering. This can take a long time... # Here we set the threshold quite high to reduce computation. p_threshold = 0.0001 f_threshold = stats.distributions.f.ppf(1. - p_threshold / 2., X1.shape[0] - 1, X1.shape[0] - 1) print('Clustering.') clu = spatio_temporal_cluster_test(X, connectivity=connectivity, n_jobs=2, threshold=f_threshold) # Now select the clusters that are sig. at p < 0.05 (note that this value # is multiple-comparisons corrected). #fsave_vertices = [np.arange(10242), np.arange(10242)] tstep = stc_v.tstep #stc_all_cluster_vis = summarize_clusters_stc(clu, tstep=tstep, # vertices=fsave_vertices, # subject='fsaverage') #stc_sig = stc_all_cluster_vis.mean() #fn_sig = subjects_dir+'/fsaverage/%s_ROIs/%s' %(method,vevent) #stc_sig.save(fn_sig) tstep = stc_v.tstep T_obs, clusters, clu_pvals, _ = clu n_times, n_vertices = T_obs.shape good_cluster_inds = np.where(clu_pvals < 0.05)[0] seeds = [] # Build a convenient representation of each cluster, where each # cluster becomes a "time point" in the SourceEstimate T_obs = abs(T_obs) if len(good_cluster_inds) > 0: data = np.zeros((n_vertices, n_times)) for cluster_ind in good_cluster_inds: data.fill(0) v_inds = clusters[cluster_ind][1] t_inds = clusters[cluster_ind][0] data[v_inds, t_inds] = T_obs[t_inds, v_inds] # Store a nice visualization of the cluster by summing across time data = np.sign(data) * np.logical_not(data == 0) * tstep seed = np.argmax(data.sum(axis=-1)) seeds.append(seed) min_subject = 'fsaverage' labels_path = subjects_dir + '/fsaverage/dSPM_ROIs/%s/ini' %vevent reset_directory(labels_path) seeds = np.array(seeds) non_index_lh = seeds[seeds < 10242] if non_index_lh.shape != []: func_labels_lh = mne.grow_labels(min_subject, non_index_lh, extents=radius, hemis=0, subjects_dir=subjects_dir, n_jobs=1) i = 0 while i < len(func_labels_lh): func_label = func_labels_lh[i] func_label.save(labels_path + '/%s_%d' %(vevent, i)) i = i + 1 seeds_rh = seeds - 10242 non_index_rh = seeds_rh[seeds_rh > 0] if non_index_rh.shape != []: func_labels_rh = mne.grow_labels(min_subject, non_index_rh, extents=radius, hemis=1, subjects_dir=subjects_dir, n_jobs=1) # right hemisphere definition j = 0 while j < len(func_labels_rh): func_label = func_labels_rh[j] func_label.save(labels_path + '/%s_%d' %(vevent, j)) j = j + 1
def sublevel_spatial_stats(X, subject, index, stc, clust_p, modality, method, condition): con = mne.spatial_tris_connectivity(grade_to_tris(5)) # morphing data subjects_dir = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/mri/' fsave_vertices = [np.arange(10242), np.arange(10242)] subject_vertices = [stc.lh_vertno, stc.rh_vertno] morph_mat = compute_morph_matrix(subject, 'fsaverage', subject_vertices, fsave_vertices, 20, subjects_dir) n_vertices_fsave = morph_mat.shape[0] nobs = index[0] ncond = len(index) ntimes = X.shape[2] nvertices = stc.lh_vertno.shape[0] + stc.rh_vertno.shape[0] # We have to change the shape for the dot() to work properly X = np.transpose(X, [1, 2, 0]) # vertices * times * obs X = X.reshape(nvertices, ntimes * nobs * ncond) print('Morphing data.') X = morph_mat.dot(X) # morph_mat is a sparse matrix X = X.reshape(n_vertices_fsave, ntimes, nobs, ncond) # list of array of shapes ncond*(obs, time, vertices) X = np.transpose(X, [2, 1, 0, 3]) X = [np.squeeze(x) for x in np.split(X, 3, axis=-1)] # average over time to clusterize only on spatial dimension X = [np.mean(x, 1) for x in X] p_threshold = clust_p f_threshold = stats.distributions.f.ppf(1 - p_threshold, ncond - 1, ncond * (nobs - 1)) # use default function one-way anova (not repeated measures!) F_obs, clu, clu_p_val, H0 = mne.stats.permutation_cluster_test( X, threshold=f_threshold, connectivity=con, n_jobs=4, verbose=True, seed=666) wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/" save_path = (wdir + subject + '/mne_python/STATS') if not os.path.exists(save_path): os.makedirs(save_path) # save cluster stats spatial_clust_F = np.array((F_obs, clu, clu_p_val, H0)) np.save((save_path + '/' + modality + '_' + 'cluster_stats_' + "_vs_".join(condition)), spatial_clust_F) # save F-Map tmp = F_obs tmp = tmp[:, np.newaxis] fsave_vertices = [np.arange(10242), np.arange(10242)] stc_Ftest = mne.SourceEstimate(tmp, fsave_vertices, 0, stc.tstep) stc_Ftest.save( (save_path + '/' + modality + '_' + "_vs_".join(condition))) # to create probability maps: threshold the map at p < 0.05 and binarize ind = np.where(F_obs >= f_threshold)[0] VertKept = np.empty((len(F_obs))) for v, vertices in enumerate(VertKept): if v in ind: VertKept[v] = 1 else: VertKept[v] = 0 VertKept = VertKept[:, np.newaxis] fsave_vertices = [np.arange(10242), np.arange(10242)] stc_Ftest = mne.SourceEstimate(VertKept, fsave_vertices, 0, stc.tstep) stc_Ftest.save((save_path + '/' + modality + '_' + 'BinForProb_' + "_vs_".join(condition))) return F_obs, clu, clu_p_val, H0
def grouplevel_spatial_stats(ListSubj,condition,method,mod,twin,clust_p): wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG" # load a specific STC morphed on fsaverage to get shape info stc0_path = (wdir + '/' + ListSubj[0] + '/mne_python/STCS/IcaCorr_' + mod + '_' + ListSubj[0] + '_' + condition[0] + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc0 = mne.read_source_estimate(stc0_path) stc0.crop(-0.2,2.5) ncond = len(condition) nsub = len(ListSubj) ntimes = len(stc0.times) nvertices = stc0.data.shape[0] # average individual STCs morphed on fsaverage for each cond AVG_STC_cond = np.empty([nvertices, ntimes, nsub, ncond]) for s,subj in enumerate(ListSubj): for c,cond in enumerate(condition): stc_path = (wdir + '/' + subj + '/mne_python/STCS/IcaCorr_' + mod + '_' + subj + '_' + cond + '_pick_oriNone_' + method + '_ico-5-fwd-fsaverage.fif-rh.stc') stc = mne.read_source_estimate(stc_path) stc.crop(-0.2,2.5) AVG_STC_cond[:,:,s,c] = stc.data # optional: restrict computation to temporal window of interest lower_bound = np.where(stc0.times >= twin[0])[0][0] upper_bound = np.where(stc0.times >= twin[1])[0][0] con = mne.spatial_tris_connectivity(grade_to_tris(5)) # array of shapes (obs, time, vertices) X = [] for c,cond in enumerate(condition): X.append(np.mean(np.transpose(AVG_STC_cond[:,lower_bound: upper_bound,:,c], [2, 1, 0]),1)) effects = 'A' factor_levels = [3] # get f-values only. def mystat_fun(*args): return f_mway_rm(np.swapaxes(args, 1, 0), factor_levels=factor_levels, effects=effects, return_pvals=False)[0] p_threshold = clust_p f_threshold = f_threshold_mway_rm(nsub,factor_levels = factor_levels, effects = effects,pvalue= p_threshold) F_obs, clu, clu_p_val, H0 = mne.stats.permutation_cluster_test(X, threshold=f_threshold,stat_fun=mystat_fun, connectivity=con, n_jobs=1, verbose=True, seed = 666) wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/" save_path = (wdir+'GROUP/mne_python/Plot_STATS/' + "_vs_".join(condition)) if not os.path.exists(save_path): os.makedirs(save_path) # save cluster stats spatial_clust_F = np.array((F_obs, clu, clu_p_val, H0)) np.save((save_path+'/' + mod + '_' +'cluster_stats_f_'+ "_vs_".join(condition)), spatial_clust_F) # save F-Map tmp = F_obs tmp = tmp[:,np.newaxis] fsave_vertices = [np.arange(10242), np.arange(10242)] stc_Ftest = mne.SourceEstimate(tmp,fsave_vertices,0,stc.tstep) stc_Ftest.save((save_path + '/fmap' + mod + '_' + "_vs_".join(condition))) return F_obs, clu, clu_p_val, H0,stc0
effects=effects, return_pvals=return_pvals)[0] # get f-values only. # Note. for further details on this ANOVA function consider the # corresponding time frequency example. ############################################################################### # Compute clustering statistic # To use an algorithm optimized for spatio-temporal clustering, we # just pass the spatial connectivity matrix (instead of spatio-temporal) source_space = grade_to_tris(5) # as we only have one hemisphere we need only need half the connectivity lh_source_space = source_space[source_space[:, 0] < 10242] print('Computing connectivity.') connectivity = spatial_tris_connectivity(lh_source_space) # Now let's actually do the clustering. Please relax, on a small # notebook and one single thread only this will take a couple of minutes ... pthresh = 0.0005 f_thresh = f_threshold_twoway_rm(n_subjects, factor_levels, effects, pthresh) # To speed things up a bit we will ... n_permutations = 128 # ... run fewer permutations (reduces sensitivity) print('Clustering.') T_obs, clusters, cluster_p_values, H0 = clu = \ spatio_temporal_cluster_test(X, connectivity=connectivity, n_jobs=1, threshold=f_thresh, stat_fun=stat_fun, n_permutations=n_permutations, buffer_size=None)
tmin, tmax = time_interval times = mean_stc1.times mask = (times >= tmin) & (times <= tmax) X1 = np.mean(X1[:, :, mask], axis=2)[:, :, None] X2 = np.mean(X2[:, :, mask], axis=2)[:, :, None] template_stc = copy.deepcopy(template_stc) template_stc.crop(tmin, tmin + template_stc.tstep) assert X1.shape == X2.shape n_samples, n_vertices, n_times = X1.shape X1 = np.ascontiguousarray(np.swapaxes(X1, 1, 2).reshape(n_samples, -1)) X2 = np.ascontiguousarray(np.swapaxes(X2, 1, 2).reshape(n_samples, -1)) #connectivity = mne.spatio_temporal_src_connectivity(src, n_times) connectivity = spatial_tris_connectivity(grade_to_tris(5)) for t in thresholds: from time import time t0 = time() T_obs, clusters, cluster_pv, H0 = mem.cache( permutation_cluster_1samp_test, ignore=['n_jobs'])(X1 - X2, threshold=t, n_permutations=n_permutations, tail=0, stat_fun=stat_fun, connectivity=connectivity, n_jobs=n_jobs, seed=0) print "Time elapsed : %s (s)" % (time() - t0)
stc_fsaverage.save(stc_fname) betas.append(stc_fsaverage._data) all_betas.append(betas) # convert to np all_betas = np.array(all_betas, float) # dimension order should be obs x time x source all_betas = np.transpose(all_betas, [0, 1, 3, 2]) for ii, regressor in enumerate(var_names): save_dir = "%s/_RESULTS/%s" % (root_dir, regressor) # apply the permutation test connectivity = spatial_tris_connectivity(grade_to_tris(spacing)) t_obs, clusters, cluster_pv, H0 = p1samp(all_betas[:, ii, ...], threshold=4, n_permutations=n_perm, connectivity=connectivity, buffer_size=None, verbose=True) # save result of the cluster test np.save('%s/_stats_%s.npy' % (save_dir, regressor), (t_obs, clusters, cluster_pv, H0)) # remove clusters that are too short or too small or not significant # cluster_bool = threshold_clusters(clusters, cluster_pv, min_times, # min_sources, min_p) # save the t-value map as an stc. note: can extract np data with stc._data