set5: phase 5 (random labels, MLP probes, 224 px check, SPair-71k), final analysis, conclusions, reproduce notebook
1777460 verified Download set5/code/phase5.py from LamTNguyen/repa-representation-probing: direct link, hf CLI and curl.
- Browser
- Download file 13.6 kB
-
https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/phase5.py
- Command line
-
hf download hf://datasets/LamTNguyen/repa-representation-probing/set5/code/phase5.py
-
curl -L -o phase5.py https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/phase5.py
13.6 kB
| """Set 5, phase 5: side test with random labels, 2-layer MLP probes, native-224 check of the encoders. | |
| rl random labels vs null label (SiT-B/2, JiT-B/16 only): NYU depth (+ normals) and ImageNet classification with | |
| every image conditioned on one fixed random class (never its true ImageNet class), probe trained and tested in | |
| that mode, every block, at the noise level selected in phase 3 for that task. | |
| mlp 2-layer token-wise MLP (hidden 1024, GELU, AdamW, weight decay chosen on validation) at the (block, s) cell | |
| selected on validation in phases 3/4 for depth, normals and ADE20K, for every B and L model. | |
| r224 every patch-16 encoder rerun at its native 224 px (own 14x14 positional embedding, 196 tokens) at the block | |
| selected for each task, to measure the effect of running encoders at 256 px with interpolated embeddings. | |
| Selections come from sel_p3.json / sel_p4.json (= p3/p4 analysis/main_table.json). Resumable units under out/p5/. | |
| """ | |
| from __future__ import annotations | |
| import csv | |
| import json | |
| import os | |
| import sys | |
| import time | |
| from pathlib import Path | |
| import numpy as np | |
| import torch | |
| CODE = Path(__file__).resolve().parent | |
| sys.path.insert(0, str(CODE)) | |
| import data5 as D # noqa: E402 | |
| import models5 as M # noqa: E402 | |
| import probes5 as PR # noqa: E402 | |
| from common5 import OUT_LOCAL, WORK, env_report, is_done, log, mark_done, sync_out, write_json # noqa: E402 | |
| OUT = OUT_LOCAL / "p5" | |
| PER = OUT_LOCAL / "perimage" / "p5" | |
| OUT.mkdir(parents=True, exist_ok=True) | |
| PER.mkdir(parents=True, exist_ok=True) | |
| SEL = {} | |
| for f in ("sel_p3.json", "sel_p4.json"): | |
| for r in json.loads((CODE / f).read_text()): | |
| SEL[(r["model"], r["task"])] = r | |
| CTOR = {"sit_b": lambda: M.SiTSource("B"), "jit_b": lambda: M.JiTSource("B"), | |
| "sit_l": lambda: M.SiTSource("L"), "jit_l": lambda: M.JiTSource("L")} | |
| ENC_B = ["mae_b", "mocov3_b", "dino_b", "ibot_b", "deit3_b", "dinov2_b"] | |
| ENC_L = ["mae_l", "mocov3_l", "ibot_l", "deit3_l"] | |
| MODELS = ["sit_b", "jit_b"] + ENC_B + ["sit_l", "jit_l"] + ENC_L | |
| RL_MODELS = ("sit_b", "jit_b") | |
| def s_val(s): | |
| return None if s in (None, "clean") else float(s) | |
| def make_fn(src, split, data, s, blocks, lat, labels=False): | |
| true = data.get("lbl") if split.startswith("inet") else None | |
| if src.kind == "latent": | |
| def fn(idx): | |
| y = torch.from_numpy(D.random_labels(split, idx, None if true is None else true[idx])).cuda() if labels else None | |
| return src.tokens(torch.from_numpy(lat[idx]).cuda(), torch.from_numpy(D.noise(split, idx, "lat")).cuda(), | |
| s, blocks, y=y) | |
| elif src.kind == "pixel": | |
| def fn(idx): | |
| y = torch.from_numpy(D.random_labels(split, idx, None if true is None else true[idx])).cuda() if labels else None | |
| x = torch.from_numpy(np.ascontiguousarray(data["img"][idx])).cuda().permute(0, 3, 1, 2).float() / 127.5 - 1 | |
| return src.tokens(x, torch.from_numpy(D.noise(split, idx, "pix")).cuda(), s, blocks, y=y) | |
| else: | |
| def fn(idx): | |
| return src.tokens(data["img"][idx], blocks) | |
| return fn | |
| def pooled(src, fn, data, blocks, bs=250): | |
| n = len(data["img"]) | |
| X = torch.zeros(len(blocks), n, src.dim, device="cuda") | |
| for i0 in range(0, n, bs): | |
| idx = np.arange(i0, min(n, i0 + bs)) | |
| for l, p in enumerate(fn(idx)): | |
| X[l, i0:i0 + len(idx)] = p.mean(1) | |
| return X | |
| def nyu_features(fn, n=1449, bs=32): | |
| out = None | |
| for i0 in range(0, n, bs): | |
| f = fn(np.arange(i0, min(n, i0 + bs)))[0] | |
| if out is None: | |
| out = torch.empty(n, *f.shape[1:], device="cuda") | |
| out[i0:i0 + f.shape[0]] = f | |
| return out | |
| def write_unit(tag, rows, per, ch, name, size, extra=None): | |
| meta = dict(model=name, method=SEL.get((name, "nyu_depth"), {}).get("group", ""), size=size, | |
| group=SEL.get((name, "nyu_depth"), {}).get("group", "")) | |
| with open(OUT / f"{tag}_rows.csv", "w", newline="") as f: | |
| w = csv.DictWriter(f, fieldnames=PR.FIELDS) | |
| w.writeheader() | |
| for r in rows: | |
| w.writerow({**{k: "" for k in PR.FIELDS}, **meta, **r}) | |
| np.savez_compressed(PER / f"{tag}.npz", **per) | |
| write_json(OUT / f"{tag}_choices.json", {"choices": ch, **(extra or {})}) | |
| def nblocks(name): | |
| return 24 if name.endswith("_l") else 12 | |
| def run_mlp(name, src, ctx): | |
| size = "L" if name.endswith("_l") else "B" | |
| for task, key in (("depth", "nyu_depth"), ("normals", "nyu_normals")): | |
| tag = f"mlp_{name}_{task}" | |
| if is_done(f"p5/{tag}.done"): | |
| continue | |
| t0 = time.time() | |
| sel = SEL[(name, key)] | |
| s = s_val(sel["s"]) | |
| Fa = nyu_features(make_fn(src, "nyu", ctx["nyu"], s, [sel["layer"]], ctx["lat"].get("nyu"))) | |
| rows, per, ch = PR.mlp_nyu_probe(Fa, ctx["nyu"], task) | |
| del Fa | |
| for r in rows: | |
| r.update(layer=sel["layer"], s=sel["s"], depth_rel=round(sel["layer"] / nblocks(name), 4)) | |
| write_unit(tag, rows, per, ch, name, size, {"cell": sel}) | |
| log(f"[{tag}] {time.time() - t0:.0f}s " + ", ".join(f"{r['metric']} {r['mean']:.4f}" for r in rows | |
| if r["metric"] in ("rmse", "mean_angle"))) | |
| mark_done(f"p5/{tag}.done") | |
| tag = f"mlp_{name}_seg" | |
| if not is_done(f"p5/{tag}.done"): | |
| t0 = time.time() | |
| sel = SEL[(name, "ade_seg")] | |
| s = s_val(sel["s"]) | |
| rows, per, ch = PR.mlp_seg_probe( | |
| make_fn(src, "ade_train", ctx["ade_train"], s, [sel["layer"]], ctx["lat"].get("ade_train")), | |
| make_fn(src, "ade_val", ctx["ade_val"], s, [sel["layer"]], ctx["lat"].get("ade_val")), | |
| ctx["ade_train"], ctx["ade_val"]) | |
| for r in rows: | |
| r.update(layer=sel["layer"], s=sel["s"], depth_rel=round(sel["layer"] / nblocks(name), 4)) | |
| write_unit(tag, rows, per, ch, name, size, {"cell": sel}) | |
| log(f"[{tag}] {time.time() - t0:.0f}s miou {rows[0]['mean']:.4f}") | |
| mark_done(f"p5/{tag}.done") | |
| def run_rl(name, src, ctx): | |
| blocks = list(range(1, 13)) | |
| tag = f"rl_{name}_nyu" | |
| if not is_done(f"p5/{tag}.done"): | |
| t0 = time.time() | |
| sel = SEL[(name, "nyu_depth")] | |
| rows, per, ch = PR.nyu_probe(make_fn(src, "nyu", ctx["nyu"], s_val(sel["s"]), blocks, ctx["lat"].get("nyu"), | |
| labels=True), ctx["nyu"], ctx["design16"], blocks) | |
| for r in rows: | |
| r.update(task=r["task"] + "_randlabel", s=sel["s"], depth_rel=round(r["layer"] / 12, 4)) | |
| write_unit(tag, rows, per, ch, name, "B", {"s": sel["s"]}) | |
| log(f"[{tag}] {time.time() - t0:.0f}s rmse by block: " + str([(r["layer"], round(r["mean"], 4)) for r in rows | |
| if r["metric"] == "rmse"])) | |
| mark_done(f"p5/{tag}.done") | |
| tag = f"rl_{name}_cls" | |
| if not is_done(f"p5/{tag}.done"): | |
| t0 = time.time() | |
| sel = SEL[(name, "imagenet_cls")] | |
| s = s_val(sel["s"]) | |
| tr, ev = ctx["inet_train"], ctx["inet_eval"] | |
| Xtr = pooled(src, make_fn(src, "inet_train", tr, s, blocks, ctx["lat"].get("inet_train"), labels=True), tr, blocks) | |
| Xte = pooled(src, make_fn(src, "inet_eval", ev, s, blocks, ctx["lat"].get("inet_eval"), labels=True), ev, blocks) | |
| rows, per_c, ch = PR.cls_probe(Xtr, torch.from_numpy(tr["lbl"]).cuda(), torch.from_numpy(tr["fold"]).cuda(), | |
| Xte, torch.from_numpy(ev["lbl"]).cuda(), [f"b{b}" for b in blocks]) | |
| del Xtr, Xte | |
| for r in rows: | |
| r.update(layer=int(r["layer"][1:]), task="imagenet_cls_randlabel", s=sel["s"]) | |
| r["depth_rel"] = round(r["layer"] / 12, 4) | |
| write_unit(tag, rows, {"correct": per_c.astype(np.int8)}, ch, name, "B", {"s": sel["s"]}) | |
| log(f"[{tag}] {time.time() - t0:.0f}s top1 by block: " + str([(r["layer"], round(r["mean"], 4)) for r in rows | |
| if r["metric"] == "top1"])) | |
| mark_done(f"p5/{tag}.done") | |
| def run_r224(name, ctx): | |
| units = [u for u in ("nyu", "seg", "cls") if not is_done(f"p5/r224_{name}_{u}.done")] | |
| if not units: | |
| return | |
| PR.GRID = 14 | |
| try: | |
| src = M.EncoderSource(name, native=True) | |
| assert src.grid == 14, src.grid | |
| size = "L" if name.endswith("_l") else "B" | |
| if "nyu" in units: | |
| t0 = time.time() | |
| bd, bn = SEL[(name, "nyu_depth")]["layer"], SEL[(name, "nyu_normals")]["layer"] | |
| blocks = sorted({bd, bn}) | |
| rows, per, ch = PR.nyu_probe(make_fn(src, "nyu", ctx["nyu"], None, blocks, None), ctx["nyu"], | |
| ctx["design14"], blocks) | |
| rows = [dict(r, task=r["task"] + "_224") for r in rows | |
| if (r["task"] == "nyu_depth" and r["layer"] == bd) or (r["task"] == "nyu_normals" and r["layer"] == bn)] | |
| for r in rows: | |
| r.update(s="clean", depth_rel=round(r["layer"] / nblocks(name), 4)) | |
| write_unit(f"r224_{name}_nyu", rows, per, ch, name, size, {"blocks": blocks}) | |
| log(f"[r224_{name}_nyu] {time.time() - t0:.0f}s " + ", ".join(f"{r['task']} {r['metric']} {r['mean']:.4f}" | |
| for r in rows if r["metric"] in ("rmse", "mean_angle"))) | |
| mark_done(f"p5/r224_{name}_nyu.done") | |
| if "seg" in units: | |
| t0 = time.time() | |
| b = SEL[(name, "ade_seg")]["layer"] | |
| rows, per, ch = PR.seg_probe(make_fn(src, "ade_train", ctx["ade_train"], None, [b], None), | |
| make_fn(src, "ade_val", ctx["ade_val"], None, [b], None), | |
| ctx["ade_train"], ctx["ade_val"], [b]) | |
| for r in rows: | |
| r.update(task="ade_seg_224", s="clean", depth_rel=round(b / nblocks(name), 4)) | |
| write_unit(f"r224_{name}_seg", rows, per, ch, name, size) | |
| log(f"[r224_{name}_seg] {time.time() - t0:.0f}s miou {rows[0]['mean']:.4f}") | |
| mark_done(f"p5/r224_{name}_seg.done") | |
| if "cls" in units: | |
| t0 = time.time() | |
| b = SEL[(name, "imagenet_cls")]["layer"] | |
| tr, ev = ctx["inet_train"], ctx["inet_eval"] | |
| Xtr = pooled(src, make_fn(src, "inet_train", tr, None, [b], None), tr, [b]) | |
| Xte = pooled(src, make_fn(src, "inet_eval", ev, None, [b], None), ev, [b]) | |
| rows, per_c, ch = PR.cls_probe(Xtr, torch.from_numpy(tr["lbl"]).cuda(), torch.from_numpy(tr["fold"]).cuda(), | |
| Xte, torch.from_numpy(ev["lbl"]).cuda(), [f"b{b}"]) | |
| for r in rows: | |
| r.update(layer=b, task="imagenet_cls_224", s="clean", depth_rel=round(b / nblocks(name), 4)) | |
| write_unit(f"r224_{name}_cls", rows, {"correct": per_c.astype(np.int8)}, ch, name, size) | |
| log(f"[r224_{name}_cls] {time.time() - t0:.0f}s top1 {rows[0]['mean']:.4f}") | |
| mark_done(f"p5/r224_{name}_cls.done") | |
| path = src.path | |
| src.close() | |
| return path | |
| finally: | |
| PR.GRID = 16 | |
| def summarise(): | |
| rows = [] | |
| for p in sorted(OUT.glob("*_rows.csv")): | |
| with open(p) as f: | |
| rows += list(csv.DictReader(f)) | |
| with open(OUT / "results_long.csv", "w", newline="") as f: | |
| w = csv.DictWriter(f, fieldnames=PR.FIELDS) | |
| w.writeheader() | |
| w.writerows(rows) | |
| log(f"[summary] {len(rows)} rows") | |
| def main(): | |
| M.no_tf32() | |
| smi, df = env_report() | |
| write_json(OUT / "env.json", {"nvidia_smi": smi, "df": df, "torch": torch.__version__, | |
| "gpu": torch.cuda.get_device_name()}) | |
| ctx = {sp: D.load(sp) for sp in ("nyu", "ade_train", "ade_val", "inet_train", "inet_eval")} | |
| ctx["lat"] = {sp: np.load(D.CACHE / f"{sp}_lat.npy") for sp in ("nyu", "ade_train", "ade_val", "inet_train", | |
| "inet_eval")} | |
| ctx["design16"] = torch.load(D.CACHE / "nyu_designs.pt") | |
| d14 = D.CACHE / "nyu_designs14.pt" | |
| if not d14.exists(): | |
| PR.GRID = 14 | |
| torch.save(PR.nyu_designs(ctx["nyu"], np.flatnonzero(ctx["nyu"]["split"] == 0)), d14) | |
| PR.GRID = 16 | |
| ctx["design14"] = torch.load(d14) | |
| only = sys.argv[1].split(",") if len(sys.argv) > 1 else None | |
| for name in MODELS: | |
| if only and name not in only: | |
| continue | |
| need = [f"mlp_{name}_{t}" for t in ("depth", "normals", "seg")] | |
| if name in RL_MODELS: | |
| need += [f"rl_{name}_nyu", f"rl_{name}_cls"] | |
| paths = [] | |
| if not all(is_done(f"p5/{u}.done") for u in need): | |
| src = CTOR[name]() if name in CTOR else M.EncoderSource(name) | |
| log(f"[{name}] loaded") | |
| run_mlp(name, src, ctx) | |
| if name in RL_MODELS: | |
| run_rl(name, src, ctx) | |
| paths.append(src.path) | |
| src.close() | |
| del src | |
| torch.cuda.empty_cache() | |
| if name in ENC_B + ENC_L and name != "dinov2_b": # DINOv2/14 already runs at its native 224 px | |
| p = run_r224(name, ctx) | |
| if p: | |
| paths.append(p) | |
| summarise() | |
| sync_out() | |
| for p in set(paths): | |
| if p and Path(p).is_file(): | |
| os.remove(p) | |
| log(f"[{name}] checkpoint deleted") | |
| summarise() | |
| log("PHASE5 FINISHED") | |
| if __name__ == "__main__": | |
| main() | |