"""Character error rate (CER) for OCR predictions. Input: JSONL from common/vlm_infer.py (fields "id", "pred", "gt", optional "source"). Results are grouped by "source" (or by the id prefix before the first "_"). Two CER variants are reported: strict Markdown symbols and HTML tags removed, Unicode NFKC, all decimal digits mapped to 0-9, whitespace collapsed. Accents and other combining marks are kept. folded strict, plus case-folded and all combining marks (Unicode category Mn) removed. Use it to separate "wrong character" errors from "missing accent / mark" errors. python -m common.score data/runs/ovisocr3_eval.jsonl """ import argparse import json import math import re import statistics as st import sys import unicodedata from collections import defaultdict from rapidfuzz.distance import Levenshtein TAG = re.compile(r"<[^>]+>") MD = re.compile(r"[*#`>|_\-]+") def _digit(ch: str) -> str: d = unicodedata.decimal(ch, None) return str(d) if d is not None else ch def norm(s: str, fold: bool = False) -> str: s = unicodedata.normalize("NFKC", MD.sub(" ", TAG.sub(" ", s))) s = "".join(_digit(c) for c in s) if fold: s = "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn") s = unicodedata.normalize("NFC", s).casefold() return re.sub(r"\s+", " ", s).strip() def cer(pred: str, gt: str) -> float: return Levenshtein.distance(pred, gt) / max(1, len(gt)) def has_loop(s: str) -> bool: """True if a 30-character chunk repeats 6+ times: the usual sign of a decoding loop.""" for i in range(0, max(1, len(s) - 60), 20): c = s[i:i + 30] if len(c.strip()) > 10 and s.count(c) >= 6: return True return False def p90(xs): xs = sorted(xs) return xs[min(len(xs) - 1, math.ceil(0.9 * len(xs)) - 1)] def report(rows, threshold: float = 0.05): groups = defaultdict(list) for r in rows: groups[r.get("source") or r["id"].split("_")[0]].append(r) for name, rs in sorted(groups.items()): ok = [r for r in rs if "pred" in r] if not ok: print(f"{name}: {len(rs)} rows, all errored") continue strict = [cer(norm(r["pred"]), norm(r["gt"])) for r in ok] folded = [cer(norm(r["pred"], True), norm(r["gt"], True)) for r in ok] print(f"{name}: n={len(rs)} scored={len(ok)} errors={len(rs) - len(ok)}") print(f" CER strict mean {st.mean(strict):.3f} median {st.median(strict):.3f} p90 {p90(strict):.3f}") print(f" CER folded mean {st.mean(folded):.3f} median {st.median(folded):.3f} p90 {p90(folded):.3f}") print(f" pages with folded CER <= {threshold:.0%}: {sum(x <= threshold for x in folded)}/{len(folded)}" f" | decoding loops: {sum(has_loop(r['pred']) for r in ok)}" f" | hit token limit: {sum(r.get('truncated', False) for r in ok)}") def main(argv=None): ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("predictions", help="JSONL written by common.vlm_infer") ap.add_argument("--threshold", type=float, default=0.05, help="count pages at or below this folded CER") a = ap.parse_args(argv) with open(a.predictions, encoding="utf-8-sig") as fh: rows = [json.loads(line) for line in fh if line.strip()] report(rows, a.threshold) if __name__ == "__main__": sys.stdout.reconfigure(encoding="utf-8") main()