add notebook_eval bootstrap target

kaggle/notebook_eval.py

@@ -0,0 +1,129 @@
+"""Kaggle notebook body for the WebFM eval run. Not imported by the app.
+
+Push with:
+  mcp__kaggle__save_notebook(text=<this file>, slug="webfm-ming-eval",
+                             enableGpu=True, machineShape="T4x2",
+                             enableInternet=True, kernelExecutionType="SaveAndRunAll")
+
+It does four things, in this order:
+
+  1. pin and prepare the Ming repo + weights
+  2. bake prompt_latent / speaker_emb for the eight WebFM voices
+     (small enough to ship; needed by the browser regardless of what the
+     model work decides)
+  3. run the eval matrix, one voice shard per visible GPU
+  4. score it and print the table
+
+Every stage writes into /kaggle/working, so a killed session keeps whatever it
+finished; ming_eval.py skips cells that already have a row.
+
+Deliberately tolerant: a failed commit checkout or a single-GPU machine does not
+abort the run, because each of those costs a whole session otherwise.
+"""
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path("/kaggle/working")
+REPO = ROOT / "Ming-3.0-tts"
+MODEL = ROOT / "Ming-3.0-tts-0.5b"
+BUNDLE = ROOT / "webfm-eval"
+PIN = "e999c39"
+WEIGHTS = "inclusionAI/Ming-3.0-tts-0.5B"
+BUNDLE_REPO = "idefinity/webfm-eval"
+MODELS = "teacher,3step,4step"
+HF_MIRROR = "https://hf-mirror.com"
+
+
+def sh(cmd: str, check: bool = True, env: dict | None = None) -> int:
+    print(f"\n$ {cmd}", flush=True)
+    rc = subprocess.run(cmd, shell=True, text=True, env=env).returncode
+    if check and rc != 0:
+        raise SystemExit(f"command failed ({rc}): {cmd}")
+    return rc
+
+
+def pull(repo_id: str, local_dir: Path, repo_type: str = "model") -> None:
+    """snapshot_download with a mirror retry; Kaggle usually reaches HF direct."""
+    if local_dir.exists() and any(local_dir.iterdir()):
+        print(f"{local_dir} already populated")
+        return
+    code = (
+        "from huggingface_hub import snapshot_download as s; "
+        f"s('{repo_id}', local_dir=r'{local_dir}', repo_type='{repo_type}')"
+    )
+    if sh(f'python3 -c "{code}"', check=False) != 0:
+        print("direct download failed, retrying through hf-mirror")
+        env = dict(os.environ, HF_ENDPOINT=HF_MIRROR)
+        sh(f'python3 -c "{code}"', env=env)
+
+
+def stage_setup() -> None:
+    sh("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader")
+    import torch
+
+    print("torch", torch.__version__, "cuda", torch.cuda.is_available(),
+          "devices", torch.cuda.device_count())
+
+    if not REPO.exists():
+        sh(f"git clone https://github.com/inclusionAI/Ming-3.0-tts.git {REPO}")
+    if sh(f"git -C {REPO} checkout {PIN}", check=False) != 0:
+        print(f"WARNING: commit {PIN} not found, staying on the default branch")
+
+    sh("pip install -q torchaudio soundfile onnx onnxruntime-gpu huggingface_hub "
+       "transformers==4.46.3 accelerate")
+    pull(WEIGHTS, MODEL)
+    pull(BUNDLE_REPO, BUNDLE, repo_type="dataset")
+
+
+def stage_bake() -> None:
+    if (ROOT / "baked/voices_baked.npz").exists():
+        print("voices already baked, skipping")
+        return
+    sh(f"cd {ROOT} && EVAL_DATA={BUNDLE} python3 {BUNDLE}/kaggle/bake_voices.py")
+
+
+def stage_eval() -> None:
+    import torch
+
+    n = max(1, torch.cuda.device_count())
+    voices = [f"v{i:02d}" for i in range(1, 9)]
+    shards = [voices[i::n] for i in range(n)]
+    print(f"{n} GPU(s), shards: {shards}")
+
+    procs = []
+    for gpu, shard in enumerate(shards):
+        env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu),
+                   EVAL_DATA=str(BUNDLE), VOICES=",".join(shard), MODELS=MODELS)
+        log = open(ROOT / f"eval_gpu{gpu}.log", "w")
+        procs.append((gpu, subprocess.Popen(
+            [sys.executable, str(BUNDLE / "kaggle/ming_eval.py")],
+            env=env, stdout=log, stderr=subprocess.STDOUT, cwd=str(ROOT)), log))
+
+    last = 0.0
+    while any(p.poll() is None for _, p, _ in procs):
+        time.sleep(60)
+        rows = ROOT / "ming_eval/results.jsonl"
+        n_rows = sum(1 for _ in rows.open()) if rows.exists() else 0
+        if n_rows != last:
+            print(f"[{time.strftime('%H:%M')}] rows={n_rows}", flush=True)
+            last = n_rows
+    for gpu, p, log in procs:
+        log.close()
+        print(f"gpu{gpu} exit={p.returncode}")
+
+
+def stage_score() -> None:
+    sh(f"python3 {BUNDLE}/eval/score.py aggregate "
+       f"--results {ROOT}/ming_eval/results.jsonl --baseline teacher --by-bucket "
+       f"--out {ROOT}/ming_eval/summary.json", check=False)
+
+
+if __name__ == "__main__":
+    stage_setup()
+    stage_bake()
+    stage_eval()
+    stage_score()
+    print("\nartifacts: baked/, ming_eval/results.jsonl, ming_eval/summary.json, ming_eval/wav/")