"""Distill the Ming-3.0-tts flow head to 4-step CFG-free. Teacher: 10-step CFG=2, fp16/fp32 Ming reference. Student: same DiT architecture, initialized from the teacher, trained to match teacher velocity on student states. Environment: N_UTTERANCES=20 number of teacher trajectories (smoke default 20) TRAIN_STEPS=100 optimizer steps (smoke default 100) BATCH=8 LR=1e-4 """ import contextlib import copy import json import math import os import random import re import sys import time import traceback import urllib.request from pathlib import Path import numpy as np import torch import torch.nn.functional as F ROOT = Path("/kaggle/working") REPO = ROOT / "Ming-3.0-tts" MODEL_DIR = ROOT / "Ming-3.0-tts-0.5b" OUT = ROOT / "ming_distill" DATA = OUT / "trajectories" LOG = ROOT / "distill.log" TEXT_URL = "https://paste.rs/m5OkO" N_UTTERANCES = int(os.environ.get("N_UTTERANCES", "20")) TRAIN_STEPS = int(os.environ.get("TRAIN_STEPS", "100")) BATCH = int(os.environ.get("BATCH", "8")) LR = float(os.environ.get("LR", "1e-4")) STUDENT_STEPS = 4 SEED = 20261021 DTYPE = os.environ.get("DTYPE", "fp32").lower() MODEL_DTYPE_NAME = "torch.float32" if DTYPE == "fp32" else "torch.float16" MODEL_DTYPE = torch.float32 if DTYPE == "fp32" else torch.float16 DATA.mkdir(parents=True, exist_ok=True) def log(msg): line = f"[{time.strftime('%H:%M:%S')}] {msg}" print(line, flush=True) with open(LOG, "a") as f: f.write(line + "\n") def load_texts(n): raw = urllib.request.urlopen(TEXT_URL, timeout=60).read().decode("utf-8", "ignore") parts = re.split(r"(?<=[。!?!?;;])\s*", raw) rows = [] for part in parts: text = re.sub(r"\s+", "", part).strip() if 12 <= len(text) <= 55 and not text.startswith(("一", "二", "三", "四", "五", "六", "七", "八", "九", "十")): rows.append(text) random.Random(SEED).shuffle(rows) if len(rows) < n: raise RuntimeError(f"only {len(rows)} usable texts") return rows[:n] class DiTGraph(torch.nn.Module): def __init__(self, dit): super().__init__() self.dit = dit def forward(self, x, t, c, history): return self.dit(x=x, t=t, c=c, latent_history=history, mask=None)[:, -1:, :] def build_models(): sys.path.insert(0, str(REPO)) subprocess_patch() from ming_tts import MingTTS import tts_tasks return MingTTS, tts_tasks def subprocess_patch(): for name in ("ming_tts.py", "modeling_bailingmm.py"): path = REPO / name s = path.read_text() s = s.replace("torch_dtype=torch.bfloat16", f"torch_dtype={MODEL_DTYPE_NAME}") s = s.replace(".eval().to(torch.bfloat16).to(device)", f".eval().to({MODEL_DTYPE_NAME}).to(device)") s = s.replace("dtype=torch.bfloat16", f"dtype={MODEL_DTYPE_NAME}") path.write_text(s) def autocast_ctx(): if DTYPE == "fp16" and torch.cuda.is_available(): return torch.autocast(device_type="cuda", dtype=torch.float16) return contextlib.nullcontext() def teacher_trajectories(tts, tts_tasks, texts): torch.set_grad_enabled(False) mm = tts.model device = next(mm.parameters()).device dtype = next(mm.parameters()).dtype prompts = json.loads((REPO / "data/voice_presets/voice_prompts.json").read_text()) prompt_text = prompts["lingguang"]["text"] prompt_wav = REPO / "data/voice_presets/voice_audio/lingguang.wav" torch.manual_seed(1234) prompt_latent, spk_emb = tts.prepare_prompt(str(prompt_wav), use_spk_emb=True) prompt_latent = prompt_latent.to(device=device, dtype=dtype) spk_emb = [x.to(device=device, dtype=dtype) for x in spk_emb] prompt = tts_tasks.build_tts_prompt("Chinese") log(f"prompt latent {tuple(prompt_latent.shape)} spk {len(spk_emb)}") total_frames = 0 for i, text in enumerate(texts): torch.manual_seed(SEED + i) try: input_ids, inputs_embeds = mm.prepare_input_embed( prompt=prompt, text=text, spk_emb=spk_emb, prompt_latent=prompt_latent, prompt_text=prompt_text, ) attention_mask = torch.ones(input_ids.shape, device=device) position_ids = (attention_mask.cumsum(-1) - 1).masked_fill_(attention_mask == 0, 1) past = None latent_history = torch.zeros( 1, mm.history_patch_size, mm.latent_dim, device=device, dtype=dtype ) if prompt_latent is not None: start = mm.history_patch_size - prompt_latent.size(1) if start < 0: latent_history[:] = prompt_latent[:, -start:, :] else: latent_history[:, start:, :] = prompt_latent budget = (512 - inputs_embeds.shape[1]) // mm.patch_size cap = min(200, max(16, int(len(text) * 2.6))) steps = max(1, min(cap, budget)) zs, hs, ns, ls = [], [], [], [] for step in range(steps): with autocast_ctx(): out = mm.model( attention_mask=attention_mask, position_ids=position_ids, inputs_embeds=inputs_embeds, audio_mask=None, image_mask=None, output_hidden_states=True, return_dict=True, use_cache=True, past_key_values=past, ) past = out.past_key_values z = out.hidden_states[-1][:, -1:, :] noise = torch.randn(1, 1, mm.latent_dim, device=device, dtype=dtype) sde = torch.randn(10, 1, 1, mm.latent_dim, device=device, dtype=dtype) with autocast_ctx(): latent = mm.flowloss.cfm.sample( noise=noise, c=z, latent_history=latent_history, sde_noise=sde, cfg_scale=2.0, sway_sampling_coef=-1.0, use_epss=True, patch_size=1, sigma=0.25, temperature=0.0, ) zs.append(z[0, 0].detach().float().cpu()) hs.append(latent_history[0].detach().float().cpu()) ns.append(noise[0, 0].detach().float().cpu()) ls.append(latent[0, 0].detach().float().cpu()) inputs_embeds = mm.linear_proj_audio(latent) position_ids = position_ids[:, -1:] + 1 attention_mask = torch.ones(inputs_embeds.shape[0], 1, device=device) latent_history[:, :-mm.patch_size, :] = latent_history[:, mm.patch_size:, :].clone() latent_history[:, -mm.patch_size:, :] = latent payload = { "text": text, "z": torch.stack(zs), "history": torch.stack(hs), "noise": torch.stack(ns), "latent": torch.stack(ls), } torch.save(payload, DATA / f"{i:04d}.pt") total_frames += steps if i % 5 == 0 or i == len(texts) - 1: log(f"trajectory {i+1}/{len(texts)} frames={steps} total={total_frames}") except Exception: log(f"trajectory {i} failed: {text}\n{traceback.format_exc()}") log(f"trajectories done frames={total_frames}") torch.set_grad_enabled(True) return total_frames def load_dataset(): zs, hs, ns, ls = [], [], [], [] for path in sorted(DATA.glob("*.pt")): row = torch.load(path, map_location="cpu", weights_only=False) zs.append(row["z"]) hs.append(row["history"]) ns.append(row["noise"]) ls.append(row["latent"]) if not zs: raise RuntimeError("no trajectories") z = torch.cat(zs).float() h = torch.cat(hs).float() n = torch.cat(ns).float() l = torch.cat(ls).float() log(f"dataset frames={z.shape[0]} z={tuple(z.shape)}") return z, h, n, l def train(student, teacher, data, device): z, h, n, target = [x.to(device) for x in data] n_frames = z.shape[0] optimizer = torch.optim.AdamW(student.parameters(), lr=LR, weight_decay=0.01) scaler = None if DTYPE == "fp16": try: scaler = torch.cuda.amp.GradScaler() except Exception: scaler = torch.amp.GradScaler("cuda") student.train() teacher.eval() losses = [] times = [0.0, 0.25, 0.5, 0.75, 1.0] for step in range(TRAIN_STEPS): idx = torch.randint(0, n_frames, (min(BATCH, n_frames),), device=device) bz = z[idx].unsqueeze(1) bh = h[idx] bn = n[idx].unsqueeze(1) bt = target[idx].unsqueeze(1) y = bn loss = 0.0 for i in range(STUDENT_STEPS): ti = times[i] dt = times[i + 1] - ti tv_t = torch.tensor(float(ti), device=device) with torch.no_grad(), autocast_ctx(): pred_cfg = teacher.forward_with_cfg( x=y, t=tv_t, c=bz, latent_history=bh, patch_size=1 ) pred, null = torch.chunk(pred_cfg, 2, dim=0) tv = pred + (pred - null) * 2.0 with autocast_ctx(): sv = student( x=y, t=torch.full((y.shape[0],), float(ti), device=device), c=bz, latent_history=bh, mask=None, )[:, -1:, :] loss = loss + F.mse_loss(sv.float(), tv.float()) * dt y = (y + sv.float() * dt).detach() loss = loss + 0.5 * F.mse_loss(y, bt) optimizer.zero_grad(set_to_none=True) if scaler is not None: scaler.scale(loss).backward() scaler.unscale_(optimizer) torch.nn.utils.clip_grad_norm_(student.parameters(), 1.0) scaler.step(optimizer) scaler.update() else: loss.backward() torch.nn.utils.clip_grad_norm_(student.parameters(), 1.0) optimizer.step() losses.append(float(loss.detach().cpu())) if step % 10 == 0 or step == TRAIN_STEPS - 1: log(f"train {step+1}/{TRAIN_STEPS} loss={losses[-1]:.5f}") return losses def export_student(student, path): student.eval() g = DiTGraph(student.float()).cpu() x = torch.randn(1, 1, 64) t = torch.tensor([0.5]) c = torch.randn(1, 1, 896) h = torch.randn(1, 1, 64) with torch.inference_mode(): ref = g(x, t, c, h) torch.onnx.export( g, (x, t, c, h), str(path), input_names=["x", "t", "c", "history"], output_names=["velocity"], opset_version=20, do_constant_folding=True, dynamo=False, ) import onnxruntime as ort sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"]) got = sess.run(None, { "x": x.numpy(), "t": t.numpy(), "c": c.numpy(), "history": h.numpy() })[0] a = ref.numpy().reshape(-1) b = got.reshape(-1) log(f"student onnx size={path.stat().st_size/1e6:.1f}MB max_abs={np.abs(a-b).max():.2e}") return g def main(): torch.set_grad_enabled(True) torch.manual_seed(SEED) if torch.cuda.is_available(): torch.cuda.manual_seed_all(SEED) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") log(f"torch={torch.__version__} cuda={torch.cuda.is_available()} device={device}") if torch.cuda.is_available(): log(f"gpu={torch.cuda.get_device_name(0)} capability={torch.cuda.get_device_capability(0)}") MingTTS, tts_tasks = build_models() t0 = time.time() tts = MingTTS(str(MODEL_DIR), device=str(device), text_normalization=False) log(f"loaded tts in {time.time()-t0:.1f}s") texts = load_texts(N_UTTERANCES) log(f"texts={len(texts)} example={texts[0]}") if not any(DATA.glob("*.pt")): teacher_trajectories(tts, tts_tasks, texts) else: log("trajectories already exist; skipping generation") data = load_dataset() torch.set_grad_enabled(True) teacher = copy.deepcopy(tts.model.flowloss.cfm.model).float().to(device).eval() student = copy.deepcopy(teacher).to(device).train() for p in teacher.parameters(): p.requires_grad_(False) losses = train(student, teacher, data, device) OUT.mkdir(exist_ok=True) torch.save({k: v.half().cpu() for k, v in student.state_dict().items()}, OUT / "student.pt") g = export_student(student, OUT / "dit4.onnx") report = { "teacher_steps": 10, "teacher_cfg": 2.0, "student_steps": STUDENT_STEPS, "student_cfg": 0.0, "schedule": [0.0, 0.25, 0.5, 0.75, 1.0], "utterances": N_UTTERANCES, "train_steps": TRAIN_STEPS, "batch": BATCH, "lr": LR, "frames": int(data[0].shape[0]), "first_loss": losses[0] if losses else None, "last_loss": losses[-1] if losses else None, "student_onnx": str(OUT / "dit4.onnx"), } (OUT / "report.json").write_text(json.dumps(report, indent=2)) log("DONE " + json.dumps(report, ensure_ascii=False)) if __name__ == "__main__": try: main() except Exception: log(traceback.format_exc()) raise