Upload folder using huggingface_hub

handler.py

@@ -0,0 +1,144 @@
+"""Custom inference handler for Hugging Face Inference Endpoints.
+
+This module exposes :class:`EndpointHandler`, the entrypoint used by the
+Hugging Face serving stack when ``--task custom`` is selected.  The handler
+loads the exported Noesis decoder ONNX graph and accepts symbolic intent
+vectors (``psi``) along with an optional ``slow_state`` memory tensor.  The
+outputs mirror the values produced by the training runtime:
+
+* ``z_out`` – semantic embedding projected back into symbolic space.
+* ``choice``, ``pain``, ``memory`` and ``quality`` – diagnostic scalars.
+* ``slow_state`` – updated slow memory tensor suitable for recurrent usage.
+
+The handler is intentionally lightweight so it can run without the rest of the
+AletheiaEngine Python package being installed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, MutableMapping, Optional
+
+import numpy as np
+import onnxruntime as ort
+
+
+@dataclass(frozen=True)
+class _ModelIO:
+    """Snapshot of ONNX input and output metadata."""
+
+    inputs: tuple[ort.NodeArg, ...]
+    outputs: tuple[ort.NodeArg, ...]
+
+
+class EndpointHandler:
+    """Callable endpoint used by Hugging Face to drive inference."""
+
+    def __init__(self, path: str | None = None) -> None:
+        self.model_dir = Path(path or Path(__file__).parent)
+        self.session = self._load_session()
+        self.io = self._capture_io()
+
+        self.primary_input = self.io.inputs[0].name
+        self.slow_input = self._find_input("slow_state")
+        self._defaults = {
+            node.name: self._zeros_like(node)
+            for node in self.io.inputs
+            if node.name not in {self.primary_input, self.slow_input}
+        }
+        if self.slow_input is not None:
+            self._slow_fallback = self._zeros_like(self._input_map[self.slow_input])
+        else:
+            self._slow_fallback = None
+
+    def _load_session(self) -> ort.InferenceSession:
+        model_path = self.model_dir / "model.onnx"
+        if not model_path.exists():
+            available = ", ".join(sorted(str(p.name) for p in self.model_dir.glob("*.onnx"))) or "<none>"
+            raise FileNotFoundError(
+                "Could not locate 'model.onnx' in %s (available: %s)" % (self.model_dir, available)
+            )
+        return ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
+
+    @property
+    def _input_map(self) -> Mapping[str, ort.NodeArg]:
+        return {node.name: node for node in self.io.inputs}
+
+    def _capture_io(self) -> _ModelIO:
+        return _ModelIO(inputs=tuple(self.session.get_inputs()), outputs=tuple(self.session.get_outputs()))
+
+    def _find_input(self, target: str) -> Optional[str]:
+        target = target.lower()
+        for node in self.io.inputs:
+            if node.name.lower() == target:
+                return node.name
+        return None
+
+    @staticmethod
+    def _zeros_like(node: ort.NodeArg) -> np.ndarray:
+        shape: list[int] = []
+        for dim in node.shape:
+            if isinstance(dim, int) and dim > 0:
+                shape.append(dim)
+            else:
+                shape.append(1)
+        return np.zeros(shape, dtype=np.float32)
+
+    @staticmethod
+    def _coerce_array(value: Any, *, allow_empty: bool = False) -> np.ndarray:
+        array = np.asarray(value, dtype=np.float32)
+        if array.size == 0 and not allow_empty:
+            raise ValueError("Received an empty array; provide at least one value.")
+        if array.ndim == 1:
+            array = np.expand_dims(array, axis=0)
+        elif array.ndim > 2:
+            raise ValueError("Expected a 1D or batched 2D array; received shape %s" % (array.shape,))
+        return array
+
+    def _prepare_inputs(self, payload: Mapping[str, Any]) -> MutableMapping[str, np.ndarray]:
+        psi = payload.get("psi")
+        if psi is None:
+            psi = payload.get("vector") or payload.get("psi_s") or payload.get("inputs")
+        if psi is None:
+            raise KeyError("Payload must include a 'psi' field containing the symbolic vector.")
+
+        inputs: MutableMapping[str, np.ndarray] = {self.primary_input: self._coerce_array(psi)}
+
+        if self.slow_input is not None:
+            slow_value = payload.get("slow_state") or payload.get("slow") or payload.get("state")
+            if slow_value is None:
+                inputs[self.slow_input] = self._slow_fallback.copy()
+            else:
+                inputs[self.slow_input] = self._coerce_array(slow_value, allow_empty=True)
+
+        for name, default in self._defaults.items():
+            inputs[name] = default.copy()
+
+        return inputs
+
+    @staticmethod
+    def _format_output(name: str, value: np.ndarray) -> Any:
+        value = np.asarray(value, dtype=np.float32)
+        value = np.nan_to_num(value, nan=0.0, posinf=0.0, neginf=0.0)
+        squeezed = np.squeeze(value)
+        if squeezed.ndim == 0:
+            return float(squeezed)
+        return squeezed.tolist()
+
+    def __call__(self, data: Mapping[str, Any]) -> Mapping[str, Any]:
+        payload = data.get("inputs", data)
+        if not isinstance(payload, Mapping):
+            payload = {"psi": payload}
+
+        feed = self._prepare_inputs(payload)
+        outputs = self.session.run(None, feed)
+
+        result = {
+            node.name: self._format_output(node.name, value)
+            for node, value in zip(self.io.outputs, outputs)
+        }
+        return result
+
+
+__all__ = ["EndpointHandler"]

requirements.txt

@@ -3,3 +3,5 @@ uvicorn[standard]>=0.23
 pydantic>=2.6
 torch>=2.1
 numpy>=1.24
+onnxruntime
+numpy