| """Kaggle notebook body for the WebFM eval run. Not imported by the app. |
| |
| 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 |
| 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" |
|
|
| |
| |
| 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", "onnx_ir", "onnxscript", |
| "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) |
| 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 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: |
| 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") |
| 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_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()) |
|
|
| 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") |
|
|
|
|
| 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 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_gpu = max(1, torch.cuda.device_count()) |
| voices = [f"v{i:02d}" for i in range(1, 9)] |
| 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): |
| time.sleep(60) |
| rows = ROOT / "ming_eval/results.jsonl" |
| 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}") |
|
|
|
|
| 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_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/") |
|
|
