You can deploy this model and start earning money today!

notmax123/
BlueTTS2.5-onnx

Name: BlueTTS2.5-onnx
Availability: InStock

onnx

Views

No views yet

ONNX export — text2latent_v2_ru @ step 748000

Multilingual 44.1 kHz TTS exported from checkpoints/text2latent_v2_ru/ckpt_step_748000.pt. Languages in the training mix: he, en, de, it, es, ru, yi.

Every checkpoint hash this was built from is recorded in manifest.json. A text2latent checkpoint is only valid against the stats file it was normalized with, so stats.npz here (from stats_yiddish.pt) is part of the export, not an interchangeable artifact.

file	what
`reference_encoder.onnx`	reference latents → 50 style tokens
`text_encoder.onnx`	phoneme ids + style → text embedding
`vector_estimator.onnx`	flow-matching velocity net (the sampler's inner loop)
`vocoder.onnx`	latents → waveform
`duration_predictor.onnx`	total duration, from reference latents
`duration_predictor_style.onnx`	total duration, from precomputed style tokens
`stats.npz`	`mean`, `std`, `normalizer_scale` for latent normalization
`uncond.npz`	`u_text`, `u_ref` — the CFG unconditional embeddings
`vocab.json`	IPA symbol → id (256-token universal vocab, PAD=0/BOS=1/EOS=2)
`tts.json`	copy of `configs/tts.json`, the architecture source of truth
`manifest.json`	source checkpoints + sha256 of every file here
`voices/*.json`	precomputed speaker styles (see below)

Graph signatures

Batch is fixed at 1; only the time axes are dynamic.

reference_encoder       z_ref[1,144,T_ref] mask[1,1,T_ref]              -> ref_values[1,50,256]
text_encoder            text_ids[1,T_txt] style_ttl[1,50,256]
                        text_mask[1,1,T_txt]                            -> text_emb[1,256,T_txt]
vector_estimator        noisy_latent[1,144,T_lat] text_emb[1,256,T_txt]
                        style_ttl[1,50,256] latent_mask[1,1,T_lat]
                        text_mask[1,1,T_txt] current_step[1]
                        total_step[1]                                   -> denoised_latent[1,144,T_lat]
vocoder                 latent[1,24,T_dec]                              -> waveform[1,T_wav]
duration_predictor      text_ids[1,T_txt] z_ref[1,144,T_ref]
                        text_mask[1,1,T_txt] ref_mask[1,1,T_ref]        -> duration[1]  (linear seconds)
duration_predictor_sty  text_ids[1,T_txt] style_dp[1,8,16]
                        text_mask[1,1,T_txt]                            -> duration[1]  (linear seconds)

Two things that are easy to get wrong:

vector_estimator bakes in the Euler step. It returns x + (1/total_step) * v, not the velocity. Classifier-free guidance has to blend velocities, so recover v = (out - noisy_latent) * total_step before mixing cond/uncond.
The latent axes are the compressed ones. The VF and DP work on [1, 144, T] at 14.35 Hz; the vocoder wants [1, 24, 6T]. Fold with z.reshape(1,24,6,T).transpose(0,1,3,2).reshape(1,24,6T), and denormalize first: z = (x / normalizer_scale) * std + mean.

Voices

Precomputed styles, so synthesis never needs a reference wav or the AE encoder. Schema matches what the repo already reads (inference_tts.py --style_json, benchmark_trt.load_style_json, inference_helper.load_voice_style): style_ttl [1,50,256] for the acoustic model, style_dp [1,8,16] for duration_predictor_style.onnx.

voice	reader	F0	source
`libri_male_6209`	6209 deckerteach	128 Hz	LibriTTS-R train-clean-100
`libri_male_8088`	8088 Jason Bolestridge	112 Hz	LibriTTS-R train-clean-100
`libri_female_6147`	6147 Liberty Stump	211 Hz	LibriTTS-R train-clean-100
`libri_female_1088`	1088 Christabel	204 Hz	LibriTTS-R train-clean-100
`female`	—	180 Hz	in-house `female1_hebrew_slow` — check rights before shipping

LibriTTS-R is CC BY 4.0 (Google LLC). Those references are 24 kHz upsampled to 44.1 kHz, so they carry no content above 12 kHz — the same form the model saw in training.

Add one with:

bash

python scripts/make_onnx_voice.py --onnx_dir onnx_models_ru_748000 \
    --name <name> --ref_wav <wav>

Running

bash

python scripts/run_onnx_inference.py --onnx_dir onnx_models_ru_748000 \
    --voice libri_male_6209 --ipa_json <ipa.json> --steps 16 --cfg 3.0

Input is IPA, not raw text — phonemization stays outside the export, because each language has its own front end (Phonikud for he, nikud + yiddish_g2p for yi, RUAccent + RUPhon for ru, espeak for the rest). --ref_wav is also accepted, but encoding a wav to latents needs the PyTorch AE encoder: export_onnx.py exports the decoder only.

Verified against the PyTorch path from identical initial noise: waveform cos-similarity ≥ 0.9995 in all 7 languages, duration agreeing to ~1e-6 s.

Russian front end (`g2p/russian_g2p.py`)

Bundled here because it is the front end this checkpoint was trained with — feed it anything else and the stress/reduction pattern will not match what the model saw.

Cyrillic --RUAccent--> '+'-accented --RUPhon--> IPA --remap--> vocab.json symbols

RUAccent resolves lexical stress from sentence context and restores omitted ё (~34% of russian_librispeech rows need it; ё is always stressed).
RUPhon applies stress-conditioned vowel reduction — the thing that makes Russian sound Russian: зам+ок → zɐmˈok vs з+амок → zˈamək.
remap_ruphon_ipa folds RUPhon's tilde tie-bars (t~s, t~ɕ, …) onto the single ligatures in vocab.json (ʦ, ʧ, ʣ, ʤ) and converts the ASCII stress mark ' to IPA ˈ (U+02C8). Without this last step stress silently trains into the apostrophe embedding — in-vocab, so it never raises an OOV.

python

from g2p.russian_g2p import phonemize_russian, remap_ruphon_ipa

phonemize_russian("на горе стоит замок")   # raw Cyrillic -> vocab-ready IPA
remap_ruphon_ipa("zɐm'ok t~sar")           # -> "zɐmˈok ʦar"  (stage 3 alone)

phonemize_russian / accent_russian need pip install ruaccent ruphon 'transformers<5'. That pin is why the two stages are kept out of the training env — phonemize offline into an ipa column. remap_ruphon_ipa, mark_yo_stress and apply_word_overrides are pure string work and safe to import anywhere.

Two deliberate quirks: ч /tɕ/ and тш /tʂ/ both map to ʧ, sharing an embedding with the English/Yiddish affricate rather than getting a symbol of their own; and всё carries a hard IPA override, because RUPhon reads it as fsʲe — which is the correct reading of все ("all"), so no respelling can fix it and the substitution has to know the source word.

Not espeak-ng: its ru voice is context-invariant (висит замок and стоит замок phonemize identically), cannot restore written-out ё, and emits ы as /y/, colliding with the German ü already in this vocab.

Known issues

Output can exceed ±1.0 (up to 1.5 measured on loud references) — anything writing PCM_16 must peak-limit or it clips silently. run_onnx_inference.py limits to 0.95.
Italian under-predicts duration by ~36%, well outside the 0.74–1.02 band of the other languages, so it sounds rushed. --speed 0.7 compensates.
Duration saturates near ~16.5 s. Longer text has to be synthesized per sentence and joined; see the --chunk note in scripts/run_ipa_inference.py.
Unknown IPA symbols map to PAD and vanish without raising. Check coverage against vocab.json when adding a language.

notmax123/BlueTTS2.5-onnx