export: drop removed kwarg, host-side numpy

kaggle/export_browser.py

@@ -49,6 +49,10 @@ def patch_fp32() -> None:
         p.write_text(s)
 
 
+def np_(t):
+    return t.detach().cpu().numpy()
+
+
 def cosine(a, b) -> float:
     a = np.asarray(a, dtype=np.float64).reshape(-1)
     b = np.asarray(b, dtype=np.float64).reshape(-1)
@@ -121,17 +125,17 @@ def stage_lm(mm, torch) -> dict:
     torch.onnx.export(wrapper, (embeds, mask, pos, *past), str(path),
                       input_names=names_in, output_names=names_out,
                       dynamic_axes=dyn, opset_version=20, do_constant_folding=True,
-                      use_external_data_format=True, dynamo=False)
+                      dynamo=False)
     log(f"{path.name}: {path.stat().st_size / 1e6:.0f} MB")
 
     sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"])
-    feeds = {"inputs_embeds": embeds.numpy(), "attention_mask": mask.numpy(),
-             "position_ids": pos.numpy()}
+    feeds = {"inputs_embeds": np_(embeds), "attention_mask": np_(mask),
+             "position_ids": np_(pos)}
     for i in range(n):
-        feeds[f"past_k_{i}"] = past[2 * i].numpy()
-        feeds[f"past_v_{i}"] = past[2 * i + 1].numpy()
+        feeds[f"past_k_{i}"] = np_(past[2 * i])
+        feeds[f"past_v_{i}"] = np_(past[2 * i + 1])
     got = sess.run(None, feeds)
-    cos = [cosine(ref[i].numpy(), got[i]) for i in range(3)]
+    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}")
     return {"graph": "lm", "mb": round(path.stat().st_size / 1e6, 1),
             "cos_hidden": cos[0], "layers": n}
@@ -152,8 +156,8 @@ def stage_agg(mm, torch) -> dict:
                       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": dummy.numpy()})[0]
-    c = cosine(ref.numpy(), got)
+    got = sess.run(None, {"latent": np_(dummy)})[0]
+    c = cosine(np_(ref), got)
     log(f"aggregator.onnx {path.stat().st_size / 1e6:.0f} MB cos={c:.6f}")
     return {"graph": "aggregator", "mb": round(path.stat().st_size / 1e6, 1),
             "cos": c, "dim_in": dim_in, "dim_out": int(ref.shape[-1])}
@@ -187,13 +191,12 @@ def stage_voc(mm, torch) -> dict:
     path = OUT / "voc.onnx"
     torch.onnx.export(voc, (dummy,), str(path), input_names=["latent"],
                       output_names=["waveform"], dynamic_axes={"latent": {1: "t"}},
-                      opset_version=20, do_constant_folding=True,
-                      use_external_data_format=True, dynamo=False)
+                      opset_version=20, do_constant_folding=True, dynamo=False)
     sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"])
-    got = sess.run(None, {"latent": dummy.numpy()})[0]
+    got = sess.run(None, {"latent": np_(dummy)})[0]
     if got.ndim == 2:
         got = got[:, None]
-    c = cosine(ref.numpy(), got)
+    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}