README.md

metadata

license: apache-2.0
language:
  - th
task_categories:
  - automatic-speech-recognition
tags:
  - forced-alignment
  - thai
  - text-to-speech
  - evaluation
  - prosody
size_categories:
  - 1K<n<10K
pretty_name: Thai Aligner Bench — forced-alignment benchmark with duration ground truth
configs:
  - config_name: default
    data_files: items.jsonl

Thai Aligner Bench

🚧 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

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:

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

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

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/<id>.flac    24 kHz mono, lossless
aligner_bench.py   the benchmark (single file)
results/<arm>/     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.