#######looking at cluster-level significance ###for induced power epochs_power = np.swapaxes(np.asarray(epochs_power), 1, 0) effects = 'A:B' def stat_fun(*args): return f_mway_rm(np.swapaxes(args, 1, 0), factor_levels=factor_levels, effects=effects, return_pvals=False)[0] # The ANOVA returns a tuple f-values and p-values, we will pick the former. pthresh = 0.00001 # set threshold rather high to save some time f_thresh = f_threshold_mway_rm(n_replications, factor_levels, effects, pthresh) tail = 1 # f-test, so tail > 0 n_permutations = 256 # Save some time (the test won't be too sensitive ...) T_obs, clusters, cluster_p_values, h0 = mne.stats.permutation_cluster_test( epochs_power, stat_fun=stat_fun, threshold=f_thresh, tail=tail, n_jobs=1, n_permutations=n_permutations, buffer_size=None) mask, _ = fdr_correction(pvals[2]) T_obs_plot2 = np.ma.masked_array(T_obs, np.invert(mask)) plt.figure()
############################################################################### # 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_mway_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) # 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] ###############################################################################
############################################################################### # Compute clustering statistic # ---------------------------- # # To use an algorithm optimized for spatio-temporal clustering, we # just pass the spatial connectivity matrix (instead of spatio-temporal). # as we only have one hemisphere we need only need half the connectivity print('Computing connectivity.') connectivity = mne.spatial_src_connectivity(src[:1]) # 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_mway_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) # 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] ###############################################################################
# A stat_fun must deal with a variable number of input arguments. def stat_fun(*args): # Inside the clustering function each condition will be passed as # flattened array, necessitated by the clustering procedure. # The ANOVA however expects an input array of dimensions: # subjects X conditions X observations (optional). # The following expression catches the list input and swaps the first and # the second dimension and finally calls the ANOVA function. return f_mway_rm(np.swapaxes(args, 1, 0), factor_levels=factor_levels, effects=effects, return_pvals=False)[0] # The ANOVA returns a tuple f-values and p-values, we will pick the former. pthresh = 0.00001 # set threshold rather high to save some time f_thresh = f_threshold_mway_rm(n_replications, factor_levels, effects, pthresh) tail = 1 # f-test, so tail > 0 n_permutations = 256 # Save some time (the test won't be too sensitive ...) T_obs, clusters, cluster_p_values, h0 = mne.stats.permutation_cluster_test( epochs_power, stat_fun=stat_fun, threshold=f_thresh, tail=tail, n_jobs=1, n_permutations=n_permutations, buffer_size=None) # Create new stats image with only significant clusters good_clusers = np.where(cluster_p_values < .05)[0] T_obs_plot = np.ma.masked_array(T_obs, np.invert(clusters[np.squeeze(good_clusers)])) plt.figure() for f_image, cmap in zip([T_obs, T_obs_plot], [plt.cm.gray, 'RdBu_r']): plt.imshow(f_image, cmap=cmap, extent=[times[0], times[-1], frequencies[0], frequencies[-1]], aspect='auto',
plt.title(r"Time-locked response for '%s' " % (effect_label)) plt.show() effects = 'A:B' def stat_fun(*args): return f_mway_rm(np.swapaxes(args, 1, 0), factor_levels=factor_levels, effects=effects, return_pvals=False)[0] # The ANOVA returns a tuple f-values and p-values, we will pick the former. pthresh = 0.001 # set threshold rather high to save some time f_thresh = f_threshold_mway_rm(13, factor_levels, effects, pthresh) tail = 1 # f-test, so tail > 0 n_permutations = 10000 # Save some time (the test won't be too sensitive ...) T_obs, clusters, cluster_p_values, h0 = mne.stats.permutation_cluster_test( cond, stat_fun=stat_fun, threshold=f_thresh, tail=tail, n_jobs=1, n_permutations=n_permutations, buffer_size=None) good_clusters = np.where(cluster_p_values < .05)[0] T_obs_plot = np.ma.masked_array(T_obs, np.invert(clusters[np.squeeze(good_clusters)]))
spacing = 4 n_jobs = 4 parc = "RegionGrowing_70" with open("{}{}_apriori".format(proc_dir, parc), "rb") as f: labels = pickle.load(f) conds = ["audio", "visual", "visselten"] conds = ["audio", "visual"] wavs = ["4000fftf", "4000Hz", "7000Hz", "4000cheby"] effect_idx = 0 factor_levels = [len(conds), len(wavs)] effects = ["A", "B", "A:B"] return_pvals = False p_thresh = 0.001 threshold = f_threshold_mway_rm(len(subjs), [3, 4], effects[effect_idx], p_thresh) threshold = dict(start=0, step=0.1) cond_str = conds[0] for c in conds[1:]: cond_str += "_" + c thresh_str = "tfce" if isinstance(threshold, dict) else p_thresh # get connectivity fs_src = mne.read_source_spaces("{}{}_ico{}-src.fif".format( proc_dir, "fsaverage", spacing)) cnx = mne.spatial_src_connectivity(fs_src) #del fs_src exclude = np.load("{}fsaverage_ico{}_exclude.npy".format(proc_dir, spacing)) results = [] figures = [] brains = []
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
# y_label=['SD/LD' , 'SD/LD by ROIs'] y_label = ['SD/LD', 'ATLs', 'SD/LD by ATLs'] # y_label = ['SD/LD', 'ATLs'] # my_colors = ['mediumblue', 'darkgreen','darkred'] my_colors = ['b', 'g', 'purple'] ############################################################################### # 2-way repeated measure : F-test and cluster-based correction plt.figure(figsize=(9, 9)) plt.rcParams['font.size'] = '18' for e, effect in enumerate(effects): f_thresh = f_threshold_mway_rm(n_subjects, factor_levels, effects=effect, pvalue=p_threshold) p = 0 def stat_fun(*args): return f_mway_rm(np.swapaxes(args, 1, 0), factor_levels=factor_levels, effects=effect, return_pvals=False)[0] # The ANOVA returns a tuple f-values and p-values, we will pick the former. tail = 0 # f-test, so tail > 0 T_obs, clusters, cluster_p_values, h0 = mne.stats.permutation_cluster_test( X_SDLD_ATLs, stat_fun=stat_fun, threshold=f_thresh, tail=tail, n_jobs=4, n_permutations=n_permutations, buffer_size=None, out_type='mask') plt.subplot(len(effects), 1, e+1) # plt.legend(loc='upper left')