File size: 3,420 Bytes
2eb3475 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 | """Evaluation metrics for error prediction.
We report:
- ROC-AUC of wrongness score vs binary `correct/incorrect` label.
- PR-AUC (positive class = wrong).
- AURC (area under risk-coverage).
- Accuracy-Rejection Curve area *above baseline* (the paper's headline metric).
- ECE of the underlying classifier (constant across feature variants, included for context).
"""
from __future__ import annotations
from typing import Dict
import numpy as np
from sklearn.metrics import average_precision_score, roc_auc_score
def accuracy_rejection_curve(
wrongness_scores: np.ndarray,
y_true: np.ndarray,
y_pred: np.ndarray,
step: int = 1,
) -> Dict[str, np.ndarray]:
"""ARC à la Nadeem et al. 2009 — sort by ascending confidence (= descending wrongness),
drop the least confident first, recompute accuracy on the remaining set.
"""
N = len(wrongness_scores)
order = np.argsort(-wrongness_scores) # most-likely-wrong first
r_rates, accs = [0.0], [float((y_pred == y_true).mean())]
for i in range(step, N, step):
keep = order[i:]
if len(keep) == 0:
break
r_rates.append(i / N)
accs.append(float((y_pred[keep] == y_true[keep]).mean()))
return {"rejection_rate": np.asarray(r_rates), "accuracy": np.asarray(accs)}
def arc_auc_above_baseline(arc: Dict[str, np.ndarray]) -> float:
"""Trapezoid-integrate (accuracy - baseline_accuracy) wrt rejection_rate."""
r = arc["rejection_rate"]
a = arc["accuracy"]
baseline = a[0]
return float(np.trapz(np.maximum(a - baseline, 0), r))
def aurc(wrongness_scores: np.ndarray, y_true: np.ndarray, y_pred: np.ndarray) -> float:
N = len(wrongness_scores)
order = np.argsort(wrongness_scores) # ascending wrongness → most confident first
cum_errors = np.cumsum((y_pred[order] != y_true[order]).astype(np.float64))
coverage = (np.arange(1, N + 1)) / N
risk = cum_errors / np.arange(1, N + 1)
return float(np.trapz(risk, coverage))
def expected_calibration_error(probs_max: np.ndarray, correct: np.ndarray, n_bins: int = 15) -> float:
bins = np.linspace(0.0, 1.0, n_bins + 1)
ece = 0.0
N = len(probs_max)
for i in range(n_bins):
lo, hi = bins[i], bins[i + 1]
mask = (probs_max > lo) & (probs_max <= hi)
if mask.sum() == 0:
continue
acc = correct[mask].mean()
conf = probs_max[mask].mean()
ece += (mask.sum() / N) * abs(acc - conf)
return float(ece)
def evaluate_all(
wrongness_scores: np.ndarray,
y_true: np.ndarray,
y_pred: np.ndarray,
probs_max: np.ndarray,
) -> Dict[str, float]:
wrong = (y_pred != y_true).astype(int)
metrics: Dict[str, float] = {}
if len(np.unique(wrong)) > 1:
metrics["roc_auc_wrong"] = float(roc_auc_score(wrong, wrongness_scores))
metrics["pr_auc_wrong"] = float(average_precision_score(wrong, wrongness_scores))
else:
metrics["roc_auc_wrong"] = float("nan")
metrics["pr_auc_wrong"] = float("nan")
arc = accuracy_rejection_curve(wrongness_scores, y_true, y_pred, step=1)
metrics["arc_auc_above_baseline"] = arc_auc_above_baseline(arc)
metrics["aurc"] = aurc(wrongness_scores, y_true, y_pred)
metrics["ece"] = expected_calibration_error(probs_max, (y_true == y_pred).astype(float))
metrics["base_accuracy"] = float((y_pred == y_true).mean())
return metrics
|