| """Bake the two offline assets Ming needs per built-in voice. |
| |
| For every entry in config/ming_voices.json this writes: |
| |
| prompt_latent - VAE posterior latent of the 6 s prompt wav (the flow head's |
| conditioning, replacing the F5 reference mel) |
| speaker_emb - 192-d CAM++ embedding of the same clip at 16 kHz |
| |
| Both are tiny and ship with the site. The browser only needs the audio encoder |
| when a user uploads their own clip, so this bake is what keeps the main bundle |
| small. |
| |
| Writes voices_baked.npz plus voices_baked.json (shapes, dtypes, source hashes). |
| |
| Run inside the Kaggle notebook after the model is downloaded: |
| EVAL_DATA=/kaggle/working/webfm-eval python3 bake_voices.py |
| """ |
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import sys |
| import traceback |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| ROOT = Path("/kaggle/working") |
| REPO = ROOT / "Ming-3.0-tts" |
| MODEL_DIR = ROOT / "Ming-3.0-tts-0.5b" |
| DATA = Path(os.environ.get("EVAL_DATA", str(ROOT / "webfm-eval"))) |
| OUT = ROOT / "baked" |
|
|
|
|
| def patch_fp32() -> None: |
| for name in ("ming_tts.py", "modeling_bailingmm.py"): |
| path = REPO / name |
| s = path.read_text() |
| s = s.replace("torch_dtype=torch.bfloat16", "torch_dtype=torch.float32") |
| s = s.replace(".eval().to(torch.bfloat16).to(device)", ".eval().to(torch.float32).to(device)") |
| s = s.replace("dtype=torch.bfloat16", "dtype=torch.float32") |
| path.write_text(s) |
|
|
|
|
| def sha8(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest()[:8] |
|
|
|
|
| def main() -> None: |
| OUT.mkdir(parents=True, exist_ok=True) |
| sys.path.insert(0, str(REPO)) |
| patch_fp32() |
| from ming_tts import MingTTS |
|
|
| tts = MingTTS(str(MODEL_DIR), device="cuda", text_normalization=False) |
| voices = json.loads((DATA / "config/ming_voices.json").read_text())["voices"] |
|
|
| arrays: dict[str, np.ndarray] = {} |
| meta: dict[str, dict] = {} |
| for v in voices: |
| vid = v["id"] |
| wav = DATA / v["promptWav"] |
| if not wav.exists(): |
| print(f"skip {vid}: {wav} missing") |
| continue |
| try: |
| with torch.no_grad(): |
| latent, spk = tts.prepare_prompt(str(wav), use_spk_emb=True) |
| latent = latent.detach().float().cpu().numpy() |
| emb = (spk[0] if isinstance(spk, (list, tuple)) else spk).detach().float().cpu() |
| emb = emb.reshape(-1).numpy() |
| arrays[f"{vid}_latent"] = latent |
| arrays[f"{vid}_spk"] = emb |
| meta[vid] = { |
| "promptWav": v["promptWav"], |
| "promptText": v["promptText"], |
| "wav_sha8": sha8(wav), |
| "latent_shape": list(latent.shape), |
| "spk_dim": int(emb.size), |
| } |
| print(f"{vid}: latent {latent.shape} spk {emb.size} from {wav.name} ({v['seconds']}s)") |
| except Exception: |
| print(f"{vid} failed\n{traceback.format_exc()}") |
|
|
| if not arrays: |
| raise SystemExit("nothing baked") |
|
|
| np.savez_compressed(OUT / "voices_baked.npz", **arrays) |
| (OUT / "voices_baked.json").write_text(json.dumps( |
| {"model": "inclusionAI/Ming-3.0-tts-0.5B", "voices": meta, |
| "note": "latent is the VAE posterior used as flow conditioning; spk is CAM++ 192-d"}, |
| ensure_ascii=False, indent=2)) |
| size = (OUT / "voices_baked.npz").stat().st_size |
| print(f"wrote {OUT/'voices_baked.npz'} ({size/1024:.0f} KB) for {len(meta)} voices") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
