Update nlu.py

nlu.py

@@ -2,25 +2,32 @@
 NLU — Embedding similarity architecture.
 =========================================
 Replaces the legacy NLLB+Qwen pipeline (preserved in nlu_legacy.py).
-
 Why embeddings?
   - Latency: ~200ms vs ~10s on CPU for the legacy stack
   - Memory:  ~420MB vs ~8GB
   - Hausa coverage: paraphrase-multilingual-MiniLM-L12-v2 was trained on 50+
     languages including Hausa, so we no longer need a translation step
   - Confidence comes for free: cosine similarity IS a calibrated confidence
-
 Pipeline (in order):
   Layer 0: Human-keyword escape ("wakili", "agent") → always wins
-  Layer 1: Structural extractors (digits, amounts, yes/no, name, date)
-           when the dialogue state has expected_slot set
+  Layer 1: Structural extractors (digits, amounts, yes/no, name, date, free
+           text, bundle) when the dialogue state sets an expected slot
   Layer 1.5: Keyword fast-path for ultra-common phrases ("duba ma'auni")
              — sub-millisecond, no model call
   Layer 2: Sentence-embedding similarity vs per-intent centroids
            — cosine sim ≥ threshold (0.4) → that intent, else unknown
-
 The dialogue manager receives the same (intent, entities, source) tuple
 as before, so app.py needs no changes.
+
+Fixes vs the POC
+----------------
+* _match_yesno no longer treats English "I" (inside any sentence) as Hausa
+  "i"=yes via substring containment; short tokens match exactly.
+* _match_intent_keyword matches keywords as whole whitespace-delimited tokens,
+  so short keywords ("ba", "data", "oda") can't fire inside unrelated words.
+* expected == "text" / "bundle" now emit the provide_text / provide_bundle
+  intents the FSM transitions expect — previously these slots were never
+  satisfied, silently breaking the complaint, bundle, and return flows.
 """
 from __future__ import annotations
 import re
@@ -45,11 +52,17 @@ WORD_AMOUNTS = {
     "ɗari": 100, "dari": 100,
 }
 
-HAUSA_YES = {"i", "eh", "haka ne", "haka", "ok", "okay", "yes"}
-HAUSA_NO = {"a'a", "a'aa", "ba haka", "ba", "no"}
+# Short yes/no tokens: matched EXACTLY (whole utterance) to avoid substring
+# false positives. Multi-word cues are matched as whitespace-bounded phrases.
+HAUSA_YES_EXACT = {"i", "eh", "ok", "okay", "yes"}
+HAUSA_YES_PHRASE = {"haka ne", "haka"}
+HAUSA_NO_EXACT = {"a'a", "a'aa", "ba", "no"}
+HAUSA_NO_PHRASE = {"ba haka"}
 
 HUMAN_KEYWORDS = {"mutum", "wakili", "agent", "human"}
 
+BUNDLE_TYPES = ("rana", "mako", "wata")
+
 
 def _extract_digits(text: str) -> Optional[str]:
     m = re.findall(r"\d+", text)
@@ -72,19 +85,22 @@ def _extract_amount(text: str) -> Optional[int]:
 
 
 def _match_yesno(text: str) -> Optional[str]:
-    t = " " + text.lower().strip() + " "
-    for kw in HAUSA_YES:
-        if f" {kw} " in t or t.strip() == kw:
-            return "yes"
-    for kw in HAUSA_NO:
-        if f" {kw} " in t or t.strip() == kw:
-            return "no"
+    t = text.lower().strip()
+    if t in HAUSA_YES_EXACT:
+        return "yes"
+    if t in HAUSA_NO_EXACT:
+        return "no"
+    padded = f" {t} "
+    if any(f" {kw} " in padded for kw in HAUSA_YES_PHRASE):
+        return "yes"
+    if any(f" {kw} " in padded for kw in HAUSA_NO_PHRASE):
+        return "no"
     return None
 
 
 def _contains_human_keyword(text: str) -> bool:
-    t = text.lower()
-    return any(kw in t for kw in HUMAN_KEYWORDS)
+    padded = f" {text.lower().strip()} "
+    return any(f" {kw} " in padded for kw in HUMAN_KEYWORDS)
 
 
 # ---------------------------------------------------------------------------
@@ -130,11 +146,13 @@ INTENT_KEYWORDS = {
 
 
 def _match_intent_keyword(text: str) -> Optional[str]:
-    t = text.lower().strip()
+    # Whitespace-bounded match: the keyword must appear as a whole token (or
+    # token sequence), never as a fragment inside another word.
+    padded = f" {text.lower().strip()} "
     all_kw = [(intent, kw) for intent, kws in INTENT_KEYWORDS.items() for kw in kws]
     all_kw.sort(key=lambda x: len(x[1]), reverse=True)
     for intent, kw in all_kw:
-        if kw in t:
+        if f" {kw} " in padded:
             return intent
     return None
 
@@ -148,14 +166,12 @@ def _match_intent_keyword(text: str) -> Optional[str]:
 # ---------------------------------------------------------------------------
 INTENT_EXAMPLES = {
     "check_balance": [
-        # Hausa
         "duba ma'auni",
         "ina son sanin kuɗin asusuna",
         "nawa ne a asusuna",
         "menene ma'aunin asusuna",
         "yi mini bayanin asusuna",
         "ina son ganin kuɗina",
-        # English
         "check my balance",
         "what is my account balance",
         "how much money do I have",
@@ -289,9 +305,8 @@ INTENT_EXAMPLES = {
 
 
 # Confidence threshold: cosine similarities below this become 'unknown'.
-# Tuned by hand at 0.4; lower if too many things are routed to 'unknown',
-# raise if too many incorrect intents get through. See nlu/tests for the
-# validation methodology.
+# Tuned by hand at 0.4 — re-tune with eval_nlu.py (threshold sweep) once you
+# have real Hausa traffic from the turn logs.
 CONFIDENCE_THRESHOLD = 0.4
 
 # Embedding model. Multilingual (50+ languages), 420MB, CPU-fast.
@@ -307,7 +322,10 @@ _embed_failed = False
 
 
 def _load_encoder():
-    """Lazy-load the sentence encoder + compute intent centroids."""
+    """Lazy-load the sentence encoder + compute intent centroids.
+    Pinned to CPU: on ZeroGPU the GPU isn't attached at import time, and the
+    encoder is fast enough on CPU (~200ms) that a GPU round-trip would be a net
+    loss — only ASR/TTS belong on the GPU."""
     global _encoder, _intent_centroids, _embed_failed
     if _embed_failed:
         return None
@@ -317,7 +335,7 @@ def _load_encoder():
         import numpy as np
         from sentence_transformers import SentenceTransformer
         logger.info(f"Loading embedding model {EMBEDDING_MODEL_ID}…")
-        _encoder = SentenceTransformer(EMBEDDING_MODEL_ID)
+        _encoder = SentenceTransformer(EMBEDDING_MODEL_ID, device="cpu")
         logger.info("Computing intent centroids…")
         _intent_centroids = {}
         for intent, phrases in INTENT_EXAMPLES.items():
@@ -335,32 +353,27 @@ def _load_encoder():
         return None
 
 
-def _classify_with_embedding(text: str, expected: Optional[str]) -> Optional[tuple[str, float]]:
-    """Cosine similarity vs intent centroids. Returns (intent, confidence)
-    or None on failure. Respects expected_slot if it constrains valid intents."""
+def _classify_with_embedding(text: str) -> Optional[tuple[str, float]]:
+    """Cosine similarity vs all intent centroids. Returns (intent, confidence)
+    or None on failure.
+
+    Note: we deliberately score against every intent rather than constraining by
+    the dialogue's expected slot. This is what lets a caller pivot mid-flow
+    (e.g. say "transfer money" while we're asking for account digits). The
+    expected-slot constraint is enforced upstream by the structural extractors
+    in parse(), not here."""
     encoder = _load_encoder()
     if encoder is None or _intent_centroids is None:
         return None
     try:
         import numpy as np
         query = encoder.encode(text, normalize_embeddings=True)
-
-        # If expected_slot constrains the answer space, filter candidates.
-        # For 'yesno', embedding NLU shouldn't fire — yes/no is handled by
-        # the structural layer. If we get here with yesno expected, it means
-        # the user said something non-standard; we treat that as a possible
-        # intent pivot (any intent is fair game).
-        valid_intents = list(_intent_centroids.keys())
-
-        scores = {}
-        for intent in valid_intents:
-            centroid = _intent_centroids[intent]
-            scores[intent] = float(np.dot(query, centroid))
-
+        scores = {intent: float(np.dot(query, centroid))
+                  for intent, centroid in _intent_centroids.items()}
         best_intent = max(scores, key=scores.get)
         best_score = scores[best_intent]
-        logger.info(f"NLU embedding: top match {best_intent}@{best_score:.3f}, "
-                    f"all scores: { {k: round(v,3) for k,v in sorted(scores.items(), key=lambda x: -x[1])[:3]} }")
+        top3 = {k: round(v, 3) for k, v in sorted(scores.items(), key=lambda x: -x[1])[:3]}
+        logger.info(f"NLU embedding: top match {best_intent}@{best_score:.3f}, top3: {top3}")
         return best_intent, best_score
     except Exception as e:
         logger.warning(f"Embedding classification failed: {e}")
@@ -374,12 +387,11 @@ def parse(text: str, expected: Optional[str] = None,
           use_llm: bool = True) -> tuple[str, dict, str]:
     """
     NLU entry point. Returns (intent, entities, source) where source is:
-      - 'structural': digit/amount/yes-no/name/date regex matched
-      - 'keyword':    keyword fast-path matched
-      - 'embedding':  sentence encoder matched above threshold
+      - 'structural':    digit/amount/yes-no/name/date/text/bundle matched
+      - 'keyword':       keyword fast-path matched
+      - 'embedding':     sentence encoder matched above threshold
       - 'human_keyword': escape-hatch keyword caught
-      - 'unknown':    nothing matched
-
+      - 'unknown':       nothing matched
     `use_llm` is a misnomer kept for backward compat with the legacy module's
     signature — here it means "use the embedding layer". Set False to test
     rule-only behavior.
@@ -392,7 +404,7 @@ def parse(text: str, expected: Optional[str] = None,
     if _contains_human_keyword(text):
         return "human_agent", entities, "human_keyword"
 
-    # Layer 1: Structural extractors for strict-format slots
+    # Layer 1: Structural extractors for slot-filling states
     if expected == "digits":
         d = _extract_digits(text)
         if d:
@@ -411,6 +423,9 @@ def parse(text: str, expected: Optional[str] = None,
             return yn, entities, "structural"
 
     if expected == "name":
+        # NOTE: naive — takes the last token, so "Musa Ibrahim" → "Ibrahim".
+        # Fine for single-name demos; add a recipient-confirmation turn before
+        # using this for real money movement.
         name = text.strip().split()[-1] if text.strip() else ""
         if name:
             entities["name"] = name
@@ -420,6 +435,21 @@ def parse(text: str, expected: Optional[str] = None,
         entities["date"] = text.strip()
         return "provide_date", entities, "structural"
 
+    if expected == "text":
+        # Free-text capture (complaint body, return reason). Layer 0 already
+        # handled an explicit human-agent request, so anything else is content.
+        entities["text"] = text.strip()
+        return "provide_text", entities, "structural"
+
+    if expected == "bundle":
+        t = text.lower()
+        for b in BUNDLE_TYPES:
+            if f" {b} " in f" {t} " or t.strip() == b:
+                entities["bundle"] = b
+                return "provide_bundle", entities, "structural"
+        # No recognized bundle word — fall through so the user can still pivot
+        # (e.g. change their mind to airtime) or get a fallback re-prompt.
+
     # Layer 1.5: Keyword fast-path (cheap, runs in any state so users can
     # pivot intent mid-flow).
     kw_intent = _match_intent_keyword(text)
@@ -432,7 +462,7 @@ def parse(text: str, expected: Optional[str] = None,
         logger.info(f"NLU: use_llm=False, returning unknown for {text!r}")
         return "unknown", entities, "unknown"
 
-    embed_result = _classify_with_embedding(text, expected)
+    embed_result = _classify_with_embedding(text)
     if embed_result is None:
         logger.warning(f"NLU embedding unavailable, returning unknown for {text!r}")
         return "unknown", entities, "unknown"
@@ -443,15 +473,5 @@ def parse(text: str, expected: Optional[str] = None,
                     f"{CONFIDENCE_THRESHOLD}, returning unknown")
         return "unknown", entities, "unknown"
 
-    # Free-text slot pass-through (preserve original Hausa)
-    if expected == "bundle":
-        t = text.lower()
-        for b in ("rana", "mako", "wata"):
-            if b in t:
-                entities["bundle"] = b
-                break
-    if expected == "text":
-        entities["text"] = text.strip()
-
     logger.info(f"NLU embedding accepted: {text!r} → {intent} (conf={confidence:.3f})")
     return intent, entities, "embedding"