radio demo: 4000-step student + end-to-end script

kaggle/radio_demo.py

@@ -0,0 +1,287 @@
+"""End-to-end radio segment: a small LLM writes the script, Ming speaks it.
+
+This is the product loop in miniature. A 0.5B instruct model plans a late-night
+segment (narration easing into a whisper), the segment is cast onto the mined
+voices, and the whole thing is rendered twice - once by the 10-step CFG teacher
+and once by the 4-step student - so the shipped model can be judged on a real
+programme rather than on isolated sentences.
+
+Two passes on purpose: the teacher and the student cannot both sit on a 15 GB
+card alongside the 1.48 B backbone.
+
+Outputs under /kaggle/working/radio:
+  script.json          the LLM's plan, plus the fallback if parsing failed
+  radio_teacher.wav    the segment, teacher
+  radio_student.wav    the segment, student
+  lines/*.wav          each line separately
+  report.json          per-line CER, duration, wall time
+"""
+import json
+import os
+import re
+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"
+BUNDLE = ROOT / "webfm-eval"
+OUT = ROOT / "radio"
+CKPT = BUNDLE / "student4_rc.pt"
+SEED = 20261031
+STEPS = 4
+GAP_S = 0.7
+SR = 44100
+
+SCRIPT_LLM = os.environ.get("SCRIPT_LLM", "Qwen/Qwen2.5-0.5B-Instruct")
+CAST = {"叙述": "a08", "故事": "a08", "耳语": "a01", "开场": "a05", "收尾": "a08"}
+
+FALLBACK = [
+    {"style": "开场", "text": "晚上好，这里是深夜频道，我是今晚陪你的人。"},
+    {"style": "叙述", "text": "窗外的雨下了一整晚，路灯把水汽照成一片模糊的黄。"},
+    {"style": "故事", "text": "很多年前，这条街上有一家很小的唱片店，老板总在打烊前放同一首歌。"},
+    {"style": "耳语", "text": "后来店关了，歌还在。"},
+    {"style": "叙述", "text": "如果你还醒着，就把灯关小一点，让声音替你把今天收好。"},
+    {"style": "耳语", "text": "晚安，我们明天见。"},
+]
+
+
+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 write_script() -> tuple[list[dict], str]:
+    """Ask a small instruct model for the segment; fall back to a fixed script."""
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    prompt = (
+        "你是一个深夜电台的编剧。写一段约 60 秒的节目串词，共 6 句，每句 8 到 28 个字。\n"
+        "要求：前两句是正常叙述，中间讲一小段故事，最后两句逐渐转为耳语，收在很轻的一句上。\n"
+        "只输出 JSON 数组，不要任何解释、不要代码块标记。格式：\n"
+        '[{"style":"开场","text":"..."},{"style":"叙述","text":"..."},'
+        '{"style":"故事","text":"..."},{"style":"耳语","text":"..."}]\n'
+        "style 只能取 开场、叙述、故事、耳语 四个值之一。"
+    )
+    try:
+        tok = AutoTokenizer.from_pretrained(SCRIPT_LLM)
+        model = AutoModelForCausalLM.from_pretrained(SCRIPT_LLM, torch_dtype=torch.float32).cuda().eval()
+        msgs = [{"role": "user", "content": prompt}]
+        text = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+        ids = tok([text], return_tensors="pt").to("cuda")
+        with torch.no_grad():
+            gen = model.generate(**ids, max_new_tokens=420, do_sample=True,
+                                 temperature=0.8, top_p=0.9,
+                                 pad_token_id=tok.eos_token_id)
+        raw = tok.decode(gen[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)
+        log(f"llm raw: {raw[:400]}")
+        del model
+        torch.cuda.empty_cache()
+
+        m = re.search(r"\[.*\]", raw, re.S)
+        rows = json.loads(m.group(0) if m else raw)
+        rows = [r for r in rows if isinstance(r, dict) and r.get("text")]
+        if len(rows) >= 4:
+            return rows[:8], "llm"
+    except Exception:
+        log("script LLM failed\n" + traceback.format_exc())
+    return FALLBACK, "fallback"
+
+
+def cast(rows: list[dict]) -> list[dict]:
+    """Assign a voice to each line and keep the plan explicit in the report."""
+    out = []
+    for i, r in enumerate(rows):
+        style = r.get("style") or "叙述"
+        slot = CAST.get(style, "a08")
+        out.append({"index": i, "style": style, "text": r["text"], "slot": slot})
+    return out
+
+
+def main() -> None:
+    import torch
+    import soundfile as sf
+    from transformers import pipeline
+
+    (OUT / "lines").mkdir(parents=True, exist_ok=True)
+    torch.manual_seed(SEED)
+
+    plan, source = write_script()
+    lines = cast(plan)
+    (OUT / "script.json").write_text(json.dumps({"source": source, "lines": lines},
+                                                ensure_ascii=False, indent=1))
+    log(f"script from {source}: {len(lines)} lines")
+    for l in lines:
+        log(f"  [{l['style']}] {l['slot']}  {l['text']}")
+
+    voices = {v["slot"]: v for v in
+              json.loads((BUNDLE / "mined/manifest.json").read_text())["voices"]}
+
+    sys.path.insert(0, str(REPO))
+    patch_fp32()
+    from ming_tts import MingTTS
+    import tts_tasks
+    sys.path.insert(0, str(BUNDLE / "eval"))
+    from score import load_t2s, score_row
+
+    table = load_t2s()
+    tts = MingTTS(str(MODEL), device="cuda", text_normalization=False)
+    report = {"script_source": source, "lines": [], "renders": {}}
+
+    def render(tag: str, use_student: bool) -> dict:
+        import copy
+
+        mm = tts.model
+        task_prompt = tts_tasks.build_tts_prompt("Chinese")
+        device = next(mm.parameters()).device
+        dtype = next(mm.parameters()).dtype
+        sampler = None
+        if use_student:
+            state = {k: v.float() for k, v in torch.load(CKPT, map_location="cpu").items()}
+            dit = copy.deepcopy(mm.flowloss.cfm.model.float())
+            dit.load_state_dict(state)
+            dit = dit.to(device).eval()
+
+            def sampler(z, hist, noise):
+                y = noise
+                for i in range(STEPS):
+                    v = dit(x=y, t=torch.full((y.shape[0],), i / STEPS, device=device),
+                            c=z, latent_history=hist, mask=None)[:, -1:, :]
+                    y = y + v * (1.0 / STEPS)
+                return y.detach()
+
+        pieces, rows = [], []
+        for line in lines:
+            v = voices[line["slot"]]
+            wav_path = str(BUNDLE / v["wav"])
+            t0 = time.time()
+            try:
+                if use_student:
+                    latent, spk = tts.prepare_prompt(wav_path, use_spk_emb=True)
+                    latent = latent.to(device=device, dtype=dtype)
+                    spk = [x.to(device=device, dtype=dtype) for x in spk]
+                    ref = tts.synthesize(task="TTS", text=line["text"], language_id="Chinese",
+                                         prompt_wav_path=wav_path, prompt_text=v["prompt_text"],
+                                         use_spk_emb=True, raw_text=True,
+                                         max_decode_steps=max(32, min(400, int(len(line["text"]) * 3.5))))
+                    ref = ref.cpu().numpy().reshape(-1)
+                    frames = max(16, int(round(ref.size / 3528)))
+                    y = _ar(mm, sampler, line["text"], task_prompt, latent,
+                            v["prompt_text"], spk, frames)
+                else:
+                    y = tts.synthesize(task="TTS", text=line["text"], language_id="Chinese",
+                                       prompt_wav_path=wav_path, prompt_text=v["prompt_text"],
+                                       use_spk_emb=True, raw_text=True,
+                                       max_decode_steps=max(32, min(400, int(len(line["text"]) * 3.5))))
+                    y = y.cpu().numpy().reshape(-1)
+            except Exception:
+                log(f"{tag} line {line['index']} failed\n{traceback.format_exc()}")
+                continue
+            wall = time.time() - t0
+            p = OUT / "lines" / f"{tag}_{line['index']:02d}.wav"
+            sf.write(str(p), y, SR)
+            rows.append({**line, "seconds": round(y.size / SR, 2), "wall": round(wall, 1),
+                         "rtf": round(wall / max(1e-6, y.size / SR), 2),
+                         "wav": str(p)})
+            log(f"{tag} {line['index']} {line['style']} {y.size/SR:.2f}s wall {wall:.1f}s")
+            pieces.append(y)
+            pieces.append(np.zeros(int(GAP_S * SR), dtype=np.float32))
+
+        if not pieces:
+            return {"rows": [], "seconds": 0}
+        full = np.concatenate(pieces[:-1])
+        peak = float(np.abs(full).max()) or 1.0
+        full = (full / peak * 0.92).astype(np.float32)
+        sf.write(str(OUT / f"radio_{tag}.wav"), full, SR)
+        return {"rows": rows, "seconds": round(full.size / SR, 1)}
+
+    teacher = render("teacher", use_student=False)
+    report["renders"]["teacher"] = teacher
+    log(f"teacher segment: {teacher['seconds']}s, {len(teacher['rows'])} lines")
+
+    student = render("student", use_student=True)
+    report["renders"]["student"] = student
+    log(f"student segment: {student['seconds']}s, {len(student['rows'])} lines")
+
+    # Transcribe once at the end: whisper is ~1 GB and does not need to be
+    # resident while the two DiTs and the backbone are generating.
+    asr = pipeline("automatic-speech-recognition", model="openai/whisper-small",
+                   device=0, torch_dtype=torch.float16)
+
+    def transcribe(y):
+        out = asr({"array": y.astype(np.float32), "sampling_rate": SR},
+                  generate_kwargs={"language": "zh", "task": "transcribe"})
+        return (out.get("text", "") if isinstance(out, dict) else str(out)).strip()
+
+    for tag in ("teacher", "student"):
+        rs = report["renders"][tag]["rows"]
+        for r in rs:
+            y, _ = sf.read(r["wav"], dtype="float32")
+            r["hyp"] = transcribe(y)
+            r["cer"] = score_row({"text": r["text"], "hyp_text": r["hyp"]}, table)["cer_norm"]
+        if rs:
+            log(f"{tag}: mean cer {np.mean([r['cer'] for r in rs]):.3f} "
+                f"mean rtf {np.mean([r['rtf'] for r in rs]):.2f}")
+
+    (OUT / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=1))
+    log("done")
+
+
+def _ar(mm, sampler, text, task_prompt, prompt_latent, prompt_text, spk, frames):
+    import torch
+
+    device = next(mm.parameters()).device
+    dtype = next(mm.parameters()).dtype
+    with torch.no_grad():
+        input_ids, inputs_embeds = mm.prepare_input_embed(
+            prompt=task_prompt, text=text, spk_emb=spk,
+            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
+    hist = torch.zeros(1, mm.history_patch_size, mm.latent_dim, device=device, dtype=dtype)
+    start = mm.history_patch_size - prompt_latent.size(1)
+    if start < 0:
+        hist[:] = prompt_latent[:, -start:, :]
+    else:
+        hist[:, start:, :] = prompt_latent
+    out = []
+    for _ in range(frames):
+        with torch.no_grad():
+            hidden = 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 = hidden.past_key_values
+        z = hidden.hidden_states[-1][:, -1:, :]
+        noise = torch.randn(1, 1, mm.latent_dim, device=device, dtype=dtype)
+        with torch.no_grad():
+            latent = sampler(z, hist, noise).to(device=device, dtype=dtype)
+        out.append(latent.detach())
+        inputs_embeds = mm.linear_proj_audio(latent)
+        position_ids = position_ids[:, -1:] + 1
+        attention_mask = torch.ones(inputs_embeds.shape[0], 1, device=device)
+        hist[:, :-mm.patch_size, :] = hist[:, mm.patch_size:, :].clone()
+        hist[:, -mm.patch_size:, :] = latent
+    with torch.no_grad():
+        speech = mm.audio.decode(torch.cat(out, dim=1), past_key_values=None,
+                                 use_cache=False, last_chunk=True)[0]
+    return speech.cpu().float().reshape(-1).numpy()
+
+
+if __name__ == "__main__":
+    main()