Upload scorer.py with huggingface_hub

scorer.py

@@ -0,0 +1,61 @@
+"""
+Pure-Python port of the TS logistic scorer (`scoreFeatures` in
+packages/intelligence/src/model.ts). Deliberately scores an ALREADY-EXTRACTED
+feature vector — it does not walk a serialization graph. Graph feature extraction
+stays single-sourced in the TS engine (see docs/huggingface-model-plan.md §0);
+duplicating that traversal here would drift silently and undetectably.
+
+This file has exactly one job, and hf/parity_test.py holds it to that: given the
+same model.json and the same feature vector, produce the same
+{score, uncertainty, explanation} the TS engine produces.
+"""
+
+from __future__ import annotations
+import json
+import math
+from dataclasses import dataclass
+
+
+@dataclass
+class AnomalyOutput:
+    score: float
+    uncertainty: float
+    explanation: str
+
+    def to_dict(self) -> dict:
+        return {"score": self.score, "uncertainty": self.uncertainty, "explanation": self.explanation}
+
+
+def load_model(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def score_features(model: dict, features: list[float]) -> AnomalyOutput:
+    """Byte-for-byte port of scoreFeatures() in model.ts — same iteration order,
+    same tie-break (first-seen wins on equal |contrib|, matching JS `>` semantics)."""
+    mean = model["mean"]
+    std = model["std"]
+    weights = model["weights"]
+    feature_names = model.get("featureNames", [])
+
+    logit = float(model["bias"])
+    top_name = ""
+    top_abs = -1.0
+    for i, fi in enumerate(features):
+        denom = std[i] if std[i] else 1.0
+        z = (fi - mean[i]) / denom
+        contrib = weights[i] * z
+        logit += contrib
+        if abs(contrib) > top_abs:
+            top_abs = abs(contrib)
+            top_name = feature_names[i] if i < len(feature_names) else f"f{i}"
+
+    p = 1.0 / (1.0 + math.exp(-logit))
+    uncertainty = 1.0 - min(1.0, 2.0 * abs(p - 0.5))
+    explanation = (
+        f"learned anomaly {round(p * 100)}% (top: {top_name})"
+        if p > 0.5
+        else f"learned: consistent (top: {top_name})"
+    )
+    return AnomalyOutput(score=p, uncertainty=uncertainty, explanation=explanation)