Improve emotion explanations and intent UI

src/models/emotion_classifier.py

@@ -56,25 +56,17 @@ class EmotionClassifier:
         config_labels = self.model.config.id2label
         self.id2label = {int(key): value for key, value in config_labels.items()}
 
-    def predict_with_confidence(self, text: str) -> dict[str, Any]:
-        clean_text = text.strip()
-        if not clean_text:
-            return {
-                "emotion": "unknown",
-                "confidence": 0.0,
-                "is_confident": False,
-                "message": "Please enter text to classify.",
-            }
-
+    def _score_text(self, text: str) -> dict[str, Any]:
         if self.model is None or self.tokenizer is None or self.torch is None:
             self.load_model()
 
         inputs = self.tokenizer(
-            clean_text,
+            text,
             return_tensors="pt",
             truncation=True,
             max_length=128,
         )
+        inputs.pop("token_type_ids", None)
 
         with self.torch.no_grad():
             logits = self.model(**inputs).logits
@@ -82,39 +74,72 @@ class EmotionClassifier:
 
         best_index = int(probabilities.argmax().item())
         confidence = float(probabilities[best_index].item())
+        scores = {self.id2label.get(index, str(index)): float(value.item()) for index, value in enumerate(probabilities)}
 
         return {
+            "index": best_index,
             "emotion": self.id2label.get(best_index, str(best_index)),
             "confidence": confidence,
-            "is_confident": confidence >= 0.60,
+            "scores": scores,
+        }
+
+    def predict_with_confidence(self, text: str) -> dict[str, Any]:
+        clean_text = text.strip()
+        if not clean_text:
+            return {
+                "emotion": "unknown",
+                "confidence": 0.0,
+                "is_confident": False,
+                "message": "Please enter text to classify.",
+            }
+
+        prediction = self._score_text(clean_text)
+
+        return {
+            "emotion": prediction["emotion"],
+            "confidence": prediction["confidence"],
+            "is_confident": prediction["confidence"] >= 0.60,
             "message": None,
         }
 
     def explain(self, text: str, top_k: int = 8) -> dict[str, Any]:
         """Estimate influential words by measuring confidence drop after removing each word."""
-        base_prediction = self.predict_with_confidence(text)
+        clean_text = text.strip()
+        base_scores = self._score_text(clean_text)
+        base_prediction = {
+            "emotion": base_scores["emotion"],
+            "confidence": base_scores["confidence"],
+            "is_confident": base_scores["confidence"] >= 0.60,
+            "message": None,
+        }
         target_emotion = base_prediction["emotion"]
         base_confidence = base_prediction["confidence"]
-        words = re.findall(r"\b[\w']+\b", text)
+        words = list(re.finditer(r"\b[\w']+\b", clean_text))
 
         impacts = []
-        for index, word in enumerate(words):
-            reduced_words = words[:index] + words[index + 1 :]
-            if not reduced_words:
-                continue
-
-            reduced_text = " ".join(reduced_words)
-            reduced_prediction = self.predict_with_confidence(reduced_text)
-            confidence_drop = base_confidence - (
-                reduced_prediction["confidence"]
-                if reduced_prediction["emotion"] == target_emotion
-                else 0.0
-            )
+        for match in words:
+            reduced_text = (clean_text[: match.start()] + clean_text[match.end() :]).strip()
+            reduced_scores = self._score_text(reduced_text) if reduced_text else {"scores": {target_emotion: 0.0}}
+            target_confidence_without_word = reduced_scores["scores"].get(target_emotion, 0.0)
+            confidence_drop = base_confidence - target_confidence_without_word
+
+            if confidence_drop > 0.001:
+                effect = "supports prediction"
+            elif confidence_drop < -0.001:
+                effect = "reduces prediction"
+            else:
+                effect = "neutral"
+
+            impact = round(float(confidence_drop), 4)
+            if impact == -0.0:
+                impact = 0.0
 
             impacts.append(
                 {
-                    "word": word,
-                    "impact": round(float(confidence_drop), 4),
+                    "word": match.group(0),
+                    "impact": impact,
+                    "confidence_without_word": round(float(target_confidence_without_word), 4),
+                    "effect": effect,
                 }
             )
 
@@ -122,6 +147,7 @@ class EmotionClassifier:
         return {
             "prediction": base_prediction,
             "top_evidence": impacts[:top_k],
+            "all_evidence": impacts,
             "method": "word occlusion: larger impact means removing the word reduced confidence more",
         }
 

src/models/emotion_detector_ui.py

@@ -46,12 +46,10 @@ CSS = """
 def model_status() -> str:
     model_dir = Path(os.getenv("EMOTION_MODEL_DIR", DEFAULT_MODEL_DIR))
     if model_dir.exists():
-        return f"<div class='status-box'>Using local trained model: <code>{model_dir}</code></div>"
+        return "<div class='status-box'>Local trained emotion model is ready.</div>"
     return (
-        "<div class='missing-box'>Local emotion model is not available at "
-        f"<code>{model_dir}</code>. Copy the trained "
-        "<code>saved_emotion_model</code> folder there, or set "
-        "<code>EMOTION_MODEL_DIR</code> to its current location.</div>"
+        "<div class='missing-box'>Local emotion model is not available yet. "
+        "Add the trained <code>saved_emotion_model</code> folder before testing.</div>"
     )
 
 
@@ -68,7 +66,7 @@ def predict_emotion(text: str) -> tuple[str, list[list[str | float]], str]:
         return _empty_result("Please enter a message to analyze.")
 
     try:
-        result = classifier.explain(text or "", top_k=6)
+        result = classifier.explain(text or "", top_k=8)
         emotion = result["prediction"]["emotion"]
         confidence = result["prediction"]["confidence"]
         card = (
@@ -78,15 +76,24 @@ def predict_emotion(text: str) -> tuple[str, list[list[str | float]], str]:
             f"<div>Confidence: <b>{confidence:.1%}</b></div>"
             "</div>"
         )
-        evidence = [[item["word"], item["impact"]] for item in result["top_evidence"]]
-        status = f"<div class='status-box'>Model source: <code>{classifier.active_model_source}</code></div>"
+        evidence = [
+            [
+                item["word"],
+                item["impact"],
+                item["confidence_without_word"],
+                item["effect"],
+            ]
+            for item in result["all_evidence"]
+        ]
+        status = "<div class='status-box'>Prediction generated by the local trained DistilBERT model.</div>"
         return card, evidence, status
     except FileNotFoundError:
         return _empty_result("Local emotion model is not available yet.")
     except ImportError as exc:
         return _empty_result(f"Missing dependency: {exc}")
     except Exception as exc:
-        return _empty_result(f"Emotion analysis is unavailable right now: {exc}")
+        print(f"Emotion UI error: {type(exc).__name__}: {exc}")
+        return _empty_result("Emotion analysis is unavailable right now. Please check the terminal logs.")
 
 
 with gr.Blocks(title="Emotion Classifier") as interface:
@@ -110,8 +117,8 @@ with gr.Blocks(title="Emotion Classifier") as interface:
             with gr.Column(scale=4):
                 result_output = gr.HTML(label="Prediction")
                 evidence_output = gr.Dataframe(
-                    headers=["Word", "Impact"],
-                    datatype=["str", "number"],
+                    headers=["Word", "Impact", "Confidence Without Word", "Effect"],
+                    datatype=["str", "number", "number", "str"],
                     label="Word Evidence",
                     interactive=False,
                 )

src/models/intent_detector_ui.py

@@ -1,3 +1,8 @@
+from __future__ import annotations
+
+import html
+import os
+
 import gradio as gr
 
 from intent_classifier import IntentClassifier
@@ -5,24 +10,160 @@ from intent_classifier import IntentClassifier
 
 classifier = IntentClassifier()
 
+INTENT_LABELS = {
+    "greeting": "Greeting",
+    "goodbye": "Goodbye",
+    "gratitude": "Gratitude",
+    "asking_mental_health_question": "Mental Health Question",
+    "out_of_scope": "Out of Scope",
+}
 
-def predict_intent(text: str) -> dict:
-    return classifier.classify(text or "")
+THEME = gr.themes.Base(
+    primary_hue="amber",
+    secondary_hue="cyan",
+    neutral_hue="gray",
+    radius_size="sm",
+)
 
+CSS = """
+.intent-shell {
+    max-width: 1040px;
+    margin: 0 auto;
+}
+.intent-header {
+    border-bottom: 3px solid #111827;
+    padding: 18px 0 14px;
+    margin-bottom: 18px;
+}
+.intent-kicker {
+    color: #0891b2;
+    font-size: 13px;
+    font-weight: 700;
+    letter-spacing: 0;
+    text-transform: uppercase;
+}
+.intent-panel {
+    background: #ffffff;
+    border: 2px solid #111827;
+    box-shadow: 6px 6px 0 #facc15;
+    padding: 16px;
+}
+.intent-result {
+    background: #f9fafb;
+    border: 2px solid #111827;
+    padding: 16px;
+}
+.intent-label {
+    font-size: 28px;
+    font-weight: 800;
+    color: #111827;
+}
+.confidence-track {
+    height: 12px;
+    background: #e5e7eb;
+    border: 1px solid #111827;
+    margin-top: 12px;
+}
+.confidence-fill {
+    height: 100%;
+    background: #06b6d4;
+}
+.intent-note {
+    color: #374151;
+    margin-top: 10px;
+}
+.intent-error {
+    background: #fff1f2;
+    border: 2px solid #be123c;
+    padding: 14px;
+}
+"""
 
-interface = gr.Interface(
-    fn=predict_intent,
-    inputs=gr.Textbox(
-        lines=4,
-        placeholder="Type a user message...",
-        label="User Message",
-    ),
-    outputs=gr.JSON(label="Intent Result"),
-    title="Module 3: Intent Classification",
-    description="Few-shot Groq intent classifier for chatbot routing.",
-    flagging_mode="never",
-)
+
+def _result_card(intent: str, confidence: float, reason: str) -> str:
+    label = INTENT_LABELS.get(intent, intent.replace("_", " ").title())
+    safe_label = html.escape(label)
+    safe_reason = html.escape(reason)
+    width = max(0, min(confidence, 1)) * 100
+
+    return (
+        "<div class='intent-result'>"
+        "<div>Detected intent</div>"
+        f"<div class='intent-label'>{safe_label}</div>"
+        f"<div class='confidence-track'><div class='confidence-fill' style='width: {width:.1f}%'></div></div>"
+        f"<div class='intent-note'>Confidence: <b>{confidence:.1%}</b></div>"
+        f"<div class='intent-note'>{safe_reason}</div>"
+        "</div>"
+    )
+
+
+def _empty_result(message: str) -> tuple[str, list[list[str]]]:
+    return f"<div class='intent-error'>{html.escape(message)}</div>", []
+
+
+def predict_intent(text: str) -> tuple[str, list[list[str]]]:
+    clean_text = (text or "").strip()
+    if not clean_text:
+        return _empty_result("Please enter a user message to classify.")
+
+    try:
+        result = classifier.classify(clean_text)
+    except RuntimeError:
+        return _empty_result("Groq API key is not configured. Set GROQ_API_KEY before running Module 3.")
+    except ImportError:
+        return _empty_result("Groq SDK is not installed. Install project requirements and try again.")
+    except Exception as exc:
+        print(f"Intent UI error: {type(exc).__name__}: {exc}")
+        return _empty_result("Intent classification is unavailable right now. Please check the terminal logs.")
+
+    intent = result["intent"]
+    confidence = float(result["confidence"])
+    reason = result["reason"]
+
+    details = [
+        ["Routing Key", intent],
+        ["Display Label", INTENT_LABELS.get(intent, intent)],
+        ["Confidence", f"{confidence:.1%}"],
+        ["Reason", reason],
+    ]
+    return _result_card(intent, confidence, reason), details
+
+
+with gr.Blocks(title="Intent Classifier") as interface:
+    with gr.Column(elem_classes=["intent-shell"]):
+        gr.HTML(
+            """
+            <div class="intent-header">
+                <div class="intent-kicker">Module 3</div>
+                <h1>Intent Routing</h1>
+            </div>
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=5, elem_classes=["intent-panel"]):
+                text_input = gr.Textbox(
+                    lines=7,
+                    label="User message",
+                    placeholder="Example: Hi, I feel anxious and cannot sleep.",
+                )
+                classify_button = gr.Button("Classify intent", variant="primary")
+            with gr.Column(scale=4):
+                result_output = gr.HTML()
+                details_output = gr.Dataframe(
+                    headers=["Field", "Value"],
+                    datatype=["str", "str"],
+                    label="Routing Details",
+                    interactive=False,
+                )
+
+        classify_button.click(
+            fn=predict_intent,
+            inputs=text_input,
+            outputs=[result_output, details_output],
+        )
 
 
 if __name__ == "__main__":
-    interface.launch()
+    port = int(os.getenv("GRADIO_SERVER_PORT", "7861"))
+    interface.launch(theme=THEME, css=CSS, server_port=port)