def test_hankel_covariances_delays(rndstate):
n_matrices, n_channels, n_times = 2, 3, 100
x = rndstate.randn(n_matrices, n_channels, n_times)
cov = HankelCovariances(delays=[1, 2])
cov.fit(x)
covmats = cov.fit_transform(x)
assert covmats.shape == (n_matrices, 3 * n_channels, 3 * n_channels)
assert is_spd(covmats)
def transform(self, X):
"""
Detect and remove dropped.
"""
out = []
hk = HankelCovariances(delays=self.order, estimator=np.corrcoef)
for x in X:
tmp = []
for a in x:
tmp.append(hk.fit_transform(np.atleast_3d(a[::self.subsample]).transpose(0,2,1))[0])
out.append(tmp)
return np.array(out).transpose(0,2,3,1)
def test_hankel_covariances(rndstate):
"""Test Hankel Covariances"""
n_matrices, n_channels, n_times = 2, 3, 100
x = rndstate.randn(n_matrices, n_channels, n_times)
cov = HankelCovariances()
cov.fit(x)
covmats = cov.fit_transform(x)
assert cov.get_params() == dict(estimator="scm", delays=4)
assert covmats.shape == (n_matrices, 4 * n_channels, 4 * n_channels)
assert is_spd(covmats)
array_clfs['Xdawn'] = make_pipeline(Xdawn(12, estimator='oas'), DownSampler(5),
EpochsVectorizer(),
LogisticRegression('l2'))
# Induced activity models
baseclf = make_pipeline(
ElectrodeSelection(10, metric=dict(mean='logeuclid', distance='riemann')),
TangentSpace('riemann'), LogisticRegression('l1'))
array_clfs['Cosp'] = make_pipeline(
CospCovariances(fs=1000, window=32, overlap=0.95, fmax=300, fmin=1),
CospBoostingClassifier(baseclf))
array_clfs['HankelCov'] = make_pipeline(
DownSampler(2), HankelCovariances(delays=[2, 4, 8, 12, 16],
estimator='oas'),
TangentSpace('logeuclid'), LogisticRegression('l1'))
array_clfs['CSSP'] = make_pipeline(
HankelCovariances(delays=[2, 4, 8, 12, 16], estimator='oas'), CSP(30),
LogisticRegression('l1'))
patients = dataframe1.PatientID.values
index = array_clfs.keys() + ['Ensemble']
columns = ['ca', 'de', 'fp', 'ja', 'mv', 'wc', 'zt']
res_acc = pd.DataFrame(index=index, columns=columns)
res_auc = pd.DataFrame(index=index, columns=columns)
fnames = glob('./fhpred/data/*/*.mat')
def pyR_decoding_on_full_epochs(X,
y,
plot_conf_matrix=0,
class_names=None,
test_size=0.2,
n_splits=5,
classifier='ERP_cov'):
""" This function decodes on the full epoch using the pyRiemannian decoder
cf https://github.com/Team-BK/Biomag2016/blob/master/Final_Submission.ipynb
Parameters
---------
X : data extracted from the epochs provided to the decoder
y : categorical variable (i.e. discrete but it can be more then 2 categories)
plot_confusion_matrix : set to 1 if you wanna see the confusion matrix
class_names: needed for the legend if confusion matrices are plotted ['cat1','cat2','cat3']
test_size : proportion of the data on which you wanna test the decoder
n_splits : when calculating the score, number of cross-validation folds
classifier : set it to 'ERP_cov', 'Xdawn_cov' or 'Hankel_cov' depending on the classification you want to do.
Returns: scores, y_test, y_pred, cnf_matrix or just scores if you don't want the confusion matrix
-------
"""
# ------- define the classifier -------
if classifier == 'ERP_cov':
spatial_filter = UnsupervisedSpatialFilter(PCA(20), average=False)
ERP_cov = ERPCovariances(estimator='lwf')
CSP_30 = CSP(30, log=False)
tang = TangentSpace('logeuclid')
clf = make_pipeline(spatial_filter, ERP_cov, CSP_30, tang,
LogisticRegression('l2'))
if classifier == 'Xdawn_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(50), average=False),
XdawnCovariances(12, estimator='lwf', xdawn_estimator='lwf'),
TangentSpace('logeuclid'), LogisticRegression('l2'))
if classifier == 'Hankel_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(70), average=False),
HankelCovariances(delays=[1, 8, 12, 64], estimator='oas'),
CSP(15, log=False), TangentSpace('logeuclid'),
LogisticRegression('l2'))
cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=4343)
y = np.asarray(y)
scores = []
for train_index, test_index in cv.split(X, y):
print(train_index)
print(test_index)
print('we are in the CV loop')
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
# Train on X_train, y_train
clf.fit(X_train, y_train)
# Predict the category on X_test
y_pred = clf.predict(X_test)
scores.append(accuracy_score(y_true=y_test, y_pred=y_pred))
scores = np.asarray(scores)
if plot_conf_matrix == 1:
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=7, stratify=y)
print('train and test have been split')
y_pred = clf.fit(X_train, y_train).predict(X_test)
# Compute confusion matrix
cnf_matrix = confusion_matrix(y_test, y_pred)
np.set_printoptions(precision=2)
print(cnf_matrix)
# Plot non-normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix,
classes=class_names,
title='Confusion matrix, without normalization')
# Plot normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix,
classes=class_names,
normalize=True,
title='Normalized confusion matrix')
plt.show()
return scores, y_test, y_pred, cnf_matrix
return scores, y_test, y_pred, cnf_matrix
def test_Hankelcovariances():
"""Test Hankel Covariances"""
x = np.random.randn(2, 3, 100)
cov = HankelCovariances()
cov.fit(x)
cov.fit_transform(x)
assert cov.get_params() == dict(estimator='scm', delays=4)
cov = HankelCovariances(delays=[1, 2])
cov.fit(x)
cov.fit_transform(x)
def test_Hankelcovariances():
"""Test Hankel Covariances"""
x = np.random.randn(2, 3, 100)
cov = HankelCovariances()
cov.fit(x)
cov.fit_transform(x)
assert_equal(cov.get_params(), dict(estimator='scm', delays=4))
cov = HankelCovariances(delays=[1, 2])
cov.fit(x)
cov.fit_transform(x)
def decode(epochs,
get_y_label_func,
epoch_filter=None,
decoding_method='standard',
sliding_window_size=None,
sliding_window_step=None,
n_jobs=multiprocessing.cpu_count(),
equalize_event_counts=True,
only_fit=False,
generalize_across_time=True):
"""
Basic flow for decoding
"""
config = dict(equalize_event_counts=equalize_event_counts,
only_fit=only_fit,
sliding_window_size=sliding_window_size,
sliding_window_step=sliding_window_step,
decoding_method=decoding_method,
generalize_across_time=generalize_across_time,
epoch_filter=str(epoch_filter))
if epoch_filter is not None:
epochs = epochs[epoch_filter]
#-- Classify epochs into groups (training epochs)
y_labels = get_y_label_func(epochs)
if equalize_event_counts:
epochs.events[:, 2] = y_labels
epochs.event_id = {str(label): label for label in np.unique(y_labels)}
min_n_items_per_y_label = min(
[len(epochs[cond]) for cond in epochs.event_id.keys()])
print("\nEqualizing the number of epochs to %d per condition..." %
min_n_items_per_y_label)
epochs.equalize_event_counts(epochs.event_id.keys())
y_labels = epochs.events[:, 2]
print("The epochs were classified into %d groups:" % len(set(y_labels)))
for g in set(y_labels):
print("Group {:}: {:} epochs".format(g, sum(np.array(y_labels) == g)))
#-- Create the decoding pipeline
print("Creating the classification pipeline...")
epochs_data = epochs.get_data()
preprocess_pipeline = None
if decoding_method.startswith('standard'):
if 'reg' in decoding_method:
clf = make_pipeline(StandardScaler(), Ridge())
else:
clf = make_pipeline(
StandardScaler(),
svm.SVC(C=1, kernel='linear', class_weight='balanced'))
if 'raw' not in decoding_method:
assert sliding_window_size is not None
assert sliding_window_step is not None
preprocess_pipeline = \
make_pipeline(umne.transformers.SlidingWindow(window_size=sliding_window_size, step=sliding_window_step, average=True))
elif decoding_method == 'ERP_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(20), average=False),
ERPCovariances(
estimator='lwf'), # todo how to apply sliding window?
CSP(30, log=False),
TangentSpace('logeuclid'),
LogisticRegression('l2')) # todo why logistic regression?
elif decoding_method == 'Xdawn_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(50), average=False),
XdawnCovariances(12, estimator='lwf', xdawn_estimator='lwf'),
TangentSpace('logeuclid'), LogisticRegression('l2'))
elif decoding_method == 'Hankel_cov':
clf = make_pipeline(
UnsupervisedSpatialFilter(PCA(70), average=False),
HankelCovariances(delays=[1, 8, 12, 64], estimator='oas'),
CSP(15, log=False), TangentSpace('logeuclid'),
LogisticRegression('l2'))
else:
raise Exception('Unknown decoding method: {:}'.format(decoding_method))
print('\nDecoding pipeline:')
for i in range(len(clf.steps)):
print('Step #{:}: {:}'.format(i + 1, clf.steps[i][1]))
if preprocess_pipeline is not None:
print('\nApplying the pre-processing pipeline:')
for i in range(len(preprocess_pipeline.steps)):
print('Step #{:}: {:}'.format(i + 1,
preprocess_pipeline.steps[i][1]))
epochs_data = preprocess_pipeline.fit_transform(epochs_data)
if only_fit:
#-- Only fit the decoders
procedure = 'only_fit'
scores = None
cv = None
if decoding_method.startswith('standard'):
if 'reg' in decoding_method:
if 'r2' in decoding_method:
scoring = metrics.make_scorer(metrics.r2_score)
else:
scoring = metrics.make_scorer(metrics.mean_squared_error)
else:
scoring = 'accuracy'
if generalize_across_time:
estimator = GeneralizingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
else:
estimator = SlidingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
else:
estimator = clf
estimator.fit(X=epochs_data, y=y_labels)
else:
#-- Classify & score -- cross-validation
procedure = 'fit_and_score'
print(
"\nCreating a classifier and calculating accuracy scores (this may take some time)..."
)
cv = StratifiedKFold(n_splits=5)
if decoding_method.startswith('standard'):
if 'reg' in decoding_method:
if 'r2' in decoding_method:
scoring = metrics.make_scorer(metrics.r2_score)
else:
scoring = metrics.make_scorer(metrics.mean_squared_error)
else:
scoring = 'accuracy'
if generalize_across_time:
estimator = GeneralizingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
else:
estimator = SlidingEstimator(clf,
scoring=scoring,
n_jobs=n_jobs)
scores = cross_val_multiscore(estimator=estimator,
X=epochs_data,
y=np.array(y_labels),
cv=cv)
else:
scores = _run_cross_validation(X=epochs_data,
y=np.array(y_labels),
clf=clf,
cv=cv)
estimator = 'None' # Estimator is not defined in the case of Riemannian decoding
times = np.linspace(epochs.tmin, epochs.tmax, epochs_data.shape[2])
return dict(procedure=procedure,
estimator=estimator,
scores=scores,
pipeline=clf,
preprocess=preprocess_pipeline,
cv=cv,
times=times,
config=config)