def logreg_timedecoding(epochs, numcv=4, jobs=1):
"""
Logistic regression over sensors. Returns Evoked array containing coefficients and ROC.
Code snippets stolen from:
https://martinos.org/mne/stable/auto_tutorials/plot_sensors_decoding.html
"""
X = epochs.get_data() # MEG signals: n_epochs, n_channels, n_times
X = X.astype(float)
y = epochs.events[:, 2] # targets
# setup and run the decoder
clf = make_pipeline(StandardScaler(), LinearModel(LogisticRegression()))
time_decod = SlidingEstimator(clf, scoring='roc_auc',
n_jobs=jobs) #scoring='roc_auc',
scores = cross_val_multiscore(time_decod, X, y, cv=numcv, n_jobs=jobs)
# Mean scores across cross-validation splits
scores = np.mean(scores, axis=0)
#
time_decod = SlidingEstimator(clf, scoring='roc_auc', n_jobs=jobs)
time_decod.fit(X, y)
coef = get_coef(time_decod, 'patterns_', inverse_transform=True)
evoked = mne.EvokedArray(coef, epochs.info, tmin=epochs.times[0])
evoked.roc_auc = scores
return evoked
sfreq=epochs.info['sfreq'],
freqs=freqs,
output='power',
n_cycles=n_cycles)
n_epochs, n_channels, n_freqs, n_times = X.shape
X = X.reshape(n_epochs, n_channels, -1) # collapse freqs and time
# Run decoding on TFR output
for analysis in analyses:
fname = results_folder +\
'%s_tf_scores_%s_%s.npy' % (subject, 'Cue', analysis)
y = np.array(events_behavior[analysis])
clf = make_pipeline(
StandardScaler(),
force_predict(LogisticRegression(), 'predict_proba', axis=1))
scorer = scorer_auc
kwargs = dict()
le = preprocessing.LabelEncoder()
le.fit(y)
y = le.transform(y)
sel = np.where(y != 0)[0]
td = SlidingEstimator(clf,
scoring=make_scorer(scorer),
n_jobs=24,
**kwargs)
td.fit(X[sel], y[sel])
scores = cross_val_multiscore(td, X[sel], y[sel], cv=StratifiedKFold(12))
scores = scores.mean(axis=0)
scores = np.reshape(scores, (n_freqs, n_times))
# Save cross validated scores
np.save(fname, np.array(scores))
fig, ax = plt.subplots()
ax.plot(epochs.times, scores, label='score')
ax.axhline(.5, color='k', linestyle='--', label='chance')
ax.set_xlabel('Times')
ax.set_ylabel('AUC') # Area Under the Curve
ax.legend()
ax.axvline(.0, color='k', linestyle='-')
ax.set_title('Sensor space decoding')
plt.show()
###############################################################################
# You can retrieve the spatial filters and spatial patterns if you explicitly
# use a LinearModel
clf = make_pipeline(StandardScaler(), LinearModel(LogisticRegression()))
time_decod = SlidingEstimator(clf, n_jobs=1, scoring='roc_auc', verbose=True)
time_decod.fit(X, y)
coef = get_coef(time_decod, 'patterns_', inverse_transform=True)
evoked = mne.EvokedArray(coef, epochs.info, tmin=epochs.times[0])
joint_kwargs = dict(ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'))
evoked.plot_joint(times=np.arange(0., .500, .100),
title='patterns',
**joint_kwargs)
###############################################################################
# Temporal Generalization
# -----------------------
#
# This runs the analysis used in [1]_ and further detailed in [2]_
#
fig, ax = plt.subplots()
ax.plot(epochs.times, scores, label='score')
ax.axhline(.5, color='k', linestyle='--', label='chance')
ax.set_xlabel('Times')
ax.set_ylabel('AUC') # Area Under the Curve
ax.legend()
ax.axvline(.0, color='k', linestyle='-')
ax.set_title('Sensor space decoding')
###############################################################################
# You can retrieve the spatial filters and spatial patterns if you explicitly
# use a LinearModel
clf = make_pipeline(StandardScaler(),
LinearModel(LogisticRegression(solver='lbfgs')))
time_decod = SlidingEstimator(clf, n_jobs=1, scoring='roc_auc', verbose=True)
time_decod.fit(X, y)
coef = get_coef(time_decod, 'patterns_', inverse_transform=True)
evoked = mne.EvokedArray(coef, epochs.info, tmin=epochs.times[0])
joint_kwargs = dict(ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'))
evoked.plot_joint(times=np.arange(0., .500, .100), title='patterns',
**joint_kwargs)
###############################################################################
# Temporal generalization
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# Temporal generalization is an extension of the decoding over time approach.
# It consists in evaluating whether the model estimated at a particular
# time instant accurately predicts any other time instant. It is analogous to
n_jobs=n_jobs,
)
y = epochs_df['label'].values.copy()
y[y == 2] = 0
scores = cross_val_multiscore(
time_decoder,
X=label_ts,
y=y,
groups=epochs_df['session'],
cv=len(epochs_df['session'].unique()),
n_jobs=n_jobs,
)
time_decoder.fit(label_ts, y)
coef = get_coef(time_decoder, 'patterns_', inverse_transform=True)
# %%
# Plot
def fig_save(fig, path):
html = fig.to_html()
with open(path, 'w') as f:
f.write(html)
p = np.max(np.abs(coef), axis=1)
o = np.argsort(p)[::-1]
p = p[o]
# Plot
fig, ax = plt.subplots()
ax.plot(epochs.times, scores, label='score')
ax.axhline(.5, color='k', linestyle='--', label='chance')
ax.set_xlabel('Times')
ax.set_ylabel('AUC') # Area Under the Curve
ax.legend()
ax.axvline(.0, color='k', linestyle='-')
ax.set_title('Sensor space decoding')
#------------------------------------------------------------------------------
clf = make_pipeline(StandardScaler(),
LinearModel(LogisticRegression(solver='lbfgs')))
time_decod = SlidingEstimator(clf, n_jobs=1, scoring='roc_auc')
time_decod.fit(ica_data, labels)
coef = get_coef(time_decod, 'patterns_', inverse_transform=True)
evoked = mne.EvokedArray(coef, epochs.info, tmin=epochs.times[0])
joint_kwargs = dict(ts_args=dict(time_unit='s'),
topomap_args=dict(time_unit='s'))
evoked.plot_joint(times=np.arange(9.5, 20.5, 1.), title='patterns',
**joint_kwargs)
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
#plot power image (time frequency-analysis)
n_cycles = 5 #number of cycles in Morlet wavelet
X_all = np.concatenate([X1, X2], axis=0)
y_all = np.concatenate([y1, y2], axis=0)
X_all.shape, y_all.shape
times = worker.clean_epochs.times
n_splits = int(y1.shape[0] / 64)
y_pred_time = np.zeros((3313, 141))
skf = StratifiedKFold(n_splits=n_splits, shuffle=False)
for train_index, test_index in skf.split(X_all, y_all):
X_train, y_train = X_all[train_index], y_all[train_index]
X_test, y_test = X_all[test_index], y_all[test_index]
estimator.fit(X_train, y_train)
y_pred_time[test_index] = estimator.predict(X_test)
# %%
y_pred_time.shape
# %%
report = metrics.classification_report(y_true=y_all,
y_pred=y_pred_time[:, 60],
output_dict=True)
print(report)
# %%
def fuck_report(report):
# different probe compare to target
if (epoch_type == 'Probe') & ('target' in analysis):
sel = np.where((events['Change'] == 1) & (~np.isnan(y)))[0]
else:
sel = np.where(~np.isnan(y))[0]
td = SlidingEstimator(clf,
scoring=make_scorer(scorer),
n_jobs=24,
**kwargs)
# run decoding
cv = StratifiedKFold(8)
scores = list()
patterns = list()
filters = list()
for train, test in cv.split(X[sel], y[sel]):
td.fit(X[sel][train], y[sel][train])
score = td.score(X[sel][test], y[sel][test])
scores.append(score)
patterns.append(get_coef(td, 'patterns_', inverse_transform=True))
filters.append(get_coef(td, 'filters_', inverse_transform=True))
scores = np.mean(scores, axis=0)
patterns = np.mean(patterns, axis=0)
filters = np.mean(filters, axis=0)
if 'angle' in analysis:
patterns = np.mean(np.abs(patterns), axis=1)
filters = np.mean(np.abs(filters), axis=1)
scores = np.reshape(scores, (n_freqs, n_times))
patterns = np.reshape(patterns, (n_channels, n_freqs, n_times))
filters = np.reshape(filters, (n_channels, n_freqs, n_times))
# save cross-validated scores
fname = results_folder +\
# fit_transform
X_train = xdawn.fit_transform(epochs[train_index])
y_train = y_true[train_index]
# transform
X_test = xdawn.transform(epochs[test_index])
y_test = y_true[test_index]
# All time decoder
# Fit
raw_decoder.fit(X_train, y_train)
# Predict
y_pred[test_index] = raw_decoder.predict(X_test)
# Time decoder
# Fit
time_decoder.fit(X_train, y_train)
# Predict
y_pred_time[test_index] = time_decoder.predict(X_test)
# Time window decoder
for window_length, _info in time_windows.items():
# _info[0], w_start
# _info[1], w_length
# _info[2], w_time
w_length = _info[1]
for j, w_start in enumerate(_info[0]):
w_stop = w_start + w_length
print(w_start)
# Crop X_train and X_test
_X_train = X_train[:, :, w_start:w_start + w_length]
_X_test = X_test[:, :, w_start:w_start + w_length]
y = le.transform(y)
sel = np.where(y != 0)[0]
le = LabelEncoder()
le.fit(y_con)
y_con = le.transform(y_con)
sel_con = np.where(y_con != 0)[0]
# Define estimators depending on the analysis
clf = make_pipeline(StandardScaler(), LinearModel(LogisticRegression()))
kwargs = dict()
est = SlidingEstimator(clf, scoring='roc_auc', n_jobs=24, **kwargs)
# Run decoding
cv = StratifiedKFold(12)
scores = list()
scores_con = list()
for train, test in cv.split(X[sel], y[sel]):
est.fit(X[sel][train], y[sel][train]) # train during WM task
score = est.score(X[sel][test], y[sel][test]) # test during WM task
score_con = est.score(X_con[sel_con],
y_con[sel_con]) # test during control task
scores.append(score)
scores_con.append(score_con)
scores = np.mean(scores, axis=0)
scores = np.reshape(scores, (n_freqs, n_times))
scores_con = np.mean(scores_con, axis=0)
scores_con = np.reshape(scores_con, (n_freqs, n_times))
# save cross-validated scores
fname = results_folder +\
'%s_scores_tf_%s.npy' % (subject, analysis)
np.save(fname, np.array(scores))
fname = results_folder +\
'%s_scores_tf_%s_con.npy' % (subject, analysis)
n_jobs=n_jobs,
)
y = df['label'].values.copy()
y[y == 2] = 0
scores = cross_val_multiscore(
time_decoder,
X=data,
y=y,
groups=df['session'],
cv=len(df['session'].unique()),
n_jobs=n_jobs,
)
time_decoder.fit(data, y)
# %%
# Plot
kwargs = dict(
x=times,
y=np.mean(scores, axis=0),
error_y=np.std(scores, axis=0),
title=f'Sensor Space Decoding (Auc of Roc) of {subject_name}',
)
fig = px.line(**kwargs)
fig.show()
coef = get_coef(time_decoder, 'patterns_', inverse_transform=True)[0]
evoked_time_gen = mne.EvokedArray(coef, info, tmin=times[0])