fix lm cache order and additive mask; probe audio VAE

kaggle/export_browser.py

@@ -80,30 +80,33 @@ def stage_lm(mm, torch) -> dict:
             self.lm = lm
 
         def forward(self, inputs_embeds, attention_mask, position_ids, *past):
+            # past arrives as [k0..k(n-1), v0..v(n-1)]; keep that order on the way out too.
             k, v = past[:n], past[n:]
             cache = tuple((k[i], v[i]) for i in range(n))
             out = self.lm(inputs_embeds=inputs_embeds, attention_mask=attention_mask,
                           position_ids=position_ids, past_key_values=cache,
                           use_cache=True, output_hidden_states=True, return_dict=True)
             new = out.past_key_values
-            flat = []
-            for i in range(n):
-                flat.append(new[i][0])
-                flat.append(new[i][1])
-            return (out.hidden_states[-1], *flat)
+            ks = [new[i][0] for i in range(n)]
+            vs = [new[i][1] for i in range(n)]
+            return (out.hidden_states[-1], *ks, *vs)
 
     wrapper = Wrapper().float().eval()
     dev = next(lm.parameters()).device
     B, S, P = 1, 4, 6
     H = cfg.hidden_size
     embeds = torch.randn(B, S, H, device=dev)
-    mask = torch.zeros(B, 1, S, P + S, device=dev)
+    # Qwen2 adds this mask to the attention scores, so blocked positions need a
+    # large negative value; 0/1 would let the model attend to the future.
+    neg = torch.finfo(torch.float32).min / 2
+    mask = torch.full((B, 1, S, P + S), neg, device=dev)
     for i in range(S):
-        mask[:, :, i, :P + i + 1] = 1.0
+        mask[:, :, i, :P + i + 1] = 0.0
     pos = torch.arange(P, P + S, device=dev).unsqueeze(0)
     past = []
     for _ in range(n):
         past.append(torch.randn(B, kv_heads, P, head_dim, device=dev))
+    for _ in range(n):
         past.append(torch.randn(B, kv_heads, P, head_dim, device=dev))
 
     with torch.no_grad():
@@ -132,8 +135,8 @@ def stage_lm(mm, torch) -> dict:
     feeds = {"inputs_embeds": np_(embeds), "attention_mask": np_(mask),
              "position_ids": np_(pos)}
     for i in range(n):
-        feeds[f"past_k_{i}"] = np_(past[2 * i])
-        feeds[f"past_v_{i}"] = np_(past[2 * i + 1])
+        feeds[f"past_k_{i}"] = np_(past[i])
+        feeds[f"past_v_{i}"] = np_(past[n + i])
     got = sess.run(None, feeds)
     cos = [cosine(np_(ref[i]), got[i]) for i in range(3)]
     log(f"validate hidden cos={cos[0]:.6f} k0={cos[1]:.6f} v0={cos[2]:.6f}")
@@ -223,6 +226,39 @@ def quantize(paths: list[Path], bits: int = 4) -> list[dict]:
     return rows
 
 
+def stage_probe_audio(mm) -> dict:
+    """Dump the audio VAE surface so the vocoder export can stop before ISTFT.
+
+    `decode` builds a complex STFT internally, which the ONNX exporter refuses
+    ("Unknown number type: complex"). The fix is to return the spectrum and do
+    the inverse transform on the host, but that needs the real method names.
+    """
+    import inspect
+
+    audio = mm.audio
+    text = []
+    text.append("class: " + type(audio).__name__)
+    text.append("\nattrs: " + ", ".join(a for a in dir(audio) if not a.startswith("__")))
+    for name in dir(audio):
+        if name.startswith("__"):
+            continue
+        fn = getattr(audio, name)
+        if not callable(fn):
+            continue
+        try:
+            src = inspect.getsource(fn)
+        except Exception:
+            continue
+        if any(k in src for k in ("istft", "stft", "complex", "spectrogram", "def decode", "def encode")):
+            text.append(f"\n\n===== {name} =====\n{src}")
+    out = OUT / "audio_src.txt"
+    out.write_text("\n".join(text))
+    log(f"wrote {out} ({len(text)} blocks)")
+    for line in text[:80]:
+        log(line)
+    return {"graph": "probe_audio", "chars": sum(len(t) for t in text)}
+
+
 def main() -> None:
     import torch
 
@@ -234,7 +270,8 @@ def main() -> None:
     mm = tts.model
     results = []
 
-    for name, fn in (("lm", stage_lm), ("agg", stage_agg), ("voc", stage_voc)):
+    for name, fn in (("lm", stage_lm), ("agg", stage_agg), ("probe", lambda m, t: stage_probe_audio(m)),
+                     ("voc", stage_voc)):
         if STAGE not in (name, "all"):
             continue
         try:
@@ -243,6 +280,9 @@ def main() -> None:
             log(f"stage {name} FAILED\n{traceback.format_exc()}")
 
     q = quantize([OUT / "lm.onnx", OUT / "aggregator.onnx", OUT / "voc.onnx"])
+    (OUT / "sizes.json").write_text(json.dumps(
+        {p_.name: round(p_.stat().st_size / 1e6, 1) for p_ in sorted(OUT.glob("*.onnx"))},
+        indent=1))
     (OUT / "report.json").write_text(json.dumps({"graphs": results, "quant": q},
                                                 ensure_ascii=False, indent=1))
     log("done")