Add zerobench_eval: official standalone scorer (pre-generated wavs in, metrics out)

zerobench_eval/README.md

@@ -0,0 +1,51 @@
+# `zerobench_eval` — the official ZeroBench-TTS scorer
+
+Scores **pre-generated wavs**. It never loads, downloads, or runs a TTS model —
+you synthesize however you like, this reports the numbers.
+
+```bash
+pip install -r zerobench_eval/requirements.txt
+
+python -m zerobench_eval manifest --out manifest.jsonl   # what to synthesize
+#   ... your synthesis, one wav per row's `output_wav` ...
+python -m zerobench_eval score --wav_dir my_wavs/ --name MyModel
+```
+
+## Commands
+
+| command | what it does |
+|---|---|
+| `manifest` | writes one JSONL row per test item: `text` to say, `ref_audio` to clone, `output_wav` to write |
+| `score` | scores a wav directory → `per_sample.csv`, `summary.json`, `report.txt` |
+| `rescore` | recomputes WER from saved transcripts — no ASR, no GPU, runs in seconds |
+
+## Layout
+
+`score` looks for `<wav_dir>/<subset>/<voice_id>.wav`, and also accepts a
+nested `wav/` folder or flat `<subset>_<voice_id>.wav` / `<id>.wav` names. If
+files are missing it tells you which and refuses to report a number, unless you
+pass `--allow_missing` (the summary is then flagged `complete: false`).
+
+## Files
+
+| file | contents |
+|---|---|
+| `scorers.py` | WER / SSIM / UTMOS / silence, self-contained |
+| `references.py` | the acceptable-reference expansion — the core of the WER policy |
+| `benchmark.py` | locating benchmark data, matching wavs to items |
+| `report.py` | aggregation and the printed table |
+| `test_references.py` | pins both directions of the WER policy — run it after any edit |
+
+## Notes
+
+* **UTMOSv2 is optional.** WER and SSIM work without it; pass `--skip_utmos`, or
+  install it with
+  `pip install git+https://github.com/sarulab-speech/UTMOSv2.git`.
+* **UTMOS is seeded.** UTMOSv2 ensembles over random crops and is not
+  reproducible unseeded (3.05 / 3.03 / 2.96 for the same clip). The RNG is reset
+  before every clip so the score is a deterministic function of the audio.
+* **Don't change `--asr`** if you want comparable numbers — the default pair is
+  part of the benchmark definition.
+
+Full metric definitions and the rationale are in the
+[dataset README](../README.md).

zerobench_eval/__init__.py

@@ -0,0 +1,11 @@
+"""ZeroBench-TTS official scorer.
+
+Scores pre-generated wavs — it never loads a TTS model.
+
+    python -m zerobench_eval manifest --out manifest.jsonl
+    python -m zerobench_eval score --wav_dir my_wavs/ --name MyModel
+"""
+from .scorers import DEFAULT_ASR, POLICIES, MetricSuite, score_all_policies  # noqa: F401
+from .references import best_wer, expand                                    # noqa: F401
+
+__version__ = "1.0.0"

zerobench_eval/__main__.py

@@ -0,0 +1,199 @@
+"""ZeroBench-TTS official scorer — pre-generated wavs in, metrics out.
+
+This never loads a TTS model. You synthesize the 137 clips however you like,
+point this at the folder, and it reports WER / SSIM / UTMOS / silence.
+
+    # 1. what to synthesize
+    python -m zerobench_eval manifest --out manifest.jsonl
+
+    # 2. ... your own synthesis, writing one wav per row's `output_wav` ...
+
+    # 3. score
+    python -m zerobench_eval score --wav_dir my_wavs/ --name MyModel
+
+Run ``python -m zerobench_eval <command> --help`` for the full flag list.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .benchmark import find_wavs, load_benchmark, resolve_ref_audio
+from .report import format_report, group_report, write_outputs
+from .scorers import DEFAULT_ASR, MetricSuite, load_wav_16k
+
+_HERE = Path(__file__).resolve().parent
+REPO_ID = "zeroweight-ai/ZeroBench-TTS"
+
+
+def _log(msg: str) -> None:
+    print(f"[zerobench] {msg}", flush=True)
+
+
+# ── manifest ──────────────────────────────────────────────────────────────────
+
+def cmd_manifest(args: argparse.Namespace) -> None:
+    """Emit exactly what a submission must contain: one row per test item, with
+    the text to say, the reference clip to clone, and the wav path to write."""
+    rows, root = load_benchmark(args.benchmark)
+    out = Path(args.out)
+    with out.open("w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps({
+                "id": r["id"],
+                "subset": r["subset"],
+                "voice_id": r["voice_id"],
+                "text": r["text"],
+                "lang": r["lang"],
+                "ref_audio": str(resolve_ref_audio(r, root)),
+                "ref_text": r.get("ref_text", ""),
+                "output_wav": f"{r['subset']}/{r['voice_id']}.wav",
+            }, ensure_ascii=False) + "\n")
+    _log(f"wrote {len(rows)} rows -> {out}")
+    _log("Synthesize `text` with `ref_audio` as the voice prompt, save each to "
+         "<your_wav_dir>/<output_wav>, then run: "
+         f"python -m zerobench_eval score --wav_dir <your_wav_dir>")
+
+
+# ── score ─────────────────────────────────────────────────────────────────────
+
+def cmd_score(args: argparse.Namespace) -> None:
+    rows, root = load_benchmark(args.benchmark)
+    if args.subsets:
+        rows = [r for r in rows if r["subset"] in set(args.subsets)]
+    if not rows:
+        raise SystemExit(f"no benchmark items matched (subsets={args.subsets})")
+
+    wav_dir = Path(args.wav_dir)
+    found, missing = find_wavs(rows, wav_dir)
+    if missing:
+        head = ", ".join(m["id"] for m in missing[:5])
+        msg = (f"{len(missing)}/{len(rows)} wavs not found under {wav_dir} "
+               f"(e.g. {head}). Expected <wav_dir>/<subset>/<voice_id>.wav — see "
+               f"`python -m zerobench_eval manifest`.")
+        if not args.allow_missing:
+            raise SystemExit(msg + "\nPass --allow_missing to score the rest anyway.")
+        _log("WARNING " + msg)
+    if not found:
+        raise SystemExit("no wavs to score")
+    _log(f"scoring {len(found)}/{len(rows)} items from {wav_dir}")
+
+    metrics = MetricSuite(device=args.device, asr_models=args.asr or DEFAULT_ASR,
+                          skip_utmos=args.skip_utmos)
+
+    ref_cache: dict[str, "object"] = {}
+    results, t0 = [], __import__("time").time()
+    for i, (row, wav_path) in enumerate(found, 1):
+        ref_path = str(resolve_ref_audio(row, root))
+        if ref_path not in ref_cache:
+            ref_cache[ref_path] = load_wav_16k(ref_path)
+        scored = metrics.score(
+            pred_wav_16k=load_wav_16k(str(wav_path)),
+            ref_wav_16k=ref_cache[ref_path],
+            text=row["text"], text_normalized=row.get("text_normalized", ""),
+            lang=row["lang"],
+        )
+        results.append({
+            "id": row["id"], "subset": row["subset"], "voice_id": row["voice_id"],
+            "voice_source": row.get("voice_source", ""), "lang": row["lang"],
+            "length_bucket": row.get("length_bucket", ""),
+            "text": row["text"], "text_normalized": row.get("text_normalized", ""),
+            **scored, "wav_path": str(wav_path),
+        })
+        if i % 10 == 0 or i == len(found):
+            _log(f"  {i}/{len(found)}  last wer={scored['wer_robust']:.3f} "
+                 f"(strict {scored['wer_strict']:.3f})  "
+                 f"[{__import__('time').time() - t0:.0f}s]")
+
+    name = args.name or wav_dir.name
+    out_dir = Path(args.out_dir) if args.out_dir else wav_dir.parent / f"{name}_zerobench"
+    summary = write_outputs(out_dir, name, results, rows, args)
+    print("\n" + group_report(name, results))
+    _log(f"per-sample -> {out_dir / 'per_sample.csv'}")
+    _log(f"summary    -> {out_dir / 'summary.json'}")
+    if summary["n_scored"] < len(rows):
+        _log(f"NOTE partial submission: {summary['n_scored']}/{len(rows)} items — "
+             "not comparable to full-benchmark numbers.")
+
+
+# ── rescore ───────────────────────────────────────────────────────────────────
+
+def cmd_rescore(args: argparse.Namespace) -> None:
+    """Recompute WER from saved transcripts — no ASR, no GPU, seconds not minutes.
+
+    Transcription does not depend on the reference policy, so editing
+    references.py never requires re-running the ASRs.
+    """
+    import pandas as pd
+    from .scorers import score_all_policies
+
+    for d in args.run_dirs:
+        d = Path(d)
+        csv_path = d / "per_sample.csv"
+        df = pd.read_csv(csv_path)
+        cols = [c for c in df.columns if c.startswith("transcript_")]
+        if not cols:
+            raise SystemExit(f"{csv_path}: no transcript_* columns")
+        before = df["wer"].mean()
+        new = pd.DataFrame([
+            score_all_policies(
+                {c[len("transcript_"):]: ("" if pd.isna(r[c]) else str(r[c])) for c in cols},
+                str(r.text), "" if pd.isna(r.text_normalized) else str(r.text_normalized))
+            for _, r in df.iterrows()], index=df.index)
+        for c in new.columns:
+            df[c] = new[c]
+        df.to_csv(csv_path, index=False, encoding="utf-8")
+        print(f"[zerobench] {d.name}: WER {before * 100:.2f}% -> {df['wer'].mean() * 100:.2f}%")
+        print(group_report(d.name, df.to_dict("records")))
+
+
+# ── cli ───────────────────────────────────────────────────────────────────────
+
+def main(argv: "list[str] | None" = None) -> None:
+    p = argparse.ArgumentParser(
+        prog="python -m zerobench_eval", description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    def common(sp):
+        sp.add_argument("--benchmark", default=None,
+                        help=f"Benchmark dir or metadata.jsonl. Default: this repo if "
+                             f"run from a clone, else downloads {REPO_ID} from the Hub.")
+
+    m = sub.add_parser("manifest", help="write the list of clips to synthesize")
+    common(m)
+    m.add_argument("--out", default="manifest.jsonl")
+    m.set_defaults(func=cmd_manifest)
+
+    s = sub.add_parser("score", help="score a directory of generated wavs")
+    common(s)
+    s.add_argument("--wav_dir", required=True,
+                   help="Directory of generated wavs. Layout <subset>/<voice_id>.wav "
+                        "(a nested wav/ folder and flat <id>.wav names also work).")
+    s.add_argument("--name", default=None, help="Label for this system in the report.")
+    s.add_argument("--out_dir", default=None)
+    s.add_argument("--subsets", nargs="+", default=None)
+    s.add_argument("--device", default="cuda")
+    s.add_argument("--asr", action="append", default=None, metavar="MODEL_ID",
+                   help="Override the ASR set (repeatable). Default is both "
+                        "openai/whisper-large-v3 and vinai/PhoWhisper-large, min taken. "
+                        "Changing this makes numbers non-comparable to the leaderboard.")
+    s.add_argument("--skip_utmos", action="store_true",
+                   help="Skip UTMOSv2 (optional dep); UTMOS is reported as NaN.")
+    s.add_argument("--allow_missing", action="store_true",
+                   help="Score a partial submission instead of erroring.")
+    s.set_defaults(func=cmd_score)
+
+    r = sub.add_parser("rescore", help="recompute WER from saved transcripts (no GPU)")
+    r.add_argument("run_dirs", nargs="+")
+    r.set_defaults(func=cmd_rescore)
+
+    args = p.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

zerobench_eval/benchmark.py

@@ -0,0 +1,96 @@
+"""Locating the benchmark data and matching a submission's wavs to it.
+
+Deliberately forgiving about wav layout — the point of the harness is that
+anyone can score their system, not that they guess a folder convention.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+REPO_ID = "zeroweight-ai/ZeroBench-TTS"
+_HERE = Path(__file__).resolve().parent
+
+
+def _local_root() -> "Path | None":
+    """metadata.jsonl next to this package (i.e. running from a repo clone)."""
+    for cand in (_HERE.parent, _HERE.parent.parent):
+        if (cand / "metadata.jsonl").exists():
+            return cand
+    return None
+
+
+def load_benchmark(path: "str | None" = None) -> "tuple[list[dict], Path]":
+    """Returns (rows, root). ``root`` is what ``ref_audio`` resolves against.
+
+    Resolution order: explicit ``path`` -> a local clone -> download from the Hub.
+    """
+    if path:
+        p = Path(path)
+        if p.is_dir() and (p / "metadata.jsonl").exists():
+            meta, root = p / "metadata.jsonl", p
+        elif p.is_file():
+            meta, root = p, p.parent
+        else:
+            raise SystemExit(f"--benchmark {path!r}: no metadata.jsonl there")
+    else:
+        root = _local_root()
+        if root is None:
+            root = _download()
+        meta = root / "metadata.jsonl"
+
+    rows = [json.loads(l) for l in meta.read_text(encoding="utf-8").splitlines() if l.strip()]
+    rows.sort(key=lambda r: (r["subset"], r["voice_id"]))
+    return rows, root
+
+
+def _download() -> Path:
+    """Pull metadata.jsonl + the reference audio from the Hub, once."""
+    from huggingface_hub import snapshot_download
+
+    print(f"[zerobench] downloading {REPO_ID} reference data from the Hub ...", flush=True)
+    return Path(snapshot_download(
+        REPO_ID, repo_type="dataset",
+        allow_patterns=["metadata.jsonl", "voices.jsonl", "audio/*"],
+    ))
+
+
+def resolve_ref_audio(row: dict, root: Path) -> Path:
+    """Absolute path to a row's reference clip."""
+    p = Path(row["ref_audio"])
+    return p if p.is_absolute() else (root / p).resolve()
+
+
+#: Layouts accepted for a submission, tried in order. Each maps a row to a
+#: path fragment under --wav_dir.
+_LAYOUTS = (
+    lambda r: f"{r['subset']}/{r['voice_id']}.wav",          # the documented one
+    lambda r: f"wav/{r['subset']}/{r['voice_id']}.wav",      # eval_tts.py's output dir
+    lambda r: f"{r['id'].replace('/', '_')}.wav",            # flat, id-derived
+    lambda r: f"{r['subset']}_{r['voice_id']}.wav",          # flat, joined
+    lambda r: f"{r['voice_id']}.wav",                        # flat (single-subset runs)
+)
+
+
+def find_wavs(rows: list[dict], wav_dir: Path) -> "tuple[list[tuple[dict, Path]], list[dict]]":
+    """Match every benchmark row to a wav under ``wav_dir``.
+
+    Returns (found, missing) where found is [(row, path)]. The flat
+    ``<voice_id>.wav`` layout is only consulted when it is unambiguous, since
+    the same voice appears in several subsets.
+    """
+    found: list[tuple[dict, Path]] = []
+    missing: list[dict] = []
+    multi_subset = len({r["subset"] for r in rows}) > 1
+    for row in rows:
+        hit = None
+        for i, layout in enumerate(_LAYOUTS):
+            if multi_subset and i == len(_LAYOUTS) - 1:
+                break                                   # ambiguous across subsets
+            cand = wav_dir / layout(row)
+            if cand.exists():
+                hit = cand
+                break
+        (found.append((row, hit)) if hit else missing.append(row))
+    return found, missing

zerobench_eval/references.py

@@ -0,0 +1,537 @@
+"""Acceptable-reference expansion for WER scoring.
+
+Why this exists
+───────────────
+WER punishes the TTS model for every token the ASR writes differently from the
+reference. But for Vietnamese benchmark text, *most* of those differences are
+the ASR's formatting policy, not the model's pronunciation:
+
+    text        "Hạn cuối là ngày 31/12/2025."
+    whisper-v3  "Hạn cuối là ngày 31 tháng 12, 2025."   ← perfect audio, 0.72 WER
+    PhoWhisper  "hạn cuối là ngày ba mốt tháng mười hai hai ngàn ..."
+
+Both transcripts are *correct readings of correct audio*. A single written
+reference plus a single hand-written spoken reference cannot cover them,
+because the choices compose: an ASR may spell the acronym out while writing the
+numbers as digits, giving a hybrid that matches neither. With k independent
+format decisions there are 2^k acceptable transcripts, and the two-reference
+scheme covers two of them.
+
+So instead of enumerating whole sentences, this module declares, per **surface
+span**, every realization a correct reading may produce, and expands the
+cross-product at scoring time. ``zerobench_eval/scorers.py`` then takes the minimum
+WER over that set (see :func:`best_wer`).
+
+What is deliberately NOT admitted
+─────────────────────────────────
+Only *legitimate* readings. Wrong Vietnamese stays wrong:
+
+  * ``18/04`` → "mười tám tháng **tư**" ✓ / "tháng **không** tư" ✗ (voiced leading zero)
+  * ``92.000.000`` → "chín mươi hai **triệu**" ✓ / "chín mươi hai **nghìn nghìn**" ✗
+  * ``AB-1234`` → "a bê một hai ba bốn" ✓ / "a bê một hai ba **bê** bốn" ✗
+
+Those three are real ZeroTTS defects found in https://github.com/zeroweight-ai/ZeroTTS/blob/main/evaluation/HIGH_WER_ANALYSIS.md,
+and the point of a faithful benchmark is that they keep costing WER.
+
+Phonetic renderings of English loanwords ("Slack" → "sờ lếch") are also NOT
+listed. They are an artifact of PhoWhisper specifically, and the eval now runs
+two ASRs and takes the better — ``openai/whisper-large-v3`` writes the Latin
+spelling, so the artifact is handled by ASR agreement rather than by loosening
+the reference set. The one exception is intra-word spacing (``ChatGPT`` vs
+"chat GPT"), which *both* ASRs get "wrong" and which is pure orthography.
+"""
+
+from __future__ import annotations
+
+import re
+from itertools import product
+
+# ── Vietnamese number reading ─────────────────────────────────────────────────
+# Each helper returns EVERY standard reading, because the dialect/register
+# switches below are all genuinely used by Vietnamese speakers and all emitted
+# by ASR:
+#     5 in the units slot after a tens word  → "lăm" | "năm"
+#     4 in the units slot after "mươi"       → "tư"  | "bốn"
+#     1 in the units slot after "mươi"       → "mốt" | "một"
+#     10^3                                   → "nghìn" | "ngàn"
+#     a <100 group under a larger scale      → with or without "không trăm"
+#     a <10 remainder after "trăm"           → "lẻ" | "linh"
+
+_DIGIT = ["không", "một", "hai", "ba", "bốn", "năm", "sáu", "bảy", "tám", "chín"]
+
+
+def _under_100(n: int, *, after_tens_word: bool = True) -> list[str]:
+    """0-99. ``after_tens_word`` False renders 1-9 bare ("năm"), True allows the
+    post-"mươi" alternants."""
+    if n < 10:
+        return [_DIGIT[n]]
+    if n < 20:
+        unit = n % 10
+        if unit == 0:
+            return ["mười"]
+        if unit == 5:
+            return ["mười lăm"]
+        return [f"mười {_DIGIT[unit]}"]
+    tens, unit = divmod(n, 10)
+    head = f"{_DIGIT[tens]} mươi"
+    if unit == 0:
+        return [head]
+    if unit == 1:
+        tails = ["mốt", "một"] if after_tens_word else ["một"]
+    elif unit == 4:
+        tails = ["tư", "bốn"]
+    elif unit == 5:
+        tails = ["lăm"]
+    else:
+        tails = [_DIGIT[unit]]
+    # Speakers routinely contract away "mươi": "ba mươi mốt" -> "ba mốt",
+    # "hai mươi lăm" -> "hai lăm". Both ASRs emit the contracted form.
+    return ([f"{head} {t}" for t in tails]
+            + [f"{_DIGIT[tens]} {t}" for t in tails])
+
+
+def _group3(n: int, *, pad_hundreds: bool) -> list[str]:
+    """0-999. ``pad_hundreds`` allows the "không trăm ..." form that Vietnamese
+    uses for a sub-100 group sitting under a larger scale ("hai nghìn KHÔNG TRĂM
+    hai mươi lăm")."""
+    if n == 0:
+        return [""]
+    if n < 100:
+        base = _under_100(n)
+        if pad_hundreds:
+            return base + [f"không trăm {b}" for b in base]
+        return base
+    hundreds, rest = divmod(n, 100)
+    head = f"{_DIGIT[hundreds]} trăm"
+    if rest == 0:
+        return [head]
+    if rest < 10:
+        return [f"{head} lẻ {_DIGIT[rest]}", f"{head} linh {_DIGIT[rest]}"]
+    return [f"{head} {r}" for r in _under_100(rest)]
+
+
+_SCALES = ["", "nghìn", "triệu", "tỷ"]
+
+
+def vi_int(n: int, *, cap: int = 12) -> list[str]:
+    """Every standard spoken reading of a non-negative integer."""
+    if n == 0:
+        return ["không"]
+    groups: list[int] = []
+    while n:
+        n, g = divmod(n, 1000)
+        groups.append(g)
+    groups.reverse()                       # most significant first
+    n_groups = len(groups)
+
+    per_group: list[list[str]] = []
+    for i, g in enumerate(groups):
+        scale = _SCALES[n_groups - 1 - i]
+        if g == 0:
+            per_group.append([""])
+            continue
+        # A group is "padded" only when something more significant precedes it.
+        readings = _group3(g, pad_hundreds=i > 0)
+        if scale == "nghìn":
+            per_group.append([f"{r} nghìn" for r in readings] + [f"{r} ngàn" for r in readings])
+        elif scale:
+            per_group.append([f"{r} {scale}" for r in readings])
+        else:
+            per_group.append(readings)
+
+    out: list[str] = []
+    for combo in product(*per_group):
+        s = " ".join(p for p in combo if p).strip()
+        if s and s not in out:
+            out.append(s)
+        if len(out) >= cap:
+            break
+    return out
+
+
+def vi_decimal(written: str) -> list[str]:
+    """"3,2" -> ["ba phẩy hai", ...]. Two-digit fractions get both the
+    read-as-a-number form ("hai phẩy hai mươi bảy") and the digit-by-digit form
+    ("hai phẩy hai bảy"); Vietnamese speakers use both."""
+    whole, _, frac = written.replace(".", "").partition(",")
+    heads = vi_int(int(whole))
+    if not frac:
+        return heads
+    tails = []
+    if len(frac) == 1:
+        tails.append(_DIGIT[int(frac)])
+    else:
+        tails.extend(vi_int(int(frac)))
+        tails.append(" ".join(_DIGIT[int(d)] for d in frac))
+    return [f"{h} phẩy {t}" for h in heads for t in tails]
+
+
+def _spoken(written: str) -> list[str]:
+    """Spoken readings of a bare numeric literal, decimal or integer."""
+    return vi_decimal(written) if "," in written else vi_int(int(written.replace(".", "")))
+
+
+# ── span builders ─────────────────────────────────────────────────────────────
+# Each returns the acceptable realizations of one surface span, written forms
+# FIRST (index 0 is always the verbatim source text, so `text` itself is always
+# among the references and coordinate descent starts from it).
+
+def num(written: str, *, suffix: str = "", extra: list[str] | None = None) -> list[str]:
+    """A number, optionally with a trailing unit that is part of the span."""
+    tail = f" {suffix}" if suffix else ""
+    out = [f"{written}{tail}"] + [f"{s}{tail}" for s in _spoken(written)]
+    return _dedup(out + (extra or []))
+
+
+def pct(written: str) -> list[str]:
+    """"3,2%" -> written form, digits + "phần trăm", and the fully spoken form."""
+    return _dedup([f"{written}%", f"{written} phần trăm"]
+                  + [f"{s} phần trăm" for s in _spoken(written)])
+
+
+def _day(d: int) -> list[str]:
+    """Day-of-month. 1 and 2 take the "mùng/mồng" prefix Vietnamese uses for the
+    first ten days; 31 contracts to "ba mốt"."""
+    base = _under_100(d)
+    out = list(base)
+    if d <= 10:
+        out += [f"mùng {b}" for b in base] + [f"mồng {b}" for b in base]
+    return _dedup(out)
+
+
+def _month(m: int) -> list[str]:
+    """Month name. April is "tư" (never "bốn" as a month), January "một"/"giêng"."""
+    if m == 1:
+        return ["một", "giêng"]
+    if m == 4:
+        return ["tư"]
+    return _under_100(m)
+
+
+def date(written: str, d: int, m: int, y: int | None = None) -> list[str]:
+    """A ``dd/mm[/yyyy]`` span. Covers the written form, the half-spoken forms
+    both ASRs actually emit ("31 tháng 12, 2025"), and the fully spoken form
+    with and without the "năm" filler before the year.
+
+    NOTE the leading zero in ``01/07`` / ``18/04`` is a *writing* convention
+    only — "tháng không bảy" is not admitted, so voicing it stays an error.
+    """
+    # The zero-padded numeral is deliberately NOT offered in the half-spoken
+    # forms. "18 tháng 04" is ambiguous — whisper-large-v3 writes it both for
+    # audio that says "tháng tư" and for audio that says "tháng KHÔNG tư" — and
+    # admitting it silently excuses the voiced-leading-zero defect that
+    # PhoWhisper transcribes explicitly. The verbatim ``written`` span stays a
+    # reference (it is the source text); only the expansion is unpadded.
+    parts = written.split("/")
+    d_num, m_num = [str(d)], [str(m)]
+    days = d_num + _day(d)
+    months = m_num + _month(m)
+
+    out = [written]
+    if y is None:
+        out += [f"{dd} tháng {mm}" for dd in days for mm in months]
+        out += [f"ngày {dd} tháng {mm}" for dd in d_num for mm in m_num]
+        return _dedup(out)
+    years = _dedup([parts[2]] + vi_int(y))
+    out += [f"{dd} tháng {mm} {yy}" for dd in days for mm in months for yy in years]
+    out += [f"{dd} tháng {mm} năm {yy}" for dd in days for mm in months for yy in years]
+    return _dedup(out)
+
+
+def time_(written: str, h: int, mi: int = 0) -> list[str]:
+    """A ``8h30`` / ``6h`` span, including the "rưỡi" (half past) reading."""
+    out = [written, f"{h} giờ" if mi == 0 else f"{h} giờ {mi}", f"{h}:{mi:02d}"]
+    hours = _under_100(h)
+    if mi == 0:
+        out += [f"{hh} giờ" for hh in hours]
+    else:
+        mins = _under_100(mi)
+        out += [f"{hh} giờ {mm}" for hh in hours for mm in mins]
+        out += [f"{hh} giờ {mm} phút" for hh in hours for mm in mins]
+        if mi == 30:
+            out += [f"{hh} giờ rưỡi" for hh in hours] + [f"{hh} rưỡi" for hh in hours]
+    return _dedup(out)
+
+
+def _dedup(items: list[str]) -> list[str]:
+    seen, out = set(), []
+    for s in items:
+        s = re.sub(r"\s+", " ", s).strip()
+        if s and s not in seen:
+            seen.add(s)
+            out.append(s)
+    return out
+
+
+# ── the span table ────────────────────────────────────────────────────────────
+# Keyed by the LITERAL substring as it appears in evaluation/text_pools.py.
+# Matching is longest-key-first and non-overlapping, so "20h" wins over "0h"
+# and "12,7%" over "12%".
+#
+# Curated by hand against the two ASRs' actual output (see
+# https://github.com/zeroweight-ai/ZeroTTS/blob/main/evaluation/HIGH_WER_ANALYSIS.md); every entry is a reading a correct
+# Vietnamese speaker could produce for that span.
+
+SPANS: dict[str, list[str]] = {
+
+    # ── acronyms & brands ─────────────────────────────────────────────────────
+    # Vietnamese reads Latin acronyms three ways: keep the letters, spell them
+    # with Vietnamese letter names, or substitute the translated full name. All
+    # three are correct; which one comes out is the model's choice, not an error.
+    "ChatGPT": ["ChatGPT", "chat GPT", "Chát Ji Pi Ti", "chát gi pi ti",
+                "chat gi pi ti", "chát ji pi ti", "Chat GPT"],
+    "GDP": ["GDP", "gi đi pi", "giê đê pê", "tổng sản phẩm quốc nội"],
+    "WHO": ["WHO", "đắp liu hát ô", "vê hát ô", "đấp bờ liu ết chờ ô",
+            "Tổ chức Y tế Thế giới"],
+    "WTO": ["WTO", "đắp liu ti ô", "vê tê ô", "đấp bờ liu ti ô",
+            "Tổ chức Thương mại Thế giới"],
+    "UNICEF": ["UNICEF", "U-ni-xép", "u ni xép", "iu ni xép",
+               "Quỹ Nhi đồng Liên Hợp Quốc"],
+    "UNESCO": ["UNESCO", "U-nét-cô", "u nét cô", "iu nét cô"],
+    "ASEAN": ["ASEAN", "A-sê-an", "a sê an", "át xê an", "a si an"],
+    "HR": ["HR", "hát rờ", "ét chờ a rờ", "ây át rờ", "nhân sự"],
+    "IT": ["IT", "ai ti", "i ti"],
+    "QR": ["QR", "kiu a", "quy a", "cu rờ", "ku a"],
+    "Internet": ["Internet", "In-tơ-nét", "in tơ nét", "internet"],
+    "Gemini": ["Gemini", "Giê mi ni", "gờ mi ni", "gemini"],
+    "Copilot": ["Copilot", "Cô pi lốt", "co pi lot", "copilot"],
+    "Vientiane": ["Vientiane", "Viêng Chăn", "viêng chăn"],
+    "TP. HCM": ["TP. HCM", "TPHCM", "TP HCM", "Thành phố Hồ Chí Minh",
+                "thành phố Hồ Chí Minh", "tê pê hát xê em"],
+    "SE1": ["SE1", "SE 1", "ét ê một", "ét xê một", "es i một", "SE một"],
+
+    # Codes: the letters may stay Latin or be spelled with Vietnamese letter
+    # names, and the digits may stay digits or be read out — independently.
+    "VN-215": ["VN-215", "VN 215", "VN215",
+               "vê en 215", "vê en hai một năm", "vê en hai một lăm",
+               "vê en hai trăm mười lăm", "vê nờ hai một năm", "vi en hai một năm"],
+    "AB-1234": ["AB-1234", "AB 1234", "AB1234",
+                "a bê 1234", "a bê một hai ba bốn", "a bê một hai ba tư",
+                "ây bi một hai ba bốn", "a bê một nghìn hai trăm ba mươi bốn"],
+    "USD/VND": ["USD/VND", "USD VND", "USD trên VND",
+                "đô la Mỹ trên đồng Việt Nam", "đô la Mỹ đồng Việt Nam",
+                "u ét đê trên vê en đê", "đô la Mỹ VND", "u ét đê vê en đê"],
+
+    # ── quarters (roman numerals) ─────────────────────────────────────────────
+    "quý III": ["quý III", "quý 3", "quý ba"],
+    "quý II": ["quý II", "quý 2", "quý hai"],
+    "quý I": ["quý I", "quý 1", "quý một"],
+
+    # ── units & symbols ───────────────────────────────────────────────────────
+    "38°C": ["38°C", "38 độ C", "ba mươi tám độ C", "ba mươi tám độ xê",
+             "ba mươi tám độ"],
+    "5 km": ["5 km", "năm km", "năm ki lô mét", "5 ki lô mét", "năm cây số"],
+    "đồng/tháng": ["đồng/tháng", "đồng một tháng", "đồng mỗi tháng", "đồng trên tháng"],
+
+    # ── dates ─────────────────────────────────────────────────────────────────
+    "31/12/2025": date("31/12/2025", 31, 12, 2025),
+    "01/07/2024": date("01/07/2024", 1, 7, 2024),
+    "2/9/1945": date("2/9/1945", 2, 9, 1945),
+    "1/1/2026": date("1/1/2026", 1, 1, 2026),
+    "15/8": date("15/8", 15, 8),
+    "10/03": date("10/03", 10, 3),
+    "25/03": date("25/03", 25, 3),
+    "09/10": date("09/10", 9, 10),
+    "20/11": date("20/11", 20, 11),
+    "30/11": date("30/11", 30, 11),
+    "18/04": date("18/04", 18, 4),
+    "27/6": date("27/6", 27, 6),
+
+    # ── times ─────────────────────────────────────────────────────────────────
+    "23h59": time_("23h59", 23, 59),
+    "20h55": time_("20h55", 20, 55),
+    "12h30": time_("12h30", 12, 30),
+    "11h20": time_("11h20", 11, 20),
+    "8h30": time_("8h30", 8, 30),
+    "5h45": time_("5h45", 5, 45),
+    "4h50": time_("4h50", 4, 50),
+    "20h": time_("20h", 20),
+    "18h": time_("18h", 18),
+    "9h": time_("9h", 9),
+    "6h": time_("6h", 6),
+    "4h": time_("4h", 4),
+    "0h": time_("0h", 0) + ["không giờ", "12 giờ đêm"],
+
+    # ── percentages ───────────────────────────────────────────────────────────
+    "12,7%": pct("12,7"), "2,27%": pct("2,27"), "0,15%": pct("0,15"),
+    "99,4%": pct("99,4"), "0,3%": pct("0,3"), "1,7%": pct("1,7"),
+    "4,9%": pct("4,9"), "3,2%": pct("3,2"), "6,8%": pct("6,8"),
+    "100%": pct("100"), "90%": pct("90"), "75%": pct("75"), "60%": pct("60"),
+    "50%": pct("50"), "40%": pct("40"), "35%": pct("35"), "12%": pct("12"),
+    "10%": pct("10"), "6%": pct("6"),
+
+    # ── quantities (span includes the unit so bare digits stay unambiguous) ───
+    "92.000.000 đồng": num("92.000.000", suffix="đồng"),
+    "5.310.000 đồng": num("5.310.000", suffix="đồng"),
+    "1.100.000 thí sinh": num("1.100.000", suffix="thí sinh"),
+    "1.000.000 đồng": num("1.000.000", suffix="đồng"),
+    "350.000 giao dịch": num("350.000", suffix="giao dịch"),
+    "1.250 tỷ đồng": num("1.250", suffix="tỷ đồng"),
+    "9.000 ca": num("9.000", suffix="ca"),
+    "500 thí sinh": num("500", suffix="thí sinh"),
+    "5,2 triệu": num("5,2", suffix="triệu"),
+    "3,5 triệu": num("3,5", suffix="triệu"),
+    "7,5 triệu": num("7,5", suffix="triệu"),
+    "1,3 triệu": num("1,3", suffix="triệu"),
+    "lần thứ 44": ["lần thứ 44", "lần thứ bốn mươi bốn", "lần thứ bốn mươi tư"],
+    "10 nước": num("10", suffix="nước"),
+    "32 tiếng": num("32", suffix="tiếng"),
+    "gấp 3 lần": ["gấp 3 lần", "gấp ba lần"],
+    "26 và 27/6": ["26 và 27/6", "26 và 27 tháng 6",
+                   "hai mươi sáu và hai mươi bảy tháng sáu",
+                   "hai sáu và hai bảy tháng sáu"],
+    "2000 – 2019": ["2000 – 2019", "2000-2019", "2000 đến 2019",
+                    "hai nghìn đến hai nghìn mười chín",
+                    "hai nghìn đến hai nghìn không trăm mười chín",
+                    "hai ngàn đến hai ngàn không trăm mười chín",
+                    "hai nghìn hai nghìn mười chín"],
+
+    # ── spelled-out numbers in the SOURCE text ────────────────────────────────
+    # The mirror image of the cases above: where text_pools already writes the
+    # number as words, whisper-large-v3 transcribes it back as a digit ("thứ
+    # Sáu" -> "thứ 6", "chín giờ" -> "9 giờ"). Same audio either way, so
+    # admitting both spellings cannot excuse a mispronunciation — it only stops
+    # charging WER for the ASR's choice of numerals.
+    "thứ Hai": ["thứ Hai", "thứ 2"],
+    "thứ Tư": ["thứ Tư", "thứ 4"],
+    "thứ Sáu": ["thứ Sáu", "thứ 6"],
+    "thứ ba": ["thứ ba", "thứ 3"],
+    "chín giờ": ["chín giờ", "9 giờ", "9h"],
+    "sáu giờ": ["sáu giờ", "6 giờ", "6h"],
+    "mười lăm phút": ["mười lăm phút", "15 phút"],
+    "ba mươi phút": ["ba mươi phút", "30 phút"],
+    "mười tiếng": ["mười tiếng", "10 tiếng"],
+    "một tiếng": ["một tiếng", "1 tiếng"],
+    "ba năm": ["ba năm", "3 năm"],
+    "sáu tháng": ["sáu tháng", "6 tháng"],
+    "hai ngày": ["hai ngày", "2 ngày"],
+    "ba ngày": ["ba ngày", "3 ngày"],
+    "một tuần": ["một tuần", "1 tuần"],
+    "một ngày": ["một ngày", "1 ngày"],
+    "năm mươi nghìn": ["năm mươi nghìn", "50.000", "50000", "năm mươi ngàn"],
+
+    # ── English loanwords whose Vietnamese pronunciation both ASRs re-spell ───
+    # Kept deliberately short: two-ASR agreement already covers PhoWhisper's
+    # phonetic renderings. These are the ones BOTH ASRs write differently from
+    # the source, i.e. genuinely ambiguous orthography rather than ASR weakness.
+    "Series": ["Series", "Serie"],
+    "series": ["series", "serie"],
+    "Team": ["Team", "Tim"],
+    # NOTE deliberately absent: "khuyến mãi" / "khuyến mại". That pair differs
+    # by TONE (ngã vs nặng), so it is a mispronunciation, not a spelling
+    # variant — the model really did say the wrong tone and must be charged.
+    # Same rule for every other tone-only pair: never admit one.
+
+    # ── bare years (always preceded by "năm" in the source text) ──────────────
+    "năm 2020": ["năm 2020"] + [f"năm {s}" for s in vi_int(2020)],
+    "năm 2024": ["năm 2024"] + [f"năm {s}" for s in vi_int(2024)],
+    "năm 2025": ["năm 2025"] + [f"năm {s}" for s in vi_int(2025)],
+    "năm 2030": ["năm 2030"] + [f"năm {s}" for s in vi_int(2030)],
+}
+
+_SPAN_RE = re.compile("|".join(re.escape(k) for k in sorted(SPANS, key=len, reverse=True)))
+
+
+# ── expansion & scoring ───────────────────────────────────────────────────────
+
+def segment(text: str) -> list[list[str]]:
+    """Split ``text`` into alternating fixed and variable segments.
+
+    Returns a list where each element is the list of acceptable realizations of
+    that segment — length 1 for literal text between spans. Element 0 of every
+    variable segment is the verbatim source form, so taking index 0 everywhere
+    reconstructs ``text``.
+    """
+    segs: list[list[str]] = []
+    pos = 0
+    for m in _SPAN_RE.finditer(text):
+        if m.start() > pos:
+            segs.append([text[pos:m.start()]])
+        segs.append(SPANS[m.group(0)])
+        pos = m.end()
+    if pos < len(text):
+        segs.append([text[pos:]])
+    return segs or [[text]]
+
+
+def n_variants(text: str) -> int:
+    n = 1
+    for s in segment(text):
+        n *= len(s)
+    return n
+
+
+def expand(text: str, limit: int = 4096) -> list[str]:
+    """Full cross-product of acceptable references, capped. Mostly for
+    inspection and tests — :func:`best_wer` avoids materializing it."""
+    segs = segment(text)
+    out = []
+    for combo in product(*segs):
+        out.append(re.sub(r"\s+", " ", "".join(combo)).strip())
+        if len(out) >= limit:
+            break
+    return out
+
+
+_EXHAUSTIVE_MAX = 512
+
+
+def best_wer(hyp: str, text: str, extra_refs: list[str] | None = None) -> tuple[float, str]:
+    """Minimum WER of ``hyp`` over every acceptable reading of ``text``.
+
+    Returns ``(wer, winning_reference)``.
+
+    Exhaustive when the cross-product is small. Above that it uses coordinate
+    descent: start from the verbatim text, then repeatedly pick the best
+    realization of one span holding the others fixed. The spans are disjoint,
+    contiguous, and non-interacting under edit distance, so this reaches the
+    same optimum as brute force in practice while doing O(spans x variants)
+    scorings instead of their product.
+    """
+    from .scorers import normalize_for_cer, word_error_rate
+
+    h = normalize_for_cer(hyp)
+
+    def score(ref: str) -> float:
+        return word_error_rate(h, normalize_for_cer(ref))
+
+    segs = segment(text)
+    total = 1
+    for s in segs:
+        total *= len(s)
+
+    best_ref, best = None, 2.0
+    if total <= _EXHAUSTIVE_MAX:
+        for combo in product(*segs):
+            ref = "".join(combo)
+            w = score(ref)
+            if w < best:
+                best, best_ref = w, ref
+    else:
+        idx = [0] * len(segs)
+        best_ref = "".join(s[0] for s in segs)
+        best = score(best_ref)
+        for _ in range(3):
+            improved = False
+            for i, seg in enumerate(segs):
+                if len(seg) == 1:
+                    continue
+                for j in range(len(seg)):
+                    if j == idx[i]:
+                        continue
+                    trial = idx.copy()
+                    trial[i] = j
+                    ref = "".join(segs[k][trial[k]] for k in range(len(segs)))
+                    w = score(ref)
+                    if w < best - 1e-12:
+                        best, best_ref, idx, improved = w, ref, trial, True
+            if not improved:
+                break
+
+    for ref in extra_refs or []:
+        if not ref:
+            continue
+        w = score(ref)
+        if w < best:
+            best, best_ref = w, ref
+    return min(best, 1.0), (best_ref or text)

zerobench_eval/report.py

@@ -0,0 +1,95 @@
+"""Aggregation, the printed table, and the files a scoring run leaves behind."""
+
+from __future__ import annotations
+
+import csv
+import json
+import statistics
+from collections import OrderedDict
+from pathlib import Path
+
+import numpy as np
+
+from .scorers import POLICIES
+
+_AGG_KEYS = ("wer", "wer_strict", "wer_norm", "wer_robust", "ssim", "utmos",
+             "excess_silence")
+
+
+def aggregate(rows: list[dict]) -> dict:
+    out: dict = {"n": len(rows)}
+    for key in _AGG_KEYS:
+        vals = [r[key] for r in rows
+                if r.get(key) is not None
+                and not (isinstance(r[key], float) and np.isnan(r[key]))]
+        out[f"{key}_mean"] = float(statistics.mean(vals)) if vals else float("nan")
+        out[f"{key}_median"] = float(statistics.median(vals)) if vals else float("nan")
+    return out
+
+
+def _group_by(rows: list[dict], key: str) -> "OrderedDict[str, dict]":
+    buckets: "OrderedDict[str, list[dict]]" = OrderedDict()
+    for r in rows:
+        buckets.setdefault(str(r.get(key, "")), []).append(r)
+    return OrderedDict((k, aggregate(v)) for k, v in sorted(buckets.items()))
+
+
+def format_report(title: str, groups: "dict[str, dict]") -> str:
+    """Fixed-width table; one row per group, all three WER policies side by side."""
+    w = 118
+    lines = ["=" * w, title, "=" * w,
+             f"{'group':<22}{'n':>5}{'WER strict':>15}{'WER norm':>15}"
+             f"{'WER robust':>15}{'SSIM':>15}{'UTMOS':>15}{'EXCESS-SIL s':>15}",
+             f"{'':<22}{'':>5}" + "".join(f"{'mean/median':>15}" for _ in range(6))]
+    for name, s in groups.items():
+        lines.append(
+            f"{name:<22}{s['n']:>5}"
+            + "".join(f"{s[f'wer_{p}_mean']:>7.4f}/{s[f'wer_{p}_median']:<7.4f}"
+                      for p in POLICIES)
+            + f"{s['ssim_mean']:>7.4f}/{s['ssim_median']:<7.4f}"
+              f"{s['utmos_mean']:>7.4f}/{s['utmos_median']:<7.4f}"
+              f"{s['excess_silence_mean']:>7.4f}/{s['excess_silence_median']:<7.4f}")
+    lines.append("=" * w)
+    return "\n".join(lines)
+
+
+def group_report(name: str, rows: list[dict]) -> str:
+    return "\n".join([
+        format_report(f"ZeroBench-TTS — {name}",
+                      {**_group_by(rows, "subset"), "── overall ──": aggregate(rows)}),
+        format_report("by length bucket", _group_by(rows, "length_bucket")),
+        format_report("by voice source", _group_by(rows, "voice_source")),
+    ])
+
+
+def write_outputs(out_dir: Path, name: str, results: list[dict],
+                  all_rows: list[dict], args) -> dict:
+    """per_sample.csv + summary.json + report.txt. Returns the summary."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    with (out_dir / "per_sample.csv").open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(results[0].keys()))
+        writer.writeheader()
+        writer.writerows(results)
+
+    summary = {
+        "system": name,
+        "benchmark": "zeroweight-ai/ZeroBench-TTS",
+        "n_items": len(all_rows),
+        "n_scored": len(results),
+        "complete": len(results) == len(all_rows),
+        "asr_models": list(getattr(args, "asr", None) or
+                           ("openai/whisper-large-v3", "vinai/PhoWhisper-large")),
+        "wer_policies": list(POLICIES),
+        "headline_wer_policy": "robust",
+        "utmos_scored": not getattr(args, "skip_utmos", False),
+        "overall": aggregate(results),
+        "by_subset": _group_by(results, "subset"),
+        "by_length_bucket": _group_by(results, "length_bucket"),
+        "by_voice_source": _group_by(results, "voice_source"),
+    }
+    (out_dir / "summary.json").write_text(
+        json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8")
+    (out_dir / "report.txt").write_text(group_report(name, results) + "\n",
+                                        encoding="utf-8")
+    return summary

zerobench_eval/requirements.txt

@@ -0,0 +1,14 @@
+# ZeroBench-TTS scorer. Install with:  pip install -r zerobench_eval/requirements.txt
+torch>=2.0
+torchaudio>=2.0
+transformers>=4.40
+huggingface_hub>=0.23
+soundfile>=0.12
+librosa>=0.10
+numpy>=1.24
+pandas>=2.0
+jiwer>=3.0
+
+# UTMOSv2 (naturalness MOS) is OPTIONAL — WER and SSIM work without it.
+# Install it for the full metric set, or pass --skip_utmos:
+#   pip install git+https://github.com/sarulab-speech/UTMOSv2.git

zerobench_eval/scorers.py

@@ -0,0 +1,355 @@
+"""Self-contained metric implementations for ZeroBench-TTS.
+
+No TTS model is ever loaded here — this module only reads finished wavs and
+scores them:
+
+    WER    two ASRs (openai/whisper-large-v3 + vinai/PhoWhisper-large), min taken,
+           against the expanded reference set from ``references.py``
+    SSIM   cosine similarity of microsoft/wavlm-base-plus-sv x-vectors between
+           the generated clip and the benchmark's reference clip
+    UTMOS  UTMOSv2 naturalness MOS (optional — see ``UTMOSScorer``)
+    SIL    excess leading / trailing / mid-utterance silence, in seconds
+
+Everything loads once per process and is reused across items.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+import numpy as np
+
+DEFAULT_ASR = ("openai/whisper-large-v3", "vinai/PhoWhisper-large")
+
+#: Reference policies, in reporting order. See ``score_all_policies``.
+POLICIES = ("strict", "norm", "robust")
+
+
+# ── text normalization + WER ──────────────────────────────────────────────────
+
+def normalize_for_cer(text: str) -> str:
+    """lowercase, NFC-normalize, strip punctuation, collapse whitespace."""
+    text = unicodedata.normalize("NFC", text.lower())
+    text = re.sub(r"[^\w\s]", "", text, flags=re.UNICODE)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def _levenshtein_seq(a, b) -> int:
+    if a == b:
+        return 0
+    if not a:
+        return len(b)
+    if not b:
+        return len(a)
+    prev = list(range(len(b) + 1))
+    for i, ca in enumerate(a, 1):
+        cur = [i] + [0] * len(b)
+        for j, cb in enumerate(b, 1):
+            cur[j] = min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (0 if ca == cb else 1))
+        prev = cur
+    return prev[-1]
+
+
+def word_error_rate(hyp: str, ref: str) -> float:
+    """WER = edit_distance(words) / len(ref_words), clamped to [0, 1]. Callers
+    normalize with :func:`normalize_for_cer` first."""
+    ref_words, hyp_words = ref.split(), hyp.split()
+    if not ref_words:
+        return 0.0 if not hyp_words else 1.0
+    try:
+        import jiwer
+        m = jiwer.process_words(ref, hyp)
+        dist = m.substitutions + m.deletions + m.insertions
+    except ImportError:
+        dist = _levenshtein_seq(hyp_words, ref_words)
+    return float(min(max(dist / len(ref_words), 0.0), 1.0))
+
+
+def score_wer_flat(pred: str, references: list[str]) -> tuple[float, str]:
+    """min WER over an explicit list of whole-sentence references."""
+    hyp = normalize_for_cer(pred)
+    best, best_ref = 1.0, references[0] if references else ""
+    for ref in references:
+        if not ref:
+            continue
+        w = word_error_rate(hyp, normalize_for_cer(ref))
+        if w < best:
+            best, best_ref = w, ref
+    return best, best_ref
+
+
+def score_all_policies(transcripts: dict[str, str], text: str,
+                       text_normalized: str = "") -> dict:
+    """WER of every ASR transcript under all three reference policies.
+
+    ``transcripts`` maps an ASR label -> its transcript of the same clip.
+
+    Returns ``wer_<policy>`` (min across ASRs — the reported number),
+    ``wer_<policy>_<asr>`` per ASR, and which ASR / reference won ``robust``.
+    """
+    from .references import best_wer
+
+    normalized = text_normalized if text_normalized and text_normalized != text else ""
+    out: dict = {}
+    winners: dict[str, tuple[float, str, str]] = {}
+
+    for policy in POLICIES:
+        per_asr: dict[str, tuple[float, str]] = {}
+        for label, hyp in transcripts.items():
+            if policy == "strict":
+                wer, ref = score_wer_flat(hyp, [text])
+            elif policy == "norm":
+                wer, ref = score_wer_flat(hyp, [text] + ([normalized] if normalized else []))
+            else:
+                wer, ref = best_wer(hyp, text, [normalized] if normalized else [])
+            per_asr[label] = (wer, ref)
+            out[f"wer_{policy}_{label}"] = round(wer, 6)
+        label = min(per_asr, key=lambda k: per_asr[k][0])
+        wer, ref = per_asr[label]
+        out[f"wer_{policy}"] = round(wer, 6)
+        winners[policy] = (wer, ref, label)
+
+    out["wer"] = out["wer_robust"]                       # headline
+    out["wer_matched_reference"] = winners["robust"][1]
+    out["wer_matched_asr"] = winners["robust"][2]
+    return out
+
+
+# ── ASR ───────────────────────────────────────────────────────────────────────
+
+def asr_label(model_id: str) -> str:
+    """Short, column-safe name for an ASR checkpoint."""
+    tail = model_id.split("/")[-1].lower()
+    if "phowhisper" in tail:
+        return "pho"
+    if "whisper-large-v3" in tail:
+        return "wlv3"
+    return re.sub(r"[^0-9a-z]+", "_", tail).strip("_")
+
+
+class WhisperTranscriber:
+    """Any Whisper-family checkpoint from `transformers`."""
+
+    def __init__(self, model_id: str = "openai/whisper-large-v3", device: str = "cuda"):
+        import torch
+        from transformers import WhisperForConditionalGeneration, WhisperProcessor
+
+        self.torch = torch
+        self.device = torch.device(device)
+        self.processor = WhisperProcessor.from_pretrained(model_id)
+        dtype = torch.float16 if self.device.type == "cuda" else torch.float32
+        self.model = (WhisperForConditionalGeneration
+                      .from_pretrained(model_id, torch_dtype=dtype)
+                      .to(self.device).eval())
+        for p in self.model.parameters():
+            p.requires_grad = False
+
+    def transcribe(self, wav_16k: np.ndarray, lang: str | None = "vi") -> str:
+        with self.torch.no_grad():
+            feats = self.processor(wav_16k, sampling_rate=16_000, return_tensors="pt")
+            feats = feats.input_features.to(self.device, dtype=self.model.dtype)
+            forced = (self.processor.get_decoder_prompt_ids(language=lang, task="transcribe")
+                      if lang else None)
+            ids = self.model.generate(feats, forced_decoder_ids=forced, max_new_tokens=256)
+        return self.processor.batch_decode(ids, skip_special_tokens=True)[0].strip()
+
+
+# ── speaker similarity ────────────────────────────────────────────────────────
+
+class SSIMScorer:
+    """Cosine similarity between WavLM-SV x-vectors of generated and reference audio."""
+
+    def __init__(self, model_id: str = "microsoft/wavlm-base-plus-sv", device: str = "cuda"):
+        import torch
+        from transformers import WavLMForXVector, Wav2Vec2FeatureExtractor
+
+        self.torch = torch
+        self.device = torch.device(device)
+        self.extractor = Wav2Vec2FeatureExtractor.from_pretrained(model_id)
+        self.model = WavLMForXVector.from_pretrained(model_id).to(self.device).eval()
+        for p in self.model.parameters():
+            p.requires_grad = False
+
+    def embed(self, wav_16k: np.ndarray) -> np.ndarray:
+        with self.torch.no_grad():
+            inputs = self.extractor(wav_16k, sampling_rate=16_000, return_tensors="pt")
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            return self.model(**inputs).embeddings.squeeze(0).float().cpu().numpy()
+
+    def score(self, pred_wav_16k: np.ndarray, ref_wav_16k: np.ndarray) -> float:
+        a, b = self.embed(pred_wav_16k), self.embed(ref_wav_16k)
+        return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8))
+
+
+# ── naturalness ───────────────────────────────────────────────────────────────
+
+UTMOS_INSTALL_HINT = (
+    "UTMOSv2 is not installed. It is an optional dependency (WER and SSIM work "
+    "without it):\n"
+    "    pip install git+https://github.com/sarulab-speech/UTMOSv2.git\n"
+    "Or pass --skip_utmos to report NaN for the UTMOS column."
+)
+
+
+class UTMOSScorer:
+    """UTMOSv2 naturalness MOS. Optional — see :data:`UTMOS_INSTALL_HINT`.
+
+    UTMOSv2 ensembles over randomly sampled spectrogram crops, so an unseeded
+    call is NOT reproducible: scoring one clip three times in a row returns
+    e.g. 3.05 / 3.03 / 2.96. A benchmark number that moves between runs is not
+    a benchmark number, so the RNG is reset to ``seed`` before every clip. That
+    makes UTMOS a deterministic function of the audio, which is what lets two
+    people scoring the same wavs get the same figure.
+    """
+
+    def __init__(self, device: str = "cuda", seed: int = 42):
+        try:
+            import utmosv2
+        except ImportError as e:                       # pragma: no cover
+            raise ImportError(UTMOS_INSTALL_HINT) from e
+        self.model = utmosv2.create_model(pretrained=True)
+        self.seed = seed
+
+    def _reseed(self) -> None:
+        import random
+
+        import torch
+        random.seed(self.seed)
+        np.random.seed(self.seed)
+        torch.manual_seed(self.seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed_all(self.seed)
+
+    def score(self, wav_16k: np.ndarray) -> float:
+        self._reseed()
+        mos = self.model.predict(data=wav_16k, sr=16_000)
+        if hasattr(mos, "item"):
+            return float(mos.item())
+        if isinstance(mos, (list, np.ndarray)):
+            return float(mos[0])
+        return float(mos)
+
+
+# ── silence hygiene (no model) ────────────────────────────────────────────────
+
+class SilenceScorer:
+    """How much *unwanted* silence a clip carries — long lead-in, long tail, long
+    internal pauses.
+
+    Nothing in WER/SSIM/UTMOS penalizes dead air: an ASR happily transcribes a
+    clip that opens with 1.5 s of nothing, the x-vector is unaffected, and UTMOS
+    rates the audio quality of silence as fine. ``librosa.effects.split`` gates
+    frame energy at ``top_db`` below the clip's own peak; whatever it drops is
+    silence. ``excess_silence`` ignores the silence a natural utterance is
+    allowed (``max_edge_sec`` per end, ``max_mid_sec`` per internal pause).
+    """
+
+    def __init__(self, top_db: float = 35.0, frame_length: int = 1024,
+                 hop_length: int = 256, max_edge_sec: float = 0.1,
+                 max_mid_sec: float = 0.3):
+        self.top_db = top_db
+        self.frame_length = frame_length
+        self.hop_length = hop_length
+        self.max_edge_sec = max_edge_sec
+        self.max_mid_sec = max_mid_sec
+
+    def score(self, wav_16k: np.ndarray, sr: int = 16_000) -> dict:
+        import librosa
+
+        wav = np.asarray(wav_16k, dtype=np.float32).reshape(-1)
+        dur = len(wav) / sr
+        dead = {"lead_silence": dur, "trail_silence": 0.0, "max_mid_silence": 0.0,
+                "total_mid_silence": 0.0, "excess_silence": dur,
+                "speech_duration": 0.0, "duration": dur}
+        if (len(wav) < self.frame_length or not np.any(np.isfinite(wav))
+                or float(np.abs(wav).max()) <= 0.0):
+            return dead
+
+        intervals = librosa.effects.split(wav, top_db=self.top_db,
+                                          frame_length=self.frame_length,
+                                          hop_length=self.hop_length)
+        if len(intervals) == 0:
+            return dead
+
+        lead = float(intervals[0][0]) / sr
+        trail = float(len(wav) - intervals[-1][1]) / sr
+        gaps = [float(intervals[k][0] - intervals[k - 1][1]) / sr
+                for k in range(1, len(intervals))]
+        excess = (max(0.0, lead - self.max_edge_sec) + max(0.0, trail - self.max_edge_sec)
+                  + sum(max(0.0, g - self.max_mid_sec) for g in gaps))
+        return {
+            "lead_silence": lead, "trail_silence": trail,
+            "max_mid_silence": max(gaps) if gaps else 0.0,
+            "total_mid_silence": float(sum(gaps)),
+            "excess_silence": excess,
+            "speech_duration": float(sum(e - s for s, e in intervals)) / sr,
+            "duration": dur,
+        }
+
+
+# ── audio io ──────────────────────────────────────────────────────────────────
+
+def load_wav_16k(path: str) -> np.ndarray:
+    """Read any wav as mono float32 at 16 kHz."""
+    import soundfile as sf
+
+    wav, sr = sf.read(str(path), dtype="float32", always_2d=False)
+    wav = np.asarray(wav, dtype=np.float32)
+    if wav.ndim > 1:
+        wav = wav.mean(axis=1)
+    return resample_to_16k(wav.reshape(-1), sr)
+
+
+def resample_to_16k(wav: np.ndarray, sr: int) -> np.ndarray:
+    if sr == 16_000:
+        return wav.astype(np.float32)
+    try:
+        import torch
+        import torchaudio
+        t = torch.from_numpy(wav.astype(np.float32)).unsqueeze(0)
+        return torchaudio.functional.resample(t, sr, 16_000).squeeze(0).numpy()
+    except ImportError:
+        import librosa
+        return librosa.resample(wav.astype(np.float32), orig_sr=sr, target_sr=16_000)
+
+
+# ── the bundle ────────────────────────────────────────────────────────────────
+
+class MetricSuite:
+    """Loads every scorer once. Instantiate a single time per process."""
+
+    def __init__(self, device: str = "cuda", asr_models=DEFAULT_ASR,
+                 skip_utmos: bool = False, silence_top_db: float = 35.0,
+                 silence_max_edge_sec: float = 0.1, silence_max_mid_sec: float = 0.3):
+        self.asr: dict[str, WhisperTranscriber] = {}
+        for model_id in asr_models:
+            print(f"[zerobench] loading ASR {model_id} ...", flush=True)
+            self.asr[asr_label(model_id)] = WhisperTranscriber(model_id, device=device)
+        print("[zerobench] loading SSIM (WavLM-SV) ...", flush=True)
+        self.ssim = SSIMScorer(device=device)
+        self.utmos = None
+        if not skip_utmos:
+            print("[zerobench] loading UTMOS (UTMOSv2) ...", flush=True)
+            self.utmos = UTMOSScorer(device=device)
+        self.silence = SilenceScorer(top_db=silence_top_db,
+                                     max_edge_sec=silence_max_edge_sec,
+                                     max_mid_sec=silence_max_mid_sec)
+
+    def score(self, pred_wav_16k: np.ndarray, ref_wav_16k: np.ndarray,
+              text: str, text_normalized: str = "", lang: str = "vi") -> dict:
+        transcripts = {label: a.transcribe(pred_wav_16k, lang=lang)
+                       for label, a in self.asr.items()}
+        sil = self.silence.score(pred_wav_16k, 16_000)
+        return {
+            **{f"transcript_{k}": v for k, v in transcripts.items()},
+            **score_all_policies(transcripts, text, text_normalized),
+            "ssim": self.ssim.score(pred_wav_16k, ref_wav_16k),
+            "utmos": self.utmos.score(pred_wav_16k) if self.utmos else float("nan"),
+            "excess_silence": sil["excess_silence"],
+            "lead_silence": sil["lead_silence"],
+            "trail_silence": sil["trail_silence"],
+            "max_mid_silence": sil["max_mid_silence"],
+            "duration_sec": len(pred_wav_16k) / 16_000,
+        }

zerobench_eval/test_references.py

@@ -0,0 +1,162 @@
+"""Regression tests for the WER reference policy.
+
+    pytest zerobench_eval/test_references.py -q
+
+Two invariants, and they pull in opposite directions:
+
+  ARTIFACTS  a correct reading transcribed in an unexpected FORMAT must score
+             0.00 — otherwise the benchmark measures the ASR's formatting
+             policy instead of the TTS model.
+  DEFECTS    a genuinely wrong reading must still cost WER — otherwise the
+             reference set has been loosened into uselessness.
+
+Every case below is a real transcript observed in https://github.com/zeroweight-ai/ZeroTTS/blob/main/evaluation/HIGH_WER_ANALYSIS.md.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from zerobench_eval.references import best_wer, expand, n_variants, vi_int  # noqa: E402
+
+_TP_HCM = ("Hà Nội, TP. HCM và Đà Nẵng chiếm khoảng 35% GDP cả nước, nhưng chỉ có 12% "
+           "diện tích cây xanh trên đầu người đạt chuẩn, theo báo cáo được công bố "
+           "ngày 18/04 vừa qua.")
+
+# (text, transcript) pairs that MUST score 0.00 — correct audio, unexpected format.
+ARTIFACTS = [
+    # intra-word spacing: both ASRs write "chat GPT", the text says "ChatGPT"
+    ("Tôi dùng ChatGPT mỗi ngày.", "tôi dùng chat gpt mỗi ngày."),
+    # hybrid: acronym kept as letters WHILE numbers are spelled out
+    ("GDP quý III tăng 6,8%.", "gdp quý ba tăng sáu phẩy tám phần trăm."),
+    # whisper-large-v3 writes dates as digits, PhoWhisper spells them out
+    ("Hạn cuối là ngày 31/12/2025.", "Hạn cuối là ngày 31 tháng 12, 2025."),
+    ("Hạn cuối là ngày 31/12/2025.",
+     "hạn cuối là ngày ba mốt tháng mười hai hai ngàn không trăm hai mươi lăm."),
+    # "không trăm" year padding and bốn/tư are both standard
+    ("Từ năm 2020 đến năm 2024, số người dùng ví điện tử đã tăng gấp 3 lần.",
+     "từ năm hai nghìn không trăm hai mươi đến năm hai nghìn không trăm hai mươi tư "
+     "số người dùng ví điện tử đã tăng gấp ba lần."),
+    # năm/lăm for the digit 5
+    ("Chuyến bay VN-215 khởi hành lúc 6h.",
+     "chuyến bay vê en hai một lăm khởi hành lúc sáu giờ."),
+    # bare vs "mùng" day, nghìn/ngàn
+    ("Ngày 2/9/1945, Chủ tịch Hồ Chí Minh đọc Tuyên ngôn Độc lập tại Hà Nội.",
+     "ngày hai tháng chín một ngàn chín trăm bốn mươi lăm chủ tịch hồ chí minh "
+     "đọc tuyên ngôn độc lập tại hà nội."),
+    # acronym read with Vietnamese letter names instead of translated
+    ("Tỷ giá USD/VND đang ở mức cao.", "tỷ giá u ét đê trên vê en đê đang ở mức cao."),
+    # roman-numeral quarter spoken, adjacent number left as digits
+    ("Doanh thu quý I đạt 1.250 tỷ đồng, tăng 12,7% so với cùng kỳ năm trước.",
+     "doanh thu quý một đạt 1.250 tỷ đồng tăng mười hai phẩy bảy phần trăm "
+     "so với cùng kỳ năm trước."),
+    # every span left in written form == the source text
+    (_TP_HCM, _TP_HCM),
+]
+
+# (text, transcript, why) that MUST still cost WER — real mispronunciations.
+DEFECTS = [
+    (_TP_HCM,
+     "hà nội thành phố hồ chí minh và đà nẵng chiếm khoảng ba mươi lăm phần trăm gdp "
+     "cả nước nhưng chỉ có mười hai phần trăm diện tích cây xanh trên đầu người đạt "
+     "chuẩn theo báo cáo được công bố ngày mười tám tháng không bốn vừa qua.",
+     "voiced the leading zero of 18/04"),
+    ("Giá vàng hôm nay là 92.000.000 đồng một lượng.",
+     "giá vàng hôm nay là chín mươi hai nghìn nghìn đồng một lượng.",
+     "magnitude collapse: 'nghìn nghìn' instead of 'triệu'"),
+    ("Mã đơn hàng của bạn là AB-1234; vui lòng giữ lại để tra cứu khi cần.",
+     "mã đơn hàng của bạn là ab một hai ba bê bốn vui lòng giữ lại để trả cứu khi cần.",
+     "stray letter re-emitted before the final digit"),
+    ("WHO vừa đưa ra khuyến cáo mới.",
+     "bách thách hắc ô vừa đưa ra khuyến cáo mới.",
+     "acronym garbled"),
+    # The zero-padded numeral must NOT be an accepted half-spoken reading:
+    # "18 tháng 04" is what whisper-large-v3 writes for BOTH "tháng tư" and the
+    # defective "tháng không tư", so admitting it would excuse the defect above.
+    (_TP_HCM,
+     "hà nội thành phố hồ chí minh và đà nẵng chiếm khoảng 35% gdp cả nước nhưng chỉ "
+     "có 12% diện tích cây xanh trên đầu người đạt chuẩn theo báo cáo được công bố "
+     "ngày 18 tháng 04 vừa qua.",
+     "zero-padded month is ambiguous with the voiced-leading-zero defect"),
+    ("Tôi sống ở Hà Nội.", "tôi ở hà nội.", "dropped a word"),
+    ("Hôm nay trời đẹp quá.", "hôm nay trời xấu quá.", "wrong word"),
+    # Tone-only pairs are MISPRONUNCIATIONS, never spelling variants. Vietnamese
+    # tone is phonemic, so admitting one of these would blind the benchmark to
+    # the most common way a TTS model gets a Vietnamese word wrong.
+    ("Chương trình khuyến mãi áp dụng từ 0h ngày 20/11 đến 23h59 ngày 30/11, giảm tới "
+     "50% cho đơn hàng trên 1.000.000 đồng, và tặng thêm 10% cho khách thanh toán "
+     "bằng thẻ tín dụng.",
+     "chương trình khuyến mại áp dụng từ 0h ngày 20 tháng 11 đến 23h59 ngày 30 tháng 11 "
+     "giảm tới 50% cho đơn hàng trên 1.000.000 đồng và tặng thêm 10% cho khách thanh "
+     "toán bằng thẻ tín dụng.",
+     "tone error: khuyến mãi (ngã) -> khuyến mại (nặng)"),
+    ("Trưa nay mình order pizza về công ty ăn cho nhanh, khỏi phải xuống dưới sảnh "
+     "xếp hàng.",
+     "trưa nay mình order pizza về công ty ăn cho nhanh khỏi phải xuống dưới sành "
+     "xếp hàng.",
+     "tone error: sảnh (hỏi) -> sành (ngang)"),
+]
+
+
+@pytest.mark.parametrize("text,hyp", ARTIFACTS)
+def test_format_artifacts_score_zero(text, hyp):
+    wer, ref = best_wer(hyp, text)
+    assert wer == 0.0, f"format artifact charged {wer:.3f} WER; best reference was {ref!r}"
+
+
+@pytest.mark.parametrize("text,hyp,why", DEFECTS)
+def test_real_defects_still_cost(text, hyp, why):
+    wer, _ = best_wer(hyp, text)
+    assert wer > 0.0, f"real defect ({why}) scored 0.00 — reference set is too loose"
+
+
+def test_source_text_is_always_a_reference():
+    """Index 0 of every span is the verbatim written form, so the unmodified
+    text must round-trip to 0.00 for every benchmark item."""
+    import json
+    meta = Path(__file__).resolve().parent.parent / "metadata.jsonl"
+    if not meta.exists():
+        pytest.skip("benchmark not built locally")
+    for line in meta.read_text(encoding="utf-8").splitlines():
+        text = json.loads(line)["text"]
+        assert best_wer(text, text)[0] == 0.0, text
+
+
+def test_curated_normalization_is_admitted():
+    """text_normalized must be reachable from the span expansion, otherwise the
+    hand-curated spoken form and the generated variants disagree."""
+    import json
+    meta = Path(__file__).resolve().parent.parent / "metadata.jsonl"
+    if not meta.exists():
+        pytest.skip("benchmark not built locally")
+    bad = []
+    for line in meta.read_text(encoding="utf-8").splitlines():
+        row = json.loads(line)
+        if not row.get("has_normalization"):
+            continue
+        wer, _ = best_wer(row["text_normalized"], row["text"])
+        if wer > 0.0:
+            bad.append((round(wer, 3), row["text"][:60]))
+    assert not bad, f"curated normalization not covered by SPANS: {bad}"
+
+
+@pytest.mark.parametrize("n,expected", [
+    (5, "năm"), (15, "mười lăm"), (21, "hai mươi mốt"), (24, "hai mươi tư"),
+    (1945, "một nghìn chín trăm bốn mươi lăm"), (2025, "hai nghìn không trăm hai mươi lăm"),
+    (92_000_000, "chín mươi hai triệu"), (1_100_000, "một triệu một trăm nghìn"),
+    (5_310_000, "năm triệu ba trăm mười nghìn"), (1_250, "một nghìn hai trăm năm mươi"),
+    (350_000, "ba trăm năm mươi nghìn"), (105, "một trăm lẻ năm"),
+])
+def test_vi_int_produces_the_standard_reading(n, expected):
+    assert expected in vi_int(n), f"{n} -> {vi_int(n)}"
+
+
+def test_variant_count_stays_bounded():
+    """Guards against a span edit blowing the cross-product up."""
+    assert n_variants(_TP_HCM) < 50_000
+    assert len(expand("Tôi dùng ChatGPT mỗi ngày.")) == 7