| """Deterministic, judge-free grader for BrowseComp-Plus answers. |
| |
| grade(pred, gold) -> (correct: bool, category: str) |
| category is one of: exact, alias, numeric, date, gold_in_pred, all_parts, fuzzy, name_subset, no_answer, mismatch |
| """ |
| from __future__ import annotations |
|
|
| import re |
| import unicodedata |
|
|
| ARTICLES = {"a", "an", "the"} |
| TITLES = {"dr", "mr", "mrs", "ms", "prof", "professor", "sir", "dame", "lord", "lady", "st", "saint", "jr", "sr"} |
|
|
|
|
| def extract_answer(text: str | None) -> str | None: |
| """Pull the final short answer out of a free-form agent response.""" |
| if text is None: |
| return None |
| t = str(text) |
| if not t.strip(): |
| return None |
| |
| m = list(re.finditer(r"exact[ \t]*answer[ \t]*\**[ \t]*[:：][ \t]*\**[ \t]*(.*)", t, re.IGNORECASE)) |
| if m: |
| ans = m[-1].group(1).strip() |
| if not ans.strip("* "): |
| return None |
| ans = re.split(r"\n|\s{2,}confidence\s*:", ans, flags=re.IGNORECASE)[0] |
| return ans.strip().strip("*").strip() |
| m = list(re.finditer(r"\\boxed\{((?:[^{}]|\{[^{}]*\})*)\}", t)) |
| if m: |
| return m[-1].group(1).strip() |
| m = list(re.finditer(r"<answer>(.*?)</answer>", t, re.IGNORECASE | re.DOTALL)) |
| if m: |
| return extract_answer(m[-1].group(1)) or m[-1].group(1).strip() |
| m = list(re.finditer(r"final\s*answer\s*\**\s*[:：]\s*\**\s*(.+)", t, re.IGNORECASE)) |
| if m: |
| return m[-1].group(1).strip().strip("*").strip() |
| lines = [l.strip() for l in t.strip().splitlines() if l.strip()] |
| lines = [l for l in lines if not re.match(r"^\**confidence", l, re.IGNORECASE)] |
| return lines[-1] if lines else None |
|
|
|
|
| def norm(s: str) -> str: |
| s = unicodedata.normalize("NFKD", str(s)) |
| s = "".join(c for c in s if not unicodedata.combining(c)) |
| s = s.lower().replace("&", " and ") |
| s = re.sub(r"[\u2018\u2019'`]s\b", "s", s) |
| s = re.sub(r"[^\w\s.]", " ", s) |
| s = re.sub(r"(?<!\d)\.|\.(?!\d)", " ", s) |
| toks = [w for w in s.split() if w not in ARTICLES and w not in TITLES] |
| return " ".join(toks) |
|
|
|
|
| def _num(s: str): |
| """Return float if s is essentially a single number (with optional unit/commas/%).""" |
| x = str(s).lower().replace(",", "").strip() |
| x = re.sub(r"^(approximately|approx\.?|about|around|~|\$|usd|eur|£|€)\s*", "", x) |
| m = re.fullmatch(r"\$?\s*(-?\d+(?:\.\d+)?)\s*(%|[a-z]{0,12}\.?)?", x) |
| if not m: |
| return None |
| try: |
| return float(m.group(1)) |
| except ValueError: |
| return None |
|
|
|
|
| def gold_aliases(gold: str) -> list[str]: |
| g = str(gold).strip() |
| out = {g} |
| |
| m = re.fullmatch(r"(.+?)\s*\((.+)\)\s*", g) |
| if m: |
| out.add(m.group(1)); out.add(m.group(2)) |
| for sep in [" / ", "/", " or ", " aka ", " a.k.a. "]: |
| if sep in g: |
| for part in g.split(sep): |
| if part.strip(): |
| out.add(part.strip()) |
| return [a for a in out if norm(a)] |
|
|
|
|
| MONTHS = {m: i + 1 for i, m in enumerate(["january", "february", "march", "april", "may", "june", "july", "august", |
| "september", "october", "november", "december"])} |
| MONTHS.update({k[:3]: v for k, v in list(MONTHS.items())}) |
| MONTHS["sept"] = 9 |
|
|
|
|
| def parse_dates(s: str) -> set: |
| """All (y, m, d) / (y, m) date mentions in s (month-name forms and ISO / D/M/Y numeric).""" |
| t = norm(s) |
| out = set() |
| mon = r"(" + "|".join(sorted(MONTHS, key=len, reverse=True)) + r")" |
| for m in re.finditer(r"(\d{1,2}) (?:of )?" + mon + r" (\d{4})", t): |
| out.add((int(m.group(3)), MONTHS[m.group(2)], int(m.group(1)))) |
| for m in re.finditer(mon + r" (\d{1,2})(?:st|nd|rd|th)? (\d{4})", t): |
| out.add((int(m.group(3)), MONTHS[m.group(1)], int(m.group(2)))) |
| for m in re.finditer(r"(\d{4}) " + mon + r" (\d{1,2})\b", t): |
| out.add((int(m.group(1)), MONTHS[m.group(2)], int(m.group(3)))) |
| for m in re.finditer(r"\b(\d{4})[-/](\d{1,2})[-/](\d{1,2})\b", str(s)): |
| out.add((int(m.group(1)), int(m.group(2)), int(m.group(3)))) |
| for m in re.finditer(r"\b(\d{1,2})[/.](\d{1,2})[/.](\d{4})\b", str(s)): |
| out.add((int(m.group(3)), int(m.group(2)), int(m.group(1)))) |
| return out |
|
|
|
|
| def _contains(hay: str, needle: str) -> bool: |
| return bool(re.search(r"(?<!\w)" + re.escape(needle) + r"(?!\w)", hay)) |
|
|
|
|
| def gold_parts(gold: str) -> list[str]: |
| """split a multi-part gold ("A, B", "A & B", "A; B", "A and B") into parts.""" |
| parts = re.split(r"\s*(?:,|;|&|\band\b)\s*", str(gold)) |
| parts = [norm(p) for p in parts if norm(p)] |
| return parts if len(parts) >= 2 else [] |
|
|
|
|
| def grade(pred: str | None, gold: str) -> tuple[bool, str]: |
| if pred is None or not norm(pred): |
| return False, "no_answer" |
| np_ = norm(pred) |
| gn = norm(gold) |
| if np_ == gn: |
| return True, "exact" |
| aliases = gold_aliases(gold) |
| |
| pvars = {np_} |
| pv0 = norm(re.sub(r"\([^)]*\)", " ", str(pred))) |
| if pv0: |
| pvars.add(pv0) |
| for m in re.finditer(r"\(([^)]*)\)", str(pred)): |
| if norm(m.group(1)): |
| pvars.add(norm(m.group(1))) |
| for a in aliases: |
| if norm(a) in pvars: |
| return True, "alias" |
| |
| gv, pv = _num(gold), _num(pred) |
| if gv is not None and pv is not None: |
| if gv == pv or (not (gv.is_integer() and pv.is_integer() and abs(gv) < 10000) and gv != 0 and abs(pv - gv) / abs(gv) <= 0.01): |
| return True, "numeric" |
| return False, "mismatch" |
| |
| gd = parse_dates(gold) |
| if gd: |
| pd_ = parse_dates(pred) |
| if pd_: |
| return (True, "date") if gd <= pd_ else (False, "mismatch") |
| ptoks = np_.split() |
| |
| for a in aliases: |
| an = norm(a) |
| if not an: |
| continue |
| specific = len(an) >= 6 and not re.fullmatch(r"[\d. ]+", an) |
| cap = 40 if specific else 12 |
| if (len(an) >= 3 or gv is not None) and _contains(np_, an) and len(ptoks) <= len(an.split()) + cap: |
| return True, "gold_in_pred" |
| |
| parts = gold_parts(gold) |
| if parts and all(_contains(np_, p) for p in parts) and len(ptoks) <= len(gn.split()) + 40: |
| return True, "all_parts" |
| |
| import difflib |
| for a in aliases: |
| an = norm(a) |
| for v in pvars: |
| if len(an) >= 6 and difflib.SequenceMatcher(None, an, v).ratio() >= 0.92: |
| return True, "fuzzy" |
| |
| gt = gn.split() |
| for v in pvars: |
| vt = v.split() |
| if len(vt) >= 2 and len(gt) >= 3 and vt[0] == gt[0] and vt[-1] == gt[-1] and set(vt) <= set(gt): |
| return True, "name_subset" |
| return False, "mismatch" |
|
|
|
|
| def extract_freeform(text: str | None) -> str | None: |
| """For long free-form reports with no answer template: bold spans of the first |
| substantive paragraph (joined), else that paragraph.""" |
| if text is None or not str(text).strip(): |
| return None |
| t = str(text) |
| if re.search(r"exact[ \t]*answer[ \t]*\**[ \t]*[:：]|\\boxed\{|<answer>", t, re.IGNORECASE): |
| return extract_answer(t) |
| m = re.search(r"<[｜|]DSML[｜|]answer>", t) |
| if m: |
| t = t[m.end():] |
| paras = [p.strip() for p in re.split(r"\n\s*\n", t) if p.strip()] |
| paras = [p for p in paras if not re.fullmatch(r"#+[^\n]*|-{3,}", p)] |
| if not paras: |
| return None |
| p = paras[0] |
| bolds = re.findall(r"\*\*(.+?)\*\*", p) |
| if bolds: |
| return " ; ".join(b.strip() for b in bolds[:4]) |
| return p |
|
|
|
|
| def grade_freeform(report: str | None, pred: str | None, gold: str) -> tuple[bool, str]: |
| """Free-form report grading: grade the extracted answer; if that fails, accept when a |
| *specific* gold (>=8 chars or >=2 tokens, not purely numeric) appears verbatim (normalized, |
| word-bounded) anywhere in the report. Lenient: can over-credit reports that list candidates.""" |
| c, k = grade(pred, gold) |
| if c or report is None: |
| return c, k |
| nr = norm(report) |
| for a in gold_aliases(gold): |
| an = norm(a) |
| if re.fullmatch(r"[\d. ]+", an): |
| continue |
| if (len(an) >= 8 or len(an.split()) >= 2) and _contains(nr, an): |
| return True, "gold_in_report" |
| return c, k |
|
|
