Python sklearn.metrics.auc() Examples
The following are 30
code examples of sklearn.metrics.auc().
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: vanilla_model.py From OpenChem with MIT License | 10 votes |
def fit_model(self, data, cross_val_data, cross_val_labels): eval_metrics = [] for i in range(self.n_ensemble): train_sm = np.concatenate(cross_val_data[:i] + cross_val_data[(i + 1):]) test_sm = cross_val_data[i] train_labels = np.concatenate(cross_val_labels[:i] + cross_val_labels[(i + 1):]) test_labels = cross_val_labels[i] fp_train = get_fp(train_sm) fp_test = get_fp(test_sm) self.model[i].fit(fp_train, train_labels.ravel()) predicted = self.model[i].predict(fp_test) if self.model_type == 'classifier': fpr, tpr, thresholds = metrics.roc_curve(test_labels, predicted) eval_metrics.append(metrics.auc(fpr, tpr)) metrics_type = 'AUC' elif self.model_type == 'regressor': r2 = metrics.r2_score(test_labels, predicted) eval_metrics.append(r2) metrics_type = 'R^2 score' return eval_metrics, metrics_type
Example #2
Source File: util.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 8 votes |
def compute_roc(y_true, y_pred, plot=False): """ TODO :param y_true: ground truth :param y_pred: predictions :param plot: :return: """ fpr, tpr, _ = roc_curve(y_true, y_pred) auc_score = auc(fpr, tpr) if plot: plt.figure(figsize=(7, 6)) plt.plot(fpr, tpr, color='blue', label='ROC (AUC = %0.4f)' % auc_score) plt.legend(loc='lower right') plt.title("ROC Curve") plt.xlabel("FPR") plt.ylabel("TPR") plt.show() return fpr, tpr, auc_score
Example #3
Source File: metrics_util.py From DeepLearningSmells with Apache License 2.0 | 8 votes |
def get_all_metrics_(eval_labels, pred_labels): fpr, tpr, thresholds_keras = roc_curve(eval_labels, pred_labels) auc_ = auc(fpr, tpr) print("auc_keras:" + str(auc_)) precision = precision_score(eval_labels, pred_labels) print('Precision score: {0:0.2f}'.format(precision)) recall = recall_score(eval_labels, pred_labels) print('Recall score: {0:0.2f}'.format(recall)) f1 = f1_score(eval_labels, pred_labels) print('F1 score: {0:0.2f}'.format(f1)) average_precision = average_precision_score(eval_labels, pred_labels) print('Average precision-recall score: {0:0.2f}'.format(average_precision)) return auc_, precision, recall, f1, average_precision, fpr, tpr
Example #4
Source File: evaluate.py From object_centric_VAD with MIT License | 6 votes |
def compute_eer(loss_file,reverse,smoothing): if not os.path.isdir(loss_file): loss_file_list = [loss_file] else: loss_file_list = os.listdir(loss_file) loss_file_list = [os.path.join(loss_file, sub_loss_file) for sub_loss_file in loss_file_list] optimal_results = RecordResult(auc=np.inf) for sub_loss_file in loss_file_list: dataset, scores, labels = get_scores_labels(sub_loss_file,reverse,smoothing) fpr, tpr, thresholds = metrics.roc_curve(labels, scores, pos_label=0) eer = cal_eer(fpr, tpr) results = RecordResult(fpr, tpr, eer, dataset, sub_loss_file) if optimal_results > results: optimal_results = results if os.path.isdir(loss_file): print(results) print('##### optimal result and model EER = {}'.format(optimal_results)) return optimal_results
Example #5
Source File: evals.py From LaMP with MIT License | 6 votes |
def compute_aupr(all_targets,all_predictions): aupr_array = [] for i in range(all_targets.shape[1]): try: precision, recall, thresholds = metrics.precision_recall_curve(all_targets[:,i], all_predictions[:,i], pos_label=1) auPR = metrics.auc(recall,precision,reorder=True) if not math.isnan(auPR): aupr_array.append(numpy.nan_to_num(auPR)) except: pass aupr_array = numpy.array(aupr_array) mean_aupr = numpy.mean(aupr_array) median_aupr = numpy.median(aupr_array) var_aupr = numpy.var(aupr_array) return mean_aupr,median_aupr,var_aupr,aupr_array
Example #6
Source File: util.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 6 votes |
def compute_roc_rfeinman(probs_neg, probs_pos, plot=False): """ TODO :param probs_neg: :param probs_pos: :param plot: :return: """ probs = np.concatenate((probs_neg, probs_pos)) labels = np.concatenate((np.zeros_like(probs_neg), np.ones_like(probs_pos))) fpr, tpr, _ = roc_curve(labels, probs) auc_score = auc(fpr, tpr) if plot: plt.figure(figsize=(7, 6)) plt.plot(fpr, tpr, color='blue', label='ROC (AUC = %0.4f)' % auc_score) plt.legend(loc='lower right') plt.title("ROC Curve") plt.xlabel("FPR") plt.ylabel("TPR") plt.show() return fpr, tpr, auc_score
Example #7
Source File: auc_test.py From allennlp with Apache License 2.0 | 6 votes |
def test_auc_gold_labels_behaviour(self, device: str): # Check that it works with different pos_label auc = Auc(positive_label=4) predictions = torch.randn(8, device=device) labels = torch.randint(3, 5, (8,), dtype=torch.long, device=device) # We make sure that the positive label is always present. labels[0] = 4 auc(predictions, labels) computed_auc_value = auc.get_metric(reset=True) false_positive_rates, true_positive_rates, _ = metrics.roc_curve( labels.cpu().numpy(), predictions.cpu().numpy(), pos_label=4 ) real_auc_value = metrics.auc(false_positive_rates, true_positive_rates) assert_allclose(real_auc_value, computed_auc_value) # Check that it errs on getting more than 2 labels. with pytest.raises(ConfigurationError) as _: labels = torch.tensor([3, 4, 5, 6, 7, 8, 9, 10], device=device) auc(predictions, labels)
Example #8
Source File: conv_featuremaps_visualization.py From MCF-3D-CNN with MIT License | 6 votes |
def accuracy(y_true, y_pred): # 计算混淆矩阵 y = np.zeros(len(y_true)) y_ = np.zeros(len(y_true)) for i in range(len(y_true)): y[i] = np.argmax(y_true[i,:]) y_[i] = np.argmax(y_pred[i,:]) cnf_mat = confusion_matrix(y, y_) # Acc = 1.0*(cnf_mat[1][1]+cnf_mat[0][0])/len(y_true) # Sens = 1.0*cnf_mat[1][1]/(cnf_mat[1][1]+cnf_mat[1][0]) # Spec = 1.0*cnf_mat[0][0]/(cnf_mat[0][0]+cnf_mat[0][1]) # # 绘制ROC曲线 # fpr, tpr, thresholds = roc_curve(y_true[:,0], y_pred[:,0]) # Auc = auc(fpr, tpr) # 计算多分类评价值 Sens = recall_score(y, y_, average='macro') Prec = precision_score(y, y_, average='macro') F1 = f1_score(y, y_, average='weighted') Support = precision_recall_fscore_support(y, y_, beta=0.5, average=None) return Sens, Prec, F1, cnf_mat
Example #9
Source File: model_utils.py From dython with BSD 3-Clause "New" or "Revised" License | 6 votes |
def _plot_macro_roc(fpr, tpr, n, lw, fmt, ax): all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n)])) mean_tpr = np.zeros_like(all_fpr) for i in range(n): mean_tpr += interp(all_fpr, fpr[i], tpr[i]) mean_tpr /= n fpr_macro = all_fpr tpr_macro = mean_tpr auc_macro = auc(fpr_macro, tpr_macro) label = 'ROC curve: macro (AUC = {auc:{fmt}})'.format(auc=auc_macro, fmt=fmt) ax.plot(fpr_macro, tpr_macro, label=label, color='navy', ls=':', lw=lw)
Example #10
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 6 votes |
def test_auc(): # Test Area Under Curve (AUC) computation x = [0, 1] y = [0, 1] assert_array_almost_equal(auc(x, y), 0.5) x = [1, 0] y = [0, 1] assert_array_almost_equal(auc(x, y), 0.5) x = [1, 0, 0] y = [0, 1, 1] assert_array_almost_equal(auc(x, y), 0.5) x = [0, 1] y = [1, 1] assert_array_almost_equal(auc(x, y), 1) x = [0, 0.5, 1] y = [0, 0.5, 1] assert_array_almost_equal(auc(x, y), 0.5)
Example #11
Source File: metrics_util.py From DeepLearningSmells with Apache License 2.0 | 6 votes |
def get_all_metrics(model, eval_data, eval_labels, pred_labels): fpr, tpr, thresholds_keras = roc_curve(eval_labels, pred_labels) auc_ = auc(fpr, tpr) print("auc_keras:" + str(auc_)) score = model.evaluate(eval_data, eval_labels, verbose=0) print("Test accuracy: " + str(score[1])) precision = precision_score(eval_labels, pred_labels) print('Precision score: {0:0.2f}'.format(precision)) recall = recall_score(eval_labels, pred_labels) print('Recall score: {0:0.2f}'.format(recall)) f1 = f1_score(eval_labels, pred_labels) print('F1 score: {0:0.2f}'.format(f1)) average_precision = average_precision_score(eval_labels, pred_labels) print('Average precision-recall score: {0:0.2f}'.format(average_precision)) return auc_, score[1], precision, recall, f1, average_precision, fpr, tpr
Example #12
Source File: metrics.py From inferbeddings with MIT License | 6 votes |
def __call__(self, pos_triples, neg_triples=None): triples = pos_triples + neg_triples labels = [1 for _ in range(len(pos_triples))] + [0 for _ in range(len(neg_triples))] Xr, Xe = [], [] for (s_idx, p_idx, o_idx), label in zip(triples, labels): Xr += [[p_idx]] Xe += [[s_idx, o_idx]] ascores = self.scoring_function([Xr, Xe]) ays = np.array(labels) if self.rescale_predictions: diffs = np.diff(np.sort(ascores)) min_diff = min(abs(diffs[np.nonzero(diffs)])) if min_diff < 1e-8: ascores = (ascores * (1e-7 / min_diff)).astype(np.float64) aucroc_value = metrics.roc_auc_score(ays, ascores) precision, recall, thresholds = metrics.precision_recall_curve(ays, ascores, pos_label=1) aucpr_value = metrics.auc(recall, precision) return aucroc_value, aucpr_value
Example #13
Source File: __init__.py From PADME with MIT License | 6 votes |
def compute_roc_auc_scores(y, y_pred): """Transforms the results dict into roc-auc-scores and prints scores. Parameters ---------- results: dict task_types: dict dict mapping task names to output type. Each output type must be either "classification" or "regression". """ try: score = roc_auc_score(y, y_pred) except ValueError: warnings.warn("ROC AUC score calculation failed.") score = 0.5 return score
Example #14
Source File: results_processor.py From pipgcn with GNU General Public License v3.0 | 6 votes |
def roc(self, data, model, tt, name): scores = self.get_predictions_loss(data, model, tt)[0] labels = [prot["label"][:, 2] for prot in data[tt]] fprs = [] tprs = [] roc_aucs = [] for s, l in zip(scores, labels): fpr, tpr, _ = roc_curve(l, s) roc_auc = auc(fpr, tpr) fprs.append(fpr) tprs.append(tpr) roc_aucs.append(roc_auc) auc_prot_med = np.median(roc_aucs) auc_prot_ave = np.mean(roc_aucs) printt("{} average protein auc: {:0.3f}".format(name, auc_prot_ave)) printt("{} median protein auc: {:0.3f}".format(name, auc_prot_med)) return ["auc_prot_ave_" + tt, "auc_prot_med_" + tt], [auc_prot_ave, auc_prot_med]
Example #15
Source File: metric.py From tensorflow_end2end_speech_recognition with MIT License | 6 votes |
def compute_auc(y_true, y_pred, label_index): """Compute Area Under the Curve (AUC) metric. Args: y_true: true class y_pred: probabilities for a class label_index: label_index == 1 => laughter (class1) vs. others (class0) label_index == 2 => filler (class1) vs. others (class0) Returns: auc_val: AUC metric accuracy """ for i in range(y_true.shape[0]): y_true[i] = 0 if y_true[i] != label_index else 1 y_true = np.reshape(y_true, (-1,)) y_pred = np.reshape(y_pred[:, label_index], (-1,)) try: fpr, tpr, _ = roc_curve(y_true, y_pred, pos_label=1) except UndefinedMetricWarning: pass auc_val = auc(fpr, tpr) return auc_val
Example #16
Source File: auc.py From allennlp with Apache License 2.0 | 5 votes |
def get_metric(self, reset: bool = False): if self._all_gold_labels.shape[0] == 0: return 0.5 false_positive_rates, true_positive_rates, _ = metrics.roc_curve( self._all_gold_labels.cpu().numpy(), self._all_predictions.cpu().numpy(), pos_label=self._positive_label, ) auc = metrics.auc(false_positive_rates, true_positive_rates) if reset: self.reset() return auc
Example #17
Source File: lfw_comparison_and_plot_roc.py From MobileFace with MIT License | 5 votes |
def lfw_plot_roc(fpr2, tpr2): roc_auc = auc(fpr2, tpr2) plt.figure(True) # == plt.figure(True) plt.figure(figsize=(10, 10)) plt.plot(fpr2, tpr2, color='red', lw=3, label='MobileFace_Identification_V2 (AUC = %0.6f)' % roc_auc) plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.0]) # Modify coordinate scale new_ticks = np.linspace(0.0, 1.0, 11) plt.xticks(new_ticks) plt.yticks(new_ticks) # Add grid plt.grid() # == plt.grid(True) plt.grid(color='b' , linewidth='0.3' ,linestyle='--') plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('LFW ROC Curves of Unrestricted and Labeled Outside Data', y=1.02) plt.legend(loc="lower right") plt.show() plt.savefig("LFW_ROC_MobileFace_Identification_V2.png")
Example #18
Source File: model_utils.py From dython with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _binary_roc_graph(y_true, y_pred, eoptimal, class_label, color, lw, ls, ms, fmt, ax): y_true = convert(y_true, 'array') y_pred = convert(y_pred, 'array') if y_pred.shape != y_true.shape: raise ValueError('y_true and y_pred must have the same shape') elif len(y_pred.shape) == 1: y_t = y_true y_p = y_pred else: y_t = [np.argmax(x) for x in y_true] y_p = [x[1] for x in y_pred] fpr, tpr, th = roc_curve(y_t, y_p) auc_score = auc(fpr, tpr) if 'class_label' is not None: class_label = ': ' + class_label else: class_label = '' label = 'ROC curve{class_label} (AUC = {auc:{fmt}}'.format(class_label=class_label, auc=auc_score, fmt=fmt) if eoptimal: eopt = _draw_estimated_optimal_threshold_mark(fpr, tpr, th, color, ms, fmt, ax) label += ', eOpT = {th:{fmt}})'.format(th=eopt, fmt=fmt) else: eopt = None label += ')' ax.plot(fpr, tpr, color=color, lw=lw, ls=ls, label=label) return {'fpr': fpr, 'tpr': tpr, 'thresholds': th, 'auc': auc_score, 'eopt': eopt}
Example #19
Source File: auc_test.py From allennlp with Apache License 2.0 | 5 votes |
def test_auc_computation(self, device: str): auc = Auc() all_predictions = [] all_labels = [] for _ in range(5): predictions = torch.randn(8, device=device) labels = torch.randint(0, 2, (8,), dtype=torch.long, device=device) auc(predictions, labels) all_predictions.append(predictions) all_labels.append(labels) computed_auc_value = auc.get_metric(reset=True) false_positive_rates, true_positive_rates, _ = metrics.roc_curve( torch.cat(all_labels, dim=0).cpu().numpy(), torch.cat(all_predictions, dim=0).cpu().numpy(), ) real_auc_value = metrics.auc(false_positive_rates, true_positive_rates) assert_allclose(real_auc_value, computed_auc_value) # One more computation to assure reset works. predictions = torch.randn(8, device=device) labels = torch.randint(0, 2, (8,), dtype=torch.long, device=device) auc(predictions, labels) computed_auc_value = auc.get_metric(reset=True) false_positive_rates, true_positive_rates, _ = metrics.roc_curve( labels.cpu().numpy(), predictions.cpu().numpy() ) real_auc_value = metrics.auc(false_positive_rates, true_positive_rates) assert_allclose(real_auc_value, computed_auc_value)
Example #20
Source File: dga_classifier.py From SANS_THIR16 with MIT License | 5 votes |
def cross_validate(fts, labels, clf, nfolds): scores = [] true_labels = [] for fold in range(nfolds): X_train, X_test, y_train, y_test = train_test_split(fts, labels, test_size=.2) clf.fit(X_train, y_train) scores.append(clf.predict_proba(X_test)[:,1]) true_labels.append(y_test) ret = {} ret['fpr'], ret['tpr'], ret['thr'] = roc_curve(np.array(true_labels).ravel(), np.array(scores).ravel()) ret['auc'] = auc(ret['fpr'], ret['tpr']) print ret['auc'] return ret
Example #21
Source File: evals.py From LaMP with MIT License | 5 votes |
def compute_aupr_thread(all_targets,all_predictions): aupr_array = [] lock = Lock() def compute_aupr_(start,end,all_targets,all_predictions): for i in range(all_targets.shape[1]): try: precision, recall, thresholds = metrics.precision_recall_curve(all_targets[:,i], all_predictions[:,i], pos_label=1) auPR = metrics.auc(recall,precision,reorder=True) lock.acquire() aupr_array.append(numpy.nan_to_num(auPR)) lock.release() except Exception: pass t1 = Thread(target=compute_aupr_, args=(0,100,all_targets,all_predictions) ) t2 = Thread(target=compute_aupr_, args=(100,200,all_targets,all_predictions) ) t3 = Thread(target=compute_aupr_, args=(200,300,all_targets,all_predictions) ) t4 = Thread(target=compute_aupr_, args=(300,400,all_targets,all_predictions) ) t5 = Thread(target=compute_aupr_, args=(400,500,all_targets,all_predictions) ) t6 = Thread(target=compute_aupr_, args=(500,600,all_targets,all_predictions) ) t7 = Thread(target=compute_aupr_, args=(600,700,all_targets,all_predictions) ) t8 = Thread(target=compute_aupr_, args=(700,800,all_targets,all_predictions) ) t9 = Thread(target=compute_aupr_, args=(800,900,all_targets,all_predictions) ) t10 = Thread(target=compute_aupr_, args=(900,919,all_targets,all_predictions) ) t1.start();t2.start();t3.start();t4.start();t5.start();t6.start();t7.start();t8.start();t9.start();t10.start() t1.join();t2.join();t3.join();t4.join();t5.join();t6.join();t7.join();t8.join();t9.join();t10.join() aupr_array = numpy.array(aupr_array) mean_aupr = numpy.mean(aupr_array) median_aupr = numpy.median(aupr_array) return mean_aupr,median_aupr,aupr_array
Example #22
Source File: auc_regressor.py From xam with MIT License | 5 votes |
def score(self, X, y): fpr, tpr, _ = metrics.roc_curve(y, sp.dot(X, self.coef_)) return metrics.auc(fpr, tpr)
Example #23
Source File: auc_regressor.py From xam with MIT License | 5 votes |
def _auc_loss(self, coef, X, y): fpr, tpr, _ = metrics.roc_curve(y, sp.dot(X, coef)) return -metrics.auc(fpr, tpr)
Example #24
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def test_deprecated_auc_reorder(): depr_message = ("The 'reorder' parameter has been deprecated in version " "0.20 and will be removed in 0.22. It is recommended not " "to set 'reorder' and ensure that x is monotonic " "increasing or monotonic decreasing.") assert_warns_message(DeprecationWarning, depr_message, auc, [1, 2], [2, 3], reorder=True)
Example #25
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def test_auc_errors(): # Incompatible shapes assert_raises(ValueError, auc, [0.0, 0.5, 1.0], [0.1, 0.2]) # Too few x values assert_raises(ValueError, auc, [0.0], [0.1]) # x is not in order x = [2, 1, 3, 4] y = [5, 6, 7, 8] error_message = ("x is neither increasing nor decreasing : " "{}".format(np.array(x))) assert_raise_message(ValueError, error_message, auc, x, y)
Example #26
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def test_roc_curve_hard(): # roc_curve for hard decisions y_true, pred, probas_pred = make_prediction(binary=True) # always predict one trivial_pred = np.ones(y_true.shape) fpr, tpr, thresholds = roc_curve(y_true, trivial_pred) roc_auc = auc(fpr, tpr) assert_array_almost_equal(roc_auc, 0.50, decimal=2) assert_equal(fpr.shape, tpr.shape) assert_equal(fpr.shape, thresholds.shape) # always predict zero trivial_pred = np.zeros(y_true.shape) fpr, tpr, thresholds = roc_curve(y_true, trivial_pred) roc_auc = auc(fpr, tpr) assert_array_almost_equal(roc_auc, 0.50, decimal=2) assert_equal(fpr.shape, tpr.shape) assert_equal(fpr.shape, thresholds.shape) # hard decisions fpr, tpr, thresholds = roc_curve(y_true, pred) roc_auc = auc(fpr, tpr) assert_array_almost_equal(roc_auc, 0.78, decimal=2) assert_equal(fpr.shape, tpr.shape) assert_equal(fpr.shape, thresholds.shape)
Example #27
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def test_roc_curve_confidence(): # roc_curve for confidence scores y_true, _, probas_pred = make_prediction(binary=True) fpr, tpr, thresholds = roc_curve(y_true, probas_pred - 0.5) roc_auc = auc(fpr, tpr) assert_array_almost_equal(roc_auc, 0.90, decimal=2) assert_equal(fpr.shape, tpr.shape) assert_equal(fpr.shape, thresholds.shape)
Example #28
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def test_roc_curve(drop): # Test Area under Receiver Operating Characteristic (ROC) curve y_true, _, probas_pred = make_prediction(binary=True) expected_auc = _auc(y_true, probas_pred) fpr, tpr, thresholds = roc_curve(y_true, probas_pred, drop_intermediate=drop) roc_auc = auc(fpr, tpr) assert_array_almost_equal(roc_auc, expected_auc, decimal=2) assert_almost_equal(roc_auc, roc_auc_score(y_true, probas_pred)) assert_equal(fpr.shape, tpr.shape) assert_equal(fpr.shape, thresholds.shape)
Example #29
Source File: test_ranking.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
def _partial_roc_auc_score(y_true, y_predict, max_fpr): """Alternative implementation to check for correctness of `roc_auc_score` with `max_fpr` set. """ def _partial_roc(y_true, y_predict, max_fpr): fpr, tpr, _ = roc_curve(y_true, y_predict) new_fpr = fpr[fpr <= max_fpr] new_fpr = np.append(new_fpr, max_fpr) new_tpr = tpr[fpr <= max_fpr] idx_out = np.argmax(fpr > max_fpr) idx_in = idx_out - 1 x_interp = [fpr[idx_in], fpr[idx_out]] y_interp = [tpr[idx_in], tpr[idx_out]] new_tpr = np.append(new_tpr, np.interp(max_fpr, x_interp, y_interp)) return (new_fpr, new_tpr) new_fpr, new_tpr = _partial_roc(y_true, y_predict, max_fpr) partial_auc = auc(new_fpr, new_tpr) # Formula (5) from McClish 1989 fpr1 = 0 fpr2 = max_fpr min_area = 0.5 * (fpr2 - fpr1) * (fpr2 + fpr1) max_area = fpr2 - fpr1 return 0.5 * (1 + (partial_auc - min_area) / (max_area - min_area))
Example #30
Source File: utils.py From V-GAN with MIT License | 5 votes |
def AUC_PR(true_vessel_img, pred_vessel_img, save_fname): """ Precision-recall curve """ precision, recall, _ = precision_recall_curve(true_vessel_img.flatten(), pred_vessel_img.flatten(), pos_label=1) save_obj({"precision":precision, "recall":recall}, save_fname) AUC_prec_rec = auc(recall, precision) return AUC_prec_rec