Update app.py

app.py

@@ -249,135 +249,48 @@ def load_preset(name):
 # ==========================================================================
 
 def eval_intent_section_md():
-    cls_report = intent_eval.get("classification_report", {})
-    per_class_rows = []
-    for cls in intent_eval.get("classes", []):
-        stats = cls_report.get(cls, {})
-        per_class_rows.append(
-            f"| {cls} | {stats.get('precision', 0):.2f} | {stats.get('recall', 0):.2f} | "
-            f"{stats.get('f1-score', 0):.2f} | {int(stats.get('support', 0))} |"
-        )
-    per_class_table = "\n".join(per_class_rows)
-    return f"""
-## 1. Intent Classifier (TF-IDF + Logistic Regression)
-
-**What it does:** routes a free-text query (e.g. *"The conveyor belt in Zone C
-is making noise"*) into one of 8 operational categories, used by both the
-AI Assistant and Inventory & Order Query tabs to decide how to handle a
-request.
-
-**Training data:** {intent_eval.get('n_train', '?') } synthetically generated
-example queries (see chart below), built from ~8 hand-written templates per
-category with randomised SKU codes, zone names, order IDs, and equipment IDs
-slotted in -- e.g. *"How many units of {{sku}} are in {{zone}}?"*. This keeps
-the language varied while being fully reproducible (`src/data_generation.py`).
-
-Evaluated on a **held-out stratified test split** of {intent_eval.get('n_test', '?')}
-examples the model never saw during training.
-
-| Metric | Score |
-|---|---|
-| **Accuracy** | **{intent_eval.get('accuracy', 0):.2%}** |
-| **Macro F1** | **{intent_eval.get('macro_f1', 0):.2%}** |
-
-**Per-class performance:**
-
-| Intent | Precision | Recall | F1 | Support |
-|---|---|---|---|---|
-{per_class_table}
-"""
+    return (
+        f"### 1. Intent Classifier   "
+        f"🎯 **{intent_eval.get('accuracy', 0):.0%} accuracy**  ·  "
+        f"**{intent_eval.get('macro_f1', 0):.0%} macro F1**  ·  "
+        f"held-out test set, {intent_eval.get('n_test', '?')} examples, "
+        f"{intent_eval.get('n_classes', '?')} classes"
+    )
 
 
 def eval_anomaly_section_md():
-    return f"""
-## 2. Predictive Maintenance Anomaly Detector (Isolation Forest)
-
-**What it does:** flags abnormal conveyor/crane motor sensor readings
-(temperature, vibration, current, belt speed) before they cause an
-unplanned stoppage -- powers the Predictive Maintenance tab.
-
-**Training data:** {900 + 100} synthetic sensor readings (900 "normal"
-+ 100 "anomaly" patterns), each with 4 features. Normal readings are drawn
-from realistic operating ranges (e.g. ~55°C motor temp, ~2.2 mm/s vibration);
-anomalies simulate bearing wear / misalignment / overload (elevated temp,
-vibration, and current with reduced belt speed). See the distribution chart
-below for exactly how these two classes differ.
-
-The model itself is trained **unsupervised** (Isolation Forest never sees
-the anomaly label during fitting) -- labels are used only to *evaluate* it
-afterward, on a held-out test split of {anomaly_eval.get('n_test', '?')}
-readings ({anomaly_eval.get('test_anomaly_rate', 0):.1%} true anomaly rate).
-
-| Metric | Score |
-|---|---|
-| **Precision** | **{anomaly_eval.get('precision', 0):.2%}** |
-| **Recall** | **{anomaly_eval.get('recall', 0):.2%}** |
-| **F1 Score** | **{anomaly_eval.get('f1', 0):.2%}** |
-| **ROC-AUC** | **{anomaly_eval.get('roc_auc', 0):.3f}** |
-| Accuracy | {anomaly_eval.get('accuracy', 0):.2%} |
-"""
+    return (
+        f"### 2. Predictive Maintenance (Anomaly Detector)   "
+        f"🎯 **{anomaly_eval.get('f1', 0):.0%} F1**  ·  "
+        f"**{anomaly_eval.get('roc_auc', 0):.2f} ROC-AUC**  ·  "
+        f"**{anomaly_eval.get('precision', 0):.0%} precision**  ·  "
+        f"**{anomaly_eval.get('recall', 0):.0%} recall**"
+    )
 
 
 def eval_retrieval_section_md():
-    retrieval_rows = "\n".join(
-        f"| {r['query']} | {r['expected']} | {r['retrieved_top1']} | "
-        f"{'✅' if r['hit@1'] else ('〰️' if r['hit@2'] else '❌')} | {r['top1_score']:.2f} |"
-        for r in retrieval_eval.get("rows", [])
+    return (
+        f"### 3. RAG Retrieval   "
+        f"🎯 **{retrieval_eval.get('hit_rate_at_1', 0):.0%} hit-rate@1**  ·  "
+        f"**{retrieval_eval.get('hit_rate_at_2', 0):.0%} hit-rate@2**  ·  "
+        f"{retrieval_eval.get('n_queries', '?')} labelled test queries"
     )
-    return f"""
-## 3. Retrieval (RAG) Evaluation
-
-**What it does:** before the LLM answers a question, this component finds
-the most relevant passages from a 10-article warehouse-operations knowledge
-base (AS/RS, AGV/AMR, WMS, sortation, picking strategy, safety, etc. -- see
-`src/knowledge_base.py`) using TF-IDF + cosine similarity, so the LLM answers
-from real context rather than guessing.
-
-**Evaluation data:** {retrieval_eval.get('n_queries', '?')} hand-labelled
-(query, expected-article) pairs -- a small ground-truth set built by hand to
-check the retriever finds the *right* article, not just *an* article.
-
-| Metric | Score |
-|---|---|
-| **Hit Rate @ 1** | **{retrieval_eval.get('hit_rate_at_1', 0):.0%}** |
-| **Hit Rate @ 2** | **{retrieval_eval.get('hit_rate_at_2', 0):.0%}** |
-
-| Query | Expected Doc | Retrieved (top-1) | Hit | Score |
-|---|---|---|---|---|
-{retrieval_rows}
-"""
 
 
 def eval_latency_section_md():
-    return f"""
-## 4. Latency Benchmark (per-request, CPU)
-
-Average of 50 runs each, measured on the same CPU hardware the Space runs on.
-
-| Component | Avg. latency |
-|---|---|
-| Intent classification | {latency_eval.get('intent_classifier_ms', '?')} ms |
-| Anomaly scoring | {latency_eval.get('anomaly_detector_ms', '?')} ms |
-| KB retrieval (TF-IDF) | {latency_eval.get('kb_retrieval_ms', '?')} ms |
-| LLM generation | Depends on the hosted Inference API (measured live per-request in the Assistant tab, not benchmarked here) |
-"""
+    return (
+        f"### 4. Latency (CPU, avg of 50 runs)   "
+        f"🎯 **{latency_eval.get('intent_classifier_ms', '?')} ms** intent  ·  "
+        f"**{latency_eval.get('anomaly_detector_ms', '?')} ms** anomaly  ·  "
+        f"**{latency_eval.get('kb_retrieval_ms', '?')} ms** retrieval"
+    )
 
 
-EVAL_METHODOLOGY_MD = """
-### Evaluation methodology notes
-
-- All datasets are **synthetically generated** (see `src/data_generation.py`) using
-  templated-but-varied natural language and randomised sensor distributions with a
-  fixed seed, so results are fully reproducible via `python build_artifacts.py`.
-- The intent classifier and anomaly detector are evaluated on a **held-out test
-  split** they never saw during training (stratified, 25% / 30% respectively).
-- The anomaly detector itself is trained **unsupervised** (Isolation Forest never
-  sees the `label` column during `.fit()`); labels are used only to *evaluate* it,
-  mirroring how you'd validate an anomaly model against a small set of confirmed
-  historical incidents in production.
-- In a production deployment, all three components would be continuously
-  re-evaluated against real WMS/WCS/sensor logs rather than synthetic data.
-"""
+EVAL_METHODOLOGY_MD = (
+    "*All metrics above are computed on held-out synthetic test data by "
+    "`build_artifacts.py` (fully reproducible) — see the **About** tab for "
+    "dataset details and how each model works.*"
+)
 
 
 
@@ -483,8 +396,21 @@ linked repository. Feedback welcome.*
 CUSTOM_CSS = """
 #title-banner { text-align: center; margin-bottom: 0.5em; }
 .gradio-container { max-width: 1150px !important; margin: auto; }
+.data-badge {
+    background: #eff6ff;
+    border-left: 4px solid #3b82f6;
+    border-radius: 6px;
+    padding: 10px 14px;
+    margin-bottom: 10px;
+    font-size: 0.92em;
+    line-height: 1.5;
+}
+.data-badge b { color: #1e3a8a; }
 """
 
+def data_badge(html: str) -> str:
+    return f'<div class="data-badge">{html}</div>'
+
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="Smart Warehouse AI Assistant") as demo:
     gr.Markdown(
         "<h1 id='title-banner'>🏭 Smart Warehouse AI Assistant</h1>"
@@ -500,25 +426,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
         )
 
     with gr.Tab("💬 AI Assistant"):
-        gr.Markdown(
-            "Ask about equipment status, maintenance, safety, inventory, order status, "
-            "AGV routing, picking strategy, or general warehouse-automation concepts. "
-            "Answers are grounded (RAG) in a small warehouse-operations knowledge base."
-        )
-        with gr.Accordion("ℹ️ About the data behind this tab", open=False):
-            gr.Markdown(
-                "- **Knowledge base (RAG source):** 10 original, hand-written articles "
-                "covering AS/RS, AGV/AMR, WMS, conveyor/sortation, picking strategy, "
-                "predictive maintenance, safety protocol, inventory accuracy, KPIs, and "
-                "energy efficiency (`src/knowledge_base.py`). Every answer's *Retrieved "
-                "context* line shows exactly which article(s) it drew on.\n"
-                "- **Intent classifier:** trained on ~480 synthetically generated example "
-                "queries across 8 categories (see the Model Evaluation tab for accuracy).\n"
-                "- **LLM:** a hosted instruct model called via the Hugging Face Inference "
-                "API — not run locally. If no `HF_TOKEN` is configured, or the API call "
-                "fails, this tab automatically falls back to showing the retrieved "
-                "knowledge-base passages directly, so it never just breaks."
-            )
+        gr.HTML(data_badge(
+            "🧪 <b>You are testing:</b> an LLM chatbot grounded in a 10-article synthetic "
+            "warehouse-ops knowledge base (RAG), routed by an intent classifier trained on "
+            "~480 synthetic queries. <b>Data type:</b> hand-written knowledge articles + "
+            "template-generated questions — not real Daifuku data."
+        ))
         gr.ChatInterface(
             fn=chat_fn,
             type="messages",
@@ -537,27 +450,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
             test_llm_btn.click(test_llm_fn, inputs=None, outputs=test_llm_output)
 
     with gr.Tab("📦 Inventory & Order Query"):
-        gr.Markdown(
-            "Type a natural-language inventory or order question. The intent classifier "
-            "decides whether to query the inventory table or the orders table, then "
-            "extracts SKU / order-id / zone slots to filter the result."
-        )
-        with gr.Accordion("ℹ️ About the data behind this tab", open=False):
-            gr.Markdown(
-                f"- **Inventory table:** {len(inventory_df)} synthetic SKUs across 5 "
-                "categories (Electronics, Apparel, Automotive Parts, Food & Beverage, "
-                "Household) and 4 warehouse zones, with randomised on-hand quantities, "
-                "reorder points, and unit costs.\n"
-                f"- **Orders table:** {len(orders_df)} synthetic orders with randomised "
-                "status (Received / Picking / Packed / Shipped / Delayed), line count, "
-                "priority, and zone.\n"
-                "- Both tables are generated by `src/data_generation.py` with a fixed "
-                "random seed, so they're reproducible but **not real operational data** "
-                "-- this is a stand-in for a live WMS/WCS query interface.\n"
-                "- Query parsing is regex-based slot extraction (SKU codes like `SKU-1042`, "
-                "order IDs like `#10007`, zone names) combined with the same intent "
-                "classifier used in the AI Assistant tab (`src/inventory_db.py`)."
-            )
+        gr.HTML(data_badge(
+            f"🧪 <b>You are testing:</b> NL→structured-query search over "
+            f"{len(inventory_df)} synthetic SKUs and {len(orders_df)} synthetic orders. "
+            "<b>Data type:</b> randomly generated inventory/order records (fixed seed, "
+            "reproducible) — a stand-in for a live WMS, not real warehouse data."
+        ))
         with gr.Row():
             inv_input = gr.Textbox(label="Query", placeholder="How many units of SKU-1042 are in Zone B?", scale=4)
             inv_btn = gr.Button("Search", variant="primary", scale=1)
@@ -582,26 +480,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
             gr.Dataframe(orders_df, wrap=True)
 
     with gr.Tab("⚠️ Predictive Maintenance"):
-        gr.Markdown(
-            "Enter live (or hypothetical) conveyor/crane motor sensor readings to check "
-            "for anomalous behaviour using an Isolation Forest model trained on "
-            "historical sensor patterns."
-        )
-        with gr.Accordion("ℹ️ About the data behind this tab", open=False):
-            gr.Markdown(
-                "- **Training data:** 1,000 synthetic sensor readings (900 normal + 100 "
-                "anomalous) across 4 features -- motor temperature, vibration, motor "
-                "current, and belt speed -- generated by `src/data_generation.py`. "
-                "Anomalies simulate realistic failure signatures: elevated temperature, "
-                "vibration, and current combined with reduced/erratic belt speed (the "
-                "pattern of bearing wear, belt misalignment, or motor overload).\n"
-                "- **Model:** Isolation Forest (unsupervised) trained on scaled features "
-                "-- it never sees a 'this is an anomaly' label during training, only "
-                "learns what 'normal' looks like and flags deviations from it.\n"
-                "- See the **Model Evaluation** tab for the feature-distribution chart "
-                "showing exactly how normal vs. anomalous readings differ, plus "
-                "precision/recall/F1/ROC-AUC on held-out data."
-            )
+        gr.HTML(data_badge(
+            "🧪 <b>You are testing:</b> an Isolation Forest anomaly detector for conveyor/"
+            "crane motor sensors. <b>Data type:</b> 1,000 synthetic sensor readings (900 "
+            "normal + 100 simulated-fault) across temperature, vibration, current, and belt "
+            "speed — trained unsupervised, not on real Daifuku equipment telemetry."
+        ))
         preset_dropdown = gr.Dropdown(
             choices=list(ANOMALY_PRESETS.keys()), label="Load a preset reading", value="Normal reading"
         )
@@ -625,48 +509,47 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
         )
 
     with gr.Tab("📊 Model Evaluation"):
-        gr.Markdown(
-            "Every metric on this tab is computed on **held-out test data** by "
-            "`build_artifacts.py` (not cherry-picked from a live demo run) -- "
-            "re-run that script any time to reproduce these numbers from scratch."
-        )
-
-        gr.Markdown(eval_intent_section_md())
-        gr.Markdown("**Dataset composition** (how many training examples per intent):")
-        gr.Image(os.path.join(ASSETS_DIR, "intent_dataset_composition.png"), show_label=False, container=False)
-        gr.Markdown("**Per-class precision / recall / F1:**")
-        gr.Image(os.path.join(ASSETS_DIR, "intent_per_class_bar.png"), show_label=False, container=False)
-        gr.Markdown("**Confusion matrix:**")
+        gr.HTML(data_badge(
+            "🧪 All charts below are computed on <b>held-out test data</b> by "
+            "<code>build_artifacts.py</code> — fully reproducible, not cherry-picked."
+        ))
+
+        gr.Markdown("### 1. Intent Classifier — accuracy: **{:.1%}** · macro F1: **{:.1%}**".format(
+            intent_eval.get("accuracy", 0), intent_eval.get("macro_f1", 0)
+        ))
+        with gr.Row():
+            gr.Image(os.path.join(ASSETS_DIR, "intent_dataset_composition.png"), show_label=False, container=False)
+            gr.Image(os.path.join(ASSETS_DIR, "intent_per_class_bar.png"), show_label=False, container=False)
         gr.Image(os.path.join(ASSETS_DIR, "intent_confusion_matrix.png"), show_label=False, container=False)
 
-        gr.Markdown("---")
-        gr.Markdown(eval_anomaly_section_md())
-        gr.Markdown("**Sensor feature distributions (normal vs. anomaly):**")
+        gr.Markdown("### 2. Predictive Maintenance — F1: **{:.1%}** · ROC-AUC: **{:.2f}**".format(
+            anomaly_eval.get("f1", 0), anomaly_eval.get("roc_auc", 0)
+        ))
         gr.Image(os.path.join(ASSETS_DIR, "sensor_distributions.png"), show_label=False, container=False)
         with gr.Row():
-            with gr.Column():
-                gr.Markdown("**Evaluation metrics:**")
-                gr.Image(os.path.join(ASSETS_DIR, "anomaly_metrics_bar.png"), show_label=False, container=False)
-            with gr.Column():
-                gr.Markdown("**Confusion matrix:**")
-                gr.Image(os.path.join(ASSETS_DIR, "anomaly_confusion_matrix.png"), show_label=False, container=False)
-        gr.Markdown("**ROC curve:**")
+            gr.Image(os.path.join(ASSETS_DIR, "anomaly_metrics_bar.png"), show_label=False, container=False)
+            gr.Image(os.path.join(ASSETS_DIR, "anomaly_confusion_matrix.png"), show_label=False, container=False)
         gr.Image(os.path.join(ASSETS_DIR, "anomaly_roc_curve.png"), show_label=False, container=False)
 
-        gr.Markdown("---")
-        gr.Markdown(eval_retrieval_section_md())
+        gr.Markdown("### 3. RAG Retrieval — Hit-rate@1: **{:.0%}** · Hit-rate@2: **{:.0%}**".format(
+            retrieval_eval.get("hit_rate_at_1", 0), retrieval_eval.get("hit_rate_at_2", 0)
+        ))
         gr.Image(os.path.join(ASSETS_DIR, "retrieval_hitrate_bar.png"), show_label=False, container=False)
 
-        gr.Markdown("---")
-        gr.Markdown(eval_latency_section_md())
+        gr.Markdown("### 4. Latency Benchmark (CPU, local components)")
         gr.Image(os.path.join(ASSETS_DIR, "latency_bar.png"), show_label=False, container=False)
 
-        gr.Markdown("---")
-        gr.Markdown(EVAL_METHODOLOGY_MD)
+        with gr.Accordion("📋 Full metrics tables & methodology notes", open=False):
+            gr.Markdown(eval_intent_section_md())
+            gr.Markdown(eval_anomaly_section_md())
+            gr.Markdown(eval_retrieval_section_md())
+            gr.Markdown(eval_latency_section_md())
+            gr.Markdown(EVAL_METHODOLOGY_MD)
 
     with gr.Tab("ℹ️ About"):
         gr.Markdown(ABOUT_MD)
 
 
+
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))