"""Fit the head at full scale at L20 and L47, and settle the tap layer. L20 beats the shipped L47 tap on two image distributions, and the gap widens with data: +0.043 r@1 at 28,000 training images and still climbing. What is missing is a head fitted at the scale the shipped one was, which is the difference between evidence and a deployable candidate. Encoding 118,287 images takes hours, so this checkpoints. A partial cache is written every CHUNK images and resumed on restart, because losing seven hours to one crash is the avoidable failure in a job this long. python scripts/tap_layer_full.py --layers 20,47 """ from __future__ import annotations import argparse import json import os import time from pathlib import Path import numpy as np import torch import torch.nn.functional as F BACKBONE = "google/gemma-4-31B-it" BATCH = 16 MAX_SEQ = 64 CHUNK = 10000 def parse_args(): p = argparse.ArgumentParser() p.add_argument("--img-dir", default="/root/train2017") p.add_argument("--caps", default="/root/annotations/captions_train2017.json") p.add_argument("--layers", default="20,47") p.add_argument("--n", type=int, default=118287) p.add_argument("--holdout", type=int, default=5000) p.add_argument("--dim", type=int, default=1024) p.add_argument("--epochs", type=int, default=40) p.add_argument("--lr", type=float, default=1e-3) p.add_argument("--tau", type=float, default=0.05) p.add_argument("--cache", default="/root/full_states_L20_L47.npz") p.add_argument("--out", default="/root/tap_layer_full.json") return p.parse_args() def pairs(caps_path: str, n: int): ann = json.load(open(caps_path)) first: dict[int, str] = {} for c in sorted(ann["annotations"], key=lambda x: x["id"]): first.setdefault(c["image_id"], c["caption"].strip()) id2file = {im["id"]: im["file_name"] for im in ann["images"]} ids = sorted(i for i in first if i in id2file)[:n] return [id2file[i] for i in ids], [first[i] for i in ids] @torch.no_grad() def encode(files, caps, img_dir, layers, proc, model, cache): from PIL import Image part = cache.replace(".npz", ".partial.npz") d = 5376 img = np.zeros((len(files), len(layers), d), np.float16) txt = np.zeros((len(caps), len(layers), d), np.float16) done_img = done_txt = 0 if os.path.exists(part): z = np.load(part, allow_pickle=False) # Older partials carry a single `done` for an interleaved image+caption loop. done_img = int(z["done_img"]) if "done_img" in z.files else int(z["done"]) done_txt = int(z["done_txt"]) if "done_txt" in z.files else int(z["done"]) img[:done_img] = z["img"][:done_img] txt[:done_txt] = z["txt"][:done_txt] print(f"resuming: {done_img} images, {done_txt} captions", flush=True) img_tok = getattr(model.config, "image_token_id", None) tok = getattr(proc, "tokenizer", proc) bos = tok.bos_token_id def save(ni, nt): np.savez(part, img=img, txt=txt, done_img=ni, done_txt=nt) print(f" checkpointed {ni} images, {nt} captions", flush=True) t0 = time.time() for i in range(done_img, len(files)): im = Image.open(os.path.join(img_dir, files[i])).convert("RGB") msg = [{"role": "user", "content": [ {"type": "image", "image": im}, {"type": "text", "text": "Describe this image."}]}] enc = proc.apply_chat_template(msg, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to("cuda") out = model(**enc, output_hidden_states=True, use_cache=False) mask = enc["input_ids"][0] == img_tok for li, L in enumerate(layers): img[i, li] = out.hidden_states[L][0][mask].float().mean(0).cpu().numpy() n = i + 1 - done_img if n % 500 == 0: r = n / (time.time() - t0) eta = (len(files) - i - 1) / r / 3600 print(f" img {i + 1}/{len(files)} {r:.2f}/s eta {eta:.2f}h", flush=True) if (i + 1) % CHUNK == 0: save(i + 1, done_txt) save(len(files), done_txt) # A caption is ~20 tokens, so a per-caption forward is almost all weight-load # overhead on a 31B backbone. Batching here is what makes the run tractable. t0 = time.time() for i in range(done_txt, len(caps), BATCH): chunk = caps[i:i + BATCH] ids_list = [] for t in chunk: ids = tok(t, truncation=True, max_length=MAX_SEQ, add_special_tokens=True).input_ids if bos is not None and ids[0] != bos: ids = [bos] + ids[: MAX_SEQ - 1] ids_list.append(ids) T = max(len(x) for x in ids_list) pad = tok.pad_token_id if tok.pad_token_id is not None else bos input_ids = torch.full((len(chunk), T), pad, dtype=torch.long) attn = torch.zeros((len(chunk), T), dtype=torch.long) for j, ids in enumerate(ids_list): input_ids[j, : len(ids)] = torch.tensor(ids) attn[j, : len(ids)] = 1 out = model(input_ids=input_ids.cuda(), attention_mask=attn.cuda(), output_hidden_states=True, use_cache=False) last = (attn.sum(-1) - 1).cuda() rows = torch.arange(len(chunk)).cuda() for li, L in enumerate(layers): txt[i:i + len(chunk), li] = (out.hidden_states[L][rows, last] .float().cpu().numpy().astype(np.float16)) n = i + len(chunk) - done_txt if (i // BATCH) % 50 == 0 and n: r = n / (time.time() - t0) print(f" txt {i + len(chunk)}/{len(caps)} {r:.1f}/s " f"eta {(len(caps) - i) / r / 3600:.2f}h", flush=True) if (i + len(chunk)) % CHUNK < BATCH: save(len(files), i + len(chunk)) np.savez_compressed(cache, img=img, txt=txt) if os.path.exists(part): os.remove(part) return img, txt def fit_and_score(I_tr, T_tr, I_te, T_te, dim, epochs, lr, tau): mu_i, mu_t = I_tr.mean(0, keepdim=True), T_tr.mean(0, keepdim=True) Wi = torch.nn.Linear(I_tr.shape[1], dim).cuda() Wt = torch.nn.Linear(T_tr.shape[1], dim).cuda() opt = torch.optim.Adam(list(Wi.parameters()) + list(Wt.parameters()), lr=lr) n = len(I_tr) for ep in range(epochs): perm = torch.randperm(n, device="cuda") for i in range(0, n, 1024): idx = perm[i:i + 1024] if len(idx) < 8: continue a = F.normalize(Wi(I_tr[idx] - mu_i), dim=1) b = F.normalize(Wt(T_tr[idx] - mu_t), dim=1) lg = a @ b.T / tau lab = torch.arange(len(idx), device="cuda") loss = 0.5 * (F.cross_entropy(lg, lab) + F.cross_entropy(lg.T, lab)) opt.zero_grad() loss.backward() opt.step() if ep % 10 == 0: print(f" epoch {ep} loss {loss.item():.4f}", flush=True) with torch.no_grad(): a = F.normalize(Wi(I_te - mu_i), dim=1) b = F.normalize(Wt(T_te - mu_t), dim=1) S = a @ b.T dg = torch.arange(len(a), device="cuda") rank = (S > S[dg, dg][:, None]).sum(1) + 1 return ({"r@1": float((rank == 1).float().mean()), "r@10": float((rank <= 10).float().mean()), "median_rank": float(rank.float().median())}, {"img": Wi.state_dict(), "txt": Wt.state_dict(), "mu_img": mu_i.cpu(), "mu_txt": mu_t.cpu()}) def main() -> None: a = parse_args() layers = [int(x) for x in a.layers.split(",")] files, caps = pairs(a.caps, a.n) print(f"{len(files)} image-caption pairs, layers {layers}", flush=True) from transformers import AutoProcessor, AutoModelForImageTextToText proc = AutoProcessor.from_pretrained(BACKBONE) model = AutoModelForImageTextToText.from_pretrained( BACKBONE, dtype=torch.bfloat16, device_map="auto").eval() img, txt = encode(files, caps, a.img_dir, layers, proc, model, a.cache) del model torch.cuda.empty_cache() rng = np.random.default_rng(0) order = rng.permutation(len(files)) te, tr = order[:a.holdout], order[a.holdout:] print(f"\nfitting on {len(tr)}, scoring {len(te)}", flush=True) results = {} for li, L in enumerate(layers): I = torch.tensor(img[:, li], dtype=torch.float32, device="cuda") T = torch.tensor(txt[:, li], dtype=torch.float32, device="cuda") print(f" L{L}", flush=True) score, head = fit_and_score(I[tr], T[tr], I[te], T[te], a.dim, a.epochs, a.lr, a.tau) results[f"L{L}"] = score torch.save(head, f"/root/head_full_L{L}.pt") print(f" L{L} r@1 {score['r@1']:.4f} median {score['median_rank']:.0f}", flush=True) Path(a.out).write_text(json.dumps({ "question": "does L20 beat the shipped L47 tap at full scale", "n_pairs": len(files), "n_train": len(tr), "n_holdout": len(te), "results": results}, indent=1)) print(f"\nwrote {a.out}") if __name__ == "__main__": main()