TTS -> ASR round trip: results, per-clip rows, MP3 clips, tensor types, logs, scripts (part 6)
ba8139c verified Download scripts/eval_tts.py from AtomicChat/ZONOS3-Mini-GGUF-metrics: direct link, hf CLI and curl.
- Browser
- Download file 9.32 kB
-
https://huggingface.co/datasets/AtomicChat/ZONOS3-Mini-GGUF-metrics/resolve/main/scripts/eval_tts.py
- Command line
-
hf download hf://datasets/AtomicChat/ZONOS3-Mini-GGUF-metrics/scripts/eval_tts.py
-
curl -L -o eval_tts.py https://huggingface.co/datasets/AtomicChat/ZONOS3-Mini-GGUF-metrics/resolve/main/scripts/eval_tts.py
9.32 kB
| #!/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() | |