| """Frozen-feature linear probe: a fast difficulty check of the FundusShift splits. |
| |
| Features: frozen backbone (default DINOv2-small, CLS + mean patch token) on the released images. |
| Classifier: logistic regression with (source, class)-balanced sample weights; C chosen on validation. |
| Reports balanced accuracy / macro-F1 per split and per source, worst test source, and open-set AUROC. |
| |
| python baselines/linear_probe.py --bench data/bench --processed data/processed --out runs/probe_dinov2s |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
| from PIL import Image |
| from sklearn.linear_model import LogisticRegression |
| from sklearn.metrics import balanced_accuracy_score, cohen_kappa_score, f1_score, roc_auc_score |
| from sklearn.preprocessing import StandardScaler |
| from transformers import AutoImageProcessor, AutoModel |
|
|
| CANON = ["N", "D", "G", "A", "M"] |
| SPLITS = ["train", "validation", "calibration", "test", "test_ood", "test_openset"] |
|
|
|
|
| class _DS(torch.utils.data.Dataset): |
| def __init__(self, paths, proc): |
| self.paths, self.proc = paths, proc |
|
|
| def __len__(self): |
| return len(self.paths) |
|
|
| def __getitem__(self, i): |
| return self.proc(images=Image.open(self.paths[i]).convert("RGB"), return_tensors="pt")["pixel_values"][0] |
|
|
|
|
| @torch.no_grad() |
| def features(paths, model_name, device): |
| proc = AutoImageProcessor.from_pretrained(model_name) |
| model = AutoModel.from_pretrained(model_name).to(device).eval() |
| dl = torch.utils.data.DataLoader(_DS(paths, proc), batch_size=64, num_workers=6) |
| out = [] |
| for x in dl: |
| h = model(pixel_values=x.to(device)).last_hidden_state |
| out.append(torch.cat([h[:, 0], h[:, 1:].mean(1)], 1).float().cpu().numpy()) |
| return np.concatenate(out) |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--bench", required=True) |
| ap.add_argument("--processed", required=True) |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--model", default="facebook/dinov2-small") |
| a = ap.parse_args(argv) |
| out = Path(a.out) |
| out.mkdir(parents=True, exist_ok=True) |
| d = pd.read_csv(Path(a.bench) / "splits_final.csv", dtype=str, keep_default_na=False) |
| d = d[d.split.isin(SPLITS)].reset_index(drop=True) |
| feat_file = out / "features.npy" |
| if feat_file.exists(): |
| X = np.load(feat_file) |
| else: |
| device = "mps" if torch.backends.mps.is_available() else ("cuda" if torch.cuda.is_available() else "cpu") |
| X = features([str(Path(a.processed) / s / f"{i}.jpg") for s, i in zip(d.source, d.image_id)], a.model, device) |
| np.save(feat_file, X) |
| CLASSES = [c for c in CANON if c in set(d.label[d.split == "train"])] |
| y = np.array([CLASSES.index(l) if l in CLASSES else -1 for l in d.label]) |
| sp = d.split.to_numpy() |
| tr = sp == "train" |
| sc = StandardScaler().fit(X[tr]) |
| Xs = sc.transform(X) |
| cell = pd.Series(list(zip(d.source[tr], d.label[tr]))) |
| w = (1.0 / cell.map(cell.value_counts())).to_numpy().copy() |
| w *= len(w) / w.sum() |
|
|
| best = None |
| for C in [0.001, 0.003, 0.01, 0.03, 0.1]: |
| clf = LogisticRegression(C=C, max_iter=3000).fit(Xs[tr], y[tr], sample_weight=w) |
| va = sp == "validation" |
| b = balanced_accuracy_score(y[va], clf.predict(Xs[va])) |
| print(f"C={C}: val bacc {b:.4f}") |
| if best is None or b > best[0]: |
| best = (b, C, clf) |
| _, C, clf = best |
| P = clf.predict_proba(Xs) |
| res = {"model": a.model, "C": C} |
| for s in ["train", "validation", "calibration", "test", "test_ood"]: |
| m = sp == s |
| pred = P[m].argmax(1) |
| per_src = {src: round(balanced_accuracy_score(y[m][d.source[m] == src], pred[d.source[m] == src]), 4) |
| for src in sorted(set(d.source[m]))} |
| recall = {c: round(float((pred[y[m] == k] == k).mean()), 4) for k, c in enumerate(CLASSES) if (y[m] == k).any()} |
| res[s] = {"balanced_accuracy": round(balanced_accuracy_score(y[m], pred), 4), |
| "macro_f1": round(f1_score(y[m], pred, average="macro"), 4), "recall": recall, |
| "per_source_bacc": per_src, "worst_source_bacc": min(per_src.values())} |
| t, o = sp == "test", sp == "test_openset" |
| res["test_openset_auroc_msp"] = round(roc_auc_score(np.r_[np.zeros(t.sum()), np.ones(o.sum())], |
| np.r_[1 - P[t].max(1), 1 - P[o].max(1)]), 4) |
| res["classes"] = CLASSES |
|
|
| |
| g = pd.to_numeric(d.dr_grade, errors="coerce").fillna(-1).astype(int).to_numpy() |
| gtr = tr & (g >= 0) |
| if gtr.any() and ((sp == "test") & (g >= 0)).any(): |
| cw = pd.Series(list(zip(d.source[gtr], g[gtr]))) |
| wg = (1.0 / cw.map(cw.value_counts())).to_numpy().copy() |
| reg = LogisticRegression(C=C, max_iter=3000).fit(Xs[gtr], g[gtr], sample_weight=wg * len(wg) / wg.sum()) |
| res["dr_grading"] = {} |
| for s_ in ["validation", "test"]: |
| m = (sp == s_) & (g >= 0) |
| pred = reg.predict(Xs[m]) |
| res["dr_grading"][s_] = {"n": int(m.sum()), "quadratic_kappa": round(cohen_kappa_score(g[m], pred, weights="quadratic"), 4), |
| "accuracy": round(float((pred == g[m]).mean()), 4), |
| "sources": sorted(set(d.source[m]))} |
| print(json.dumps(res, indent=2)) |
| (out / "probe_metrics.json").write_text(json.dumps(res, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
