def test_TSclassifier_classifier(get_covmats, get_labels): """Test TS Classifier""" n_trials, n_channels, n_classes = 6, 3, 2 covmats = get_covmats(n_trials, n_channels) labels = get_labels(n_trials, n_classes) clf = TSclassifier(clf=DummyClassifier()) clf.fit(covmats, labels).predict(covmats)
def check_other_classifiers(train_X, train_y, test_X, test_y): from pyriemann.classification import MDM, TSclassifier from sklearn.linear_model import LogisticRegression from pyriemann.estimation import Covariances from sklearn.pipeline import Pipeline from mne.decoding import CSP import seaborn as sns import pandas as pd train_y = [np.where(i == 1)[0][0] for i in train_y] test_y = [np.where(i == 1)[0][0] for i in test_y] cov_data_train = Covariances().transform(train_X) cov_data_test = Covariances().transform(test_X) cv = KFold(n_splits=10, random_state=42) clf = TSclassifier() scores = cross_val_score(clf, cov_data_train, train_y, cv=cv, n_jobs=1) print("Tangent space Classification accuracy: ", np.mean(scores)) clf = TSclassifier() clf.fit(cov_data_train, train_y) print(clf.score(cov_data_test, test_y)) mdm = MDM(metric=dict(mean='riemann', distance='riemann')) scores = cross_val_score(mdm, cov_data_train, train_y, cv=cv, n_jobs=1) print("MDM Classification accuracy: ", np.mean(scores)) mdm = MDM() mdm.fit(cov_data_train, train_y) fig, axes = plt.subplots(1, 2) ch_names = [ch for ch in range(8)] df = pd.DataFrame(data=mdm.covmeans_[0], index=ch_names, columns=ch_names) g = sns.heatmap(df, ax=axes[0], square=True, cbar=False, xticklabels=2, yticklabels=2) g.set_title('Mean covariance - feet') df = pd.DataFrame(data=mdm.covmeans_[1], index=ch_names, columns=ch_names) g = sns.heatmap(df, ax=axes[1], square=True, cbar=False, xticklabels=2, yticklabels=2) plt.xticks(rotation='vertical') plt.yticks(rotation='horizontal') g.set_title('Mean covariance - hands') # dirty fix plt.sca(axes[0]) plt.xticks(rotation='vertical') plt.yticks(rotation='horizontal') plt.savefig("meancovmat.png") plt.show()
def test_TSclassifier(): """Test TS Classifier""" covset = generate_cov(40, 3) labels = np.array([0, 1]).repeat(20) assert_raises(TypeError, TSclassifier, clf='666') clf = TSclassifier() clf.fit(covset, labels) clf.predict(covset) clf.predict_proba(covset)
def test_TSclassifier(): """Test TS Classifier""" covset = generate_cov(40, 3) labels = np.array([0, 1]).repeat(20) assert_raises(TypeError, TSclassifier, clf='666') clf = TSclassifier() clf.fit(covset, labels) clf.predict(covset) clf.predict_proba(covset)
def test_TSclassifier(): """Test TS Classifier""" covset = generate_cov(40, 3) labels = np.array([0, 1]).repeat(20) with pytest.raises(TypeError): TSclassifier(clf='666') clf = TSclassifier() clf.fit(covset, labels) assert_array_equal(clf.classes_, np.array([0, 1])) clf.predict(covset) clf.predict_proba(covset)
class wrapper_TSclassifier(machine_learning_method): """wrapper for pyriemann TSclassifier""" def __init__(self, method_name, method_args): super(wrapper_TSclassifier, self).__init__(method_name, method_args) self.init_method() def init_method(self): self.classifier = TSclassifier(metric=self.method_args['metric'], tsupdate=self.method_args['tsupdate']) def fit(self, X, y): return self.classifier.fit(X, y) def predict(self, X): return self.classifier.predict(X)
def fit(self, X, y): # validate X, y = check_X_y(X, y, allow_nd=True) X = check_array(X, allow_nd=True) # set internal vars self.classes_ = unique_labels(y) self.X_ = X self.y_ = y ################################################## # split X into train and test sets, so that # grid search can be performed on train set only seed = 7 np.random.seed(seed) #X_TRAIN, X_TEST, y_TRAIN, y_TEST = train_test_split(X, y, test_size=0.25, random_state=seed) for epoch_trim in self.epoch_bounds: for bandpass in self.bandpass_filters: X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, random_state=seed) # X_train = np.copy(X_TRAIN) # X_test = np.copy(X_TEST) # y_train = np.copy(y_TRAIN) # y_test = np.copy(y_TEST) # separate out inputs that are tuples bandpass_start, bandpass_end = bandpass epoch_trim_start, epoch_trim_end = epoch_trim # bandpass filter coefficients b, a = butter( 5, np.array([bandpass_start, bandpass_end]) / (self.sfreq * 0.5), 'bandpass') # filter and crop TRAINING SET X_train = self.preprocess_X(X_train, b, a, epoch_trim_start, epoch_trim_end) # validate X_train, y_train = check_X_y(X_train, y_train, allow_nd=True) X_train = check_array(X_train, allow_nd=True) # filter and crop TEST SET X_test = self.preprocess_X(X_test, b, a, epoch_trim_start, epoch_trim_end) # validate X_test, y_test = check_X_y(X_test, y_test, allow_nd=True) X_test = check_array(X_test, allow_nd=True) ########################################################################### # self-tune CSP to find optimal number of filters to use at these settings #[best_num_filters, best_num_filters_score] = self.self_tune(X_train, y_train) best_num_filters = 5 # as an option, we could tune optimal CSP filter num against complete train set #X_tune = self.preprocess_X(X, b, a, epoch_trim_start, epoch_trim_end) #[best_num_filters, best_num_filters_score] = self.self_tune(X_tune, y) # now use this insight to really fit with optimal CSP spatial filters """ reg : float | str | None (default None) if not None, allow regularization for covariance estimation if float, shrinkage covariance is used (0 <= shrinkage <= 1). if str, optimal shrinkage using Ledoit-Wolf Shrinkage ('ledoit_wolf') or Oracle Approximating Shrinkage ('oas'). """ transformer = CSP(n_components=best_num_filters, reg='ledoit_wolf') transformer.fit(X_train, y_train) # use these CSP spatial filters to transform train and test spatial_filters_train = transformer.transform(X_train) spatial_filters_test = transformer.transform(X_test) # put this back in as failsafe if NaN or inf starts cropping up # spatial_filters_train = np.nan_to_num(spatial_filters_train) # check_X_y(spatial_filters_train, y_train) # spatial_filters_test = np.nan_to_num(spatial_filters_test) # check_X_y(spatial_filters_test, y_test) # train LDA classifier = LinearDiscriminantAnalysis() classifier.fit(spatial_filters_train, y_train) score = classifier.score(spatial_filters_test, y_test) #print "current score",score print "bandpass:"******"epoch window:", epoch_trim_start, epoch_trim_end #print best_num_filters,"filters chosen" # put in ranked order Top 10 list idx = bisect(self.ranked_scores, score) self.ranked_scores.insert(idx, score) self.ranked_scores_opts.insert( idx, dict(bandpass=bandpass, epoch_trim=epoch_trim, filters=best_num_filters)) self.ranked_classifiers.insert(idx, classifier) self.ranked_transformers.insert(idx, transformer) if len(self.ranked_scores) > self.num_votes: self.ranked_scores.pop(0) if len(self.ranked_scores_opts) > self.num_votes: self.ranked_scores_opts.pop(0) if len(self.ranked_classifiers) > self.num_votes: self.ranked_classifiers.pop(0) if len(self.ranked_transformers) > self.num_votes: self.ranked_transformers.pop(0) """ Covariance computation """ # compute covariance matrices cov_data_train = covariances(X=X_train) cov_data_test = covariances(X=X_test) clf_mdm = MDM(metric=dict(mean='riemann', distance='riemann')) clf_mdm.fit(cov_data_train, y_train) score_mdm = clf_mdm.score(cov_data_test, y_test) # print "MDM prediction score:",score_mdm # put in ranked order Top 10 list idx = bisect(self.ranked_scores_mdm, score_mdm) self.ranked_scores_mdm.insert(idx, score_mdm) self.ranked_scores_opts_mdm.insert( idx, dict(bandpass=bandpass, epoch_trim=epoch_trim, filters=best_num_filters)) self.ranked_classifiers_mdm.insert(idx, clf_mdm) if len(self.ranked_scores_mdm) > self.num_votes: self.ranked_scores_mdm.pop(0) if len(self.ranked_scores_opts_mdm) > self.num_votes: self.ranked_scores_opts_mdm.pop(0) if len(self.ranked_classifiers_mdm) > self.num_votes: self.ranked_classifiers_mdm.pop(0) clf_ts = TSclassifier() clf_ts.fit(cov_data_train, y_train) score_ts = clf_ts.score(cov_data_test, y_test) # put in ranked order Top 10 list idx = bisect(self.ranked_scores_ts, score_ts) self.ranked_scores_ts.insert(idx, score_ts) self.ranked_scores_opts_ts.insert( idx, dict(bandpass=bandpass, epoch_trim=epoch_trim, filters=best_num_filters)) self.ranked_classifiers_ts.insert(idx, clf_ts) if len(self.ranked_scores_ts) > self.num_votes: self.ranked_scores_ts.pop(0) if len(self.ranked_scores_opts_ts) > self.num_votes: self.ranked_scores_opts_ts.pop(0) if len(self.ranked_classifiers_ts) > self.num_votes: self.ranked_classifiers_ts.pop(0) print "CSP+LDA score:", score, "Tangent space w/LR score:", score_ts print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" print "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" print " T O P ", self.num_votes, " C L A S S I F I E R S" print #j=1 for i in xrange(len(self.ranked_scores)): print i, ",", round(self.ranked_scores[i], 4), ",", print self.ranked_scores_opts[i] print "-------------------------------------" for i in xrange(len(self.ranked_scores_ts)): print i, ",", round(self.ranked_scores_ts[i], 4), ",", print self.ranked_scores_opts_ts[i] print "-------------------------------------" for i in xrange(len(self.ranked_scores_mdm)): print i, ",", round(self.ranked_scores_mdm[i], 4), ",", print self.ranked_scores_opts_mdm[i] # finish up, set the flag to indicate "fitted" state self.fit_ = True # Return the classifier return self
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('-----------------------------------------') clf = TSclassifier() clf.fit(train, train_label) pred = clf.predict(test) print('TSC: {:4f}'.format(np.sum(pred == test_label) / box_length)) TSC_record.append(np.sum(pred == test_label) / box_length) print('-----------------------------------------') lr = LogisticRegression() csp = CSP(n_components=4, reg='ledoit_wolf', log=True) clf = Pipeline([('CSP', csp), ('LogisticRegression', lr)]) clf.fit(train_CSP, train_label) pred = clf.predict(test_CSP) print('CSP_lr: {:4f}'.format( np.sum(pred == test_label) / box_length)) CSP_lr_record.append(np.sum(pred == test_label) / box_length)