radio: student reuses teacher frames; parse malformed script JSON

kaggle/radio_demo.py

@@ -93,10 +93,8 @@ def write_script() -> tuple[list[dict], str]:
         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")]
-        # Three usable lines is a valid answer; the previous >=4 gate rejected a
+        rows = parse_script(raw)
+        # Three usable lines is a valid answer; an earlier >=4 gate rejected a
         # correct three-line script and silently used the fallback.
         if len(rows) >= 3:
             return rows[:8], "llm"
@@ -105,6 +103,28 @@ def write_script() -> tuple[list[dict], str]:
     return FALLBACK, "fallback"
 
 
+def parse_script(raw: str) -> list[dict]:
+    """Pull style/text pairs out of the model's answer.
+
+    A 1.5B instruct model reliably writes the fields but not reliably the
+    punctuation: one observed answer dropped a closing brace and the whole
+    array stopped being JSON. Scanning for the pairs survives that, while
+    `json.loads` cannot.
+    """
+    pairs = re.findall(r'"style"\s*:\s*"([^"]*)"\s*,\s*"text"\s*:\s*"([^"]*)"', raw)
+    if not pairs:
+        pairs = [(s, t) for t, s in re.findall(
+            r'"text"\s*:\s*"([^"]*)"\s*,\s*"style"\s*:\s*"([^"]*)"', raw)]
+    out = [{"style": s or "叙述", "text": t} for s, t in pairs if t.strip()]
+    if not out:
+        try:
+            rows = json.loads(re.search(r"\[.*\]", raw, re.S).group(0))
+            out = [r for r in rows if isinstance(r, dict) and r.get("text")]
+        except Exception:
+            pass
+    return out
+
+
 def cast(rows: list[dict]) -> list[dict]:
     """Assign a voice to each line and keep the plan explicit in the report."""
     out = []
@@ -145,7 +165,7 @@ def main() -> None:
     tts = MingTTS(str(MODEL), device="cuda", text_normalization=False)
     report = {"script_source": source, "lines": [], "renders": {}}
 
-    def render(tag: str, use_student: bool) -> dict:
+    def render(tag: str, use_student: bool, frames_by_index: dict | None = None) -> dict:
         import copy
 
         mm = tts.model
@@ -177,12 +197,15 @@ def main() -> None:
                     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)))
+                    # Reuse the teacher's own frame count. Synthesising the
+                    # teacher again to measure length gives a different take -
+                    # 25 frames vs 16 on a whisper line - and a wrong budget
+                    # makes the student drift into a loop or into silence.
+                    frames = (frames_by_index or {}).get(line["index"])
+                    if not frames:
+                        log(f"{tag} line {line['index']} skipped: no teacher frames")
+                        continue
+                    torch.manual_seed(SEED + line["index"])
                     y = _ar(mm, sampler, line["text"], task_prompt, latent,
                             v["prompt_text"], spk, frames)
                 else:
@@ -198,6 +221,7 @@ def main() -> None:
             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),
+                         "frames": max(1, int(round(y.size / 3528))),
                          "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")
@@ -216,7 +240,8 @@ def main() -> None:
     report["renders"]["teacher"] = teacher
     log(f"teacher segment: {teacher['seconds']}s, {len(teacher['rows'])} lines")
 
-    student = render("student", use_student=True)
+    frames = {r["index"]: r["frames"] for r in teacher["rows"]}
+    student = render("student", use_student=True, frames_by_index=frames)
     report["renders"]["student"] = student
     log(f"student segment: {student['seconds']}s, {len(student['rows'])} lines")