File size: 10,626 Bytes
a4822b5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
"""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