README.md

---
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:
  - split: test
    path: data/challenging.parquet
- config_name: code_switch
  data_files:
  - split: test
    path: data/code_switch.parquet
- config_name: cross_lingual
  data_files:
  - split: test
    path: data/cross_lingual.parquet
- config_name: vietnamese
  data_files:
  - split: test
    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.

---

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

Four systems, 137/137 items each, scored by `zerobench_eval`:

| Model | WER (raw text) | WER (normalized) | SSIM | UTMOS | Excess silence |
|---|---|---|---|---|---|
| **[ZeroTTS](https://huggingface.co/zeroweight-ai/ZeroTTS)** | **1.03 %** | **0.56 %** | 0.936 | **2.91** | **0.029 s** |
| [OmniVoice](https://huggingface.co/k2-fsa/OmniVoice) | 4.13 % | 2.12 % | **0.950** | 2.76 | 0.340 s |
| [XTTS-v2-vietnamse](https://huggingface.co/thivux/XTTS-v2-vietnamse) | 16.42 % | 7.27 % | 0.940 | 2.43 | 0.532 s |
| [viXTTS](https://huggingface.co/capleaf/viXTTS) | 18.40 % | 8.61 % | 0.935 | 2.35 | 0.233 s |

**raw text** = the model reads `31/12/2025` and `ChatGPT` as written, the
benchmark task. **normalized** = every model is handed the spoken-out form
instead, simulating a perfect Vietnamese text frontend. Scoring references are
identical in both, so the columns are comparable.

Per subset, raw text:

| Subset | ZeroTTS | OmniVoice | XTTS-v2-vietnamse | viXTTS |
|---|---|---|---|---|
| `vietnamese` | **0.16 %** | 0.50 % | 7.92 % | 9.56 % |
| `code_switch` | 0.97 % | **0.46 %** | 10.94 % | 9.25 % |
| `cross_lingual` | **1.42 %** | 17.71 % | 21.37 % | 27.27 % |
| `challenging` | **1.75 %** | 4.46 % | 27.86 % | 31.85 % |

Worth reading the subsets, not just the total. OmniVoice leads on
`code_switch` and on speaker similarity, and its overall figure is dominated by
`cross_lingual` — foreign voice prompt, Vietnamese text — where it degrades by
reference language (German 0.00 %, Korean 0.13 %, Japanese 0.41 %). The two
XTTS finetunes gain the most from normalization because their tokenizers have
no Vietnamese number expansion at all.

OmniVoice was given its optional `language="vi"` hint, which its model card
recommends; without it, it scores 5.15 % / 3.87 % instead.

Full per-subset tables, per-item audits and reproduction commands live in the
[ZeroTTS repository](https://github.com/zeroweight-ai/ZeroTTS/blob/main/docs/BENCHMARKS.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
[AILAB-VNUHCM/vivos](https://huggingface.co/datasets/AILAB-VNUHCM/vivos),
[capleaf/viVoice](https://huggingface.co/datasets/capleaf/viVoice) and
[thivux/phoaudiobook](https://huggingface.co/datasets/thivux/phoaudiobook).
`cross_lingual` reference audio is redistributed from
[amphion/Emilia-Dataset](https://huggingface.co/datasets/amphion/Emilia-Dataset).
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>