Download code/bgpt_ceiling.py from Cross-Mergeability/compose-audit: direct link, hf CLI and curl.
- Browser
- Download file 6.41 kB
-
https://huggingface.co/datasets/Cross-Mergeability/compose-audit/resolve/main/code/bgpt_ceiling.py
- Command line
-
hf download hf://datasets/Cross-Mergeability/compose-audit/code/bgpt_ceiling.py
-
curl -L -o bgpt_ceiling.py https://huggingface.co/datasets/Cross-Mergeability/compose-audit/resolve/main/code/bgpt_ceiling.py
6.41 kB
| """What would SUCCESS look like? The jointly-trained bilingual ceiling. | |
| SET 4 shows that merging two monolingual Goldfish models produces a model that is destroyed by | |
| likelihood and badly degraded by accuracy. That is only interpretable against what a bilingual model | |
| of the same budget actually achieves. B-GPT (Arnett et al.) trains English+X jointly with a single | |
| shared tokenizer — the target the composition literature is trying to reach without joint training. | |
| Reports the same two metrics on the same two corpora: nats per UTF-8 byte on FLORES-200 devtest, and | |
| MultiBLiMP 1.0 accuracy.""" | |
| import os, sys, json, time, csv, argparse | |
| sys.path.insert(0, "/root/compose-audit") | |
| from common import * | |
| from mergeschool.core.models import load_hf | |
| from huggingface_hub import hf_hub_download | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--pairs", default="nld_Latn:nl:nld,spa_Latn:es:spa,ell_Grek:el:ell,pol_Latn:pl:pol") | |
| ap.add_argument("--variant", default="simultaneous") | |
| ap.add_argument("--n_sent", type=int, default=500) | |
| ap.add_argument("--max_items", type=int, default=1200) | |
| ap.add_argument("--bs", type=int, default=8) | |
| A = ap.parse_args() | |
| OUT = "/root/compose-audit/results/bgpt_ceiling.jsonl" | |
| DEV = "cuda" | |
| def log(*a): print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True) | |
| def build_blocks(tok, text, block=128, max_blocks=200): | |
| ids = tok(text)["input_ids"] | |
| n = max(1, min(max_blocks, len(ids) // block)) | |
| arr = torch.from_numpy(np.asarray(ids[: n * block], dtype=np.int64).reshape(n, block)) | |
| nb = sum(len(tok.decode(list(arr[i, 1:].numpy())).encode("utf-8")) for i in range(n)) | |
| return arr, nb | |
| def nll_total(model, blocks, dev, bs=8): | |
| tot, ntok = 0.0, 0 | |
| for i in range(0, blocks.shape[0], bs): | |
| x = blocks[i:i + bs].to(dev) | |
| lp = torch.log_softmax(model(x).logits.float()[:, :-1], -1) | |
| tgt = x[:, 1:] | |
| tot += (-lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1)).sum().item(); ntok += tgt.numel() | |
| return tot, ntok | |
| def mb_pairs(lang, n): | |
| p = hf_hub_download("jumelet/multiblimp", f"{lang}/data.tsv", repo_type="dataset") | |
| rows = list(csv.DictReader(open(p, encoding="utf-8"), delimiter="\t"))[:n] | |
| return [(r["sen"], r["wrong_sen"]) for r in rows if r.get("sen") and r.get("wrong_sen")] | |
| def mb_acc(model, tok, pairs, dev, bs=48, maxlen=64): | |
| def sc(sents): | |
| e = tok(sents, return_tensors="pt", padding=True, truncation=True, max_length=maxlen) | |
| ids, am = e["input_ids"], e["attention_mask"] | |
| o = [] | |
| for i in range(0, ids.shape[0], bs): | |
| x, m = ids[i:i + bs].to(dev), am[i:i + bs].to(dev) | |
| lp = torch.log_softmax(model(x, attention_mask=m).logits.float()[:, :-1], -1) | |
| o.append((lp.gather(-1, x[:, 1:].unsqueeze(-1)).squeeze(-1) * m[:, 1:].float()).sum(1).cpu()) | |
| return torch.cat(o).numpy() | |
| sg, sb = sc([g for g, _ in pairs]), sc([b for _, b in pairs]) | |
| unk = 0.0 | |
| if tok.unk_token_id is not None: | |
| e = tok([g for g, _ in pairs], return_tensors="pt", padding=True, truncation=True, max_length=maxlen) | |
| unk = float(((e["input_ids"] == tok.unk_token_id) & e["attention_mask"].bool()).sum().item() | |
| / max(1, e["attention_mask"].sum().item())) | |
| return float((sg > sb).mean()), unk | |
| eng_text = "\n".join(flores_lines("eng_Latn")[: A.n_sent]) | |
| MB_ENG = mb_pairs("eng", A.max_items) | |
| BLOCK = 128 # B-GPT's n_positions. Every model in this table is scored at the SAME | |
| # context length so the nats/byte numbers are comparable. | |
| def eval_model(m, tok, x_text, mbx): | |
| be, nbe = build_blocks(tok, eng_text, BLOCK); bx, nbx = build_blocks(tok, x_text, BLOCK) | |
| te, _ = nll_total(m, be, DEV, bs=A.bs); tx, _ = nll_total(m, bx, DEV, bs=A.bs) | |
| ae, ue = mb_acc(m, tok, MB_ENG, DEV) | |
| ax, ux = mb_acc(m, tok, mbx, DEV) | |
| return {"nats_per_byte_eng": te / nbe, "nats_per_byte_x": tx / nbx, | |
| "multiblimp_eng": ae, "multiblimp_x": ax, "unk_rate_eng": ue, "unk_rate_x": ux} | |
| done = set() | |
| if os.path.exists(OUT): | |
| for l in open(OUT): | |
| try: done.add(json.loads(l)["lang"]) | |
| except Exception: pass | |
| fh = open(OUT, "a") | |
| for spec in A.pairs.split(","): | |
| fcode, x2, mb = spec.split(":") | |
| if fcode in done: continue | |
| repo = f"catherinearnett/B-GPT_en_{x2}_{A.variant}" | |
| try: | |
| m, tok = load_hf(repo, dtype=torch.float32, device=DEV); m.eval() | |
| except Exception as e: | |
| log("FAILED to load", repo, type(e).__name__, str(e)[:200]); continue | |
| x_text = "\n".join(flores_lines(fcode)[: A.n_sent]) | |
| MBX = mb_pairs(mb, A.max_items) | |
| arms = {"bgpt_joint_bilingual": eval_model(m, tok, x_text, MBX)} | |
| log(f" B-GPT joint: {arms['bgpt_joint_bilingual']}") | |
| del m; torch.cuda.empty_cache() | |
| # --- the same table for the Goldfish parents and their merges, at the SAME 128-token context | |
| gcode = {"nld_Latn": "nld_latn", "spa_Latn": "spa_latn", "ell_Grek": "ell_grek", "pol_Latn": "pol_latn"}[fcode] | |
| m_e, tok_e = load_hf("goldfish-models/eng_latn_1000mb", dtype=torch.float32, device=DEV); m_e.eval() | |
| SD_E = sd_np(m_e) | |
| arms["goldfish_eng_parent"] = eval_model(m_e, tok_e, x_text, MBX) | |
| m_x, tok_x = load_hf(f"goldfish-models/{gcode}_1000mb", dtype=torch.float32, device=DEV); m_x.eval() | |
| SD_X = sd_np(m_x) | |
| arms["goldfish_partner_parent"] = eval_model(m_x, tok_x, x_text, MBX) | |
| del m_x; torch.cuda.empty_cache() | |
| V = int(m_e.config.vocab_size) | |
| vkeys = [k for k in SD_X if k.endswith("wte.weight") or k.endswith("lm_head.weight")] | |
| SD_X_V, _cov = AL.remap_vocab_rows(SD_X, tok_e, tok_x, V, keys=vkeys) | |
| for k in vkeys: | |
| W = np.asarray(SD_X_V[k], float) | |
| if W.shape[0] == V: | |
| bad = ~np.isfinite(W).all(axis=1); W[bad] = np.asarray(SD_E[k], float)[bad] | |
| SD_X_V[k] = W | |
| for nm, sd in (("merge_M0_naive", MG.average([SD_E, SD_X])), | |
| ("merge_M1a_vocab", MG.average([SD_E, SD_X_V]))): | |
| sd_load(m_e, sd, DEV) | |
| arms[nm] = eval_model(m_e, tok_e, x_text, MBX) | |
| log(f" {nm}: {arms[nm]}") | |
| del m_e; torch.cuda.empty_cache() | |
| r = {"set": "bgpt_ceiling", "lang": fcode, "repo": repo, "variant": A.variant, | |
| "context_tokens": BLOCK, "n_items_eng": len(MB_ENG), "n_items_x": len(MBX), | |
| "arms": arms} | |
| fh.write(json.dumps(r) + "\n"); fh.flush() | |
| fh.close() | |
| log("DONE bgpt") | |