| """Step D. Score one shard with one or both cross-encoders. Identical on the box and on Colab.
|
|
|
| CUDA_VISIBLE_DEVICES=1 python scripts/05_ce_score.py \
|
| --shard work/shards/test_shard1of4.parquet \
|
| --model work/ce_model_A --out work/scored/shard1_bge.parquet
|
|
|
| The Colab notebook calls exactly this code path through the berx package, so a bug found on
|
| one lane is fixed for all four.
|
|
|
| --batch defaults to 0, meaning "probe it". A shared card has an unpredictable amount of free
|
| memory, and a fixed batch size is either too small (wasting the card) or too large (an OOM an
|
| hour into the run). The probe doubles the batch until it OOMs, then backs off one step.
|
| """
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import os
|
| import sys
|
| import time
|
|
|
| import numpy as np
|
| import pandas as pd
|
|
|
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
| from berx import ce_score as CE
|
|
|
|
|
| def probe_batch(tok, model, texts_a, texts_b, device, max_len, cap=1024):
|
| """Find a batch size that fits, using the LONGEST pairs so the answer is safe for all."""
|
| import torch
|
| lens = np.fromiter((len(a) + len(b) for a, b in zip(texts_a, texts_b)), np.int32,
|
| len(texts_a))
|
| worst = np.argsort(lens)[-cap:]
|
| b, best = 16, 16
|
| while b <= cap:
|
| idx = worst[-b:]
|
| try:
|
| with torch.inference_mode():
|
| 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")):
|
| model(**enc)
|
| best = b
|
| b *= 2
|
| except RuntimeError as e:
|
| if "out of memory" not in str(e).lower():
|
| raise
|
| torch.cuda.empty_cache()
|
| break
|
| torch.cuda.empty_cache()
|
| return max(16, best // 2)
|
|
|
|
|
| def main():
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--shard", required=True)
|
| ap.add_argument("--model", required=True, help="local dir or HF id")
|
| ap.add_argument("--out", required=True)
|
| ap.add_argument("--score-col", default="ce")
|
| ap.add_argument("--device", default="cuda")
|
| ap.add_argument("--batch", type=int, default=0, help="0 = probe")
|
| ap.add_argument("--max-len", type=int, default=160)
|
| ap.add_argument("--ckpt", default="", help="checkpoint prefix; on Colab put it on Drive")
|
| ap.add_argument("--ckpt-every", type=int, default=200_000)
|
| ap.add_argument("--compile", action="store_true")
|
| ap.add_argument("--output", default="logit", choices=["logit", "prob"],
|
| help="MUST be 'logit' to match model-4's stored ce column")
|
| a = ap.parse_args()
|
|
|
| df = pd.read_parquet(a.shard)
|
| ta, tb = df["text_a"].tolist(), df["text_b"].tolist()
|
| print(f"shard {a.shard}: {len(df):,} pairs")
|
|
|
| tok, model = CE.load_model(a.model, a.device, compile_model=a.compile)
|
| batch = a.batch or probe_batch(tok, model, ta, tb, a.device, a.max_len)
|
| print(f"batch={batch} max_len={a.max_len} model={a.model}")
|
|
|
| t0 = time.time()
|
| s = CE.score_pairs(ta, tb, tok, model, a.device, batch=batch, max_len=a.max_len,
|
| ckpt=a.ckpt or None, ckpt_every=a.ckpt_every,
|
| output=a.output)
|
| el = time.time() - t0
|
|
|
| out = df[["q", "c"]].copy()
|
| out[a.score_col] = s
|
| os.makedirs(os.path.dirname(os.path.abspath(a.out)) or ".", exist_ok=True)
|
| out.to_parquet(a.out, index=False, compression="zstd")
|
| print(f"wrote {a.out} {el/60:.1f} min {len(df)/max(el,1e-9):,.0f} pairs/s")
|
| print(f" score mean {s.mean():.4f} min {s.min():.3f} max {s.max():.3f} "
|
| f">0 {(s > 0).mean():.2%}")
|
| if a.output == "logit" and s.min() >= 0.0 and s.max() <= 1.0:
|
| print(" WARNING: every score is in [0,1]. That is a probability, not a logit - "
|
| "check the model head before merging into model-4's ce column.")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
