| """ |
| evaluate.py — grapheme-cluster CER and codepoint CER (Pillar 2). |
| |
| Core claim being tested: |
| codepoint-CER misranks Tamil errors because Tamil matras and combining marks |
| are multi-codepoint sequences that form a single perceptual unit. |
| grapheme_cer measures edit distance over \\X clusters; codepoint_cer over |
| individual Unicode codepoints. We empirically show that a substitution of |
| one matra can inflate codepoint-CER by 2–3× vs grapheme-CER. |
| |
| Both metrics apply NFC normalization before comparison (canonical Pillar-2 form). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
|
|
| from textkit import normalize, segment |
|
|
|
|
| |
| |
| |
|
|
| def _edit_distance(seq_a: list, seq_b: list) -> int: |
| """Standard DP edit distance (insertion, deletion, substitution cost=1).""" |
| m, n = len(seq_a), len(seq_b) |
| |
| prev = list(range(n + 1)) |
| for i in range(1, m + 1): |
| curr = [i] + [0] * n |
| for j in range(1, n + 1): |
| cost = 0 if seq_a[i - 1] == seq_b[j - 1] else 1 |
| curr[j] = min( |
| curr[j - 1] + 1, |
| prev[j] + 1, |
| prev[j - 1] + cost, |
| ) |
| prev = curr |
| return prev[n] |
|
|
|
|
| |
| |
| |
|
|
| def grapheme_cer(hypothesis: str, reference: str) -> float: |
| """ |
| CER over Unicode grapheme clusters (\\X after NFC). |
| This is the primary Pillar-2 metric. |
| Returns edit_distance(clusters_hyp, clusters_ref) / len(clusters_ref). |
| Returns 0.0 if reference is empty. |
| """ |
| ref = segment(normalize(reference)) |
| hyp = segment(normalize(hypothesis)) |
| if not ref: |
| return 0.0 |
| return _edit_distance(hyp, ref) / len(ref) |
|
|
|
|
| def codepoint_cer(hypothesis: str, reference: str) -> float: |
| """ |
| CER over individual Unicode codepoints (after NFC). |
| Included to demonstrate misranking on Tamil (Pillar 2 empirical demo). |
| """ |
| ref = list(normalize(reference)) |
| hyp = list(normalize(hypothesis)) |
| if not ref: |
| return 0.0 |
| return _edit_distance(hyp, ref) / len(ref) |
|
|
|
|
| def word_accuracy(hypothesis: str, reference: str) -> float: |
| """ |
| Word-level accuracy (fraction of reference words that appear in hyp |
| at the same position after whitespace tokenization). |
| Low word-acc at low char-CER = segmentation/sandhi phenomenon noted in |
| Jayatilleke & de Silva 2025 — we track this separately. |
| """ |
| ref_words = normalize(reference).split() |
| hyp_words = normalize(hypothesis).split() |
| if not ref_words: |
| return 1.0 |
| correct = sum(r == h for r, h in zip(ref_words, hyp_words)) |
| return correct / len(ref_words) |
|
|
|
|
| |
| |
| |
|
|
| def evaluate_manifest( |
| manifest_path: Path, |
| predictions_path: Path, |
| out_path: Path | None = None, |
| ) -> list[dict]: |
| """ |
| manifest_path: JSONL from datagen.py (fields: id, ground_truth, ...) |
| predictions_path: JSONL with fields: id, prediction |
| Returns list of result dicts with both CER metrics. |
| """ |
| gt: dict[str, str] = {} |
| with open(manifest_path, encoding="utf-8") as f: |
| for line in f: |
| rec = json.loads(line) |
| gt[rec["id"]] = rec["ground_truth"] |
|
|
| preds: dict[str, str] = {} |
| with open(predictions_path, encoding="utf-8") as f: |
| for line in f: |
| rec = json.loads(line) |
| preds[rec["id"]] = rec["prediction"] |
|
|
| results = [] |
| for id_, reference in gt.items(): |
| hyp = preds.get(id_, "") |
| results.append({ |
| "id": id_, |
| "grapheme_cer": grapheme_cer(hyp, reference), |
| "codepoint_cer": codepoint_cer(hyp, reference), |
| "word_acc": word_accuracy(hyp, reference), |
| "hypothesis": hyp, |
| "reference": reference, |
| }) |
|
|
| if out_path: |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| with open(out_path, "w", encoding="utf-8") as f: |
| for r in results: |
| f.write(json.dumps(r, ensure_ascii=False) + "\n") |
|
|
| return results |
|
|
|
|
| def summary(results: list[dict]) -> dict: |
| """Compute mean metrics across a result list.""" |
| if not results: |
| return {} |
| keys = ["grapheme_cer", "codepoint_cer", "word_acc"] |
| return {k: sum(r[k] for r in results) / len(results) for k in keys} |
|
|
|
|
| |
| |
| |
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--manifest", required=True) |
| ap.add_argument("--predictions", required=True) |
| ap.add_argument("--out", default=None) |
| ap.add_argument("--by_script", action="store_true", |
| help="break down summary by script field in manifest") |
| args = ap.parse_args() |
|
|
| results = evaluate_manifest( |
| Path(args.manifest), |
| Path(args.predictions), |
| Path(args.out) if args.out else None, |
| ) |
| s = summary(results) |
| print(f"\nOverall n={len(results)}") |
| for k, v in s.items(): |
| print(f" {k:20s}: {v:.4f}") |
|
|
| if args.by_script: |
| |
| manifest_meta: dict[str, str] = {} |
| with open(args.manifest, encoding="utf-8") as f: |
| for ln in f: |
| rec = json.loads(ln) |
| manifest_meta[rec["id"]] = rec.get("script", "unknown") |
| scripts: dict[str, list[dict]] = {} |
| for r in results: |
| sc = manifest_meta.get(r["id"], "unknown") |
| scripts.setdefault(sc, []).append(r) |
| for sc, recs in sorted(scripts.items()): |
| s2 = summary(recs) |
| print(f"\nScript={sc} n={len(recs)}") |
| for k, v in s2.items(): |
| print(f" {k:20s}: {v:.4f}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
