| """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 | |
| 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") | |