Upload app.py with huggingface_hub

app.py

@@ -308,6 +308,24 @@ def answer_systemone(state: str, questions: dict, backend: str = "needle") -> di
             "usage": {"input_tokens": None, "output_tokens": None}}
 
 
+# --------------------------------------------------------------- tuned adapter vocab
+# The trigger vocabulary from the TUNED adapter (eval_harness.TRIGGERS), copied here so
+# the Space can drive the tuned path without importing the eval harness. These are the
+# lists that produced 87.5% held out; see the README for why each design choice exists.
+TRIG = {
+    "billing": r"\b(charge|charged|charges|invoice|refund|refunded|billing|billed|bill|"
+               r"payment|paid|pay|subscription|price|pricing|duplicate|double charged|"
+               r"credited|owing|owed|bank|card|cost)\b",
+    "technical": r"\b(error|errors|bug|bugs|crash|crashes|broken|fails|failing|failed|"
+                 r"outage|down|exception|blank|screen|sync|search|upload|webhook|api|"
+                 r"json|csv|export|import|dashboard|app|version|update|fix|feature|"
+                 r"documentation)\b",
+    "account": r"\b(log ?in|login|log into|sign ?in|sign in|password|reset|two-factor|"
+               r"2fa|authentication|locked out|lock|unlock|access|permission|profile|"
+               r"email address|account|session expired|erasure|delete my account)\b",
+}
+
+
 @spaces.GPU(duration=240)
 def compare_backends() -> dict:
     """Head-to-head: Needle 3 vs BART-MNLI on the SAME questions.
@@ -337,21 +355,38 @@ def compare_backends() -> dict:
                               "no_text": "the writer is not asking for any money back"}}
 
     out: dict[str, Any] = {"questions": list(Q), "cases": [], "summary": {}}
-    tally = {"needle": {"choice": 0, "noul": 0, "n": 0},
-             "bart": {"choice": 0, "noul": 0, "n": 0}}
+    backends = ("tuned", "space", "bart")
+    tally = {b: {"choice": 0, "noul": 0, "n": 0} for b in backends}
 
     for state, expect in cases:
         row = {"state": state, "expect": expect}
-        for backend in ("needle", "bart"):
+        for backend in backends:
             try:
-                r = answer_systemone(state, Q, backend=backend)
+                if backend == "tuned":
+                    # the tuned adapter declares only its own criteria; give it the
+                    # REQUEST portion for trigger scoping, as its design requires
+                    tq = {"department": {"type": "choice", "instructions": "Which team?",
+                                         "criteria": {k: {"description": v,
+                                                          "triggers": TRIG[k]}
+                                                      for k, v in crit.items()}},
+                          "refund_requested": {"type": "noul",
+                                               "instructions": "Is the writer asking "
+                                                               "for a refund?"},
+                          "_request_text": state}
+                    r = answer_tuned(state, tq)
+                elif backend == "space":
+                    r = answer_systemone(state, Q, backend="needle")
+                else:
+                    r = answer_systemone(state, Q, backend="bart")
             except Exception as e:
                 row[backend] = {"error": f"{type(e).__name__}: {e}"}
                 continue
             ch = r["answers"]["department"]
             nl = r["answers"]["refund_requested"]
-            got_ch, got_nl = ch.get("choice"), int(round(nl.get("noul", 0.0)))
-            row[backend] = {"choice": got_ch, "choice_correct": got_ch == expect["department"],
+            got_ch = ch.get("choice")
+            got_nl = int(round(nl.get("noul", 0.0)))
+            row[backend] = {"choice": got_ch,
+                            "choice_correct": got_ch == expect["department"],
                             "choice_conf": ch.get("confidence"),
                             "noul": round(nl.get("noul", 0.0), 4),
                             "noul_correct": got_nl == expect["refund_requested"],
@@ -365,9 +400,59 @@ def compare_backends() -> dict:
         n2 = max(tally[b]["n"], 1)
         tally[b]["accuracy"] = (tally[b]["choice"] + tally[b]["noul"]) / n2
     out["summary"] = tally
+    out["label_note"] = (
+        "tuned = the trigger-based adapter that scored 87.5% held out on 28 tickets. "
+        "space = this Space's bare-prompt first-token path (a DIFFERENT, weaker design; "
+        "do not read it as 'Needle'). bart = facebook/bart-large-mnli zero-shot.")
     return out
 
 
+def _ensure_tuned_assets() -> dict:
+    """Fetch what the TUNED adapter path needs, at MODULE scope.
+
+    The tuned adapter (jev_adapter.py) uses the NATIVE engine -- `needle.Needle(tools=...)`
+    with no `weights=` -- which is the configuration that scored 87.5% held out. That is a
+    DIFFERENT runtime from the JAX-logits path this Space normally uses: it needs the native
+    `libneedle` shared library plus the `needle3.cact` archive, both of which the package
+    auto-downloads into ~/.cache/cactus-needle/.
+
+    Why module scope: network access inside a @spaces.GPU function is restricted on ZeroGPU,
+    so anything that fetches must run at import. This is the same reason the safetensors
+    checkpoint is prefetched at startup.
+    """
+    info: dict[str, Any] = {"ok": False}
+    try:
+        import needle as _n
+        # _load_base fetches/validates the .cact; the engine library is fetched lazily
+        # by _lib_path on first real call, so trigger it here too.
+        from needle import _base_weights_path, _lib_path
+        lib = _lib_path(3)
+        w = _base_weights_path(3)
+        info.update({"ok": True, "lib": str(lib), "weights": str(w),
+                     "weights_bytes": os.path.getsize(w) if os.path.exists(w) else None})
+    except Exception as e:
+        info["error"] = f"{type(e).__name__}: {e}"
+    return info
+
+
+@spaces.GPU(duration=600)
+def answer_tuned(state: str, questions: dict) -> dict:
+    """The TUNED adapter path: one tool per option, triggers, scoped to the request.
+
+    This is the implementation that scored 87.5% held out on the 28-ticket set. It is
+    exposed separately from `answer_systemone` because it is a different runtime (native
+    engine vs JAX logits) and a different design (tools + triggers vs bare-prompt
+    first-token matching). Keeping them distinct stops the comparison from silently
+    attributing the naive path's score to the tuned one.
+    """
+    from jev_adapter import run_systemone as _tuned
+    # The adapter needs the request alone for trigger scoping. The caller may pass a
+    # combined state; if it does not declare the request portion we use the whole thing
+    # and the adapter warns about it.
+    request_text = questions.pop("_request_text", None) if isinstance(questions, dict) else None
+    return _tuned(state, questions, request_text=request_text)
+
+
 @spaces.GPU(duration=120)
 def run_method_comparison() -> dict:
     """The scoring-method comparison on three unambiguous cases.
@@ -549,12 +634,27 @@ with gr.Blocks(title="needle3 logits") as demo:
         b3.click(_score, [st, instr, backend_sel], out_json, api_name="score")
 
     with gr.Tab("Compare backends"):
-        gr.Markdown("Needle 3 vs BART-MNLI on the same questions and the same cases. "
-                    "Both polarities of `noul` are exercised, so a 'yes to everything' "
-                    "bug cannot hide.")
+        gr.Markdown("**tuned** = the trigger-based adapter (87.5% held out) · "
+                    "**space** = this Space's bare-prompt path (weaker, different design) · "
+                    "**bart** = facebook/bart-large-mnli zero-shot. Both polarities of "
+                    "`noul` are exercised, so a 'yes to everything' bug cannot hide.")
         cmp_btn = gr.Button("run head-to-head", variant="primary")
         cmp_out = gr.JSON(label="comparison")
         cmp_btn.click(compare_backends, None, cmp_out, api_name="compare")
+        tun_btn = gr.Button("tuned adapter only (single state)")
+        tun_out = gr.JSON(label="tuned response")
+        tun_btn.click(
+            lambda s: answer_tuned(s, {
+                "department": {"type": "choice", "instructions": "Which team?",
+                               "criteria": {k: {"description": v, "triggers": TRIG[k]}
+                                            for k, v in
+                                            {"billing": "Payment, charges, invoices, refunds.",
+                                             "technical": "Bugs, errors, outages.",
+                                             "account": "Login, password, access."}.items()}},
+                "refund_requested": {"type": "noul",
+                                     "instructions": "Is the writer asking for a refund?"},
+                "_request_text": s}),
+            [st], tun_out, api_name="tuned")
 
     with gr.Tab("Method comparison"):
         gr.Markdown("Which scoring method actually separates the three clear cases?")
@@ -600,10 +700,19 @@ if __name__ == "__main__":
               f"({os.path.getsize(CKPT) if os.path.exists(CKPT) else 0} bytes)")
     except Exception as _e:  # noqa: BLE001
         print(f"[startup] checkpoint prefetch failed: {type(_e).__name__}: {_e}")
+    # The tuned adapter uses the NATIVE engine (libneedle + needle3.cact), which is a
+    # DIFFERENT runtime from the JAX safetensors path above. Prefetch it here too, so the
+    # first tuned call does not hit the network inside a GPU-decorated function.
+    _tuned_asset_info = _ensure_tuned_assets()
+    print(f"[startup] tuned assets: {_tuned_asset_info}")
     demo.queue(max_size=8).launch(server_name="0.0.0.0", server_port=7860)
 else:
     try:
         _ensure_ckpt()
     except Exception as _e:  # noqa: BLE001
         print(f"[startup] checkpoint prefetch failed: {type(_e).__name__}: {_e}")
+    try:
+        print(f"[startup] tuned assets: {_ensure_tuned_assets()}")
+    except Exception as _e:  # noqa: BLE001
+        print(f"[startup] tuned asset prefetch failed: {type(_e).__name__}: {_e}")