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 permutation_cluster_analysis(epochs, n_permutations=1000, plot=True):
"""
Do a spatio-temporal cluster analyis to compare experimental conditions.
"""
# get the data for each event in epochs.evet_id transpose because the cluster test requires
# channels to be last. In this case, inference is done over items. In the same manner, we could
# also conduct the test over, e.g., subjects.
tfce = dict(start=.2, step=.2)
time_unit = dict(time_unit="s")
events = list(epochs.event_id.keys())
if plot:
if len(events) == 2: # When comparing two events subtract evokeds
evoked = combine_evoked([epochs[events[0]].average(), -epochs[events[1]].average()],
weights='equal')
title = "%s vs %s" % (events[0], events[1])
elif len(events) > 2: # When comparing more than two events verage them
evoked = combine_evoked([epochs[e].average() for e in events], weights='equal')
evoked.data /= len(events)
title = ""
for e in events:
title += e+" + "
title = title[:-2]
evoked.plot_joint(title=title, ts_args=time_unit, topomap_args=time_unit)
X = [epochs[e].get_data().transpose(0, 2, 1) for e in events]
t_obs, clusters, cluster_pv, h0 = spatio_temporal_cluster_test(X, tfce, n_permutations)
significant_points = cluster_pv.reshape(t_obs.shape).T < .05
selections = make_1020_channel_selections(evoked.info, midline="12z")
fig, axes = plt.subplots(nrows=3, figsize=(8, 8))
axes = {sel: ax for sel, ax in zip(selections, axes.ravel())}
evoked.plot_image(axes=axes, group_by=selections, colorbar=False, show=False,
mask=significant_points, show_names="all", titles=None,
**time_unit)
plt.colorbar(axes["Left"].images[-1], ax=list(axes.values()), shrink=.3, label="µV")
plt.show()
def mne_spatio_temporal_cluster_test(X, **kwargs):
threshold_tfce = dict(start=0, step=0.2)
F_obs, _, p_values, _ = spatio_temporal_cluster_test(X, n_permutations=1000,
threshold=threshold_tfce, tail=1,
n_jobs=1, buffer_size=None,
connectivity=None)
return F_obs, p_values
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 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())
# 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]
###############################################################################
# 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
stc_all_cluster_vis = summarize_clusters_stc(clu,
tstep=tstep,
# Then we generate a distribution from the data by shuffling our conditions
# between our samples and recomputing our clusters and the test statistics.
# We test for the significance of a given cluster by computing the probability
# of observing a cluster of that size. For more background read:
# Maris/Oostenveld (2007), "Nonparametric statistical testing of EEG- and
# MEG-data" Journal of Neuroscience Methods, Vol. 164, No. 1., pp. 177-190.
# doi:10.1016/j.jneumeth.2007.03.024
# set cluster threshold
threshold = 50.0 # very high, but the test is quite sensitive on this data
# set family-wise p-value
p_accept = 0.001
cluster_stats = spatio_temporal_cluster_test(
X, n_permutations=1000, threshold=threshold, tail=1, n_jobs=1, connectivity=connectivity
)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
###############################################################################
# Note. The same functions work with source estimate. The only differences
# are the origin of the data, the size, and the connectivity definition.
# It can be used for single trials or for groups of subjects.
#
# Visualize clusters
# ------------------
# configure variables for visualization
times = epochs.times * 1e3
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'
)
# required to merge epochs from differen subjects together
ep.info["dev_head_t"] = None
X_low = ep["low"].get_data().transpose([0, 2, 1])
y_low = ep["low"].events[:, 2]
X_high = ep["high"].get_data().transpose([0, 2, 1])
y_high = ep["high"].events[:, 2]
erf_low = ep["low"].average()
erf_high = ep["high"].average()
p_accept = 0.05
cluster_stats = spatio_temporal_cluster_test(
[X_low, X_high],
n_permutations=100,
# threshold=threshold,
tail=0,
n_jobs=1,
buffer_size=None,
adjacency=adjacency,
)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
# organize data for plotting
evokeds = {"low": erf_low, "high": erf_high}
sel_idx = pick_types(info, meg="grad")
info.pick_channels([info.ch_names[s] for s in sel_idx])
plot_temporal_clusters(
good_cluster_inds, evokeds, T_obs, clusters, erf_low.times, info
# Then we generate a distribution from the data by shuffling our conditions
# between our samples and recomputing our clusters and the test statistics.
# We test for the significance of a given cluster by computing the probability
# of observing a cluster of that size. For more background read:
# Maris/Oostenveld (2007), "Nonparametric statistical testing of EEG- and
# MEG-data" Journal of Neuroscience Methods, Vol. 164, No. 1., pp. 177-190.
# doi:10.1016/j.jneumeth.2007.03.024
# set cluster threshold
threshold = 50.0 # very high, but the test is quite sensitive on this data
# set family-wise p-value
p_accept = 0.01
cluster_stats = spatio_temporal_cluster_test(X, n_permutations=1000,
threshold=threshold, tail=1,
n_jobs=1,
connectivity=connectivity)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
###############################################################################
# Note. The same functions work with source estimate. The only differences
# are the origin of the data, the size, and the connectivity definition.
# It can be used for single trials or for groups of subjects.
#
# Visualize clusters
# ------------------
# configure variables for visualization
colors = {"Aud": "crimson", "Vis": 'steelblue'}
# between our samples and recomputing our clusters and the test statistics.
# We test for the significance of a given cluster by computing the probability
# of observing a cluster of that size. For more background read:
# Maris/Oostenveld (2007), "Nonparametric statistical testing of EEG- and
# MEG-data" Journal of Neuroscience Methods, Vol. 164, No. 1., pp. 177-190.
# doi:10.1016/j.jneumeth.2007.03.024
# set cluster threshold
threshold = 50.0 # very high, but the test is quite sensitive on this data
# set family-wise p-value
p_accept = 0.01
cluster_stats = spatio_temporal_cluster_test(X,
n_permutations=1000,
threshold=threshold,
tail=1,
n_jobs=1,
buffer_size=None,
adjacency=adjacency)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
###############################################################################
# Note. The same functions work with source estimate. The only differences
# are the origin of the data, the size, and the adjacency definition.
# It can be used for single trials or for groups of subjects.
#
# Visualize clusters
# ------------------
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,
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 < 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,
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 SensorStatsPlot(condcomb, ListSubj, colors):
#ListSubj = ('sd130343','cb130477' , 'rb130313', 'jm100109',
# 'sb120316', 'tk130502','lm130479' , 'ms130534', 'ma100253', 'sl130503',
# 'mb140004','mp140019' , 'dm130250', 'hr130504', 'wl130316', 'rl130571')
ListSubj = ('sd130343', 'cb130477', 'rb130313', 'jm100109', 'tk130502',
'lm130479', 'ms130534', 'ma100253', 'sl130503', 'mb140004',
'mp140019', 'dm130250', 'hr130504', 'rl130571')
condcomb = ('EtPast', 'EtPre', 'EtFut')
colors = ((1, 0, 0), (1, 0.37, 0.15), (1, 0.75, 0.3))
#ipython --pylab
import mne
import numpy as np
import matplotlib.pyplot as plt
import itertools
from mne.stats import spatio_temporal_cluster_test
from mne.channels import read_ch_connectivity
from scipy import stats as stats
from mne.viz import plot_evoked_topo, iter_topography
import os
os.chdir('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/SCRIPTS/MNE_PYTHON')
os.environ['MNE_ROOT'] = '/neurospin/local/mne'
wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/"
# load FieldTrip neighbor definition to setup sensor connectivity
neighbor_file_mag = '/neurospin/local/fieldtrip/template/neighbours/neuromag306mag_neighb.mat' # mag
neighbor_file_grad = '/neurospin/local/fieldtrip/template/neighbours/neuromag306planar_neighb.mat' # grad
neighbor_file_eeg = '/neurospin/local/fieldtrip/template/neighbours/easycap64ch-avg_neighb.mat' # eeg
connectivity, ch_names = mne.channels.read_ch_connectivity(
neighbor_file_eeg, picks=range(60))
connectivity_mag, ch_names_mag = read_ch_connectivity(neighbor_file_mag)
connectivity_grad, ch_names_grad = read_ch_connectivity(neighbor_file_grad)
connectivity_eeg, ch_names_eeg = read_ch_connectivity(neighbor_file_eeg)
# evoked 0 to get the size of the matrix
fname0 = (wdir + ListSubj[0] + "/mne_python/MEEG_" + condcomb[0] + "_" +
ListSubj[0] + "-ave.fif")
evoked0 = mne.read_evokeds(fname0, condition=0, baseline=(-0.2, 0))
sensordatamat_meg_mag = np.empty(
[len(condcomb),
len(ListSubj), 102, evoked0.data.shape[1]])
sensordatamat_meg_grad = np.empty(
[len(condcomb),
len(ListSubj), 204, evoked0.data.shape[1]])
sensordatamat_meg_eeg = np.empty(
[len(condcomb),
len(ListSubj), 60, evoked0.data.shape[1]])
# define statistical threshold
p_threshold = 0.05
t_threshold = -stats.distributions.t.ppf(p_threshold / 2.,
len(ListSubj) - 1)
# compute grand averages
GDAVGmag, GDAVGgrad, GDAVGeeg = [], [], []
sensordatamat_meg_mag = np.empty(
(len(condcomb), len(ListSubj), 102, len(evoked0.times)))
sensordatamat_meg_grad = np.empty(
(len(condcomb), len(ListSubj), 204, len(evoked0.times)))
#sensordatamat_eeg = np.empty((len(condcomb),len(ListSubj),60 ,len(evoked0.times)))
for c in range(len(condcomb)):
evoked2plotmag, evoked2plotgrad, evoked2ploteeg = [], [], []
for i in range(len(ListSubj)):
fname_ave_meg = (wdir + ListSubj[i] + "/mne_python/MEEG_" +
condcomb[c] + "_" + ListSubj[i] + "-ave.fif")
tmp_evoked_meg = mne.read_evokeds(fname_ave_meg,
condition=0,
baseline=(-0.2, 0))
evoked2plotmag.append(tmp_evoked_meg.pick_types('mag'))
sensordatamat_meg_mag[c, i, ::, ::] = tmp_evoked_meg.data
tmp_evoked_meg = mne.read_evokeds(fname_ave_meg,
condition=0,
baseline=(-0.2, 0))
evoked2plotgrad.append(tmp_evoked_meg.pick_types('grad'))
sensordatamat_meg_grad[c, i, ::, ::] = tmp_evoked_meg.data
#tmp_evoked_meg = mne.read_evokeds(fname_ave_meg, condition=0, baseline=(-0.2, 0))
#evoked2ploteeg.append(tmp_evoked_meg.pick_types('eeg'))
#sensordatamat_eeg[c,i,::,::] = tmp_evoked_meg.data
GDAVGmag.append(mne.grand_average(evoked2plotmag))
GDAVGgrad.append(mne.grand_average(evoked2plotgrad))
#GDAVGeeg.append(mne.grand_average(evoked2ploteeg))
# plot topomaps of grand_averages
for ax, idx in iter_topography(GDAVGmag[0].info,
fig_facecolor='black',
axis_facecolor='black',
axis_spinecolor='k'):
for c, cond in enumerate(condcomb):
ax.plot(GDAVGmag[c].data[idx], color=colors[c])
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ "_".join([str(cond) for cond in condcomb]) + "_GDAVG_mags.eps",
format='eps',
dpi=1500)
plt.close()
mne.viz.plot_topo(GDAVGmag, color=['r', 'orange', 'y'])
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ "_".join([str(cond) for cond in condcomb]) + "_bis_GDAVG_mags.eps",
format='eps',
dpi=1500)
plt.close()
for ax, idx in iter_topography(GDAVGgrad[0].info,
fig_facecolor='black',
axis_facecolor='black',
axis_spinecolor='k'):
for c, cond in enumerate(condcomb):
ax.plot(GDAVGgrad[c].data[idx], color=colors[c])
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ "_".join([str(cond) for cond in condcomb]) + "_GDAVG_grads.eps",
format='eps',
dpi=1500)
plt.close()
mne.viz.plot_topo(GDAVGmag, color=['r', 'orange', 'y'])
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ "_".join([str(cond) for cond in condcomb]) + "_bis_GDAVG_grads.eps",
format='eps',
dpi=1500)
plt.close()
times = np.arange(-0.1, 0.9, 0.05)
for c in range(len(condcomb)):
GDAVGmag[c].plot_topomap(times,
ch_type='mag',
vmin=-40,
vmax=40,
average=0.05)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ str(condcomb[c]) + "_GDAVG_mags.eps",
format='eps',
dpi=1500)
plt.close()
GDAVGgrad[c].plot_topomap(times,
ch_type='grad',
vmin=-10,
vmax=10,
average=0.05)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ str(condcomb[c]) + "_GDAVG_grads.eps",
format='eps',
dpi=1500)
plt.close()
for combination in itertools.combinations(range(3), 2):
tmp = []
tmp = GDAVGmag[combination[0]] - GDAVGmag[combination[1]]
tmp.plot_topomap(times, ch_type='mag', vmin=-15, vmax=15, average=0.05)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ str(condcomb[combination[0]]) + '_minus_' +
str(condcomb[combination[1]]) + "_GDAVG_mags.eps",
format='eps',
dpi=1000)
plt.close()
tmp = []
tmp = GDAVGgrad[combination[0]] - GDAVGgrad[combination[1]]
tmp.plot_topomap(times, ch_type='grad', vmin=0, vmax=2, average=0.05)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/TOPOPLOT_ERF/"
+ str(condcomb[combination[0]]) + '_minus_' +
str(condcomb[combination[1]]) + "_GDAVG_grads.eps",
format='eps',
dpi=1000)
plt.close()
allcond_meg_mag = [
np.transpose(x, (0, 2, 1)) for x in sensordatamat_meg_mag
]
allcond_meg_grad = [
np.transpose(x, (0, 2, 1)) for x in sensordatamat_meg_grad
]
###############################################################################
t_threshold = -stats.distributions.t.ppf(0 / 2, len(ListSubj) - 1)
T_obs, clusters, cluster_p_values, HO = spatio_temporal_cluster_test(
allcond_meg_mag,
n_permutations=1024,
threshold=t_threshold,
tail=0,
n_jobs=4,
connectivity=connectivity_mag)
t_threshold = -stats.distributions.t.ppf(0 / 2, len(ListSubj) - 1)
T_obs, clusters, cluster_p_values, HO = spatio_temporal_cluster_test(
allcond_meg_grad,
n_permutations=1024,
threshold=t_threshold,
tail=0,
n_jobs=4,
connectivity=connectivity_grad)
)
fig.set_size_inches((20, 10))
plt.show()
adjacency, ch_names = find_ch_adjacency(info, ch_type="grad")
# set cluster threshold
threshold = 10.0 # very high, but the test is quite sensitive on this data
# set family-wise p-value
p_accept = 0.05
# X_low = X[y == LOW_CONF_EPOCH, ...].transpose(0, 2, 1)
# X_high = X[y == HIGH_CONF_EPOCH, ...].transpose(0, 2, 1)
cluster_stats = spatio_temporal_cluster_test(
[theta_power_low[:, np.newaxis, :], theta_power_high[:, np.newaxis, :]],
n_permutations=100,
threshold=threshold,
tail=1,
n_jobs=1,
buffer_size=None,
adjacency=adjacency,
)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
# organize data for plotting
evokeds = {"low": erf_low, "high": erf_high}
plot_temporal_clusters(good_cluster_inds, evokeds, T_obs, clusters,
erf_low.times, info)
from mne.stats import (spatio_temporal_cluster_1samp_test, summarize_clusters_stc)
print('Clustering.')
T_obs, clusters, cluster_p_values, H0 = clu = \
spatio_temporal_cluster_1samp_test(X, connectivity=connectivity, n_jobs=1,
threshold=t_threshold, buffer_size = None)
# Now select the clusters that are sig. at p < 0.05 (note that this value
# is multiple-comparisons corrected).
#%%
from mne.stats import spatio_temporal_cluster_test
good_cluster_inds = np.where(cluster_p_values < 0.1)[0]
a = spatio_temporal_cluster_test(
X, threshold=None, n_permutations=1024, tail=0, stat_fun=None,
connectivity=None, verbose=None, n_jobs=1, seed=None, max_step=1,
spatial_exclude=None, step_down_p=0, t_power=1, out_type='indices',
check_disjoint=False)
#%%############################################################################
# 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
stc_all_cluster_vis = summarize_clusters_stc(clu, p_thresh=0.1, tstep=tstep,
vertices=fsave_vertices, subject=subject)
#%% Let's actually plot the first "time point" in the SourceEstimate, which
# shows all the clusters, weighted by duration
subjects_dir = os.path.join(mainDir)
epochs = mne.read_epochs(epochs_folder +
'%s_trial_start-epo.fif' % subject)
epochs.pick_types(meg="mag")
X_ctl_left[j, :, :] = epochs["ctl/left"].average().data.T
X_ctl_right[j, :, :] = epochs["ctl/right"].average().data.T
X_ent_left[j, :, :] = epochs["ent/left"].average().data.T
X_ent_right[j, :, :] = epochs["ent/right"].average().data.T
X = [X_ctl_left, X_ctl_right, X_ent_left, X_ent_right]
###############################################################################
# load FieldTrip neighbor definition to setup sensor connectivity
connectivity, ch_names = read_ch_connectivity('neuromag306mag')
# set cluster threshold
# set family-wise p-value
p_accept = 0.05
cluster_stats = spatio_temporal_cluster_test(X,
n_permutations=5000,
tail=0,
n_jobs=3,
connectivity=connectivity)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
pickle.dump(cluster_stats, open(result_dir + "/cluster_stats_pow_mag.p", "wb"))
connectivity = spatial_src_connectivity(src)
# 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=1,
threshold=f_threshold, 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]
###############################################################################
# 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,
print(f"NO MATCH FOR {trial_path}")
X_high = np.array(X_high)
X_low = np.array(X_low)
print("X_high.shape = ", X_high.shape)
print("X_low.shape = ", X_low.shape)
adjacency = spatial_src_adjacency(src)
thresh_pv = 0.02
F_obs, clusters, cluster_pv, H0 = clu = spatio_temporal_cluster_test(
[X_high, X_low],
# threshold=8,
n_permutations=100,
adjacency=adjacency,
out_type="indices",
check_disjoint=True,
stat_fun=ttest_ind_no_p,
)
stc_all_cluster_vis = summarize_clusters_stc(
clu,
p_thresh=thresh_pv,
# p_thresh=0.05,
vertices=src,
subject="fsaverage",
)
stc_all_cluster_vis
stc_all_cluster_vis.plot(subjects_dir=dirs.fsf_subjects, hemi="both")
connectivity = spatial_src_connectivity(src)
# 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=1,
threshold=f_threshold, 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]
###############################################################################
# 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,
plt.show()
adjacency, ch_names = find_ch_adjacency(info, ch_type=ch_type)
# set cluster threshold
threshold = 6.0 # very high, but the test is quite sensitive on this data
# set family-wise p-value
p_accept = 0.05
psds_low_t = psds_low.transpose(0, 2, 1)
psds_high_t = psds_high.transpose(0, 2, 1)
cluster_stats = spatio_temporal_cluster_test(
[psds_low_t, psds_high_t],
n_permutations=500,
threshold=threshold,
tail=1,
n_jobs=8,
buffer_size=None,
adjacency=adjacency,
)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
colors = {"low": "crimson", "high": "steelblue"}
linestyles = {"low": "-", "high": "--"}
# organize data for plotting
info['sfreq'] = len(freqs) / freqs[-1]
evokeds = {
"low": EvokedArray(psds_low.mean(0), info, tmin=freqs[0]),
"high": EvokedArray(psds_high.mean(0), info, tmin=freqs[0]),
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.0 - p_threshold / 2.0, 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, 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 < 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")
def SensorStatsPlot(condcomb, ListSubj, colors):
#ListSubj = ('sd130343','cb130477' , 'rb130313', 'jm100109',
# 'sb120316', 'tk130502','lm130479' , 'ms130534', 'ma100253', 'sl130503',
# 'mb140004','mp140019' , 'dm130250', 'hr130504', 'wl130316', 'rl130571')
#ListSubj = ('sd130343','cb130477' , 'rb130313', 'jm100109',
# 'tk130502','lm130479' , 'ms130534', 'ma100253', 'sl130503',
# 'mb140004','mp140019' , 'dm130250', 'hr130504', 'rl130571')
#condcomb = ('QtPast' ,'QtPre','QtFut' )
#condcomb = ('QsWest' ,'QsPar','QsEast')
#ipython --pylab
import mne
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
from mne.viz import plot_topomap
from mne.stats import spatio_temporal_cluster_test
from mne.datasets import sample
from mne.channels import read_ch_connectivity
from scipy import stats as stats
from mne.viz import plot_topo
import os
os.chdir('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/SCRIPTS/MNE_PYTHON')
os.environ['MNE_ROOT'] = '/neurospin/local/mne'
wdir = "/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/"
# load FieldTrip neighbor definition to setup sensor connectivity
neighbor_file_mag = '/neurospin/local/fieldtrip/template/neighbours/neuromag306mag_neighb.mat' # mag
neighbor_file_grad = '/neurospin/local/fieldtrip/template/neighbours/neuromag306planar_neighb.mat' # grad
neighbor_file_eeg = '/neurospin/local/fieldtrip/template/neighbours/easycap64ch-avg_neighb.mat' # eeg
connectivity, ch_names = mne.channels.read_ch_connectivity(
neighbor_file_eeg, picks=range(60))
connectivity_mag, ch_names_mag = read_ch_connectivity(neighbor_file_mag)
connectivity_grad, ch_names_grad = read_ch_connectivity(neighbor_file_grad)
connectivity_eeg, ch_names_eeg = read_ch_connectivity(neighbor_file_eeg)
# evoked 0 to get the size of the matrix
fname0 = (wdir + ListSubj[0] + "/mne_python/MEEG_" + condcomb[0] + "_" +
ListSubj[0] + "-ave.fif")
evoked0 = mne.read_evokeds(fname0, condition=0, baseline=(-0.2, 0))
sensordatamat_meg_mag = np.empty(
[len(condcomb),
len(ListSubj), 102, evoked0.data.shape[1]])
sensordatamat_meg_grad = np.empty(
[len(condcomb),
len(ListSubj), 204, evoked0.data.shape[1]])
sensordatamat_meg_eeg = np.empty(
[len(condcomb),
len(ListSubj), 60, evoked0.data.shape[1]])
# define statistical threshold
p_threshold = 0.05
t_threshold = -stats.distributions.t.ppf(p_threshold / 2.,
len(ListSubj) - 1)
# compute grand averages
GDAVGmag, GDAVGgrad, GDAVGeeg = [], [], []
sensordatamat_meg_mag = np.empty(
(len(condcomb), len(ListSubj), 102, len(evoked0.times)))
sensordatamat_meg_grad = np.empty(
(len(condcomb), len(ListSubj), 204, len(evoked0.times)))
#sensordatamat_eeg = np.empty((len(condcomb),len(ListSubj),60 ,len(evoked0.times)))
for c in range(len(condcomb)):
evoked2plotmag, evoked2plotgrad, evoked2ploteeg = [], [], []
for i in range(len(ListSubj)):
fname_ave_meg = (wdir + ListSubj[i] + "/mne_python/MEEG_" +
condcomb[c] + "_" + ListSubj[i] + "-ave.fif")
tmp_evoked_meg = mne.read_evokeds(fname_ave_meg,
condition=0,
baseline=(-0.2, 0))
evoked2plotmag.append(tmp_evoked_meg.pick_types('mag'))
sensordatamat_meg_mag[c, i, ::, ::] = tmp_evoked_meg.data
tmp_evoked_meg = mne.read_evokeds(fname_ave_meg,
condition=0,
baseline=(-0.2, 0))
evoked2plotgrad.append(tmp_evoked_meg.pick_types('grad'))
sensordatamat_meg_grad[c, i, ::, ::] = tmp_evoked_meg.data
#tmp_evoked_meg = mne.read_evokeds(fname_ave_meg, condition=0, baseline=(-0.2, 0))
#evoked2ploteeg.append(tmp_evoked_meg.pick_types('eeg'))
#sensordatamat_eeg[c,i,::,::] = tmp_evoked_meg.data
GDAVGmag.append(mne.grand_average(evoked2plotmag))
GDAVGgrad.append(mne.grand_average(evoked2plotgrad))
#GDAVGeeg.append(mne.grand_average(evoked2ploteeg))
# plot topomaps of grand_averages
plot_topo(GDAVGmag, color=colors)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/"
+ "_".join([str(cond) for cond in condcomb]) + "_GDAVG_mags")
plot_topo(GDAVGgrad, color=colors)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/"
+ "_".join([str(cond) for cond in condcomb]) + "_GDAVG_grads")
times = np.arange(-0.1, 0.9, 0.05)
for c in range(len(condcomb)):
GDAVGmag[c].plot_topomap(times,
ch_type='mag',
vmin=-40,
vmax=40,
average=0.05)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/"
+ str(condcomb[c]) + "_GDAVG_mags")
GDAVGgrad[c].plot_topomap(times,
ch_type='grad',
vmin=-10,
vmax=10,
average=0.05)
plt.savefig(
"/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/decoding_context_yousra/"
+ str(condcomb[c]) + "_GDAVG_grads")
allcond_meg_mag = [
np.transpose(x, (0, 2, 1)) for x in sensordatamat_meg_mag
]
allcond_meg_grad = [
np.transpose(x, (0, 2, 1)) for x in sensordatamat_meg_grad
]
###############################################################################
t_threshold = -stats.distributions.t.ppf(0 / 2, len(ListSubj) - 1)
T_obs, clusters, cluster_p_values, HO = spatio_temporal_cluster_test(
allcond_meg_mag[0::1],
n_permutations=1024,
threshold=t_threshold,
tail=0,
n_jobs=4,
connectivity=connectivity_mag)
t_threshold = -stats.distributions.t.ppf(0 / 2, len(ListSubj) - 1)
T_obs, clusters, cluster_p_values, HO = spatio_temporal_cluster_test(
allcond_meg_grad,
n_permutations=1024,
threshold=t_threshold,
tail=0,
n_jobs=4,
connectivity=connectivity_grad)
data_invol = np.rollaxis(data_invol, 2, 1)
neighbor_file = '/home/mje/Toolboxes/fieldtrip/template/neighbours' \
'/biosemi64_neighb'
connectivity, ft_ch_names = mne.channels.read_ch_connectivity(neighbor_file,
picks=picks)
threshold = None
n_permutations = 2000
tail = 0
T_obs, clusters, cluster_p_values, H0 =\
spatio_temporal_cluster_test([data_vol, data_invol],
n_permutations=n_permutations,
threshold=threshold,
tail=tail,
out_type="mask",
connectivity=connectivity,
n_jobs=2)
# PLOT
# Make evoked difference between the two conditions.
diff_wave = epochs["voluntary"].average() -\
epochs["involuntary"].average()
diff_wave.crop(test_times[0], test_times[-1])
min_cluster_index = cluster_p_values.argmin()
mask = np.squeeze(clusters[min_cluster_index][:, np.newaxis].T)
plot_times = np.arange(-0.5, 0.5, 0.1)
diff_wave.plot_topomap(times=plot_times, ch_type='eeg',
y_df.query(
'metric_type=="{}" & subj_id=="{}" & channel=="{}"'.format(
metric_type, s, ch))['env'].values for ch in CHANNELS
] for s in y_df.query('fb_type=="FBMock"')['subj_id'].unique()]),
2, 1)
from mne.stats import spatio_temporal_cluster_test
from mne import create_info
from mne.channels import read_montage, find_ch_connectivity
cnk = find_ch_connectivity(
create_info(CHANNELS, 250, 'eeg', read_montage('standard_1005')),
'eeg')[0]
t_obs, clusters, cluster_pv, h0 = spatio_temporal_cluster_test(
[g1, g2], 138, stat_fun=rankstat, tail=1, connectivity=cnk)
cluster_pv
good_cluster_inds = np.where(cluster_pv < 0.05)[0]
for i_clu, clu_idx in enumerate(good_cluster_inds[:10]):
# unpack cluster information, get unique indices
time_inds, space_inds = np.squeeze(clusters[clu_idx])
ch_inds = np.unique(space_inds)
time_inds = np.unique(time_inds)
# get topography for F stat
f_map = t_obs[time_inds, ...].mean(axis=0)
# get signals at the sensors contributing to the cluster
sig_times = np.arange(30)[time_inds]
'%s_trial_start-epo.fif' % subject)
epochs.pick_types(meg="mag")
X_ctl_left[j, :, :] = epochs["ctl/left"].average().data.T
X_ctl_right[j, :, :] = epochs["ctl/right"].average().data.T
X_ent_left[j, :, :] = epochs["ent/left"].average().data.T
X_ent_right[j, :, :] = epochs["ent/right"].average().data.T
X = [X_ctl_left, X_ctl_right, X_ent_left, X_ent_right]
###############################################################################
# load FieldTrip neighbor definition to setup sensor connectivity
connectivity, ch_names = read_ch_connectivity('neuromag306mag')
# set cluster threshold
# set family-wise p-value
p_accept = 0.05
cluster_stats = spatio_temporal_cluster_test(X, n_permutations=5000,
tail=0,
n_jobs=3,
connectivity=connectivity)
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < p_accept)[0]
pickle.dump(cluster_stats, open(result_dir +
"/cluster_stats_pow_mag.p", "wb"))
print('[Main effect of Category]')
stat_fun = stat_fun_Category
savedirname = 'MainEffect_Category'
elif ef == 'B':
print('[Main effect of SF]')
stat_fun = stat_fun_SF
savedirname = 'MainEffect_SF'
elif ef == 'A:B':
print('[Category x SF interaction]')
stat_fun = stat_fun_Interaction
savedirname = 'Interaction'
# ANOVA with cluster-based permutation test
startT = time.time()
scores, _, p_val, H0 = spatio_temporal_cluster_test(Dataset, threshold=thresh, n_permutations=Nperm, tail=tail,
connectivity=connectivity, n_jobs=njobs, buffer_size=None,
spatial_exclude=excludedVerts, stat_fun=stat_fun)
elapsed_time = (time.time() - startT)/60
p_val = p_val.reshape(scores.shape)
# save results
os.chdir(savedir)
if not os.path.exists('./'+savedirname):
os.mkdir('./'+savedirname)
os.chdir('./'+savedirname)
np.save('TFCEscores.npy', scores)
np.save('Pvalues.npy', p_val)
np.save('ObservedClusterLevelStats.npy', H0)
print(' -> Finished.')
return coo_matrix(dists < dist), labels
if __name__ == "__main__":
X, dfs = load_source_data()
conf_mask = np.logical_and(dfs.confidence > 0, dfs.confidence < 100)
X = X[conf_mask, :, :]
dfs = dfs[conf_mask]
low_mask = dfs.confidence < 40
high_mask = dfs.confidence > 60
X_low = X[low_mask, :, :].transpose(0, 2, 1)
X_high = X[high_mask, :, :].transpose(0, 2, 1)
adj, labels = get_label_adjacency()
cluster_stats = spatio_temporal_cluster_test(
[X_low, X_high], adjacency=adj, n_permutations=100, threshold=6
)
T_obs, clusters, p_values, _ = cluster_stats
thresh = 0.05
good_cluster_inds = (p_values < thresh).nonzero()[0]
times = np.arange(-1, 1.002, 0.002)
for g in good_cluster_inds:
print("-" * 80)
lab_inds = np.unique(clusters[g][1])
time_inds = np.unique(clusters[g][0])
for lb in lab_inds:
print(labels[lb].name)
print([int(times[t] * 1000) for t in time_inds])
data_invol = np.rollaxis(data_invol, 2, 1)
neighbor_file = '/home/mje/Toolboxes/fieldtrip/template/neighbours' \
'/biosemi64_neighb'
connectivity, ft_ch_names = mne.channels.read_ch_connectivity(neighbor_file,
picks=picks)
threshold = None
n_permutations = 2000
tail = 0
T_obs, clusters, cluster_p_values, H0 =\
spatio_temporal_cluster_test([data_vol, data_invol],
n_permutations=n_permutations,
threshold=threshold,
tail=tail,
out_type="mask",
connectivity=connectivity,
n_jobs=2)
# PLOT
# Make evoked difference between the two conditions.
diff_wave = epochs["voluntary"].average() -\
epochs["involuntary"].average()
diff_wave.crop(test_times[0], test_times[-1])
min_cluster_index = cluster_p_values.argmin()
mask = np.squeeze(clusters[min_cluster_index][:, np.newaxis].T)
plot_times = np.arange(-0.5, 0.5, 0.1)
diff_wave.plot_topomap(times=plot_times,
# Calculate adjacency matrix between sensors from their locations
adjacency, _ = find_ch_adjacency(epochs.info, "eeg")
# Extract data: transpose because the cluster test requires channels to be last
# In this case, inference is done over items. In the same manner, we could
# also conduct the test over, e.g., subjects.
X = [
long_words.get_data().transpose(0, 2, 1),
short_words.get_data().transpose(0, 2, 1)
]
tfce = dict(start=.4, step=.4) # ideally start and step would be smaller
# Calculate statistical thresholds
t_obs, clusters, cluster_pv, h0 = spatio_temporal_cluster_test(
X, tfce, adjacency=adjacency,
n_permutations=100) # a more standard number would be 1000+
significant_points = cluster_pv.reshape(t_obs.shape).T < .05
print(str(significant_points.sum()) + " points selected by TFCE ...")
##############################################################################
# The results of these mass univariate analyses can be visualised by plotting
# :class:`mne.Evoked` objects as images (via :class:`mne.Evoked.plot_image`)
# and masking points for significance.
# Here, we group channels by Regions of Interest to facilitate localising
# effects on the head.
# We need an evoked object to plot the image to be masked
evoked = mne.combine_evoked(
[long_words.average(), short_words.average()],
weights=[1, -1]) # calculate difference wave
from scipy import stats as stats
from mne import spatial_tris_connectivity, grade_to_tris
from mne.stats import spatio_temporal_cluster_test, summarize_clusters_stc
f_threshold = 0.01
st_max, st_min = 0.3, 0. # time period of stimulus
res_max, res_min = 0.1, -0.2 # time period of response
subjects_dir = '/home/uais_common/dong/freesurfer/subjects/'
stcs_path = subjects_dir + '/fsaverage/conf_stc/'
st_list = ['LLst', 'RRst', 'RLst', 'LRst'] # stimulus events
res_list = ['LLrt', 'RRrt', 'LRrt', 'RLrt']
do_arange = True
if do_arange:
tstep, X = ara_trivsres(st_list, res_list, st_min, st_max, res_min,
res_max, stcs_path, subjects_dir)
else:
res_mat = np.load(stcs_path + 'res.npz')
tri_mat = np.load(stcs_path + 'tri.npz')
X = [tri_mat['tri'], res_mat['res']]
tstep = tri_mat['tstep']
fsave_vertices = [np.arange(10242), np.arange(10242)]
connectivity = spatial_tris_connectivity(grade_to_tris(5))
T_obs, clusters, cluster_p_values, H0 = clu = \
spatio_temporal_cluster_test(X, n_permutations=8192/2, #step_down_p=0.001,
connectivity=connectivity, n_jobs=1,
# threshold=t_threshold, stat_fun=stats.ttest_ind)
threshold=f_threshold)
np.savez(stcs_path + 'trivsres.npz',
clu=clu,
tstep=tstep,
fsave_vertices=fsave_vertices)
# correcting for multiple tests.
# MNE offers various methods for this; amongst them, cluster-based permutation
# methods allow deriving power from the spatio-temoral correlation structure
# of the data. Here, we use TFCE.
# Calculate statistical thresholds
con = find_ch_connectivity(epochs.info, "eeg")
# Extract data: transpose because the cluster test requires channels to be last
# In this case, inference is done over items. In the same manner, we could
# also conduct the test over, e.g., subjects.
X = [long.get_data().transpose(0, 2, 1),
short.get_data().transpose(0, 2, 1)]
tfce = dict(start=.2, step=.2)
t_obs, clusters, cluster_pv, h0 = spatio_temporal_cluster_test(
X, tfce, n_permutations=100)
significant_points = cluster_pv.reshape(t_obs.shape).T < .05
print(str(significant_points.sum()) + " points selected by TFCE ...")
##############################################################################
# The results of these mass univariate analyses can be visualised by plotting
# :class:`mne.Evoked` objects as images (via :class:`mne.Evoked.plot_image`)
# and masking points for significance.
# Here, we group channels by Regions of Interest to facilitate localising
# effects on the head.
# We need an evoked object to plot the image to be masked
evoked = mne.combine_evoked([long.average(), -short.average()],
weights='equal') # calculate difference wave
time_unit = dict(time_unit="s")
evoked.plot_joint(title="Long vs. short words", ts_args=time_unit,
# correcting for multiple tests.
# MNE offers various methods for this; amongst them, cluster-based permutation
# methods allow deriving power from the spatio-temoral correlation structure
# of the data. Here, we use TFCE.
# Calculate statistical thresholds
con = find_ch_connectivity(epochs.info, "eeg")
# Extract data: transpose because the cluster test requires channels to be last
# In this case, inference is done over items. In the same manner, we could
# also conduct the test over, e.g., subjects.
X = [long_words.get_data().transpose(0, 2, 1),
short_words.get_data().transpose(0, 2, 1)]
tfce = dict(start=.2, step=.2)
t_obs, clusters, cluster_pv, h0 = spatio_temporal_cluster_test(
X, tfce, n_permutations=100) # a more standard number would be 1000+
significant_points = cluster_pv.reshape(t_obs.shape).T < .05
print(str(significant_points.sum()) + " points selected by TFCE ...")
##############################################################################
# The results of these mass univariate analyses can be visualised by plotting
# :class:`mne.Evoked` objects as images (via :class:`mne.Evoked.plot_image`)
# and masking points for significance.
# Here, we group channels by Regions of Interest to facilitate localising
# effects on the head.
# We need an evoked object to plot the image to be masked
evoked = mne.combine_evoked([long_words.average(), -short_words.average()],
weights='equal') # calculate difference wave
time_unit = dict(time_unit="s")
evoked.plot_joint(title="Long vs. short words", ts_args=time_unit,
# as we only have one hemisphere we need only need half the adjacency
print('Computing adjacency.')
adjacency = mne.spatial_src_adjacency(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.005
f_thresh = f_threshold_mway_rm(n_subjects, factor_levels, effects, pthresh)
# To speed things up a bit we will ...
n_permutations = 50 # ... run way fewer permutations (reduces sensitivity)
print('Clustering.')
F_obs, clusters, cluster_p_values, H0 = clu = \
spatio_temporal_cluster_test(X, adjacency=adjacency, n_jobs=None,
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]
# %%
# 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
stc_all_cluster_vis = summarize_clusters_stc(clu, tstep=tstep,
vertices=fsave_vertices,
def run_sensor_stats():
for c in np.arange(len(config.stats_params)):
# organise data and analysis parameters
dat0_files = config.stats_params[c]['dat0_files']
dat1_files = config.stats_params[c]['dat1_files']
condnames = config.stats_params[c]['condnames']
tmin, tmax = config.stats_params[c]['statwin']
n_permutations = config.stats_params[c]['n_permutations']
p_threshold = config.stats_params[c]['threshold']
tail = config.stats_params[c]['tail']
if tail == 0:
p_threshold = p_threshold / 2
tail_x = 1
else:
tail_x = tail
if 'multi-subject' in config.stats_params[c] and config.stats_params[c]['multi-subject'] == True:
# we will run the same analysis on each subject separately
nruns = len(dat0_files)
ismulti = True
else:
nruns = 1
ismulti = False
results = [] # to store the results later
for statrun in np.arange(nruns):
if ismulti:
# we will run the same analysis on each subject separately
dat0, evokeds0, connectivity = collect_data([dat0_files[statrun]],condnames[0],tmin,tmax,ismulti)
dat1, evokeds1, _ = collect_data([dat1_files[statrun]],condnames[1],tmin,tmax,ismulti)
else:
# collect together the data to be compared
dat0, evokeds0, connectivity = collect_data(dat0_files,condnames[0],tmin,tmax,ismulti)
dat1, evokeds1, _ = collect_data(dat1_files,condnames[1],tmin,tmax,ismulti)
alldata = []
# fix threshold to be one-sided if requested
if type(p_threshold) != 'dict': # i.e. is NOT TFCE
if config.stats_params[c]['stat'] == 'indep':
stat_fun = ttest_ind_no_p
if len(dat0_files) == 1: # ie is single subject stats
df = dat0.data.shape[0] - 1 + dat1.data.shape[0] - 1
else:
df = len(dat0_files) - 1 + len(dat1_files) - 1
else: # ie is dependent data, and so is one-sample t test
# this will only ever be group data...
# If the length of dat0_files and dat1_files are different it'll crash later anyway
stat_fun = ttest_1samp_no_p
df = len(dat0_files) - 1
threshold_stat = stats.distributions.t.ppf(1. - p_threshold, df) * tail_x
else: # i.e. is TFCE
threshold_stat = p_threshold
# run the stats
if config.stats_params[c]['stat'] == 'indep':
alldata = [dat0,dat1]
cluster_stats = spatio_temporal_cluster_test(alldata, n_permutations=n_permutations,
threshold=threshold_stat,
tail=tail, stat_fun=stat_fun,
n_jobs=1, buffer_size=None,
connectivity=connectivity)
elif config.stats_params[c]['stat'] == 'dep':
# we have to use 1-sample t-tests here so also need to subtract conditions
alldata = dat0 - dat1
cluster_stats = spatio_temporal_cluster_1samp_test(alldata, n_permutations=n_permutations,
threshold=threshold_stat,
tail=tail, stat_fun=stat_fun,
n_jobs=1, buffer_size=None,
connectivity=connectivity)
# extract stats of interest
T_obs, clusters, p_values, _ = cluster_stats
good_cluster_inds = np.where(p_values < config.stats_params[c]['p_accept'])[0]
# tell the user the results
print('There are {} significant clusters'.format(good_cluster_inds.size))
if good_cluster_inds.size != 0:
print('p-values: {}'.format(p_values[good_cluster_inds]))
else:
if p_values.any():
print('Minimum p-value: {}'.format(np.min(p_values)))
else:
print('No clusters found')
# some final averaging and tidying
if len(evokeds0) == 1:
dat0_avg = evokeds0[0].average()
dat1_avg = evokeds1[0].average()
else:
dat0_avg = mne.grand_average(evokeds0)
dat1_avg = mne.grand_average(evokeds1)
diffcond_avg = mne.combine_evoked([dat0_avg, -dat1_avg], 'equal')
# get sensor positions via layout
pos = mne.find_layout(evokeds0[0].info).pos
## EVENTUALLY I WILL PUT THE PLOTTING IN A SEPARATE FUNCTION...
do_plot = False
if do_plot:
# loop over clusters
for i_clu, clu_idx in enumerate(good_cluster_inds):
# unpack cluster information, get unique indices
time_inds, space_inds = np.squeeze(clusters[clu_idx])
ch_inds = np.unique(space_inds)
time_inds = np.unique(time_inds)
# get topography for F stat
f_map = T_obs[time_inds, ...].mean(axis=0)
# get topography of difference
time_shift = evokeds0[0].time_as_index(tmin) # fix windowing shift
print('time_shift = {}'.format(time_shift))
sig_times_idx = time_inds + time_shift
diff_topo = np.mean(diffcond_avg.data[:,sig_times_idx],axis=1)
sig_times = evokeds0[0].times[sig_times_idx]
# create spatial mask
mask = np.zeros((f_map.shape[0], 1), dtype=bool)
mask[ch_inds, :] = True
# initialize figure
fig, ax_topo = plt.subplots(1, 1, figsize=(10, 3))
# plot average difference and mark significant sensors
image, _ = plot_topomap(diff_topo, pos, mask=mask, axes=ax_topo, cmap='RdBu_r',
vmin=np.min, vmax=np.max, show=False)
# create additional axes (for ERF and colorbar)
divider = make_axes_locatable(ax_topo)
# add axes for colorbar
ax_colorbar = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(image, cax=ax_colorbar)
ax_topo.set_xlabel(
'Mean difference ({:0.3f} - {:0.3f} s)'.format(*sig_times[[0, -1]]))
# add new axis for time courses and plot time courses
ax_signals = divider.append_axes('right', size='300%', pad=1.2)
title = 'Cluster #{0}, {1} sensor'.format(i_clu + 1, len(ch_inds))
if len(ch_inds) > 1:
title += "s (mean)"
plot_compare_evokeds([dat0_avg, dat1_avg], title=title, picks=ch_inds, axes=ax_signals,
colors=None, show=False,
split_legend=False, truncate_yaxis='max_ticks')
# plot temporal cluster extent
ymin, ymax = ax_signals.get_ylim()
ax_signals.fill_betweenx((ymin, ymax), sig_times[0], sig_times[-1],
color='orange', alpha=0.3)
# clean up viz
mne.viz.tight_layout(fig=fig)
fig.subplots_adjust(bottom=.05)
plt.show()
results.append({
'cluster_stats': cluster_stats,
'good_cluster_inds': good_cluster_inds,
'alldata': alldata,
'evokeds0': evokeds0,
'evokeds1': evokeds1
})
# save
save_name = op.join(config.stat_path, config.stats_params[c]['analysis_name'] + '.dat')
pickle_out = open(save_name,'wb')
pickle.dump(results, pickle_out)
pickle_out.close()
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,
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 < 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,
vertno=fsave_vertices,
subject='fsaverage')
adjacency = spatial_src_adjacency(src)
# 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, adjacency=adjacency, n_jobs=1,
threshold=f_threshold, 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]
###############################################################################
# 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,
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)
# 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
stc_all_cluster_vis = summarize_clusters_stc(clu, tstep=tstep,
vertices=fsave_vertices,
subject='fsaverage')
def erp_analysis(subjects):
from mne.stats import spatio_temporal_cluster_test
from mne.channels import read_ch_connectivity
from mpl_toolkits.axes_grid1 import make_axes_locatable
from scipy import stats as stats
all_evo = {'off_sup_lon': list(), 'off_sup_sho': list()}
all_log = list()
condition_names = ['S2 Longer', 'S2 Shorter']
n_subjects = len(subjects)
# Load
for subj in subjects:
epochs, log = load_subj(subj)
epochs = epochs[['off_sup_lon', 'off_sup_sho']]
log = log.loc[(log.Condition == 2.0) & (log.Ratio != 1.0)]
corr_log = list()
for k in all_evo.keys():
c = marks_off[k]
sub_log = log[log.condition == c]
sub_log['epo_ix'] = np.arange(len(sub_log))
# corr_ix = sub_log['epo_ix'].loc[(sub_log.condition == c) & (sub_log.Accuracy == 1.0)].values
# sub_log = sub_log.loc[(sub_log.condition == c) & (sub_log.Accuracy == 1.0)]
corr_ix = sub_log['epo_ix']
all_evo[k].append(epochs[k][corr_ix].average())
corr_log.append(sub_log)
print(k, c, len(corr_ix))
all_log.append(pd.concat(corr_log))
all_log = pd.concat(all_log)
all_log.groupby('condition')[['condition'
]].agg(np.count_nonzero).plot(kind='bar')
# Plot
evoked = {
k: mne.combine_evoked(all_evo[k], weights='nave')
for k in all_evo.keys()
}
mne.viz.plot_evoked_topo([evoked[ev] for ev in evoked.keys()])
# Stats
connectivity, ch_names = read_ch_connectivity(
'/Users/lpen/Documents/MATLAB/Toolbox/fieldtrip-20170628/template/neighbours/biosemi128_neighb.mat'
)
#threshold = {'start': 5, 'step': 0.5}
threshold = None
p_threshold = 0.001
t_threshold = -stats.distributions.t.ppf(p_threshold / 2., n_subjects - 1)
x = {
k: np.array([all_evo[k][ix_s].data for ix_s in range(len(subjects))])
for k in sorted(all_evo.keys())
}
x = [np.transpose(x[k], (0, 2, 1)) for k in sorted(x.keys())]
t_obs, clusters, p_values, _ = spatio_temporal_cluster_test(
x,
n_permutations=1000,
threshold=t_threshold,
tail=0,
n_jobs=2,
connectivity=connectivity,
)
p_val = 0.01
good_cluster_inds = np.where(p_values < p_val)[0]
print(good_cluster_inds)
print(len(good_cluster_inds))
# configure variables for visualization
times = evoked['off_sup_lon'].times * 1e3
colors = 'r', 'b',
linestyles = '-', '-',
# grand average as numpy arrray
grand_ave = np.array(x).mean(axis=1)
# get sensor positions via layout
pos = mne.find_layout(evoked['off_sup_lon'].info).pos
# loop over significant clusters
for i_clu, clu_idx in enumerate(good_cluster_inds):
# unpack cluster infomation, get unique indices
time_inds, space_inds = np.squeeze(clusters[clu_idx])
ch_inds = np.unique(space_inds)
time_inds = np.unique(time_inds)
# get topography for F stat
f_map = t_obs[time_inds, ...].mean(axis=0)
# get signals at significant sensors
signals = grand_ave[..., ch_inds].mean(axis=-1)
sig_times = times[time_inds]
# create spatial mask
mask = np.zeros((f_map.shape[0], 1), dtype=bool)
mask[ch_inds, :] = True
# initialize figure
fig, ax_topo = plt.subplots(1, 1, figsize=(10, 3))
title = 'Cluster #{0}'.format(i_clu + 1)
fig.suptitle(title, fontsize=14)
# plot average test statistic and mark significant sensors
image, _ = mne.viz.plot_topomap(f_map,
pos,
mask=mask,
axes=ax_topo,
cmap='magma',
vmin=np.min,
vmax=np.max)
# advanced matplotlib for showing image with figure and colorbar
# in one plot
divider = make_axes_locatable(ax_topo)
# add axes for colorbar
ax_colorbar = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(image, cax=ax_colorbar)
ax_topo.set_xlabel('Averaged F-map ({:0.1f} - {:0.1f} ms)'.format(
*sig_times[[0, -1]]))
# add new axis for time courses and plot time courses
ax_signals = divider.append_axes('right', size='300%', pad=1.5)
for signal, name, col, ls in zip(signals, condition_names, colors,
linestyles):
ax_signals.plot(times, signal, color=col, linestyle=ls, label=name)
# add information
ax_signals.axvline(0, color='k', linestyle=':', label='stimulus onset')
ax_signals.set_xlim([times[0], times[-1]])
ax_signals.set_ylim([-10e-7, 20e-7])
ax_signals.set_xlabel('time [ms]')
ax_signals.set_ylabel('Amplitude')
ax_signals.hlines(0, xmin=times[0], xmax=times[-1], linestyles='--')
# plot significant time range
ymin, ymax = ax_signals.get_ylim()
ax_signals.fill_betweenx((ymin, ymax),
sig_times[0],
sig_times[-1],
color='orange',
alpha=0.3)
ax_signals.legend(loc='lower right')
ax_signals.set_ylim(ymin, ymax)
# clean up viz
mne.viz.tight_layout(fig=fig)
fig.subplots_adjust(bottom=.05)
plt.show()
fig.savefig(op.join(study_path, 'figures',
'ERP_off_ckust_{}.eps'.format(i_clu)),
format='eps',
dpi=300)
# Cluster Amplitude
# t_mask = np.arange(len(times))[(times > 300) & (times < 400)]
# sig_amp = {k: np.array([x[ix_c][ix_s, t_mask, :][:, ch_inds].mean() for ix_s, s in enumerate(subjects)]) for ix_c, k in enumerate(['lon', 'sho'])}
sig_amp = {
k: np.array([
x[ix_c][ix_s, time_inds, :][:, ch_inds].mean()
for ix_s, s in enumerate(subjects)
])
for ix_c, k in enumerate(['lon', 'sho'])
}
subj_cond = all_log.groupby('subject')[['RT', 'Accuracy']].agg(np.mean)
subj_cond['acc_lon'] = all_log[all_log.condition == 90].groupby(
'subject')[['Accuracy']].agg(np.mean)
subj_cond['acc_sho'] = all_log[all_log.condition == 70].groupby(
'subject')[['Accuracy']].agg(np.mean)
subj_cond['amp_lon'] = sig_amp['lon']
subj_cond['amp_sho'] = sig_amp['sho']
subj_cond['amp_dif'] = subj_cond['amp_sho'] - subj_cond['amp_lon']
subj_cond.corr(method='pearson')
from seaborn import regplot
from eeg_etg_fxs import permutation_pearson
r_sho, p_sho = permutation_pearson(subj_cond['amp_dif'].values,
subj_cond['acc_sho'].values, 10000)
r_lon, p_lon = permutation_pearson(subj_cond['amp_dif'].values,
subj_cond['acc_lon'].values, 10000)
plt.style.use('ggplot')
fig, axes = plt.subplots(1, 2, sharey=True, sharex=True)
for ix, (r, p, c) in enumerate(
zip([r_lon, r_sho], [p_lon, p_sho], ['acc_lon', 'acc_sho'])):
regplot(subj_cond['amp_dif'], subj_cond[c], ci=None, ax=axes[ix])
axes[ix].set_title('r = %0.3f p = %0.3f' % (r, p))
fig.savefig(op.join(study_path, 'figures', 'ERP_diff_acc.eps'),
format='eps',
dpi=300)
mne.viz.plot_compare_evokeds([evoked[ev] for ev in evoked.keys()], picks=2)
plt.savefig(op.join(study_path, 'figures', 'ERP_diff_A4.eps'),
format='eps',
dpi=300)