--- license: apache-2.0 language: - th task_categories: - automatic-speech-recognition tags: - forced-alignment - thai - text-to-speech - evaluation - prosody size_categories: - 1K 🚧 **Development in progress.** This benchmark is under active development. The > aligner set, the metrics and the asset bundle may all change without notice, and > every number below should be read as **provisional**. If you need reproducibility, > pin a commit SHA rather than tracking `main`. **Which forced aligner should score Thai TTS pauses?** A self-contained benchmark: one Python file (`aligner_bench.py`) plus 1,572 clips of Thai TTS audio carrying **frozen timing ground truth**. No Thai NLP, no TTS model, no other code needed — just `numpy soundfile torch torchaudio transformers`. The ground truth is unusual and is what makes this dataset useful: the audio was rendered by a TTS model whose duration predictor emitted an explicit frame count per token (`pred_dur`, 25 ms/frame, `sum(pred_dur) * 600 == len(audio)` exactly at 24 kHz). The token boundaries in the audio therefore **are** the `pred_dur` boundaries — no human annotation, no second aligner, no circularity. Any forced aligner can be measured against them directly. Two questions are answered per aligner: 1. **Delay / timing accuracy** — onset error percentiles, signed **bias**, **jitter** (spread with bias removed), duration error, span coverage. 2. **Downstream pause accuracy** — silences are detected, attributed to a text juncture through the aligner's char timings, and classified `ok` / `bad_juncture` / `intra_word` / `unaligned`. Scoring the same clips through `pred_dur` gives the reference, so each aligner also reports **agreement with ground truth**. ## Quick start ```bash git clone https://huggingface.co/datasets/kunato/thai-aligner-bench-dev cd thai-aligner-bench-dev pip install numpy soundfile torch torchaudio transformers python aligner_bench.py run --bundle . --aligner ctc --out out/ctc python aligner_bench.py run --bundle . --aligner mms --out out/mms python aligner_bench.py report out/ctc out/mms ``` `run` = `align` (GPU, writes `spans.jsonl`) + `score` (CPU, writes `metrics.json`). Run them separately to re-score without re-aligning. Pre-computed `spans.jsonl` for all four arms is in `results/`, so **you can reproduce every number below on CPU alone**: ```bash cp -r results/ctc out/ctc && python aligner_bench.py score --bundle . --out out/ctc ``` Useful flags: `--limit N` / `--speakers spk00,spk03` (fast subsets), `--word-seg {tltk,newmm}` (which frozen word segmentation attributes the pause), `--quantize-ms 38.5` (round predicted onsets onto a coarser grid — tests whether an aligner's deficit is really just its frame rate), `--device`, `--batch-size`. ## Aligners included | arm | model | note | |---|---|---| | `ctc` | [`airesearch/wav2vec2-large-xlsr-53-th`](https://huggingface.co/airesearch/wav2vec2-large-xlsr-53-th) | Thai char CTC, 50 fps — the default | | `mms` | `torchaudio.pipelines.MMS_FA` | generic multilingual phone aligner; IPA mapped onto its roman labels | | `qwen` | [`Qwen/Qwen3-ASR-1.7B-hf`](https://huggingface.co/Qwen/Qwen3-ASR-1.7B-hf) + a Thai char timestamp head | `--ctc-head-repo`; head architecture is **inferred from the weights**, so a new head loads with no code change | The `qwen` arm needs `transformers>=5.13`. Side-load rather than upgrade if pinned: ```bash pip install --no-deps --target=/tmp/tf514 transformers==5.14.1 PYTHONPATH=/tmp/tf514 python aligner_bench.py run --bundle . --aligner qwen \ --ctc-head-repo --out out/qwen ``` ## Add your own aligner Write one function returning `[(char_idx, t0_ms, t1_ms)]` over `item["text"]`, time-monotonic, and register it: ```python def mine_bundle(device, **_): return SimpleNamespace(..., tag="mine:v1", batched=False) def mine_char_spans(wav, sr, item, b): ... # item["_align"].phonemes / .units are there if you align on phones return spans ALIGNERS["mine"] = (mine_bundle, mine_char_spans, None) ``` Everything downstream — silence detection, attribution, classification, aggregation, agreement — is shared, so arms stay comparable. > **If you batch, pass an explicit length mask.** This is not a style note. > `wav2vec2-large-xlsr-53-th` ships `return_attention_mask: false` while being a > `feat_extract_norm='layer'` model trained *with* masking. Running it unmasked > scales each clip's whole char timeline by `len/batch_max` — drift that reached > **−1670 ms** by the end of a 7.5 s clip, silently destroying every downstream > number until it was found. The Qwen arm has the identical trap (features padded > to 30 s). Both shipped paths build the mask from raw input lengths. ## Results 1,572 clips (12 synthetic speakers × 131 long-sentence texts), `--word-seg tltk`, default thresholds, one RTX 3090. Produced by this exact file; raw artifacts in `results/`. **Timing vs `pred_dur` ground truth (ms; lower is better):** | model | fps | onset p50 | p90 | >100 ms | bias | jitter | dur p50 | coverage | s/clip | |---|---|---|---|---|---|---|---|---|---| | **`ctc`** xlsr-53-th | 50 | **17.26** | **40.74** | **0.2%** | −15.91 | 11.96 | 15.21 | 0.401 | 0.209 | | `mms` MMS_FA | 50 | 28.43 | 46.91 | 0.4% | −28.39 | **9.38** | **14.52** | 0.709 | **0.154** | | `qwen` + ctc-head-v2 | 26 | 36.54 | 82.20 | 4.4% | −33.62 | 24.09 | 28.44 | 0.669 | 0.331 | | `qwen` + ctc-head-cv-only | 26 | 29.97 | 72.52 | 2.9% | −26.59 | 22.34 | 27.72 | 0.731 | 0.332 | **Downstream pause metrics + agreement with ground truth:** | model | /clip | precision | intra_word | PPER | bad/min | r(count) | verdict | per-spk r | bad-junc | Jaccard | |---|---|---|---|---|---|---|---|---|---|---| | *`pred_dur` (truth)* | 2.291 | 0.8681 | 0.0878 | 0.2226 | 1.911 | — | — | — | — | — | | **`ctc`** | 2.268 | **0.8634** | **0.1018** | 0.2290 | 1.959 | 0.9603 | **95.2%** | **0.9614** | 248/319 | **0.6685** | | `mms` | 2.414 | 0.7718 | 0.2265 | 0.3321 | 3.484 | 0.9411 | 85.4% | 0.7525 | **249**/319 | 0.6587 | | `qwen` + v2 | 2.240 | 0.8606 | 0.1031 | **0.2284** | 1.975 | 0.9597 | 94.3% | 0.9353 | 241/319 | 0.6359 | | `qwen` + cv-only | 2.233 | 0.8390 | 0.1387 | 0.2665 | 2.273 | **0.9611** | 90.5% | 0.9388 | 240/319 | 0.6107 | **`ctc` wins every downstream column.** Three results worth more than the ranking: * **Timing accuracy does not imply attribution accuracy.** MMS has the *tightest jitter* of any arm (9.38 ms vs `ctc`'s 11.96) and the best duration error — once its larger constant bias is removed it is the sharpest aligner here. It still loses 0.09 precision, drops per-speaker r to 0.75, and more than doubles `intra_word`. It aligns *romanized* Thai through a lossy map (length and tone dropped; ɛ/e, ɔ/o, ɯ/ɤ/u collapse), so it puts precisely-timed boundaries in the wrong places. Character identity beats milliseconds. * **Below ~40 ms median onset error, timing stops mattering for this metric.** `qwen`+v2 has 2× `ctc`'s onset error and 2× its duration error, yet lands within 0.003 precision and 0.026 per-speaker r. Pauses are ≥80 ms, so a 36 ms error rarely flips which juncture a silence belongs to. Do not tune an aligner for this metric past ~40 ms — spend the effort on character/tokenizer fidelity instead. * **The qwen heads' deficit is not their frame rate.** Rounding `ctc`'s own onsets onto qwen's 38.5 ms grid (`--quantize-ms 38.5`) moves it 17.26 → 19.0 ms p50 and 11.96 → 14.5 ms jitter. The grid costs ~1.7 ms against a ~19 ms gap. A bigger ConvTranspose upsample would not help either: it makes a finer output *grid* over the encoder's native 13 fps / 77 ms information floor. Beating `ctc` needs a finer-resolution encoder, not a bigger head. Between the two qwen heads, `v2` (GigaSpeech2-th) beats `cv-only` (Common Voice) downstream — 0.861 vs 0.839 precision, 94.3% vs 90.5% verdict agreement — despite cv-only's better raw onsets (29.97 vs 36.54). Same architecture, so this is a training-data effect, and it is the third instance here of better timing not surviving into better attribution. ### Reading the numbers * **Read `precision` next to `/clip`.** The masks are precision-side only — they mark where a break is *allowed*, never where one is *required* — so an aligner (or a TTS system) that finds no pauses scores 1.000. Precision alone is not a ranking. * **`per-spk r` is the real instrument test.** It is whether the aligner ranks the 12 voices the way ground truth does. An aligner can hold aggregate precision and still be useless for comparing systems; this column catches it. * **`bias` is correctable, `jitter` is not.** Aligners report the *left edge* of a frame, so each carries a systematic half-frame early bias that a constant shift removes. Jitter is what decides usability. * **Never compare CTC span *widths* across aligners.** They allocate blank frames differently — `coverage` runs from 0.40 to 0.73 here. Measuring duration as a span's own width reverses the ranking. `dur p50` therefore uses `onset[i+1] − onset[i]`, the convention `pred_dur` itself uses. ## Dataset structure ``` items.jsonl one JSON per clip (1,572) audio/.flac 24 kHz mono, lossless aligner_bench.py the benchmark (single file) results// metrics.json, align_meta.json, spans.jsonl ``` | field | meaning | |---|---| | `id` / `speaker` / `text_id` | clip key; `text_id` groups the same text across the 12 voices | | `text` | the **normalized** text actually spoken — every char index, gold mark and word span below is in this coordinate space | | `gold` | pause mask; `\|` marks a juncture where a break is allowed (hand-calibrated, precision-side only) | | `pred_dur` | duration-predictor frame counts, 25 ms/frame, one pad token at each end — **the timing ground truth** | | `align.phonemes` | IPA, byte-identical to what the model was fed | | `align.units` | syllable / English-word / punct atoms: `[ph_a, ph_b)` in phonemes, `[ch_a, ch_b)` in text | | `align.words` | word spans with surfaces | | `align.ph2unit` | phoneme char → unit index (−1 for spaces) | | `align.tok2ph` | model token index → phoneme char index | | `word_spans` | two independent word segmentations (`tltk`, `newmm`) so tokenizer choice can be varied with no Thai tokenizer installed | ## Limitations * **The audio is vocoder output, not natural speech.** It is out of domain for aligners trained on read speech. That is deliberate — it is the audio the metric has to work on — but results here are not a claim about natural speech, and an aligner that does well on real speech may not do well here. * **`pred_dur` is ground truth for *this* TTS model's rendering**, not a human phonetic transcription. It is exact about where the model placed each token; it does not adjudicate whether that placement was phonetically ideal. * **Precision-side only.** No `‖` "a break is required here" marks exist, so missing a break is unpenalized under `pause_precision`. * **Synthetic speakers.** 12 designed voices from one checkpoint, so speaker diversity is narrower than a natural-speech corpus. * Earlier internal runs of this comparison reported larger gaps between aligners. Two things changed: a coordinate bug specific to the MMS arm (its char indices came from the G2P's units, which index normalized text, while attribution used raw text — they differ on 900/1,572 clips), and everything now aligning on the text actually spoken. Both raise agreement with ground truth across the board. The ranking is unchanged; the margins were overstated.