"""Is the L60 collapse lost information, or a readout that lost reach? The depth sweep scored raw states with a centred cosine. A cosine only finds structure in the basis it is handed, so "the forward pass discarded it" and "the forward pass moved it somewhere a cosine cannot follow" produce the same reading. A first attempt to separate them fitted a ridge map on 936 images and failed its own control, losing to the un-fitted arm at L47. That was a sample-size failure, not an answer. This runs the real recipe instead: the same contrastive head the Lab ships, two 1024-d towers trained with InfoNCE, fitted independently at each depth on 4,000 images and scored on 1,000 held out. The control is L47. A fitted head there must clearly beat the head-free cosine, because that is the layer the shipped head uses. If it does not, the instrument is invalid again and no other layer's number means anything. python scripts/l60_head_refit.py --layers 28,47,54,60 """ from __future__ import annotations import argparse import json import os import numpy as np import torch import torch.nn.functional as F BACKBONE = "google/gemma-4-31B-it" BATCH = 16 MAX_SEQ = 64 def parse_args(): p = argparse.ArgumentParser() p.add_argument("--img-dir", default="/root/val2017") p.add_argument("--caps", default="/root/annotations/captions_val2017.json") p.add_argument("--layers", default="28,47,54,60") p.add_argument("--n", type=int, default=5000) p.add_argument("--holdout", type=int, default=1000) p.add_argument("--proj-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/l60_states.npz") p.add_argument("--out", default="/root/l60_head_refit.json") return p.parse_args() @torch.no_grad() def encode(files, caps, img_dir, layers, proc, model, cache): if os.path.exists(cache): z = np.load(cache, allow_pickle=True) print(f"resuming from {cache}", flush=True) return z["img"], z["txt"] from PIL import Image d = model.config.text_config.hidden_size if hasattr(model.config, "text_config") else 5376 img_tok = getattr(model.config, "image_token_id", None) img = np.zeros((len(files), len(layers), d), np.float16) for i, fname in enumerate(files): im = Image.open(os.path.join(img_dir, fname)).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() if (i + 1) % 250 == 0: print(f" img {i + 1}/{len(files)}", flush=True) tok = getattr(proc, "tokenizer", proc) bos = tok.bos_token_id txt = np.zeros((len(caps), len(layers), d), np.float16) for i in range(0, 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)) if (i // BATCH) % 50 == 0: print(f" txt {i}/{len(caps)}", flush=True) np.savez_compressed(cache, img=img, txt=txt) return img, txt def ranks(A, B): A = F.normalize(A, dim=1) B = F.normalize(B, dim=1) S = A @ B.T d = torch.arange(len(A), device=A.device) return (S > S[d, d][:, None]).sum(1) + 1 def report(r): r = r.float() return {"r@1": float((r == 1).float().mean()), "r@10": float((r <= 10).float().mean()), "median_rank": float(r.median())} def fit_head(I_tr, T_tr, I_te, T_te, dim, epochs, lr, tau): dev = "cuda" 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).to(dev) Wt = torch.nn.Linear(T_tr.shape[1], dim).to(dev) 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=dev) 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) logits = a @ b.T / tau lab = torch.arange(len(idx), device=dev) loss = 0.5 * (F.cross_entropy(logits, lab) + F.cross_entropy(logits.T, lab)) opt.zero_grad() loss.backward() opt.step() with torch.no_grad(): a = Wi(I_te - mu_i) b = Wt(T_te - mu_t) return a, b def main() -> None: a = parse_args() layers = [int(x) for x in a.layers.split(",")] ann = json.load(open(a.caps)) first = {} 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)[:a.n] files = [id2file[i] for i in ids] caps = [first[i] for i in ids] print(f"{len(files)} images with a caption, 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:] 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") I_te_c = I[te] - I[te].mean(0, keepdim=True) T_te_c = T[te] - T[te].mean(0, keepdim=True) free = report(ranks(I_te_c, T_te_c)) a_te, b_te = fit_head(I[tr], T[tr], I[te], T[te], a.proj_dim, a.epochs, a.lr, a.tau) fitted = report(ranks(a_te, b_te)) results[f"L{L}"] = {"head_free": free, "fitted_head": fitted} print(f"L{L:<3d} head-free r@1 {free['r@1']:.3f} med {free['median_rank']:.0f} " f"fitted r@1 {fitted['r@1']:.3f} med {fitted['median_rank']:.0f}", flush=True) out = { "question": "is the L60 collapse lost information or a readout that lost reach", "method": "shipped head recipe: two 1024-d towers, InfoNCE, fitted per layer", "control": "a fitted head at L47 must clearly beat head-free, or the instrument is invalid", "n_images": len(files), "n_train": len(tr), "n_holdout": len(te), "backbone": BACKBONE, "results": results, } with open(a.out, "w") as f: json.dump(out, f, indent=1) print(f"\nwrote {a.out}") if __name__ == "__main__": main()