set5: phase 5 (random labels, MLP probes, 224 px check, SPair-71k), final analysis, conclusions, reproduce notebook
1777460 verified Download set5/code/analyze5.py from LamTNguyen/repa-representation-probing: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/analyze5.py
- Command line
-
hf download hf://datasets/LamTNguyen/repa-representation-probing/set5/code/analyze5.py
-
curl -L -o analyze5.py https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/analyze5.py
10.7 kB
| """Final set-5 analysis (Mac): linear vs MLP probes, random-label side test, native-224 check, combined long CSV. | |
| python analyze5.py <out_dir> # out_dir holds p3/, p4/, p5/ (rows CSVs) and perimage/p5/*.npz | |
| Writes <out_dir>/final/: results_long_all.csv, linear_vs_mlp.json, gap_linear_vs_mlp.json, randlabel.json, | |
| check224.json and figures (randlabel_*.png). | |
| """ | |
| from __future__ import annotations | |
| import csv | |
| import json | |
| import sys | |
| from pathlib import Path | |
| import numpy as np | |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) | |
| import analyze3 as A # noqa: E402 | |
| import probes5 as PR # noqa: E402 | |
| PRIMARY = {"nyu_depth": "rmse", "nyu_normals": "mean_angle", "ade_seg": "miou"} | |
| HIGHER = {"nyu_depth": False, "nyu_normals": False, "ade_seg": True, "imagenet_cls": True} | |
| DENOISERS = {"B": ["sit_b", "jit_b"], "L": ["sit_l", "jit_l"]} | |
| SSL = {"B": ["mae_b", "mocov3_b", "dino_b", "ibot_b", "deit3_b"], "L": ["mae_l", "mocov3_l", "ibot_l", "deit3_l"]} | |
| def read_rows(d): | |
| rows = [] | |
| for p in sorted(d.glob("*_rows.csv")): | |
| with open(p) as f: | |
| for r in csv.DictReader(f): | |
| r["mean"] = float(r["mean"]) | |
| rows.append(r) | |
| return rows | |
| def find(rows, **kw): | |
| out = [r for r in rows if all(str(r[k]) == str(v) for k, v in kw.items())] | |
| return out[0] if out else None | |
| def mlp_stat(out, model, task, W): | |
| """Per-image arrays of the MLP probe -> [B] seed-averaged primary metric for resampling weights W.""" | |
| t = {"nyu_depth": "depth", "nyu_normals": "normals", "ade_seg": "seg"}[task] | |
| z = np.load(out / "perimage" / "p5" / f"mlp_{model}_{t}.npz") | |
| if task == "nyu_depth": | |
| return A.stat("mean", z["depth_rmse"], W) | |
| if task == "nyu_normals": | |
| return A.stat("normals", z["normals_stats"].astype(np.float64), W) | |
| return A.stat("seg", z["ade_counts"].astype(np.float64), W) | |
| def main(): | |
| out = Path(sys.argv[1]) | |
| fin = out / "final" | |
| fin.mkdir(parents=True, exist_ok=True) | |
| r3, r4, r5 = read_rows(out / "p3"), read_rows(out / "p4"), read_rows(out / "p5") | |
| with open(fin / "results_long_all.csv", "w", newline="") as f: | |
| w = csv.DictWriter(f, fieldnames=PR.FIELDS) | |
| w.writeheader() | |
| for r in r3 + r4 + r5: | |
| w.writerow({k: r.get(k, "") for k in PR.FIELDS}) | |
| sel = {} | |
| for ph in ("p3", "p4"): | |
| for r in json.loads((out / ph / "analysis" / "main_table.json").read_text()): | |
| sel[(r["model"], r["task"])] = r | |
| # ---------------------------------------------------------------- linear vs MLP at the same cell | |
| lvm = [] | |
| for size in ("B", "L"): | |
| for m in DENOISERS[size] + SSL[size] + (["dinov2_b"] if size == "B" else []): | |
| for task, met in PRIMARY.items(): | |
| s = sel.get((m, task)) | |
| r = find(r5, model=m, task=f"{task}_mlp", metric=met, split="test") | |
| if s and r: | |
| lin = s[met] | |
| lvm.append(dict(size=size, model=m, task=task, layer=s["layer"], s=s["s"], linear=lin, | |
| mlp=r["mean"], mlp_ci=(float(r["ci_lo"]), float(r["ci_hi"])), mlp_minus_linear=r["mean"] - lin)) | |
| (fin / "linear_vs_mlp.json").write_text(json.dumps(lvm, indent=1)) | |
| # ---------------------------------------------------------------- denoising - SSL gap under each probe type | |
| gaps = [] | |
| for size in ("B", "L"): | |
| for task in PRIMARY: | |
| for d in DENOISERS[size]: | |
| for o in SSL[size]: | |
| a, b = sel.get((d, task)), sel.get((o, task)) | |
| ra = find(r5, model=d, task=f"{task}_mlp", metric=PRIMARY[task], split="test") | |
| rb = find(r5, model=o, task=f"{task}_mlp", metric=PRIMARY[task], split="test") | |
| if not (a and b and ra and rb): | |
| continue | |
| n = np.load(out / "perimage" / "p5" / f"mlp_{d}_{ {'nyu_depth': 'depth', 'nyu_normals': 'normals', 'ade_seg': 'seg'}[task] }.npz") | |
| nimg = next(iter(n.values())).shape[1] | |
| W = PR.boot_weights(nimg, n_boot=2000, seed=2) | |
| diff = mlp_stat(out, d, task, W) - mlp_stat(out, o, task, W) | |
| lo, hi = np.percentile(diff, [2.5, 97.5]) | |
| gaps.append(dict(size=size, task=task, denoiser=d, ssl=o, | |
| linear_gap=a[PRIMARY[task]] - b[PRIMARY[task]], | |
| mlp_gap=ra["mean"] - rb["mean"], mlp_gap_ci=(float(lo), float(hi)), | |
| mlp_verdict="ngang nhau" if lo <= 0 <= hi else | |
| (f"{d} tốt hơn" if ((ra["mean"] > rb["mean"]) == HIGHER[task]) else f"{o} tốt hơn"))) | |
| (fin / "gap_linear_vs_mlp.json").write_text(json.dumps(gaps, indent=1)) | |
| # ---------------------------------------------------------------- random label vs null label, per block | |
| rl = [] | |
| for m in ("sit_b", "jit_b"): | |
| for task, met, nullt in (("nyu_depth_randlabel", "rmse", "nyu_depth"), ("imagenet_cls_randlabel", "top1", "imagenet_cls")): | |
| for r in [r for r in r5 if r["model"] == m and r["task"] == task and r["metric"] == met and r["split"] == "test"]: | |
| nl = find(r3, model=m, task=nullt, metric=met, layer=r["layer"], s=r["s"], split="test") | |
| rl.append(dict(model=m, task=nullt, s=r["s"], layer=int(r["layer"]), random_label=r["mean"], | |
| random_ci=(float(r["ci_lo"]), float(r["ci_hi"])), null_label=nl["mean"] if nl else None, | |
| null_ci=(nl["ci_lo"], nl["ci_hi"]) if nl else None)) | |
| (fin / "randlabel.json").write_text(json.dumps(rl, indent=1, default=str)) | |
| try: | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| fig, axes = plt.subplots(1, 2, figsize=(11, 3.8)) | |
| for ax, task, lab in ((axes[0], "nyu_depth", "RMSE độ sâu (↓)"), (axes[1], "imagenet_cls", "top-1 ImageNet (↑)")): | |
| for m, c in (("sit_b", "C0"), ("jit_b", "C1")): | |
| xs = sorted({r["layer"] for r in rl if r["model"] == m and r["task"] == task}) | |
| g = {r["layer"]: r for r in rl if r["model"] == m and r["task"] == task} | |
| if not xs: | |
| continue | |
| ax.plot(xs, [g[x]["null_label"] for x in xs], "-o", ms=3, c=c, label=f"{A.NAMES[m]} nhãn rỗng (s={g[xs[0]]['s']})") | |
| ax.plot(xs, [g[x]["random_label"] for x in xs], "--o", ms=3, c=c, label=f"{A.NAMES[m]} nhãn ngẫu nhiên") | |
| ax.set_xlabel("block") | |
| ax.set_ylabel(lab) | |
| ax.legend(fontsize=7) | |
| fig.tight_layout() | |
| fig.savefig(fin / "randlabel.png", dpi=130) | |
| plt.close(fig) | |
| except Exception as e: # noqa: BLE001 | |
| print("figure skipped:", e) | |
| # ---------------------------------------------------------------- native 224 vs 256 at the selected block | |
| c224 = [] | |
| for r in r5: | |
| if not r["task"].endswith("_224") or r["split"] != "test": | |
| continue | |
| base = r["task"][:-4] | |
| if r["metric"] != {"nyu_depth": "rmse", "nyu_normals": "mean_angle", "ade_seg": "miou", "imagenet_cls": "top1"}[base]: | |
| continue | |
| s = sel.get((r["model"], base)) | |
| v256 = s[r["metric"]] if s else None | |
| c224.append(dict(model=r["model"], task=base, layer=int(r["layer"]), at256=v256, at224=r["mean"], | |
| ci224=(float(r["ci_lo"]), float(r["ci_hi"])), diff_224_minus_256=None if v256 is None else r["mean"] - v256)) | |
| (fin / "check224.json").write_text(json.dumps(c224, indent=1)) | |
| for x in lvm: | |
| print("MLP", x["size"], x["model"], x["task"], f"lin {x['linear']:.4f} mlp {x['mlp']:.4f} ({x['mlp_minus_linear']:+.4f})") | |
| for g in gaps: | |
| print("GAP", g["size"], g["task"], g["denoiser"], "-", g["ssl"], f"linear {g['linear_gap']:+.4f} mlp {g['mlp_gap']:+.4f}", | |
| f"[{g['mlp_gap_ci'][0]:+.4f}, {g['mlp_gap_ci'][1]:+.4f}]", g["mlp_verdict"]) | |
| for x in c224: | |
| print("224", x["model"], x["task"], f"b{x['layer']} 256 {x['at256']:.4f} 224 {x['at224']:.4f} ({x['diff_224_minus_256']:+.4f})") | |
| for x in rl: | |
| print("RL", x["model"], x["task"], f"b{x['layer']} null {x['null_label']} random {x['random_label']:.4f}") | |
| def spair(out): | |
| """SPair-71k: per model the (block, s) cell best on val; test PCK with CI; paired bootstrap of denoiser - SSL.""" | |
| rows = [r for r in read_rows(out / "p5") if r["task"] == "spair_pck"] | |
| best = {} | |
| for m in sorted({r["model"] for r in rows}): | |
| v = max((r for r in rows if r["model"] == m and r["split"] == "val"), key=lambda r: r["mean"]) | |
| t = find(rows, model=m, split="test", layer=v["layer"], s=v["s"]) | |
| best[m] = dict(model=m, layer=int(v["layer"]), s=v["s"], val=v["mean"], test=t["mean"], | |
| ci=(float(t["ci_lo"]), float(t["ci_hi"])), depth_rel=float(t["depth_rel"])) | |
| pw = [] | |
| for size in ("B", "L"): | |
| for d in DENOISERS[size]: | |
| for o in SSL[size] + ([d.replace("sit", "jit")] if d.startswith("sit") else []): | |
| if d not in best or o not in best: | |
| continue | |
| za, zb = (np.load(out / "perimage" / "p5" / f"spair_{m}.npz") for m in (d, o)) | |
| ca = za[f"s{best[d]['s']}_b{best[d]['layer']}"].astype(float) | |
| cb = zb[f"s{best[o]['s']}_b{best[o]['layer']}"].astype(float) | |
| tot = za["total"].astype(float) | |
| W = PR.boot_weights(len(tot), n_boot=2000, seed=4) | |
| diff = (W @ ca - W @ cb) / (W @ tot) | |
| lo, hi = np.percentile(diff, [2.5, 97.5]) | |
| pa, pb = ca.sum() / tot.sum(), cb.sum() / tot.sum() | |
| pw.append(dict(size=size, a=d, b=o, a_pck=pa, b_pck=pb, diff=pa - pb, ci=(float(lo), float(hi)), | |
| verdict="ngang nhau" if lo <= 0 <= hi else (f"{d} tốt hơn" if pa > pb else f"{o} tốt hơn"))) | |
| fin = out / "final" | |
| (fin / "spair_best.json").write_text(json.dumps(list(best.values()), indent=1)) | |
| (fin / "spair_pairwise.json").write_text(json.dumps(pw, indent=1)) | |
| for b in best.values(): | |
| print("SPAIR", b["model"], f"b{b['layer']} s={b['s']} test {b['test']:.4f} [{b['ci'][0]:.4f}, {b['ci'][1]:.4f}] rel {b['depth_rel']}") | |
| for p in pw: | |
| print("SPAIR-PW", p["size"], p["a"], "-", p["b"], f"{p['diff']:+.4f} [{p['ci'][0]:+.4f}, {p['ci'][1]:+.4f}]", p["verdict"]) | |
| if __name__ == "__main__" and len(sys.argv) > 2 and sys.argv[2] == "spair": | |
| spair(Path(sys.argv[1])) | |
| elif __name__ == "__main__": | |
| main() | |