def _Q_S_estim_riemann(self, data): # Check if X is a single trial (test data) or not if data.ndim == 2: data = data[np.newaxis, ...] # Get data shape n_trials, n_channels, n_samples = data.shape X = np.concatenate((data, data), axis=1) # Concatenate all the trials UX = np.empty((n_channels, n_samples * n_trials)) for trial_n in range(n_trials): UX[:, trial_n * n_samples:(trial_n + 1) * n_samples] = data[trial_n, :, :] # Mean centering UX -= np.mean(UX, 1)[:, None] # Compute empirical variance of all data (to be bounded) cov = Covariances(estimator=self.estimator).fit_transform( UX[np.newaxis, ...]) Q = np.squeeze(cov) cov = Covariances(estimator=self.estimator).fit_transform(X) S = cov[:, :n_channels, n_channels:] + cov[:, n_channels:, :n_channels] S = mean_covariance(S, metric=self.method) return S, Q
def _Q_S_estim(self, data): # Check if X is a single trial (test data) or not if data.ndim == 2: data = data[np.newaxis, ...] # Get data shape n_trials, n_channels, n_samples = data.shape X = np.concatenate((data, data), axis=1) # Initialize S matrix S = np.zeros((n_channels, n_channels)) # Estimate covariance between every trial and the rest of the trials (excluding itself) for trial_i in range(n_trials - 1): x1 = np.squeeze(data[trial_i, :, :]) # Mean centering for the selected trial x1 -= np.mean(x1, 0) # Select a second trial that is different for trial_j in range(trial_i + 1, n_trials): x2 = np.squeeze(data[trial_j, :, :]) # Mean centering for the selected trial x2 -= np.mean(x2, 0) # Put the two trials together X = np.concatenate((x1, x2)) if n_channels == 1: X = X.reshape((n_channels, len(X))) # Regularized covariance estimate cov = Covariances(estimator=self.estimator).fit_transform( X[np.newaxis, ...]) cov = np.squeeze(cov) # Compute empirical covariance betwwen the two selected trials and sum it if n_channels > 1: S = S + cov[:n_channels, n_channels:] + cov[n_channels:, :n_channels] else: S = S + cov + cov # Concatenate all the trials UX = np.empty((n_channels, n_samples * n_trials)) for trial_n in range(n_trials): UX[:, trial_n * n_samples:(trial_n + 1) * n_samples] = data[trial_n, :, :] # Mean centering UX -= np.mean(UX, 1)[:, None] cov = Covariances(estimator=self.estimator).fit_transform( UX[np.newaxis, ...]) Q = np.squeeze(cov) return S, Q
def _train_raw(df): """Train a classifier on raw EEG data""" X, y = transform.signal_ndarray(df) # print(X, y) # Fixes non-convergence for binary classification dual = set(y) == 2 clfs: Dict[str, Pipeline] = { # These four are from https://neurotechx.github.io/eeg-notebooks/auto_examples/visual_ssvep/02r__ssvep_decoding.html "CSP + Cov + TS": make_pipeline( Covariances(), CSP(4, log=False), TangentSpace(), LogisticRegression(dual=dual), ), "Cov + TS": make_pipeline(Covariances(), TangentSpace(), LogisticRegression(dual=dual)), # Performs meh # "CSP + RegLDA": make_pipeline( # Covariances(), CSP(4), LDA(shrinkage="auto", solver="eigen") # ), # Performs badly # "Cov + MDM": make_pipeline(Covariances(), MDM()), } for name, clf in clfs.items(): logger.info(f"===== Training with {name} =====") _train(X, y, clf)
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_shrinkage(): """Test Shrinkage""" x = np.random.randn(2, 3, 100) cov = Covariances() covs = cov.fit_transform(x) sh = Shrinkage() sh.fit(covs) sh.transform(covs) assert_equal(sh.get_params(), dict(shrinkage=0.1))
def test_shrinkage(): """Test Shrinkage""" x = np.random.randn(2, 3, 100) cov = Covariances() covs = cov.fit_transform(x) sh = Shrinkage() sh.fit(covs) sh.transform(covs) assert sh.get_params() == dict(shrinkage=0.1)
def make_fig2(save=False): data_params = {} data_params[ 'path'] = '/research/vibs/Pedro/datasets/motorimagery/BCI-competitions/BCI-IV/2a/' data_params['session'] = 1 data_params['task'] = 1 data_params['tparams'] = [1.25, 3.75] data_params['fparams'] = [8.0, 35.0] data_params['subject'] = 5 X, yworst = get_data(data_params) X = X[(yworst == 1) | (yworst == 2)] yworst = yworst[(yworst == 1) | (yworst == 2)] covs = Covariances().fit_transform(X) uworst, lworst = get_diffusionEmbedding(points=covs, distance=distance_riemann) data_params['subject'] = 1 X, ybest = get_data(data_params) X = X[(ybest == 1) | (ybest == 2)] ybest = ybest[(ybest == 1) | (ybest == 2)] covs = Covariances().fit_transform(X) ubest, lbest = get_diffusionEmbedding(points=covs, distance=distance_riemann) fig = plt.figure(figsize=(10.5, 5)) plt.subplots_adjust(wspace=0.020, hspace=0.025) plt.subplot(1, 2, 1) colorst = [['b', 'r'][int(t)] for t in (yworst - 2)] plt.scatter(uworst[:, 1], uworst[:, 2], color=colorst, s=44) plt.xlabel(r'$\phi_1$', fontsize=26) plt.ylabel(r'$\phi_2$', fontsize=26) plt.xticks([]) plt.yticks([]) ttl = plt.title('Worst subject', fontsize=20) ttl.set_position([.5, 1.025]) ax = plt.subplot(1, 2, 2) colorst = [['b', 'r'][int(t)] for t in (ybest - 2)] plt.scatter(ubest[:, 1], ubest[:, 2], color=colorst, s=44) plt.xlabel(r'$\phi_1$', fontsize=26) plt.ylabel(r'$\phi_2$', fontsize=26) ax.yaxis.set_label_position("right") plt.xticks([]) plt.yticks([]) ttl = plt.title('Best subject', fontsize=20) ttl.set_position([.5, 1.025]) if save: name = 'figure2' savefigure(name) return [uworst, lworst], [ubest, lbest]
def compute_cov(state): """Computes the crosspectrum matrices per subjects.""" for sub in SUBJECT_LIST: pattern = prefix + "_s{}_{}.mat" file_path = path(SAVE_PATH / pattern.format(sub, state)) if not file_path.isfile(): # data must be of shape n_trials x n_elec x n_samples data = load_samples(DATA_PATH, sub, state) if FULL_TRIAL: data = np.concatenate(data, axis=1) data = data.reshape(1, data.shape[0], data.shape[1]) cov = Covariances() mat = cov.fit_transform(data) savemat(file_path, {"data": mat})
def xdawn_embedding(data, use_xdawn): """Perform embedding of EEG data in 2D Euclidean space with Laplacian Eigenmaps. Parameters ---------- data : dict A dictionary containing training and testing data Returns ------- array Embedded """ if use_xdawn: nfilter = 3 xdwn = XdawnCovariances(estimator='scm', nfilter=nfilter) covs = xdwn.fit(data['train_x'], data['train_y']).transform(data['test_x']) lapl = Embedding(metric='riemann', n_components=3) embd = lapl.fit_transform(covs) else: tangent_space = Pipeline([ ('cov_transform', Covariances(estimator='lwf')), ('tangent_space', TangentSpace(metric='riemann')) ]) t_space = tangent_space.fit(data['train_x'], data['train_y']).transform(data['test_x']) reducer = umap.UMAP(n_neighbors=30, min_dist=1, spread=2) embd = reducer.fit_transform(t_space) return embd
def svm_tangent_space_cross_validate(data): """A cross validated tangent space classifier with svm. Parameters ---------- data : dict A dictionary containing training and testing data Returns ------- cross validated scores A list of cross validated scores. """ # Combine the dataset x = np.concatenate((data['train_x'], data['test_x']), axis=0) y = np.concatenate((data['train_y'], data['test_y']), axis=0) # Construct sklearn pipeline clf = Pipeline([('cov_transform', Covariances(estimator='lwf')), ('tangent_space', TangentSpace(metric='riemann')), ('svm_classify', SVC(kernel='rbf', gamma='auto'))]) # cross validation scores = cross_val_score(clf, x, y, cv=KFold(5, shuffle=True)) print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2)) print('\n') return scores
def get_trajectory(subject): print 'subject ' + str(subject) print '' data_params = {} data_params[ 'path'] = '/research/vibs/Pedro/datasets/motorimagery/Physionet/eegmmidb/' data_params['session'] = 1 data_params['task'] = 4 data_params['fparams'] = [8.0, 35.0] data_params['subject'] = subject data_params['tparams'] = [-13.8, +13.] X, y = get_data(data_params) L = 160 nt, nc, ns = X.shape covm = [] for w in tqdm(gen_windows(L, ns, step=20)): xw = X[:, :, w] covs = Covariances().fit_transform(xw) covm.append(mean_riemann(covs)) print 'getting the diffusion embedding' covm = np.stack(covm) u, l = get_diffusionEmbedding(covm, distance_riemann, alpha=1.0, tdiff=0) filepath = './results/Physionet/' filepath = filepath + 'trajectory_subject' + str(subject) + '.pkl' embedding = [u, l] joblib.dump(embedding, filepath) print ''
def test_tsclassifier_clf_error(get_covmats, get_labels): """Test TS if not Classifier""" n_matrices, n_channels, n_classes = 6, 3, 2 covmats = get_covmats(n_matrices, n_channels) labels = get_labels(n_matrices, n_classes) with pytest.raises(TypeError): TSclassifier(clf=Covariances()).fit(covmats, labels)
def estimate_covariance_matrices(raw_dataset): """ Creates the simple covariance matrices for the raw data """ covariance_matrices = [] for subject in raw_dataset: covariance_matrices.append(Covariances("oas").transform(subject)) return np.asarray(covariance_matrices)
def plot_covs(XX, category, normalize=False, train_size=0.7, estimator='scm'): if normalize: XX = (XX - XX.mean(2)[:, :, None]) / XX.std(2)[:, :, None] n_trials = XX.shape[0] # covs = np.array([np.cov(XX[i]) for i in range(n_trials)]) covs = Covariances(estimator=estimator).fit_transform(XX) vmin = None vmax = None if normalize: vmin = 0.0 vmax = 1.0 title = "Mean Covariance - Category %s" % category covs_mean = covs.mean(0) plot_cov(covs_mean, title, vmin, vmax) return covs
def test_covariances(): """Test fit Covariances""" x = np.random.randn(2, 3, 100) cov = Covariances() cov.fit(x) cov.fit_transform(x) assert_equal(cov.get_params(), dict(estimator='scm'))
def RHvsLH_cross(out_dir, pipelines): name = 'RHvsLH_cross' datasets = utils.dataset_search('imagery', events=['right_hand', 'left_hand'], has_all_events=True, min_subjects=2, multi_session=False) print(datasets) pipelines = OrderedDict() pipelines['TS'] = make_pipeline(Covariances('oas'), TSclassifier()) pipelines['CSP+LDA'] = make_pipeline(Covariances('oas'), CSP(6), LDA()) pipelines['CSP+SVM'] = make_pipeline(Covariances('oas'), CSP(6), SVC()) # context = LeftRightImagery(pipelines, CrossSubjectEvaluation(n_jobs=10), datasets) results = context.process()
def test_shrinkage(shrinkage, rndstate): """Test Shrinkage""" n_matrices, n_channels, n_times = 2, 3, 100 x = rndstate.randn(n_matrices, n_channels, n_times) covmats = Covariances().fit_transform(x) sh = Shrinkage(shrinkage=shrinkage) covmats = sh.fit(covmats).transform(covmats) assert sh.get_params() == dict(shrinkage=shrinkage) assert covmats.shape == (n_matrices, n_channels, n_channels) assert is_spd(covmats)
def create_mdm(raw, event_id): tmin, tmax = -1., 4. 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 = epochs.get_data()[:, :-1] cov_data_train = Covariances().transform(epochs_data_train) mdm = MDM(metric=dict(mean='riemann', distance='riemann')) mdm.fit(cov_data_train, labels) return mdm
def find_reference(raw, n_cluster, pick_types=None, copy=True, flat_threshold=1e-15, n_split=100, plot=True): """ Computes covariance on splits of the raw data, and apply KMeans clustering to find the number of disjoint references. n_cluster is found with PCA if float """ import matplotlib.pyplot as plt from pyriemann.estimation import Covariances from sklearn.cluster import KMeans from sklearn.metrics.pairwise import pairwise_distances if copy: raw = raw.copy() # Remove flat lines flat = np.where(np.std(raw._data, axis=1) < flat_threshold)[0] for ch in flat: raw.info['bads'] += [raw.ch_names[ch]] # Pick data channels only if pick_types is None: pick_types = dict(seeg=True, exclude='bads') raw.pick_types(**pick_types) # Compute covariance on data splits n_time = len(raw.times) t_max = raw.times[n_time - n_time % n_split - 1] raw.crop(0, t_max, copy=False) # ensure regularly sized splits X = np.array(np.array_split(raw._data, n_split, axis=1)) covs = Covariances().fit_transform(X) # Compute cluster for each data split cluster = KMeans(n_cluster) all_kmeans = list() for cov in covs: dist = pairwise_distances(cov) all_kmeans.append(cluster.fit_predict(dist)) # Combine clusters dist = pairwise_distances(np.array(all_kmeans).T) idx = cluster.fit_predict(dist) if plot: idx_ = np.argsort(idx) cov = np.median(covs, axis=0) plt.matshow(np.log10(cov)[idx_, :][:, idx_]) clusters = [np.array(raw.ch_names)[idx == ii] for ii in np.unique(idx)] return clusters
def tangent_space_classifier(features, labels, classifier): """A tangent space classifier with svm for 3 classes. Parameters ---------- features : array A array of features labels : array True labels classifier : string option : Support Vector Machines (svc) or Random Forest (rf) Returns ------- sklearn classifier Learnt classifier. """ # Construct sklearn pipeline if classifier == 'svc': clf = Pipeline([('covariance_transform', Covariances(estimator='scm')), ('tangent_space', TangentSpace(metric='riemann')), ('classifier', SVC(kernel='rbf', gamma='auto', decision_function_shape='ovr'))]) elif classifier == 'rf': clf = Pipeline([('covariance_transform', Covariances(estimator='scm')), ('tangent_space', TangentSpace(metric='riemann')), ('classifier', RandomForestClassifier(n_estimators=100, oob_score=True))]) else: print("Please select the appropriate classifier ") return # cross validation clf.fit(features, labels) return clf
def subject_independent_cov_data(config): """Get subject independent covariance data (pooled data). Parameters ---------- config : yaml The configuration file Returns ------- features, labels, leave_leave_tags 2 arrays features and labels. A tag determines whether the data point is used in training. """ path = str(Path(__file__).parents[2] / config['clean_emg_data']) data = dd.io.load(path) # Parameters subjects = config['subjects'] # Empty array (list) x = [] y = [] leave_tags = np.empty((0, 1)) for subject in subjects: cov_temp = Covariances().transform(data['subject_' + subject]['features']) x_temp = TangentSpace(metric='riemann').transform(cov_temp) y_temp = data['subject_' + subject]['labels'] x.append(x_temp) y.append(y_temp) leave_tags = np.concatenate((leave_tags, y_temp[:, 0:1] * 0 + 1), axis=0) # Convert to array x = np.concatenate(x, axis=0) y = np.concatenate(y, axis=0) # Balance the dataset rus = RandomUnderSampler() rus.fit_resample(y, y) # Store them in dictionary features = x[rus.sample_indices_, :] labels = y[rus.sample_indices_, :] leave_tags = leave_tags[rus.sample_indices_, :] return features, labels, leave_tags
def get_results(clf, source_dataset, source_subject, target_dataset, target_subject, ncovs_target_train_list): scores_target = {} print('target subject:', target_subject, ', source subject:', source_subject) # get the data from source dataset dataset_source, dataset_target, idx = utilities.get_source_target_dataset( source_dataset, source_subject, target_dataset, target_subject) # estimate the covariances source = {} source['org'] = {} source['org']['covs'] = Covariances(estimator='lwf').fit_transform( dataset_source['epochs']) source['org']['labels'] = dataset_source['labels'] target = {} target['org'] = {} target['org']['covs'] = Covariances(estimator='lwf').fit_transform( dataset_target['epochs']) target['org']['labels'] = dataset_target['labels'] # match the dimensions (reorder and expand) source['org-aug'], target[ 'org-aug'] = utilities.match_source_target_dimensions_motorimagery( source['org'], target['org'], idx) # get the scores scores_target[source_subject] = {} for ncovs_target_train in ncovs_target_train_list: scores_target[source_subject][ ncovs_target_train] = scores_transfer_learning_cross_validation( clf, source, target, ncovs_target_train, nrzt=5) return scores_target
def test_covariances(estimator, rndstate): """Test Covariances""" n_matrices, n_channels, n_times = 2, 3, 100 x = rndstate.randn(n_matrices, n_channels, n_times) cov = Covariances(estimator=estimator) cov.fit(x) covmats = cov.fit_transform(x) assert cov.get_params() == dict(estimator=estimator) assert covmats.shape == (n_matrices, n_channels, n_channels) assert is_spd(covmats)
def forest_tangent_space_cross_validate(data, cv=False): """A cross validated tangent space classifier with svm. Parameters ---------- data : dict A dictionary containing training and testing data Returns ------- cross validated scores A list of cross validated scores. """ # Construct sklearn pipeline clf = Pipeline([('cov_transform', Covariances('lwf')), ('tangent_space', TangentSpace(metric='riemann')), ('random_forest_classify', RandomForestClassifier(n_estimators=20, max_depth=10, random_state=43))]) if cv: # Combine the dataset x = np.concatenate((data['train_x'], data['test_x']), axis=0) y = np.concatenate((data['train_y'], data['test_y']), axis=0) # cross validation scores = cross_val_score(clf, x, y, cv=KFold(5, shuffle=True)) print("Accuracy: %0.4f (+/- %0.4f)" % (scores.mean(), scores.std() * 2)) print('\n') else: clf = RandomForestClassifier(n_estimators=20, max_depth=10, random_state=43) plt.style.use('clean') y_train = np.argmax(data['train_y'], axis=1) + 1 y_test = np.argmax(data['test_y'], axis=1) + 1 classifier = clf.fit(data['train_x'], y_train) plot_confusion_matrix(classifier, data['test_x'], y_test, normalize='true', cmap=plt.cm.Blues) return None
def get_score(subject, event): if event == "left_vs_right": runs = [4, 8, 12] event_id = dict(rest=1, left=2, right=3) else: runs = [6, 10, 14] event_id = dict(rest=1, hands=2, feet=3) raw = get_raw(subject, runs=runs) data = raw.get_data() mdm = create_mdm(raw, event_id) w_length = 160 # 学習epochのlength w_step = 80 current_step = 0 count = 0 score = 0 print("start") for i in range(len(data[0])): current_step += 1 if i > w_length and current_step > w_step: window = np.array([data[0:16, i:i+w_length]]) X_test = Covariances().transform(window) # print(X_test.shape) label = mdm.predict(X_test) current_step = 0 count += 1 window_labels = np.array(data[16][i:i+w_length], dtype=np.int64) label_count = np.bincount(window_labels) argmax_label = np.argmax(label_count) print(i, label, argmax_label) if label == argmax_label: score += 1 # sleep(1./160) print(subject, score/count) print("end") return score/count
def get_embedding(): path = '/localdata/coelhorp/epilepsy/seizure_detection/' subjects = ['Dog_3', 'Dog_4', 'Patient_2', 'Patient_6', 'Patient_7'] for subject in subjects: print 'processing subject: ' + subject filepaths = sorted(glob.glob(path + subject + '/*_ictal_*')) X = [] lat = [] for filepath in filepaths: struct = sp.io.loadmat(filepath) X.append(struct['data']) lat.append(struct['latency'][0]) lat = np.array(lat) X = np.stack(X) fs = struct['freq'] fini = 1.0 fend = 40.0 b, a = signal.butter(5, [fini / (fs / 2), fend / (fs / 2)], btype='bandpass') for xt in X: f, pxx = welch(xt, fs=fs) xt = signal.filtfilt(b, a, xt) covs = Covariances(estimator='oas').fit_transform(X) print 'getting the diffusion embedding' u, l = get_diffusionEmbedding(points=covs, distance=distance_riemann) directory = './results/Epilepsy/' if not os.path.exists(directory): os.makedirs(directory) filepath = directory + 'embedding_subject-' + str(subject) + '.pkl' embedding = [u, l] joblib.dump([embedding, lat], filepath) print ''
def aggregate_cov(X, n_subjects, metadata, filterbank=True, s_class='rest', estimator='lwf'): """Compute covmat for concatenated signals""" subjX = np.array(metadata['subject']) cov_list = [] for s in range(n_subjects): s_loc = subjX == (s + 1) X_sig = np.array(X[np.logical_and(s_loc, y == s_class)]) if filterbank: sig_ext = X_sig[:, :, :, :-1].transpose((0, 3, 1, 2)) n_trials, n_freqs, n_channels, n_times = sig_ext.shape X_sig = sig_ext.reshape((n_trials, n_channels * n_freqs, n_times)) X_sig = np.concatenate([X_sig[i, :, :] for i in range(X_sig.shape[0])], axis=1) cov = Covariances(estimator='lwf').transform( X_sig.reshape((1, *(X_sig.shape)))) cov_list.append(cov) return np.concatenate(cov_list, axis=0)
def get_twoclasses(subject): print 'subject ' + str(subject) print '' data_params = {} data_params[ 'path'] = '/research/vibs/Pedro/datasets/motorimagery/Physionet/eegmmidb/' data_params['session'] = 1 data_params['task'] = 4 data_params['tparams'] = [1.0, 2.0] data_params['fparams'] = [8.0, 35.0] data_params['subject'] = subject X, y = get_data(data_params) covs = Covariances().fit_transform(X) u, l = get_diffusionEmbedding(points=covs, distance=distance_riemann) filepath = './results/Physionet/' filepath = filepath + 'twoclasses_subject' + str(subject) + '.pkl' embedding = [u, l] joblib.dump([embedding, y], filepath)
def get_twoclasses(subject): print 'subject ' + str(subject) print '' data_params = {} data_params['path'] = '/research/vibs/Pedro/datasets/motorimagery/BCI-competitions/BCI-IV/2a/' data_params['session'] = 1 data_params['task'] = 1 data_params['tparams'] = [1.25, 3.75] data_params['fparams'] = [8.0, 35.0] data_params['subject'] = subject X,y = get_data(data_params) X = X[(y == 1) | (y == 2)] y = y[(y == 1) | (y == 2)] covs = Covariances().fit_transform(X) u,l = get_diffusionEmbedding(points=covs, distance=distance_riemann) filepath = './results/BCI-IV/' filepath = filepath + 'twoclasses_subject' + str(subject) + '.pkl' embedding = [u,l] joblib.dump([embedding, y], filepath)
def get_score(subject=7, runs=[6, 10, 14], event_id=dict(hands=2, feet=3)): tmin, tmax = -1., 4. raw = 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] # cv = KFold(len(labels), 10, shuffle=True, random_state=42) epochs_data_train = epochs.get_data()[:, :-1] cov_data_train = Covariances().transform(epochs_data_train) ############################################################################### # Classification with Minimum distance to mean mdm = MDM(metric=dict(mean='riemann', distance='riemann')) pl = Pipeline([("mdm", mdm)]) params = {"mdm__metric": [dict(mean='riemann', distance='riemann')]} clf = GridSearchCV(pl, params, n_jobs=-1, cv=5, return_train_score=True) clf.fit(cov_data_train, labels) df = pd.DataFrame(clf.cv_results_) return df
def svm_tangent_space_classifier(features, labels): """A tangent space classifier with svm for 3 classes. Parameters ---------- features : array A array of features labels : array True labels Returns ------- sklearn classifier Learnt classifier. """ # Construct sklearn pipeline clf = Pipeline([('cov_transform', Covariances('oas')), ('tangent_space', TangentSpace(metric='riemann')), ('svm_classify', SVC(kernel='rbf', gamma='auto'))]) # cross validation clf.fit(features, labels) return clf
raw.filter(7., 35., method='iir', picks=picks) epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=None, preload=True, add_eeg_ref=False, verbose=False) labels = epochs.events[:, -1] - 2 # get epochs epochs_data = epochs.get_data() ############################################################################### # Pairwise distance based permutation test ############################################################################### covest = Covariances() Fs = 160 window = 2*Fs Nwindow = 20 Ns = epochs_data.shape[2] step = int((Ns-window)/Nwindow) time_bins = range(0, Ns-window, step) pv = [] Fv = [] # For each frequency bin, estimate the stats t_init = time() for t in time_bins: covmats = covest.fit_transform(epochs_data[:, ::1, t:(t+window)]) p_test = PermutationDistance(1000, metric='riemann', mode='pairwise')
def test_covariances(): """Test fit Covariances""" x = np.random.randn(2,3,100) cov = Covariances() cov.fit(x) cov.fit_transform(x)