File size: 7,111 Bytes
0c64c71
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
"""Source-grounded LLM judging for the two summarization families (the only judge-scored families).

Modes
  primary : judge_qwen3_30b_a3b, T=0, every response (+ control candidates: gold reference = positive control, reference of another article = negative control)
  repeat  : same judge, T=0.7, 3 samples on the reliability subset  -> within-judge noise (ICC)
  alt     : judge_gemma3_27b (different family), T=0, reliability subset -> cross-judge agreement
Unparsable outputs are retried (T=0.2, 6000 tokens) up to 2 rounds, then labelled unparsed (Q missing, label_confidence 0).  Empty final answers are scored 0 without a judge call.
Usage: python judge.py --mode primary [--models a,b] [--wave w1] ;  outputs scores/judge/raw_<mode>.jsonl and scores/judge/parsed_<mode>.jsonl
"""
import argparse
import hashlib
import json
import random
import sys
import time
from pathlib import Path

import pandas as pd

sys.path.insert(0, "src")
sys.path.insert(0, ".")
from llmroute.evaluation.extract import split_thinking
from llmroute.orouter2 import judge as J
from llmroute.seqroute import serve as S
from llmroute.seqroute.client import read_ids, run_jobs

ROOT = Path("/mnt/localssd/seqroute1m")
OUT = ROOT / "scores/judge"
SPECS = {
    "primary": dict(id="judge_qwen3_30b_a3b", tp=2, serve_args=[], max_model_len=12288, temperature=0.0, top_p=1.0, chat_template_kwargs={}),
    "repeat": dict(id="judge_qwen3_30b_a3b", tp=2, serve_args=[], max_model_len=12288, temperature=0.7, top_p=0.95, chat_template_kwargs={}),
    "alt": dict(id="judge_gemma3_27b", tp=1, serve_args=["--limit-mm-per-prompt", json.dumps({"image": 0, "video": 0, "audio": 0})], max_model_len=12288, temperature=0.0, top_p=1.0, chat_template_kwargs={}),
}
SEED = 20261010
FAMS = ("summ_news", "summ_abstractive")


def hh(*p):
    return hashlib.sha1("|".join(map(str, p)).encode()).hexdigest()


def reliability_subset(q: pd.DataFrame, n_per_family: int = 150) -> set:
    out = set()
    for fam in FAMS:
        ids = sorted(q[q.task_family == fam].query_id, key=lambda x: hh("rel", SEED, x))
        out |= set(ids[:n_per_family])
    return out


def build_items(q, models, mode, wave_ids):
    qj = q[q.task_family.isin(FAMS)].set_index("query_id")
    rel = reliability_subset(q)
    items, zeros = [], []
    for m in models:
        f = ROOT / "responses" / f"{m}.jsonl"
        if not f.exists():
            continue
        for l in open(f):
            r = json.loads(l)
            qid = r["id"]
            if qid not in qj.index or (wave_ids is not None and qid not in wave_ids) or (mode != "primary" and qid not in rel):
                continue
            fin, _ = split_thinking(r["text"], r.get("reasoning"), r.get("finish_reason"))
            if not fin.strip():
                zeros.append(f"{m}|{qid}")
                continue
            items.append((f"{m}|{qid}", qid, fin))
    if mode == "primary":      # controls
        for fam in FAMS:
            ids = sorted(qj[qj.task_family == fam].index, key=lambda x: hh("ctrl", SEED, x))[:100]
            for i, qid in enumerate(ids):
                other = qj.loc[ids[(i + 37) % len(ids)]]
                items.append((f"ctrl_ref|{qid}", qid, qj.loc[qid].reference))
                items.append((f"ctrl_neg|{qid}", qid, other.reference))
    return qj, items, zeros


def parse_any(text, style):
    return J.parse_summ(text)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--mode", required=True, choices=list(SPECS))
    ap.add_argument("--models", default="")
    ap.add_argument("--wave", default="")
    ap.add_argument("--queries", default=str(ROOT / "queries/master_queries.parquet"))
    a = ap.parse_args()
    OUT.mkdir(parents=True, exist_ok=True)
    q = pd.read_parquet(a.queries)
    models = [m["id"] for m in json.load(open(ROOT / "manifests/models.json"))]
    if a.models:
        models = [m for m in models if m in a.models.split(",")]
    wave_ids = set(json.load(open(ROOT / "manifests" / f"wave_{a.wave}.json"))) if a.wave else None
    qj, items, zeros = build_items(q, models, a.mode, wave_ids)
    raw = OUT / f"raw_{a.mode}.jsonl"
    reps = 3 if a.mode == "repeat" else 1
    jobs = []
    for rid, qid, fin in items:
        row = qj.loc[qid]
        style = json.loads(row.payload)["style"]
        prompt = J.prompt_summ(style, json.loads(row.payload)["source"], fin)
        for k in range(reps):
            jobs.append(dict(id=f"{rid}#r{k}", prompt=prompt, max_tokens=3000, seed=1000 + k))
    have = read_ids(raw)
    todo = [j for j in jobs if j["id"] not in have]
    print(f"{a.mode}: {len(items)} items, {len(zeros)} empty (score 0), {len(jobs)} calls, {len(todo)} to run", flush=True)
    spec = SPECS[a.mode]
    if todo:
        S.stop_servers()
        ports = S.start_servers(spec, max_num_seqs=64)
        S.wait_ready(ports)
        params = dict(temperature=spec["temperature"], top_p=spec["top_p"], chat_template_kwargs=spec["chat_template_kwargs"], logprobs=False)
        t0 = time.time()
        run_jobs(todo, raw, spec["id"], ports, params, per_server=64, every=2000)
        # retry unparsable outputs: larger budget, T=0.2, two rounds
        for rnd in range(4):
            recs = {}
            for l in open(raw):
                r = json.loads(l)
                recs[r["id"]] = r
            bad = [j for j in jobs if (j["id"] not in recs or parse_any(recs[j["id"]]["text"], None) is None) and f"{j['id']}~rt{rnd}" not in recs]
            if not bad:
                break
            print(f"retry round {rnd}: {len(bad)} unparsable", flush=True)
            rj = [dict(j, id=f"{j['id']}~rt{rnd}", max_tokens=6000, seed=2000 + rnd) for j in bad]      # rounds 2-3 resample at T=0.7 to escape degenerate loops
            run_jobs(rj, raw, spec["id"], ports, dict(params, temperature=0.2 if rnd < 2 else 0.7, top_p=1.0 if rnd < 2 else 0.95), per_server=64, every=2000)
        S.stop_servers()
        json.dump(dict(mode=a.mode, wall_s=time.time() - t0, n_calls=len(todo)), open(OUT / f"stats_{a.mode}_{int(time.time())}.json", "w"))
    # parse
    recs = {}
    for l in open(raw):
        r = json.loads(l)
        recs[r["id"]] = r
    parsed = OUT / f"parsed_{a.mode}.jsonl"
    n_ok = n_bad = 0
    with open(parsed, "w") as f:
        for j in jobs:
            best = None
            for suffix in ("", "~rt0", "~rt1", "~rt2", "~rt3"):
                r = recs.get(j["id"] + suffix)
                if r:
                    p = parse_any(r["text"], None)
                    if p is not None:
                        best = dict(p, retried=bool(suffix))
                        break
            rid, k = j["id"].rsplit("#r", 1)
            f.write(json.dumps(dict(id=rid, rep=int(k), parsed=best is not None, **(best or {}))) + "\n")
            n_ok += best is not None
            n_bad += best is None
        for z in zeros:
            f.write(json.dumps(dict(id=z, rep=0, parsed=True, Q=0.0, empty_final=True)) + "\n")
    print(f"parsed {n_ok} ok, {n_bad} unparsed, {len(zeros)} empty-final zeros", flush=True)


if __name__ == "__main__":
    main()