fix deps: install requirement set, self-heal imports, add smoke stage

kaggle/notebook_eval.py

@@ -1,26 +1,26 @@
 """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.
+Pulled and executed by the kernel `kkonda/webfm-ming-tts-eval`, which does
+nothing but snapshot_download idefinity/webfm-eval and exec this file. The run
+logic lives here so it can change without touching the kernel.
+
+Stages, in order:
+
+  1. install the pinned runtime, then prove `from ming_tts import MingTTS`
+     imports — repairing missing modules by name, because guessing the
+     transitive dependency set is how the first run died on `loguru`
+  2. clone the repo at the pinned commit, download weights, pull the bundle
+  3. bake prompt_latent / speaker_emb for the eight WebFM voices
+  4. smoke: one voice, two sentences, teacher + 3step. Cheaper to find API
+     drift here than 40 minutes into the matrix
+  5. the full matrix, one voice shard per visible GPU
+  6. score
+
+Everything writes into /kaggle/working; ming_eval.py skips cells that already
+have a row, so a killed session keeps its progress.
 """
 import os
+import re
 import subprocess
 import sys
 import time
@@ -36,6 +36,15 @@ BUNDLE_REPO = "idefinity/webfm-eval"
 MODELS = "teacher,3step,4step"
 HF_MIRROR = "https://hf-mirror.com"
 
+# requirements.txt at PIN, minus torch/torchaudio: Kaggle ships a newer CUDA
+# build and downgrading it would cost the session.
+DEPS = [
+    "transformers==4.46.3", "tokenizers", "accelerate==1.3.0", "huggingface_hub",
+    "soundfile==0.12.1", "tqdm", "loguru", "x_transformers==2.9.2",
+    "diffusers==0.33.0", "onnxruntime", "onnx", "inflect", "einops", "packaging",
+]
+ALIASES = {"cv2": "opencv-python", "yaml": "pyyaml", "PIL": "pillow", "sklearn": "scikit-learn"}
+
 
 def sh(cmd: str, check: bool = True, env: dict | None = None) -> int:
     print(f"\n$ {cmd}", flush=True)
@@ -45,35 +54,56 @@ def sh(cmd: str, check: bool = True, env: dict | None = None) -> int:
     return rc
 
 
+def pip(*pkgs: str) -> None:
+    sh("pip install -q " + " ".join(f'"{p}"' for p in pkgs), check=False)
+
+
 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}')"
-    )
+    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)
+        sh(f'python3 -c "{code}"', env=dict(os.environ, HF_ENDPOINT=HF_MIRROR))
+
 
+def stage_repo() -> None:
+    """Clone before the import probe, which imports from this directory."""
+    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")
 
-def stage_setup() -> None:
+
+def stage_deps() -> 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")
+    pip(*DEPS)
+    probe = ("import sys; sys.path.insert(0, r'%s'); from ming_tts import MingTTS; "
+             "print('import ok')" % REPO)
+    for attempt in range(6):
+        r = subprocess.run([sys.executable, "-c", probe], capture_output=True, text=True)
+        if r.returncode == 0:
+            print("ming_tts imports cleanly")
+            return
+        m = re.search(r"No module named '([^']+)'", r.stderr)
+        if not m:
+            print(r.stderr[-3000:])
+            raise SystemExit("ming_tts import failed for a reason pip cannot repair")
+        missing = m.group(1).split(".")[0]
+        pkg = ALIASES.get(missing, missing)
+        print(f"[{attempt+1}] missing '{missing}' -> installing '{pkg}'")
+        pip(pkg)
+    raise SystemExit("could not satisfy ming_tts imports")
+
+
+def stage_prepare() -> None:
     pull(WEIGHTS, MODEL)
     pull(BUNDLE_REPO, BUNDLE, repo_type="dataset")
 
@@ -85,33 +115,48 @@ def stage_bake() -> None:
     sh(f"cd {ROOT} && EVAL_DATA={BUNDLE} python3 {BUNDLE}/kaggle/bake_voices.py")
 
 
+def run_eval(tag: str, voices: list[str], models: str, limit: int, gpu: int = 0) -> subprocess.Popen:
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu), EVAL_DATA=str(BUNDLE),
+               VOICES=",".join(voices), MODELS=models, LIMIT=str(limit))
+    log = open(ROOT / f"eval_{tag}.log", "w")
+    return subprocess.Popen([sys.executable, str(BUNDLE / "kaggle/ming_eval.py")],
+                            env=env, stdout=log, stderr=subprocess.STDOUT, cwd=str(ROOT))
+
+
+def stage_smoke() -> None:
+    """One voice, two sentences. Catches API drift before the long run."""
+    if (ROOT / "smoke.ok").exists():
+        return
+    p = run_eval("smoke", ["v01"], "teacher,3step", 2)
+    p.wait()
+    rows = ROOT / "ming_eval/results.jsonl"
+    n = sum(1 for _ in rows.open()) if rows.exists() else 0
+    if n < 4:
+        print((ROOT / "eval_smoke.log").read_text()[-4000:])
+        raise SystemExit(f"smoke produced {n} rows, expected at least 4")
+    (ROOT / "smoke.ok").write_text("ok")
+    print(f"smoke ok ({n} rows)")
+
+
 def stage_eval() -> None:
     import torch
 
-    n = max(1, torch.cuda.device_count())
+    n_gpu = 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))
+    shards = [voices[i::n_gpu] for i in range(n_gpu)]
+    print(f"{n_gpu} GPU(s), shards: {shards}")
 
+    procs = [(gpu, run_eval(f"gpu{gpu}", shard, MODELS, 40, gpu))
+             for gpu, shard in enumerate(shards)]
     last = 0.0
-    while any(p.poll() is None for _, p, _ in procs):
+    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()
+        n = sum(1 for _ in rows.open()) if rows.exists() else 0
+        if n != last:
+            print(f"[{time.strftime('%H:%M')}] rows={n}", flush=True)
+            last = n
+    for gpu, p in procs:
         print(f"gpu{gpu} exit={p.returncode}")
 
 
@@ -122,8 +167,11 @@ def stage_score() -> None:
 
 
 if __name__ == "__main__":
-    stage_setup()
+    stage_repo()
+    stage_deps()
+    stage_prepare()
     stage_bake()
+    stage_smoke()
     stage_eval()
     stage_score()
     print("\nartifacts: baked/, ming_eval/results.jsonl, ming_eval/summary.json, ming_eval/wav/")