def train_classifiers(self): n_folds = len(self.binary_csp.folds) n_class_pairs = len(self.binary_csp.class_pairs) self.clf = np.empty((n_folds, n_class_pairs), dtype=object) for fold_i in range(n_folds): for class_i in range(n_class_pairs): train_feature = self.train_feature[fold_i, class_i] clf = lda_train_scaled(train_feature, shrink=True) self.clf[fold_i, class_i] = clf
def train_classifiers(self): n_folds = len(self.binary_csp.folds) n_class_pairs = len(self.binary_csp.class_pairs) self.clf = np.empty((n_folds, n_class_pairs), dtype=object) for fold_i in range(n_folds): for class_i in range(n_class_pairs): train_feature = self.train_feature[fold_i, class_i] clf = lda_train_scaled(train_feature, shrink=True) self.clf[fold_i, class_i] = clf
def test_lda_train_scaled(): ## these values were checked with matlab # matlab had almost same values (<0.01 differences on weights, # < 0.1 on bias) featurevector = lambda: None featurevector.data = np.array([[8.2, 3.5, 5.6], [9.1, 1.2, 2.4], [8.8, 3.5, 5.6], [7.1, 1.5, 2.9]]) featurevector.axes = [[1, 0, 1, 0], []] w, b = lda_train_scaled(featurevector, shrink=True) assert np.allclose([0.13243638, 0.31727594, 0.42877362], w) assert np.allclose(-3.6373072863307785, b)
def test_lda_train_scaled(): ## these values were checked with matlab # matlab had almost same values (<0.01 differences on weights, # < 0.1 on bias) featurevector = lambda: None featurevector.data = np.array([[8.2, 3.5, 5.6], [9.1, 1.2, 2.4], [8.8, 3.5, 5.6], [7.1, 1.5, 2.9]]) featurevector.axes = [[1,0,1,0], []] w,b = lda_train_scaled(featurevector, shrink=True) assert np.allclose([ 0.13243638, 0.31727594, 0.42877362], w) assert np.allclose(-3.6373072863307785, b)
def cross_validate_lda(features): folds = KFold(features.data.shape[0], n_folds=5, shuffle=False) test_accuracies = [] for train_inds, test_inds in folds: train_features = features.copy(data=features.data[train_inds], axes=[features.axes[0][train_inds]]) test_features = features.copy(data=features.data[test_inds], axes=[features.axes[0][test_inds]]) clf = lda_train_scaled(train_features, shrink=True) test_out = lda_apply(test_features, clf) second_class_test = test_features.axes[0] == np.max(test_features.axes[0]) predicted_2nd_class_test = test_out >= 0 test_accuracy = sum(second_class_test == predicted_2nd_class_test) / float(len(predicted_2nd_class_test)) test_accuracies.append(test_accuracy) return np.mean(test_accuracies)
def cross_validate_lda(features): folds = KFold(features.data.shape[0], n_folds=5, shuffle=False) test_accuracies = [] for train_inds, test_inds in folds: train_features = features.copy(data=features.data[train_inds], axes=[features.axes[0][train_inds]]) test_features = features.copy(data=features.data[test_inds], axes=[features.axes[0][test_inds]]) clf = lda_train_scaled(train_features, shrink=True) test_out = lda_apply(test_features, clf) second_class_test = test_features.axes[0] == np.max( test_features.axes[0]) predicted_2nd_class_test = test_out >= 0 test_accuracy = ( sum(second_class_test == predicted_2nd_class_test) / float(len(predicted_2nd_class_test))) test_accuracies.append(test_accuracy) return np.mean(test_accuracies)
def run_pair(self, epo_train, epo_test, bp_nr, fold_nr, pair_nr): class_pair = self.class_pairs[pair_nr] self.print_class_pair(class_pair) ### Run Training epo_train_pair = select_classes(epo_train, class_pair) epo_test_pair = select_classes(epo_test, class_pair) if self.ival_optimizer is not None: best_segment_ival = self.ival_optimizer.optimize(epo_train_pair) log.info("Ival {:.0f}ms - {:.0f}ms".format(*best_segment_ival)) epo_train_pair = select_ival(epo_train_pair, best_segment_ival) epo_test_pair = select_ival(epo_test_pair, best_segment_ival) epo_train = select_ival(epo_train, best_segment_ival) epo_test = select_ival(epo_test, best_segment_ival) self.train_labels[fold_nr][pair_nr] = epo_train_pair.axes[0] self.test_labels[fold_nr][pair_nr] = epo_test_pair.axes[0] ## Calculate CSP filters, patterns, variances = calculate_csp(epo_train_pair) ## Apply csp, calculate features if self.n_filters is not None: # take topmost and bottommost filters, e.g. # for n_filters=3 0,1,2,-3,-2,-1 columns = range(0, self.n_filters) + \ range(-self.n_filters, 0) else: # take all possible filters columns = range(len(filters)) train_feature = apply_csp_var_log(epo_train_pair, filters, columns) ## Calculate LDA clf = lda_train_scaled(train_feature, shrink=True) assert not np.any(np.isnan(clf[0])) assert not np.isnan(clf[1]) ## Apply LDA to train train_out = lda_apply(train_feature, clf) correct_train = train_feature.axes[0] == class_pair[1] predicted_train = train_out >= 0 train_accuracy = (sum(correct_train == predicted_train) / float(len(predicted_train))) ### Feature Computation and LDA Application for test test_feature = apply_csp_var_log(epo_test_pair, filters, columns) test_out = lda_apply(test_feature, clf) correct_test = test_feature.axes[0] == class_pair[1] predicted_test = test_out >= 0 test_accuracy = (sum(correct_test == predicted_test) / float(len(predicted_test))) ### Feature Computations for full fold (for later multiclass) train_feature_full_fold = apply_csp_var_log(epo_train, filters, columns) test_feature_full_fold = apply_csp_var_log(epo_test, filters, columns) ### Store results # only store used patterns filters variances # to save memory space on disk self.store_results(bp_nr, fold_nr, pair_nr, filters[:, columns], patterns[:, columns], variances[columns], train_feature, test_feature, train_feature_full_fold, test_feature_full_fold, clf, train_accuracy, test_accuracy) if self.ival_optimizer is not None: self.best_ival[bp_nr, fold_nr, pair_nr] = best_segment_ival self.print_results(bp_nr, fold_nr, pair_nr)
def run_pair(self, epo_train, epo_test, bp_nr, fold_nr, pair_nr): class_pair = self.class_pairs[pair_nr] self.print_class_pair(class_pair) ### Run Training epo_train_pair = select_classes(epo_train, class_pair) epo_test_pair = select_classes(epo_test, class_pair) if self.ival_optimizer is not None: best_segment_ival = self.ival_optimizer.optimize(epo_train_pair) log.info("Ival {:.0f}ms - {:.0f}ms".format(*best_segment_ival)) epo_train_pair = select_ival(epo_train_pair, best_segment_ival) epo_test_pair = select_ival(epo_test_pair, best_segment_ival) epo_train = select_ival(epo_train, best_segment_ival) epo_test = select_ival(epo_test, best_segment_ival) self.train_labels[fold_nr][pair_nr] = epo_train_pair.axes[0] self.test_labels[fold_nr][pair_nr] = epo_test_pair.axes[0] ## Calculate CSP filters, patterns, variances = calculate_csp(epo_train_pair) ## Apply csp, calculate features if self.n_filters is not None: # take topmost and bottommost filters, e.g. # for n_filters=3 0,1,2,-3,-2,-1 columns = range(0, self.n_filters) + range(-self.n_filters, 0) else: # take all possible filters columns = range(len(filters)) train_feature = apply_csp_var_log(epo_train_pair, filters, columns) ## Calculate LDA clf = lda_train_scaled(train_feature, shrink=True) assert not np.any(np.isnan(clf[0])) assert not np.isnan(clf[1]) ## Apply LDA to train train_out = lda_apply(train_feature, clf) correct_train = train_feature.axes[0] == class_pair[1] predicted_train = train_out >= 0 train_accuracy = sum(correct_train == predicted_train) / float(len(predicted_train)) ### Feature Computation and LDA Application for test test_feature = apply_csp_var_log(epo_test_pair, filters, columns) test_out = lda_apply(test_feature, clf) correct_test = test_feature.axes[0] == class_pair[1] predicted_test = test_out >= 0 test_accuracy = sum(correct_test == predicted_test) / float(len(predicted_test)) ### Feature Computations for full fold (for later multiclass) train_feature_full_fold = apply_csp_var_log(epo_train, filters, columns) test_feature_full_fold = apply_csp_var_log(epo_test, filters, columns) ### Store results # only store used patterns filters variances # to save memory space on disk self.store_results( bp_nr, fold_nr, pair_nr, filters[:, columns], patterns[:, columns], variances[columns], train_feature, test_feature, train_feature_full_fold, test_feature_full_fold, clf, train_accuracy, test_accuracy, ) if self.ival_optimizer is not None: self.best_ival[bp_nr, fold_nr, pair_nr] = best_segment_ival self.print_results(bp_nr, fold_nr, pair_nr)