webfm eval set: 40 sentences, 8 voice prompts, scoring harness

README.md

@@ -0,0 +1,58 @@
+---
+license: mit
+language:
+  - zh
+tags:
+  - text-to-speech
+  - evaluation
+  - webfm
+---
+
+# webfm-eval
+
+Fixed evaluation set and harness for the WebFM TTS work. Small on purpose: it
+exists so two model tiers can be compared on the same sentences in the same
+run, not to be trained on.
+
+## Contents
+
+```
+eval/sentences.json      40 sentences, 7 buckets (short / medium / long /
+                         number / latin / polyphone / narration)
+eval/score.py            raw + normalised CER, prefix CER, per-bucket and
+                         per-voice aggregation, delta against a baseline
+eval/t2s.json            traditional -> simplified table, used only when
+                         opencc is unavailable
+config/ming_voices.json  the eight WebFM voices and their prompt transcripts
+refs/wav/v01..v08.wav    prompt clips, reconstructed from the shipped F5
+                         reference mels
+kaggle/bake_voices.py    prompt_latent + CAM++ speaker_emb for each voice
+kaggle/ming_eval.py      teacher x student matrix, resumable per cell
+```
+
+## Why the scoring is fussy
+
+Whisper usually transcribes Chinese in traditional characters. Comparing that
+against simplified references and counting character differences adds tens of
+points of fake error. Every score here is reported twice: `cer_raw` (as
+produced) and `cer_norm` (after traditional->simplified, punctuation stripped).
+The gap is measurement, not model quality.
+
+`cer_prefix` scores only the first four characters. A garbled opening syllable
+barely moves overall CER but ruins a radio line, and it is the failure mode that
+weight-only int4 quantisation produced on the 3-step student.
+
+## Usage
+
+```bash
+python3 eval/score.py selftest
+python3 eval/score.py aggregate --results results.jsonl --baseline teacher --by-bucket
+```
+
+`results.jsonl` carries one row per generated utterance:
+`{id, model, voice, text, hyp_text, spk_cos?, mel_l1?, dur_ratio?}`.
+
+## Licence
+
+MIT for the code. The prompt clips derive from a purchased SFW corpus; check the
+source terms before commercial use.

config/ming_voices.json

@@ -0,0 +1,101 @@
+{
+ "version": 1,
+ "voices": [
+  {
+   "id": "v01",
+   "name": "声线 01",
+   "nameEn": "VOICE 01",
+   "promptWav": "refs/wav/v01.wav",
+   "promptText": "然后再放松你的嘴唇和下巴，轻轻地摊开你的四周，",
+   "sampleRate": 24000,
+   "seconds": 6.6,
+   "accent": "#ffcf9e",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v02",
+   "name": "声线 02",
+   "nameEn": "VOICE 02",
+   "promptWav": "refs/wav/v02.wav",
+   "promptText": "我們從這裡 進入了另外一個更廣闊的空間",
+   "sampleRate": 24000,
+   "seconds": 6.0,
+   "accent": "#9ecbff",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v03",
+   "name": "声线 03",
+   "nameEn": "VOICE 03",
+   "promptWav": "refs/wav/v03.wav",
+   "promptText": "嗯很舒服用一个你觉得舒服",
+   "sampleRate": 24000,
+   "seconds": 6.0,
+   "accent": "#b9a6ff",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v04",
+   "name": "声线 04",
+   "nameEn": "VOICE 04",
+   "promptWav": "refs/wav/v04.wav",
+   "promptText": "现在是我的灵魂在说话。",
+   "sampleRate": 24000,
+   "seconds": 2.8,
+   "accent": "#8fe3c8",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v05",
+   "name": "声线 05",
+   "nameEn": "VOICE 05",
+   "promptWav": "refs/wav/v05.wav",
+   "promptText": "小兔子都睡觉了，那我们小狗要不要睡觉呀？",
+   "sampleRate": 24000,
+   "seconds": 6.0,
+   "accent": "#ffb4c8",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v06",
+   "name": "声线 06",
+   "nameEn": "VOICE 06",
+   "promptWav": "refs/wav/v06.wav",
+   "promptText": "对于我露瑟瑟念的这个神像你们有什么比较",
+   "sampleRate": 24000,
+   "seconds": 6.0,
+   "accent": "#93d7ff",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v07",
+   "name": "声线 07",
+   "nameEn": "VOICE 07",
+   "promptWav": "refs/wav/v07.wav",
+   "promptText": "好，睡吧，睡吧，睡吧吧，给你一个睡，睡吧。",
+   "sampleRate": 24000,
+   "seconds": 6.0,
+   "accent": "#ffd59e",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  },
+  {
+   "id": "v08",
+   "name": "声线 08",
+   "nameEn": "VOICE 08",
+   "promptWav": "refs/wav/v08.wav",
+   "promptText": "那么请仰躺在床上深呼吸之后",
+   "sampleRate": 24000,
+   "seconds": 6.0,
+   "accent": "#f5a6ff",
+   "sfw": true,
+   "source": "webfm-f5-mel-vocoded"
+  }
+ ]
+}

eval/score.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""Score Ming TTS candidates on the fixed eval set in eval/sentences.json.
+
+Two numbers are always reported:
+
+- `cer_raw`  — character error rate on the ASR transcript exactly as produced.
+- `cer_norm` — same, after traditional->simplified, full-width folding and
+  punctuation stripping.
+
+The gap between them is a measurement artefact, not model quality. Whisper
+usually emits Chinese in traditional characters; comparing that to simplified
+references can add 30-50 points of fake error. Always report both, and always
+compare a candidate against a baseline measured in the same run.
+
+Input is JSONL, one row per generated utterance:
+
+  {"id": "s01", "model": "3step", "voice": "v01", "text": "...",
+   "hyp_text": "...", "spk_cos": 0.91, "mel_l1": 3.2, "dur_ratio": 1.00}
+
+`text` and `hyp_text` are required; audio metrics are optional and only
+aggregated when present.
+
+Usage:
+  python3 eval/score.py aggregate --results runs/eval.jsonl --baseline teacher
+  python3 eval/score.py selftest
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import unicodedata
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PUNCT = set("，。、；：？！“”‘’（）《》〈〉【】…—·「」『』,.;:?!!()[]<>\"'`~-_/\\|@#$%^&*+= \t\n\r")
+
+
+def load_t2s() -> dict[str, str]:
+    try:
+        import opencc  # type: ignore
+
+        conv = opencc.OpenCC("t2s")
+
+        return {"__opencc__": conv}  # type: ignore[dict-item]
+    except Exception:
+        pass
+    path = HERE / "t2s.json"
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text())["map"]
+
+
+def to_simplified(text: str, table: dict) -> str:
+    conv = table.get("__opencc__")
+    if conv is not None:
+        return conv.convert(text)
+    return "".join(table.get(ch, ch) for ch in text)
+
+
+def strip_text(text: str) -> str:
+    text = unicodedata.normalize("NFKC", text or "")
+    out = []
+    for ch in text:
+        if ch in PUNCT or ch.isspace():
+            continue
+        if "\u4e00" <= ch <= "\u9fff" or ch.isalnum():
+            out.append(ch.lower())
+    return "".join(out)
+
+
+def normalize(text: str, table: dict, simplify: bool) -> str:
+    if simplify:
+        text = to_simplified(text, table)
+    return strip_text(text)
+
+
+def edit_distance(a: str, b: str) -> int:
+    if a == b:
+        return 0
+    if not a:
+        return len(b)
+    if not b:
+        return len(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(cur[-1] + 1, prev[j] + 1, prev[j - 1] + (ca != cb)))
+        prev = cur
+    return prev[-1]
+
+
+def cer(ref: str, hyp: str) -> float:
+    if not ref:
+        return 0.0 if not hyp else 1.0
+    return edit_distance(ref, hyp) / len(ref)
+
+
+def score_row(row: dict, table: dict) -> dict:
+    ref_raw = strip_text(row["text"])
+    hyp_raw = strip_text(row["hyp_text"])
+    ref_norm = normalize(row["text"], table, True)
+    hyp_norm = normalize(row["hyp_text"], table, True)
+    head = min(4, len(ref_norm))
+    return {
+        "cer_raw": cer(ref_raw, hyp_raw),
+        "cer_norm": cer(ref_norm, hyp_norm),
+        "cer_prefix": cer(ref_norm[:head], hyp_norm[:head]) if head else 0.0,
+        "ref_norm": ref_norm,
+        "hyp_norm": hyp_norm,
+    }
+
+
+def mean(values: list[float]) -> float | None:
+    values = [v for v in values if v is not None]
+    return sum(values) / len(values) if values else None
+
+
+def aggregate(rows: list[dict], table: dict, baseline: str | None) -> dict:
+    sentences = {i["id"]: i for i in json.loads((HERE / "sentences.json").read_text())["items"]}
+    scored: list[dict] = []
+    for row in rows:
+        entry = dict(row)
+        entry.update(score_row(row, table))
+        bucket = sentences.get(row.get("id", ""), {}).get("bucket", "unknown")
+        entry["bucket"] = bucket
+        scored.append(entry)
+
+    models: dict[str, dict] = {}
+    for entry in scored:
+        m = models.setdefault(entry["model"], {"rows": [], "by_bucket": {}, "voices": {}})
+        m["rows"].append(entry)
+        m["by_bucket"].setdefault(entry["bucket"], []).append(entry)
+        m["voices"].setdefault(entry.get("voice", "-"), []).append(entry)
+
+    summary: dict[str, dict] = {}
+    for name, m in models.items():
+        rows_m = m["rows"]
+        summary[name] = {
+            "n": len(rows_m),
+            "cer_raw": mean([r["cer_raw"] for r in rows_m]),
+            "cer_norm": mean([r["cer_norm"] for r in rows_m]),
+            "cer_prefix": mean([r["cer_prefix"] for r in rows_m]),
+            "spk_cos": mean([r.get("spk_cos") for r in rows_m]),
+            "mel_l1": mean([r.get("mel_l1") for r in rows_m]),
+            "dur_ratio": mean([r.get("dur_ratio") for r in rows_m]),
+            "by_bucket": {
+                b: {
+                    "n": len(rs),
+                    "cer_norm": mean([r["cer_norm"] for r in rs]),
+                }
+                for b, rs in m["by_bucket"].items()
+            },
+            "by_voice": {
+                v: {
+                    "n": len(rs),
+                    "cer_norm": mean([r["cer_norm"] for r in rs]),
+                    "spk_cos": mean([r.get("spk_cos") for r in rs]),
+                }
+                for v, rs in m["voices"].items()
+            },
+            "worst": sorted(rows_m, key=lambda r: -r["cer_norm"])[:5],
+        }
+
+    if baseline and baseline in summary:
+        base = summary[baseline]
+        for name, s in summary.items():
+            if name == baseline:
+                continue
+            s["delta_vs_baseline"] = {
+                "cer_norm_pp": None
+                if s["cer_norm"] is None or base["cer_norm"] is None
+                else (s["cer_norm"] - base["cer_norm"]) * 100,
+                "spk_cos": None
+                if s["spk_cos"] is None or base["spk_cos"] is None
+                else s["spk_cos"] - base["spk_cos"],
+            }
+    return {"models": summary, "scored": scored}
+
+
+def print_table(summary: dict) -> None:
+    print(f"{'model':<14}{'n':>5}{'cer_raw':>10}{'cer_norm':>10}{'cer_head':>10}{'spk_cos':>10}{'dur':>8}")
+    for name, s in sorted(summary.items(), key=lambda kv: (kv[1]["cer_norm"] or 0)):
+        def fmt(v, p=4):
+            return "-" if v is None else f"{v:.{p}f}"
+
+        print(f"{name:<14}{s['n']:>5}{fmt(s['cer_raw']):>10}{fmt(s['cer_norm']):>10}"
+              f"{fmt(s['cer_prefix'], 3):>10}{fmt(s['spk_cos'], 3):>10}{fmt(s['dur_ratio'], 3):>8}")
+
+
+def cmd_aggregate(args) -> int:
+    table = load_t2s()
+    rows = []
+    with open(args.results) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    if not rows:
+        print("no rows", file=sys.stderr)
+        return 1
+    result = aggregate(rows, table, args.baseline)
+    print_table(result["models"])
+    if args.baseline and any("delta_vs_baseline" in s for s in result["models"].values()):
+        print(f"\ndelta vs {args.baseline} (negative CER delta is better):")
+        for name, s in result["models"].items():
+            d = s.get("delta_vs_baseline")
+            if d:
+                print(f"  {name:<12} cer {'%+.2f' % d['cer_norm_pp']} pp   "
+                      f"spk {'%+.3f' % d['spk_cos'] if d['spk_cos'] is not None else '-'}")
+    if args.by_bucket:
+        print("\ncer_norm by bucket:")
+        buckets = sorted({b for s in result["models"].values() for b in s["by_bucket"]})
+        print(f"{'model':<14}" + "".join(f"{b:>12}" for b in buckets))
+        for name, s in result["models"].items():
+            cells = []
+            for b in buckets:
+                v = s["by_bucket"].get(b, {}).get("cer_norm")
+                cells.append(f"{v:.3f}" if v is not None else "-")
+            print(f"{name:<14}" + "".join(f"{c:>12}" for c in cells))
+    if args.out:
+        Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.out).write_text(json.dumps(result, ensure_ascii=False, indent=2))
+        print(f"\nwrote {args.out}")
+    return 0
+
+
+SELFTEST = [
+    ("雨落在窗台上，远处的灯一盏一盏亮起来。", "雨落在窗台上遠處的燈一盞一盞亮起來", 0.0),
+    ("风从门缝里进来，带着一点潮湿的木头气味。", "風從門縫裡進來帶著一點潮濕的木頭氣味", 0.0),
+    ("她把杯子放在桌边，屋里的光慢慢暗下去。", "他把杯子放在桌邊屋裡的光慢慢按下去", 2 / 17),
+]
+
+
+def cmd_selftest(_args) -> int:
+    table = load_t2s()
+    backend = "opencc" if "__opencc__" in table else "bundled table"
+    print(f"t2s backend: {backend}\n")
+    ok = True
+    for ref, hyp, expect in SELFTEST:
+        s = score_row({"text": ref, "hyp_text": hyp}, table)
+        flag = "ok" if abs(s["cer_norm"] - expect) < 0.02 else "MISMATCH"
+        if flag != "ok":
+            ok = False
+        print(f"raw {s['cer_raw']:.3f} -> norm {s['cer_norm']:.3f}  "
+              f"(expect {expect:.3f})  {flag}\n  {s['hyp_norm']}")
+    if not ok:
+        print("\nselftest failed", file=sys.stderr)
+        return 1
+    print("\nselftest ok")
+    return 0
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    a = sub.add_parser("aggregate")
+    a.add_argument("--results", required=True)
+    a.add_argument("--baseline", default=None)
+    a.add_argument("--out", default=None)
+    a.add_argument("--by-bucket", action="store_true")
+    a.set_defaults(func=cmd_aggregate)
+    s = sub.add_parser("selftest")
+    s.set_defaults(func=cmd_selftest)
+    args = ap.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

eval/sentences.json

@@ -0,0 +1,61 @@
+{
+  "version": 1,
+  "note": "Fixed evaluation set for the Ming TTS migration. Every model tier is scored on exactly these ids. Do not tune anything against this set; it exists to be compared, not improved.",
+  "buckets": {
+    "short": "8-14 characters, the shape most spoken lines take",
+    "medium": "15-25 characters, a normal multi-clause line",
+    "long": "26-45 characters, where a 3-step student tends to drift or repeat",
+    "number": "digits, dates, percentages, ordinals",
+    "latin": "Latin words and acronyms inside Chinese",
+    "polyphone": "调/着/得 traps that the F5 pinyin table used to patch by hand",
+    "narration": "book-page style, close to the verbatim reading path"
+  },
+  "items": [
+    { "id": "s01", "bucket": "short", "text": "灯关小一点，我们慢慢来。" },
+    { "id": "s02", "bucket": "short", "text": "外面在下雨。" },
+    { "id": "s03", "bucket": "short", "text": "别急，先呼吸。" },
+    { "id": "s04", "bucket": "short", "text": "今天有点冷。" },
+    { "id": "s05", "bucket": "short", "text": "你醒着吗？" },
+    { "id": "s06", "bucket": "short", "text": "声音轻一点。" },
+
+    { "id": "m01", "bucket": "medium", "text": "窗外的雨一直没有停，楼下的车声也少了。" },
+    { "id": "m02", "bucket": "medium", "text": "他把外套挂在门后，然后坐回了那把旧椅子上。" },
+    { "id": "m03", "bucket": "medium", "text": "如果你还不想睡，我们可以再聊一会儿。" },
+    { "id": "m04", "bucket": "medium", "text": "这条街以前有两家书店，现在只剩一家。" },
+    { "id": "m05", "bucket": "medium", "text": "火车的灯从远处过来，又慢慢开走了。" },
+    { "id": "m06", "bucket": "medium", "text": "杯子里的水已经凉了，屋顶上还有一点风。" },
+    { "id": "m07", "bucket": "medium", "text": "她把窗帘拉开一条缝，看了看外面的天。" },
+    { "id": "m08", "bucket": "medium", "text": "睡不着的夜里，时间会走得特别慢。" },
+
+    { "id": "l01", "bucket": "long", "text": "雨从傍晚开始下，一直没停，窗户上蒙了一层薄薄的水汽，把外面的灯都晕开了。" },
+    { "id": "l02", "bucket": "long", "text": "很多年以后，他还是记得那个下午，教室里很安静，只有粉笔在黑板上划过的声音。" },
+    { "id": "l03", "bucket": "long", "text": "她在站台上等了很久，风把围巾吹起来，广播里重复着那趟已经晚点的列车。" },
+    { "id": "l04", "bucket": "long", "text": "那条河从城西一直流到城东，夏天的时候孩子们会在浅水处玩水，冬天就结了很厚的冰。" },
+    { "id": "l05", "bucket": "long", "text": "他慢慢走到窗前，把杯子放在窗台上，看着外面的雨一点一点变密，觉得今天可以早点睡了。" },
+    { "id": "l06", "bucket": "long", "text": "老屋的房梁上还挂着一盏灯，光很暗，照不亮墙角，只够看见桌上那本翻旧了的书。" },
+    { "id": "l07", "bucket": "long", "text": "夜班的护士推着车走过走廊，鞋底和地面摩擦出很轻的声音，病房里的人大多已经睡下了。" },
+    { "id": "l08", "bucket": "long", "text": "她把那封信读了第三遍，然后折好放回抽屉，窗外的天已经开始亮了，鸟叫得很轻。" },
+
+    { "id": "n01", "bucket": "number", "text": "现在还差五分十二点。" },
+    { "id": "n02", "bucket": "number", "text": "从一九九八年到二零零六年，这条街变了三次。" },
+    { "id": "n03", "bucket": "number", "text": "这趟车晚点三十分钟，站台上有一百多人。" },
+    { "id": "n04", "bucket": "number", "text": "第三病房在二楼，走廊尽头右转。" },
+    { "id": "n05", "bucket": "number", "text": "他数到第两百下的时候，终于听见了雨声。" },
+    { "id": "n06", "bucket": "number", "text": "房租涨了百分之二十，她决定搬到城北去。" },
+
+    { "id": "x01", "bucket": "latin", "text": "我把 Wi-Fi 密码写在便签上了。" },
+    { "id": "x02", "bucket": "latin", "text": "这首歌的名字是 Blue Hour。" },
+    { "id": "x03", "bucket": "latin", "text": "他的 MP3 里只有十几首歌。" },
+    { "id": "x04", "bucket": "latin", "text": "会议改到周五下午三点，线上，用 Teams。" },
+
+    { "id": "p01", "bucket": "polyphone", "text": "她把收音机调到那个熟悉的频率。" },
+    { "id": "p02", "bucket": "polyphone", "text": "走廊里有人在低声调整音量的旋钮。" },
+    { "id": "p03", "bucket": "polyphone", "text": "他睡不着，就起身把灯重新调暗了一点。" },
+    { "id": "p04", "bucket": "polyphone", "text": "这段旋律单调得让人想睡，声调也压得很低。" },
+
+    { "id": "b01", "bucket": "narration", "text": "那时他常说，夜里最安静的时候，能听见自己在想什么。" },
+    { "id": "b02", "bucket": "narration", "text": "书里写着：雨停之后，城里会亮起很多很细的灯。" },
+    { "id": "b03", "bucket": "narration", "text": "「你还记得吗？」她问，声音很轻，像怕吵醒什么。" },
+    { "id": "b04", "bucket": "narration", "text": "后来那家店关了门，招牌被拆下来，靠在墙边放了很久。" }
+  ]
+}

eval/t2s.json

@@ -0,0 +1,40 @@
+{
+  "version": 1,
+  "note": "High-frequency traditional -> simplified map, used only when opencc is unavailable. Whisper often transcribes Chinese in traditional characters; comparing that against simplified references inflates CER by tens of points. Prefer opencc when installed. Extend by adding confident pairs only: a wrong pair silently corrupts the score.",
+  "map": {
+    "這": "这", "個": "个", "們": "们", "來": "来", "時": "时", "會": "会",
+    "對": "对", "開": "开", "關": "关", "麼": "么", "樣": "样", "過": "过",
+    "還": "还", "進": "进", "遠": "远", "燈": "灯", "盞": "盏", "風": "风",
+    "從": "从", "門": "门", "縫": "缝", "裡": "里", "帶": "带", "著": "着",
+    "點": "点", "濕": "湿", "頭": "头", "氣": "气", "聲": "声", "語": "语",
+    "話": "话", "誰": "谁", "覺": "觉", "兒": "儿", "見": "见", "現": "现",
+    "實": "实", "聽": "听", "寫": "写", "讀": "读", "書": "书", "頁": "页",
+    "紙": "纸", "錢": "钱", "鐘": "钟", "長": "长", "間": "间", "陽": "阳",
+    "陰": "阴", "雲": "云", "電": "电", "車": "车", "馬": "马", "鳥": "鸟",
+    "魚": "鱼", "龍": "龙", "華": "华", "國": "国", "際": "际", "學": "学",
+    "習": "习", "練": "练", "體": "体", "溫": "温", "熱": "热", "東": "东",
+    "場": "场", "處": "处", "應": "应", "該": "该", "讓": "让", "給": "给",
+    "沒": "没", "無": "无", "為": "为", "與": "与", "將": "将", "軍": "军",
+    "醫": "医", "藥": "药", "夢": "梦", "鄉": "乡", "憶": "忆", "舊": "旧",
+    "靜": "静", "動": "动", "淚": "泪", "願": "愿", "歲": "岁", "幾": "几",
+    "隨": "随", "邊": "边", "變": "变", "別": "别", "認": "认", "識": "识",
+    "記": "记", "謝": "谢", "請": "请", "問": "问", "題": "题", "說": "说",
+    "講": "讲", "談": "谈", "親": "亲", "愛": "爱", "歡": "欢", "樂": "乐",
+    "憂": "忧", "傷": "伤", "涼": "凉", "潤": "润", "軟": "软", "輕": "轻",
+    "內": "内", "麵": "面", "髮": "发", "隻": "只", "條": "条", "顆": "颗",
+    "張": "张", "塊": "块", "陣": "阵", "麗": "丽", "豐": "丰", "滿": "满",
+    "於": "于", "並": "并", "卻": "却", "據": "据", "錯": "错", "誤": "误",
+    "舉": "举", "頓": "顿", "轉": "转", "嗎": "吗", "畫": "画", "買": "买",
+    "賣": "卖", "貴": "贵", "價": "价", "貨": "货", "資": "资", "費": "费",
+    "單": "单", "雙": "双", "慶": "庆", "農": "农", "業": "业", "產": "产",
+    "團": "团", "隊": "队", "員": "员", "機": "机", "閉": "闭", "傳": "传",
+    "統": "统", "網": "网", "線": "线", "級": "级", "優": "优", "總": "总",
+    "結": "结", "續": "续", "斷": "断", "環": "环", "節": "节", "塵": "尘",
+    "霧": "雾", "燭": "烛", "爐": "炉", "鏡": "镜", "盤": "盘", "碗": "碗",
+    "簾": "帘", "牆": "墙", "磚": "砖", "階": "阶", "櫃": "柜", "飯": "饭",
+    "餅": "饼", "煙": "烟", "鬧": "闹", "響": "响", "濃": "浓", "鹹": "咸",
+    "鮮": "鲜", "澀": "涩", "細": "细", "寬": "宽", "淺": "浅", "後": "后",
+    "側": "侧", "頂": "顶", "臟": "脏", "腸": "肠", "膚": "肤", "齒": "齿",
+    "頸": "颈", "齡": "龄", "灣": "湾", "濕": "湿", "衛": "卫", "準": "准"
+  }
+}

kaggle/bake_voices.py

@@ -0,0 +1,100 @@
+"""Bake the two offline assets Ming needs per built-in voice.
+
+For every entry in config/ming_voices.json this writes:
+
+  prompt_latent  - VAE posterior latent of the 6 s prompt wav (the flow head's
+                   conditioning, replacing the F5 reference mel)
+  speaker_emb    - 192-d CAM++ embedding of the same clip at 16 kHz
+
+Both are tiny and ship with the site. The browser only needs the audio encoder
+when a user uploads their own clip, so this bake is what keeps the main bundle
+small.
+
+Writes voices_baked.npz plus voices_baked.json (shapes, dtypes, source hashes).
+
+Run inside the Kaggle notebook after the model is downloaded:
+  EVAL_DATA=/kaggle/working/webfm-eval python3 bake_voices.py
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+import numpy as np
+import torch
+
+ROOT = Path("/kaggle/working")
+REPO = ROOT / "Ming-3.0-tts"
+MODEL_DIR = ROOT / "Ming-3.0-tts-0.5b"
+DATA = Path(os.environ.get("EVAL_DATA", str(ROOT / "webfm-eval")))
+OUT = ROOT / "baked"
+
+
+def patch_fp32() -> None:
+    for name in ("ming_tts.py", "modeling_bailingmm.py"):
+        path = REPO / name
+        s = path.read_text()
+        s = s.replace("torch_dtype=torch.bfloat16", "torch_dtype=torch.float32")
+        s = s.replace(".eval().to(torch.bfloat16).to(device)", ".eval().to(torch.float32).to(device)")
+        s = s.replace("dtype=torch.bfloat16", "dtype=torch.float32")
+        path.write_text(s)
+
+
+def sha8(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()[:8]
+
+
+def main() -> None:
+    OUT.mkdir(parents=True, exist_ok=True)
+    sys.path.insert(0, str(REPO))
+    patch_fp32()
+    from ming_tts import MingTTS
+
+    tts = MingTTS(str(MODEL_DIR), device="cuda", text_normalization=False)
+    voices = json.loads((DATA / "config/ming_voices.json").read_text())["voices"]
+
+    arrays: dict[str, np.ndarray] = {}
+    meta: dict[str, dict] = {}
+    for v in voices:
+        vid = v["id"]
+        wav = DATA / v["promptWav"]
+        if not wav.exists():
+            print(f"skip {vid}: {wav} missing")
+            continue
+        try:
+            with torch.no_grad():
+                latent, spk = tts.prepare_prompt(str(wav), use_spk_emb=True)
+            latent = latent.detach().float().cpu().numpy()
+            emb = (spk[0] if isinstance(spk, (list, tuple)) else spk).detach().float().cpu()
+            emb = emb.reshape(-1).numpy()
+            arrays[f"{vid}_latent"] = latent
+            arrays[f"{vid}_spk"] = emb
+            meta[vid] = {
+                "promptWav": v["promptWav"],
+                "promptText": v["promptText"],
+                "wav_sha8": sha8(wav),
+                "latent_shape": list(latent.shape),
+                "spk_dim": int(emb.size),
+            }
+            print(f"{vid}: latent {latent.shape} spk {emb.size} from {wav.name} ({v['seconds']}s)")
+        except Exception:
+            print(f"{vid} failed\n{traceback.format_exc()}")
+
+    if not arrays:
+        raise SystemExit("nothing baked")
+
+    np.savez_compressed(OUT / "voices_baked.npz", **arrays)
+    (OUT / "voices_baked.json").write_text(json.dumps(
+        {"model": "inclusionAI/Ming-3.0-tts-0.5B", "voices": meta,
+         "note": "latent is the VAE posterior used as flow conditioning; spk is CAM++ 192-d"},
+        ensure_ascii=False, indent=2))
+    size = (OUT / "voices_baked.npz").stat().st_size
+    print(f"wrote {OUT/'voices_baked.npz'} ({size/1024:.0f} KB) for {len(meta)} voices")
+
+
+if __name__ == "__main__":
+    main()

kaggle/ming_eval.py

@@ -0,0 +1,318 @@
+"""Evaluate every Ming TTS tier on the fixed WebFM eval set (eval/sentences.json).
+
+Runs the teacher and the distilled students over the same voice x sentence
+matrix, writes one wav per cell and one JSONL row per cell, then leaves the
+scoring to `eval/score.py`.
+
+The teacher is generated in the same run and on the same sentences: a candidate
+is only meaningful as a delta against it.
+
+Expected Kaggle inputs:
+  /kaggle/input/webfm-eval/eval/sentences.json     (this repo's eval/)
+  /kaggle/input/webfm-eval/config/ming_voices.json
+  /kaggle/input/webfm-eval/refs/wav/v01.wav .. v08.wav
+  /kaggle/working/Ming-3.0-tts + Ming-3.0-tts-0.5b  (as in ming_multistep.py)
+
+Env:
+  VOICES=v01,v02,...       subset of voices, for splitting across two GPUs
+  MODELS=teacher,3step,4step
+  LIMIT=40                 sentences to run
+  SEED=20261021
+
+Resumable: a cell whose wav exists is not regenerated; the JSONL is appended
+and flushed per row, so a killed session keeps what it finished.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import time
+import traceback
+from pathlib import Path
+
+import numpy as np
+import torch
+import torchaudio
+
+ROOT = Path("/kaggle/working")
+REPO = ROOT / "Ming-3.0-tts"
+MODEL_DIR = ROOT / "Ming-3.0-tts-0.5b"
+DATA = Path(os.environ.get("EVAL_DATA", "/kaggle/input/webfm-eval"))
+OUT = ROOT / "ming_eval"
+WAV = OUT / "wav"
+ROWS = OUT / "results.jsonl"
+LOG = OUT / "eval.log"
+
+SEED = int(os.environ.get("SEED", "20261021"))
+LIMIT = int(os.environ.get("LIMIT", "40"))
+VOICE_FILTER = [v for v in os.environ.get("VOICES", "").split(",") if v]
+MODELS = [m for m in os.environ.get("MODELS", "teacher,3step,4step").split(",") if m]
+TEACHER_STEPS = 10
+TEACHER_CFG = 2.0
+
+STUDENT_REPOS = {
+    "1step": ("idefinity/ming-3.0-tts-1step-distill-int4", 1),
+    "2step": ("idefinity/ming-3.0-tts-2step-distill-int4", 2),
+    "3step": ("idefinity/ming-3.0-tts-3step-distill-int4", 3),
+    "4step": ("idefinity/ming-3.0-tts-4step-distill-int4", 4),
+}
+
+for p in (OUT, WAV):
+    p.mkdir(parents=True, exist_ok=True)
+
+
+def log(msg: str) -> None:
+    line = f"[{time.strftime('%H:%M:%S')}] {msg}"
+    print(line, flush=True)
+    with open(LOG, "a") as f:
+        f.write(line + "\n")
+
+
+def patch_fp32() -> None:
+    """T4 has no bf16; the repo defaults to bf16 and NaNs out under fp16."""
+    for name in ("ming_tts.py", "modeling_bailingmm.py"):
+        path = REPO / name
+        s = path.read_text()
+        s = s.replace("torch_dtype=torch.bfloat16", "torch_dtype=torch.float32")
+        s = s.replace(".eval().to(torch.bfloat16).to(device)", ".eval().to(torch.float32).to(device)")
+        s = s.replace("dtype=torch.bfloat16", "dtype=torch.float32")
+        path.write_text(s)
+
+
+def done_cells() -> set[tuple[str, str, str]]:
+    seen = set()
+    if ROWS.exists():
+        for line in ROWS.read_text().splitlines():
+            if not line.strip():
+                continue
+            try:
+                r = json.loads(line)
+                seen.add((r["model"], r["voice"], r["id"]))
+            except Exception:
+                continue
+    return seen
+
+
+def sample_latent(student, z, history, noise, n_steps):
+    y = noise
+    for i in range(n_steps):
+        dt = 1.0 / n_steps
+        v = student(
+            x=y, t=torch.full((y.shape[0],), i / n_steps, device=y.device),
+            c=z, latent_history=history, mask=None,
+        )[:, -1:, :]
+        y = y + v * dt
+    return y
+
+
+def ar_generate(mm, dit, n_steps, prompt, text, prompt_latent, prompt_text, spk_emb, frames):
+    """Autoregressive rollout with a chosen flow head. Length is forced to the
+    teacher's frame count, so this measures content and timbre, not stopping."""
+    device = next(mm.parameters()).device
+    dtype = next(mm.parameters()).dtype
+    with torch.no_grad():
+        input_ids, inputs_embeds = mm.prepare_input_embed(
+            prompt=prompt, text=text, spk_emb=spk_emb,
+            prompt_latent=prompt_latent, prompt_text=prompt_text,
+        )
+    attention_mask = torch.ones(input_ids.shape, device=device)
+    position_ids = (attention_mask.cumsum(-1) - 1).masked_fill_(attention_mask == 0, 1)
+    past = None
+    history = torch.zeros(1, mm.history_patch_size, mm.latent_dim, device=device, dtype=dtype)
+    if prompt_latent is not None:
+        start = mm.history_patch_size - prompt_latent.size(1)
+        if start < 0:
+            history[:] = prompt_latent[:, -start:, :]
+        else:
+            history[:, start:, :] = prompt_latent
+    out = []
+    for _ in range(frames):
+        with torch.no_grad():
+            hidden = mm.model(
+                attention_mask=attention_mask, position_ids=position_ids,
+                inputs_embeds=inputs_embeds, audio_mask=None, image_mask=None,
+                output_hidden_states=True, return_dict=True, use_cache=True,
+                past_key_values=past,
+            )
+            past = hidden.past_key_values
+            z = hidden.hidden_states[-1][:, -1:, :]
+            noise = torch.randn(1, 1, mm.latent_dim, device=device, dtype=dtype)
+            latent = sample_latent(dit, z, history, noise, n_steps).to(device=device, dtype=dtype)
+        out.append(latent)
+        inputs_embeds = mm.linear_proj_audio(latent)
+        position_ids = position_ids[:, -1:] + 1
+        attention_mask = torch.ones(inputs_embeds.shape[0], 1, device=device)
+        history[:, :-mm.patch_size, :] = history[:, mm.patch_size:, :].clone()
+        history[:, -mm.patch_size:, :] = latent
+    with torch.no_grad():
+        speech = mm.audio.decode(torch.cat(out, dim=1), past_key_values=None,
+                                 use_cache=False, last_chunk=True)[0]
+    return speech.cpu().float().reshape(-1).numpy()
+
+
+def load_student(name: str, teacher_dit, device):
+    from huggingface_hub import hf_hub_download
+
+    repo, steps = STUDENT_REPOS[name]
+    path = hf_hub_download(repo_id=repo, filename=f"distill/student_{steps}step.pt")
+    state = torch.load(path, map_location="cpu")
+    state = {k: v.float() for k, v in state.items()}
+    import copy
+
+    dit = copy.deepcopy(teacher_dit)
+    dit.load_state_dict(state)
+    return dit.to(device).eval(), steps
+
+
+def build_asr():
+    from transformers import pipeline
+
+    kwargs = {"model": "openai/whisper-small", "device": 0}
+    try:
+        pipe = pipeline("automatic-speech-recognition", torch_dtype=torch.float16, **kwargs)
+    except Exception:
+        pipe = pipeline("automatic-speech-recognition", **kwargs)
+    prompt = "以下是普通话的句子，请使用简体中文转写。"  # pushes Whisper off traditional output
+
+    def asr(wav: np.ndarray, sr: int = 44100) -> str:
+        out = pipe(
+            {"array": wav.astype(np.float32), "sampling_rate": sr},
+            generate_kwargs={"language": "zh", "task": "transcribe", "initial_prompt": prompt},
+        )
+        return out.get("text", "") if isinstance(out, dict) else str(out)
+
+    return asr
+
+
+def main() -> None:
+    torch.manual_seed(SEED)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(SEED)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    log(f"device={device} limit={LIMIT} models={MODELS} voices={VOICE_FILTER or 'all'}")
+
+    sys.path.insert(0, str(REPO))
+    patch_fp32()
+    from ming_tts import MingTTS
+    import tts_tasks
+
+    sentences = json.loads((DATA / "eval/sentences.json").read_text())["items"][:LIMIT]
+    voices = json.loads((DATA / "config/ming_voices.json").read_text())["voices"]
+    if VOICE_FILTER:
+        voices = [v for v in voices if v["id"] in VOICE_FILTER]
+    log(f"sentences={len(sentences)} voices={[v['id'] for v in voices]}")
+
+    tts = MingTTS(str(MODEL_DIR), device=str(device), text_normalization=False)
+    mm = tts.model
+    dtype = next(mm.parameters()).dtype
+    prompt = tts_tasks.build_tts_prompt("Chinese")
+    teacher_dit = mm.flowloss.cfm.model.float().eval()
+    for p in teacher_dit.parameters():
+        p.requires_grad_(False)
+
+    students = {}
+    for name in MODELS:
+        if name in STUDENT_REPOS:
+            students[name], steps = load_student(name, teacher_dit, device)
+            log(f"loaded student {name} ({steps} steps)")
+
+    asr = build_asr()
+    spk = tts.spkemb_extractor
+    mel = torchaudio.transforms.MelSpectrogram(
+        sample_rate=44100, n_fft=1024, hop_length=256, n_mels=80, power=2.0
+    )
+
+    def speaker_cos(ref: np.ndarray, hyp: np.ndarray) -> float:
+        a = torchaudio.functional.resample(torch.from_numpy(ref).float(), 44100, 16000).unsqueeze(0)
+        b = torchaudio.functional.resample(torch.from_numpy(hyp).float(), 44100, 16000).unsqueeze(0)
+        ea, eb = spk(a).reshape(-1).float(), spk(b).reshape(-1).float()
+        return float(torch.dot(ea, eb) / (ea.norm() * eb.norm() + 1e-9))
+
+    def mel_l1(ref: np.ndarray, hyp: np.ndarray) -> float:
+        mr = torch.log(mel(torch.from_numpy(ref).float().unsqueeze(0)) + 1e-6).squeeze(0)
+        mh = torch.log(mel(torch.from_numpy(hyp).float().unsqueeze(0)) + 1e-6).squeeze(0)
+        n = min(mr.shape[-1], mh.shape[-1])
+        return float((mr[..., :n] - mh[..., :n]).abs().mean())
+
+    seen = done_cells()
+    log(f"resume: {len(seen)} cells already done")
+
+    for voice in voices:
+        vid = voice["id"]
+        wav_path = DATA / voice["promptWav"]
+        prompt_text = voice["promptText"]
+        prompt_latent, spk_emb = tts.prepare_prompt(str(wav_path), use_spk_emb=True)
+        prompt_latent = prompt_latent.to(device=device, dtype=dtype)
+        spk_emb = [x.to(device=device, dtype=dtype) for x in spk_emb]
+
+        for item in sentences:
+            sid, text = item["id"], item["text"]
+            ref_wav_path = WAV / "teacher" / vid / f"{sid}.wav"
+
+            if ("teacher", vid, sid) not in seen:
+                try:
+                    t0 = time.time()
+                    wav = tts.synthesize(
+                        task="TTS", text=text, language_id="Chinese",
+                        prompt_wav_path=str(wav_path), prompt_text=prompt_text,
+                        use_spk_emb=True, raw_text=True,
+                        max_decode_steps=max(16, min(400, int(len(text) * 3.0))),
+                    )
+                    arr = wav.cpu().numpy().reshape(-1)
+                    ref_wav_path.parent.mkdir(parents=True, exist_ok=True)
+                    torchaudio.save(str(ref_wav_path), torch.from_numpy(arr).unsqueeze(0), 44100)
+                    frames = max(16, int(round(arr.size / 3528)))
+                    with open(ROWS, "a") as f:
+                        f.write(json.dumps({
+                            "model": "teacher", "voice": vid, "id": sid, "bucket": item["bucket"],
+                            "text": text, "hyp_text": asr(arr), "frames": frames,
+                            "seconds": arr.size / 44100, "wall": time.time() - t0,
+                        }, ensure_ascii=False) + "\n")
+                    seen.add(("teacher", vid, sid))
+                    log(f"teacher {vid} {sid} {arr.size/44100:.2f}s in {time.time()-t0:.1f}s")
+                except Exception:
+                    log(f"teacher {vid} {sid} failed\n{traceback.format_exc()}")
+                    continue
+
+            if not ref_wav_path.exists():
+                continue
+            ref_audio, _ = torchaudio.load(str(ref_wav_path))
+            ref_audio = ref_audio.reshape(-1).numpy()
+            frames = max(16, int(round(ref_audio.size / 3528)))
+
+            for name, dit in students.items():
+                if (name, vid, sid) in seen:
+                    continue
+                try:
+                    t0 = time.time()
+                    torch.manual_seed(SEED)
+                    arr = ar_generate(mm, dit, STUDENT_REPOS[name][1], prompt, text,
+                                      prompt_latent, prompt_text, spk_emb, frames)
+                    path = WAV / name / vid / f"{sid}.wav"
+                    path.parent.mkdir(parents=True, exist_ok=True)
+                    torchaudio.save(str(path), torch.from_numpy(arr).unsqueeze(0), 44100)
+                    with open(ROWS, "a") as f:
+                        f.write(json.dumps({
+                            "model": name, "voice": vid, "id": sid, "bucket": item["bucket"],
+                            "text": text, "hyp_text": asr(arr),
+                            "spk_cos": speaker_cos(ref_audio, arr),
+                            "mel_l1": mel_l1(ref_audio, arr),
+                            "dur_ratio": arr.size / max(1, ref_audio.size),
+                            "wall": time.time() - t0,
+                        }, ensure_ascii=False) + "\n")
+                    seen.add((name, vid, sid))
+                    log(f"{name} {vid} {sid} in {time.time()-t0:.1f}s")
+                except Exception:
+                    log(f"{name} {vid} {sid} failed\n{traceback.format_exc()}")
+
+    log("DONE")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        log(traceback.format_exc())
+        raise

refs/wav/v01.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9403f42449c585268b93990e0c3e6a1f3821be80763f72b2023510f99514f7cd
+size 287276

refs/wav/v02.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34da9be3dadd01a5eb5806f6f69d9e6183bebccb77f44da8e7604e3c73da7013
+size 287276

refs/wav/v03.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bbe102ec68fe264cb5eb165afda3237fdcd5e3083c1cfc1eeef1c30632f3684c
+size 287276

refs/wav/v04.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47aa8198a3faf5eb9bd68520933e639af3db97d013ab6025385555220121ac53
+size 287276

refs/wav/v05.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38adeaa6dc2e787c25e5642fbf277351636aa7f0363900cdc36f24bf9bcc1d77
+size 287276

refs/wav/v06.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f613ab783cc876239a93bd46251524f683a37d240ae16be30018679f11d4242e
+size 287276

refs/wav/v07.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b8e94303381eb65f268029644c7cdf0f99c16d4e7f138a0dfaa8c9048744a0d
+size 287276

refs/wav/v08.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd0f430f24b895679ee4f8c77af5f04d0505ca60f2a7ad8b897e98778d192580
+size 287276