code/set4_reverse.py

"""SET 4, REVERSE direction: the partner language is the anchor, English is transported into it.

Same four Goldfish pairs, same rungs, same metric — but the merged model now lives in the PARTNER
language's tokenizer and residual basis. If the composition failure were an artifact of anchoring on
English (English rows filling every unshared id, English tokenizer scoring the partner text), it
would not survive the swap."""
import os, sys, json, time, argparse, gc
sys.path.insert(0, "/root/compose-audit")
from common import *
import gpt2_align as G2
from set4_goldfish_lib import sent_acts
from mergeschool.core.models import load_hf

ap = argparse.ArgumentParser()
ap.add_argument("--pairs", default="nld_Latn:nld_latn,spa_Latn:spa_latn,ell_Grek:ell_grek,pol_Latn:pol_latn")
ap.add_argument("--n_sent", type=int, default=500)
ap.add_argument("--bs", type=int, default=8)
ap.add_argument("--barrier_n", type=int, default=7)
A = ap.parse_args()
OUT = "/root/compose-audit/results/set4_reverse.jsonl"
DEV = "cuda"
ENG_REPO = "goldfish-models/eng_latn_1000mb"


def log(*a):
    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)


def build_blocks(tok, text, block=512, max_blocks=64):
    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


@torch.no_grad()
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


eng_lines = flores_lines("eng_Latn")[: A.n_sent]
eng_text = "\n".join(eng_lines)
m_e, tok_e = load_hf(ENG_REPO, dtype=torch.float32, device=DEV); m_e.eval()
SD_E = sd_np(m_e)
cfg = m_e.config
D, NH, NL, V = cfg.n_embd, cfg.n_head, cfg.n_layer, cfg.vocab_size
acts_e = sent_acts(m_e, tok_e, eng_lines, DEV)
bl_e_e, by_e_e = build_blocks(tok_e, eng_text)
te0, _ = nll_total(m_e, bl_e_e, DEV, bs=A.bs)
ENG_ON_ENG = te0 / by_e_e
del m_e; torch.cuda.empty_cache()
log(f"eng parent on eng (own tok) = {ENG_ON_ENG:.4f} nats/byte")

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, gcode = spec.split(":")
    if fcode in done: continue
    t0 = time.time()
    repo = f"goldfish-models/{gcode}_1000mb"
    log(f"=== ANCHOR={fcode}  transporting {ENG_REPO} into it")
    m_x, tok_x = load_hf(repo, dtype=torch.float32, device=DEV); m_x.eval()
    SD_X = sd_np(m_x)                       # ANCHOR  (role "A")
    shell = m_x
    x_lines = flores_lines(fcode)[: A.n_sent]
    x_text = "\n".join(x_lines)
    acts_x = sent_acts(m_x, tok_x, x_lines, DEV)
    bl_x_x, by_x_x = build_blocks(tok_x, x_text)         # X text, X tok  (anchor space)
    bl_e_x, by_e_x = build_blocks(tok_x, eng_text)       # eng text, X tok (anchor space)
    tx, _ = nll_total(m_x, bl_x_x, DEV, bs=A.bs); X_ON_X = tx / by_x_x

    def ev(sd, blocks):
        sd_load(shell, sd, DEV)
        t, n = nll_total(shell, blocks, DEV, bs=A.bs)
        return t, n

    tex, _ = ev(SD_X, bl_e_x); X_ON_ENG = tex / by_e_x
    log(f"  parents: X/X={X_ON_X:.4f}  X-on-eng={X_ON_ENG:.4f}  eng/eng(own tok)={ENG_ON_ENG:.4f}")

    # transport ENGLISH into the anchor's id space
    vkeys = [k for k in SD_E if k.endswith("wte.weight") or k.endswith("lm_head.weight")]
    SD_E_V, cov = AL.remap_vocab_rows(SD_E, tok_x, tok_e, V, keys=vkeys)
    for k in vkeys:
        W = np.asarray(SD_E_V[k], float)
        if W.shape[0] == V:
            bad = ~np.isfinite(W).all(axis=1); W[bad] = np.asarray(SD_X[k], float)[bad]
        SD_E_V[k] = W
    anchors = AL.vocab_anchors(tok_x, tok_e)
    BODY = [k for k in SD_X if not (k.endswith("wte.weight") or k.endswith("lm_head.weight"))]
    R_emb, n_anch = G2.emb_procrustes(SD_X, SD_E, tok_x, tok_e)
    sd_emb = G2.apply_resid(SD_E_V, D, R=R_emb)
    sdp, ip = G2.align_full(SD_X, SD_E_V, D, NH, acts_x, acts_e, "permutation", body_keys=BODY)
    sdo, io = G2.align_full(SD_X, SD_E_V, D, NH, acts_x, acts_e, "orthogonal", body_keys=BODY)
    sdof, _ = G2.align_full(SD_X, SD_E_V, D, NH, acts_x, acts_e, "orthogonal", body_keys=BODY, accept_each=False)

    rungs = {"M0_naive_avg": MG.average([SD_X, SD_E]),
             "M1a_vocab_avg": MG.average([SD_X, SD_E_V]),
             "M1b_vocab_perm_avg": MG.average([SD_X, sdp]),
             "M1c_vocab_orth_avg": MG.average([SD_X, sdo]),
             "M1e_vocab_orth_forced": MG.average([SD_X, sdof]),
             "M1g_emb_procrustes": MG.average([SD_X, sd_emb])}
    res = {}
    for k, sd in rungs.items():
        t_x, n_x = ev(sd, bl_x_x); t_e, n_e = ev(sd, bl_e_x)
        res[k] = {"x": {"nats_per_byte": t_x / by_x_x, "nats_per_token": t_x / n_x},
                  "eng": {"nats_per_byte": t_e / by_e_x, "nats_per_token": t_e / n_e},
                  "delta_floor_x": t_x / by_x_x - X_ON_X,
                  "delta_floor_eng": t_e / by_e_x - min(X_ON_ENG, ENG_ON_ENG)}
        res[k]["delta_floor_mean"] = 0.5 * (res[k]["delta_floor_x"] + res[k]["delta_floor_eng"])
    for k in res:
        res[k]["delta_vs_naive_mean"] = res[k]["delta_floor_mean"] - res["M0_naive_avg"]["delta_floor_mean"]

    r = {"set": "set4_reverse", "lang": fcode, "anchor": fcode, "repo_a": repo, "repo_b": ENG_REPO,
         "corpus": "flores200_devtest", "n_sent": A.n_sent,
         "metric": "nats_per_utf8_byte (likelihood, NOT benchmark accuracy)",
         "parents": {"x_on_x": X_ON_X, "x_on_eng": X_ON_ENG, "eng_on_eng_own_tok": ENG_ON_ENG},
         "floor_x": X_ON_X, "floor_eng": min(X_ON_ENG, ENG_ON_ENG),
         "vocab_anchors": len(anchors), "align_info": {"perm": ip, "orth": io},
         "rungs": res, "secs": time.time() - t0}
    fh.write(json.dumps(r) + "\n"); fh.flush()
    log("  " + "  ".join(f"{k}: dfl_mean={v['delta_floor_mean']:+.4f}" for k, v in res.items()))
    del rungs, sdp, sdo, sdof, sd_emb, SD_E_V, m_x; gc.collect(); torch.cuda.empty_cache()
fh.close()
log("DONE set4_reverse")