Blame for code/berx/ce_score.py

"""D. Cross-encoder scoring, shardable across machines, and the dual-CE blend.



WHY BOTH ENCODERS. Averaging mDeBERTa-v3 with bge-reranker-v2-m3 measured +0.0011 CE-only val

F0.5, against +0.0023 for doubling the training data of one of them. The average costs no

training at all, only a second forward pass, so it is the better trade whenever a GPU-hour is

the scarce resource. Note the two numbers are not directly comparable to the final metric: a

separate end-to-end test put the post-stacker gain at +0.00032, because the stacker already

recovers most of what the blend adds. Budget for the smaller number.



A CAVEAT THAT MATTERS FOR WHICH CHECKPOINT YOU BLEND. Model-3's reranker saw 4,581 of

model-4's val records and 8,977 of its stack records during training. Any dual-CE gain

measured on model-4's val with THAT checkpoint is partly leakage, not signal. Blend

checkpoints trained on the same split as the run you are evaluating, or accept that the val

number is optimistic and judge on the leaderboard.



THROUGHPUT. Pairs are sorted by tokenised length before batching, so a batch is padded to its

own longest member rather than to the corpus maximum. That alone is most of the difference

between ~150 pairs/s and ~2,400 pairs/s on a shared card.



RESUMPTION. The checkpoint stores a count of completed rows in LENGTH-SORTED order, and the

scores are written back through the sort permutation only at the end. Do not "simplify" this

to input order: the resume prefix would no longer be contiguous and a restart would silently

score the wrong rows.

"""
from __future__ import annotations

import json
import os
import time

import numpy as np

os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")


def pair_text(name, addr, country) -> str:
    """The exact string format the shipped cross-encoders were fine-tuned on.



    Changing the separators or the field order here silently degrades a fine-tuned model,

    because the tokeniser sees a format it never saw in training. It is also what made a

    cross-model ensemble possible at all: both encoders were trained on this same rendering.

    """
    return f"name: {name} | addr: {addr} | country: {country}"


def load_model(path_or_id: str, device: str = "cuda", compile_model: bool = False):
    """Load a sequence-classification cross-encoder for scoring.



    fp32 weights are requested even though inference runs under autocast. Loading fp16 master

    weights is how a previous run produced NaNs on optimiser step 1; for pure inference it is

    merely wasteful, but keeping one loading path for both avoids reintroducing that.

    """
    import torch
    from transformers import AutoModelForSequenceClassification, AutoTokenizer

    tok = AutoTokenizer.from_pretrained(path_or_id)
    model = AutoModelForSequenceClassification.from_pretrained(path_or_id, dtype=torch.float32)
    model.eval().to(device)
    if compile_model:
        try:
            model = torch.compile(model, mode="max-autotune")
        except Exception as e:                                  # not fatal, just slower
            print(f"  torch.compile unavailable: {e}")
    return tok, model


@np.errstate(over="ignore")
def _sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))


def score_pairs(texts_a, texts_b, tok, model, device: str = "cuda", batch: int = 128,

                max_len: int = 160, ckpt: str | None = None, ckpt_every: int = 200_000,

                log_every: int = 50, output: str = "logit"):
    """Score a list of (a, b) text pairs. Returns float32 scores in INPUT order.



    `output` MUST match the scale the consuming model was trained on:

      "logit" (default) - the raw head output

      "prob"            - sigmoid / softmax of it



    THIS DEFAULT IS NOT COSMETIC. model-4's stored `ce` column is a RAW LOGIT: range

    -11.06 to 9.63, mean 3.46, 98% of values outside [0, 1] (y=1 mean 8.66, y=0 mean -6.35).

    Scoring new candidate pairs as probabilities and appending them to that column would give

    the stacker a feature on two scales - old rows in [-11, 10], new rows in [0, 1] - so every

    new pair would land where the model reads "strong negative". It would validate, score

    plausibly, and be wrong exactly on the pairs the rescue channels exist to recover.



    `ckpt_every` defaults to 200,000 rather than the 2,000,000 used on the college box.

    A Colab session can disappear without warning, and 2M rows is roughly 15 minutes of work

    to redo; 200k is under two. Write the checkpoint to Drive, never to the VM disk.

    """
    import torch

    n = len(texts_a)
    assert len(texts_b) == n, "pair arrays differ in length"
    lens = np.fromiter((len(a) + len(b) for a, b in zip(texts_a, texts_b)), np.int32, n)
    order = np.argsort(lens, kind="stable")                     # short batches first

    scores_sorted = np.zeros(n, dtype=np.float32)
    start = 0
    if ckpt and os.path.exists(ckpt + ".json"):
        meta = json.load(open(ckpt + ".json"))
        if meta.get("n") == n:
            start = int(meta["done"])
            scores_sorted[:start] = np.load(ckpt + ".npy")[:start]
            print(f"  resuming at {start:,}/{n:,}")
        else:
            print(f"  checkpoint is for n={meta.get('n')}, this run has n={n}; ignoring")

    t0 = time.time()
    last_ck = start
    with torch.inference_mode():
        for bi, s in enumerate(range(start, n, batch)):
            e = min(s + batch, n)
            idx = order[s:e]
            enc = tok([texts_a[i] for i in idx], [texts_b[i] for i in idx],
                      padding=True, truncation=True, max_length=max_len,
                      return_tensors="pt").to(device)
            with torch.autocast("cuda", dtype=torch.float16, enabled=device.startswith("cuda")):
                logits = model(**enc).logits
            lg = logits.float().cpu().numpy()
            if output == "logit":
                # one column -> that logit; two -> the positive-class margin
                scores_sorted[s:e] = lg[:, 0] if lg.shape[1] == 1 else lg[:, -1] - lg[:, 0]
            else:
                scores_sorted[s:e] = _sigmoid(lg[:, 0]) if lg.shape[1] == 1 \
                    else _softmax_pos(lg)
            if ckpt and e - last_ck >= ckpt_every:
                _save_ckpt(ckpt, scores_sorted, e, n)
                last_ck = e
            if log_every and bi % log_every == 0:
                done = e / n
                el = time.time() - t0
                rate = (e - start) / max(el, 1e-9)
                print(f"  {e:>10,}/{n:,} ({done:6.1%})  {rate:7.0f} pairs/s  "
                      f"eta {(n - e) / max(rate, 1e-9):6.0f}s", flush=True)

    if ckpt:
        _save_ckpt(ckpt, scores_sorted, n, n)
    out = np.empty(n, dtype=np.float32)
    out[order] = scores_sorted                                  # undo the length sort
    return out


def _softmax_pos(lg):
    m = lg.max(axis=1, keepdims=True)
    ex = np.exp(lg - m)
    return (ex[:, -1] / ex.sum(axis=1)).astype(np.float32)


def _save_ckpt(ckpt: str, scores, done: int, n: int):
    np.save(ckpt + ".npy", scores)
    with open(ckpt + ".json", "w") as fh:
        json.dump({"done": int(done), "n": int(n)}, fh)


def blend(score_a: np.ndarray, score_b: np.ndarray, w: float = 0.5,

          mode: str = "rank") -> np.ndarray:
    """Combine two cross-encoder score vectors.



    `mode="rank"` averages normalised ranks rather than probabilities. Two encoders fine-tuned

    separately are not calibrated to each other, so averaging raw probabilities lets whichever

    one happens to be more confident dominate; rank averaging is invariant to that. `mode="p"`

    is the plain probability average, kept because it is what the +0.0011 measurement used.

    """
    if mode == "p":
        return (w * score_a + (1 - w) * score_b).astype(np.float32)
    ra = _rank01(score_a)
    rb = _rank01(score_b)
    return (w * ra + (1 - w) * rb).astype(np.float32)


def _rank01(x):
    o = np.argsort(x, kind="stable")
    r = np.empty(len(x), dtype=np.float32)
    r[o] = np.arange(len(x), dtype=np.float32)
    return r / max(len(x) - 1, 1)