"""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 @torch.no_grad() 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()