| """Clone the eight mined voices with Ming and render a sample for each. |
| |
| The point is comparison: the listening page already has the raw 6 s crop, this |
| adds what the model actually produces from it, on the same two sentences, so |
| timbre can be judged before any voice joins the roster. |
| |
| Reads webfm-eval/mined/manifest.json, writes voices_clone/{slot}_1.wav, |
| voices_clone/{slot}_2.wav and voices_clone/metrics.json. |
| |
| Note the prompt transcripts come from adult-roleplay ASMR clips. Only the timbre |
| is cloned; the prompt text is conditioning, never spoken in the product. Source |
| provenance still needs to hold up in the licence audit before any of these ship. |
| """ |
| import json |
| import os |
| import sys |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working")) |
| REPO = ROOT / "Ming-3.0-tts" |
| MODEL = ROOT / "Ming-3.0-tts-0.5b" |
| BUNDLE = ROOT / "webfm-eval" |
| OUT = ROOT / "voices_clone" |
|
|
| TEXTS = [ |
| "灯关小一点，我们慢慢来。", |
| "睡不着的夜里，时间会走得特别慢。", |
| ] |
|
|
|
|
| def log(msg: str) -> None: |
| print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) |
|
|
|
|
| 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 hf_ratio(y: np.ndarray, sr: int, cut: int = 8000) -> float: |
| spec = np.abs(np.fft.rfft(y)) ** 2 |
| freqs = np.fft.rfftfreq(len(y), 1 / sr) |
| return float(spec[freqs > cut].sum() / (spec.sum() + 1e-12)) |
|
|
|
|
| def main() -> None: |
| import torch |
| import torchaudio |
|
|
| OUT.mkdir(parents=True, exist_ok=True) |
| sys.path.insert(0, str(REPO)) |
| patch_fp32() |
| from ming_tts import MingTTS |
|
|
| sys.path.insert(0, str(BUNDLE / "eval")) |
| from score import load_t2s, score_row |
| table = load_t2s() |
|
|
| from transformers import pipeline |
| asr_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-small", |
| device=0, torch_dtype=torch.float16) |
|
|
| def asr(y: np.ndarray) -> str: |
| out = asr_pipe({"array": y.astype(np.float32), "sampling_rate": 44100}, |
| generate_kwargs={"language": "zh", "task": "transcribe"}) |
| return (out.get("text", "") if isinstance(out, dict) else str(out)).strip() |
|
|
| tts = MingTTS(str(MODEL), device="cuda", text_normalization=False) |
| voices = json.loads((BUNDLE / "mined/manifest.json").read_text())["voices"] |
| log(f"{len(voices)} voices, {len(TEXTS)} sentences each") |
|
|
| rows = [] |
| for v in voices: |
| wav_path = BUNDLE / v["wav"] |
| entry = dict(v) |
| for i, text in enumerate(TEXTS, 1): |
| try: |
| t0 = time.time() |
| torch.manual_seed(1234) |
| wav = tts.synthesize( |
| task="TTS", text=text, language_id="Chinese", |
| prompt_wav_path=str(wav_path), prompt_text=v["prompt_text"], |
| use_spk_emb=True, raw_text=True, |
| max_decode_steps=max(32, min(400, int(len(text) * 3.5))), |
| ) |
| arr = wav.cpu().numpy().reshape(-1) |
| path = OUT / f"{v['slot']}_{i}.wav" |
| torchaudio.save(str(path), torch.from_numpy(arr).unsqueeze(0), 44100) |
| s = score_row({"text": text, "hyp_text": asr(arr)}, table) |
| entry[f"cer_{i}"] = s["cer_norm"] |
| entry[f"asr_{i}"] = s["hyp_text"] |
| entry[f"hf_{i}"] = hf_ratio(arr, 44100) |
| entry[f"sec_{i}"] = round(arr.size / 44100, 2) |
| log(f"{v['slot']} #{i} cer={s['cer_norm']:.3f} hf={entry[f'hf_{i}']:.4f} " |
| f"{arr.size/44100:.1f}s {time.time()-t0:.0f}s") |
| except Exception as exc: |
| entry[f"error_{i}"] = f"{type(exc).__name__}: {exc}" |
| log(f"{v['slot']} #{i} failed: {exc}") |
| entry["cer"] = float(np.mean([entry[k] for k in entry if k.startswith("cer_")] or [9])) |
| entry["hf"] = float(np.mean([entry[k] for k in entry if k.startswith("hf_")] or [0])) |
| rows.append(entry) |
|
|
| rows.sort(key=lambda r: r["cer"]) |
| (OUT / "metrics.json").write_text(json.dumps(rows, ensure_ascii=False, indent=1)) |
| log("\n-- by CER --") |
| for r in rows: |
| log(f" {r['cer']:.3f} hf={r['hf']:.4f} {r['slot']} {r['artist'][:16]:<16} " |
| f"mine_cer={r['mine_cer']:.3f}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
