"""Objective quality evaluators for SeqRoute-1M (Q in [0, 10]). Judge / COMET / BERTScore based families return None here and are scored in batch by separate scripts. evaluate_row(evaluator_type, prompt, payload, text, reasoning, finish_reason) -> dict(Q, raw, raw_name, parse_ok, answer, truncated, sub) or None when scored elsewhere. """ from __future__ import annotations import json import re import string from collections import Counter from llmroute.orouter2 import evaluate as OE from llmroute.orouter2.evaluate import last_json from llmroute.evaluation.extract import split_thinking DEFERRED = {"judge_summ", "comet", "simplification"} def _strip_md(s: str) -> str: s = re.sub(r"\\boxed\{([^{}]*)\}", r"\1", s) s = s.replace("**", "").replace("__", "").replace("`", "").replace("$", "") return s.strip() def final_answer_span(final: str) -> str | None: ms = list(re.finditer(r"final\s*answer\s*[:\-]?\s*", final, re.I)) if ms: tail = final[ms[-1].end():].strip() line = tail.split("\n")[0] if tail else "" return _strip_md(line or tail) lines = [l for l in final.strip().split("\n") if l.strip()] return _strip_md(lines[-1]) if lines else None def _norm_text(s: str) -> str: s = _strip_md(s).lower().strip().strip(".").strip() s = s.strip("\"'") return re.sub(r"\s+", " ", s) def _num(s: str): s = s.replace(",", "").strip() try: return float(s) except ValueError: return None def eval_exact_str(payload: dict, final: str) -> dict: span = final_answer_span(final) ok = False if span: gold = str(payload["gold"]) if payload.get("kind") == "letter": m = re.match(r"^\(?([A-Za-z])\)?(?:[\s.:)\]]|$)", span.strip()) ok = bool(m and m.group(1).upper() == gold.upper()) else: a, b = _norm_text(span), _norm_text(gold) ok = a == b or a.replace(" ", "") == b.replace(" ", "") if not ok: na, nb = _num(a), _num(b) ok = na is not None and nb is not None and abs(na - nb) < 1e-6 if not ok and gold.lower() in ("true", "false", "yes", "no", "valid", "invalid"): first = re.match(r"^[a-z]+", a) ok = bool(first and first.group(0) == b) return dict(Q=10.0 * ok, raw=float(ok), raw_name="exact_match", parse_ok=span is not None, answer=span, sub={}) def eval_label(payload: dict, final: str) -> dict: t = _norm_text(final.split("\n")[0] if final.strip() else "") labels = payload["labels"] low = {l.lower(): l for l in labels} t = re.sub(r"^(label|answer)\s*[:\-]\s*", "", t).strip(" .") pred = low.get(t) if pred is None: hits = [l for l in sorted(low, key=len, reverse=True) if re.search(rf"(? str: return re.sub(r"[\s_\-]", "", str(k).lower()) def _val(v) -> str: if isinstance(v, bool): return "yes" if v else "no" s = re.sub(r"\s+", " ", str(v).strip().lower()).replace("£ ", "£") return {"true": "yes", "false": "no"}.get(s, s) def eval_json_slots(payload: dict, final: str) -> dict: v = last_json(final) gold = Counter((_key(k), _val(x)) for k, x in payload["gold"].items()) if not isinstance(v, dict): return dict(Q=0.0, raw=0.0, raw_name="slot_f1", parse_ok=False, answer=None, sub=dict(precision=0.0, recall=0.0, valid_structure=0.0)) allowed = {_key(k) for k in ("name", "eatType", "food", "priceRange", "customer rating", "area", "familyFriendly", "near")} pred = Counter((_key(k), _val(x)) for k, x in v.items() if not isinstance(x, (dict, list))) tp = sum((pred & gold).values()) p, r = tp / max(sum(pred.values()), 1), tp / max(sum(gold.values()), 1) f = 2 * p * r / (p + r) if p + r else 0.0 valid = float(all(_key(k) in allowed for k in v)) return dict(Q=10.0 * f, raw=f, raw_name="slot_f1", parse_ok=True, answer=json.dumps(v)[:1000], sub=dict(precision=p, recall=r, valid_structure=valid, exact_match=float(pred == gold))) def _qa_norm(s: str) -> str: s = s.lower() s = "".join(ch for ch in s if ch not in set(string.punctuation)) s = re.sub(r"\b(a|an|the)\b", " ", s) return " ".join(s.split()) def _f1(pred: str, gold: str) -> float: p, g = _qa_norm(pred).split(), _qa_norm(gold).split() if not p or not g: return float(p == g) c = sum((Counter(p) & Counter(g)).values()) if c == 0: return 0.0 pr, rc = c / len(p), c / len(g) return 2 * pr * rc / (pr + rc) def eval_qa_f1(payload: dict, final: str) -> dict: ans = re.sub(r"^\s*(final\s*)?answer\s*[:\-]\s*", "", _strip_md(final.strip()), flags=re.I)[:400] gold = [str(g) for g in payload["gold"]] unans = lambda s: bool(re.search(r"\bunanswerable\b|\bno answer\b|\bnot (?:answerable|mentioned|stated|specified)\b", s.lower())) gold_un = [g for g in gold if unans(g)] gold_ans = [g for g in gold if not unans(g)] if not gold_ans: f = float(unans(ans)) em = f else: f = max(_f1(ans, g) for g in gold_ans) if unans(ans): f = 1.0 if gold_un else 0.0 em = float(any(_qa_norm(ans) == _qa_norm(g) for g in gold_ans)) return dict(Q=10.0 * f, raw=f, raw_name="token_f1", parse_ok=bool(ans.strip()), answer=ans[:300], sub=dict(exact_match=em)) # ---- planning / puzzles ------------------------------------------------------------------------------------------------------------------------ def eval_blocksworld(payload: dict, final: str) -> dict: v = last_json(final) if not isinstance(v, list): return dict(Q=0.0, raw=0.0, raw_name="plan_success", parse_ok=False, answer=None, sub={}) stacks = [list(s) for s in payload["init"]] goal = {tuple(s) for s in payload["goal"]} legal = True for mv in v: m = re.fullmatch(r"\s*move\s+([A-Z])\s+(?:to|onto|on)\s+([A-Z]|table)\s*", str(mv), re.I) if not m: legal = False; break x, y = m.group(1).upper(), m.group(2) y = "table" if y.lower() == "table" else y.upper() src = next((s for s in stacks if x in s), None) if src is None or src[-1] != x: legal = False; break if y != "table": dst = next((s for s in stacks if y in s), None) if dst is None or dst[-1] != y or y == x: legal = False; break src.pop() if y == "table": stacks.append([x]) else: dst.append(x) stacks = [s for s in stacks if s] reached = legal and {tuple(s) for s in stacks} == goal n_on = sum(len(s) for s in goal) cur = {tuple(s) for s in stacks} prog = len(cur & goal) / max(len(goal), 1) q = 10.0 if reached else (3.0 * prog if legal else 0.0) return dict(Q=q, raw=float(reached), raw_name="plan_success", parse_ok=True, answer=json.dumps(v)[:500], sub=dict(all_legal=float(legal), n_moves=len(v))) def eval_hanoi(payload: dict, final: str) -> dict: v = last_json(final) if not isinstance(v, list): return dict(Q=0.0, raw=0.0, raw_name="plan_success", parse_ok=False, answer=None, sub={}) pegs = {p: list(d) for p, d in payload["init"].items()} legal = True for mv in v: try: d, a, b = int(mv[0]), str(mv[1]).upper(), str(mv[2]).upper() if a not in pegs or b not in pegs or not pegs[a] or pegs[a][-1] != d or (pegs[b] and pegs[b][-1] < d) or a == b: legal = False; break pegs[a].pop(); pegs[b].append(d) except Exception: legal = False; break reached = legal and {p: list(d) for p, d in pegs.items()} == {p: list(d) for p, d in payload["goal"].items()} gp = {d: p for p, ds in payload["goal"].items() for d in ds} cur = {d: p for p, ds in pegs.items() for d in ds} prog = sum(cur.get(d) == gp[d] for d in gp) / len(gp) q = 10.0 if reached else (3.0 * prog if legal else 0.0) return dict(Q=q, raw=float(reached), raw_name="plan_success", parse_ok=True, answer=json.dumps(v)[:500], sub=dict(all_legal=float(legal), n_moves=len(v))) def eval_sudoku(payload: dict, final: str) -> dict: n, sol, pz = payload["n"], payload["solution"], payload["puzzle"] span = final[re.search(r"final\s*answer\s*[:\-]?", final, re.I).end():] if re.search(r"final\s*answer\s*[:\-]?", final, re.I) else final rows = [re.sub(r"[^0-9]", "", l) for l in _strip_md(span).split("\n")] rows = [r for r in rows if len(r) == n] if len(rows) < n: return dict(Q=0.0, raw=0.0, raw_name="blank_cell_accuracy", parse_ok=False, answer=None, sub=dict(all_correct=0.0)) rows = rows[-n:] blanks = [(r, c) for r in range(n) for c in range(n) if pz[r][c] == 0] ok = sum(int(rows[r][c]) == sol[r][c] for r, c in blanks) acc = ok / max(len(blanks), 1) return dict(Q=10.0 * acc, raw=acc, raw_name="blank_cell_accuracy", parse_ok=True, answer="\n".join(rows), sub=dict(all_correct=float(ok == len(blanks)))) def evaluate_row(evaluator: str, prompt: str, payload: dict, text: str, reasoning: str | None, finish_reason: str | None) -> dict | None: if evaluator in DEFERRED: return None final, truncated = split_thinking(text, reasoning, finish_reason) if evaluator in ("math_exact", "mc_exact"): r = OE.eval_exact(payload, final) elif evaluator == "unit_tests": r = OE.eval_code(payload, final) elif evaluator == "extraction_f1": r = OE.eval_extraction(payload, final) elif evaluator == "ifeval_strict": r = OE.eval_ifeval(prompt, payload, final) elif evaluator == "exact_str": r = eval_exact_str(payload, final) elif evaluator == "label_exact": r = eval_label(payload, final) elif evaluator == "json_slots": r = eval_json_slots(payload, final) elif evaluator == "qa_f1": r = eval_qa_f1(payload, final) elif evaluator == "plan_blocksworld": r = eval_blocksworld(payload, final) elif evaluator == "plan_hanoi": r = eval_hanoi(payload, final) elif evaluator == "sudoku": r = eval_sudoku(payload, final) else: raise ValueError(evaluator) r["truncated"] = bool(truncated) r["empty_final"] = not final.strip() return r