reproduction script

scripts/ablate_induction.py

@@ -0,0 +1,76 @@
+"""Causal control for the induction atlas: ablate the top-k induction heads vs k RANDOM heads
+and measure the damage to in-context (2nd-copy) loss. An induction score is correlational;
+this is what makes it a mechanism."""
+import json, os, shutil, sys
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+MODEL = "EleutherAI/pythia-160m"
+REVS = sys.argv[1:] or ["step512", "step1000", "step2000", "step16000", "step143000"]
+K = 5
+dev = "cuda" if torch.cuda.is_available() else "cpu"
+tok = AutoTokenizer.from_pretrained(MODEL)
+g = torch.Generator().manual_seed(0)
+half = torch.randint(0, tok.vocab_size, (16, 64), generator=g)
+ids = torch.cat([half, half], 1).to(dev)
+L = 64
+
+
+def install(model, heads):
+    """Zero each (layer,head)'s slice of the attention output before the dense projection."""
+    cfg = model.config
+    dh = cfg.hidden_size // cfg.num_attention_heads
+    by = {}
+    for (l, h) in heads:
+        by.setdefault(l, []).append(h)
+    hs = []
+    for l, hd in by.items():
+        dense = model.gpt_neox.layers[l].attention.dense
+        def pre(mod, args, hd=hd):
+            x = args[0].clone()
+            for h in hd:
+                x[..., h * dh:(h + 1) * dh] = 0
+            return (x,) + tuple(args[1:])
+        hs.append(dense.register_forward_pre_hook(pre))
+    return hs
+
+
+@torch.no_grad()
+def second_copy_loss(model):
+    lg = model(ids).logits[:, :-1].float()
+    lp = torch.log_softmax(lg, -1).gather(2, ids[:, 1:].unsqueeze(2)).squeeze(2)
+    return float(-lp[:, L:].mean())
+
+
+scores = {r["revision"]: r for r in
+          (json.loads(l) for l in open("data/induction_pythia-160m.jsonl"))}
+out = []
+for rev in REVS:
+    m = AutoModelForCausalLM.from_pretrained(MODEL, revision=rev, attn_implementation="eager",
+                                             dtype=torch.float32).to(dev).eval()
+    base = second_copy_loss(m)
+    hs = sorted(scores[rev]["heads"], key=lambda h: -h["induction_mean"])[:K]
+    top = [(h["layer"], h["head"]) for h in hs]
+    gg = torch.Generator().manual_seed(1)
+    NL, NH = scores[rev]["n_layers"], scores[rev]["n_heads"]
+    rnd = [(int(torch.randint(0, NL, (1,), generator=gg)),
+            int(torch.randint(0, NH, (1,), generator=gg))) for _ in range(K)]
+
+    hk = install(m, top); abl_i = second_copy_loss(m); [h.remove() for h in hk]
+    hk = install(m, rnd); abl_r = second_copy_loss(m); [h.remove() for h in hk]
+    rec = {"revision": rev, "step": scores[rev]["step"], "baseline_2nd_copy_loss": base,
+           "ablate_induction": abl_i, "ablate_random": abl_r,
+           "delta_induction": abl_i - base, "delta_random": abl_r - base,
+           "top_heads": top, "random_heads": rnd}
+    out.append(rec)
+    print(f"{rev:>12} base {base:6.3f} | ablate induction {abl_i:6.3f} ({abl_i-base:+.3f}) "
+          f"| random {abl_r:6.3f} ({abl_r-base:+.3f})", flush=True)
+    del m
+    if dev == "cuda": torch.cuda.empty_cache()
+    shutil.rmtree(os.path.expanduser("~/.cache/huggingface/hub/models--EleutherAI--pythia-160m"),
+                  ignore_errors=True)
+
+with open("data/ablation_pythia-160m.jsonl", "w") as f:
+    for r in out:
+        f.write(json.dumps(r) + "\n")
+print("written")