#!/usr/bin/env python3 """TTS -> ASR round trip for ZONOS3-Mini GGUF rungs (one stand: same box, build, mmproj, texts, voices, seeds). For every rung x language x sentence x seed: llama-tts writes a WAV; Whisper large-v3-turbo transcribes it (CER, and WER for space-separated languages); WavLM-base-plus-sv gives the cosine to the voice's reference clip. Per rung and language: means, runaway/failed generations, and the paired difference to BF16 with a bootstrap over sentences (seeds of one sentence move together), so a gap is read against the sampling noise. usage: eval_tts.py --out DIR --mmproj F --rung NAME=PATH [--rung ...] [--seeds 1 2 3] [--jobs 4] [--stage gen|asr|all] """ import argparse, json, os, random, re, subprocess, sys, time, unicodedata from concurrent.futures import ThreadPoolExecutor from pathlib import Path HERE = Path(__file__).resolve().parent SRC = Path("/root/zonos3-src") TTS = "/root/llama.cpp/build/bin/llama-tts" MAX_FRAMES = 600 # 600 x 2940 / 44100 = 40 s; a sentence here takes 3-8 s FRAME_S = 2940 / 44100 def norm(s, lang): s = unicodedata.normalize("NFKC", s).lower() s = "".join(" " if unicodedata.category(c)[0] in "PS" else c for c in s) s = re.sub(r"\s+", " ", s).strip() return s.replace(" ", "") if lang == "zh" else s def lev(a, b): if len(a) < len(b): a, b = b, a prev = list(range(len(b) + 1)) for i, ca in enumerate(a, 1): cur = [i] for j, cb in enumerate(b, 1): cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb))) prev = cur return prev[-1] def gen_one(job): rung, path, mmproj, lang, voice, idx, text, seed, wav = job if wav.exists() and wav.stat().st_size > 1000: return {"skip": True} t0 = time.time() r = subprocess.run([TTS, "-m", path, "-mm", mmproj, "-ngl", "99", "-p", text, "--tts-voice", voice, "-s", str(seed), "-n", str(MAX_FRAMES), "--output", str(wav)], capture_output=True, text=True, timeout=600) rec = {"rung": rung, "lang": lang, "idx": idx, "seed": seed, "rc": r.returncode, "gen_s": round(time.time() - t0, 2)} if r.returncode != 0 or not wav.exists(): rec["err"] = (r.stderr or r.stdout)[-600:] return rec def stage_gen(a, sents, rungs): jobs = [] for rung, path in rungs: for lang, d in sents.items(): for idx, text in enumerate(d["texts"]): for seed in a.seeds: wav = Path(a.out) / "wav" / rung / f"{lang}_{idx:02d}_s{seed}.wav" wav.parent.mkdir(parents=True, exist_ok=True) jobs.append((rung, path, a.mmproj, lang, d["voice"], idx, text, seed, wav)) log = open(Path(a.out) / "gen.jsonl", "a") t0, done = time.time(), 0 with ThreadPoolExecutor(a.jobs) as ex: for rec in ex.map(gen_one, jobs): done += 1 if not rec.get("skip"): log.write(json.dumps(rec) + "\n"); log.flush() if rec["rc"] != 0: print("GEN FAIL", rec, flush=True) if done % 50 == 0: print(f"gen {done}/{len(jobs)} {time.time() - t0:.0f}s", flush=True) def load16(path): import numpy as np, soundfile as sf from scipy.signal import resample_poly x, sr = sf.read(str(path), dtype="float32", always_2d=True) x = x.mean(axis=1) if sr != 16000: from math import gcd g = gcd(sr, 16000) x = resample_poly(x, 16000 // g, sr // g).astype("float32") return x, len(x) / 16000 def stage_asr(a, sents, rungs): import numpy as np, torch from transformers import pipeline, AutoFeatureExtractor, WavLMForXVector asr = pipeline("automatic-speech-recognition", model="openai/whisper-large-v3-turbo", torch_dtype=torch.float16, device=0) fe = AutoFeatureExtractor.from_pretrained("microsoft/wavlm-base-plus-sv") sv = WavLMForXVector.from_pretrained("microsoft/wavlm-base-plus-sv").cuda().eval() def emb(x): with torch.no_grad(): inp = fe([x], sampling_rate=16000, return_tensors="pt", padding=True).to("cuda") e = sv(**inp).embeddings[0] return torch.nn.functional.normalize(e, dim=-1).cpu() refs = {lang: emb(load16(SRC / d["ref"])[0]) for lang, d in sents.items()} rows = [] for rung, _ in rungs: for lang, d in sents.items(): items = [] for idx, text in enumerate(d["texts"]): for seed in a.seeds: wav = Path(a.out) / "wav" / rung / f"{lang}_{idx:02d}_s{seed}.wav" if wav.exists(): x, dur = load16(wav) items.append((idx, seed, text, x, dur)) else: rows.append({"rung": rung, "lang": lang, "idx": idx, "seed": seed, "missing": True}) outs = asr([{"raw": it[3], "sampling_rate": 16000} for it in items], batch_size=16, generate_kwargs={"language": d["whisper"], "task": "transcribe"}) for (idx, seed, text, x, dur), o in zip(items, outs): hyp, ref = norm(o["text"], lang), norm(text, lang) row = {"rung": rung, "lang": lang, "idx": idx, "seed": seed, "dur": round(dur, 2), "runaway": dur >= (MAX_FRAMES - 2) * FRAME_S, "hyp": o["text"].strip(), "cer": lev(hyp, ref) / max(1, len(ref)), "sim": float(emb(x) @ refs[lang]) if len(x) > 1600 else 0.0} if lang != "zh": row["wer"] = lev(hyp.split(), ref.split()) / max(1, len(ref.split())) rows.append(row) print(f"asr {rung} {lang}: {len(items)} clips", flush=True) with open(Path(a.out) / "asr.jsonl", "w") as f: for r in rows: f.write(json.dumps(r, ensure_ascii=False) + "\n") summarize(a, rows, rungs, sents) def boot_diff(pairs, n=2000): """pairs: {idx: [(rung_value, base_value), ...]}; bootstrap over sentences -> (mean diff, lo, hi).""" keys = list(pairs) def m(ks): v = [r - b for k in ks for r, b in pairs[k]] return sum(v) / len(v) rnd = random.Random(0) bs = sorted(m([rnd.choice(keys) for _ in keys]) for _ in range(n)) return m(keys), bs[int(0.025 * n)], bs[int(0.975 * n)] def summarize(a, rows, rungs, sents): base = rungs[0][0] by = {} for r in rows: by.setdefault((r["rung"], r["lang"]), []).append(r) out, lines = {}, [] hdr = f"{'rung':16s} {'lang':4s} {'n':>4s} {'miss':>4s} {'runaway':>7s} {'CER%':>6s} {'dCER [95%]':>22s} {'WER%':>6s} {'sim':>6s} {'dsim [95%]':>24s} {'dur':>5s}" lines.append(hdr) for rung, _ in rungs: for lang in sents: rs = by.get((rung, lang), []) ok = [r for r in rs if not r.get("missing")] if not ok: continue s = {"n": len(ok), "missing": len(rs) - len(ok), "runaway": sum(r["runaway"] for r in ok), "cer": sum(r["cer"] for r in ok) / len(ok), "sim": sum(r["sim"] for r in ok) / len(ok), "dur": sum(r["dur"] for r in ok) / len(ok)} if lang != "zh": s["wer"] = sum(r["wer"] for r in ok) / len(ok) bmap = {(r["idx"], r["seed"]): r for r in by.get((base, lang), []) if not r.get("missing")} for key in ("cer", "sim"): pairs = {} for r in ok: b = bmap.get((r["idx"], r["seed"])) if b: pairs.setdefault(r["idx"], []).append((r[key], b[key])) if pairs and rung != base: s[f"d{key}"] = boot_diff(pairs) out[f"{rung}/{lang}"] = s dc = s.get("dcer"); ds = s.get("dsim") lines.append(f"{rung:16s} {lang:4s} {s['n']:4d} {s['missing']:4d} {s['runaway']:7d} {100 * s['cer']:6.2f} " + (f"{100 * dc[0]:+6.2f} [{100 * dc[1]:+5.2f},{100 * dc[2]:+5.2f}]" if dc else " " * 22) + f" {100 * s.get('wer', float('nan')):6.2f} {s['sim']:6.3f} " + (f"{ds[0]:+6.3f} [{ds[1]:+6.3f},{ds[2]:+6.3f}]" if ds else " " * 24) + f" {s['dur']:5.2f}") json.dump(out, open(Path(a.out) / "summary.json", "w"), indent=1) open(Path(a.out) / "summary.txt", "w").write("\n".join(lines) + "\n") print("\n".join(lines), flush=True) def main(): ap = argparse.ArgumentParser() ap.add_argument("--out", required=True) ap.add_argument("--mmproj", required=True) ap.add_argument("--rung", action="append", required=True, help="NAME=PATH; the first one is the reference") ap.add_argument("--seeds", type=int, nargs="+", default=[1, 2, 3]) ap.add_argument("--jobs", type=int, default=4) ap.add_argument("--stage", default="all", choices=["gen", "asr", "all"]) a = ap.parse_args() sents = json.load(open(HERE / "sentences.json")) rungs = [tuple(r.split("=", 1)) for r in a.rung] os.makedirs(a.out, exist_ok=True) if a.stage in ("gen", "all"): stage_gen(a, sents, rungs) if a.stage in ("asr", "all"): stage_asr(a, sents, rungs) if __name__ == "__main__": main()