Download set5/code/phase3.py from LamTNguyen/repa-representation-probing: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/phase3.py
- Command line
-
hf download hf://datasets/LamTNguyen/repa-representation-probing/set5/code/phase3.py
-
curl -L -o phase3.py https://huggingface.co/datasets/LamTNguyen/repa-representation-probing/resolve/main/set5/code/phase3.py
11.9 kB
| """Set 5, phase 3: every B-size model and lower baseline, every main probe, all blocks, the full noise grid. | |
| Sources: SiT-B/2 (latent denoiser), JiT-B/16 (pixel denoiser), MAE-B, MoCo v3-B, DINO-B, iBOT-B, DeiT III-B, DINOv2-B | |
| (external-data reference), and the protocol's lower baselines (noisy VAE-latent patches, noisy pixel patches, clean pixel | |
| patches). Denoisers and noisy baselines at s in {0.05, 0.1, 0.3, 0.5, 0.7}; encoders on clean images. | |
| Probes (frozen features, 3 seeds = 3 validation folds): NYU depth and normals (ridge, one feature pass), ADE20K linear | |
| segmentation (soft-label CE per token), ImageNet classification (mean patch token; encoders also CLS, reference only). | |
| Units are (source, s, task-group) with a done marker under out/p3/ mirrored to Drive; a rerun skips finished units and a | |
| source whose units are all done is not even loaded. results_long.csv is rebuilt from the per-unit CSVs on the VM and on | |
| Drive (a new VM only holds its own units). Checkpoints are deleted once all units of their source are done. | |
| """ | |
| from __future__ import annotations | |
| import csv | |
| import json | |
| import os | |
| import subprocess | |
| 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_DRIVE, OUT_LOCAL, WORK, disk_free_gb, drive_ok, env_report, is_done, log, mark_done, # noqa: E402 | |
| sync_out, write_json) | |
| SIZE = os.environ.get("SET5_SIZE", "B") # B -> phase 3 (out/p3); L -> phase 4 (out/p4) | |
| PHASE_DIR = "p3" if SIZE == "B" else "p4" | |
| OUT = OUT_LOCAL / PHASE_DIR | |
| PER = OUT_LOCAL / "perimage" / PHASE_DIR | |
| OUT.mkdir(parents=True, exist_ok=True) | |
| PER.mkdir(parents=True, exist_ok=True) | |
| S_GRID = [0.05, 0.1, 0.3, 0.5, 0.7] | |
| TASKS = ("nyu", "seg", "cls") | |
| STEPS = {"sit_b": "800K steps (author, issue #42)", "jit_b": "600 ep (README)", "mae_b": "1600 ep", "mocov3_b": "300 ep", | |
| "dino_b": "400 ep", "ibot_b": "400 ep", "deit3_b": "800+20 ep", "dinov2_b": "LVD-142M (external)", | |
| "base_latent": "", "base_pixel": "", "base_pixel_clean": "", | |
| "sit_l": "800K steps (author, issue #42)", "jit_l": "600 ep (README)", "mae_l": "1600 ep", | |
| "mocov3_l": "300 ep (third-party reproduction)", "ibot_l": "250 ep", "deit3_l": "800+20 ep"} | |
| SOURCES_L = [ # protocol: no DINO v1-L; baselines are size independent (phase 3); DINOv2 reference is B only | |
| ("sit_l", lambda: M.SiTSource("L"), S_GRID), | |
| ("jit_l", lambda: M.JiTSource("L"), S_GRID), | |
| ("mae_l", lambda: M.EncoderSource("mae_l"), [None]), | |
| ("mocov3_l", lambda: M.EncoderSource("mocov3_l"), [None]), | |
| ("ibot_l", lambda: M.EncoderSource("ibot_l"), [None]), | |
| ("deit3_l", lambda: M.EncoderSource("deit3_l"), [None]), | |
| ] | |
| SOURCES = [ | |
| ("sit_b", lambda: M.SiTSource("B"), S_GRID), | |
| ("jit_b", lambda: M.JiTSource("B"), S_GRID), | |
| ("mae_b", lambda: M.EncoderSource("mae_b"), [None]), | |
| ("mocov3_b", lambda: M.EncoderSource("mocov3_b"), [None]), | |
| ("dino_b", lambda: M.EncoderSource("dino_b"), [None]), | |
| ("ibot_b", lambda: M.EncoderSource("ibot_b"), [None]), | |
| ("deit3_b", lambda: M.EncoderSource("deit3_b"), [None]), | |
| ("dinov2_b", lambda: M.EncoderSource("dinov2_b"), [None]), | |
| ("base_latent", lambda: M.PatchBaseline("latent"), S_GRID), | |
| ("base_pixel", lambda: M.PatchBaseline("pixel"), S_GRID), | |
| ("base_pixel_clean", lambda: M.PatchBaseline("pixel_clean"), [None]), | |
| ] | |
| def s_label(s): | |
| return "clean" if s is None else s | |
| def unit_rel(name, s, task): | |
| return f"{PHASE_DIR}/{name}_s{s_label(s)}_{task}.done" | |
| def blocks_of(src): | |
| """B: every block (12); L: every second block (12 points), as the protocol asks.""" | |
| n = src.n_blocks | |
| return list(range(1, n + 1)) if n <= 12 else list(range(2, n + 1, 2)) | |
| def make_fn(src, split, data, s, blocks, lat): | |
| if src.kind == "latent": | |
| def fn(idx): | |
| return src.tokens(torch.from_numpy(lat[idx]).cuda(), torch.from_numpy(D.noise(split, idx, "lat")).cuda(), | |
| s, blocks) | |
| elif src.kind == "pixel": | |
| def fn(idx): | |
| 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) | |
| else: | |
| def fn(idx): | |
| return src.tokens(data["img"][idx], blocks) | |
| return fn | |
| def pooled(src, fn, data, blocks, bs=250): | |
| """Mean patch token per block [+ CLS per block for encoders with a CLS token]: [L(+L), N, D] on GPU.""" | |
| n = len(data["img"]) | |
| with_cls = src.kind == "image" and getattr(src, "prefix", 0) > 0 | |
| L = len(blocks) | |
| X = torch.zeros(L * (2 if with_cls else 1), n, src.dim, device="cuda") | |
| for i0 in range(0, n, bs): | |
| idx = np.arange(i0, min(n, i0 + bs)) | |
| if with_cls: | |
| patches, cls = src.tokens(data["img"][idx], blocks, with_cls=True) | |
| for l, c in enumerate(cls): | |
| X[L + l, i0:i0 + len(idx)] = c | |
| else: | |
| patches = fn(idx) | |
| for l, p in enumerate(patches): | |
| X[l, i0:i0 + len(idx)] = p.mean(1) | |
| return X, with_cls | |
| def write_rows(path, rows, meta): | |
| with open(path, "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}) | |
| def run_unit(name, src, s, task, ctx): | |
| blocks = blocks_of(src) | |
| t0 = time.time() | |
| if task == "nyu": | |
| fn = make_fn(src, "nyu", ctx["nyu"], s, blocks, ctx["lat"].get("nyu")) | |
| rows, per, ch = PR.nyu_probe(fn, ctx["nyu"], ctx["design"], blocks) | |
| elif task == "seg": | |
| ftr = make_fn(src, "ade_train", ctx["ade_train"], s, blocks, ctx["lat"].get("ade_train")) | |
| fte = make_fn(src, "ade_val", ctx["ade_val"], s, blocks, ctx["lat"].get("ade_val")) | |
| # ADE train features of all chosen blocks are held in CPU RAM (bf16); split into passes when they would not fit | |
| n_pass = 2 if len(blocks) * src.dim > 12 * 768 else 1 | |
| chunks = [blocks[i::n_pass] for i in range(n_pass)] | |
| rows, per, ch = [], None, [] | |
| for cb in chunks: | |
| r_, p_, c_ = PR.seg_probe(make_fn(src, "ade_train", ctx["ade_train"], s, cb, ctx["lat"].get("ade_train")), | |
| make_fn(src, "ade_val", ctx["ade_val"], s, cb, ctx["lat"].get("ade_val")), | |
| ctx["ade_train"], ctx["ade_val"], cb) | |
| rows += r_ | |
| ch += c_ | |
| if per is None: | |
| per = {"ade_counts": np.zeros((len(blocks),) + p_["ade_counts"].shape[1:], np.int32)} | |
| for j, b in enumerate(cb): | |
| per["ade_counts"][blocks.index(b)] = p_["ade_counts"][j] | |
| else: | |
| tr, ev = ctx["inet_train"], ctx["inet_eval"] | |
| Xtr, with_cls = pooled(src, make_fn(src, "inet_train", tr, s, blocks, ctx["lat"].get("inet_train")), tr, blocks) | |
| Xte, _ = pooled(src, make_fn(src, "inet_eval", ev, s, blocks, ctx["lat"].get("inet_eval")), ev, blocks) | |
| names = [f"b{b}" for b in blocks] + ([f"b{b}_cls" for b in blocks] if with_cls else []) | |
| 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(), names) | |
| del Xtr, Xte | |
| for r in rows: | |
| nm = r["layer"] | |
| r["layer"] = int(nm.split("_")[0][1:]) | |
| if nm.endswith("_cls"): | |
| r["metric"] = r["metric"].replace("top1", "top1_cls") | |
| per = {"correct": per_c.astype(np.int8)} | |
| nb = src.n_blocks | |
| for r in rows: | |
| r.update(s=s_label(s), depth_rel=0.0 if name.startswith("base_") else round(r["layer"] / nb, 4)) | |
| tag = f"{name}_s{s_label(s)}_{task}" | |
| group = getattr(src, "group", "") | |
| write_rows(OUT / f"{tag}_rows.csv", rows, dict(model=name, method=group, steps=STEPS.get(name, ""), size=SIZE, | |
| group=group)) | |
| np.savez_compressed(PER / f"{tag}.npz", **per) | |
| write_json(OUT / f"{tag}_choices.json", ch) | |
| key = {"nyu": ("nyu_depth", "rmse"), "seg": ("ade_seg", "miou"), "cls": ("imagenet_cls", "top1")}[task] | |
| best = [(r["layer"], round(r["mean"], 4)) for r in rows if (r["task"], r["metric"]) == key] | |
| log(f"[{tag}] {time.time() - t0:.0f}s; {key[1]} by block: {best}") | |
| torch.cuda.empty_cache() | |
| mark_done(unit_rel(name, s, task), {"seconds": round(time.time() - t0), "ckpt": getattr(src, "ckpt", None)}) | |
| def summarise(): | |
| """results_long.csv from every per-unit CSV, on the VM or on Drive (VM copy wins).""" | |
| files = {} | |
| if drive_ok() and (OUT_DRIVE / PHASE_DIR).is_dir(): | |
| files.update({p.name: p for p in (OUT_DRIVE / PHASE_DIR).glob("*_rows.csv")}) | |
| files.update({p.name: p for p in OUT.glob("*_rows.csv")}) | |
| rows = [] | |
| for nm in sorted(files): | |
| with open(files[nm]) 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 from {len(files)} unit files") | |
| def prepare(ctx): | |
| logs = WORK / "logs" | |
| logs.mkdir(exist_ok=True) | |
| jobs = [] | |
| if not (D.CACHE / "inet_train.done").exists(): # CPU download/decoding runs beside the NYU/ADE preparation | |
| jobs.append(subprocess.Popen([sys.executable, str(CODE / "data5.py"), "val,train"], | |
| stdout=open(logs / "inet_prep.log", "a"), stderr=subprocess.STDOUT)) | |
| D.prepare_nyu() | |
| D.prepare_normals() | |
| D.prepare_ade() | |
| for j in jobs: | |
| if j.wait() != 0: | |
| raise RuntimeError("ImageNet preparation failed (logs/inet_prep.log)") | |
| for sp in ("nyu", "ade_train", "ade_val", "inet_train", "inet_eval"): | |
| ctx[sp] = D.load(sp) | |
| vae = {} | |
| def get_vae(): | |
| vae.setdefault("v", M.VAE()) | |
| return vae["v"] | |
| ctx["lat"] = {sp: M.latents(sp, ctx[sp]["img"], get_vae, D.CACHE) for sp in | |
| ("nyu", "ade_train", "ade_val", "inet_train", "inet_eval")} | |
| vae.clear() | |
| torch.cuda.empty_cache() | |
| dp = D.CACHE / "nyu_designs.pt" | |
| if not dp.exists(): | |
| tr = np.flatnonzero(ctx["nyu"]["split"] == 0) | |
| torch.save(PR.nyu_designs(ctx["nyu"], tr), dp) | |
| ctx["design"] = torch.load(dp) | |
| def main(): | |
| only = sys.argv[1].split(",") if len(sys.argv) > 1 else None | |
| M.no_tf32() | |
| smi, df = env_report() | |
| print(smi, df, flush=True) | |
| write_json(OUT / "env.json", {"nvidia_smi": smi, "df": df, "disk_free_gb": round(disk_free_gb(), 1), | |
| "torch": torch.__version__, "gpu": torch.cuda.get_device_name()}) | |
| ctx = {} | |
| prepare(ctx) | |
| summarise() | |
| sync_out() | |
| for name, ctor, svals in (SOURCES if SIZE == "B" else SOURCES_L): | |
| if only and name not in only: | |
| continue | |
| todo = [(s, t) for s in svals for t in TASKS if not is_done(unit_rel(name, s, t))] | |
| if not todo: | |
| continue | |
| src = ctor() | |
| log(f"[{name}] loaded; {len(todo)} units to run") | |
| for s, t in todo: | |
| run_unit(name, src, s, t, ctx) | |
| summarise() | |
| sync_out() | |
| path = getattr(src, "path", None) | |
| src.close() | |
| del src | |
| torch.cuda.empty_cache() | |
| if path and Path(path).exists() and Path(path).is_file(): | |
| os.remove(path) # protocol: delete a checkpoint once its model is probed | |
| log(f"[{name}] checkpoint deleted") | |
| summarise() | |
| sync_out() | |
| log(f"PHASE3 FINISHED (size {SIZE})") | |
| if __name__ == "__main__": | |
| main() | |