notforu777's picture
TTS -> ASR round trip: results, per-clip rows, MP3 clips, tensor types, logs, scripts (part 6)
ba8139c verified
Raw History Blame Contribute Delete
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()