| """Robustness: is SET 1's Δfloor an artifact of the held-out corpus? |
| |
| The main SET 1 tables score on FLORES-200 English devtest, which is genuinely held out from |
| PolyPythia training but out-of-domain for the Pile. A reviewer's first objection is that the merge |
| penalty is inflated by domain shift. This re-scores a subset of the same pairs and the same merges on |
| a **Pile sample** (`NeelNanda/pile-10k`, in-distribution for Pythia) and on **WikiText-103 |
| validation**, and reports the three side by side.""" |
| import os, sys, json, time, itertools, argparse, gc |
| sys.path.insert(0, "/root/compose-audit") |
| from common import * |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| from datasets import load_dataset |
|
|
| ap = argparse.ArgumentParser() |
| ap.add_argument("--size", default="14m") |
| ap.add_argument("--seeds", default="1,2,3,4,5,6") |
| ap.add_argument("--blocks", type=int, default=48) |
| ap.add_argument("--bs", type=int, default=16) |
| ap.add_argument("--acts_rows", type=int, default=2048) |
| A = ap.parse_args() |
| SEEDS = [int(s) for s in A.seeds.split(",")] |
| OUT = f"/root/compose-audit/results/corpus_{A.size}.jsonl" |
| DEV = "cuda" |
|
|
|
|
| def log(*a): print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True) |
|
|
|
|
| def neox_head_match(sd_a, sd_b, d, nh, nl): |
| hd, perms = d // nh, {} |
| for L in range(nl): |
| qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight" |
| de = f"gpt_neox.layers.{L}.attention.dense.weight" |
| if qk not in sd_a: continue |
| Aq = np.asarray(sd_a[qk], float).reshape(nh, 3 * hd, d) |
| Bq = np.asarray(sd_b[qk], float).reshape(nh, 3 * hd, d) |
| Ad = np.asarray(sd_a[de], float).reshape(d, nh, hd) |
| Bd = np.asarray(sd_b[de], float).reshape(d, nh, hd) |
| perms[L] = AL._assignment(np.einsum("ixy,jxy->ij", Aq, Bq) + np.einsum("xiy,xjy->ij", Ad, Bd)) |
| return perms |
|
|
|
|
| def neox_apply_head(sd, perms, d, nh): |
| hd, o = d // nh, dict(sd) |
| for L, h in perms.items(): |
| qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight" |
| qb = f"gpt_neox.layers.{L}.attention.query_key_value.bias" |
| de = f"gpt_neox.layers.{L}.attention.dense.weight" |
| o[qk] = np.asarray(sd[qk], float).reshape(nh, 3 * hd, d)[h].reshape(3 * d, d) |
| if qb in sd: o[qb] = np.asarray(sd[qb], float).reshape(nh, 3 * hd)[h].reshape(3 * d) |
| o[de] = np.asarray(sd[de], float).reshape(d, nh, hd)[:, h].reshape(d, d) |
| return o |
|
|
|
|
| def align_perm(sd_a, sd_b, d, aa, ab, nh, nl): |
| sd, _ = AL.align_weights_full(sd_a, sd_b, d, acts_a=aa, acts_b=ab, n_heads=None, |
| method="permutation", strict=True, accept_each=True) |
| hp = neox_head_match(sd_a, sd, d, nh, nl) |
| if hp: |
| cand = neox_apply_head(sd, hp, d, nh) |
| if AL.block_normalised_distance(sd_a, cand) <= AL.block_normalised_distance(sd_a, sd): |
| sd = cand |
| return sd |
|
|
|
|
| tok = AutoTokenizer.from_pretrained(f"EleutherAI/pythia-{A.size}") |
| CORPORA = {} |
| CORPORA["flores_eng"] = make_blocks(tok, flores_lines("eng_Latn"), 512, A.blocks) |
| try: |
| d = load_dataset("NeelNanda/pile-10k", split="train") |
| CORPORA["pile_10k"] = make_blocks(tok, [x for x in d["text"][:400]], 512, A.blocks) |
| except Exception as e: |
| log("pile load failed", type(e).__name__, str(e)[:150]) |
| try: |
| d = load_dataset("Salesforce/wikitext", "wikitext-103-raw-v1", split="validation") |
| CORPORA["wikitext103_val"] = make_blocks(tok, [x for x in d["text"] if x.strip()][:4000], 512, A.blocks) |
| except Exception as e: |
| log("wikitext load failed", type(e).__name__, str(e)[:150]) |
| log("corpora:", {k: tuple(v.shape) for k, v in CORPORA.items()}) |
|
|
| shell = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{SEEDS[0]}", |
| dtype=torch.float32).to(DEV).eval() |
| cfg = shell.config |
| D, NH, NL = cfg.hidden_size, cfg.num_attention_heads, cfg.num_hidden_layers |
|
|
|
|
| def ev_all(sd): |
| sd_load(shell, sd, DEV) |
| return {k: nll_nats(shell, b, DEV, bs=A.bs) for k, b in CORPORA.items()} |
|
|
|
|
| SDS, ACTS, PAR = {}, {}, {} |
| for s in SEEDS: |
| m = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{s}", dtype=torch.float32).to(DEV).eval() |
| SDS[s] = sd_np(m); ACTS[s] = capture_acts(m, CORPORA["flores_eng"], DEV, n_rows=A.acts_rows, bs=A.bs) |
| del m; torch.cuda.empty_cache() |
| PAR[s] = ev_all(SDS[s]) |
| log(f" seed{s} {PAR[s]}") |
|
|
| done = set() |
| if os.path.exists(OUT): |
| for l in open(OUT): |
| try: done.add(tuple(json.loads(l)["pair"])) |
| except Exception: pass |
| fh = open(OUT, "a") |
| for a, b in itertools.combinations(SEEDS, 2): |
| if (a, b) in done: continue |
| t0 = time.time() |
| sbp = align_perm(SDS[a], SDS[b], D, ACTS[a], ACTS[b], NH, NL) |
| rungs = {"M0_naive_avg": MG.average([SDS[a], SDS[b]]), "M1_perm_avg": MG.average([SDS[a], sbp])} |
| res = {} |
| for k, sd in rungs.items(): |
| nl_ = ev_all(sd) |
| res[k] = {c: {"nll": v, "delta_floor": v - min(PAR[a][c], PAR[b][c])} for c, v in nl_.items()} |
| r = {"set": "set1_corpus_robustness", "size": A.size, "pair": [a, b], |
| "parent_nll": {"a": PAR[a], "b": PAR[b]}, "rungs": res, "secs": time.time() - t0} |
| fh.write(json.dumps(r) + "\n"); fh.flush() |
| log(f"pair {a},{b} " + " | ".join( |
| f"{c}: M0 {res['M0_naive_avg'][c]['delta_floor']:+.2f} M1 {res['M1_perm_avg'][c]['delta_floor']:+.2f}" |
| for c in CORPORA) + f" ({r['secs']:.0f}s)") |
| del rungs, sbp; gc.collect() |
| fh.close() |
| log("DONE corpus", A.size) |
|
|
