| |
| """LLM-judge factual correctness for the multi-tool set (semantic/factual |
| correctness rather than lexical overlap). |
| |
| python3 mt_judge.py --pred preds_mt/X.jsonl --name X --provider glm --judge glm-5.3 [--concurrency 10] |
| |
| The judge sees the question, the GOLD backend outputs (so answers built from wrongly |
| routed calls are judged against what the correct analyses say), the reference answer |
| and the candidate, and returns a 0-1 score. Wording and style are not scored. |
| Output: scores/mt/judge/<name>.judge_<judge>.jsonl {question_hash, score, reasoning} |
| """ |
| import argparse, json, os, sys, time, statistics as st |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| import mt_qa |
| SYS = ("You are an expert hardware-design reviewer grading answers about a Verilog module. You are given the " |
| "question, the outputs of the EDA analyses relevant to it (ground truth), a reference answer, and a " |
| "candidate answer. Score the candidate's factual correctness and completeness for the question on a " |
| "scale from 0.0 to 1.0, using the analysis outputs as ground truth:\n" |
| "1.0 = every stated fact agrees with the analysis outputs and every part of the question is answered;\n" |
| "deduct for wrong or invented values, claims not supported by the outputs, and parts of the question left " |
| "unanswered. The candidate may use different but correct facts than the reference. Do not score wording, " |
| "length or style.\n" |
| 'Return only JSON: {"score": <float>, "reasoning": "<one sentence>"}') |
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--pred", required=True); ap.add_argument("--name", required=True) |
| ap.add_argument("--ref", default="splits/mt/test.jsonl") |
| ap.add_argument("--provider", choices=["glm", "claude-cli"], required=True); ap.add_argument("--judge", required=True) |
| ap.add_argument("--concurrency", type=int, default=8) |
| a = ap.parse_args() |
| mt_qa.SYS = SYS |
| ref = {json.loads(l)["question_hash"]: json.loads(l) for l in open(a.ref)} |
| preds = {json.loads(l)["question_hash"]: json.loads(l).get("prediction", "") for l in open(a.pred)} |
| os.makedirs("scores/mt/judge", exist_ok=True) |
| out = f"scores/mt/judge/{a.name}.judge_{a.judge}.jsonl" |
| done = set() |
| if os.path.exists(out): |
| for l in open(out): done.add(json.loads(l)["question_hash"]) |
| todo = [h for h in ref if h not in done] |
| ask = (lambda u: mt_qa.ask_glm(a.judge, u)) if a.provider == "glm" else (lambda u: mt_qa.ask_cli(a.judge, u)) |
| def work(h): |
| r = ref[h] |
| u = (f"Question:\n{r['question']}\n\nAnalysis outputs (ground truth):\n{r['tool_result']}\n\n" |
| f"Reference answer:\n{r['answer']}\n\nCandidate answer:\n{preds.get(h, '')}") |
| for _ in range(4): |
| try: |
| t = ask(u) |
| if "```" in t: t = t.split("```")[1].removeprefix("json") |
| d = json.loads(t[t.find("{"): t.rfind("}") + 1]) |
| s = float(d["score"]) |
| return {"question_hash": h, "score": max(0.0, min(1.0, s)), "reasoning": str(d.get("reasoning", ""))[:300]} |
| except Exception: |
| time.sleep(3) |
| return None |
| n = ok = 0 |
| with ThreadPoolExecutor(a.concurrency) as ex, open(out, "a") as f: |
| for fu in as_completed([ex.submit(work, h) for h in todo]): |
| r = fu.result(); n += 1 |
| if r: f.write(json.dumps(r) + "\n"); f.flush(); ok += 1 |
| sc = [json.loads(l)["score"] for l in open(out)] |
| print(json.dumps({"name": a.name, "judge": a.judge, "n": len(sc), "missing": len(ref) - len(sc), "mean": round(100 * st.mean(sc), 1)})) |
| if __name__ == "__main__": |
| main() |
|
|
