Upload verify.py

data/verifier/verify.py

@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+"""Verifies the math answers in the dataset against the model outputs.
+The dataset is a single row with the answer and predictions path is a jsonl file with single row of model output.
+
+Example:
+
+```
+python notebooks/math_final_answer_verifier.py \
+    --dataset-path.jsonl \
+    --predictions-path model_output.json \
+    --prediction-column model_output
+```
+
+Supported input formats: ``.jsonl``/``.ndjson``, ``.json``, ``.csv``,
+``.tsv`` and ``.parquet`` (requires pandas).
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import numbers
+import re
+import sys
+import unicodedata
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+
+
+MODEL_OUTPUT_COL = "__model_output"
+ROW_ID_COL = "__row_id"
+
+# Regexes that help identify different final-answer formats.
+BOXED_PATTERN = re.compile(r"\\boxed\s*\{([^}]*)\}")
+HASH_PATTERN = re.compile(r"####\s*(.+)")
+FINAL_ANSWER_PATTERNS = [
+    re.compile(r"(?i)final answer(?: is)?\s*[:=\-]?\s*(.+)"),
+    re.compile(r"(?i)final result(?: is)?\s*[:=\-]?\s*(.+)"),
+    re.compile(r"(?i)the answer is\s*(.+)"),
+    re.compile(r"(?i)answer(?: is)?\s*[:=\-]?\s*(.+)"),
+    re.compile(r"(?i)ans(?: is)?\s*[:=\-]?\s*(.+)"),
+    re.compile(r"(?i)result(?: is)?\s*[:=\-]?\s*(.+)"),
+]
+
+
+LATEX_TEXT_REPLACEMENTS = {
+    "\\leq": "<=",
+    "\\le": "<=",
+    "\\geq": ">=",
+    "\\ge": ">=",
+    "\\neq": "!=",
+    "\\times": "*",
+    "\\cdot": "*",
+    "\\div": "/",
+    "\\pm": "+-",
+    "\\pi": "pi",
+    "\\Pi": "pi",
+    "\\infty": "inf",
+    "\\sqrt": "sqrt",
+    "\\Gamma": "gamma",
+    "\\Omega": "omega",
+    "\\alpha": "alpha",
+    "\\beta": "beta",
+    "\\gamma": "gamma",
+    "\\delta": "delta",
+    "\\int": "integral",
+    "\\log": "log",
+    "\\ln": "ln",
+}
+
+
+SYMBOL_REPLACEMENTS = {
+    "−": "-",
+    "–": "-",
+    "—": "-",
+    "·": "*",
+    "×": "*",
+    "÷": "/",
+    "π": "pi",
+    "Π": "pi",
+    "∞": "inf",
+    "√": "sqrt",
+    "≤": "<=",
+    "≥": ">=",
+    "≠": "!=",
+    "∈": "in",
+    "∉": "notin",
+    "∪": "union",
+    "∩": "intersect",
+    "′": "'",
+}
+
+
+OUTPUT_KEYWORDS = {"final_answer", "answer", "prediction", "output", "result"}
+
+
+@dataclass
+class ComparisonResult:
+    is_match: bool
+    matched_candidate: str | None
+    match_type: str | None
+    normalized_gold: str | None
+    normalized_candidate: str | None
+    candidates: Sequence[str]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Verify math final answers against model outputs")
+    parser.add_argument("--dataset-path", required=True, help="Path to the JSONL/CSV/TSV/parquet dataset")
+    parser.add_argument("--predictions-path", required=True, help="Path to the predictions file")
+    parser.add_argument(
+        "--final-answer-column",
+        default="final_answer",
+        help="Name of the column that holds the ground-truth final answer",
+    )
+    parser.add_argument(
+        "--prediction-column",
+        default="model_output",
+        help="Name of the column that holds the model response",
+    )
+    parser.add_argument(
+        "--id-column",
+        default=None,
+        help="Optional column used to align dataset rows with predictions (defaults to row order)",
+    )
+    parser.add_argument(
+        "--dump-results",
+        default=None,
+        help="Optional path to write the per-row evaluation as JSONL",
+    )
+    parser.add_argument(
+        "--dump-mismatches",
+        default=None,
+        help="Optional path to write only the mismatched rows as JSONL",
+    )
+    return parser.parse_args()
+
+
+def load_records(path: Path) -> list[dict[str, Any]]:
+    if not path.exists():
+        raise FileNotFoundError(f"Missing file: {path}")
+    ext = path.suffix.lower()
+    if ext in {".jsonl", ".ndjson"}:
+        rows: list[dict[str, Any]] = []
+        with path.open(encoding="utf-8") as handle:
+            for line in handle:
+                line = line.strip()
+                if not line:
+                    continue
+                obj = json.loads(line)
+                if isinstance(obj, dict):
+                    rows.append(obj)
+                else:
+                    rows.append({"value": obj})
+        return rows
+    if ext == ".json":
+        content = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(content, list):
+            return [dict(row) if isinstance(row, dict) else {"value": row} for row in content]
+        if isinstance(content, dict):
+            return [content]
+        raise ValueError(f"Unsupported JSON structure in {path}")
+    if ext in {".csv", ".tsv"}:
+        delimiter = "\t" if ext == ".tsv" else ","
+        with path.open(encoding="utf-8", newline="") as handle:
+            reader = csv.DictReader(handle, delimiter=delimiter)
+            return [dict(row) for row in reader]
+    if ext == ".parquet":
+        try:
+            import pandas as pd  # type: ignore
+        except ImportError as exc:  # pragma: no cover - optional dependency
+            raise ImportError("Reading parquet files requires pandas and pyarrow.") from exc
+        return pd.read_parquet(path).to_dict(orient="records")
+    raise ValueError(f"Unsupported file format: {path}")
+
+
+def align_tables(
+    dataset_rows: Sequence[dict[str, Any]],
+    prediction_rows: Sequence[dict[str, Any]],
+    *,
+    id_column: str | None,
+    prediction_column: str,
+) -> tuple[list[dict[str, Any]], str]:
+    if not prediction_rows:
+        raise ValueError("Predictions file has no rows")
+
+    if not any(prediction_column in row for row in prediction_rows):
+        raise KeyError(f"Prediction column '{prediction_column}' not found in predictions")
+
+    key_column = ROW_ID_COL
+
+    if id_column:
+        missing_ids = [idx for idx, row in enumerate(dataset_rows) if row.get(id_column) is None]
+        if missing_ids:
+            raise KeyError(
+                f"Dataset rows missing '{id_column}' (first few indices: {missing_ids[:5]})"
+            )
+        prediction_index: dict[Any, dict[str, Any]] = {}
+        for pred in prediction_rows:
+            key = pred.get(id_column)
+            if key is None:
+                continue
+            prediction_index[key] = pred
+
+        aligned: list[dict[str, Any]] = []
+        missing = 0
+        for idx, row in enumerate(dataset_rows):
+            merged = dict(row)
+            merged[ROW_ID_COL] = idx
+            pred_row = prediction_index.get(row[id_column])
+            if pred_row is not None and prediction_column in pred_row:
+                merged[MODEL_OUTPUT_COL] = pred_row.get(prediction_column)
+            else:
+                merged[MODEL_OUTPUT_COL] = None
+                missing += 1
+            aligned.append(merged)
+
+        if missing:
+            print(
+                f"[warn] {missing} dataset rows did not have matching predictions by '{id_column}'",
+                file=sys.stderr,
+            )
+        return aligned, id_column
+
+    # Fall back to row order when an ID column is not provided.
+    align_len = min(len(dataset_rows), len(prediction_rows))
+    if align_len == 0:
+        raise ValueError("No overlapping rows between dataset and predictions")
+    if len(dataset_rows) != len(prediction_rows):
+        shorter = "predictions" if len(prediction_rows) < len(dataset_rows) else "dataset"
+        print(
+            f"[warn] {shorter} has fewer rows (evaluating on {align_len} aligned samples)",
+            file=sys.stderr,
+        )
+    trimmed: list[dict[str, Any]] = []
+    for idx in range(align_len):
+        merged = dict(dataset_rows[idx])
+        merged[ROW_ID_COL] = idx
+        merged[MODEL_OUTPUT_COL] = prediction_rows[idx].get(prediction_column)
+        trimmed.append(merged)
+    return trimmed, ROW_ID_COL
+
+
+def normalize_answer_text(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, float) and math.isnan(value):
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+
+    text = unicodedata.normalize("NFKC", text)
+    text = strip_leading_label(text)
+    for src, dst in SYMBOL_REPLACEMENTS.items():
+        text = text.replace(src, dst)
+    for src, dst in LATEX_TEXT_REPLACEMENTS.items():
+        text = text.replace(src, dst)
+
+    text = re.sub(r"\\text\s*\{([^}]*)\}", r"\1", text)
+    text = re.sub(r"\\boxed\s*\{([^}]*)\}", r"\1", text)
+    text = text.replace("\\", "")
+    text = text.replace("{", "").replace("}", "")
+    text = text.replace("\r", "\n")
+    text = text.replace("\t", " ")
+    text = re.sub(r"\s+", " ", text).strip()
+    if not text:
+        return None
+    text = text.lower()
+    text = text.replace(" ", "")
+    return text
+
+
+def strip_leading_label(text: str) -> str:
+    candidate = text
+    patterns = [
+        re.compile(r"(?i)^\s*(?:the\s+)?final\s+answer\s*(?:is)?\s*[:=\-]?\s*"),
+        re.compile(r"(?i)^\s*(?:the\s+)?answer\s*(?:is)?\s*[:=\-]?\s*"),
+        re.compile(r"(?i)^\s*ans\s*(?:is)?\s*[:=\-]?\s*"),
+        re.compile(r"(?i)^\s*(?:final\s+result|result)\s*(?:is)?\s*[:=\-]?\s*"),
+    ]
+    for pattern in patterns:
+        stripped = pattern.sub("", candidate, count=1)
+        if stripped != candidate:
+            return stripped.strip()
+    return candidate
+
+
+def extract_candidate_answers(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, (dict, list)):
+        text = json.dumps(value, ensure_ascii=False)
+    else:
+        text = str(value)
+    text = text.strip()
+    if not text:
+        return []
+
+    candidates: list[str] = []
+
+    candidates.extend(_maybe_extract_from_json(text))
+
+    boxed_matches = BOXED_PATTERN.findall(text)
+    for match in reversed(boxed_matches):
+        stripped = match.strip()
+        if stripped:
+            candidates.append(stripped)
+
+    hash_matches = HASH_PATTERN.findall(text)
+    if hash_matches:
+        candidates.append(hash_matches[-1].strip())
+
+    for pattern in FINAL_ANSWER_PATTERNS:
+        for match in pattern.finditer(text):
+            snippet = match.group(1).strip()
+            if snippet:
+                candidates.append(snippet)
+
+    equals_match = re.search(r"=\s*([^=\n]+)$", text)
+    if equals_match:
+        candidates.append(equals_match.group(1).strip())
+
+    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+    if lines:
+        candidates.append(lines[-1])
+
+    candidates.append(text)
+
+    return _dedupe_preserving_order(candidates)
+
+
+def _maybe_extract_from_json(text: str) -> list[str]:
+    stripped = text.strip()
+    if not stripped or stripped[0] not in "[{":
+        return []
+    try:
+        payload = json.loads(stripped)
+    except json.JSONDecodeError:
+        return []
+
+    values: list[str] = []
+
+    def _collect(obj: Any) -> None:
+        if isinstance(obj, dict):
+            for key, val in obj.items():
+                if isinstance(val, (str, int, float)) and key.lower() in OUTPUT_KEYWORDS:
+                    values.append(str(val))
+                elif isinstance(val, (dict, list)):
+                    _collect(val)
+        elif isinstance(obj, list):
+            for item in obj:
+                _collect(item)
+
+    _collect(payload)
+    return values
+
+
+def _dedupe_preserving_order(items: Iterable[str]) -> list[str]:
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for item in items:
+        if not item:
+            continue
+        if item in seen:
+            continue
+        seen.add(item)
+        deduped.append(item)
+    return deduped
+
+
+def compare_answers(gold: str, prediction: str) -> ComparisonResult:
+    normalized_gold = normalize_answer_text(gold)
+    candidates = extract_candidate_answers(prediction)
+    if not normalized_gold:
+        return ComparisonResult(False, None, None, normalized_gold, None, candidates)
+
+    for candidate in candidates:
+        normalized_candidate = normalize_answer_text(candidate)
+        if not normalized_candidate:
+            continue
+        if normalized_candidate == normalized_gold:
+            return ComparisonResult(True, candidate.strip(), "exact", normalized_gold, normalized_candidate, candidates)
+        if normalized_gold in normalized_candidate:
+            return ComparisonResult(True, candidate.strip(), "substring_match", normalized_gold, normalized_candidate, candidates)
+
+    return ComparisonResult(False, None, None, normalized_gold, None, candidates)
+
+
+def evaluate_rows(
+    records: Sequence[dict[str, Any]], *, final_answer_column: str, key_column: str
+) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for idx, row in enumerate(records):
+        gold = row.get(final_answer_column)
+        prediction = row.get(MODEL_OUTPUT_COL)
+        key = row.get(key_column, row.get(ROW_ID_COL, idx))
+
+        gold_text = str(gold)
+        has_prediction = not _is_missing(prediction)
+
+        if has_prediction:
+            comp = compare_answers(gold_text, str(prediction))
+        else:
+            comp = ComparisonResult(False, None, None, normalize_answer_text(gold_text), None, [])
+
+        key_value: Any = key
+        if isinstance(key_value, numbers.Integral):
+            key_value = int(key_value)
+        elif isinstance(key_value, numbers.Real) and float(key_value).is_integer():
+            key_value = int(key_value)
+
+        record = {
+            "row_key_column": key_column,
+            "row_key": key_value,
+            "final_answer": gold_text,
+            "model_output": str(prediction) if has_prediction else None,
+            "has_prediction": has_prediction,
+            "is_correct": has_prediction and comp.is_match,
+            "match_type": comp.match_type if has_prediction else None,
+            "matched_candidate": comp.matched_candidate,
+            "first_candidate": comp.candidates[0] if comp.candidates else None,
+            "candidate_count": len(comp.candidates),
+            "normalized_final_answer": comp.normalized_gold,
+            "normalized_candidate": comp.normalized_candidate,
+        }
+
+        if not has_prediction:
+            record["failure_reason"] = "no_prediction"
+        elif not comp.candidates:
+            record["failure_reason"] = "no_candidate"
+        elif not comp.is_match:
+            record["failure_reason"] = "mismatch"
+        else:
+            record["failure_reason"] = None
+
+        rows.append(record)
+    return rows
+
+
+def _is_missing(value: Any) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, float) and math.isnan(value):
+        return True
+    if isinstance(value, str) and not value.strip():
+        return True
+    return False
+
+
+def write_jsonl(path: Path, rows: Sequence[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    args = parse_args()
+    dataset_rows = load_records(Path(args.dataset_path))
+    if not dataset_rows:
+        raise ValueError("Dataset file is empty")
+    if not any(args.final_answer_column in row for row in dataset_rows):
+        raise KeyError(
+            f"'{args.final_answer_column}' not found in dataset columns"
+        )
+    filtered_dataset = [
+        row for row in dataset_rows if not _is_missing(row.get(args.final_answer_column))
+    ]
+    if not filtered_dataset:
+        raise ValueError("Dataset does not contain rows with non-empty final answers")
+
+    prediction_rows = load_records(Path(args.predictions_path))
+    aligned_rows, key_column = align_tables(
+        filtered_dataset,
+        prediction_rows,
+        id_column=args.id_column,
+        prediction_column=args.prediction_column,
+    )
+
+    evaluation_rows = evaluate_rows(aligned_rows, final_answer_column=args.final_answer_column, key_column=key_column)
+
+    total_rows = len(evaluation_rows)
+    with_prediction = sum(1 for row in evaluation_rows if row["has_prediction"])
+    matches = sum(1 for row in evaluation_rows if row["is_correct"])
+    no_candidate = sum(1 for row in evaluation_rows if row["failure_reason"] == "no_candidate")
+    no_prediction = sum(1 for row in evaluation_rows if row["failure_reason"] == "no_prediction")
+
+    accuracy = matches / with_prediction if with_prediction else 0.0
+
+    print(f"Evaluated rows: {total_rows}")
+    print(f"Rows with predictions: {with_prediction}")
+    print(f"Matches: {matches}")
+    print(f"Accuracy: {accuracy:.2%}")
+    if no_prediction:
+        print(f"Rows without predictions: {no_prediction}")
+    if no_candidate:
+        print(f"Rows where no final answer was extractable: {no_candidate}")
+
+    mismatches = [row for row in evaluation_rows if not row["is_correct"]]
+
+    if args.dump_results:
+        write_jsonl(Path(args.dump_results), evaluation_rows)
+        print(f"Wrote detailed results to {args.dump_results}")
+    if args.dump_mismatches:
+        write_jsonl(Path(args.dump_mismatches), mismatches)
+        print(f"Wrote mismatches to {args.dump_mismatches}")
+
+    reward = "pass" if total_rows and matches == total_rows else "fail"
+    print(f"Reward: {reward}")
+
+
+if __name__ == "__main__":
+    main()