scripts/runners/run_rerank.py

#!/usr/bin/env python3
"""
Scherm benchmark — Reranker runner (bge-reranker-v2-m3, cross-encoder).

Reranker NÃO é embedding: recebe (query, documento) e retorna score de relevância.
vLLM serve com --task score, endpoint /score (ou /v1/score). Mede throughput
(pares/s) e latência sob concorrência. Mesma filosofia ACM (10 reps, mediana+IQR).

Uso:
  python run_rerank.py --served-model BAAI/bge-reranker-v2-m3 --base-url http://localhost:8000 \
      --concurrencies 1 8 32 64 --reps 10 --out /work/results --tag GPU --run-id RID
"""
import argparse, json, os, statistics, time, subprocess, platform, urllib.request
from datetime import datetime, timezone
from concurrent.futures import ThreadPoolExecutor

def sh(c): return subprocess.run(c, shell=True, capture_output=True, text=True)
def gpu_name():
    return (sh("nvidia-smi --query-gpu=name --format=csv,noheader").stdout.strip().splitlines() or ["?"])[0]
def gpu_driver():
    return (sh("nvidia-smi --query-gpu=driver_version --format=csv,noheader").stdout.strip().splitlines() or [""])[0]
def vram_used():
    v=[int(x) for x in sh("nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits").stdout.split() if x.strip().isdigit()]
    return max(v) if v else None

def quantiles(xs):
    xs=sorted(x for x in xs if x is not None)
    if not xs: return {}
    n=len(xs)
    def pct(p):
        if n==1: return xs[0]
        k=(n-1)*p; f=int(k); c=min(f+1,n-1); return xs[f]+(xs[c]-xs[f])*(k-f)
    mean=statistics.mean(xs); std=statistics.pstdev(xs) if n>1 else 0.0
    return {"n":n,"mean":round(mean,3),"std":round(std,3),"median":round(pct(.5),3),
            "q1":round(pct(.25),3),"q3":round(pct(.75),3),"p95":round(pct(.95),3),
            "p99":round(pct(.99),3),"min":round(xs[0],3),"max":round(xs[-1],3),
            "ci95_halfwidth":round(1.96*std/(n**.5),3) if n>1 else 0.0}

QUERY="Qual o prazo para recurso de apelação no processo civil?"
DOCS=["O prazo para apelação é de 15 dias úteis contados da intimação da sentença.",
      "A petição inicial deve conter o pedido e suas especificações conforme o CPC.",
      "Trata-se de embargos de declaração opostos contra acórdão da turma.",
      "O réu foi citado por edital após tentativas frustradas de citação pessoal.",
      "Defiro a gratuidade de justiça ao autor nos termos da lei 1.060/50."]*4  # 20 docs

def one_request(base_url, model):
    body=json.dumps({"model":model,"query":QUERY,"documents":DOCS}).encode()
    req=urllib.request.Request(f"{base_url}/score",data=body,headers={"Content-Type":"application/json"})
    t0=time.time()
    try:
        with urllib.request.urlopen(req,timeout=180) as r:
            d=json.load(r)
        dt=time.time()-t0
        n=len(d.get("data",d.get("results",[]))) or len(DOCS)
        return {"latency_s":dt,"n_pairs":n,"ok":True}
    except Exception as e:
        # fallback p/ endpoint /v1/rerank
        try:
            body2=json.dumps({"model":model,"query":QUERY,"documents":DOCS}).encode()
            req2=urllib.request.Request(f"{base_url}/v1/rerank",data=body2,headers={"Content-Type":"application/json"})
            t1=time.time()
            with urllib.request.urlopen(req2,timeout=180) as r:
                d=json.load(r)
            return {"latency_s":time.time()-t1,"n_pairs":len(DOCS),"ok":True}
        except Exception as e2:
            return {"ok":False,"err":str(e)[:80]+" | "+str(e2)[:80]}

def main():
    ap=argparse.ArgumentParser()
    ap.add_argument("--served-model",required=True)
    ap.add_argument("--base-url",default="http://localhost:8000")
    ap.add_argument("--concurrencies",nargs="+",type=int,default=[1,8,32,64])
    ap.add_argument("--reps",type=int,default=10); ap.add_argument("--warmups",type=int,default=1)
    ap.add_argument("--out",required=True); ap.add_argument("--tag",default=""); ap.add_argument("--run-id",default="")
    a=ap.parse_args()
    os.makedirs(a.out,exist_ok=True)
    env={"timestamp_utc":datetime.now(timezone.utc).isoformat(),"modality":"reranker",
         "gpu_name":gpu_name(),"nvidia_driver":gpu_driver(),"served_model":a.served_model,
         "n_docs":len(DOCS),"reps":a.reps,"python":platform.python_version()}
    safe=a.served_model.replace("/","_"); raw={"env":env,"points":[]}; rows=[]
    for conc in a.concurrencies:
        for _ in range(a.warmups): one_request(a.base_url,a.served_model)
        pairs_s=[]; lat=[]; vr=[]
        for _ in range(a.reps):
            t0=time.time()
            with ThreadPoolExecutor(max_workers=conc) as ex:
                res=list(ex.map(lambda _:one_request(a.base_url,a.served_model),range(conc)))
            wall=time.time()-t0
            ok=[r for r in res if r.get("ok")]
            if ok:
                pairs_s.append(sum(r["n_pairs"] for r in ok)/wall)
                lat.append(statistics.mean([r["latency_s"] for r in ok])*1000)
                vr.append(vram_used())
        agg={"pairs_per_s":quantiles(pairs_s),"latency_ms":quantiles(lat),"vram_mib":quantiles(vr)}
        raw["points"].append({"concurrency":conc,"n_ok":len(pairs_s),"agg":agg})
        g=lambda k,kk:agg.get(k,{}).get(kk,"")
        rows.append([gpu_name(),a.served_model,conc,len(pairs_s),g("pairs_per_s","median"),
                     g("pairs_per_s","q3"),g("latency_ms","median"),g("vram_mib","median")])
        print(f"  [RERANK {a.served_model}] conc={conc} n={len(pairs_s)} pairs/s(med)={g('pairs_per_s','median')} "
              f"lat(med)={g('latency_ms','median')}ms vram={g('vram_mib','median')}MiB",flush=True)
    sfx=f"{a.tag}_{a.run_id}" if a.run_id else a.tag
    with open(f"{a.out}/rerank_{sfx}_{safe}.json","w") as f: json.dump(raw,f,indent=2)
    csv=f"{a.out}/rerank_{sfx}_{safe}.csv"; new=not os.path.exists(csv)
    with open(csv,"a") as f:
        if new: f.write("gpu,model,concurrency,n_ok,pairs_per_s_median,pairs_per_s_q3,latency_ms_median,vram_mib_median\n")
        for r in rows: f.write(",".join(str(x) for x in r)+"\n")
    print(f"[OK] rerank {a.served_model} -> {a.out} ({csv})",flush=True)

if __name__=="__main__": main()