Datasets:
Download code/src_seqroute/evaluate.py from divy123/sequential-router-v2: direct link, hf CLI and curl.
- Browser
- Download file 10.6 kB
-
https://huggingface.co/datasets/divy123/sequential-router-v2/resolve/main/code/src_seqroute/evaluate.py
- Command line
-
hf download hf://datasets/divy123/sequential-router-v2/code/src_seqroute/evaluate.py
-
curl -L -o evaluate.py https://huggingface.co/datasets/divy123/sequential-router-v2/resolve/main/code/src_seqroute/evaluate.py
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 | |