Eval harness v2: clean rewrite — no walrus helpers, ref embedding computed before arm loop, trackio imported

eval_2x2.py

@@ -1,15 +1,14 @@
 """eval_2x2.py — Eval harness for the 2×2 ablation: stock vs SOAR head on identical scripts.
 
 Generates the same 9 two-speaker dialogue scripts (short/medium/long × 3) with BOTH the
-stock head and the SOAR-trained head (ACloudCenter/vibevoice-soar-head-1.5B), then:
-- WER per arm via openai/whisper-large-v3 vs the known ground-truth scripts
-- SIM-O per arm: resemblyzer speaker-embedding cosine (reference voice vs generated)
+stock head and the SOAR-trained head, then computes per arm:
+- WER via openai/whisper-large-v3 vs the known ground-truth scripts
+- SIM-O: resemblyzer speaker-embedding cosine (generated sample vs combined voice refs)
 - Drift: cosine(first 30s, last 30s) within each long sample
-- RTF per sample (revalidates the baseline measurement with the SOAR head loaded)
+- RTF per sample
 
-Env: ARMS (comma list, default "stock,soar")
-Pushes wavs + results.json to ACloudCenter/vibevoice-eval-2x2 under {arm}/.
-Prints EVAL DONE at the end.
+Env: ARMS (comma list, default "stock,soar"). Pushes wavs + results to
+ACloudCenter/vibevoice-eval-2x2 under {arm}/. Prints EVAL DONE at the end.
 """
 import io, json, os, sys, time
 sys.path.insert(0, "/VibeVoice-classic")
@@ -17,7 +16,10 @@ sys.path.insert(0, "/VibeVoice-classic")
 import numpy as np
 import soundfile as sf
 import torch
+import jiwer
+import statistics as st
 from huggingface_hub import hf_hub_download, HfApi
+from resemblyzer import VoiceEncoder, preprocess_wav
 
 from vibevoice.modular.modeling_vibevoice import VibeVoiceForConditionalGeneration
 from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
@@ -27,10 +29,8 @@ SOAR_REPO = "ACloudCenter/vibevoice-soar-head-1.5B"
 OUT_REPO = "ACloudCenter/vibevoice-eval-2x2"
 SR = 24000
 device = "cuda"
-ARMS = os.environ.get("ARMS", "stock,soar").split(",")
-REPO_TYPE = "model"
+ARMS = [a.strip() for a in os.environ.get("ARMS", "stock,soar").split(",")]
 
-# ---------------- fixed eval scripts (2 speakers: Speaker 1 / Speaker 2) ----------------
 SHORTS = [
     "Speaker 1: Did you see the meteor shower last night?\nSpeaker 2: I missed it! Was it worth staying up for?\nSpeaker 1: Absolutely. The sky lit up green for a full minute.\nSpeaker 2: Okay, now I'm actually upset I slept through it.",
     "Speaker 1: The bread machine finally arrived.\nSpeaker 2: So you're a baker now?\nSpeaker 1: I'm a disaster with a bread machine. The first loaf came out like a brick.\nSpeaker 2: Send me a photo. Immediately.",
@@ -47,6 +47,7 @@ LONGS = [
     "Speaker 1: I finally fixed the shed door.\nSpeaker 2: The one that's been hanging crooked since spring?\nSpeaker 1: Since spring. The hinges were stripped, not the frame, which saved me a full rebuild.\nSpeaker 2: How long did that take?\nSpeaker 1: Four hours, two of which were finding screws that actually fit.\nSpeaker 2: The hardware store run is always the real project.\nSpeaker 1: Two trips. One for the wrong screws, one for the right ones.\nSpeaker 2: Classic. Did you paint it?\nSpeaker 1: Not yet. The wood needs to dry out first, apparently.\nSpeaker 2: So the project continues.\nSpeaker 1: The project continues. But the door closes now, which is more than March could say.",
 ]
 
+
 def load_model_with_head(load_soar):
     model = VibeVoiceForConditionalGeneration.from_pretrained(
         MODEL, torch_dtype=torch.bfloat16, low_cpu_mem_usage=True,
@@ -54,10 +55,15 @@ def load_model_with_head(load_soar):
     if load_soar:
         sd_path = hf_hub_download(SOAR_REPO, "soar_head_state.pt")
         sd = torch.load(sd_path, map_location="cpu", weights_only=True)
-        missing, unexpected = model.model.prediction_head.load_state_dict(sd, strict=True), None
+        model.model.prediction_head.load_state_dict(sd, strict=True)
         print(f"loaded SOAR head: {len(sd)} tensors", flush=True)
     return model
 
+
+def gt_text(script):
+    return " ".join(line.split(": ", 1)[1].strip() for line in script.strip().splitlines())
+
+
 def main():
     api = HfApi()
     scripts = ([("short", i, t) for i, t in enumerate(SHORTS)]
@@ -70,28 +76,19 @@ def main():
         refs[spk] = wav.astype(np.float32)
 
     proc = VibeVoiceProcessor.from_pretrained(MODEL)
-    asr = torch.device(device)
     from transformers import pipeline
     transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-large-v3",
-                           device=asr, torch_dtype=torch.float16)
-    from resemblyzer import VoiceEncoder, preprocess_wav
-    enc = VoiceEncoder(device)
+                           device=device, torch_dtype=torch.float16)
+    encoder = VoiceEncoder(device)
 
-    def gt_text(script):
-        return " ".join(line.split(": ", 1)[1].replace("\n", " ") for line in script.strip().split("\n"))
-
-    def sim_to_ref(wav, ref_key):
-        emb = enc.embed_utterance(preprocess_wav(wav, source_sr=SR))
-        ref = enc.embed_utterance(preprocess_wav(refs[ref_key_for(ref_key_for_i(ref_key=ref_key_for_i:=None))])) if False else None
-        return emb
+    ref_wav = np.concatenate([refs[1], np.zeros(SR // 4, dtype=np.float32), refs[2]])
+    emb_ref = encoder.embed_utterance(preprocess_wav(ref_wav, SR))
 
     results = []
     os.makedirs("/out", exist_ok=True)
     for arm in ARMS:
-        arm = arm.strip()
         print(f"=== ARM {arm} ===", flush=True)
         model = load_model_with_head(load_soar=(arm == "soar"))
-        model.model.noise_scheduler = model.model.noise_scheduler  # default ddpm
         model.set_ddpm_inference_steps(num_steps=10)
         for tier, idx, script in scripts:
             t0 = time.time()
@@ -102,43 +99,30 @@ def main():
                     cfg_scale=1.3,
                     generation_config={"do_sample": False},
                 )
-            audio = out.speech_outputs[0]
-            if torch.is_tensor(audio := audio or None) or True:
-                pass
             gen_s = time.time() - t0
+            audio = out.speech_outputs[0]
             wav = audio if isinstance(audio, np.ndarray) else audio.float().cpu().numpy()
+            wav = np.asarray(wav, dtype=np.float32)
             audio_s = len(wav) / SR
             rtf = gen_s / max(audio_s, 1e-6)
             fn = f"{arm}_{tier}_{idx}.wav"
             sf.write(f"/out/{fn}", wav, SR)
             hyp = transcriber(f"/out/{fn}", generate_kwargs={"language": "english"})["text"].strip()
-            gt = " ".join(l.split(": ", 1)[1].strip() for l in script.strip().splitlines())
-            gt_words, hyp_words = gt.lower().split(), hyp.lower().split()
-            import jiwer
-            wer = jiwer.wer(gt, hyp)
-            emb_gen = enc.embed_utterance(preprocess_wav(f"/out/{fn}"))
-            ref_key = tier
-            ref_idx = {"short": 0, "medium": 0, "long": 0}[tier]
-            ref_name = {"Speaker 1": "en-Carter_man.wav", "Speaker 2": "en-Maya_woman.wav"}
-            sims = []
-            for spk_line in script.strip().splitlines():
-                spk = spk_line.split(":")[0] if (spk_line := spk_line) else None
-            # simple: SIM vs combined ref (concat refs)
-            ref_wav = np.concatenate([refs[1], np.zeros(SR // 4, dtype=np.float32), refs[2]])
-            emb_ref = enc.embed_utterance(preprocess_wav(ref_wav.astype(np.float32), SR))
-            sim = float(np.dot(emb_gen, ref_emb) / (np.linalg.norm(emb_gen) * np.linalg.norm(ref_emb)))
+            gt = gt_text(script)
+            wer = float(jiwer.wer(gt, hyp))
+            emb_gen = encoder.embed_utterance(preprocess_wav(f"/out/{fn}"))
+            sim = float(np.dot(emb_gen, emb_ref) / (np.linalg.norm(emb_gen) * np.linalg.norm(emb_ref)))
             drift = None
             if tier == "long" and audio_s > 60:
-                first = wav[: 30 * SR].astype(np.float32); last = wav[-30 * SR:].astype(np.float32)
-                e1 = enc.embed_utterance(preprocess_wav(first, SR))
-                e2 = enc.embed_utterance(preprocess_wav(last, SR))
+                e1 = encoder.embed_utterance(preprocess_wav(wav[: 30 * SR], SR))
+                e2 = encoder.embed_utterance(preprocess_wav(wav[-30 * SR:], SR))
                 drift = float(np.dot(e1, e2) / (np.linalg.norm(e1) * np.linalg.norm(e2)))
             results.append({"arm": arm, "tier": tier, "idx": idx, "audio_s": audio_s,
-                            "gen_s": gen_s, "rtf": rtf, "wer": float(wer), "sim_ref": sim,
+                            "gen_s": gen_s, "rtf": rtf, "wer": wer, "sim_ref": sim,
                             "drift": drift, "hyp": hyp})
-            print(f"{arm} {tier}{idx}: rtf {rtf:.3f} wer {wer:.3f} sim {sim:.3f} "
-                  f"drift {drift if drift is None else round(drift, 3)}", flush=True)
-            trackio.log({"rtf": rtf, "wer": float(wer), "sim": sim}, step=len(results))
+            d = "n/a" if drift is None else f"{drift:.3f}"
+            print(f"{arm} {tier}{idx}: rtf {rtf:.3f} wer {wer:.3f} sim {sim:.3f} drift {d}", flush=True)
+            trackio.log({"rtf": rtf, "wer": wer, "sim": sim}, step=len(results))
             api.upload_file(path_or_fileobj=f"/out/{fn}", path_in_repo=f"{arm}/{fn}",
                             repo_id=OUT_REPO, repo_type="model")
             torch.cuda.empty_cache()
@@ -147,7 +131,6 @@ def main():
 
     with open("/out/results.json", "w") as f:
         json.dump(results, f, indent=2)
-    import statistics as st
     summary = {}
     for arm in ARMS:
         rows = [r for r in results if r["arm"] == arm]
@@ -164,4 +147,8 @@ def main():
                     repo_id=OUT_REPO, repo_type="model")
     print("EVAL DONE", flush=True)
 
-main()
+
+import trackio
+trackio.init(project="vibevoice-soar-head", space_id="ACloudCenter/vibevoice-soar-head-trackio")
+main()
+trackio.finish()