code/scripts/embed_eval.py

#!/opt/pytorch/bin/python
"""Zero-shot embedding-model evaluation for AMLC 2026 business entity resolution.

Builds an S1 -> (S2 u S3) retrieval eval set per country from the labelled train
data, encodes it with candidate encoders on the GPU (no fine-tuning), and reports
recall@K / MRR / hard-negative AUC, recall@20 per pair category, a z-scored
cosine ensemble plus top-K union of two models, and name-only text variants.

Run on the GPU box:
    /opt/pytorch/bin/python embed_eval.py            # full run
    /opt/pytorch/bin/python embed_eval.py --smoke    # tiny eval set, no S3 upload
    /opt/pytorch/bin/python embed_eval.py --models bge-m3,qwen3-4b
Embeddings are cached per model/variant, so a rerun after a Spot interruption
only re-encodes what is missing.
"""
import os
import sys
import gc
import json
import time
import argparse
import datetime
import subprocess
import traceback

os.environ.setdefault("HF_HOME", "/opt/dlami/nvme/hf")
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")

import numpy as np
import pandas as pd
import duckdb
import torch
import torch.nn.functional as F
from sklearn.metrics import roc_auc_score

BASE = os.environ.get("AMLC_BASE", "/opt/dlami/nvme/amlc")
DB = f"{BASE}/amlc.duckdb"
AUDIT = f"{BASE}/parquet/pair_audit.parquet"
S3 = "s3://amlc-2026-478982785786/ckpt/embed_eval/"
COUNTRIES = ["US", "India"]
SEED = 42
KS = [1, 5, 20, 50]
MAX_SEQ = 64
CATS = ["indic_name", "domain_form", "former_form", "rename", "addr_empty", "other"]
CAT_DESC = {"rename": "rename (name_j=0)", "other": "other (none of the flags)"}
QWEN_INST = ("Instruct: Given a business name and address, retrieve records of the "
             "same business entity\nQuery:")

MODELS = {
    # key: hf id, dtype, batch, query prompt, document prompt, extra variants
    "bge-m3": dict(hf="BAAI/bge-m3", dtype="float16", bs=256,
                   q_prompt=None, d_prompt=None, name_variant=True),
    "e5-large": dict(hf="intfloat/multilingual-e5-large", dtype="float16", bs=256,
                     q_prompt="query: ", d_prompt="query: "),
    "qwen3-0.6b": dict(hf="Qwen/Qwen3-Embedding-0.6B", dtype="bfloat16", bs=128,
                       q_prompt_name="query", d_prompt=None, left_pad=True, inst_variant=True),
    # bs=64 measured faster than 128/256 on the power-capped (72 W) L4
    "qwen3-4b": dict(hf="Qwen/Qwen3-Embedding-4B", dtype="bfloat16", bs=64,
                     q_prompt_name="query", d_prompt=None, left_pad=True,
                     name_variant=True, inst_variant=True),
    # contrastively fine-tuned e5-large (hf_jobs/train_e5_ft.py; private repo, loaded with HF_TOKEN)
    "e5-ft": dict(hf=os.environ.get("FT_MODEL", "Arushhh/amlc-e5-ft"), dtype="float16", bs=256,
                  q_prompt="query: ", d_prompt="query: "),
}
ENS = ("bge-m3", "qwen3-4b")


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


class Cfg:
    n_q = 6000
    n_dist = 120000
    suffix = ""
    upload = True


def path(name):
    stem, ext = os.path.splitext(name)
    return f"{BASE}/{stem}{Cfg.suffix}{ext}"


def cache_path(key, variant):
    return f"{BASE}/embed_eval_cache{Cfg.suffix}/{key}__{variant}.npy"


def s3_put(p, sub="", wait=True):
    if not Cfg.upload:
        return None
    cmd = ["aws", "s3", "cp", p, S3 + sub + os.path.basename(p), "--only-show-errors"]
    if not wait:
        return subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
    try:
        r = subprocess.run(cmd, capture_output=True, text=True, timeout=900)
        if r.returncode != 0:
            log("S3 upload failed", p, r.stderr[-500:])
    except Exception as e:  # never let an upload kill the run
        log("S3 upload error", p, repr(e))
    return None


# --------------------------------------------------------------------------- eval set
def build_eval_set(rebuild=False):
    pq = path("parquet/embed_eval_set.parquet")
    if os.path.exists(pq) and not rebuild:
        log("loading eval set", pq)
        return pd.read_parquet(pq)
    t0 = time.time()
    con = duckdb.connect(DB, read_only=True)
    con.execute("SET memory_limit='16GB'")
    con.execute(f"SET temp_directory='{BASE}/duck_tmp'")
    parts = []
    for c in COUNTRIES:
        q = con.execute(
            """SELECT s1.entity_id, s1.business_name, s1.business_address, s1.country, 'S1' AS src
               FROM s1 SEMI JOIN pairs p ON p.a = s1.entity_id
               WHERE s1.country = ?
               ORDER BY hash(s1.entity_id || ?) LIMIT ?""",
            [c, f"q{SEED}", Cfg.n_q]).df()
        q["role"] = "query"
        q["match_of"] = None
        con.register("qids", q[["entity_id"]])
        m = con.execute(
            """SELECT s.entity_id, s.business_name, s.business_address, s.country, s.src,
                      p.a AS match_of
               FROM pairs p JOIN qids ON p.a = qids.entity_id
               JOIN s23 s ON s.entity_id = p.b""").df()
        m["role"] = "match"
        con.register("mids", m[["entity_id"]])
        d = con.execute(
            """SELECT s.entity_id, s.business_name, s.business_address, s.country, s.src
               FROM s23 s ANTI JOIN mids ON s.entity_id = mids.entity_id
               WHERE s.country = ?
               ORDER BY hash(s.entity_id || ?) LIMIT ?""",
            [c, f"d{SEED}", Cfg.n_dist]).df()
        d["role"] = "distractor"
        d["match_of"] = None
        con.unregister("qids")
        con.unregister("mids")
        part = pd.concat([q, m, d], ignore_index=True)
        part["eval_country"] = c
        parts.append(part)
        log(f"eval set {c}: {len(q)} queries, {len(m)} true matches, {len(d)} distractors")
    ev = pd.concat(parts, ignore_index=True)

    # pair categories from pair_audit (matches only; b is unique across pairs)
    mm = ev.loc[ev.role == "match", ["match_of", "entity_id"]]
    con.register("mm", mm)
    aud = con.execute(
        f"""SELECT a.a AS match_of, a.b AS entity_id, a.name_j, a.addr_j,
                   a.indic_name, a.domain_form, a.former_form, a.addr_empty
            FROM read_parquet('{AUDIT}') a
            JOIN mm ON a.a = mm.match_of AND a.b = mm.entity_id""").df()
    con.close()
    flags = ["indic_name", "domain_form", "former_form", "addr_empty"]
    is_m = (ev.role == "match").to_numpy()
    mdf = ev.loc[is_m, ["match_of", "entity_id"]].merge(aud, on=["match_of", "entity_id"], how="left")
    n_missing = int(mdf.name_j.isna().sum() + 0)
    if n_missing:
        log(f"WARNING: {n_missing} matches missing from pair_audit (treated as no flags)")
    ev["name_j"] = np.nan
    ev["addr_j"] = np.nan
    ev.loc[is_m, "name_j"] = mdf.name_j.to_numpy()
    ev.loc[is_m, "addr_j"] = mdf.addr_j.to_numpy()
    for f in flags:
        ev[f] = False
        ev.loc[is_m, f] = mdf[f].fillna(False).astype(bool).to_numpy()
    ev["rename"] = is_m & (ev.name_j == 0).to_numpy()
    anyflag = ev[flags + ["rename"]].any(axis=1).to_numpy()
    ev["other"] = is_m & ~anyflag

    name = ev.business_name.fillna("").astype(str).str.strip()
    addr = ev.business_address.fillna("").astype(str).str.strip()
    ev["text_name"] = name
    ev["text_full"] = np.where(addr.str.len() > 0, name + " | " + addr, name)
    pq_dir = os.path.dirname(pq)
    os.makedirs(pq_dir, exist_ok=True)
    ev.to_parquet(pq, index=False)
    log(f"eval set built in {time.time() - t0:.1f}s -> {pq} ({len(ev)} rows)")
    s3_put(pq)
    return ev


def country_index(ev):
    CI = {}
    role = ev.role.to_numpy()
    ctry = ev.eval_country.to_numpy()
    eid = ev.entity_id.to_numpy()
    for c in COUNTRIES:
        qrows = np.nonzero((ctry == c) & (role == "query"))[0]
        prows = np.nonzero((ctry == c) & (role != "query"))[0]
        qpos = {e: i for i, e in enumerate(eid[qrows])}
        pool = ev.iloc[prows]
        pair_p = np.nonzero((pool.role == "match").to_numpy())[0]
        pair_q = np.array([qpos[a] for a in pool.match_of.to_numpy()[pair_p]], dtype=np.int64)
        o = np.argsort(pair_q, kind="stable")
        pair_q, pair_p = pair_q[o], pair_p[o]
        cats = {k: pool[k].to_numpy()[pair_p].astype(bool) for k in CATS}
        CI[c] = dict(qrows=qrows, prows=prows, pair_q=pair_q, pair_p=pair_p, cats=cats)
        log(f"{c}: {len(qrows)} queries, pool {len(prows)}, {len(pair_p)} true pairs, "
            + ", ".join(f"{k}={int(v.sum())}" for k, v in cats.items()))
    return CI


# --------------------------------------------------------------------------- encoding
def load_model(cfg):
    from sentence_transformers import SentenceTransformer
    dt = getattr(torch, cfg["dtype"])
    kw = dict(device="cuda", model_kwargs={"dtype": dt})
    if cfg.get("left_pad"):
        kw["processor_kwargs"] = {"padding_side": "left"}
    t0 = time.time()
    try:
        m = SentenceTransformer(cfg["hf"], **kw)
    except TypeError:
        kw.pop("processor_kwargs", None)
        try:
            m = SentenceTransformer(cfg["hf"], **kw)
        except TypeError:  # older transformers only know torch_dtype
            kw["model_kwargs"] = {"torch_dtype": dt}
            m = SentenceTransformer(cfg["hf"], **kw)
    if next(m.parameters()).dtype != dt:
        m = m.to(dt)
    if cfg.get("left_pad"):
        try:
            m.tokenizer.padding_side = "left"
        except Exception as e:
            log("could not set padding_side on tokenizer:", repr(e))
    m.max_seq_length = MAX_SEQ
    m.eval()
    return m, time.time() - t0


def encode(m, texts, bs, prompt=None, prompt_name=None, tag=""):
    n = len(texts)
    order = np.argsort(-np.fromiter((len(t) for t in texts), dtype=np.int64, count=n), kind="stable")
    out = None
    CH = 16384
    torch.cuda.synchronize()
    t0 = time.time()
    for s in range(0, n, CH):
        idx = order[s:s + CH]
        with torch.inference_mode():
            e = m.encode([texts[i] for i in idx], batch_size=bs, prompt=prompt,
                         prompt_name=prompt_name, normalize_embeddings=True,
                         convert_to_tensor=True, show_progress_bar=False)
        e = e.float().cpu().numpy().astype(np.float16)
        if out is None:
            out = np.empty((n, e.shape[1]), dtype=np.float16)
        out[idx] = e
        el = time.time() - t0
        done = min(n, s + CH)
        log(f"  {tag}: {done}/{n} encoded, {el:.0f}s, {done / el:.0f} rec/s")
    torch.cuda.synchronize()
    return out, time.time() - t0


def trunc_rate(m, texts, prompt):
    tok = m.tokenizer
    pre = prompt or ""
    ids = tok([pre + t for t in texts], add_special_tokens=True, truncation=False)["input_ids"]
    lens = np.array([len(x) for x in ids])
    return float((lens > MAX_SEQ).mean()), float(np.median(lens)), float(np.percentile(lens, 95))


def encode_model(key, ev, R, prev):
    cfg = MODELS[key]
    variants = ["full"] + (["name"] if cfg.get("name_variant") else [])
    if cfg.get("inst_variant"):
        variants.append("qinst")
    todo = [v for v in variants if not os.path.exists(cache_path(key, v))]
    if not todo:
        log(f"{key}: all embeddings cached")
        if key in prev.get("throughput", {}):
            R["throughput"][key] = prev["throughput"][key]
        return
    os.makedirs(os.path.dirname(cache_path(key, "x")), exist_ok=True)
    log(f"{key}: loading {cfg['hf']} ({cfg['dtype']})")
    torch.cuda.reset_peak_memory_stats()
    m, load_s = load_model(cfg)
    q_prompt = cfg.get("q_prompt")
    if cfg.get("q_prompt_name"):
        q_prompt = m.prompts.get(cfg["q_prompt_name"])
        if q_prompt is None:
            raise RuntimeError(f"prompt '{cfg['q_prompt_name']}' missing in {cfg['hf']}")
    d_prompt = cfg.get("d_prompt")
    log(f"{key}: loaded in {load_s:.1f}s; q_prompt={q_prompt!r} d_prompt={d_prompt!r}; "
        f"param dtype={next(m.parameters()).dtype}; max_seq_length={m.max_seq_length}")
    tp = R["throughput"].setdefault(key, {})
    tp.update(hf=cfg["hf"], dtype=cfg["dtype"], batch=cfg["bs"], max_seq=MAX_SEQ,
              load_s=round(load_s, 1), q_prompt=q_prompt, d_prompt=d_prompt)
    is_q = (ev.role == "query").to_numpy()
    tf = ev.text_full.to_numpy()
    rng = np.random.default_rng(SEED)
    tr = {}
    for c in COUNTRIES:
        in_c = (ev.eval_country == c).to_numpy()
        prow = np.nonzero(in_c & ~is_q)[0]
        qrow = np.nonzero(in_c & is_q)[0]
        prow = rng.choice(prow, size=min(20000, len(prow)), replace=False)
        qrow = rng.choice(qrow, size=min(3000, len(qrow)), replace=False)
        dr = trunc_rate(m, tf[prow].tolist(), d_prompt)
        qr = trunc_rate(m, tf[qrow].tolist(), q_prompt)
        tr[c] = dict(pool_trunc=round(dr[0], 4), pool_med_tok=dr[1], pool_p95_tok=dr[2],
                     query_trunc=round(qr[0], 4), query_med_tok=qr[1], query_p95_tok=qr[2])
    tp["tokens"] = tr
    log(f"{key}: token stats {tr}")

    for v in todo:
        cp = cache_path(key, v)
        if v == "qinst":
            texts = ev.text_full.to_numpy()[is_q].tolist()
            emb, sec = encode(m, texts, cfg["bs"], prompt=QWEN_INST, tag=f"{key}/qinst")
        else:
            col = ev["text_" + v].to_numpy()
            if q_prompt == d_prompt:
                emb, sec = encode(m, col.tolist(), cfg["bs"], prompt=q_prompt, tag=f"{key}/{v}")
            else:
                eq, s1 = encode(m, col[is_q].tolist(), cfg["bs"], prompt=q_prompt, tag=f"{key}/{v}/query")
                ed, s2 = encode(m, col[~is_q].tolist(), cfg["bs"], prompt=d_prompt, tag=f"{key}/{v}/pool")
                emb = np.empty((len(col), eq.shape[1]), dtype=np.float16)
                emb[is_q] = eq
                emb[~is_q] = ed
                sec = s1 + s2
        n = emb.shape[0]
        tp[v] = dict(n=n, sec=round(sec, 1), rps=round(n / sec, 1))
        log(f"{key}/{v}: {n} texts in {sec:.1f}s = {n / sec:.0f} rec/s, dim={emb.shape[1]}")
        np.save(cp + ".tmp.npy", emb)
        os.replace(cp + ".tmp.npy", cp)
        s3_put(cp, sub="cache/", wait=False)
    tp["peak_mem_gb"] = round(torch.cuda.max_memory_allocated() / 1e9, 2)
    del m
    gc.collect()
    torch.cuda.empty_cache()


# --------------------------------------------------------------------------- evaluation
def to_gpu(a):
    return F.normalize(torch.from_numpy(np.ascontiguousarray(a)).cuda().float(), dim=1)


@torch.no_grad()
def rank_eval(score_fn, nq, ci, want_stats=False, chunk=512):
    pair_q, pair_p = ci["pair_q"], ci["pair_p"]
    npairs = len(pair_q)
    ranks = np.empty(npairs, dtype=np.float64)  # mid-rank on ties
    tsc = np.empty(npairs, dtype=np.float32)
    top = np.empty((nq, 50), dtype=np.int32)
    hard = np.empty((nq, 20), dtype=np.float32)
    pq_t = torch.from_numpy(pair_q).cuda()
    pp_t = torch.from_numpy(pair_p).cuda()
    s_sum = s_sq = 0.0
    n_el = 0
    for s in range(0, nq, chunk):
        e = min(nq, s + chunk)
        S = score_fn(s, e)
        if want_stats:
            s_sum += S.sum(dtype=torch.float64).item()
            s_sq += (S.double() ** 2).sum().item()
            n_el += S.numel()
        lo, hi = np.searchsorted(pair_q, [s, e])
        r = pq_t[lo:hi] - s
        cidx = pp_t[lo:hi]
        t = S[r, cidx]
        for b in range(0, hi - lo, 256):
            rb, tb = r[b:b + 256], t[b:b + 256]
            Sb = S[rb]
            gt = (Sb > tb[:, None]).sum(1).double()
            eq = (Sb == tb[:, None]).sum(1).double()  # includes the pair itself
            ranks[lo + b: lo + b + len(rb)] = (gt + 1 + (eq - 1) / 2).cpu().numpy()
            del Sb
        tsc[lo:hi] = t.cpu().numpy()
        top[s:e] = S.topk(50, dim=1).indices.cpu().numpy()
        S[r, cidx] = -float("inf")
        hard[s:e] = S.topk(20, dim=1).values.cpu().numpy()
        del S
    stats = None
    if want_stats:
        mu = s_sum / n_el
        stats = (mu, float(np.sqrt(max(s_sq / n_el - mu * mu, 1e-12))))
    return ranks, tsc, hard, top, stats


def summarize(ranks, tsc, hard, ci, nq):
    m = {f"R@{k}": float((ranks <= k).mean()) for k in KS}
    best = np.full(nq, np.inf)
    np.minimum.at(best, ci["pair_q"], ranks)
    m["Hit@1"] = float((best <= 1).mean())
    m["R@1_ceiling"] = float(nq / len(ranks))
    m["MRR"] = float((1.0 / best).mean())
    m["MRR_pair"] = float((1.0 / ranks).mean())
    y = np.r_[np.ones(len(tsc)), np.zeros(hard.size)]
    m["AUC_hard20"] = float(roc_auc_score(y, np.r_[tsc, hard.ravel()]))
    m["n_queries"] = int(nq)
    m["n_pairs"] = int(len(ranks))
    m["cat_R@20"] = {k: {"n": int(v.sum()), "R@20": (float((ranks[v] <= 20).mean()) if v.any() else None)}
                     for k, v in ci["cats"].items()}
    return m


STATE = {}  # (label, country) -> dict(top=..., stats=...)


def eval_single(label, key, variant, ev, CI, R):
    E = np.load(cache_path(key, "full" if variant == "qinst" else variant), mmap_mode="r")
    Eq_inst = None
    if variant == "qinst":
        Eq_inst = np.load(cache_path(key, "qinst"))
        qall = np.nonzero((ev.role == "query").to_numpy())[0]
    R["metrics"].setdefault(label, {})
    for c in COUNTRIES:
        ci = CI[c]
        if Eq_inst is not None:
            Q = to_gpu(Eq_inst[np.searchsorted(qall, ci["qrows"])])
        else:
            Q = to_gpu(E[ci["qrows"]])
        P = to_gpu(E[ci["prows"]])
        t0 = time.time()
        ranks, tsc, hard, top, stats = rank_eval(lambda s, e: Q[s:e] @ P.T, len(ci["qrows"]), ci, want_stats=True)
        m = summarize(ranks, tsc, hard, ci, len(ci["qrows"]))
        m["cos_mean"], m["cos_std"] = stats
        m["eval_s"] = round(time.time() - t0, 1)
        R["metrics"][label][c] = m
        STATE[(label, c)] = dict(top=top, stats=stats)
        log(f"{label} {c}: " + " ".join(f"{k}={m[k]:.4f}" for k in ["R@1", "R@5", "R@20", "R@50", "Hit@1", "MRR", "AUC_hard20"])
            + f" ({m['eval_s']}s)")
        del Q, P
        torch.cuda.empty_cache()


def eval_ensemble(variant, ev, CI, R):
    a, b = ENS
    la, lb = label_for(a, variant), label_for(b, variant)
    if any((l, c) not in STATE for l in (la, lb) for c in COUNTRIES):
        log(f"ensemble {variant}: missing inputs, skipped")
        return
    Ea = np.load(cache_path(a, variant), mmap_mode="r")
    Eb = np.load(cache_path(b, variant), mmap_mode="r")
    lz = f"ens-z({a}+{b})" + ("" if variant == "full" else f" [{variant}]")
    lu = f"union({a}|{b})" + ("" if variant == "full" else f" [{variant}]")
    R["metrics"].setdefault(lz, {})
    R["union"].setdefault(lu, {})
    for c in COUNTRIES:
        ci = CI[c]
        nq = len(ci["qrows"])
        Qa, Pa = to_gpu(Ea[ci["qrows"]]), to_gpu(Ea[ci["prows"]])
        Qb, Pb = to_gpu(Eb[ci["qrows"]]), to_gpu(Eb[ci["prows"]])
        ma, sa = STATE[(la, c)]["stats"]
        mb, sb = STATE[(lb, c)]["stats"]
        fn = lambda s, e: 0.5 * ((Qa[s:e] @ Pa.T - ma) / sa + (Qb[s:e] @ Pb.T - mb) / sb)
        ranks, tsc, hard, top, _ = rank_eval(fn, nq, ci)
        m = summarize(ranks, tsc, hard, ci, nq)
        R["metrics"][lz][c] = m
        log(f"{lz} {c}: " + " ".join(f"{k}={m[k]:.4f}" for k in ["R@1", "R@5", "R@20", "R@50", "Hit@1", "MRR", "AUC_hard20"]))
        del Qa, Pa, Qb, Pb
        torch.cuda.empty_cache()
        # union of each model's top-K
        ta, tb = STATE[(la, c)]["top"], STATE[(lb, c)]["top"]
        pq, pp = ci["pair_q"], ci["pair_p"]
        u = {}
        for K in KS:
            ina = (ta[pq, :K] == pp[:, None]).any(1)
            inb = (tb[pq, :K] == pp[:, None]).any(1)
            hit = ina | inb
            srt = np.sort(np.hstack([ta[:, :K], tb[:, :K]]), axis=1)
            size = 1 + (np.diff(srt, axis=1) != 0).sum(1)
            u[f"K={K}"] = dict(recall=float(hit.mean()), mean_cands=float(size.mean()),
                               only_a=float((ina & ~inb).mean()), only_b=float((inb & ~ina).mean()))
            if K == 20:
                u["cat_R@20"] = {k: {"n": int(v.sum()), "R@20": (float(hit[v].mean()) if v.any() else None)}
                                 for k, v in ci["cats"].items()}
        R["union"][lu][c] = u
        log(f"{lu} {c}: " + " ".join(f"{k}:{v['recall']:.4f}/{v['mean_cands']:.1f}c" for k, v in u.items() if k.startswith("K=")))


def label_for(key, variant):
    return key if variant == "full" else (f"{key} +inst" if variant == "qinst" else f"{key} [{variant}]")


# --------------------------------------------------------------------------- reporting
def fmt_tables(R):
    L = []
    add = L.append
    meta = R["meta"]
    add(f"AMLC 2026 zero-shot embedding eval — started {meta['started']}, "
        f"{'finished ' + meta['finished'] if meta.get('finished') else 'PARTIAL'}")
    add(f"GPU: {meta['gpu']} | torch {meta['torch']} | transformers {meta['transformers']} | "
        f"sentence-transformers {meta['st']} | max_seq_length={MAX_SEQ}")
    add("Eval set: per country, S1 queries with >=1 labelled match; pool = all their true S2/S3 matches "
        "+ random same-country S2/S3 distractors (seeded hash sample). Text = name | address.")
    for c, s in R.get("eval_set", {}).items():
        add(f"  {c}: {s['queries']} queries, {s['pairs']} true pairs, pool {s['pool']} "
            f"({s['distractors']} distractors)")
    add("Metrics: R@K = share of true pairs ranked in the top K of the pool for their S1 (pair-level; "
        "R@1 is capped at n_queries/n_pairs because an S1 has ~3.7 matches but one rank-1 slot); "
        "Hit@1 = share of S1 whose top-1 is a true match; MRR = mean over S1 of 1/rank of its best-ranked "
        "true match; MRRp = mean over pairs of 1/rank; AUC = ROC-AUC of cosine, true pairs vs each S1's "
        "top-20 non-matches (hard negatives). Ties get the mid-rank.")
    add("")

    add("== Throughput on L4 (full text; query side with prompt + pool side) ==")
    hdr = f"{'model':<12} {'dtype':<9} {'bs':>4} {'load s':>7} {'texts':>8} {'enc s':>8} {'rec/s':>8} " \
          f"{'name rec/s':>10} {'peak GB':>8}  {'trunc>64 pool/query US':>23}  {'trunc>64 pool/query IN':>23}"
    add(hdr)
    for k, t in R["throughput"].items():
        full = t.get("full", {})
        nm = t.get("name", {})
        tok = t.get("tokens", {})

        def tr(c):
            d = tok.get(c)
            return f"{d['pool_trunc']:.1%} / {d['query_trunc']:.1%}" if d else "-"

        add(f"{k:<12} {t.get('dtype', ''):<9} {t.get('batch', ''):>4} {t.get('load_s', ''):>7} "
            f"{full.get('n', ''):>8} {full.get('sec', ''):>8} {full.get('rps', ''):>8} {nm.get('rps', '-'):>10} "
            f"{t.get('peak_mem_gb', ''):>8}  {tr('US'):>23}  {tr('India'):>23}")
    add("")

    for c in COUNTRIES:
        add(f"== Retrieval metrics — {c} ==")
        cap = next((per[c]["R@1_ceiling"] for per in R["metrics"].values() if c in per), None)
        if cap is not None:
            add(f"(R@1 ceiling = {cap:.4f})")
        add(f"{'variant':<36} {'R@1':>7} {'R@5':>7} {'R@20':>7} {'R@50':>7} {'Hit@1':>7} {'MRR':>7} {'MRRp':>7} {'AUC':>7}")
        for lab, per in R["metrics"].items():
            if c not in per:
                continue
            m = per[c]
            add(f"{lab:<36} {m['R@1']:>7.4f} {m['R@5']:>7.4f} {m['R@20']:>7.4f} {m['R@50']:>7.4f} "
                f"{m['Hit@1']:>7.4f} {m['MRR']:>7.4f} {m['MRR_pair']:>7.4f} {m['AUC_hard20']:>7.4f}")
        add("")

    if R["union"]:
        add("== Union of each model's top-K (recall of true pairs / mean candidate count per S1) ==")
        for c in COUNTRIES:
            add(f"-- {c}")
            add(f"{'variant':<36} " + " ".join(f"{'K=' + str(k) + ' rec':>10} {'cands':>6}" for k in KS)
                + f" {'onlyA@20':>9} {'onlyB@20':>9}")
            for lab, per in R["union"].items():
                if c not in per:
                    continue
                u = per[c]
                add(f"{lab:<36} " + " ".join(f"{u[f'K={k}']['recall']:>10.4f} {u[f'K={k}']['mean_cands']:>6.1f}" for k in KS)
                    + f" {u['K=20']['only_a']:>9.4f} {u['K=20']['only_b']:>9.4f}")
        add("  (onlyA/onlyB = share of true pairs found in the top-20 of only the first / only the second model)")
        add("")

    for c in COUNTRIES:
        add(f"== Recall@20 by pair category — {c} (categories overlap; 'other' = none of the flags) ==")
        ns = None
        for per in R["metrics"].values():
            if c in per:
                ns = {k: v["n"] for k, v in per[c]["cat_R@20"].items()}
                break
        if ns is None:
            continue
        add(f"{'variant':<36} {'all':>7} " + " ".join(f"{k[:12]:>12}" for k in CATS))
        add(f"{'(n pairs)':<36} {'':>7} " + " ".join(f"{ns[k]:>12}" for k in CATS))
        rows = [(lab, per[c]["R@20"], per[c]["cat_R@20"]) for lab, per in R["metrics"].items() if c in per]
        rows += [(lab + " @20", per[c]["K=20"]["recall"], per[c]["cat_R@20"]) for lab, per in R["union"].items() if c in per]
        for lab, allr, cr in rows:
            add(f"{lab:<36} {allr:>7.4f} " + " ".join(
                (f"{cr[k]['R@20']:>12.4f}" if cr[k]["R@20"] is not None else f"{'-':>12}") for k in CATS))
        add("")

    add("== Name-only vs name|address text, Recall@20 ==")
    add(f"{'model':<36} {'US full':>8} {'US name':>8} {'IN full':>8} {'IN name':>8}")
    for base in list(ENS) + [f"ens-z({ENS[0]}+{ENS[1]})"]:
        full = R["metrics"].get(base, {})
        nm = R["metrics"].get(f"{base} [name]", {})
        if not full and not nm:
            continue
        g = lambda d, c: (f"{d[c]['R@20']:.4f}" if c in d else "-")
        add(f"{base:<36} {g(full,'US'):>8} {g(nm,'US'):>8} {g(full,'India'):>8} {g(nm,'India'):>8}")
    add("")
    if R["failures"]:
        add("== Failures ==")
        for k, v in R["failures"].items():
            add(f"{k}: {v}")
        add("")
    return "\n".join(L)


def save(R):
    jp, tp = path("embed_eval_results.json"), path("embed_eval_results.txt")
    with open(jp + ".tmp", "w") as f:
        json.dump(R, f, indent=1, default=float)
    os.replace(jp + ".tmp", jp)
    txt = fmt_tables(R)
    with open(tp, "w") as f:
        f.write(txt + "\n")
    s3_put(jp)
    s3_put(tp)
    return txt


# --------------------------------------------------------------------------- main
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--models", default=",".join(MODELS))
    ap.add_argument("--smoke", action="store_true")
    ap.add_argument("--rebuild", action="store_true")
    ap.add_argument("--no-upload", action="store_true")
    args = ap.parse_args()
    if args.smoke:
        Cfg.n_q, Cfg.n_dist, Cfg.suffix, Cfg.upload = 300, 4000, "_smoke", False
    if args.no_upload:
        Cfg.upload = False
    keys = [k for k in args.models.split(",") if k]
    import transformers
    import sentence_transformers
    prev = {}
    if os.path.exists(path("embed_eval_results.json")):
        try:
            prev = json.load(open(path("embed_eval_results.json")))
        except Exception:
            prev = {}
    R = dict(meta=dict(started=f"{datetime.datetime.now():%Y-%m-%d %H:%M:%S}", finished=None,
                       gpu=torch.cuda.get_device_name(0), torch=torch.__version__,
                       transformers=transformers.__version__, st=sentence_transformers.__version__,
                       n_q=Cfg.n_q, n_dist=Cfg.n_dist, seed=SEED, max_seq=MAX_SEQ, qwen_inst=QWEN_INST),
             eval_set={}, throughput={}, metrics={}, union={}, failures={})
    log("config", R["meta"])
    ev = build_eval_set(args.rebuild)
    CI = country_index(ev)
    for c in COUNTRIES:
        ci = CI[c]
        R["eval_set"][c] = dict(queries=len(ci["qrows"]), pairs=len(ci["pair_p"]), pool=len(ci["prows"]),
                                distractors=len(ci["prows"]) - len(ci["pair_p"]),
                                cats={k: int(v.sum()) for k, v in ci["cats"].items()})
    save(R)

    for key in keys:
        cfg = MODELS[key]
        try:
            encode_model(key, ev, R, prev)
        except Exception as e:
            log(f"{key}: ENCODE FAILED\n{traceback.format_exc()}")
            R["failures"][key] = f"encode/load: {type(e).__name__}: {str(e)[:1500]}"
            gc.collect()
            torch.cuda.empty_cache()
            save(R)
            continue
        variants = ["full"] + (["name"] if cfg.get("name_variant") else []) + (["qinst"] if cfg.get("inst_variant") else [])
        for v in variants:
            try:
                eval_single(label_for(key, v), key, v, ev, CI, R)
            except Exception as e:
                log(f"{key}/{v}: EVAL FAILED\n{traceback.format_exc()}")
                R["failures"][f"{key}/{v}"] = f"eval: {type(e).__name__}: {str(e)[:1500]}"
        txt = save(R)
        log("tables so far:\n" + txt)

    if all(k in keys for k in ENS):
        for v in ["full", "name"]:
            try:
                eval_ensemble(v, ev, CI, R)
            except Exception as e:
                log(f"ensemble/{v}: FAILED\n{traceback.format_exc()}")
                R["failures"][f"ensemble/{v}"] = f"{type(e).__name__}: {str(e)[:1500]}"
    R["meta"]["finished"] = f"{datetime.datetime.now():%Y-%m-%d %H:%M:%S}"
    txt = save(R)
    log("FINAL TABLES:\n" + txt)
    log("EMBED_EVAL_DONE")


if __name__ == "__main__":
    main()