| """Mine replacement prompt voices from DownFlow/ASMR. |
| |
| The shipped voices failed as Ming prompts because their transcripts do not |
| describe their audio: v04's promptText covers ~2.8 s of speech while the clip |
| runs 5.98 s, so the clone learns a broken text/audio alignment that every |
| generated line inherits (teacher CER 0.83 versus 0.08 for a good prompt). |
| |
| Two rules here: |
| |
| 1. every candidate is cropped on a phrase boundary and transcribed from the |
| crop itself, never from the parent 30 s clip's transcript; |
| 2. every candidate is ranked by the only measure that matters: bake it as a |
| prompt, synthesise three fixed sentences with the teacher, transcribe, |
| count character errors. |
| |
| Stages: |
| STAGE=harvest CPU. stream, filter, crop, re-transcribe, score the signal |
| STAGE=probe GPU. bake each candidate, run the teacher probe, rank |
| STAGE=all both |
| |
| Outputs: voices/{candidates/, candidates.json, probe.json, best.json} |
| """ |
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import sys |
| import time |
| import traceback |
| 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" |
| WORK = ROOT / "voices" |
| CAND = WORK / "candidates" |
|
|
| DATASET = "DownFlow/ASMR" |
| N_ARTISTS = int(os.environ.get("N_ARTISTS", "20")) |
| N_PER_ARTIST = int(os.environ.get("N_PER_ARTIST", "6")) |
| CROP_S = float(os.environ.get("CROP_S", "6.0")) |
| MIN_SPEECH_S = float(os.environ.get("MIN_SPEECH_S", "4.5")) |
| STAGE = os.environ.get("STAGE", "all") |
| TOP_K = int(os.environ.get("TOP_K", "8")) |
| MAX_SCAN = int(os.environ.get("MAX_SCAN", "6000")) |
|
|
| PROBE_TEXTS = [ |
| "灯关小一点，我们慢慢来。", |
| "雨从傍晚开始下，一直没停，窗户上蒙了一层薄薄的水汽。", |
| "睡不着的夜里，时间会走得特别慢。", |
| ] |
|
|
| BLOCK = [ |
| "操", "肏", "做爱", "阴茎", "阴道", "奶子", "龟头", "高潮", "自慰", "口交", |
| "性爱", "色情", "淫", "骚", "舔我", |
| "fuck", "cum", "penis", "pussy", "cock", "orgasm", "horny", "dick", |
| ] |
|
|
| for _p in (WORK, CAND): |
| _p.mkdir(parents=True, exist_ok=True) |
|
|
|
|
| def log(msg: str) -> None: |
| print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) |
|
|
|
|
| def is_sfw(text: str) -> bool: |
| t = (text or "").lower() |
| return not any(w in t for w in BLOCK) |
|
|
|
|
| def frame_rms(y: np.ndarray, sr: int, hop_s: float = 0.01, win_s: float = 0.025) -> np.ndarray: |
| hop, win = int(sr * hop_s), int(sr * win_s) |
| if len(y) < win: |
| return np.zeros(1, dtype=np.float32) |
| n = 1 + (len(y) - win) // hop |
| idx = np.arange(win)[None, :] + hop * np.arange(n)[:, None] |
| return np.sqrt((y[idx] ** 2).mean(axis=1) + 1e-12) |
|
|
|
|
| def speech_mask(rms: np.ndarray) -> np.ndarray: |
| floor = float(np.percentile(rms, 10)) |
| mask = rms > max(floor * 3.0, 1e-4) |
| gap = 20 |
| i = 0 |
| while i < len(mask): |
| if mask[i]: |
| i += 1 |
| continue |
| j = i |
| while j < len(mask) and not mask[j]: |
| j += 1 |
| if i > 0 and (j - i) < gap and j < len(mask): |
| mask[i:j] = True |
| i = j |
| return mask |
|
|
|
|
| def crop_on_phrase(y: np.ndarray, sr: int): |
| """Pick a CROP_S window beginning at a phrase onset. Returns (audio, stats).""" |
| rms = frame_rms(y, sr) |
| mask = speech_mask(rms) |
| runs, start = [], (0 if mask[0] else None) |
| for e in np.flatnonzero(np.diff(mask.astype(np.int8))): |
| if start is None: |
| start = e + 1 |
| else: |
| runs.append((start, int(e) + 1)) |
| start = None |
| if start is not None: |
| runs.append((start, len(mask))) |
|
|
| per_10ms = int(sr * 0.01) |
| need = int(MIN_SPEECH_S * 100) |
| runs = [r for r in runs if r[1] - r[0] >= need] |
| if not runs: |
| return None, {"reject": "no_phrase"} |
|
|
| s, e = max(runs, key=lambda r: float(rms[r[0]:r[1]].mean())) |
| n = int(CROP_S * 100) |
| if e - s < n: |
| s = max(s, e - n) |
| else: |
| e = s + n |
|
|
| seg = np.asarray(y[s * per_10ms: e * per_10ms], dtype=np.float32) |
| if seg.size < per_10ms * 100 * 0.8: |
| return None, {"reject": "short_crop"} |
| peak = float(np.abs(seg).max()) |
| if peak > 0: |
| seg = seg * (0.90 / peak) |
|
|
| noise = rms[~mask] if (~mask).any() else rms |
| speech = rms[s:e][mask[s:e]] |
| snr = 10 * np.log10(max(1e-8, float(speech.mean()) ** 2 / max(1e-8, float(noise.mean()) ** 2))) |
| stats = { |
| "speech_ratio": float(mask[s:e].mean()), |
| "snr_db": float(snr), |
| "clip_ratio": float((np.abs(seg) > 0.995).mean()), |
| } |
| return seg, stats |
|
|
|
|
| def spectral_flatness(y: np.ndarray, sr: int) -> float: |
| win = int(0.025 * sr) |
| if len(y) < win: |
| return 1.0 |
| frames = np.lib.stride_tricks.sliding_window_view(y, win)[:: int(0.01 * sr)] |
| spec = np.abs(np.fft.rfft(frames * np.hanning(win), axis=1)) + 1e-10 |
| return float(np.median(np.exp(np.log(spec).mean(axis=1)) / spec.mean(axis=1))) |
|
|
|
|
| def speech_modulation(y: np.ndarray, sr: int) -> float: |
| """Share of envelope energy in the 2-8 Hz syllabic band. |
| |
| Speech has a syllabic rhythm; rustling, tapping and room tone do not. This |
| is the physical counterpart to the transcript: whisper-small happily |
| invents a caption over pure noise ("字幕by索兰娅"), so the transcript alone |
| cannot tell us whether anyone is talking. |
| """ |
| hop = int(0.01 * sr) |
| if len(y) < hop * 50: |
| return 0.0 |
| n = len(y) // hop |
| env = np.sqrt((y[: n * hop].reshape(n, hop) ** 2).mean(axis=1) + 1e-12) |
| env = env - env.mean() |
| spec = np.abs(np.fft.rfft(env)) |
| freqs = np.fft.rfftfreq(len(env), 0.01) |
| total = spec.sum() + 1e-12 |
| return float(spec[(freqs >= 2.0) & (freqs <= 8.0)].sum() / total) |
|
|
|
|
| ASR_ARTIFACTS = ("字幕", "by索", "谢谢观看", "请订阅", "amara", "subtitles", "感谢观看") |
|
|
|
|
| def repeated_run(text: str) -> float: |
| """Share of the transcript taken by its longest repeated character run.""" |
| if not text: |
| return 1.0 |
| best, cur = 1, 1 |
| for a, b in zip(text, text[1:]): |
| cur = cur + 1 if a == b else 1 |
| best = max(best, cur) |
| return best / len(text) |
|
|
|
|
| def build_asr(): |
| import torch |
| from transformers import pipeline |
|
|
| pipe = pipeline("automatic-speech-recognition", model="openai/whisper-small", |
| device=0, torch_dtype=torch.float16) |
|
|
| def asr(y: np.ndarray, sr: int) -> str: |
| out = pipe({"array": y.astype(np.float32), "sampling_rate": sr}, |
| generate_kwargs={"language": "zh", "task": "transcribe"}) |
| return (out.get("text", "") if isinstance(out, dict) else str(out)).strip() |
|
|
| return asr |
|
|
|
|
| def harvest(asr) -> list[dict]: |
| import soundfile as sf |
| from datasets import load_dataset |
|
|
| ds = load_dataset(DATASET, split="train", streaming=True) |
| per_artist: dict[str, list[dict]] = {} |
| scanned = 0 |
| t0 = time.time() |
|
|
| for row in ds: |
| scanned += 1 |
| if scanned > MAX_SCAN or len(per_artist) >= N_ARTISTS: |
| break |
| creator = row.get("creator") or "unknown" |
| if len(per_artist.get(creator, [])) >= N_PER_ARTIST: |
| continue |
| if creator not in per_artist and len(per_artist) >= N_ARTISTS: |
| continue |
| if row.get("nsfw") or not row.get("has_verbal_speech") or row.get("hallucinated"): |
| continue |
| if not is_sfw(row.get("transcript", "")): |
| continue |
|
|
| try: |
| audio = row["audio"] |
| y = np.asarray(audio["array"], dtype=np.float32).reshape(-1) |
| sr = int(audio["sampling_rate"]) |
| except Exception: |
| continue |
|
|
| seg, st = crop_on_phrase(y, sr) |
| if seg is None: |
| continue |
| flat = spectral_flatness(seg, sr) |
| mod = speech_modulation(seg, sr) |
| st["flatness"] = flat |
| st["modulation"] = mod |
| if st["snr_db"] < 12 or st["clip_ratio"] > 1e-3 or st["speech_ratio"] < 0.55 or flat > 0.35: |
| continue |
| |
| |
| |
| |
| |
| |
|
|
| text = asr(seg, sr) |
| if not (6 <= len(text) <= 70) or repeated_run(text) > 0.3 or not is_sfw(text): |
| continue |
| if any(a in text for a in ASR_ARTIFACTS): |
| continue |
| |
| |
| rate = len(text) / (len(seg) / sr) |
| if not (2.5 <= rate <= 9.0): |
| continue |
|
|
| idx = len(per_artist.get(creator, [])) |
| tag = hashlib.md5(creator.encode("utf-8")).hexdigest()[:4] |
| cid = f"{tag}_{idx}" |
| path = CAND / f"{cid}.wav" |
| sf.write(str(path), seg, sr) |
| per_artist.setdefault(creator, []).append({ |
| "cid": cid, "artist": creator, "wav": str(path), |
| "prompt_text": text, "duration_s": round(len(seg) / sr, 2), **st, |
| "source_file": row.get("source_file"), "clip_index": row.get("clip_index"), |
| }) |
| if len(per_artist[creator]) == 1: |
| log(f"artist {len(per_artist)}: {creator[:40]} first candidate ok") |
|
|
| out = [c for cl in per_artist.values() for c in cl] |
| (WORK / "candidates.json").write_text(json.dumps(out, ensure_ascii=False, indent=2)) |
| log(f"harvest: {len(per_artist)} artists, {len(out)} candidates, scanned {scanned} " |
| f"rows in {time.time()-t0:.0f}s") |
| return out |
|
|
|
|
| def hf_ratio(y: np.ndarray, sr: int, cut: int = 8000) -> float: |
| """Energy share above `cut`. A 16 kHz source cannot produce it, so a dull |
| clone shows up here even when CER looks fine.""" |
| 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 patch_fp32() -> None: |
| """T4 has no bf16 and the repo defaults to it.""" |
| 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 probe(cands: list[dict], asr) -> list[dict]: |
| import torch |
|
|
| sys.path.insert(0, str(REPO)) |
| patch_fp32() |
| from ming_tts import MingTTS |
| import tts_tasks |
|
|
| sys.path.insert(0, str(ROOT / "webfm-eval/eval")) |
| from score import load_t2s, score_row |
|
|
| table = load_t2s() |
| tts = MingTTS(str(MODEL), device="cuda", text_normalization=False) |
| mm = tts.model |
| device = next(mm.parameters()).device |
| dtype = next(mm.parameters()).dtype |
| _ = tts_tasks.build_tts_prompt("Chinese") |
|
|
| results = [] |
| for i, c in enumerate(cands): |
| try: |
| t0 = time.time() |
| torch.manual_seed(1234) |
| lat, spk = tts.prepare_prompt(c["wav"], use_spk_emb=True) |
| lat = lat.to(device=device, dtype=dtype) |
| ces, hfs = [], [] |
| for text in PROBE_TEXTS: |
| wav = tts.synthesize( |
| task="TTS", text=text, language_id="Chinese", |
| prompt_wav_path=c["wav"], prompt_text=c["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) |
| ces.append(score_row({"text": text, "hyp_text": asr(arr, 44100)}, table)["cer_norm"]) |
| hfs.append(hf_ratio(arr, 44100)) |
| row = dict(c, cer=float(np.mean(ces)), cer_each=ces, |
| hf=float(np.mean(hfs)), wall=round(time.time() - t0, 1)) |
| |
| |
| |
| row["keep"] = bool(row["cer"] < 0.5) |
| results.append(row) |
| log(f"[{i+1}/{len(cands)}] {c['cid']} cer={row['cer']:.3f} hf={row['hf']:.4f} " |
| f"snr={c['snr_db']:.1f} {c['prompt_text'][:16]}") |
| except Exception: |
| log(f"{c['cid']} probe failed\n{traceback.format_exc()}") |
|
|
| results.sort(key=lambda r: (r["cer"], -r["hf"])) |
| (WORK / "probe.json").write_text(json.dumps(results, ensure_ascii=False, indent=2)) |
| return results |
|
|
|
|
| def select(results: list[dict]) -> list[dict]: |
| best: dict[str, dict] = {} |
| for r in results: |
| best.setdefault(r["artist"], r) |
| ranked = [r for r in sorted(best.values(), key=lambda r: r["cer"]) |
| if r.get("keep", True)][:TOP_K] |
| (WORK / "best.json").write_text(json.dumps(ranked, ensure_ascii=False, indent=2)) |
| log("\n-- best per artist --") |
| for r in ranked: |
| log(f" {r['cer']:.3f} hf={r['hf']:.4f} {r['artist'][:34]:<34} " |
| f"{r['duration_s']}s {r['prompt_text'][:20]}") |
| return ranked |
|
|
|
|
| def main() -> None: |
| asr = build_asr() |
| if STAGE in ("harvest", "all"): |
| cands = harvest(asr) |
| else: |
| cands = json.loads((WORK / "candidates.json").read_text()) |
| if STAGE in ("probe", "all"): |
| select(probe(cands, asr)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
|
|
|
|
