Datasets:
File size: 5,548 Bytes
53de216 70f9003 53de216 70f9003 53de216 70f9003 53de216 70f9003 53de216 | 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 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | """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
# task 3: DR grading (ICDR 0-4) on images that carry a grade
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()
|