voc: stop at the ISTFT head projection, ship spec

kaggle/export_browser.py

@@ -167,41 +167,60 @@ def stage_agg(mm, torch) -> dict:
 
 
 def stage_voc(mm, torch) -> dict:
+    """Export the vocoder up to the ISTFT head's linear projection.
+
+    `decode` ends in a complex STFT, which ONNX cannot represent. The head does
+    `linear -> (mag, phase) -> complex -> istft`, so the last real-valued tensor
+    is the projection output. The host does the rest, matching the documented
+    `voc -> spec` contract.
+    """
     import onnxruntime as ort
 
-    audio = mm.audio
+    dec = mm.audio.decoder
+    head = dec.head
+    lin = getattr(head, "linear", None)
+    if lin is None:
+        lin = next((m for m in head.modules() if isinstance(m, torch.nn.Linear)), None)
+    if lin is None:
+        raise RuntimeError("could not find the ISTFT head projection layer")
+    log(f"head projection: out_features={getattr(lin, 'out_features', '?')}")
 
-    class Voc(torch.nn.Module):
+    class VocSpec(torch.nn.Module):
         def __init__(self):
             super().__init__()
-            self.a = audio
+            self.dec = dec
 
         def forward(self, latent):
-            out = self.a.decode(latent, past_key_values=None, use_cache=False,
-                                last_chunk=True)
-            return out[0] if isinstance(out, (tuple, list)) else out
+            x = self.dec.fc1(latent)
+            if getattr(self.dec, "patch_size", -1) != -1:
+                x = self.dec.upsampling.upsampler(x.transpose(1, 2)).transpose(1, 2)
+            x = self.dec.decoder(inputs_embeds=x).last_hidden_state
+            return lin(x)
 
-    voc = Voc().float().eval()
+    voc = VocSpec().float().eval()
     T = 8
-    dev = next(audio.parameters()).device
+    dev = next(dec.parameters()).device
     dummy = torch.randn(1, T, mm.latent_dim, device=dev)
     with torch.no_grad():
         ref = voc(dummy)
-    log(f"voc ref shape {tuple(ref.shape)}")
-    if ref.dim() == 2:
-        ref = ref.unsqueeze(1)
+    log(f"spec shape {tuple(ref.shape)}")
 
     path = OUT / "voc.onnx"
     torch.onnx.export(voc, (dummy,), str(path), input_names=["latent"],
-                      output_names=["waveform"], dynamic_axes={"latent": {1: "t"}},
+                      output_names=["spec"], dynamic_axes={"latent": {1: "t"}},
                       opset_version=20, do_constant_folding=True, dynamo=False)
     sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"])
     got = sess.run(None, {"latent": np_(dummy)})[0]
-    if got.ndim == 2:
-        got = got[:, None]
     c = cosine(np_(ref), got)
-    log(f"voc.onnx {path.stat().st_size / 1e6:.0f} MB cos={c:.6f} out={got.shape}")
-    return {"graph": "voc", "mb": round(path.stat().st_size / 1e6, 1), "cos": c}
+    log(f"voc.onnx {path.stat().st_size / 1e6:.0f} MB cos={c:.6f} spec={got.shape}")
+
+    meta = {"n_fft": int(head.n_fft), "hop_length": int(head.hop_length),
+            "padding": str(getattr(head, "padding", "same")),
+            "spec_bins": int(got.shape[-1]), "frames_per_latent": T}
+    (OUT / "voc_meta.json").write_text(json.dumps(meta, indent=1))
+    log(f"voc meta {meta}")
+    return {"graph": "voc", "mb": round(path.stat().st_size / 1e6, 1), "cos": c,
+            "spec_shape": list(got.shape)}
 
 
 def quantize(paths: list[Path], bits: int = 4) -> list[dict]: