File size: 5,453 Bytes
58e7bb7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | """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)
|