holdout run: exclude a07 from training, add int4 eval stage

kaggle/train_voices.py

@@ -42,6 +42,7 @@ BATCH = int(os.environ.get("BATCH", "16"))
 LR = float(os.environ.get("LR", "1e-4"))
 VOICE_FILTER = [v for v in os.environ.get("VOICES", "").split(",") if v]
 EVAL_VOICES = [v for v in os.environ.get("EVAL_VOICES", "").split(",") if v]
+HOLDOUT = {v for v in os.environ.get("HOLDOUT", "").split(",") if v}
 N_TEXTS = int(os.environ.get("N_TEXTS", "120"))
 SMOKE = os.environ.get("SMOKE", "0") == "1"
 
@@ -64,9 +65,11 @@ def patch_fp32() -> None:
         path.write_text(s)
 
 
-def voices() -> list[dict]:
+def voices(include_holdout: bool = False) -> list[dict]:
     vs = json.loads((BUNDLE / "mined/manifest.json").read_text())["voices"]
     vs = [v for v in vs if v["artist"] not in DROP]
+    if not include_holdout:
+        vs = [v for v in vs if v["slot"] not in HOLDOUT]
     if VOICE_FILTER:
         vs = [v for v in vs if v["slot"] in VOICE_FILTER]
     return vs
@@ -281,7 +284,7 @@ def sample_latent(dit, z, hist, noise, n_steps):
     return y
 
 
-def ar_generate(mm, dit, n_steps, text, task_prompt, prompt_latent, prompt_text, spk, frames):
+def ar_generate(mm, sample_fn, text, task_prompt, prompt_latent, prompt_text, spk, frames):
     import torch
 
     device = next(mm.parameters()).device
@@ -313,7 +316,7 @@ def ar_generate(mm, dit, n_steps, text, task_prompt, prompt_latent, prompt_text,
         # no_grad matters: the DiT params require grad, so an unguarded sample
         # builds a graph per frame that stays alive through `hist`.
         with torch.no_grad():
-            latent = sample_latent(dit, z, hist, noise, n_steps).to(device=device, dtype=dtype)
+            latent = sample_fn(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
@@ -357,7 +360,7 @@ def stage_eval() -> None:
 
     sents = json.loads((BUNDLE / "eval/sentences.json").read_text())["items"]
     want = EVAL_VOICES or [v["slot"] for v in voices()[:2]]
-    sel = [x for x in voices() if x["slot"] in want]
+    sel = [x for x in voices(include_holdout=True) if x["slot"] in want]
     wav_dir = OUT / "eval_wavs"
     wav_dir.mkdir(parents=True, exist_ok=True)
     rows = []
@@ -410,8 +413,8 @@ def stage_eval() -> None:
                 tw = torch.load(tp, map_location="cpu").numpy()
                 frames = max(16, int(round(tw.size / 3528)))
                 torch.manual_seed(SEED)
-                sw = ar_generate(mm, student, STEPS, text, task_prompt, latent,
-                                 v["prompt_text"], spk, frames)
+                sw = ar_generate(mm, lambda z, h, n: sample_latent(student, z, h, n, STEPS),
+                                 text, task_prompt, latent, v["prompt_text"], spk, frames)
                 hyp = asr(sw)
                 s = score_row({"text": text, "hyp_text": hyp}, table)
                 rows.append({"voice": v["slot"], "artist": v["artist"], "id": item["id"],
@@ -433,6 +436,89 @@ def stage_eval() -> None:
             log(f"   {v} n={len(vs)} cer={np.mean(vs):.4f}")
 
 
+def stage_eval_int4() -> None:
+    """Same cells as stage_eval, sampled through the int4 ONNX graph.
+
+    Runs as its own process so the PyTorch DiT is not resident: the ORT session
+    plus the backbone is already close to a 15 GB T4.
+    """
+    import onnxruntime as ort
+    import torch
+    from transformers import pipeline
+
+    sys.path.insert(0, str(REPO))
+    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()
+    model_path = OUT / f"dit{STEPS}_int4.onnx"
+    if not model_path.exists():
+        raise SystemExit(f"{model_path} missing")
+    sess = ort.InferenceSession(str(model_path), providers=["CUDAExecutionProvider"])
+    log(f"int4 session providers: {sess.get_providers()}")
+
+    def ort_sample(z, hist, noise):
+        times = [i / STEPS for i in range(STEPS + 1)]
+        y = noise.detach().cpu().numpy()
+        zc, hc = z.detach().cpu().numpy(), hist.detach().cpu().numpy()
+        for i in range(STEPS):
+            v = sess.run(None, {"x": y, "t": np.array([times[i]], np.float32),
+                                "c": zc, "history": hc})[0]
+            y = y + v * (times[i + 1] - times[i])
+        return torch.from_numpy(y)
+
+    tts = MingTTS(str(MODEL), device="cuda", text_normalization=False)
+    mm = tts.model
+    device = next(mm.parameters()).device
+    dtype = next(mm.parameters()).dtype
+    task_prompt = tts_tasks.build_tts_prompt("Chinese")
+    asr_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-small",
+                        device=0, torch_dtype=torch.float16)
+
+    def asr(y):
+        out = asr_pipe({"array": y.astype(np.float32), "sampling_rate": 44100},
+                       generate_kwargs={"language": "zh", "task": "transcribe"})
+        return (out.get("text", "") if isinstance(out, dict) else str(out)).strip()
+
+    sents = json.loads((BUNDLE / "eval/sentences.json").read_text())["items"]
+    want = EVAL_VOICES or [v["slot"] for v in voices(include_holdout=True)[:2]]
+    wav_dir = OUT / "eval_wavs"
+    rows = []
+    for v in [x for x in voices(include_holdout=True) if x["slot"] in want]:
+        latent, spk = tts.prepare_prompt(str(BUNDLE / v["wav"]), use_spk_emb=True)
+        latent = latent.to(device=device, dtype=dtype)
+        spk = [x.to(device=device, dtype=dtype) for x in spk]
+        for item in sents:
+            text = item["text"]
+            try:
+                tp = wav_dir / f"{v['slot']}_{item['id']}_teacher.pt"
+                tw = torch.load(tp, map_location="cpu").numpy()
+                frames = max(16, int(round(tw.size / 3528)))
+                torch.manual_seed(SEED)
+                sw = ar_generate(mm, ort_sample, text, task_prompt, latent,
+                                 v["prompt_text"], spk, frames)
+                hyp = asr(sw)
+                s = score_row({"text": text, "hyp_text": hyp}, table)
+                rows.append({"voice": v["slot"], "artist": v["artist"], "id": item["id"],
+                             "model": "int4", "text": text, "cer": s["cer_norm"],
+                             "cer_head": s["cer_prefix"], "hyp": hyp})
+            except Exception:
+                log(f"int4 {v['slot']} {item['id']} failed\n{traceback.format_exc()}")
+            torch.cuda.empty_cache()
+        log(f"int4 {v['slot']} done ({len(rows)} rows)")
+
+    (OUT / "eval_rows_int4.json").write_text(json.dumps(rows, ensure_ascii=False, indent=1))
+    sel_rows = rows
+    if sel_rows:
+        log(f"int4     n={len(sel_rows)} cer={np.mean([r['cer'] for r in sel_rows]):.4f} "
+            f"head={np.mean([r['cer_head'] for r in sel_rows]):.4f}")
+    for v in sorted({r["voice"] for r in sel_rows}):
+        vs = [r["cer"] for r in sel_rows if r["voice"] == v]
+        log(f"   {v} n={len(vs)} cer={np.mean(vs):.4f}")
+
+
 def main() -> None:
     import torch
 
@@ -446,6 +532,11 @@ def main() -> None:
         stage_traj()
         return
 
+    if STAGE == "eval_int4":
+        patch_fp32()
+        stage_eval_int4()
+        return
+
     sys.path.insert(0, str(REPO))
     patch_fp32()
     from ming_tts import MingTTS