def test_read_ch_connectivity():
"Test reading channel connectivity templates"
a = partial(np.array, dtype='<U7')
# no pep8
nbh = np.array([[(['MEG0111'], [[a(['MEG0131'])]]),
(['MEG0121'], [[a(['MEG0111'])],
[a(['MEG0131'])]]),
(['MEG0131'], [[a(['MEG0111'])],
[a(['MEG0121'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_mat.mat')
savemat(mat_fname, mat)
ch_connectivity = read_ch_connectivity(mat_fname)
x = ch_connectivity
assert_equal(x.shape, (3, 3))
assert_equal(x[0, 1], False)
assert_equal(x[0, 2], True)
assert_true(np.all(x.diagonal()))
assert_raises(ValueError, read_ch_connectivity, mat_fname, [0, 3])
ch_connectivity = read_ch_connectivity(mat_fname, picks=[0, 2])
assert_equal(ch_connectivity.shape[0], 2)
ch_names = ['EEG01', 'EEG02', 'EEG03']
neighbors = [['EEG02'], ['EEG04'], ['EEG02']]
assert_raises(ValueError, ch_neighbor_connectivity, ch_names, neighbors)
neighbors = [['EEG02'], ['EEG01', 'EEG03'], ['EEG 02']]
assert_raises(ValueError, ch_neighbor_connectivity, ch_names[:2],
neighbors)
neighbors = [['EEG02'], 'EEG01', ['EEG 02']]
assert_raises(ValueError, ch_neighbor_connectivity, ch_names, neighbors)
def test_read_ch_connectivity():
"Test reading channel connectivity templates"
tempdir = _TempDir()
a = partial(np.array, dtype='<U7')
# no pep8
nbh = np.array([[(['MEG0111'], [[a(['MEG0131'])]]),
(['MEG0121'], [[a(['MEG0111'])], [a(['MEG0131'])]]),
(['MEG0131'], [[a(['MEG0111'])], [a(['MEG0121'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_mat.mat')
savemat(mat_fname, mat)
ch_connectivity = read_ch_connectivity(mat_fname)
x = ch_connectivity
assert_equal(x.shape, (3, 3))
assert_equal(x[0, 1], False)
assert_equal(x[0, 2], True)
assert_true(np.all(x.diagonal()))
assert_raises(ValueError, read_ch_connectivity, mat_fname, [0, 3])
ch_connectivity = read_ch_connectivity(mat_fname, picks=[0, 2])
assert_equal(ch_connectivity.shape[0], 2)
ch_names = ['EEG01', 'EEG02', 'EEG03']
neighbors = [['EEG02'], ['EEG04'], ['EEG02']]
assert_raises(ValueError, ch_neighbor_connectivity, ch_names, neighbors)
neighbors = [['EEG02'], ['EEG01', 'EEG03'], ['EEG 02']]
assert_raises(ValueError, ch_neighbor_connectivity, ch_names[:2],
neighbors)
neighbors = [['EEG02'], 'EEG01', ['EEG 02']]
assert_raises(ValueError, ch_neighbor_connectivity, ch_names, neighbors)
def __init__(self, sensor_type='mag'):
# @sensor_type "mag" or "grad"
sensor_type = sensor_type
code_dir = os.path.dirname(os.path.realpath(__file__))
info_path = os.path.join(code_dir, 'neuromag_info')
if (sensor_type == 'mag'):
neighboring_filename = os.path.join(info_path,
'neuromag306mag_neighb.mat')
if (sensor_type == 'grad'):
neighboring_filename = os.path.join(
info_path, 'neuromag306planar_neighb.mat')
neuromag = read_raw_fif(sample.data_path() +
'/MEG/sample/sample_audvis_raw.fif')
self.topography_2D = find_layout(neuromag.info,
ch_type=sensor_type).pos
topography_3D = np.array([
ch['loc'][:3] for ch in neuromag.info['chs']
if (ch['ch_name'][-1] == '1') & (ch['ch_name'][0:3] == 'MEG')
])
neighboring, ch_names = read_ch_connectivity(
neighboring_filename,
picks=None) #ch. names written in 'MEG1111' format
neighboring = neighboring.toarray()
num_channels = len(ch_names)
Convolutions.__init__(self, neighboring, topography_3D, ch_names,
num_channels)
def __init__(self,sensor_type = 'mag'):
# sensor_type - mag or grad. Grad not yet implemented
code_dir = os.path.dirname(os.path.realpath(__file__))
info_path = os.path.join(code_dir, 'neuromag_info')
neuromag = read_raw_fif(sample.data_path() +
'/MEG/sample/sample_audvis_raw.fif')
topography_2D = find_layout(neuromag.info, ch_type=sensor_type).pos[:,:2]
if (sensor_type == 'mag'):
topography_3D = np.array([ch['loc'][:3] for ch in neuromag.info['chs'] if
(ch['ch_name'][-1] == '1') &
(ch['ch_name'][0:3] == 'MEG')]) #Numbers of mag sensors ended by '1'
neighboring_filename = os.path.join(info_path, 'neuromag306mag_neighb.mat')
if (sensor_type == 'grad'):
topography_3D = np.array([ch['loc'][:3] for ch in neuromag.info['chs'] if
((ch['ch_name'][-1] == '2') | (ch['ch_name'][-1] == '3')) &
(ch['ch_name'][0:3] == 'MEG')]) # Numbers of grad sensors ended by '2' or '3'
neighboring_filename = os.path.join(info_path, 'neuromag306planar_neighb.mat')
neighboring, ch_names = read_ch_connectivity(neighboring_filename,
picks=None) # ch. names written in 'MEG1111' format
neighboring = neighboring.toarray()
num_channels = len(ch_names)
self.sensor_type = sensor_type
Device.__init__(self,ch_names, topography_3D, topography_2D, neighboring, num_channels)
def __init__(self):
code_dir = os.path.dirname(os.path.realpath(__file__))
info_path = os.path.join(code_dir, 'gsn128_info')
neighboring_filename = os.path.join(info_path, 'gsn128_neighb.mat')
topography_2D = read_layout('GSN-128.lay', info_path).pos[:, :2]
num_channels, ch_names, topography_3D = self._parse_mat(os.path.join(info_path, 'bs_topography.mat'))
neighboring, self.ch_names = read_ch_connectivity(neighboring_filename, picks=None)
neighboring = neighboring.toarray()
Device.__init__(self, ch_names, topography_3D, topography_2D, neighboring, num_channels)
def meg_to_gradmag(chan_types):
"""force separation of magnetometers and gradiometers"""
from mne.channels import read_ch_connectivity
if 'meg' in [chan['name'] for chan in chan_types]:
mag_connectivity, _ = read_ch_connectivity('neuromag306mag')
# FIXME grad connectivity? Need virtual sensor?
# grad_connectivity, _ = read_ch_connectivity('neuromag306grad')
chan_types = [dict(name='mag', connectivity=mag_connectivity),
dict(name='grad', connectivity='missing')] + \
[chan for chan in chan_types if chan['name'] != 'meg']
return chan_types
def test_read_ch_connectivity():
"""Test reading channel connectivity templates"""
tempdir = _TempDir()
a = partial(np.array, dtype='<U7')
# no pep8
nbh = np.array([[(['MEG0111'], [[a(['MEG0131'])]]),
(['MEG0121'], [[a(['MEG0111'])],
[a(['MEG0131'])]]),
(['MEG0131'], [[a(['MEG0111'])],
[a(['MEG0121'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_mat.mat')
savemat(mat_fname, mat, oned_as='row')
ch_connectivity, ch_names = read_ch_connectivity(mat_fname)
x = ch_connectivity
assert_equal(x.shape[0], len(ch_names))
assert_equal(x.shape, (3, 3))
assert_equal(x[0, 1], False)
assert_equal(x[0, 2], True)
assert_true(np.all(x.diagonal()))
assert_raises(ValueError, read_ch_connectivity, mat_fname, [0, 3])
ch_connectivity, ch_names = read_ch_connectivity(mat_fname, picks=[0, 2])
assert_equal(ch_connectivity.shape[0], 2)
assert_equal(len(ch_names), 2)
ch_names = ['EEG01', 'EEG02', 'EEG03']
neighbors = [['EEG02'], ['EEG04'], ['EEG02']]
assert_raises(ValueError, _ch_neighbor_connectivity, ch_names, neighbors)
neighbors = [['EEG02'], ['EEG01', 'EEG03'], ['EEG 02']]
assert_raises(ValueError, _ch_neighbor_connectivity, ch_names[:2],
neighbors)
neighbors = [['EEG02'], 'EEG01', ['EEG 02']]
assert_raises(ValueError, _ch_neighbor_connectivity, ch_names, neighbors)
connectivity, ch_names = read_ch_connectivity('neuromag306mag')
assert_equal(connectivity.shape, (102, 102))
assert_equal(len(ch_names), 102)
assert_raises(ValueError, read_ch_connectivity, 'bananas!')
# In EGI 256, E31 sensor has no neighbour
a = partial(np.array)
nbh = np.array([[(['E31'], []),
(['E1'], [[a(['E2'])],
[a(['E3'])]]),
(['E2'], [[a(['E1'])],
[a(['E3'])]]),
(['E3'], [[a(['E1'])],
[a(['E2'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_isolated_mat.mat')
savemat(mat_fname, mat, oned_as='row')
ch_connectivity, ch_names = read_ch_connectivity(mat_fname)
x = ch_connectivity.todense()
assert_equal(x.shape[0], len(ch_names))
assert_equal(x.shape, (4, 4))
assert_true(np.all(x.diagonal()))
assert_false(np.any(x[0, 1:]))
assert_false(np.any(x[1:, 0]))
# Check for neighbours consistency. If a sensor is marked as a neighbour,
# then it should also have its neighbours defined.
a = partial(np.array)
nbh = np.array([[(['E31'], []),
(['E1'], [[a(['E8'])],
[a(['E3'])]]),
(['E2'], [[a(['E1'])],
[a(['E3'])]]),
(['E3'], [[a(['E1'])],
[a(['E2'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_error_mat.mat')
savemat(mat_fname, mat, oned_as='row')
assert_raises(ValueError, read_ch_connectivity, mat_fname)
picks=picks,
baseline=None,
reject=reject,
preload=True)
epochs.drop_channels(['EOG 061'])
epochs.equalize_event_counts(event_id, copy=False)
condition_names = 'Aud_L', 'Aud_R', 'Vis_L', 'Vis_R'
X = [epochs[k].get_data() for k in condition_names] # as 3D matrix
X = [np.transpose(x, (0, 2, 1)) for x in X] # transpose for clustering
###############################################################################
# Load FieldTrip neighbor definition to setup sensor connectivity
# ---------------------------------------------------------------
connectivity, ch_names = read_ch_connectivity('neuromag306mag')
print(type(connectivity)) # it's a sparse matrix!
plt.imshow(connectivity.toarray(),
cmap='gray',
origin='lower',
interpolation='nearest')
plt.xlabel('{} Magnetometers'.format(len(ch_names)))
plt.ylabel('{} Magnetometers'.format(len(ch_names)))
plt.title('Between-sensor adjacency')
###############################################################################
# Compute permutation statistic
# -----------------------------
#
def group_stats(subjects,
path,
exp,
filt,
analysis,
c_names,
seed=42,
threshold=1.96,
p_accept=0.05,
chance=.5,
n_perm=10000,
reg_type='rerf'):
# Load the subject gats
group_gat = list()
group_td = list()
group_reg = list()
group_dict = dict()
group_dev = list()
for subject in subjects:
subject_template = op.join(path, subject, 'mne', subject + '_%s%s.%s')
fname_gat = subject_template % (exp, '_calm_' + filt + '_filt_' +
analysis + '_gat', 'npy')
fname_reg = subject_template % (exp, '_calm_' + filt + '_filt_' +
analysis + '_%s-ave' % reg_type, 'fif')
gat = np.load(fname_gat)
group_gat.append(gat)
group_td.append(np.diag(gat))
reg = mne.read_evokeds(fname_reg)
if isinstance(c_names, list):
evokeds = list()
for r in reg:
if r.comment == c_names[0]:
evokeds.insert(0, r)
elif r.comment == c_names[1]:
evokeds.append(r)
assert len(evokeds) == 2
reg = mne.evoked.combine_evoked([evokeds[0], evokeds[1]],
weights=[1, -1])
elif isinstance(c_names, str):
reg = reg[0]
# transpose for the stats func
group_reg.append(reg.data.T)
n_subjects = len(subjects)
connectivity, ch_names = read_ch_connectivity('KIT-208')
##################
# Auxiliary info #
##################
# define a layout
layout = mne.find_layout(reg.info)
group_dict['layout'] = layout
group_dict['times'] = reg.times
group_dict['sfreq'] = reg.info['sfreq']
group_dict['subjects'] = subjects
#############################
# run a spatio-temporal REG #
#############################
group_reg = np.array(group_reg)
group_dict['reg_stats'] = stc_1samp_test(group_reg,
n_permutations=n_perm,
threshold=threshold,
tail=0,
connectivity=connectivity,
seed=seed,
n_jobs=-1)
#########################
# run a GAT clustering #
#########################
# remove chance from the gats
group_gat = np.array(group_gat) - chance
_, clusters, p_values, _ = stc_1samp_test(group_gat,
n_permutations=n_perm,
threshold=threshold,
tail=0,
seed=seed,
out_type='mask',
n_jobs=-1)
p_values_ = np.ones_like(group_gat[0]).T
for cluster, pval in zip(clusters, p_values):
p_values_[cluster.T] = pval
group_dict['gat_sig'] = p_values_ < p_accept
########################
# run a TD clustering #
########################
# remove chance from the gats
group_td = np.array(group_td) - chance
group_dict['td_stats'] = pc_1samp_test(group_td,
n_permutations=n_perm,
threshold=threshold,
tail=0,
seed=seed,
n_jobs=-1)
#########################
# run a GAT clustering #
#########################
# determining deviation from diag
group_diag = np.array([np.diag(gat)[:, np.newaxis] for gat in group_gat])
group_dev = group_gat - group_diag
_, clusters, p_values, _ = stc_1samp_test(group_dev,
n_permutations=n_perm,
threshold=threshold,
tail=0,
seed=seed,
out_type='mask',
n_jobs=-1)
p_values_ = np.ones_like(group_dev[0]).T
for cluster, pval in zip(clusters, p_values):
p_values_[cluster.T] = pval
group_dict['gat_dev_sig'] = p_values_ < p_accept
return group_dict
# combine grad with RMS
data[:, grad[::2], :] = np.sqrt((data[:, grad[::2], :] ** 2 +
data[:, grad[1::2], :] ** 2) / 2.)
data[:, grad[1::2], :] = data[:, grad[::2], :]
data[:, grad, :] += analysis['chance']
# keep robust averaging for plotting
epochs = EpochsArray(data, evoked.info,
events=np.zeros((len(data), 3), dtype=int),
tmin=evoked.times[0])
evoked = epochs.average()
evoked.data = robust_mean(data, axis=0)
# Run stats
p_values_chans = list()
epochs.pick_types('mag')
connectivity, _ = read_ch_connectivity('neuromag306mag')
X = np.transpose(epochs._data, [0, 2, 1])
_, clusters, cl_p_val, _ = stats(
X, out_type='mask', n_permutations=2 ** 11,
connectivity=connectivity, n_jobs=-1)
p_values = np.ones_like(X[0]).T
for cluster, pval in zip(clusters, cl_p_val):
p_values[cluster.T] = pval
sig = p_values < .05
# Save contrast
save([evoked, data, p_values, sig, analysis],
'evoked', analysis=('stats_' + analysis['name']),
overwrite=True)
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)
from main import get_data
from mne.channels import read_ch_connectivity
from mne.stats import permutation_cluster_test
import numpy as np
from mne.io import read_raw_fif
from mne.datasets import sample
from mne.channels import find_layout
from mne.viz import plot_topomap
import os
import matplotlib.pyplot as plt
from scipy.signal import butter, lfilter
info = read_raw_fif(sample.data_path() + '/MEG/sample/sample_audvis_raw.fif',verbose=False).info
connectivity = read_ch_connectivity('neuromag306planar_neighb.mat', picks=None)
def butter_lowpass(cutoff, fs, order=5):
nyq = 0.5 * fs
normal_cutoff = cutoff / nyq
b, a = butter(order, normal_cutoff, btype='low', analog=False)
return b, a
def butter_lowpass_filter(data, cutoff, fs, order=5):
b, a = butter_lowpass(cutoff, fs, order=order)
y=np.zeros(data.shape)
for tr in range(data.shape[0]):
for ch in range(data.shape[2]):
y[tr,:,ch] = lfilter(b, a, data[tr,:,ch])
return y
def make_scales(s):
''' populate attributes describing channels and units '''
# channels
use_ext = '.sfp'
path, file = os.path.split(s.params['Coordinates file'])
fn, ext = file.split('.')
s.montage = mne.channels.read_montage(os.path.join(path, fn) + use_ext)
# channel "connectivity" (adjacency)
target_path = '/active_projects/matlab_common/hbnl_neighbs.mat'
s.ch_connectivity, ch_names = read_ch_connectivity(target_path)
# units and suggested limits
s.db_lims, s.db_units = [-3, 3], 'decibels (dB)'
s.itc_lims, s.itc_units = [-.06, 0.3], 'ITC'
s.coh_lims, s.coh_units = [-.06, 0.3], 'ISPS'
s.phi_lims, s.phi_units = [-np.pi, np.pi], 'Radians'
s.z_lims, s.z_units = [-1, 9], 'Z-score'
# ERP times
s.srate = s.params['Sampling rate'][0][0]
if s.source_pipeline is 'matlab':
s.make_tfscales_matlab()
elif s.source_pipeline is 'erostack':
s.make_tfscales_erostack()
s.zero_tf = convert_ms(s.time_tf, 0)
freq_tick_space = freq_tick_heuristic(s.freq)
s.freq_ticks_pt = range(0, len(s.freq), freq_tick_space)
s.freq_ticks_hz = ['{0:.1f}'.format(f) for f in s.freq[::freq_tick_space]]
s.time_ticks() # additional helper function for ticks
# time plot limits
s.time_plotlims = [convert_ms(s.time, ms) for ms in time_plotlims_ms]
s.time_tf_plotlims = [convert_ms(s.time_tf, ms)
for ms in time_plotlims_ms]
# freq plot limits
s.freq_tf_plotlims = [convert_ms(s.freq, hz)
for hz in freq_plotlims_hz]
# only CSD beyond this if statement
if not s.params['CSD matrix']:
s.pot_lims, s.pot_units = [-10, 16], r'$\mu$V'
return
if s.params['CSD matrix'].shape[0] <= 2:
s.pot_lims, s.pot_units = [-10, 16], r'$\mu$V'
return
s.pot_lims, s.pot_units = [-.2, .2], r'$\mu$V / $cm^2$'
s.cohpair_inds = [[int(chan_num) - 1 for chan_num in pair] # MATLAB index
for pair in s.params['Coherence pairs'].T]
if len(s.params['Coherence pairs'].shape) > 1:
s.cohpair_lbls = ['~'.join([s.montage.ch_names[chan_ind]
for chan_ind in pair])
for pair in s.cohpair_inds]
s.cohpair_sets = OrderedDict()
s.cohchan_sets = OrderedDict()
for pind, pset in enumerate(s.params['Coherence pair subsets']):
tmp_pairs = np.where(
s.params['Coherence pair subset index'] == pind + 1)[1]
setpairs = [s.cohpair_lbls[pair] for pair in tmp_pairs]
s.cohpair_sets[pset] = setpairs
setchans = np.unique(np.array([s.cohpair_inds[p]
for p in tmp_pairs]))
s.cohchan_sets[pset] = [s.montage.ch_names[i] for i in setchans]
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)
def test_read_ch_connectivity():
"""Test reading channel connectivity templates."""
tempdir = _TempDir()
a = partial(np.array, dtype='<U7')
# no pep8
nbh = np.array([[(['MEG0111'], [[a(['MEG0131'])]]),
(['MEG0121'], [[a(['MEG0111'])],
[a(['MEG0131'])]]),
(['MEG0131'], [[a(['MEG0111'])],
[a(['MEG0121'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_mat.mat')
savemat(mat_fname, mat, oned_as='row')
ch_connectivity, ch_names = read_ch_connectivity(mat_fname)
x = ch_connectivity
assert_equal(x.shape[0], len(ch_names))
assert_equal(x.shape, (3, 3))
assert_equal(x[0, 1], False)
assert_equal(x[0, 2], True)
assert np.all(x.diagonal())
pytest.raises(ValueError, read_ch_connectivity, mat_fname, [0, 3])
ch_connectivity, ch_names = read_ch_connectivity(mat_fname, picks=[0, 2])
assert_equal(ch_connectivity.shape[0], 2)
assert_equal(len(ch_names), 2)
ch_names = ['EEG01', 'EEG02', 'EEG03']
neighbors = [['EEG02'], ['EEG04'], ['EEG02']]
pytest.raises(ValueError, _ch_neighbor_connectivity, ch_names, neighbors)
neighbors = [['EEG02'], ['EEG01', 'EEG03'], ['EEG 02']]
pytest.raises(ValueError, _ch_neighbor_connectivity, ch_names[:2],
neighbors)
neighbors = [['EEG02'], 'EEG01', ['EEG 02']]
pytest.raises(ValueError, _ch_neighbor_connectivity, ch_names, neighbors)
connectivity, ch_names = read_ch_connectivity('neuromag306mag')
assert_equal(connectivity.shape, (102, 102))
assert_equal(len(ch_names), 102)
pytest.raises(ValueError, read_ch_connectivity, 'bananas!')
# In EGI 256, E31 sensor has no neighbour
a = partial(np.array)
nbh = np.array([[(['E31'], []),
(['E1'], [[a(['E2'])],
[a(['E3'])]]),
(['E2'], [[a(['E1'])],
[a(['E3'])]]),
(['E3'], [[a(['E1'])],
[a(['E2'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_isolated_mat.mat')
savemat(mat_fname, mat, oned_as='row')
ch_connectivity, ch_names = read_ch_connectivity(mat_fname)
x = ch_connectivity.todense()
assert_equal(x.shape[0], len(ch_names))
assert_equal(x.shape, (4, 4))
assert np.all(x.diagonal())
assert not np.any(x[0, 1:])
assert not np.any(x[1:, 0])
# Check for neighbours consistency. If a sensor is marked as a neighbour,
# then it should also have its neighbours defined.
a = partial(np.array)
nbh = np.array([[(['E31'], []),
(['E1'], [[a(['E8'])],
[a(['E3'])]]),
(['E2'], [[a(['E1'])],
[a(['E3'])]]),
(['E3'], [[a(['E1'])],
[a(['E2'])]])]],
dtype=[('label', 'O'), ('neighblabel', 'O')])
mat = dict(neighbours=nbh)
mat_fname = op.join(tempdir, 'test_error_mat.mat')
savemat(mat_fname, mat, oned_as='row')
pytest.raises(ValueError, read_ch_connectivity, mat_fname)
epochs = mne.read_epochs(epochs_folder +
'%s_trial_start-epo.fif' % subject)
epochs.pick_types(meg="grad")
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('neuromag306planar')
# 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=4,
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_grad.p", "wb"))
from __future__ import print_function
from __future__ import division
import numpy as np
import mne
import matplotlib.pyplot as plt
import pycnbi_utils as pu
from mne import Epochs, pick_types
import q_common as qc
from mne.viz import topomap
from mne.stats import spatio_temporal_cluster_test
from mne.channels import read_ch_connectivity
from mne.viz import plot_topomap
from mpl_toolkits.axes_grid1 import make_axes_locatable
connectivity, ch_names = read_ch_connectivity('biosemi16')
# load parameters
import imp
cfg_module = "config.py"
if cfg_module[-3:] == '.py':
cfg_module = cfg_module[:-3]
cfg = imp.load_source(cfg_module, "./config.py")
spfilter = cfg.SP_FILTER
tpfilter = cfg.TP_FILTER
triggers = {cfg.tdef.by_value[c]: c for c in set(cfg.TRIGGER_DEF)}
print(triggers)
# ftrain =r'D:\data\Records\fif\20170309-195357-raw.fif'
ftrain = []
reject = dict(mag=4e-12, eog=150e-6)
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, reject=reject, preload=True)
epochs.drop_channels(["EOG 061"])
epochs.equalize_event_counts(event_id, copy=False)
condition_names = "Aud_L", "Aud_R", "Vis_L", "Vis_R"
X = [epochs[k].get_data() for k in condition_names] # as 3D matrix
X = [np.transpose(x, (0, 2, 1)) for x in X] # transpose for clustering
###############################################################################
# Load FieldTrip neighbor definition to setup sensor connectivity
# ---------------------------------------------------------------
connectivity, ch_names = read_ch_connectivity("neuromag306mag")
print(type(connectivity)) # it's a sparse matrix!
plt.imshow(connectivity.toarray(), cmap="gray", origin="lower", interpolation="nearest")
plt.xlabel("{} Magnetometers".format(len(ch_names)))
plt.ylabel("{} Magnetometers".format(len(ch_names)))
plt.title("Between-sensor adjacency")
###############################################################################
# Compute permutation statistic
# -----------------------------
#
# How does it work? We use clustering to `bind` together features which are
# similar. Our features are the magnetic fields measured over our sensor
# array at different times. This reduces the multiple comparison problem.
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)
