| """Export the browser graphs: LM, aggregator, vocoder. |
| |
| The original export notebook is gone and took its graphs with it, so this is |
| written against the call patterns that are known to work in inference |
| (`ar_generate` in train_voices.py): `mm.model(...)` for the backbone, |
| `mm.linear_proj_audio`, `mm.audio.decode` for the waveform. |
| |
| Every graph is validated against PyTorch before anything is quantised, and each |
| section is isolated so one failure does not hide the others. |
| |
| Contracts (host does the rest): |
| lm inputs_embeds[B,S,896], mask4d[B,1,S,P], position_ids[B,S], |
| past_k/v per layer -> hidden[B,S,896], new past_k/v |
| aggregator latent[B,1,64] -> embeds[B,1,896] |
| voc latent[B,T,64] -> waveform[B,1,N] |
| |
| Stages: STAGE=lm|agg|voc|all, then quantisation runs over whatever exists. |
| """ |
| import json |
| import os |
| import sys |
| import time |
| import traceback |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working")) |
| REPO = ROOT / "Ming-3.0-tts" |
| MODEL = ROOT / "Ming-3.0-tts-0.5b" |
| OUT = ROOT / "export" |
| STAGE = os.environ.get("STAGE", "all") |
|
|
| for p in (OUT,): |
| p.mkdir(parents=True, exist_ok=True) |
|
|
|
|
| def log(msg: str) -> None: |
| print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) |
|
|
|
|
| def patch_fp32() -> None: |
| for name in ("ming_tts.py", "modeling_bailingmm.py"): |
| p = REPO / name |
| s = p.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") |
| p.write_text(s) |
|
|
|
|
| def np_(t): |
| return t.detach().cpu().numpy() |
|
|
|
|
| def cosine(a, b) -> float: |
| a = np.asarray(a, dtype=np.float64).reshape(-1) |
| b = np.asarray(b, dtype=np.float64).reshape(-1) |
| na, nb = np.linalg.norm(a), np.linalg.norm(b) |
| if na == 0 or nb == 0: |
| return 0.0 |
| return float(a @ b / (na * nb)) |
|
|
|
|
| def stage_lm(mm, torch) -> dict: |
| """One graph for both prefill and decode: past_len and seq_len are dynamic.""" |
| import onnxruntime as ort |
|
|
| lm = mm.model |
| cfg = lm.config |
| n = cfg.num_hidden_layers |
| kv_heads = getattr(cfg, "num_key_value_heads", cfg.num_attention_heads) |
| head_dim = cfg.hidden_size // cfg.num_attention_heads |
| log(f"lm: {n} layers, {kv_heads} kv heads, head_dim {head_dim}, " |
| f"hidden {cfg.hidden_size}, vocab {cfg.vocab_size}") |
|
|
| class Wrapper(torch.nn.Module): |
| def __init__(self): |
| super().__init__() |
| self.lm = lm |
|
|
| def forward(self, inputs_embeds, attention_mask, position_ids, *past): |
| |
| k, v = past[:n], past[n:] |
| cache = tuple((k[i], v[i]) for i in range(n)) |
| out = self.lm(inputs_embeds=inputs_embeds, attention_mask=attention_mask, |
| position_ids=position_ids, past_key_values=cache, |
| use_cache=True, output_hidden_states=True, return_dict=True) |
| new = out.past_key_values |
| ks = [new[i][0] for i in range(n)] |
| vs = [new[i][1] for i in range(n)] |
| return (out.hidden_states[-1], *ks, *vs) |
|
|
| wrapper = Wrapper().float().eval() |
| dev = next(lm.parameters()).device |
| B, S, P = 1, 4, 6 |
| H = cfg.hidden_size |
| embeds = torch.randn(B, S, H, device=dev) |
| |
| |
| neg = torch.finfo(torch.float32).min / 2 |
| mask = torch.full((B, 1, S, P + S), neg, device=dev) |
| for i in range(S): |
| mask[:, :, i, :P + i + 1] = 0.0 |
| pos = torch.arange(P, P + S, device=dev).unsqueeze(0) |
| past = [] |
| for _ in range(n): |
| past.append(torch.randn(B, kv_heads, P, head_dim, device=dev)) |
| for _ in range(n): |
| past.append(torch.randn(B, kv_heads, P, head_dim, device=dev)) |
|
|
| with torch.no_grad(): |
| ref = wrapper(embeds, mask, pos, *past) |
|
|
| names_in = ["inputs_embeds", "attention_mask", "position_ids"] |
| names_in += [f"past_k_{i}" for i in range(n)] + [f"past_v_{i}" for i in range(n)] |
| names_out = ["hidden"] |
| names_out += [f"out_k_{i}" for i in range(n)] + [f"out_v_{i}" for i in range(n)] |
|
|
| dyn = {"inputs_embeds": {1: "s"}, "attention_mask": {2: "s", 3: "p"}, |
| "position_ids": {1: "s"}} |
| for i in range(n): |
| dyn[f"past_k_{i}"] = {2: "p"} |
| dyn[f"past_v_{i}"] = {2: "p"} |
|
|
| path = OUT / "lm.onnx" |
| log(f"exporting {path.name} (this takes a few minutes)") |
| torch.onnx.export(wrapper, (embeds, mask, pos, *past), str(path), |
| input_names=names_in, output_names=names_out, |
| dynamic_axes=dyn, opset_version=20, do_constant_folding=True, |
| dynamo=False) |
| log(f"{path.name}: {path.stat().st_size / 1e6:.0f} MB") |
|
|
| sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"]) |
| feeds = {"inputs_embeds": np_(embeds), "attention_mask": np_(mask), |
| "position_ids": np_(pos)} |
| for i in range(n): |
| feeds[f"past_k_{i}"] = np_(past[i]) |
| feeds[f"past_v_{i}"] = np_(past[n + i]) |
| got = sess.run(None, feeds) |
| cos = [cosine(np_(ref[i]), got[i]) for i in range(3)] |
| log(f"validate hidden cos={cos[0]:.6f} k0={cos[1]:.6f} v0={cos[2]:.6f}") |
| return {"graph": "lm", "mb": round(path.stat().st_size / 1e6, 1), |
| "cos_hidden": cos[0], "layers": n} |
|
|
|
|
| def stage_agg(mm, torch) -> dict: |
| import onnxruntime as ort |
|
|
| lin = mm.linear_proj_audio |
| dim_in = mm.latent_dim |
| dev = next(lin.parameters()).device |
| dummy = torch.randn(1, 1, dim_in, device=dev) |
| with torch.no_grad(): |
| ref = lin(dummy) |
| path = OUT / "aggregator.onnx" |
| torch.onnx.export(lin.float().eval(), (dummy,), str(path), |
| input_names=["latent"], output_names=["embeds"], |
| dynamic_axes={"latent": {1: "t"}}, opset_version=20, |
| do_constant_folding=True, dynamo=False) |
| sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"]) |
| got = sess.run(None, {"latent": np_(dummy)})[0] |
| c = cosine(np_(ref), got) |
| log(f"aggregator.onnx {path.stat().st_size / 1e6:.0f} MB cos={c:.6f}") |
| return {"graph": "aggregator", "mb": round(path.stat().st_size / 1e6, 1), |
| "cos": c, "dim_in": dim_in, "dim_out": int(ref.shape[-1])} |
|
|
|
|
| def stage_voc(mm, torch) -> dict: |
| """Export the vocoder up to the ISTFT head's linear projection. |
| |
| `decode` ends in a complex STFT, which ONNX cannot represent. The head does |
| `linear -> (mag, phase) -> complex -> istft`, so the last real-valued tensor |
| is the projection output. The host does the rest, matching the documented |
| `voc -> spec` contract. |
| """ |
| import onnxruntime as ort |
|
|
| dec = mm.audio.decoder |
| head = dec.head |
| lin = getattr(head, "linear", None) |
| if lin is None: |
| lin = next((m for m in head.modules() if isinstance(m, torch.nn.Linear)), None) |
| if lin is None: |
| raise RuntimeError("could not find the ISTFT head projection layer") |
| log(f"head projection: out_features={getattr(lin, 'out_features', '?')}") |
|
|
| class VocSpec(torch.nn.Module): |
| def __init__(self): |
| super().__init__() |
| self.dec = dec |
|
|
| def forward(self, latent): |
| x = self.dec.fc1(latent) |
| if getattr(self.dec, "patch_size", -1) != -1: |
| x = self.dec.upsampling.upsampler(x.transpose(1, 2)).transpose(1, 2) |
| x = self.dec.decoder(inputs_embeds=x).last_hidden_state |
| return lin(x) |
|
|
| voc = VocSpec().float().eval() |
| T = 8 |
| dev = next(dec.parameters()).device |
| dummy = torch.randn(1, T, mm.latent_dim, device=dev) |
| with torch.no_grad(): |
| ref = voc(dummy) |
| log(f"spec shape {tuple(ref.shape)}") |
|
|
| path = OUT / "voc.onnx" |
| torch.onnx.export(voc, (dummy,), str(path), input_names=["latent"], |
| output_names=["spec"], dynamic_axes={"latent": {1: "t"}}, |
| opset_version=20, do_constant_folding=True, dynamo=False) |
| sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"]) |
| got = sess.run(None, {"latent": np_(dummy)})[0] |
| c = cosine(np_(ref), got) |
| log(f"voc.onnx {path.stat().st_size / 1e6:.0f} MB cos={c:.6f} spec={got.shape}") |
|
|
| meta = {"n_fft": int(head.n_fft), "hop_length": int(head.hop_length), |
| "padding": str(getattr(head, "padding", "same")), |
| "spec_bins": int(got.shape[-1]), "frames_per_latent": T} |
| (OUT / "voc_meta.json").write_text(json.dumps(meta, indent=1)) |
| log(f"voc meta {meta}") |
| return {"graph": "voc", "mb": round(path.stat().st_size / 1e6, 1), "cos": c, |
| "spec_shape": list(got.shape)} |
|
|
|
|
| def quantize(paths: list[Path], bits: int = 4) -> list[dict]: |
| from onnxruntime.quantization.matmul_nbits_quantizer import MatMulNBitsQuantizer |
|
|
| rows = [] |
| for src in paths: |
| if not src.exists(): |
| continue |
| dst = src.with_name(src.stem + f"_int{bits}.onnx") |
| try: |
| q = MatMulNBitsQuantizer(str(src), bits=bits, block_size=32, is_symmetric=True, |
| accuracy_level=4, op_types_to_quantize=("MatMul", "Gemm")) |
| q.process() |
| q.model.save_model_to_file(str(dst), use_external_data_format=False) |
| rows.append({"graph": src.stem, "fp32_mb": round(src.stat().st_size / 1e6, 1), |
| "int_mb": round(dst.stat().st_size / 1e6, 1)}) |
| log(f"quantise {src.stem}: {src.stat().st_size/1e6:.0f} -> " |
| f"{dst.stat().st_size/1e6:.0f} MB (int{bits})") |
| except Exception: |
| log(f"quantise {src.stem} failed\n{traceback.format_exc()}") |
| return rows |
|
|
|
|
| def stage_probe_audio(mm) -> dict: |
| """Dump the audio VAE surface so the vocoder export can stop before ISTFT. |
| |
| `decode` builds a complex STFT internally, which the ONNX exporter refuses |
| ("Unknown number type: complex"). The fix is to return the spectrum and do |
| the inverse transform on the host, but that needs the real method names. |
| """ |
| import inspect |
|
|
| audio = mm.audio |
| text = [] |
| text.append("class: " + type(audio).__name__) |
| text.append("\nattrs: " + ", ".join(a for a in dir(audio) if not a.startswith("__"))) |
| for name in dir(audio): |
| if name.startswith("__"): |
| continue |
| fn = getattr(audio, name) |
| if not callable(fn): |
| continue |
| try: |
| src = inspect.getsource(fn) |
| except Exception: |
| continue |
| if any(k in src for k in ("istft", "stft", "complex", "spectrogram", "def decode", "def encode")): |
| text.append(f"\n\n===== {name} =====\n{src}") |
| out = OUT / "audio_src.txt" |
| out.write_text("\n".join(text)) |
| log(f"wrote {out} ({len(text)} blocks)") |
| for line in text[:80]: |
| log(line) |
| return {"graph": "probe_audio", "chars": sum(len(t) for t in text)} |
|
|
|
|
| def main() -> None: |
| import torch |
|
|
| sys.path.insert(0, str(REPO)) |
| patch_fp32() |
| from ming_tts import MingTTS |
|
|
| tts = MingTTS(str(MODEL), device="cuda", text_normalization=False) |
| mm = tts.model |
| results = [] |
|
|
| for name, fn in (("lm", stage_lm), ("agg", stage_agg), ("probe", lambda m, t: stage_probe_audio(m)), |
| ("voc", stage_voc)): |
| if STAGE not in (name, "all"): |
| continue |
| try: |
| results.append(fn(mm, torch)) |
| except Exception: |
| log(f"stage {name} FAILED\n{traceback.format_exc()}") |
|
|
| q = quantize([OUT / "lm.onnx", OUT / "aggregator.onnx", OUT / "voc.onnx"]) |
| (OUT / "sizes.json").write_text(json.dumps( |
| {p_.name: round(p_.stat().st_size / 1e6, 1) for p_ in sorted(OUT.glob("*.onnx"))}, |
| indent=1)) |
| (OUT / "report.json").write_text(json.dumps({"graphs": results, "quant": q}, |
| ensure_ascii=False, indent=1)) |
| log("done") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
|
|
|
|
