fix: torch.from_numpy crash with numpy 2.x in frozen binary (#361)

torch is compiled against numpy 1.x. numpy 2.x changed the ABI version returned by PyArray_GetNDArrayCVersion() (0x01000009 → 0x02000000), so torch's is_numpy_available() always returns False and torch.from_numpy() raises RuntimeError. This causes TTS generation to fail with: ValueError: Unable to create tensor, you should probably activate padding with 'padding=True' Two fixes: 1. Pin numpy<2.0 in requirements.txt so new builds bundle a compatible numpy version. (The existing comment already flagged this intention but the upper bound was never added.) 2. Add a PyInstaller runtime hook (pyi_rth_numpy_compat.py) that installs a ctypes memmove fallback for torch.from_numpy() at startup. Runtime hooks run after FrozenImporter is registered so frozen torch is importable. The fallback catches RuntimeError from the C-level ABI check and copies the numpy array into a new tensor via raw memory copy, bypassing the check entirely. This is a belt-and-suspenders fix that works regardless of the bundled numpy version. Co-authored-by: aimaaaimaa <[email protected]> Co-authored-by: Claude Sonnet 4.6 <[email protected]>
2026-09-20 07:10:40 -07:00 · 2026-04-16 01:46:40 -07:00
parent 75abbb02c3
commit a383ff6863
3 changed files with 91 additions and 1 deletions
@@ -0,0 +1,80 @@
+"""
+PyInstaller runtime hook: numpy 2.x / torch ABI mismatch fix.
+
+Problem
+-------
+torch is compiled against numpy 1.x headers. numpy 2.x changed the version
+number returned by PyArray_GetNDArrayCVersion() (0x01000009 → 0x02000000),
+so torch's is_numpy_available() returns False and every torch.from_numpy()
+call raises:
+
+    RuntimeError: Numpy is not available
+
+This surfaces as:
+
+    ValueError: Unable to create tensor, you should probably activate
+    padding with 'padding=True'
+
+during TTS generation (EncodecFeatureExtractor → BatchFeature.convert_to_tensors).
+
+Fix
+---
+Runtime hooks execute after PyInstaller's FrozenImporter is registered, so
+frozen torch/numpy are importable here. We start a background thread that
+waits for torch to finish loading then wraps torch.from_numpy with a ctypes
+memmove fallback that bypasses the C-level numpy ABI check entirely.
+
+This approach works with any numpy version and is safer than binary-patching
+libtorch_python.dylib (which risks PyArray_Descr struct layout mismatches).
+"""
+
+import sys
+import threading
+
+
+def _patch_torch_from_numpy():
+    import time
+
+    for _ in range(7200):  # poll up to 360 s at 50 ms intervals
+        time.sleep(0.05)
+        torch = sys.modules.get("torch")
+        if torch is None or not hasattr(torch, "from_numpy"):
+            continue
+        if getattr(torch, "_vb_from_numpy_patched", False):
+            return
+        try:
+            import ctypes
+            import numpy as np
+
+            _orig = torch.from_numpy
+
+            def _safe_from_numpy(arr, _orig=_orig, _c=ctypes, _np=np, _t=torch):
+                try:
+                    return _orig(arr)
+                except RuntimeError:
+                    a = _np.ascontiguousarray(arr)
+                    dtype_map = {
+                        "float32": _t.float32,
+                        "float64": _t.float64,
+                        "int32": _t.int32,
+                        "int64": _t.int64,
+                        "int16": _t.int16,
+                        "int8": _t.int8,
+                        "uint8": _t.uint8,
+                        "bool": _t.bool,
+                    }
+                    out = _t.empty(
+                        list(a.shape),
+                        dtype=dtype_map.get(str(a.dtype), _t.float32),
+                    )
+                    _c.memmove(out.data_ptr(), a.ctypes.data, a.nbytes)
+                    return out
+
+            torch.from_numpy = _safe_from_numpy
+            torch._vb_from_numpy_patched = True
+        except Exception:
+            pass
+        return
+
+
+threading.Thread(target=_patch_torch_from_numpy, daemon=True).start()