def test_MDM_predict():
"""Test prediction of MDM"""
covset = generate_cov(100, 3)
labels = np.array([0, 1]).repeat(50)
mdm = MDM(metric='riemann')
mdm.fit(covset, labels)
mdm.predict(covset)
def test_MDM_predict():
"""Test prediction of MDM"""
covset = generate_cov(100,3)
labels = np.array([0,1]).repeat(50)
mdm = MDM(metric='riemann')
mdm.fit(covset,labels)
mdm.predict(covset)
def test_MDM_predict():
"""Test prediction of MDM"""
covset = generate_cov(100, 3)
labels = np.array([0, 1]).repeat(50)
mdm = MDM(metric='riemann')
mdm.fit(covset, labels)
mdm.predict(covset)
# test fit_predict
mdm = MDM(metric='riemann')
mdm.fit_predict(covset, labels)
# test transform
mdm.transform(covset)
# predict proba
mdm.predict_proba(covset)
# test n_jobs
mdm = MDM(metric='riemann', n_jobs=2)
mdm.fit(covset, labels)
mdm.predict(covset)
def erp_cov_vr_pc(X_training, labels_training, X_test, labels_test, class_name,
class_info):
# estimate the extended ERP covariance matrices with Xdawn
erpc = ERPCovariances(classes=[class_info[class_name]], estimator='lwf')
erpc.fit(X_training, labels_training)
covs_training = erpc.transform(X_training)
covs_test = erpc.transform(X_test)
# get the AUC for the classification
clf = MDM()
clf.fit(covs_training, labels_training)
labels_pred = clf.predict(covs_test)
return roc_auc_score(labels_test, labels_pred)
def test_MDM_predict():
"""Test prediction of MDM"""
covset = generate_cov(100, 3)
labels = np.array([0, 1]).repeat(50)
mdm = MDM(metric='riemann')
mdm.fit(covset, labels)
mdm.predict(covset)
# test fit_predict
mdm = MDM(metric='riemann')
mdm.fit_predict(covset, labels)
# test transform
mdm.transform(covset)
# predict proba
mdm.predict_proba(covset)
# test n_jobs
mdm = MDM(metric='riemann', n_jobs=2)
mdm.fit(covset, labels)
mdm.predict(covset)
class FgMDM2(BaseEstimator, ClassifierMixin, TransformerMixin):
def __init__(self, metric='riemann', tsupdate=False, n_jobs=1):
"""Init."""
self.metric = metric
self.n_jobs = n_jobs
self.tsupdate = tsupdate
if isinstance(metric, str):
self.metric_mean = metric
elif isinstance(metric, dict):
# check keys
for key in ['mean', 'distance']:
if key not in metric.keys():
raise KeyError('metric must contain "mean" and "distance"')
self.metric_mean = metric['mean']
else:
raise TypeError('metric must be dict or str')
def fit(self, X, y):
self.classes_ = unique_labels(y)
self._mdm = MDM(metric=self.metric, n_jobs=self.n_jobs)
self._fgda = FGDA(metric=self.metric_mean, tsupdate=self.tsupdate)
cov = self._fgda.fit_transform(X, y)
self._mdm.fit(cov, y)
return self
def predict(self, X):
cov = self._fgda.transform(X)
return self._mdm.predict(cov)
def predict_proba(self, X):
cov = self._fgda.transform(X)
return self._mdm.predict_proba(cov)
def transform(self, X):
cov = self._fgda.transform(X)
return self._mdm.transform(cov)
class wrapper_MDM(machine_learning_method):
"""wrapper for pyriemann MDM"""
def __init__(self, method_name, method_args):
super(wrapper_MDM, self).__init__(method_name, method_args)
self.init_method()
def init_method(self, n_jobs=1):
self.classifier = MDM(metric=self.method_args['metric'], n_jobs=n_jobs)
def set_parallel(self, is_parallel=False, n_jobs=8):
logging.warning(
'The call to this set_parallel method is reseting the class, and must be fitted again'
)
self.parallel = is_parallel
self.n_jobs = n_jobs
if self.parallel:
self.init_method(n_jobs)
def fit(self, X, y):
return self.classifier.fit(X, y)
def predict(self, X):
return self.classifier.predict(X)
tmax=5,
baseline=None)
offline_epochs_data = offline_epochs.get_data()
# Creating ML model
offline_cov_matrix = Covariances(
estimator='lwf').transform(offline_epochs_data)
mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
mdm.fit(offline_cov_matrix, labels)
# Evoking trials to simulate online input
iter_evoked = epochs.iter_evoked()
epochs_data = offline_epochs_data
time_array = []
pre_predict = mdm.predict(offline_cov_matrix)
print("Labels: ")
print(labels)
for i, evoked in enumerate(iter_evoked):
evoked_raw = createRaw(evoked.data, raw, filtered=False)
## Start Time Counting
time_1 = time.time()
## Filtering
evoked_filtered_signal = _bandpass_filter(evoked_raw, frequencies,
frequency_range)
evoked_filtered_signal = np.array(evoked_filtered_signal)
evoked_filtered_signal = np.expand_dims(evoked_filtered_signal, axis=0)
def get_score(subject=7, runs=[6, 10, 14], event_id=dict(hands=2, feet=3)):
if subject in EXCLUDE_SUBJECTS:
return
tmin, tmax = -1., 4.
weights = np.arange(0.1, 1.0, 0.1)
for weight in weights:
first_sub = 2 if subject == 1 else 1
raw = get_raw(subject, runs)
scores = []
for i in range(first_sub, TRANS_SUBJECT_COUNT):
print(i)
if i == subject or (i in EXCLUDE_SUBJECTS):
continue
raw.append(get_raw(i, runs))
events = find_events(raw, shortest_event=0, stim_channel='STI 014')
epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True,
baseline=None, preload=True, verbose=False)
labels = epochs.events[:, -1]
epochs_data_train = 1e6*epochs.get_data()[:, :-1]
cov_data_train = Covariances().transform(epochs_data_train)
target_sample_weight_base = np.ones(EPOCH_COUNT)*weight
others_sample_weight_base = np.ones(
len(epochs)-EPOCH_COUNT)*(1.-weight)
sample_weight = np.hstack(
(target_sample_weight_base, others_sample_weight_base))
others_size = others_sample_weight_base.size
others_index = np.arange(others_size)
mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
cv = KFold(n_splits=5, shuffle=True, random_state=42)
train_scores = []
test_scores = []
dumy_array = np.ones(EPOCH_COUNT)
for train_index, test_index in cv.split(dumy_array):
train_index = np.hstack(
(others_index, train_index+others_size))
x = cov_data_train[train_index]
y = labels[train_index]
mdm.fit(x, y, sample_weight=sample_weight[train_index])
score = (mdm.predict(x) == y).sum()/len(train_index)
train_scores.append(score)
test_index = test_index + others_size
y = mdm.predict(cov_data_train[test_index])
score = (y == labels[test_index]).sum()/len(test_index)
test_scores.append(score)
train_score = np.mean(train_scores)
test_score = np.mean(test_scores)
scores.append([subject, i, train_score, test_score])
df = pd.DataFrame(
scores, columns=["subject", "transfer_count", "train_score", "test_score"])
df.to_excel("data/riemann/gradually/test_subject_%d_weight_%e.xlsx" %
(subject, weight), index=False)
epochs_data = np.concatenate((epochs_data, filtered_signal), axis=0)
## No Filtering
# raw_evoked_signal = evoked.data
# raw_evoked_signal = np.array(raw_evoked_signal)
# raw_evoked_signal = np.expand_dims(raw_evoked_signal, axis=0)
cov_ext_trials = Covariances(estimator='lwf').transform(epochs_data)
labels = np.append(labels, labels[count])
if (count % 4 == 0 and count != 0 and retrain == True):
mdm.fit(cov_ext_trials, labels)
print("retrained")
prediction_labeled = mdm.predict(cov_ext_trials)
# Finish Time Counter
time_2 = time.time()
time_array.append(time_2 - time_1)
count += 1
print("Predictions: ")
print(prediction_labeled[:32])
print(prediction_labeled[32:])
# print ("Label: " + str(labels[i]))
print("Time: " + str(time_2 - time_1) + '\n')
print("Predictions: ")
print(prediction_labeled[:32])
print(prediction_labeled[32:])
for train_index, test_index in kf.split(X_train):
logging.info(f'Doing fold {i}')
clf_knn = KNearestNeighbor(n_neighbors, metric, n_jobs)
clf_mdm = MDM(metric, n_jobs)
X_train_fold, X_test_fold = X_train[train_index], X_train[test_index]
y_train_fold, y_test_fold = y_train[train_index], y_train[test_index]
clf_knn.fit(X_train_fold, y_train_fold)
y_predicted = clf_knn.predict(X_test_fold)
accuracy = (y_test_fold == y_predicted).sum() / len(y_test_fold)
clf_knn_k_fold.append(clf_knn)
accuracy_list_training_knn.append(accuracy)
clf_mdm.fit(X_train_fold, y_train_fold)
y_predicted = clf_mdm.predict(X_test_fold)
accuracy = (y_test_fold == y_predicted).sum() / len(y_test_fold)
clf_mdm_k_fold.append(clf_mdm)
accuracy_list_training_mdm.append(accuracy)
i += 1
# Testing on test dataset
logging.info('Doing testing')
accuracy_list_testing_knn = []
accuracy_list_testing_mdm = []
X_test, y_test = shuffle(X_test, y_test, random_state=args.seed)
for clf_knn in clf_knn_k_fold:
y_predicted = clf_knn.predict(X_test)
accuracy = (y_test == y_predicted).sum() / len(y_test)
def get_score(subject=7, runs=[6, 10, 14], event_id=dict(hands=2, feet=3)):
tmin, tmax = -1., 4.
# learn all suject exclude target subject. #############################
first_sub = 2 if subject == 1 else 1
raw = get_raw(first_sub, runs)
for i in range(first_sub + 1, 3):
if i != subject and not (i in [88, 89, 92, 100]):
# print(i)
raw.append(get_raw(i, runs))
raw.append(get_raw(subject, runs))
events = find_events(raw, shortest_event=0, stim_channel='STI 014')
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=True,
baseline=None,
preload=True,
verbose=False)
labels = epochs.events[:, -1]
epochs_data_train = 1e6 * epochs.get_data()[:, :-1]
cov_data_train = Covariances().transform(epochs_data_train)
weights = np.arange(0.1, 1.0, 0.1)
scores = []
for weight in weights:
mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
others_sample_weight_base = np.ones(len(epochs) -
EPOCH_COUNT) * (1. - weight)
target_sample_weight_base = np.ones(EPOCH_COUNT) * weight
sample_weight = np.hstack(
(others_sample_weight_base, target_sample_weight_base))
others_size = others_sample_weight_base.size
others_index = np.arange(others_size)
cv = KFold(n_splits=5, shuffle=True, random_state=42)
train_scores = []
test_scores = []
dumy_array = np.ones(EPOCH_COUNT)
for train_index, test_index in cv.split(dumy_array):
train_index = np.hstack((others_index, train_index + others_size))
x = cov_data_train[train_index]
y = labels[train_index]
mdm.fit(x, y, sample_weight=sample_weight[train_index])
score = (mdm.predict(x) == y).sum() / len(train_index)
train_scores.append(score)
test_index = test_index + others_size
y = mdm.predict(cov_data_train[test_index])
score = (y == labels[test_index]).sum() / len(test_index)
test_scores.append(score)
train_score = np.mean(train_scores)
test_score = np.mean(test_scores)
scores.append([subject, weight, train_score, test_score])
# print("train:%s test:%s" % (train_score, test_score))
return scores
blocks = np.arange(1, 12+1)
for train_idx, test_idx in kf.split(np.arange(12)):
# split in training and testing blocks
X_training, labels_training, _ = get_block_repetition(X, labels, meta, blocks[train_idx], repetitions)
X_test, labels_test, _ = get_block_repetition(X, labels, meta, blocks[test_idx], repetitions)
# estimate the extended ERP covariance matrices with Xdawn
dict_labels = {'Target':1, 'NonTarget':0}
erpc = ERPCovariances(classes=[dict_labels['Target']], estimator='lwf')
erpc.fit(X_training, labels_training)
covs_training = erpc.transform(X_training)
covs_test = erpc.transform(X_test)
# get the AUC for the classification
clf = MDM()
clf.fit(covs_training, labels_training)
labels_pred = clf.predict(covs_test)
auc.append(roc_auc_score(labels_test, labels_pred))
# stock scores
scores_subject.append(np.mean(auc))
scores.append(scores_subject)
# print results
df[tmax] = pd.DataFrame(scores, columns=['subject', 'VR', 'PC'])
filename = './results.pkl'
joblib.dump(df, filename)
def score_ensemble_rot(settings, subject_target, ntop):
dataset = settings['dataset']
paradigm = settings['paradigm']
session = settings['session']
storage = settings['storage']
filepath = '../results/' + dataset + '/TL_intra-subject_scores.pkl'
acc_intra_dict = joblib.load(filepath)
scores = []
subject_sources = []
for subject in settings['subject_list']:
if subject == subject_target:
continue
else:
scores.append(acc_intra_dict[subject])
subject_sources.append(subject)
scores = np.array(scores)
subject_sources = np.array(subject_sources)
idx_sort = scores.argsort()[::-1]
scores = scores[idx_sort]
subject_sources = subject_sources[idx_sort]
subject_sources_ntop = subject_sources[:ntop]
# get the geometric means for each subject (each class and also the center)
filename = '../results/' + dataset + '/subject_means.pkl'
subj_means = joblib.load(filename)
# get the data for the target subject
target_org = GD.get_dataset(dataset, subject_target, session, storage)
if paradigm == 'MI':
# things here are only implemented for MI for now
target_org['covs'] = Covariances(estimator='oas').fit_transform(
target_org['signals'])
target_org['labels'] = target_org['labels']
ncovs = settings['ncovs_list'][0]
nrzt = 10
score_rzt = 0.0
for rzt in range(nrzt):
# split randomly the target dataset
target_org_train, target_org_test = get_target_split_motorimagery(
target_org, ncovs)
covs_train_target = target_org_train['covs']
labs_train_target = target_org_train['labels']
MC_target = mean_riemann(covs_train_target)
M1_target = mean_riemann(
covs_train_target[labs_train_target == 'left_hand'])
M2_target = mean_riemann(
covs_train_target[labs_train_target == 'right_hand'])
M1_target_rct = np.dot(invsqrtm(MC_target),
np.dot(M1_target, invsqrtm(MC_target)))
M2_target_rct = np.dot(invsqrtm(MC_target),
np.dot(M2_target, invsqrtm(MC_target)))
covs_train_target = np.stack([M1_target_rct, M2_target_rct])
labs_train_target = np.array(['left_hand', 'right_hand'])
clf = []
for subj_source in subject_sources_ntop:
MC_source = subj_means[subj_source]['center']
M1_source = subj_means[subj_source]['left_hand']
M2_source = subj_means[subj_source]['right_hand']
M1_source_rct = np.dot(invsqrtm(MC_source),
np.dot(M1_source, invsqrtm(MC_source)))
M2_source_rct = np.dot(invsqrtm(MC_source),
np.dot(M2_source, invsqrtm(MC_source)))
M = [M1_target_rct, M2_target_rct]
Mtilde = [M1_source_rct, M2_source_rct]
R = manifoptim.get_rotation_matrix(M, Mtilde)
M1_source_rot = np.dot(R, np.dot(M1_source_rct, R.T))
M2_source_rot = np.dot(R, np.dot(M2_source_rct, R.T))
covs_train_source = np.stack([M1_source_rot, M2_source_rot])
labs_train_source = np.array(['left_hand', 'right_hand'])
covs_train = np.concatenate([covs_train_source, covs_train_target])
labs_train = np.concatenate([labs_train_source, labs_train_target])
clfi = MDM()
# problems here when using integer instead of floats on the sample_weight
clfi.fit(covs_train,
labs_train,
sample_weight=np.array(
[200.0, 200.0, 2.0 * ncovs, 2.0 * ncovs]))
clf.append(clfi)
covs_test = target_org_test['covs']
labs_test = target_org_test['labels']
ypred = []
for clfi in clf:
yi = clfi.predict(covs_test)
ypred.append(yi)
ypred = np.array(ypred)
majorvoting = []
for j in range(ypred.shape[1]):
ypredj = ypred[:, j]
values_unique, values_count = np.unique(ypredj, return_counts=True)
majorvoting.append(values_unique[np.argmax(values_count)])
majorvoting = np.array(majorvoting)
score_rzt = score_rzt + np.mean(majorvoting == labs_test)
score = score_rzt / nrzt
return score
for fold in range(1, 6):
train = cov_data_bad[index[bad_subject_index] != fold]
train_CSP = epochs_data_train_bad[index[bad_subject_index] != fold]
train_label = labels_bad[index[bad_subject_index] != fold]
test = cov_data_bad[index[bad_subject_index] == fold]
test_CSP = epochs_data_train_bad[index[bad_subject_index] == fold]
test_label = labels_bad[index[bad_subject_index] == fold]
box_length = np.sum([index[bad_subject_index] == fold])
mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
mdm.fit(train, train_label)
pred = mdm.predict(test)
print('MDM: {:4f}'.format(np.sum(pred == test_label) / box_length))
MDM_record.append(np.sum(pred == test_label) / box_length)
print('-----------------------------------------')
Fgmdm = FgMDM(metric=dict(mean='riemann', distance='riemann'))
Fgmdm.fit(train, train_label)
pred = Fgmdm.predict(test)
print('FGMDM: {:4f}'.format(
np.sum(pred == test_label) / box_length))
FGMDM_record.append(np.sum(pred == test_label) / box_length)
print('-----------------------------------------')
