| """FundusShift evaluation protocol (model-agnostic). |
| |
| Input: per-split prediction files (parquet/csv) with columns image_id, logit_N, logit_D, logit_G. |
| 1. temperature T fitted on calibration cal_A (NLL) |
| 2. referral threshold on max-probability chosen on cal_B for a target accepted-risk (default 5% error) |
| 3. report on test / test_ood: accuracy, balanced accuracy, macro-F1, ECE, per-source balanced accuracy, |
| worst-source balanced accuracy, coverage and risk at the cal_B threshold, AURC |
| 4. test_openset: AUROC of (1 - max prob) for separating out-of-label-space images from core test images |
| |
| python baselines/evaluate.py --preds runs/resnet50 --repo le-dang1haha/FundusShift |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| from scipy.optimize import minimize_scalar |
| from sklearn.metrics import balanced_accuracy_score, f1_score, roc_auc_score |
|
|
| CANON = ["N", "D", "G", "A", "M"] |
| META = ["image_id", "label", "source", "cal_subset"] |
|
|
|
|
| def softmax(z): |
| z = z - z.max(1, keepdims=True) |
| e = np.exp(z) |
| return e / e.sum(1, keepdims=True) |
|
|
|
|
| def fit_temperature(logits, y): |
| nll = lambda t: -np.log(softmax(logits / t)[np.arange(len(y)), y] + 1e-12).mean() |
| return minimize_scalar(nll, bounds=(0.05, 20), method="bounded").x |
|
|
|
|
| def ece(p, y, bins=15): |
| conf, pred = p.max(1), p.argmax(1) |
| edges = np.linspace(0, 1, bins + 1) |
| e = 0.0 |
| for lo, hi in zip(edges[:-1], edges[1:]): |
| m = (conf > lo) & (conf <= hi) |
| if m.any(): |
| e += m.mean() * abs((pred[m] == y[m]).mean() - conf[m].mean()) |
| return e |
|
|
|
|
| def threshold_for_risk(p, y, target): |
| """Smallest max-prob threshold whose accepted-set error <= target (falls back to accept-all).""" |
| conf, err = p.max(1), p.argmax(1) != y |
| order = np.argsort(-conf) |
| cum_risk = np.cumsum(err[order]) / np.arange(1, len(y) + 1) |
| ok = np.flatnonzero(cum_risk <= target) |
| return float(conf[order][ok.max()]) if len(ok) else 1.0 |
|
|
|
|
| def aurc(p, y): |
| conf, err = p.max(1), (p.argmax(1) != y).astype(float) |
| order = np.argsort(-conf) |
| return float((np.cumsum(err[order]) / np.arange(1, len(y) + 1)).mean()) |
|
|
|
|
| def report(p, y, src, thr): |
| pred = p.argmax(1) |
| per_src = {s: balanced_accuracy_score(y[src == s], pred[src == s]) for s in np.unique(src)} |
| acc = p.max(1) >= thr |
| return {"n": int(len(y)), "accuracy": float((pred == y).mean()), "balanced_accuracy": balanced_accuracy_score(y, pred), |
| "macro_f1": f1_score(y, pred, average="macro"), "ece": ece(p, y), "aurc": aurc(p, y), |
| "coverage_at_thr": float(acc.mean()), "risk_at_thr": float((pred[acc] != y[acc]).mean()) if acc.any() else None, |
| "worst_source_bacc": min(per_src.values()), "per_source_bacc": per_src} |
|
|
|
|
| def load_preds(d, split, meta): |
| f = Path(d) / f"{split}.csv" |
| if not f.exists(): |
| return None |
| return meta[split].merge(pd.read_csv(f, dtype={"image_id": str}), on="image_id", validate="1:1") |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--preds", required=True) |
| ap.add_argument("--repo", default="le-dang1haha/FundusShift") |
| ap.add_argument("--target-risk", type=float, default=0.05) |
| ap.add_argument("--splits-csv", help="local mode: metadata/splits_final.csv instead of the Hub") |
| a = ap.parse_args(argv) |
| head = pd.read_csv(Path(a.preds) / "calibration.csv", nrows=1) |
| CLASSES = [c[len("logit_"):] for c in head.columns if c.startswith("logit_")] |
| if a.splits_csv: |
| d = pd.read_csv(a.splits_csv, dtype=str, keep_default_na=False) |
| d["split"] = d.split.replace({"val": "validation", "cal": "calibration"}) |
| d["label"] = [CLASSES.index(l) if l in CLASSES else -1 for l in d.label] |
| meta = {s: g[META].reset_index(drop=True) for s, g in d.groupby("split")} |
| else: |
| from datasets import load_dataset |
| ds = load_dataset(a.repo) |
| meta = {s: ds[s].remove_columns("image").select_columns(META).to_pandas() for s in ds} |
| L = [f"logit_{c}" for c in CLASSES] |
|
|
| cal = load_preds(a.preds, "calibration", meta) |
| ca, cb = cal[cal.cal_subset == "cal_A"], cal[cal.cal_subset == "cal_B"] |
| T = fit_temperature(ca[L].to_numpy(), ca.label.to_numpy()) |
| thr = threshold_for_risk(softmax(cb[L].to_numpy() / T), cb.label.to_numpy(), a.target_risk) |
| out = {"temperature": T, "threshold_maxprob": thr, "target_risk": a.target_risk} |
| for split in ["validation", "test", "test_ood"]: |
| d = load_preds(a.preds, split, meta) |
| if d is not None: |
| p = softmax(d[L].to_numpy() / T) |
| out[split] = report(p, d.label.to_numpy(), d.source.to_numpy(), thr) |
| out[split]["ece_uncalibrated"] = ece(softmax(d[L].to_numpy()), d.label.to_numpy()) |
| o, t = load_preds(a.preds, "test_openset", meta), load_preds(a.preds, "test", meta) |
| if o is not None and t is not None: |
| po, pt = softmax(o[L].to_numpy() / T), softmax(t[L].to_numpy() / T) |
| score = np.r_[1 - pt.max(1), 1 - po.max(1)] |
| out["test_openset"] = {"auroc_msp": roc_auc_score(np.r_[np.zeros(len(pt)), np.ones(len(po))], score), |
| "fraction_referred_at_thr": float((po.max(1) < thr).mean())} |
| print(json.dumps(out, indent=2, default=float)) |
| (Path(a.preds) / "metrics.json").write_text(json.dumps(out, indent=2, default=float)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
