reproduction script

scripts/sweep_induction.py

@@ -0,0 +1,112 @@
+"""Per-head induction / prev-token / ICL scores across an open model's training checkpoints.
+
+Writes one JSONL row per (checkpoint, layer, head) plus a per-checkpoint summary row.
+Resumable: skips checkpoints already present in the output file.
+Purges each checkpoint from the HF cache after probing (154 ckpts would otherwise be ~58GB).
+"""
+import argparse, json, os, shutil, sys, time
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from huggingface_hub import list_repo_refs
+
+p = argparse.ArgumentParser()
+p.add_argument("--model", default="EleutherAI/pythia-160m")
+p.add_argument("--out", required=True)
+p.add_argument("--batch", type=int, default=16)
+p.add_argument("--seqlen", type=int, default=64)
+p.add_argument("--seeds", type=int, default=3)      # stimulus seeds -> error bars on every score
+p.add_argument("--limit", type=int, default=0)
+p.add_argument("--steps", default="", help="comma-separated step numbers; default = all")
+p.add_argument("--dtype", default="float32", choices=["float32","bfloat16","float16"])
+args = p.parse_args()
+
+dev = "cuda" if torch.cuda.is_available() else "cpu"
+tok = AutoTokenizer.from_pretrained(args.model)
+V = tok.vocab_size
+
+
+def stimulus(seed):
+    """[random tokens][same tokens again] -- the induction probe."""
+    g = torch.Generator().manual_seed(seed)
+    h = torch.randint(0, V, (args.batch, args.seqlen), generator=g)
+    return torch.cat([h, h], 1).to(dev)
+
+
+STIM = [stimulus(s) for s in range(args.seeds)]
+L = args.seqlen
+dest = torch.arange(L, 2 * L - 1)
+src_ind = dest - L + 1          # induction: attend to token AFTER previous occurrence
+src_prev = dest - 1             # previous-token head
+
+
+@torch.no_grad()
+def probe(rev):
+    m = AutoModelForCausalLM.from_pretrained(
+        args.model, revision=rev, attn_implementation="eager",
+        dtype=getattr(torch, args.dtype)
+    ).to(dev).eval()
+    ind, prev, icl = [], [], []
+    for ids in STIM:
+        out = m(ids, output_attentions=True)
+        NL = len(out.attentions); NH = out.attentions[0].shape[1]
+        i = torch.stack([out.attentions[l][:, :, dest, src_ind].mean(dim=(0, 2)) for l in range(NL)])
+        p_ = torch.stack([out.attentions[l][:, :, dest, src_prev].mean(dim=(0, 2)) for l in range(NL)])
+        ind.append(i.float().cpu()); prev.append(p_.float().cpu())
+        lg = out.logits[:, :-1].float(); tg = ids[:, 1:]
+        lp = torch.log_softmax(lg, -1).gather(2, tg.unsqueeze(2)).squeeze(2)
+        icl.append(((-lp[:, L:].mean()) - (-lp[:, :L].mean())).item())
+        del out
+    ind = torch.stack(ind); prev = torch.stack(prev)     # [seeds, NL, NH]
+    del m
+    if dev == "cuda":
+        torch.cuda.empty_cache()
+    return ind, prev, icl
+
+
+def purge(model_id):
+    d = os.path.expanduser("~/.cache/huggingface/hub/models--" + model_id.replace("/", "--"))
+    shutil.rmtree(d, ignore_errors=True)
+
+
+steps = sorted([b.name for b in list_repo_refs(args.model).branches if b.name.startswith("step")],
+               key=lambda s: int(s[4:]))
+if args.steps:
+    want = {int(x) for x in args.steps.split(",")}
+    steps = [s for s in steps if int(s[4:]) in want]
+if args.limit:
+    steps = steps[:args.limit]
+
+done = set()
+if os.path.exists(args.out):
+    for line in open(args.out):
+        try:
+            done.add(json.loads(line)["revision"])
+        except Exception:
+            pass
+
+print(f"{args.model}: {len(steps)} checkpoints, {len(done)} already done", flush=True)
+with open(args.out, "a") as f:
+    for k, rev in enumerate(steps):
+        if rev in done:
+            continue
+        t0 = time.time()
+        try:
+            ind, prev, icl = probe(rev)
+        except Exception as e:
+            print(f"  {rev}: FAILED {type(e).__name__}: {e}", flush=True)
+            purge(args.model); continue
+        S, NL, NH = ind.shape
+        rec = {"revision": rev, "step": int(rev[4:]), "model": args.model,
+               "dtype": args.dtype, "batch": args.batch, "seqlen": args.seqlen,
+               "icl_score_mean": sum(icl) / len(icl), "icl_score_seeds": icl,
+               "n_layers": NL, "n_heads": NH,
+               "heads": [{"layer": l, "head": h,
+                          "induction_mean": float(ind[:, l, h].mean()),
+                          "induction_std": float(ind[:, l, h].std()),
+                          "prev_token_mean": float(prev[:, l, h].mean())}
+                         for l in range(NL) for h in range(NH)]}
+        f.write(json.dumps(rec) + "\n"); f.flush()
+        purge(args.model)
+        print(f"  [{k+1}/{len(steps)}] {rev}: max induction {float(ind.mean(0).max()):.3f}  "
+              f"ICL {rec['icl_score_mean']:+.2f}  ({time.time()-t0:.0f}s)", flush=True)
+print("DONE", flush=True)