Python sklearn.metrics.accuracy_score() Examples
The following are 30
code examples of sklearn.metrics.accuracy_score().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
sklearn.metrics
, or try the search function
.

Example #1
Source File: main.py From transferlearning with MIT License | 13 votes |
def classify_1nn(data_train, data_test): ''' Classification using 1NN Inputs: data_train, data_test: train and test csv file path Outputs: yprediction and accuracy ''' from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score from sklearn.preprocessing import StandardScaler data = {'src': np.loadtxt(data_train, delimiter=','), 'tar': np.loadtxt(data_test, delimiter=','), } Xs, Ys, Xt, Yt = data['src'][:, :-1], data['src'][:, - 1], data['tar'][:, :-1], data['tar'][:, -1] Xs = StandardScaler(with_mean=0, with_std=1).fit_transform(Xs) Xt = StandardScaler(with_mean=0, with_std=1).fit_transform(Xt) clf = KNeighborsClassifier(n_neighbors=1) clf.fit(Xs, Ys) ypred = clf.predict(Xt) acc = accuracy_score(y_true=Yt, y_pred=ypred) print('Acc: {:.4f}'.format(acc)) return ypred, acc
Example #2
Source File: multi_class_classification.py From edge2vec with BSD 3-Clause "New" or "Revised" License | 11 votes |
def multi_class_classification(data_X,data_Y): ''' calculate multi-class classification and return related evaluation metrics ''' svc = svm.SVC(C=1, kernel='linear') # X_train, X_test, y_train, y_test = train_test_split( data_X, data_Y, test_size=0.4, random_state=0) clf = svc.fit(data_X, data_Y) #svm # array = svc.coef_ # print array predicted = cross_val_predict(clf, data_X, data_Y, cv=2) print "accuracy",metrics.accuracy_score(data_Y, predicted) print "f1 score macro",metrics.f1_score(data_Y, predicted, average='macro') print "f1 score micro",metrics.f1_score(data_Y, predicted, average='micro') print "precision score",metrics.precision_score(data_Y, predicted, average='macro') print "recall score",metrics.recall_score(data_Y, predicted, average='macro') print "hamming_loss",metrics.hamming_loss(data_Y, predicted) print "classification_report", metrics.classification_report(data_Y, predicted) print "jaccard_similarity_score", metrics.jaccard_similarity_score(data_Y, predicted) # print "log_loss", metrics.log_loss(data_Y, predicted) print "zero_one_loss", metrics.zero_one_loss(data_Y, predicted) # print "AUC&ROC",metrics.roc_auc_score(data_Y, predicted) # print "matthews_corrcoef", metrics.matthews_corrcoef(data_Y, predicted)
Example #3
Source File: link_prediction.py From edge2vec with BSD 3-Clause "New" or "Revised" License | 7 votes |
def evaluation_analysis(true_label,predicted): ''' return all metrics results ''' print "accuracy",metrics.accuracy_score(true_label, predicted) print "f1 score macro",metrics.f1_score(true_label, predicted, average='macro') print "f1 score micro",metrics.f1_score(true_label, predicted, average='micro') print "precision score",metrics.precision_score(true_label, predicted, average='macro') print "recall score",metrics.recall_score(true_label, predicted, average='macro') print "hamming_loss",metrics.hamming_loss(true_label, predicted) print "classification_report", metrics.classification_report(true_label, predicted) print "jaccard_similarity_score", metrics.jaccard_similarity_score(true_label, predicted) print "log_loss", metrics.log_loss(true_label, predicted) print "zero_one_loss", metrics.zero_one_loss(true_label, predicted) print "AUC&ROC",metrics.roc_auc_score(true_label, predicted) print "matthews_corrcoef", metrics.matthews_corrcoef(true_label, predicted)
Example #4
Source File: drop_connect_trainer.py From MNIST-baselines with MIT License | 7 votes |
def test(data, model, optimizer, logger, config): test_batches = (data.DATA_SIZE[1] + config["batch_size"] - 1) // config["batch_size"] for param in model.parameters(): param.requires_grad = False model.eval() prediction = np.zeros(data.DATA_SIZE[1], dtype=np.uint8) for i in range(test_batches): inputs = Variable(torch.from_numpy(data.data_test[i * config["batch_size"]: min((i + 1) * config["batch_size"], data.DATA_SIZE[1]), :]), requires_grad=False).view(-1, 1, 45, 45) if config["cuda"] and torch.cuda.is_available(): inputs = inputs.cuda() outputs = model(inputs) prediction[i * config["batch_size"]: min((i + 1) * config["batch_size"], data.DATA_SIZE[1])] = np.argmax(outputs.data.cpu().numpy(), axis=1) print('Accuracy: %0.2f' % (100 * accuracy_score(data.label_test, prediction))) init_dir(config['output_dir']) np.save(os.path.join(config['output_dir'], '%s_pred.npy' % config['method']), prediction)
Example #5
Source File: accuracy.py From pipeline with MIT License | 7 votes |
def calculate(self): if not self._predictions: raise PipelineError("You need to add predictions for calculating the accuracy first") y_pred = np.concatenate(self._predictions) y_true = np.concatenate(self._true_labels) if y_pred.shape[-1] == 1: # Binary classification y_pred = (y_pred >= self._border).astype("int") else: y_pred = np.argmax(y_pred, -1) if len(y_true.shape) != 1: y_true = np.argmax(y_true, -1) result = accuracy_score(y_true, y_pred) return {"accuracy": result}
Example #6
Source File: utils.py From Attention-Gated-Networks with MIT License | 6 votes |
def classification_scores(gts, preds, labels): accuracy = metrics.accuracy_score(gts, preds) class_accuracies = [] for lab in labels: # TODO Fix class_accuracies.append(metrics.accuracy_score(gts[gts == lab], preds[gts == lab])) class_accuracies = np.array(class_accuracies) f1_micro = metrics.f1_score(gts, preds, average='micro') precision_micro = metrics.precision_score(gts, preds, average='micro') recall_micro = metrics.recall_score(gts, preds, average='micro') f1_macro = metrics.f1_score(gts, preds, average='macro') precision_macro = metrics.precision_score(gts, preds, average='macro') recall_macro = metrics.recall_score(gts, preds, average='macro') # class wise score f1s = metrics.f1_score(gts, preds, average=None) precisions = metrics.precision_score(gts, preds, average=None) recalls = metrics.recall_score(gts, preds, average=None) confusion = metrics.confusion_matrix(gts,preds, labels=labels) #TODO confusion matrix, recall, precision return accuracy, f1_micro, precision_micro, recall_micro, f1_macro, precision_macro, recall_macro, confusion, class_accuracies, f1s, precisions, recalls
Example #7
Source File: label_accuracy.py From linguistic-style-transfer with Apache License 2.0 | 6 votes |
def get_label_accuracy(predictions_file_path, gold_labels_file_path, saved_model_path): with open(os.path.join(saved_model_path, global_config.label_to_index_dict_file), 'r') as json_file: label_to_index_map = json.load(json_file) gold_labels = list() prediction_labels = list() with open(gold_labels_file_path) as gold_labels_file: for text_label in gold_labels_file: gold_labels.append(label_to_index_map[text_label.strip()]) with open(predictions_file_path) as predictions_file: for label in predictions_file: prediction_labels.append(int(label.strip())) accuracy = metrics.accuracy_score(y_true=gold_labels, y_pred=prediction_labels) logger.info("Classification Accuracy: {}".format(accuracy))
Example #8
Source File: toxcast_maml.py From deepchem with MIT License | 6 votes |
def compute_scores(optimize): maml.restore() y_true = [] y_pred = [] losses = [] for task in range(learner.n_training_tasks, n_tasks): learner.set_task_index(task) if optimize: maml.train_on_current_task(restore=True) inputs = learner.get_batch() loss, prediction = maml.predict_on_batch(inputs) y_true.append(inputs[1]) y_pred.append(prediction[0][:, 0]) losses.append(loss) y_true = np.concatenate(y_true) y_pred = np.concatenate(y_pred) print() print('Cross entropy loss:', np.mean(losses)) print('Prediction accuracy:', accuracy_score(y_true, y_pred > 0.5)) print('ROC AUC:', dc.metrics.roc_auc_score(y_true, y_pred)) print()
Example #9
Source File: score_dataset.py From snape with Apache License 2.0 | 6 votes |
def score_multiclass_classification(y, y_hat, report=True): """ Create multiclass classification score :param y: :param y_hat: :return: """ report_string = "---Multiclass Classification Score--- \n" report_string += classification_report(y, y_hat) score = accuracy_score(y, y_hat) report_string += "\nAccuracy = " + str(score) if report: print(report_string) return score, report_string
Example #10
Source File: capsnet_trainer.py From MNIST-baselines with MIT License | 6 votes |
def test(data, model, optimizer, logger, config): test_batches = (data.DATA_SIZE[1] + config["batch_size"] - 1) // config["batch_size"] for param in model.parameters(): param.requires_grad = False model.eval() prediction = np.zeros(data.DATA_SIZE[1], dtype=np.uint8) for i in range(test_batches): inputs = Variable(torch.from_numpy(data.data_test[i * config["batch_size"]: min((i + 1) * config["batch_size"], data.DATA_SIZE[1]), :]), requires_grad=False).view(-1, 1, 45, 45) if config["cuda"] and torch.cuda.is_available(): inputs = inputs.cuda() outputs, probs = model(inputs) prediction[i * config["batch_size"]: min((i + 1) * config["batch_size"], data.DATA_SIZE[1])] = np.argmax(probs.data.cpu().numpy(), axis=1) print('Accuracy: %0.2f' % (100 * accuracy_score(data.label_test, prediction))) init_dir(config['output_dir']) np.save(os.path.join(config['output_dir'], '%s_pred.npy' % config['method']), prediction)
Example #11
Source File: dnn_trainer.py From MNIST-baselines with MIT License | 6 votes |
def test(data, model, optimizer, logger, config): test_batches = (data.DATA_SIZE[1] + config["batch_size"] - 1) // config["batch_size"] for param in model.parameters(): param.requires_grad = False model.eval() prediction = np.zeros(data.DATA_SIZE[1], dtype=np.uint8) for i in range(test_batches): inputs = Variable(torch.from_numpy(data.data_test[i * config["batch_size"]: min((i + 1) * config["batch_size"], data.DATA_SIZE[1]), :]), requires_grad=False).view(-1, 1, 45, 45) if config["cuda"] and torch.cuda.is_available(): inputs = inputs.cuda() outputs = model(inputs) prediction[i * config["batch_size"]: min((i + 1) * config["batch_size"], data.DATA_SIZE[1])] = np.argmax(outputs.data.cpu().numpy(), axis=1) print('Accuracy: %0.2f' % (100 * accuracy_score(data.label_test, prediction))) init_dir(config['output_dir']) np.save(os.path.join(config['output_dir'], '%s_pred.npy' % config['method']), prediction)
Example #12
Source File: run.py From fever-naacl-2018 with Apache License 2.0 | 6 votes |
def print_evaluation(model,data,ls,log=None): features,actual = data predictions = predict(model, features, 500).data.numpy().reshape(-1).tolist() labels = [ls.idx[i] for i, _ in enumerate(ls.idx)] actual = [labels[i] for i in actual] predictions = [labels[i] for i in predictions] print(accuracy_score(actual, predictions)) print(classification_report(actual, predictions)) print(confusion_matrix(actual, predictions)) data = zip(actual,predictions) if log is not None: f = open(log, "w+") for a,p in data: f.write(json.dumps({"actual": a, "predicted": p}) + "\n") f.close()
Example #13
Source File: pcnn_model.py From PCNN with Apache License 2.0 | 6 votes |
def run_evaluate(self, test): """Evaluates performance on test set Args: test: dataset that yields tuple of (sentences, relation tags) Returns: metrics: (dict) metrics["acc"] = 98.4, ... """ y_true, y_pred = [], [] for data in minibatches(test, self.config.batch_size): word_batch, pos1_batch, pos2_batch, pos_batch, y_batch = data relations_pred = self.predict_batch(word_batch, pos1_batch, pos2_batch, pos_batch) assert len(relations_pred) == len(y_batch) y_true += y_batch y_pred += relations_pred.tolist() acc = accuracy_score(y_true, y_pred) p = precision_score(y_true, y_pred, average='macro') r = recall_score(y_true, y_pred, average='macro') f1 = f1_score(y_true, y_pred, average='macro') return {"acc":acc, "p":p, "r":r, "f1":f1}
Example #14
Source File: textpro.py From comparable-text-miner with Apache License 2.0 | 6 votes |
def evaluate(trueValues, predicted, decimals, note): print note label = 1 avg = 'weighted' a = accuracy_score(trueValues, predicted) p = precision_score(trueValues, predicted, pos_label=label, average=avg) r = recall_score(trueValues, predicted, pos_label=label, average=avg) avg_f1 = f1_score(trueValues, predicted, pos_label=label, average=avg) fclasses = f1_score(trueValues, predicted, average=None) f1c1 = fclasses[0]; f1c2 = fclasses[1] fw = (f1c1 + f1c2)/2.0 print 'accuracy:\t', str(round(a,decimals)) print 'precision:\t', str(round(p,decimals)) print 'recall:\t', str(round(r,decimals)) print 'avg f1:\t', str(round(avg_f1,decimals)) print 'c1 f1:\t', str(round(f1c1,decimals)) print 'c2 f1:\t', str(round(f1c2,decimals)) print 'avg(c1,c2):\t', str(round(fw,decimals)) print '------------' ################################################################################### # split a parallel or comparable corpus into two parts
Example #15
Source File: train_eval.py From Bert-Chinese-Text-Classification-Pytorch with MIT License | 6 votes |
def evaluate(config, model, data_iter, test=False): model.eval() loss_total = 0 predict_all = np.array([], dtype=int) labels_all = np.array([], dtype=int) with torch.no_grad(): for texts, labels in data_iter: outputs = model(texts) loss = F.cross_entropy(outputs, labels) loss_total += loss labels = labels.data.cpu().numpy() predic = torch.max(outputs.data, 1)[1].cpu().numpy() labels_all = np.append(labels_all, labels) predict_all = np.append(predict_all, predic) acc = metrics.accuracy_score(labels_all, predict_all) if test: report = metrics.classification_report(labels_all, predict_all, target_names=config.class_list, digits=4) confusion = metrics.confusion_matrix(labels_all, predict_all) return acc, loss_total / len(data_iter), report, confusion return acc, loss_total / len(data_iter)
Example #16
Source File: utils.py From Text-Classification-Models-Pytorch with MIT License | 6 votes |
def evaluate_model(model, iterator): all_preds = [] all_y = [] for idx,batch in enumerate(iterator): if torch.cuda.is_available(): batch = [Variable(record).cuda() for record in batch] else: batch = [Variable(record).cuda() for record in batch] x, y = batch y_pred = model(x) predicted = torch.max(y_pred.cpu().data, 1)[1] all_preds.extend(predicted.numpy()) all_y.extend(y.cpu().numpy()) score = accuracy_score(all_y, np.array(all_preds).flatten()) return score
Example #17
Source File: estimator_utils.py From EDeN with MIT License | 5 votes |
def perf(y_true, y_pred, y_score): """perf.""" print('Accuracy: %.2f' % accuracy_score(y_true, y_pred)) print(' AUC ROC: %.2f' % roc_auc_score(y_true, y_score)) print(' AUC AP: %.2f' % average_precision_score(y_true, y_score)) print() print('Classification Report:') print(classification_report(y_true, y_pred)) print() plot_confusion_matrices(y_true, y_pred, size=int(len(set(y_true)) * 2.5)) print() plot_aucs(y_true, y_score, size=10)
Example #18
Source File: digit_deep_feature.py From transferlearning with MIT License | 5 votes |
def classify_1nn(): from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score from sklearn.preprocessing import StandardScaler data = {'src': np.loadtxt(args.source + '_' + args.source + '.csv', delimiter=','), 'tar': np.loadtxt(args.source + '_' + args.target + '.csv', delimiter=','), } Xs, Ys, Xt, Yt = data['src'][:, :-1], data['src'][:, -1], data['tar'][:, :-1], data['tar'][:, -1] Xs = StandardScaler(with_mean=0, with_std=1).fit_transform(Xs) Xt = StandardScaler(with_mean=0, with_std=1).fit_transform(Xt) clf = KNeighborsClassifier(n_neighbors=1) clf.fit(Xs, Ys) ypred = clf.predict(Xt) acc = accuracy_score(y_true=Yt, y_pred=ypred) print('{} - {}: acc: {:.4f}'.format(args.source, args.target, acc))
Example #19
Source File: SFA.py From transferlearning with MIT License | 5 votes |
def fit_predict(self, Xs, Xt, X_test, Ys, Y_test): ut = self.fit(Xs, Xt) Xs = self.transform(Xs) self.base_classifer.fit(Xs, Ys) X_test = self.transform(X_test) y_pred = self.base_classifer.predict(X_test) acc = accuracy_score(Y_test, y_pred) return acc
Example #20
Source File: SCL.py From transferlearning with MIT License | 5 votes |
def fit_predict(self, Xs, Xt, X_test, Ys, Y_test): self.fit(Xs, Xt) Xs = self.transform(Xs) self.base_classifer.fit(Xs, Ys) X_test = self.transform(X_test) y_pred = self.base_classifer.predict(X_test) acc = accuracy_score(Y_test, y_pred) return acc
Example #21
Source File: validation.py From steppy-toolkit with MIT License | 5 votes |
def torch_acc_score(output, target): output = output.data.cpu().numpy() y_true = target.numpy() y_pred = output.argmax(axis=1) return accuracy_score(y_true, y_pred)
Example #22
Source File: base_intent_model.py From TaskBot with GNU General Public License v3.0 | 5 votes |
def __init__(self, param: dict, opt=torch.optim.Adam, metric=accuracy_score, loss=F.cross_entropy, save_path="default"): super().__init__() self.param = param self.opt = None self.loss = loss self.metric = metric self.start_epoch = 0 if save_path == "default": self.save_path = MODEL_PATH / "intent" else: self.save_path = save_path
Example #23
Source File: audio_inference_demo.py From Tensorflow-Audio-Classification with Apache License 2.0 | 5 votes |
def inference_wav(wav_file): """Test audio model on a wav file.""" label = util.urban_labels([wav_file])[0] graph = tf.Graph() with tf.Session(graph=graph, config=SESS_CONFIG) as sess: with VGGishExtractor(VGGISH_CKPT, VGGISH_PCA, audio_params.VGGISH_INPUT_TENSOR_NAME, audio_params.VGGISH_OUTPUT_TENSOR_NAME) as ve: vggish_features = ve.wavfile_to_features(wav_file) assert vggish_features is not None labels = [label] * vggish_features.shape[0] # restore graph # _restore_from_meta_and_ckpt(sess, META, CKPT) _restore_from_defined_and_ckpt(sess, CKPT) # get input and output tensor # graph = tf.get_default_graph() inputs = graph.get_tensor_by_name(audio_params.AUDIO_INPUT_TENSOR_NAME) outputs = graph.get_tensor_by_name(audio_params.AUDIO_OUTPUT_TENSOR_NAME) predictions = sess.run(outputs, feed_dict={inputs: vggish_features}) idxes = np.argmax(predictions, 1) probs = np.max(predictions, 1) print(predictions) print(idxes) print(labels) print(probs) acc = accuracy_score(labels, idxes) print('acc:', acc)
Example #24
Source File: audio_inference_demo.py From Tensorflow-Audio-Classification with Apache License 2.0 | 5 votes |
def inference_on_test(): """Test audio model on test dataset.""" graph = tf.Graph() with tf.Session(graph=graph, config=SESS_CONFIG) as sess: rp = RecordsParser([audio_params.TF_RECORDS_TEST], audio_params.NUM_CLASSES, feature_shape=None) test_iterator, test_batch = rp.iterator(is_onehot=True, batch_size=1) # restore graph: 2 ways to restore, both will working # _restore_from_meta_and_ckpt(sess, META, CKPT) _restore_from_defined_and_ckpt(sess, CKPT) # get input and output tensor # graph = tf.get_default_graph() inputs = graph.get_tensor_by_name(audio_params.AUDIO_INPUT_TENSOR_NAME) outputs = graph.get_tensor_by_name(audio_params.AUDIO_OUTPUT_TENSOR_NAME) sess.run(test_iterator.initializer) predicted = [] groundtruth = [] while True: try: # feature: [batch_size, num_features] # label: [batch_size, num_classes] te_features, te_labels = sess.run(test_batch) except tf.errors.OutOfRangeError: break predictions = sess.run(outputs, feed_dict={inputs: te_features}) predicted.extend(np.argmax(predictions, 1)) groundtruth.extend(np.argmax(te_labels, 1)) # print(te_features.shape, te_labels, te_labels.shape) right = accuracy_score(groundtruth, predicted, normalize=False) # True: return prob print('all: {}, right: {}, wrong: {}, acc: {}'.format( len(predicted), right, len(predicted) - right, right/(len(predicted))))
Example #25
Source File: model.py From fake-news-detection with MIT License | 5 votes |
def accuracy_at_threshold(self, y_true, y_scores, threshold): ''' Dyanamic threshold accuracy. ''' y_pred = np.asarray([1 if i >= threshold else 0 for i in y_scores]) return metrics.accuracy_score(y_true, y_pred)
Example #26
Source File: model.py From fake-news-detection with MIT License | 5 votes |
def accuracy_at_k(self, y_true, y_scores, k): ''' Dynamic k accuracy, where 0<k<1. ''' y_pred = self.k_predictions(y_scores, k) return metrics.accuracy_score(y_true, y_pred)
Example #27
Source File: custom_metrics.py From sagemaker-xgboost-container with Apache License 2.0 | 5 votes |
def accuracy(preds, dtrain): """Compute accuracy. :param preds: Prediction values :param dtrain: Training data with labels :return: Metric name, accuracy value. """ labels = dtrain.get_label() rounded_preds = [np.argmax(value) if (type(value) is np.ndarray) else round(value) for value in preds] return 'accuracy', accuracy_score(labels, rounded_preds)
Example #28
Source File: test_stacker.py From xcessiv with Apache License 2.0 | 5 votes |
def test_fit_and_process_using_meta_feature_generator(self): X, y = load_iris(return_X_y=True) X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=8) self.stacked_ensemble.fit(X_train, y_train) preds = self.stacked_ensemble._process_using_meta_feature_generator(X_test, 'predict') assert np.round(accuracy_score(y_test, preds), 3) == 0.868 probas = self.stacked_ensemble._process_using_meta_feature_generator(X_test, 'predict_proba') preds = np.argmax(probas, axis=1) assert np.round(accuracy_score(y_test, preds), 3) == 0.868
Example #29
Source File: model_selection.py From MKLpy with GNU General Public License v3.0 | 5 votes |
def __def_score__(score): '''internal check''' score = score.lower() if score == 'roc_auc': return roc_auc_score, 'decision_function' elif score == 'accuracy': return accuracy_score, 'predict' elif score == 'f_score': return f1_score, 'predict' else: raise ValueError('%s is not a valid metric. Valid metrics are \'roc_auc\', \'accuracy\', or \'f_score\'.' % score)
Example #30
Source File: callbacks.py From MKLpy with GNU General Public License v3.0 | 5 votes |
def on_step_end(self, step): if step % self.cooldown: return if self.metric == 'obj': current = self.model.solution.objective elif self.metric == 'val_obj': pass elif self.metric == 'auc': Kva = self.model.func_form(self.KLva, self.model.solution.weights) ys = self.model.learner.fit(self.model.solution.ker_matrix, self.model.Y) \ .decision_function(Kva) current = roc_auc_score(self.Yva, ys) elif self.metric == 'accuracy': Kva = self.model.func_form(self.KLva, self.model.solution.weights) ys = self.model.learner.fit(self.model.solution.ker_matrix, self.model.Y) \ .predict(Kva) current = accuracy_score(self.Yva, ys) else: raise Error('Metric error') self.vals.append(current)#ratio(self.model.solution.ker_matrix, self.model.Y)) #print ('[%d][earlystopping] current' % step, \ # self.model.solution.objective, self.vals[-1], current) if self.monitor_op(current, self.best): self.best_solution = Solution( weights = self.model.solution.weights, objective = self.model.solution.objective, ker_matrix = self.model.solution.ker_matrix, ) self.best = current self.wait = 0 else: self.wait += 1 if self.wait >= self.patience: self.stoppend_epoch = step self.model.convergence = True