LamTNguyen's picture
set5: phase 5 (random labels, MLP probes, 224 px check, SPair-71k), final analysis, conclusions, reproduce notebook
1777460 verified
Raw History Blame Contribute Delete
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()