Download code/common/score.py from aziz9788/OvisOCR3-Arabic-workdir: direct link, hf CLI and curl.
- Browser
- Download file 3.53 kB
-
https://huggingface.co/datasets/aziz9788/OvisOCR3-Arabic-workdir/resolve/main/code/common/score.py
- Command line
-
hf download hf://datasets/aziz9788/OvisOCR3-Arabic-workdir/code/common/score.py
-
curl -L -o score.py https://huggingface.co/datasets/aziz9788/OvisOCR3-Arabic-workdir/resolve/main/code/common/score.py
3.53 kB
| """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() | |