Datasets:

zeroweight-ai
/

ZeroBench-TTS

@@ -2,18 +2,27 @@
 license: cc-by-nc-4.0
 task_categories:
 - text-to-speech
 language:
 - vi
-pretty_name: ZeroBench-TTS
 size_categories:
 - n<1K
 tags:
 - tts
 - zero-shot
 - voice-cloning
 - code-switching
 - cross-lingual
-- vietnamese
 configs:
 - config_name: challenging
   data_files:
@@ -33,123 +42,300 @@ configs:
     path: data/vietnamese.parquet
 ---
-# ZeroBench-TTS
-From [ZeroWeight AI](https://huggingface.co/zeroweight-ai) — the benchmark
-counterpart to ZeroTTS. A small, fully specified benchmark
-for **zero-shot Vietnamese TTS / voice cloning**: 39 held-out
-Vietnamese reference voices × 3 subsets
-(`vietnamese`, `code_switch`, `challenging`), plus 20 non-Vietnamese
-reference voices × 1 `cross_lingual` subset = **137 test items**. Every
-item pairs one reference clip (with its ground-truth transcript) with one
-**Vietnamese** target sentence to synthesize — `cross_lingual` tests whether a
-system can speak Vietnamese given a foreign-language voice prompt, which is
-the direction that matters for a Vietnamese TTS system (not the reverse).
-It is deliberately small enough to run every checkpoint on, and every item is
-scored the same way — WER, SSIM, UTMOS — so numbers are comparable across
-systems.
-## Subsets
-| config | n | language of `text` | what it stresses |
-|---|---|---|---|
-| `challenging` | 39 | `vi` | repeated words, acronyms (ChatGPT, ASEAN, WHO), times, dates, percentages, dense punctuation |
-| `code_switch` | 39 | `vi` | natural Vietnamese with embedded English (names, brands, workplace loanwords) |
-| `cross_lingual` | 20 | `vi` | non-Vietnamese reference voice (Emilia: zh/de/fr/ja/ko) reading Vietnamese text — many languages -> Vietnamese zero-shot cloning |
-| `vietnamese` | 39 | `vi` | monolingual Vietnamese — the baseline case |
-Within every subset the target sentences are split evenly into **short /
-medium / long** thirds (`length_bucket`), so length is covered across the board
-rather than confounded with subset. `cross_lingual`'s target texts are drawn
-from the other three subsets' pools (mixed, not a pool of its own) — see
-`text_origin_subset`.
-## Fields
 | field | type | description |
 |---|---|---|
 | `id` | string | `{subset}/{voice_id}` |
-| `subset` | string | one of the configs above |
 | `text` | string | **the text to synthesize**, verbatim — always Vietnamese |
-| `text_normalized` | string | spoken-out form of `text` (equal to `text` when nothing needs expanding) |
-| `has_normalization` | bool | whether `text_normalized` actually differs |
-| `lang` | string | target language of `text` (always `vi`) |
-| `text_origin_subset` | string | which pool `text` came from (`vietnamese`/`code_switch`/`challenging`) — trivially equal to `subset` except for `cross_lingual` rows |
 | `length_bucket` | string | `short` / `medium` / `long` |
 | `n_chars`, `n_words` | int | length of `text` |
-| `ref_audio` | audio | **reference voice** to clone, mono 24000 Hz |
-| `ref_text` | string | ground-truth transcript of `ref_audio`, in `voice_lang` — for systems that need an in-context audio+text prompt. Speaker-encoder models can ignore it. |
-| `ref_duration` | float | seconds of `ref_audio` |
-| `voice_id` | string | stable voice identifier; the same voice appears once per subset |
 | `voice_source` | string | `vivos` / `viVoice` / `phoaudiobook` / `emilia` |
 | `source_speaker`, `source_utterance` | string | provenance in the source corpus |
-| `voice_lang` | string | language of the reference speaker (`vi` for the first three subsets; `zh`/`de`/`fr`/`ja`/`ko` for `cross_lingual`) |
-| `cross_lingual` | bool | `lang != voice_lang` — always `False` except for the `cross_lingual` subset |
-## Usage
 ```python
 import io, soundfile as sf
 from datasets import load_dataset, Audio
 ds = load_dataset("zeroweight-ai/ZeroBench-TTS", "challenging", split="test")
-# Reading the raw wav bytes works on every `datasets` version; asking for a
-# decoded array needs a codec backend (`pip install torchcodec`) on datasets>=5.
-ds = ds.cast_column("ref_audio", Audio(decode=False))
 row = ds[0]
 wav, sr = sf.read(io.BytesIO(row["ref_audio"]["bytes"]))
-audio = my_tts(text=row["text"], reference=(wav, sr))   # clone and speak
 ```
 ## Metrics
-The reference implementation is `scripts/eval_tts.py` in the ZeroTTS repo.
-* **WER** — [`vinai/PhoWhisper-large`](https://huggingface.co/vinai/PhoWhisper-large)
-  (a Vietnamese-specialized Whisper finetune — NOT raw `openai/whisper-large-v3`)
-  transcribes the generated audio; WER is computed against the target text
-  after lowercasing, punctuation stripping and whitespace collapsing.
-  `scripts/eval_tts.py --whisper_model` can swap in any other Whisper-family
-  checkpoint if you want a different ASR.
-* **SSIM** — cosine similarity between `microsoft/wavlm-base-plus-sv` x-vectors
-  of the generated clip and `ref_audio`.
-* **UTMOS** — UTMOSv2 predicted naturalness MOS of the generated clip.
-* **Excess silence** — seconds of unwanted lead-in/tail/mid-utterance pause,
-  specifically to catch weird long silences (stalls, dead air, a stuck
-  decoder) that WER/SSIM/UTMOS don't penalize on their own — none of the three
-  metrics above notice a generation that's otherwise correct but padded with
-  several extra seconds of dead air.
-**Scoring the `challenging` subset:** take
-`min(WER(hyp, text), WER(hyp, text_normalized))`. Whisper may transcribe
-`3,2%` either as digits or as *ba phẩy hai phần trăm*, and that choice belongs
-to the ASR, not to the TTS system under test — scoring against a single form
-would measure Whisper's formatting policy instead of intelligibility.
 ## Voice selection
 * **VIVOS** — every speaker of the VIVOS *test* split (`VIVOSDEV01`–`VIVOSDEV19`),
   one clip each, chosen closest to 6 s.
-* **viVoice / phoaudiobook** — 10 speakers each. These corpora carry
-  no usable speaker labels, so clips were selected geometrically: **k-means over
-  WeSpeaker x-vectors, keeping each cluster's medoid**. That yields mutually
-  distinct voices spread over the corpus's voice space, while medoids stay
-  typical of their region rather than being recording outliers.
-  `source_speaker` is therefore a synthetic cluster id, not an upstream label.
-All Vietnamese reference clips are 4–12 s, mono, 24000 Hz.
-* **Emilia (`cross_lingual` only)** — 4 speakers each from
-  5 non-Vietnamese languages (de, fr, ja, ko, zh), sampled from the
-  gated [amphion/Emilia-Dataset](https://huggingface.co/datasets/amphion/Emilia-Dataset).
   Candidates are filtered by duration, DNSMOS quality, and a per-language text
   sanity check (script range for zh/ja/ko, function-word check for de/fr) —
   Emilia's own per-clip language tag is not fully reliable (English text was
   found mislabeled `ko` in the first Korean shard during a spot check).
 ## Provenance & license
 Vietnamese reference audio is redistributed from
@@ -161,3 +347,28 @@ Vietnamese reference audio is redistributed from
 Please honour each upstream corpus's own license and cite them alongside this
 benchmark. The target sentences are original, written for this benchmark.
 Released for research and evaluation use.

 license: cc-by-nc-4.0
 task_categories:
 - text-to-speech
+- automatic-speech-recognition
 language:
 - vi
+pretty_name: 'ZeroBench-TTS: Vietnamese Zero-Shot TTS & Voice Cloning Benchmark'
 size_categories:
 - n<1K
 tags:
 - tts
+- text-to-speech
+- vietnamese
+- vietnamese-tts
+- tieng-viet
 - zero-shot
 - voice-cloning
+- speech-synthesis
 - code-switching
 - cross-lingual
+- benchmark
+- evaluation
+- wer
+- speaker-similarity
 configs:
 - config_name: challenging
   data_files:
     path: data/vietnamese.parquet
 ---
+# ZeroBench-TTS — a Vietnamese zero-shot TTS & voice-cloning benchmark
+**Bộ benchmark đánh giá text-to-speech tiếng Việt (zero-shot voice cloning).**
+137 test items · 59 held-out reference voices · 4 subsets · one command to score
+your model · [official scorer included](#scoring-your-model-in-3-commands).
+From [ZeroWeight AI](https://huggingface.co/zeroweight-ai). Companion to
+**[ZeroTTS](https://huggingface.co/zeroweight-ai/ZeroTTS)**, our open Vietnamese
+zero-shot TTS model — see [current results](#results) below.
+Vietnamese TTS has had no shared evaluation: papers and model cards report WER
+against different ASRs, different reference text, and different (usually
+unpublished) test sets, so no two numbers can be compared. ZeroBench-TTS is an
+attempt at a fixed target — public items, a published scorer, and a WER
+definition that measures the **synthesizer** rather than the ASR's spelling
+habits.
+---
+## Why another benchmark
+Most Vietnamese TTS evaluations quietly measure the wrong thing. Three failure
+modes we hit ourselves, and what this benchmark does about them:
+**1. A single ASR cannot judge Vietnamese TTS.**
+`vinai/PhoWhisper-large` handles Vietnamese phonology well but cannot emit Latin
+script — it transcribes *Slack* as "sờ lếch" and *backup* as "bắt cấp", charging
+WER to audio that is perfectly intelligible. `openai/whisper-large-v3` writes the
+Latin spelling but is weaker on Vietnamese tone. Their failure modes are close to
+disjoint.
+→ **ZeroBench runs both and takes the minimum.** A clip is only charged when
+*neither* ASR can recover the target.
+**2. One reference sentence cannot cover correct readings.**
+`31/12/2025` is correctly read as "ba mươi mốt tháng mười hai năm hai nghìn
+không trăm hai mươi lăm" *or* "ba mốt tháng mười hai hai ngàn hai mươi lăm", and
+correctly transcribed as `31 tháng 12, 2025`. With *k* independent formatting
+decisions in a sentence there are 2^k correct transcripts; an ASR routinely
+produces a hybrid — acronym spelled out, numbers left as digits — that matches
+neither of two hand-written references.
+→ **References are expanded per surface span** and WER is the minimum over the
+whole set. `ChatGPT`/"chat GPT", `nghìn`/`ngàn`, `thứ Sáu`/`thứ 6`,
+`bốn`/`tư` are all free.
+**3. A permissive reference set is just as wrong.**
+Widening references until everything scores 0 measures nothing.
+→ **Tone-only variants are never admitted.** Vietnamese tone is phonemic, so
+`khuyến mãi` → `khuyến mại` and `sảnh` → `sành` stay errors — they are the most
+common way a TTS model actually gets a Vietnamese word wrong. Neither are
+wrong-but-plausible readings: a voiced leading zero (`18/04` → "tháng **không**
+tư") or a collapsed magnitude (`92.000.000` → "chín mươi hai **nghìn nghìn**")
+costs WER, as it should.
+Both directions are enforced by a test suite, not by good intentions:
+`zerobench_eval/test_references.py` asserts that **format artifacts score 0.00**
+*and* that **real defects still cost**. Any change to the reference policy that
+breaks either direction fails CI.
+### Does it actually work?
+The `vietnamese` subset is the control: no digits, acronyms or English, so there
+is nothing for the reference expansion to do. Measured across three systems, the
+three reference policies are **identical to four decimal places** on that
+subset — while `challenging` moves a lot. The expansion is targeted, not a
+blanket loosening.
+| Reference policy | `vietnamese` | `challenging` |
+|---|---|---|
+| `strict` — written text only | 0.16% | 11.75% |
+| `norm` — + curated spoken form | 0.16% | 5.62% |
+| `robust` — + all acceptable readings | **0.16%** | **1.75%** |
+<sub>ZeroTTS, same wavs throughout. All three policies are reported by the
+scorer on every run, so you can always see how much of a number is scoring
+policy.</sub>
+---
+## Scoring your model in 3 commands
+The scorer **never loads a TTS model**. It reads finished wavs and reports
+metrics — bring your own synthesis, in any framework, any language.
+```bash
+# 0. get the benchmark + scorer
+huggingface-cli download zeroweight-ai/ZeroBench-TTS --repo-type dataset \
+    --local-dir ZeroBench-TTS
+cd ZeroBench-TTS && pip install -r zerobench_eval/requirements.txt
+# 1. what to synthesize (137 rows: text, reference clip, output path)
+python -m zerobench_eval manifest --out manifest.jsonl
+# 2. ... your own synthesis, writing each clip to <wav_dir>/<subset>/<voice_id>.wav ...
+# 3. score
+python -m zerobench_eval score --wav_dir my_wavs/ --name MyModel
+```
+Output: a printed table plus `per_sample.csv` (every metric, **both ASR
+transcripts**, and which reference matched — so any number is auditable),
+`summary.json`, and `report.txt`.
+Each `manifest.jsonl` row:
+```json
+{"id": "challenging/vivos-VIVOSDEV08", "subset": "challenging",
+ "text": "Tôi dùng ChatGPT mỗi ngày.", "lang": "vi",
+ "ref_audio": "/abs/path/audio/vivos-VIVOSDEV08.wav",
+ "ref_text": "...", "output_wav": "challenging/vivos-VIVOSDEV08.wav"}
+```
+Synthesize `text` using `ref_audio` as the voice prompt. `ref_text` is there for
+systems that need an audio+text in-context prompt; speaker-encoder models can
+ignore it. **Never feed `text_normalized` to the model** for a headline
+number — reading raw orthography is the task. (It is available as a deliberate
+ablation; see [Reproducibility](#reproducibility--fair-use).)
+Useful flags: `--skip_utmos` (UTMOSv2 is an optional dependency),
+`--subsets challenging`, `--allow_missing` (partial submission, flagged in the
+summary), `--device cpu`.
+Changed the reference policy and want to re-score without re-running the ASRs?
+`python -m zerobench_eval rescore <run_dir>` — seconds, no GPU.
+---
+## What's in it
+| config | n | what it stresses |
+|---|---|---|
+| `vietnamese` | 39 | monolingual Vietnamese — the baseline case |
+| `code_switch` | 39 | natural Vietnamese with embedded English (brands, workplace loanwords) |
+| `challenging` | 39 | acronyms (ChatGPT, ASEAN, WHO), dates, times, percentages, currency, repeated words, dense punctuation |
+| `cross_lingual` | 20 | **non-Vietnamese reference voice** (zh/de/fr/ja/ko) reading Vietnamese text |
+The target sentence is **Vietnamese in every subset**. `cross_lingual` varies the
+*reference voice*, not the language of the text — it asks whether a foreign
+speaker's timbre can carry Vietnamese, which is the direction that matters for a
+Vietnamese TTS system.
+Within every subset the sentences split evenly into **short / medium / long**
+thirds (`length_bucket`), so length is covered rather than confounded with
+subset. `cross_lingual` target texts are drawn from the other three pools (see
+`text_origin_subset`).
+It is deliberately small enough to run on every checkpoint.
+### Fields
 | field | type | description |
 |---|---|---|
 | `id` | string | `{subset}/{voice_id}` |
 | `text` | string | **the text to synthesize**, verbatim — always Vietnamese |
+| `text_normalized` | string | spoken-out form, a **scoring reference only** (equals `text` when nothing needs expanding) |
+| `has_normalization` | bool | whether `text_normalized` differs |
+| `lang` | string | language of `text` (always `vi`) |
 | `length_bucket` | string | `short` / `medium` / `long` |
 | `n_chars`, `n_words` | int | length of `text` |
+| `ref_audio` | audio | **reference voice to clone**, mono 24 kHz, 4–12 s |
+| `ref_text` | string | ground-truth transcript of `ref_audio` |
+| `ref_duration` | float | seconds |
+| `voice_id` | string | stable voice id; the same voice appears once per subset |
 | `voice_source` | string | `vivos` / `viVoice` / `phoaudiobook` / `emilia` |
+| `voice_lang` | string | `vi`, or `zh`/`de`/`fr`/`ja`/`ko` for `cross_lingual` |
+| `cross_lingual` | bool | `lang != voice_lang` |
+| `text_origin_subset` | string | which pool `text` came from |
 | `source_speaker`, `source_utterance` | string | provenance in the source corpus |
+### Loading with `datasets`
 ```python
 import io, soundfile as sf
 from datasets import load_dataset, Audio
 ds = load_dataset("zeroweight-ai/ZeroBench-TTS", "challenging", split="test")
+ds = ds.cast_column("ref_audio", Audio(decode=False))   # raw bytes: works on every version
 row = ds[0]
 wav, sr = sf.read(io.BytesIO(row["ref_audio"]["bytes"]))
+audio = my_tts(text=row["text"], reference=(wav, sr))
 ```
+---
 ## Metrics
+| metric | definition | direction |
+|---|---|---|
+| **WER** | min over {`whisper-large-v3`, `PhoWhisper-large`} × all acceptable references | lower better |
+| **SSIM** | cosine similarity of `microsoft/wavlm-base-plus-sv` x-vectors, generated vs `ref_audio` | higher better |
+| **UTMOS** | UTMOSv2 predicted naturalness MOS (seeded — see below) | higher better |
+| **Excess silence** | seconds of unwanted lead-in / tail / mid-utterance pause | lower better |
+Three WER numbers are reported on every run:
+| policy | references | use |
+|---|---|---|
+| `strict` | the written `text`, verbatim | what a naive pipeline measures |
+| `norm` | `text` + curated `text_normalized` | the usual two-reference scheme |
+| `robust` | + every acceptable reading, expanded per span | **the headline number** |
+Reporting all three is the point: the gap between them tells you how much of a
+WER figure is scoring policy rather than synthesis.
+**Excess silence** exists because nothing else catches 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. A stalled or padded
+decoder is invisible to WER/SSIM/UTMOS.
+**UTMOS is seeded.** UTMOSv2 ensembles over randomly sampled crops, so unseeded
+it returns 3.05 / 3.03 / 2.96 for the *same clip*. The scorer resets the RNG
+before every clip, making UTMOS a deterministic function of the audio — without
+that, the column is not reproducible between runs.
+---
+## Reproducibility & fair use
+* **Report `robust` WER** as the headline, and don't change `--asr` — the ASR
+  pair is part of the benchmark definition.
+* **Synthesize from `text`**, not `text_normalized`. Feeding the spoken-out form
+  simulates a perfect Vietnamese text-normalization frontend; it is a legitimate
+  and interesting *ablation* (it isolates grapheme-to-phoneme errors from
+  acoustic ones), but it is not the benchmark task and must be labelled if
+  reported.
+* **Report all 137 items.** Partial runs are marked `complete: false` in
+  `summary.json`.
+* `per_sample.csv` keeps **both ASR transcripts** and the matched reference for
+  every item, so any surprising number can be audited rather than trusted.
+---
+## Results
+ZeroTTS vs. the two public Vietnamese XTTS-v2 finetunes. 137/137 items, scored
+by `zerobench_eval` at every policy:
+| Model | WER strict | WER norm | **WER robust** | SSIM | UTMOS | Excess silence |
+|---|---|---|---|---|---|---|
+| **[ZeroTTS](https://huggingface.co/zeroweight-ai/ZeroTTS)** | **5.26%** | **2.96%** | **1.03%** | 0.936 | **2.91** | **0.029 s** |
+| [XTTS-v2-vietnamse](https://huggingface.co/thivux/XTTS-v2-vietnamse) | 18.83% | 17.82% | 16.42% | **0.940** | 2.43 | 0.532 s |
+| [viXTTS](https://huggingface.co/capleaf/viXTTS) | 20.22% | 19.47% | 18.40% | 0.935 | 2.35 | 0.233 s |
+The two baselines barely move between policies (18.83% → 16.42%) while ZeroTTS
+drops 5.1×. That asymmetry is informative: the baselines' errors are hallucinated
+and garbled speech, which no reference policy can excuse, whereas most of
+ZeroTTS's residual was formatting.
+**With a perfect text-normalization frontend.** Feeding every model the
+spoken-out `text_normalized` instead of raw orthography — an ablation, not a
+benchmark score — separates grapheme-to-spoken-form errors from acoustic ones:
+| Model | raw text | pre-normalized text |
+|---|:-:|:-:|
+| **ZeroTTS** | **1.03%** | **0.56%** |
+| XTTS-v2-vietnamse | 16.42% | 7.27% |
+| viXTTS | 18.40% | 8.61% |
+The baselines gain the most (their tokenizers have no Vietnamese number
+expansion) and still lose by 13–15×. Useful if you are deciding whether to
+invest in a text frontend or a better acoustic model.
+Full per-subset tables, per-item audits and reproduction commands live in the
+[ZeroTTS repository](https://github.com/zeroweight-ai/ZeroTTS/blob/main/evaluation/RESULTS.md).
+**Submitting a result:** open a discussion on this dataset with your
+`summary.json` and a note on how the wavs were produced.
+---
 ## Voice selection
 * **VIVOS** — every speaker of the VIVOS *test* split (`VIVOSDEV01`–`VIVOSDEV19`),
   one clip each, chosen closest to 6 s.
+* **viVoice / phoaudiobook** — 10 speakers each. These corpora carry no usable
+  speaker labels, so clips were selected geometrically: **k-means over WeSpeaker
+  x-vectors, keeping each cluster's medoid**. That yields mutually distinct
+  voices spread across the corpus's voice space, while medoids stay typical of
+  their region rather than being recording outliers. `source_speaker` is
+  therefore a synthetic cluster id, not an upstream label.
+* **Emilia (`cross_lingual` only)** — 4 speakers each from 5 non-Vietnamese
+  languages (de, fr, ja, ko, zh), sampled from the gated
+  [amphion/Emilia-Dataset](https://huggingface.co/datasets/amphion/Emilia-Dataset).
   Candidates are filtered by duration, DNSMOS quality, and a per-language text
   sanity check (script range for zh/ja/ko, function-word check for de/fr) —
   Emilia's own per-clip language tag is not fully reliable (English text was
   found mislabeled `ko` in the first Korean shard during a spot check).
+All Vietnamese reference clips are 4–12 s, mono, 24 kHz. Every voice is
+**held out**: none appears in ZeroTTS's training data.
+---
 ## Provenance & license
 Vietnamese reference audio is redistributed from
 Please honour each upstream corpus's own license and cite them alongside this
 benchmark. The target sentences are original, written for this benchmark.
 Released for research and evaluation use.
+## Citation
+```bibtex
+@misc{zerobench_tts_2026,
+  title  = {ZeroBench-TTS: A Vietnamese Zero-Shot Text-to-Speech and
+            Voice Cloning Benchmark},
+  author = {ZeroWeight AI},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/zeroweight-ai/ZeroBench-TTS}
+}
+```
+## See also
+* **[ZeroTTS](https://huggingface.co/zeroweight-ai/ZeroTTS)** — open Vietnamese
+  zero-shot TTS model (the reference system for this benchmark)
+* **[ZeroTTS on GitHub](https://github.com/zeroweight-ai/ZeroTTS)** — training,
+  inference and the full evaluation write-up
+<sub>Keywords: Vietnamese TTS benchmark · vietnamese text to speech evaluation ·
+zero-shot voice cloning Vietnamese · đánh giá TTS tiếng Việt · benchmark giọng
+nói tiếng Việt · Vietnamese speech synthesis WER · code-switching Vietnamese
+English TTS · cross-lingual voice cloning · PhoWhisper WER evaluation ·
+tổng hợp tiếng nói tiếng Việt</sub>

zerobench_eval/README.md ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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 ADDED Viewed

	@@ -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