LamTNguyen's picture
set5: phase 2 (pilot) results, report and code
c8420ab verified
Raw History Blame Contribute Delete
12.9 kB
"""Set 5, phase 2 (pilot): SiT-B/2, JiT-B/16, MAE-B; NYU depth only, two noise levels, three blocks; plus the
pilot checks the protocol asks for.
1. samples from SiT-B and JiT-B through the same loaders used for features (grids);
2. prediction error vs s on 256 ImageNet val images (1 per class, classes 0-255), with the mapping used (t = 1 - s)
and the opposite one (t = s): the used mapping must give an error that grows with s and is far below the
opposite mapping at low s (confirms the time convention of the inputs fed to the probes);
3. NYU depth (ridge, 3 seeds): SiT-B and JiT-B at s in {0.1, 0.5}, MAE-B on clean images; blocks 4, 8, 12;
4. ImageNet classification, MoCo v3-B vs MAE-B (mean patch token at blocks 4, 8, 12; CLS at block 12 as reference).
Resumable: each unit writes out/pilot/<unit>.done (mirrored to Drive) and is skipped when present.
ImageNet train (gated) is prepared by a CPU subprocess that waits for the HF token file; GPU work does not wait for it
until step 4.
"""
from __future__ import annotations
import csv
import json
import subprocess
import sys
import time
from pathlib import Path
import numpy as np
import torch
from PIL import Image
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, disk_free_gb, env_report, is_done, log, mark_done, sync_out, write_json # noqa: E402
OUT = OUT_LOCAL / "pilot"
PER = OUT_LOCAL / "perimage" / "pilot" # per-image metrics (derived from NYU / ImageNet): Drive only, never pushed to HF
OUT.mkdir(parents=True, exist_ok=True)
PER.mkdir(parents=True, exist_ok=True)
BLOCKS = [4, 8, 12]
S_PILOT = [0.1, 0.5]
S_CHECK = [0.02, 0.05, 0.1, 0.2, 0.3, 0.5, 0.7, 0.9, 0.98]
GRID_CLASSES = [88, 207, 279, 291, 360, 387, 417, 812, 933, 963, 970, 980, 1, 130, 323, 954]
STEPS = {"sit_b": "800K steps (author, issue #42)", "jit_b": "600 ep (README)", "mae_b": "1600 ep",
"mocov3_b": "300 ep"}
def save_grid(u8, path): # [16, 3, H, W] or [16, H, W, 3] uint8
a = u8.permute(0, 2, 3, 1).cpu().numpy() if u8.shape[1] == 3 else np.asarray(u8)
rows = [np.concatenate(a[r * 4:(r + 1) * 4], 1) for r in range(4)]
Image.fromarray(np.concatenate(rows, 0)).save(path)
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 check_rows(model, kind, s, mapping, err, ident=None, err_v=None):
return dict(model=model, kind=kind, s=s, mapping=mapping, rel_err_x0=err, rel_err_identity=ident,
rel_err_velocity=err_v)
def check_subset(ev):
return np.arange(256) * D.EVAL_PER_CLASS # inet_eval is class-major: first image of classes 0..255
# ----------------------------------------------------------------------------- denoisers
@torch.no_grad()
def unit_sit(nyu, ev, nyu_lat):
rel = "pilot/sit_b.done"
if is_done(rel):
return
t0 = time.time()
src = M.SiTSource("B")
vae = M.VAE()
save_grid(src.sample_grid(vae, GRID_CLASSES), OUT / "sit_B_grid_sde250_nocfg.png")
# time convention check (x0 estimate from the velocity: x0 = x_s + s * v)
idx = check_subset(ev)
x0 = vae.encode(ev["img"][idx])
eps = torch.from_numpy(D.noise("inet_eval", idx, "lat")).cuda()
del vae
torch.cuda.empty_cache()
var, chk = float(x0.var()), []
for s in S_CHECK:
xs = (1 - s) * x0 + s * eps
ident = float(((xs - x0) ** 2).mean()) / var
for mapping, t in (("t=1-s (used)", 1 - s), ("t=s (opposite)", s)):
v = torch.cat([src.predict(xs[i:i + 64], t) for i in range(0, len(xs), 64)])
x0h = xs + s * v
chk.append(check_rows("sit_b", "latent velocity", s, mapping, float(((x0h - x0) ** 2).mean()) / var,
ident, float(((v - (x0 - eps)) ** 2).mean() / ((x0 - eps) ** 2).mean())))
write_json(OUT / "sit_b_time_check.json", chk)
rows = depth_for(src, nyu, lambda idx, s: src.tokens(torch.from_numpy(nyu_lat[idx]).cuda(),
torch.from_numpy(D.noise("nyu", idx, "lat")).cuda(), s, BLOCKS))
meta = dict(model="sit_b", method="denoise_latent", steps=STEPS["sit_b"], size="B", group="denoise_latent")
write_rows(OUT / "sit_b_rows.csv", rows, meta)
write_json(OUT / "sit_b_info.json", {"ckpt": src.ckpt, "seconds": round(time.time() - t0), "blocks": BLOCKS,
"s": S_PILOT, "n_blocks": src.n_blocks})
src.close()
mark_done(rel)
@torch.no_grad()
def unit_jit(nyu, ev):
rel = "pilot/jit_b.done"
if is_done(rel):
return
t0 = time.time()
src = M.JiTSource("B")
for cfg in (1.0, M.JiTSource.CFG["B"]):
save_grid(src.sample_grid(GRID_CLASSES, cfg), OUT / f"jit_B_grid_heun50_cfg{cfg}.png")
idx = check_subset(ev)
x = torch.from_numpy(np.ascontiguousarray(ev["img"][idx])).cuda().permute(0, 3, 1, 2).float() / 127.5 - 1
eps = torch.from_numpy(D.noise("inet_eval", idx, "pix")).cuda()
var, chk = float(x.var()), []
for s in S_CHECK:
z = (1 - s) * x + s * src.noise_scale * eps
ident = float(((z - x) ** 2).mean()) / var
for mapping, t in (("t=1-s (used)", 1 - s), ("t=s (opposite)", s)):
xp = torch.cat([src.predict(z[i:i + 64], t) for i in range(0, len(z), 64)])
chk.append(check_rows("jit_b", "pixel x-prediction", s, mapping, float(((xp - x) ** 2).mean()) / var, ident))
write_json(OUT / "jit_b_time_check.json", chk)
def feats(idx, s):
xi = torch.from_numpy(np.ascontiguousarray(nyu["img"][idx])).cuda().permute(0, 3, 1, 2).float() / 127.5 - 1
return src.tokens(xi, torch.from_numpy(D.noise("nyu", idx, "pix")).cuda(), s, BLOCKS)
rows = depth_for(src, nyu, feats)
meta = dict(model="jit_b", method="denoise_pixel", steps=STEPS["jit_b"], size="B", group="denoise_pixel")
write_rows(OUT / "jit_b_rows.csv", rows, meta)
write_json(OUT / "jit_b_info.json", {"ckpt": src.ckpt, "seconds": round(time.time() - t0), "blocks": BLOCKS,
"s": S_PILOT, "n_blocks": src.n_blocks, "in_context": [src.ic_start, src.ic_len]})
src.close()
mark_done(rel)
def depth_for(src, nyu, feats_s):
rows = []
for s in S_PILOT:
r, per, ch = PR.depth_probe(lambda idx: feats_s(idx, s), nyu, BLOCKS)
for x in r:
x.update(s=s, depth_rel=round(x["layer"] / src.n_blocks, 4))
rows += r
np.savez_compressed(PER / f"{src.name}_depth_s{s}.npz", **per)
write_json(OUT / f"{src.name}_depth_s{s}_choices.json", ch)
log(f"[{src.name}] depth s={s}: " + ", ".join(f"b{x['layer']} rmse {x['mean']:.3f}" for x in r
if x["metric"] == "rmse"))
return rows
# ----------------------------------------------------------------------------- encoders
@torch.no_grad()
def unit_mae_depth(nyu):
rel = "pilot/mae_b_depth.done"
if is_done(rel):
return
t0 = time.time()
src = M.EncoderSource("mae_b")
rows, per, ch = PR.depth_probe(lambda idx: src.tokens(nyu["img"][idx], BLOCKS), nyu, BLOCKS)
for x in rows:
x.update(s="clean", depth_rel=round(x["layer"] / src.n_blocks, 4))
np.savez_compressed(PER / "mae_b_depth_clean.npz", **per)
write_json(OUT / "mae_b_depth_choices.json", ch)
write_rows(OUT / "mae_b_depth_rows.csv", rows, dict(model="mae_b", method="masked", steps=STEPS["mae_b"], size="B",
group="masked"))
write_json(OUT / "mae_b_info.json", {"ckpt": src.ckpt, "seconds": round(time.time() - t0)})
log("[mae_b] depth: " + ", ".join(f"b{x['layer']} rmse {x['mean']:.3f}" for x in rows if x["metric"] == "rmse"))
src.close()
mark_done(rel)
@torch.no_grad()
def pooled(src, img, bs=250):
L = len(BLOCKS) + 1
X = torch.zeros(L, len(img), src.dim, device="cuda")
for i in range(0, len(img), bs):
patches, cls = src.tokens(img[i:i + bs], BLOCKS, with_cls=True)
for l, p in enumerate(patches):
X[l, i:i + bs] = p.mean(1)
X[-1, i:i + bs] = cls[-1]
return X
def unit_cls(name, ev):
rel = f"pilot/cls_{name}.done"
if is_done(rel):
return
tr = D.load("inet_train")
t0 = time.time()
src = M.EncoderSource(name)
Xtr, Xte = pooled(src, tr["img"]), pooled(src, ev["img"])
src.close()
names = [f"b{b}_meanpatch" for b in BLOCKS] + [f"b{BLOCKS[-1]}_cls"]
rows, per, 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)
for x in rows:
b = int(x["layer"].split("_")[0][1:])
x.update(s="clean", depth_rel=round(b / 12, 4))
np.savez_compressed(PER / f"{name}_cls.npz", correct=per)
write_json(OUT / f"{name}_cls_choices.json", ch)
write_rows(OUT / f"{name}_cls_rows.csv", rows, dict(model=name, method=src.group, steps=STEPS[name], size="B",
group=src.group))
log(f"[{name}] cls: " + ", ".join(f"{x['layer']} {x['mean']:.4f}" for x in rows if x["metric"] == "top1"))
mark_done(rel, {"seconds": round(time.time() - t0)})
# ----------------------------------------------------------------------------- summary
def summarise():
rows = []
for p in sorted(OUT.glob("*_rows.csv")):
rows += list(csv.DictReader(open(p)))
with open(OUT / "results_long.csv", "w", newline="") as f:
w = csv.DictWriter(f, fieldnames=PR.FIELDS)
w.writeheader()
w.writerows(rows)
out = {}
for m in ("sit_b", "jit_b"):
p = OUT / f"{m}_time_check.json"
if not p.exists():
continue
chk = json.loads(p.read_text())
used = [c for c in chk if c["mapping"].startswith("t=1-s")]
opp = {c["s"]: c["rel_err_x0"] for c in chk if c["mapping"].startswith("t=s")}
errs = [c["rel_err_x0"] for c in used]
out[m] = dict(monotone=bool(all(b >= a - 1e-3 for a, b in zip(errs, errs[1:]))),
used_below_opposite_s_le_0_3=bool(all(c["rel_err_x0"] < opp[c["s"]] for c in used if c["s"] <= 0.3)),
used_err=dict(zip([c["s"] for c in used], errs)), opposite_err=opp)
top1 = {(r["model"], r["layer"]): float(r["mean"]) for r in rows
if r["task"] == "imagenet_cls" and r["metric"] == "top1"}
if ("mocov3_b", "b12_meanpatch") in top1 and ("mae_b", "b12_meanpatch") in top1:
out["cls_mocov3_gt_mae_b12"] = top1[("mocov3_b", "b12_meanpatch")] > top1[("mae_b", "b12_meanpatch")]
out["top1"] = {f"{k[0]}:{k[1]}": v for k, v in top1.items()}
write_json(OUT / "pilot_checks.json", out)
log("[summary] " + json.dumps(out))
def main():
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()})
log(f"disk free {disk_free_gb():.0f} GB")
logs = WORK / "logs"
logs.mkdir(exist_ok=True)
train_job = None
if not (D.CACHE / "inet_train.done").exists(): # CPU-only download/decoding, overlaps the GPU units
train_job = subprocess.Popen([sys.executable, str(CODE / "data5.py"), "train"],
stdout=open(logs / "inet_train.log", "a"), stderr=subprocess.STDOUT)
D.prepare_imagenet_val()
ev = D.load("inet_eval")
depth_units = ("pilot/sit_b.done", "pilot/jit_b.done", "pilot/mae_b_depth.done")
if not all(is_done(u) for u in depth_units): # a new VM after the depth units finished skips NYU entirely
D.prepare_nyu()
nyu = D.load("nyu")
vae_holder = {}
def get_vae():
vae_holder.setdefault("v", M.VAE())
return vae_holder["v"]
nyu_lat = M.latents("nyu", nyu["img"], get_vae, D.CACHE)
vae_holder.clear()
torch.cuda.empty_cache()
for unit in (lambda: unit_sit(nyu, ev, nyu_lat), lambda: unit_jit(nyu, ev), lambda: unit_mae_depth(nyu)):
unit()
summarise()
sync_out()
else:
log("depth units already done (Drive markers); skipping NYU")
if train_job is not None and train_job.wait() != 0:
raise RuntimeError("ImageNet train preparation failed (see logs/inet_train.log)")
for name in ("mocov3_b", "mae_b"):
unit_cls(name, ev)
summarise()
sync_out()
log("PILOT FINISHED")
if __name__ == "__main__":
main()