Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+noesis_model.onnx.data filter=lfs diff=lfs merge=lfs -text

handler.py

@@ -1,144 +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_infer.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"]
+"""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"]

noesis_model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09208897eb94632e675cf7ea7aa2e5b30fbb18014cebd26faa8a96ed99bd600f
+size 508690432