"""diagnose_closedloop.py v2 — three-part diagnosis of the SOAR closed-loop failure. Part A: per-5s RMS(dB) + spectral flatness for all 18 eval wavs + Whisper first/last 10s. Part B: latent-scale check — std(x0hat)/std(x0_target), stock vs SOAR head. Part C: teacher-forced v-pred loss, stock vs SOAR head, 8 held-out shard-3 dialogues. Prints DIAGNOSIS DONE. """ import io, os, random, sys sys.path.insert(0, "/VibeVoice-classic") import numpy as np import pyarrow.parquet as pq import soundfile as sf import torch import torch.nn.functional as F from huggingface_hub import hf_hub_download from vibevoice.modular.modeling_vibevoice import VibeVoiceForConditionalGeneration from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor from vibevoice.processor.vibevoice_tokenizer_processor import AudioNormalizer MODEL = "microsoft/VibeVoice-1.5B" SOAR_REPO = "ACloudCenter/vibevoice-soar-head-1.5B" EVAL_REPO = "ACloudCenter/vibevoice-eval-2x2" SR, COMPRESS, LATENT_DIM, SEM_DIM = 24000, 3200, 64, 128 device = "cuda" TIERS = ["short", "short", "short", "medium", "medium", "medium", "long", "long", "long"] def load_dialogues(shard_idx, min_turns=4, max_turns=10, min_sec=20.0, max_sec=60.0, limit=None): fn = hf_hub_download("eustlb/dailytalk", f"data/train-{shard_idx:05d}-of-00009.parquet", repo_type="dataset") tbl = pq.read_table(fn, columns=["conversation_id", "turn_id", "speaker_id", "text", "audio"]) cids = tbl.column("conversation_id").to_pylist() tids = tbl.column("turn_id").to_pylist() spks = tbl.column("speaker_id").to_pylist() texts = tbl.column("text").to_pylist() auds = tbl.column("audio").to_pylist() convs = {} for i, cid in enumerate(cids): convs.setdefault(cid, []).append(i) out = [] for cid, idxs in convs.items(): idxs.sort(key=lambda i: tids[i]) turns, ok = [], True for i in idxs: try: wav, sr = sf.read(io.BytesIO(auds[i]["bytes"])) except Exception: ok = False break if sr != SR or wav.ndim > 1: ok = False break turns.append((1 + int(spks[i]), texts[i], wav.astype(np.float32))) if not ok: continue total = sum(len(w) for _, _, w in turns) / SR nspk = len(set(s for s, _, _ in turns)) if min_turns <= len(turns) <= max_turns and min_sec <= total <= max_sec and nspk == 2: out.append(turns) if limit and len(out) >= limit: break return out def build_sample(model, proc, tok, dialogue, refs, turn_sec_cap, gap_sec=0.45): _TD = next(model.model.acoustic_tokenizer.parameters()) audio_norm = AudioNormalizer() parts = [] for spk, text, wav in dialogue: parts.append(audio_norm(wav[: int(turn_sec_cap * SR)]).astype(np.float32)) parts.append(np.zeros(int(gap_sec * SR), dtype=np.float32)) if len(parts): parts.pop() target = np.concatenate(parts).astype(np.float32) script = "".join(f"Speaker {spk}: {text.strip()}\n" for spk, text, _ in dialogue) with torch.no_grad(): out = proc(text=[script], voice_samples=[[refs[1], refs[2]]], padding=False, return_tensors="pt", return_attention_mask=True) ids = out["input_ids"][0].tolist() sim = out["speech_input_mask"][0].tolist() voice_np = out["speech_tensors"].cpu().numpy() voice_masks = out["speech_masks"].cpu().numpy().astype(bool) n_voice = voice_np.shape[0] with torch.no_grad(): _enc = model.model.acoustic_tokenizer.encode(torch.from_numpy(target).to(_TD)[None, None, :]) t_lat, _ = _enc.sample("fix") T_t = t_lat.shape[1] lat_segs = [] for i in range(n_voice): T_v = int(voice_masks[i].sum()) w = torch.from_numpy(np.ascontiguousarray(voice_np[i][: T_v * COMPRESS])).to(_TD)[None, None, :] with torch.no_grad(): e = model.model.acoustic_tokenizer.encode(w) v_lat, _ = e.sample("fix") lat_segs.append(v_lat[0]) lat_segs.append(t_lat[0]) n_seg = len(lat_segs) max_lat = max(s.shape[0] for s in lat_segs) speech_tensors = np.zeros((n_seg, max_lat, LATENT_DIM), dtype=np.float32) for i, s in enumerate(lat_segs): speech_tensors[i, : s.shape[0]] = s.float().cpu().numpy() speech_masks = np.zeros((n_seg, max_lat), dtype=bool) loss_input = np.zeros((n_seg, max_lat), dtype=bool) for i, s in enumerate(lat_segs): speech_masks[i, : s.shape[0]] = True loss_input[-1, : T_t] = True sems = np.zeros((n_seg, max_lat, SEM_DIM), dtype=np.float32) with torch.no_grad(): for i in range(n_voice): T_v = int(voice_masks[i].sum()) w = torch.from_numpy(np.ascontiguousarray(voice_np[i][: T_v * COMPRESS])).to(_TD)[None, None, :] m = model.model.semantic_tokenizer.encode(w).mean[0] n = min(m.shape[0], max_lat) sems[i, :n] = m[:n].float().cpu().numpy() m = model.model.semantic_tokenizer.encode(torch.from_numpy(target).to(_TD)[None, None, :]).mean[0] n = min(m.shape[0], max_lat) sems[-1, :n] = m[:n].float().cpu().numpy() diff_id, end_id = tok.speech_diffusion_id, tok.speech_end_id eos = getattr(tok, "eos_token_id", None) tail = [end_id] + ([eos] if eos is not None else []) ids_ext = ids + [diff_id] * T_t + tail in_mask = sim + [True] * T_t + [False] * len(tail) lo_mask = [False] * len(ids) + [True] * T_t + [False] * len(tail) return { "input_ids": torch.tensor(ids_ext, dtype=torch.long), "in_mask": torch.tensor(in_mask, dtype=torch.bool), "prompt_len": len(ids), "lo_mask": torch.tensor(lo_mask, dtype=torch.bool), "speech_tensors": torch.from_numpy(speech_tensors), "speech_masks": torch.from_numpy(speech_masks), "loss_input": torch.from_numpy(loss_input), "sems": torch.from_numpy(sems), } def part_a(): from transformers import pipeline transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-large-v3", device=device, torch_dtype=torch.float16, chunk_length_s=30) print("=== PART A: onset / energy-growth analysis ===", flush=True) for arm in ("stock", "soar"): for idx, tier in enumerate(TIERS): fn = f"{arm}_{tier}_{idx % 3}.wav" p = hf_hub_download(EVAL_REPO, f"{arm}/{fn}", repo_type="model") wav, sr = sf.read(p, dtype="float32") win = 5 * sr nwin = max(1, len(wav) // win) rms, flat = [], [] for k in range(nwin): w = wav[k * win:(k + 1) * win] rms.append(20 * np.log10(np.sqrt(np.mean(w ** 2)) + 1e-9)) spec = np.abs(np.fft.rfft(w)) ** 2 flat.append(float(np.exp(np.mean(np.log(spec + 1e-12))) / (np.mean(spec) + 1e-12))) def fmt(xs, f="{:5.1f}"): return " ".join(f.format(x) for x in xs) print(f"{fn}: dur {len(wav) / sr:6.1f}s", flush=True) print(f" rmsdB {fmt(rms[:20])}", flush=True) print(f" flatn {fmt(flat[:20], '{:5.2f}')}", flush=True) if arm == "soar": first = transcriber({"array": wav[: 10 * sr], "sampling_rate": sr}, generate_kwargs={"language": "english"})["text"].strip() last = transcriber({"array": wav[-10 * sr:], "sampling_rate": sr}, generate_kwargs={"language": "english"})["text"].strip() print(f" first10s: {first[:120]!r}", flush=True) print(f" last10s : {last[:120]!r}", flush=True) def build_conditions(model, proc, tok, refs, dialogues): conds = [] for di, dialogue in enumerate(dialogues): b = build_sample(model, proc, tok, dialogue, refs, 3.0) smask = b["speech_masks"].to(device) n_t = int(b["loss_input"].sum()) with torch.no_grad(): x = model.get_input_embeddings()(b["input_ids"].to(device)[None]) af, conn = model.forward_speech_features( speech_tensors=b["speech_tensors"].to(device).type_as(x), speech_masks=smask, speech_type="vae", return_unmask=True) sem_conn = model.model.semantic_connector(b["sems"].to(device).type_as(x)) feat_all = conn[smask] + sem_conn[smask] assert feat_all.shape[0] == int(smask.sum()) def cond_from(xe): h = model.model.language_model( inputs_embeds=xe, attention_mask=torch.ones(1, xe.shape[1], device=device), use_cache=False).last_hidden_state return h[b["lo_mask"].unsqueeze(0).to(device)] xe_c = x.clone() xe_c[b["in_mask"].unsqueeze(0).to(device)] = feat_all cond_c = cond_from(xe_c) x0 = af[b["loss_input"].to(device) & smask] assert x0.shape[0] == n_t conds.append({"cond": cond_c, "x0": x0}) print(f"cond {di}: frames {n_t}", flush=True) return conds def eval_head(model, sched, conds, tag, seed=7): torch.manual_seed(7) random.seed(7) mul = 4 losses, ratios, ratios_low = [], [], [] with torch.no_grad(): for ci, c in enumerate(conds): x0 = c["x0"].to(device) cond = c["cond"].to(device) N = x0.shape[0] t = torch.multinomial(torch.ones(1000), N * mul, replacement=True).to(device) noise = torch.randn(N * mul, LATENT_DIM, device=device) x0r = x0.repeat_interleave(mul, 0) noisy = sched.add_noise(x0r, noise, t) tv = sched.get_velocity(x0r, noise, t) v = model.model.prediction_head(noisy, t.type_as(noisy), cond.repeat_interleave(mul, 0)) el = ((v.float() - tv.float()) ** 2).mean(-1) losses.append(float(el.mean())) a1 = sched.alpha_t[t].view(-1, 1).float() s1 = sched.sigma_t[t].view(-1, 1).float() x0h = a1 * noisy.float() - s1 * v.float() ratios.append(float(x0h.std() / x0r.float().std())) m = t < 200 if int(m.sum()) > 0: ratios_low.append(float(x0h[m].std() / x0r[m].float().std())) print(f" dlg {ci}: per-elem {float(el.mean()):.4f} x0hat/target {ratios[-1]:.3f}", flush=True) low = np.mean(ratios_low) if ratios_low else float("nan") print(f"HEAD {tag}: mean tfl {np.mean(losses):.4f} | x0hat/target {np.mean(ratios):.3f} | t<200 {low:.3f}", flush=True) return np.mean(losses) random.seed(0) torch.manual_seed(0) np.random.seed(0) print("=== PART A ===", flush=True) part_a() print("=== loading model (fp32) ===", flush=True) model = VibeVoiceForConditionalGeneration.from_pretrained( MODEL, torch_dtype=torch.float32, low_cpu_mem_usage=True).to(device).eval() proc = VibeVoiceProcessor.from_pretrained(MODEL) tok = proc.tokenizer sched = model.model.noise_scheduler assert hasattr(sched, "alpha_t") and hasattr(sched, "sigma_t") alpha_t = sched.alpha_t.to(device).float() sigma_t = sched.sigma_t.to(device).float() refs = {} for spk, name in ((1, "en-Carter_man.wav"), (2, "en-Maya_woman.wav")): wav, sr = sf.read(f"/VibeVoice-classic/demo/voices/{name}") assert sr == SR refs[spk] = wav.astype(np.float32) dgs = load_dialogues(3, limit=8) print(f"held-out dialogues: {len(dgs)}", flush=True) conds = build_conditions(model, proc, tok, refs, dgs) print("=== PARTS B+C: stock head ===", flush=True) head0 = {k: v.clone() for k, v in model.model.prediction_head.state_dict().items()} stock_loss = eval_head(model, sched, conds, "stock") print("=== PARTS B+C: SOAR head ===", flush=True) sd_path = hf_hub_download(SOAR_REPO, "soar_head_state.pt") sd = torch.load(sd_path, map_location="cpu", weights_only=True) model.model.prediction_head.load_state_dict(sd, strict=True) soar_loss = eval_head(model, sched, conds, "soar") print(f"VERDICT teacher-forced: stock {stock_loss:.4f} vs soar {soar_loss:.4f}", flush=True) model.model.prediction_head.load_state_dict(head0) print("DIAGNOSIS DONE", flush=True)