def run_linear_regression_v2(analysis_name, regressor_names, subject, cleaned=True):
# Load data & update metadata (in case new things were added)
if cleaned:
epochs = epoching_funcs.load_epochs_items(subject, cleaned=True)
epochs = epoching_funcs.update_metadata_rejected(subject, epochs)
else:
epochs = epoching_funcs.load_epochs_items(subject, cleaned=False)
epochs = epoching_funcs.update_metadata_rejected(subject, epochs)
# # ====== remove some items from the linear model ==========
print('We remove the first sequence item for which the surprise is not well computed and for which there is no RepeatAlter')
epochs = epochs["StimPosition > 1"]
# print('We remove items from trials with violation')
# epochs = epochs["ViolationInSequence == 0"]
# ====== regressors
names = regressor_names
# ====== normalization ?
for name in names:
epochs.metadata[name] = scale(epochs.metadata[name])
# ====== Linear model (all items)
df = epochs.metadata
epochs.metadata = df.assign(Intercept=1) # Add an intercept for later
names = ["Intercept"] + names
res = linear_regression(epochs, epochs.metadata[names], names=names)
# Save regression results
out_path = op.join(config.result_path, 'linear_models', analysis_name, subject)
utils.create_folder(out_path)
for name in names:
res[name].beta.save(op.join(out_path, name + '.fif'))
def decode_probe(file):
#load in epochs
_id = file.split('_')[0]
try:
epochs = mne.epochs.read_epochs(join(epodir, file))
if len(epochs) < 30:
return [0]
# crop out the postcue period after pre-stim baseline
# epochs.apply_baseline(baseline=(3, 3.5))
# epochs.crop(tmin=3, tmax=4.5)
epochs.apply_baseline(baseline=(1.5, 2))
epochs.crop(tmin=1.5, tmax=3.5)
epochs.metadata = epochs.metadata.assign(Intercept=1)
epochs.metadata['ang_dist'] = ang_dist(epochs.metadata[['targ_ang', 'resp_ang']], 90)
epochs.pick_types(meg=True, chpi=False)
#epochs.metadata.perc_diff = (epochs.metadata.perc_diff - epochs.metadata.perc_diff.mean) /epochs.metadata.perc_diff
# seperate out probe directions
_l = epochs['cue_dir == 0']
_r = epochs['cue_dir == 1']
_n = epochs['cue_dir == -1']
lav = _l.average()
rav = _r.average()
nav = _n.average()
# l = mne.combine_evoked([lav, nav], [1, -1])
# r = mne.combine_evoked([rav, nav], [1, -1])
l = _l
r = _r
names = ["Intercept", reg_n]
res_l = linear_regression(l, l.metadata[names].reset_index(drop=True), names=names)
res_r = linear_regression(r, r.metadata[names].reset_index(drop=True), names=names)
res_both = linear_regression(epochs, epochs.metadata[names].reset_index(drop=True), names=names)
return [res_l, res_r, res_both]
except:
return [0]
def run_linear_regression(subject, cleaned=True):
# Load data
if cleaned:
epochs = epoching_funcs.load_epochs_items(subject, cleaned=True)
epochs = epoching_funcs.update_metadata(subject, epochs)
else:
epochs = epoching_funcs.load_epochs_items(subject, cleaned=False)
epochs = epoching_funcs.update_metadata(subject, epochs)
# add surprise_dynamic in metadata (excluding removed items/trials)
print('We merge the dynamical model of surprise with the metadata')
run_info_subject_dir = op.join(config.run_info_dir, subject)
surprise = loadmat(op.join(run_info_subject_dir, 'surprise.mat'))
surprise = list(surprise['Surprise'])
badidx = np.where(epochs.drop_log)
badidx = badidx[0]
[surprise.pop(i) for i in badidx[::-1]]
surprise = np.asarray(surprise)
epochs.metadata['surprise_dynamic'] = surprise
# ====== remove the first item of each sequence in the linear model ==========
print('We remove the first sequence item for which the surprise is not well computed')
epochs = epochs["StimPosition > 1"]
# ====== normalization ?
epochs.metadata['surprise_dynamic'] = scale(epochs.metadata['surprise_dynamic'])
epochs.metadata['Complexity'] = scale(epochs.metadata['Complexity'])
epochs.metadata['ViolationOrNot'] = scale(epochs.metadata['ViolationOrNot'])
# ====== let's add in the metadata a term of violation_or_not X complexity ==========
print('We remove the first sequence item for which the surprise is not well computed')
# epochs.metadata['violation_X_complexity'] = np.asarray([epochs.metadata['ViolationOrNot'][i]*epochs.metadata['Complexity'][i] for i in range(len(epochs.metadata))]) # does not work, replaced by the next line (correct?)
epochs.metadata['violation_X_complexity'] = scale(epochs.metadata['ViolationOrNot'] * epochs.metadata['Complexity'])
# Linear model (all items)
df = epochs.metadata
epochs.metadata = df.assign(Intercept=1) # Add an intercept for later
names = ["Intercept", "Complexity", "surprise_dynamic", "ViolationOrNot", "violation_X_complexity"]
res = linear_regression(epochs, epochs.metadata[names], names=names)
# Save regression results
out_path = op.join(config.result_path, 'linear_models', 'complexity&surprisedynamic', subject)
utils.create_folder(out_path)
res['Intercept'].beta.save(op.join(out_path, 'beta_intercept-ave.fif'))
res['Complexity'].beta.save(op.join(out_path, 'beta_Complexity-ave.fif'))
res['surprise_dynamic'].beta.save(op.join(out_path, 'beta_surprise_dynamic-ave.fif'))
res['ViolationOrNot'].beta.save(op.join(out_path, 'beta_violation_or_not-ave.fif'))
res['violation_X_complexity'].beta.save(op.join(out_path, 'beta_violation_X_complexity-ave.fif'))
epochs = epochs[idx]
design_matrix = design_matrix[idx]
evts = evts[idx]
# rerf keys
dm_keys = evts[:, 0]
assert len(design_matrix) == len(epochs) == len(dm_keys)
# group_ols[subject] = epochs.average()
# Define 'y': what you're predicting
y = design_matrix[:, -1]
# run a rERF
covariates = dict(zip(dm_keys, y))
# linear regression
reg = linear_regression(epochs, design_matrix, reg_names)
reg[c_name].beta.save(fname_reg)
print 'get ready for decoding ;)'
train_times = {
'start': tmin,
'stop': tmax,
'length': length,
'step': step
}
cv = KFold(n=len(y), n_folds=n_folds, random_state=random_state)
gat = GeneralizationAcrossTime(predict_mode='cross-validation',
n_jobs=-1,
train_times=train_times,
scorer=rank_scorer,
df = epochs.metadata
df[name] = pd.cut(df[name], 11, labels=False) / 10
colors = {str(val): val for val in df[name].unique()}
epochs.metadata = df.assign(Intercept=1) # Add an intercept for later
evokeds = {val: epochs[name + " == " + val].average() for val in colors}
plot_compare_evokeds(evokeds, colors=colors, split_legend=True,
cmap=(name + " Percentile", "viridis"))
##############################################################################
# We observe that there appears to be a monotonic dependence of EEG on
# concreteness. We can also conduct a continuous analysis: single-trial level
# regression with concreteness as a continuous (although here, binned)
# feature. We can plot the resulting regression coefficient just like an
# Event-related Potential.
names = ["Intercept", name]
res = linear_regression(epochs, epochs.metadata[names], names=names)
for cond in names:
res[cond].beta.plot_joint(title=cond, ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'))
##############################################################################
# Because the `linear_regression` function also estimates p values, we can --
# after applying FDR correction for multiple comparisons -- also visualise the
# statistical significance of the regression of word concreteness.
# The :func:`mne.viz.plot_evoked_image` function takes a `mask` parameter.
# If we supply it with a boolean mask of the positions where we can reject
# the null hypothesis, points that are not significant will be shown
# transparently, and if desired, in a different colour palette and surrounded
# by dark contour lines.
reject_H0, fdr_pvals = fdr_correction(res["Concreteness"].p_val.data)
evoked = res["Concreteness"].beta
###############################################################################
# Next, we can inspect the effect of phase-coherence on the activation
# patterns evoked by the presented face-stimuli.
# Here, one would expect that faces with high phase-coherence evoke a stronger
# response, as participants should be better at identifying these faces.
#
# Create design matrix for linear regression. We'll use the information
# contained in the ``limo_epochs.metadata``.
design = limo_epochs.metadata.copy()
design = design.assign(intercept=1) # add intercept
design['face a - face b'] = np.where(design['face'] == 'A', 1, -1)
names = ['intercept', 'face a - face b', 'phase-coherence']
# fit linear model
reg = linear_regression(limo_epochs, design[names], names=names)
###############################################################################
# Visualise effect of phase-coherence.
reg['phase-coherence'].beta.plot_joint(ts_args=ts_args,
title='Effect of phase-coherence',
times=[.23])
###############################################################################
# Here we can see a clear effect of phase-coherence, with higher
# phase-coherence (i.e., better "face visibility") being associated with
# stronger activity patterns.
###############################################################################
# Conversely, there appears to be no (or very small) systematic effects when
# constraining Face A and Face B. This is largely consistent with the
def run_linear_reg_surprise_repeat_alt_latest(subject, cross_validate=True):
# remove old files
meg_subject_dir = op.join(config.meg_dir, subject)
metadata_path = op.join(meg_subject_dir, 'metadata_item.pkl')
if op.exists(metadata_path):
os.remove(metadata_path)
metadata_path = op.join(meg_subject_dir, 'metadata_item_clean.pkl')
if op.exists(metadata_path):
os.remove(metadata_path)
list_omegas = np.logspace(-1, 2, 50)
TP_funcs.from_epochs_to_surprise(subject, list_omegas)
TP_funcs.append_surprise_to_metadata_clean(subject)
# =========== correction of the metadata with the surprise for the clean epochs ============
# TP_funcs.append_surprise_to_metadata_clean(subject) # already done above
# ====== load the data , remove the first item for which the surprise is not computed ==========
epochs = epoching_funcs.load_epochs_items(subject, cleaned=True)
metadata = epoching_funcs.update_metadata(subject,
clean=True,
new_field_name=None,
new_field_values=None)
metadata["surprise_100"] = metadata[
"surprise_100.00000"] # "rename" the variable
# metadata.to_csv(r'tmp.csv')
# ============ build the repeatAlter and the surprise 100 for n+1 ==================
metadata_notclean = epoching_funcs.update_metadata(subject,
clean=False,
new_field_name=None,
new_field_values=None)
metadata_notclean["surprise_100"] = metadata_notclean[
"surprise_100.00000"] # "rename" the variable
RepeatAlternp1_notclean = metadata_notclean["RepeatAlter"].values[
1:].tolist()
RepeatAlternp1_notclean.append(np.nan)
Surprisenp1_notclean = metadata_notclean["surprise_100"].values[1:].tolist(
)
Surprisenp1_notclean.append(np.nan)
good_idx = np.where(
[len(epochs.drop_log[i]) == 0 for i in range(len(epochs.drop_log))])[0]
RepeatAlternp1 = np.asarray(RepeatAlternp1_notclean)[good_idx]
Surprisenp1 = np.asarray(Surprisenp1_notclean)[good_idx]
# ======================================================================================
metadata = metadata.assign(Intercept=1) # Add an intercept for later
metadata = metadata.assign(RepeatAlternp1=RepeatAlternp1)
metadata = metadata.assign(
Surprisenp1=Surprisenp1) # Add an intercept for later
epochs.metadata = metadata
epochs.pick_types(meg=True, eeg=True)
# np.unique(metadata[np.isnan(epochs.metadata['RepeatAlter'])]['StimPosition'].values)
# np.unique(metadata[np.isnan(epochs.metadata['surprise_100'])]['StimPosition'].values)
# np.unique(metadata[np.isnan(metadata['RepeatAlternp1'])]['StimPosition'].values)
# np.unique(metadata[np.isnan(metadata['Surprisenp1'])]['StimPosition'].values)
epochs = epochs[np.where(
1 - np.isnan(epochs.metadata["surprise_100"].values))[0]]
epochs = epochs[np.where(
1 - np.isnan(epochs.metadata["RepeatAlternp1"].values))[0]]
# =============== define the regressors =================
# Repetition and alternation for n (not defined for the 1st item of the 16)
# Repetition and alternation for n+1 (not defined for the last item of the 16)
# Omega infinity for n (not defined for the 1st item of the 16)
# Omega infinity for n+1 (not defined for the last item of the 16)
names = [
"Intercept", "surprise_100", "Surprisenp1", "RepeatAlter",
"RepeatAlternp1"
]
for name in names:
print(name)
print(np.unique(epochs.metadata[name].values))
# ====== normalization ? ====== #
for name in names[1:]: # all but intercept
epochs.metadata[name] = scale(epochs.metadata[name])
# ====== baseline correction ? ====== #
print('Baseline correction...')
epochs = epochs.apply_baseline(baseline=(-0.050, 0))
lin_reg = linear_regression(epochs, epochs.metadata[names], names=names)
out_path = op.join(config.result_path, 'linear_models',
'reg_repeataltern_surpriseOmegainfinity', subject)
utils.create_folder(out_path)
suffix = ''
if cross_validate:
# ---- we replace the data in lin_reg ----
suffix = '_cv'
skf = StratifiedKFold(n_splits=4)
y_balancing = epochs.metadata[
"SequenceID"].values * 100 + epochs.metadata["StimPosition"].values
betas = []
scores = []
fold_number = 1
for train_index, test_index in skf.split(np.zeros(len(y_balancing)),
y_balancing):
print("======= running a new fold =======")
# predictor matrix
preds_matrix_train = np.asarray(
epochs[train_index].metadata[names].values)
preds_matrix_test = np.asarray(
epochs[test_index].metadata[names].values)
betas_matrix = np.zeros((len(names), epochs.get_data().shape[1],
epochs.get_data().shape[2]))
scores_cv = np.zeros((epochs.get_data().shape[2]))
residuals_cv = np.zeros(epochs[test_index].get_data().shape)
for tt in range(epochs.get_data().shape[2]):
# for each time-point, we run a regression for each channel
reg = linear_model.LinearRegression(fit_intercept=False)
data_train = epochs[train_index].get_data()
data_test = epochs[test_index].get_data()
reg.fit(y=data_train[:, :, tt], X=preds_matrix_train)
betas_matrix[:, :, tt] = reg.coef_.T
y_preds = reg.predict(preds_matrix_test)
scores_cv[tt] = r2_score(y_true=data_test[:, :, tt],
y_pred=y_preds)
# build the residuals by removing the betas computed on the training set to the data from the testing set
residuals_cv[:, :, tt] = data_test[:, :, tt] - y_preds
residual_epochs_cv = epochs[test_index].copy()
residual_epochs_cv._data = residuals_cv
residual_epochs_cv.save(out_path + op.sep + 'fold_' +
str(fold_number) + 'residuals-epo.fif',
overwrite=True)
betas.append(betas_matrix)
scores.append(scores_cv)
fold_number += 1
# MEAN ACROSS CROSS-VALIDATION FOLDS
betas = np.mean(betas, axis=0)
scores = np.mean(scores, axis=0)
lin_reg['Intercept'].beta._data = np.asarray(betas[0, :, :])
lin_reg['surprise_100'].beta._data = np.asarray(betas[1, :, :])
lin_reg['Surprisenp1'].beta._data = np.asarray(betas[2, :, :])
lin_reg['RepeatAlter'].beta._data = np.asarray(betas[3, :, :])
lin_reg['RepeatAlternp1'].beta._data = np.asarray(betas[4, :, :])
# Save surprise regression results
lin_reg['Intercept'].beta.save(
op.join(out_path, suffix + 'beta_intercept-ave.fif'))
lin_reg['surprise_100'].beta.save(
op.join(out_path, suffix + 'beta_surpriseN-ave.fif'))
lin_reg['Surprisenp1'].beta.save(
op.join(out_path, suffix + 'beta_surpriseNp1-ave.fif'))
lin_reg['RepeatAlternp1'].beta.save(
op.join(out_path, suffix + 'beta_RepeatAlternp1-ave.fif'))
lin_reg['RepeatAlter'].beta.save(
op.join(out_path, suffix + 'beta_RepeatAlter-ave.fif'))
if cross_validate:
np.save(op.join(out_path, 'scores_linear_reg_CV.npy'), scores)
# save the residuals epoch in the same folder
residuals = epochs.get_data() - lin_reg['Intercept'].beta.data
for nn in ["surprise_100", "Surprisenp1", "RepeatAlter", "RepeatAlternp1"]:
residuals = residuals - np.asarray([
epochs.metadata[nn].values[i] * lin_reg[nn].beta._data
for i in range(len(epochs))
])
residual_epochs = epochs.copy()
residual_epochs._data = residuals
# save the residuals epoch in the same folder
residual_epochs.save(out_path + op.sep + suffix + 'residuals-epo.fif',
overwrite=True)
def run_linear_reg_surprise_repeat_alt(subject,
with_complexity=False,
cross_validate=True):
TP_funcs.append_surprise_to_metadata_clean(subject)
# ====== load the data , remove the first item for which the surprise is not computed ==========
epochs = epoching_funcs.load_epochs_items(subject, cleaned=True)
metadata = epoching_funcs.update_metadata(subject,
clean=True,
new_field_name=None,
new_field_values=None)
# ============ build the repeatAlter and the surprise 299 for n+1 ==================
metadata_notclean = epoching_funcs.update_metadata(subject,
clean=False,
new_field_name=None,
new_field_values=None)
# ====== attention il faut que je code à la main la présence de répétition ou d'alternance ===========
metadata_notclean = repeat_alternate_from_metadata(metadata_notclean)
RepeatAlternp1_notclean = metadata_notclean["RepeatAlter"].values[
1:].tolist()
RepeatAlternp1_notclean.append(np.nan)
Surprisenp1_notclean = metadata_notclean["surprise_299"].values[1:].tolist(
)
Surprisenp1_notclean.append(np.nan)
good_idx = np.where(
[len(epochs.drop_log[i]) == 0 for i in range(len(epochs.drop_log))])[0]
RepeatAlternp1 = np.asarray(RepeatAlternp1_notclean)[good_idx]
Surprisenp1 = np.asarray(Surprisenp1_notclean)[good_idx]
# ======================================================================================
metadata = metadata.assign(Intercept=1) # Add an intercept for later
metadata = metadata.assign(RepeatAlternp1=RepeatAlternp1)
metadata = metadata.assign(
Surprisenp1=Surprisenp1) # Add an intercept for later
epochs.metadata = metadata
epochs.pick_types(meg=True, eeg=True)
epochs = epochs[np.where(
1 - np.isnan(epochs.metadata["surprise_299"].values))[0]]
epochs = epochs[np.where(
1 - np.isnan(epochs.metadata["RepeatAlternp1"].values))[0]]
# =============== define the regressors =================
# Repetition and alternation for n (not defined for the 1st item of the 16)
# Repetition and alternation for n+1 (not defined for the last item of the 16)
# Omega infinity for n (not defined for the 1st item of the 16)
# Omega infinity for n+1 (not defined for the last item of the 16)
names = [
"Intercept", "surprise_299", "Surprisenp1", "RepeatAlter",
"RepeatAlternp1"
]
if with_complexity:
names.append("Complexity")
for name in names:
print(name)
print(np.unique(epochs.metadata[name].values))
# ============== define the output paths ======
out_path = op.join(config.result_path, 'linear_models',
'reg_repeataltern_surpriseOmegainfinity', subject)
if with_complexity:
out_path = op.join(
config.result_path, 'linear_models',
'reg_repeataltern_surpriseOmegainfinity_complexity', subject)
utils.create_folder(out_path)
# ------------------- implementing the 4 folds CV -----------------
if cross_validate:
from sklearn.model_selection import StratifiedKFold
skf = StratifiedKFold(n_splits=4)
y_balancing = epochs.metadata[
"SequenceID"].values * 100 + epochs.metadata["StimPosition"].values
Intercept = []
surprise_299 = []
Surprisenp1 = []
RepeatAlternp1 = []
RepeatAlter = []
Complexity = []
for train_index, test_index in skf.split(np.zeros(len(y_balancing)),
y_balancing):
print("======= running a new fold =======")
lin_reg_cv = linear_regression(epochs[train_index],
epochs[train_index].metadata[names],
names=names)
# score with cross validation
Intercept.append(lin_reg_cv['Intercept'].beta)
surprise_299.append(lin_reg_cv['surprise_299'].beta)
Surprisenp1.append(lin_reg_cv['Surprisenp1'].beta)
RepeatAlternp1.append(lin_reg_cv['RepeatAlternp1'].beta)
RepeatAlter.append(lin_reg_cv['RepeatAlter'].beta)
if with_complexity:
Complexity.append(lin_reg_cv['Complexity'].beta)
lin_reg_cv['Intercept'].beta = np.asarray(np.mean(Intercept, axis=0))
lin_reg_cv['surprise_299'].beta = np.asarray(
np.mean(surprise_299, axis=0))
lin_reg_cv['Surprisenp1'].beta = np.asarray(
np.mean(Surprisenp1, axis=0))
lin_reg_cv['RepeatAlternp1'].beta = np.asarray(
np.mean(RepeatAlternp1, axis=0))
lin_reg_cv['RepeatAlter'].beta = np.asarray(
np.mean(RepeatAlter, axis=0))
if with_complexity:
lin_reg_cv['Complexity'].beta = np.asarray(
np.mean(Complexity, axis=0))
lin_reg = lin_reg_cv
# ------ end of the CV option -------
else:
lin_reg = linear_regression(epochs,
epochs.metadata[names],
names=names)
# Save surprise regression results
lin_reg['Intercept'].beta.save(op.join(out_path, 'beta_intercept-ave.fif'))
lin_reg['surprise_299'].beta.save(
op.join(out_path, 'beta_surpriseN-ave.fif'))
lin_reg['Surprisenp1'].beta.save(
op.join(out_path, 'beta_surpriseNp1-ave.fif'))
lin_reg['RepeatAlternp1'].beta.save(
op.join(out_path, 'beta_RepeatAlternp1-ave.fif'))
lin_reg['RepeatAlter'].beta.save(
op.join(out_path, 'beta_RepeatAlter-ave.fif'))
if with_complexity:
lin_reg['Complexity'].beta.save(
op.join(out_path, 'beta_Complexity-ave.fif'))
# save the residuals epoch in the same folder
residuals = epochs.get_data() - lin_reg['Intercept'].beta.data
for nn in ["surprise_299", "Surprisenp1", "RepeatAlter", "RepeatAlternp1"]:
residuals = residuals - np.asarray([
epochs.metadata[nn].values[i] * lin_reg[nn].beta._data
for i in range(len(epochs))
])
if with_complexity:
residuals = residuals - np.asarray([
epochs.metadata["Complexity"].values[i] *
lin_reg["Complexity"].beta._data for i in range(len(epochs))
])
residual_epochs = epochs.copy()
residual_epochs._data = residuals
# save the residuals epoch in the same folder
residual_epochs.save(out_path + op.sep + 'residuals-epo.fif',
overwrite=True)
return True
# name of predictors + intercept
predictor_vars = ['face a - face b', 'phase-coherence', 'intercept']
# create design matrix
design = limo_epochs.metadata[['phase-coherence', 'face']].copy()
design['face a - face b'] = np.where(design['face'] == 'A', 1, -1)
design['intercept'] = 1
design = design[predictor_vars]
###############################################################################
# Now we can set up the linear model to be used in the analysis using
# MNE-Python's func:`~mne.stats.linear_regression` function.
reg = linear_regression(limo_epochs,
design_matrix=design,
names=predictor_vars)
###############################################################################
# Extract regression coefficients
# -------------------------------
#
# The results are stored within the object ``reg``,
# which is a dictionary of evoked objects containing
# multiple inferential measures for each predictor in the design matrix.
print('predictors are:', list(reg))
print('fields are:', [field for field in getattr(reg['intercept'], '_fields')])
###############################################################################
# Plot model results
method='dSPM')
for col, cond in zip(['condition', 'circscale'], ['pure', 'scale']):
list = []
for i in range(len(events)):
list.append(int(events.iloc[i][col] == cond))
events[col] = list
events['interaction'] = events['freq'] * events['condition']
X = events[var_names].values
X = sm.add_constant(X) # add intercept
print("Fitting...")
# fit regression
lm = linear_regression(stcs, X, ['intercept'] + var_names)
betas = [] # will contain betas over regressors per subject
for regressor in var_names:
print('Regressor: %s' % (regressor))
# make directories if they dont exists
save_dir = "%s/_RESULTS/%s" % (root_dir, regressor)
if not os.path.isdir(save_dir):
os.mkdir(
save_dir) # put the data into an stc for convenience, and save
stc_fname = '%s/morphed_stcs/%s_%s_%s_morphed' % (save_dir, subject,
regressor, data_type)
stc_data = eval("lm['%s'].%s" % (regressor, data_type))
# morph the stc to average brain
for wav_idx, wav in enumerate(wavs):
stc_temp = mne.read_source_estimate(
"{dir}stcs/nc_{a}_{b}_{c}_{d}-lh.stc".format(dir=proc_dir,
a=sub,
b=cond,
c=wav,
d=spacing))
stcs.append(morph.apply(stc_temp))
df_laut["Intercept"] = 1
temp_df = []
for cond in conds:
temp_df.append(df_laut[df_laut["Block"] == cond])
df_laut = pd.concat(temp_df)
predictor_vars = ["Laut"] + ["Intercept"]
design_matrix = df_laut.copy()[predictor_vars]
reg_laut = linear_regression(stcs,
design_matrix=design_matrix,
names=predictor_vars)
df_ang["Intercept"] = 1
temp_df = []
for cond in conds:
temp_df.append(df_ang[df_ang["Block"] == cond])
df_ang = pd.concat(temp_df)
predictor_vars = ["Angenehm"] + ["Intercept"]
design_matrix = df_ang.copy()[predictor_vars]
reg_ang = linear_regression(stcs,
design_matrix=design_matrix,
names=predictor_vars)
# them back to a channels x time points space.
lm_betas = dict()
for ind, predictor in enumerate(predictors):
# extract coefficients
beta = betas[:, ind]
# back projection to channels x time points
beta = beta.reshape((n_channels, n_times))
# create evoked object containing the back projected coefficients
# for each predictor
lm_betas[predictor] = EvokedArray(beta, epochs_info, tmin)
###############################################################################
# plot results of linear regression
# only show -250 to 500 ms
ts_args = dict(xlim=(-.25, 0.5))
# visualise effect of phase-coherence for sklearn estimation method.
lm_betas['phase-coherence'].plot_joint(ts_args=ts_args,
title='Phase-coherence - sklearn betas',
times=[.23])
###############################################################################
# replicate analysis using mne.stats.linear_regression
reg = linear_regression(limo_epochs['2'], design, names=predictors)
# visualise effect of phase-coherence for mne.stats method.
reg['phase-coherence'].beta.plot_joint(ts_args=ts_args,
title='Phase-coherence - mne betas',
times=[.23])
df = epochs.metadata
df[name] = pd.cut(df[name], 11, labels=False) / 10
colors = {str(val): val for val in df[name].unique()}
epochs.metadata = df.assign(Intercept=1) # Add an intercept for later
evokeds = {val: epochs[name + " == " + val].average() for val in colors}
plot_compare_evokeds(evokeds, colors=colors, split_legend=True,
cmap=(name + " Percentile", "viridis"))
##############################################################################
# We observe that there appears to be a monotonic dependence of EEG on
# concreteness. We can also conduct a continuous analysis: single-trial level
# regression with concreteness as a continuous (although here, binned)
# feature. We can plot the resulting regression coefficient just like an
# Event-related Potential.
names = ["Intercept", name]
res = linear_regression(epochs, epochs.metadata[names], names=names)
for cond in names:
res[cond].beta.plot_joint(title=cond, ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'))
##############################################################################
# Because the `linear_regression` function also estimates p values, we can --
# after applying FDR correction for multiple comparisons -- also visualise the
# statistical significance of the regression of word concreteness.
# The :func:`mne.viz.plot_evoked_image` function takes a `mask` parameter.
# If we supply it with a boolean mask of the positions where we can reject
# the null hypothesis, points that are not significant will be shown
# transparently, and if desired, in a different colour palette and surrounded
# by dark contour lines.
reject_H0, fdr_pvals = fdr_correction(res["Concreteness"].p_val.data)
evoked = res["Concreteness"].beta
# ====== normalization of regressors ====== #
for name in names:
epochs.metadata[name] = scale(epochs.metadata[name])
# ====== Linear model (all items) ====== #
if config.noEEG:
epochs = epochs.pick_types(meg=True, eeg=False)
else:
epochs = epochs.pick_types(meg=True, eeg=True)
df = epochs.metadata
epochs.metadata = df.assign(Intercept=1) # Add an intercept for later
regressors_names = ["Intercept"] + names
res = linear_regression(epochs,
epochs.metadata[regressors_names],
names=regressors_names)
if cross_validate:
skf = StratifiedKFold(n_splits=4)
y_balancing = epochs.metadata[
"SequenceID"].values * 100 + epochs.metadata[
"StimPosition"].values
betas = []
scores = []
fold_number = 1
for train_index, test_index in skf.split(
np.zeros(len(y_balancing)), y_balancing):
print("======= running regression for fold %i =======" %
fold_number)
print "Total reward"
behaviour.reward.sum()
# Drop the first trial
behaviour = behaviour[1:]
outcomes.drop(0)
# Assign behavioural data to metadata attribute
outcomes.metadata = behaviour.assign(Intercept=1)
# Linear regression
# The regression has two terms - the intercept (not interesting) and the reward level (interesting)
from mne.stats import linear_regression, fdr_correction
names = ["Intercept", 'reward']
res = linear_regression(outcomes, outcomes.metadata[names], names=names)
# Create an "evoked" object for the reward predictor - this represents the beta value for reward level in the model
# across time points and gradiometers
reward_evoked = res["reward"].beta
reward_evoked.plot_joint(ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'))
plt.savefig(
'/Users/dancingdiva12/Desktop/UCL/Research Project/thesis/figures/{0}_evoked_rewards.png'
.format(subject_id))
# You can choose which time points the plot shows scalp plots for using the times argument
reward_evoked.plot_joint(ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'),
times=[.09, .45])
shock_evoked.save(os.path.join(data_dir, 'shock_evoked-ave.fif.gz'))
