divy123's picture
Add files using upload-large-folder tool
a4822b5 verified
Raw History Blame Contribute Delete
10.6 kB
"""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"(?<![a-z]){re.escape(l)}(?![a-z])", _norm_text(final))]
hits = [h for h in hits if not any(h != o and h in o for o in hits)]
pred = low[hits[0]] if len(hits) == 1 else None
ok = pred == payload["gold"]
return dict(Q=10.0 * ok, raw=float(ok), raw_name="accuracy", parse_ok=pred is not None, answer=pred, sub={})
def _key(k: str) -> 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