diagnose_closedloop.py

"""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)