Datasets:

zeroweight-ai
/

ZeroBench-TTS

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.

From ZeroWeight AI. Companion to ZeroTTS, our open Vietnamese zero-shot TTS model — see current 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%

_{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.}

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.

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

{"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.)

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`

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	5.26%	2.96%	1.03%	0.936	2.91	0.029 s
XTTS-v2-vietnamse	18.83%	17.82%	16.42%	0.940	2.43	0.532 s
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.

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. 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, capleaf/viVoice and thivux/phoaudiobook. cross_lingual reference audio is redistributed from 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

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