Upload 34 files

DEPLOY.md

@@ -19,11 +19,11 @@ Two ways to deploy: the web UI (easiest, no git needed) or the CLI/git route.
 
 1. Go to https://huggingface.co/new-space
 2. Fill in:
-   - **Space name:** e.g. `daifuku-warehouse-ai`
+   - **Space name:** e.g. `smart-warehouse-ai`
    - **License:** MIT (or your choice)
    - **Select the Space SDK:** **Gradio**
    - **Space hardware:** CPU basic (free tier is enough for this app)
-   - Visibility: **Public** (so you can share the link with Daifuku)
+   - Visibility: **Public** (so you can share the link with recruiters/employers)
 3. Click **Create Space**.
 4. On the new Space page, click **Files → Add file → Upload files**, and
    upload the *entire project folder contents* (keep the folder structure:
@@ -32,7 +32,7 @@ Two ways to deploy: the web UI (easiest, no git needed) or the CLI/git route.
 5. Wait for the Space to build (check the **Logs** tab if it fails — almost
    always a missing/incompatible package version).
 6. Once it shows "Running", your demo is live at:
-   `https://huggingface.co/spaces/<your-username>/daifuku-warehouse-ai`
+   `https://huggingface.co/spaces/<your-username>/smart-warehouse-ai`
 
 ## Option B — git (recommended if you'll keep iterating)
 
@@ -42,11 +42,11 @@ pip install huggingface_hub
 huggingface-cli login
 
 # 2. Create the Space (or create it via the web UI first, then just clone it)
-huggingface-cli repo create daifuku-warehouse-ai --type space --space_sdk gradio
+huggingface-cli repo create smart-warehouse-ai --type space --space_sdk gradio
 
 # 3. Clone it, copy in the project files, and push
-git clone https://huggingface.co/spaces/<your-username>/daifuku-warehouse-ai
-cd daifuku-warehouse-ai
+git clone https://huggingface.co/spaces/<your-username>/smart-warehouse-ai
+cd smart-warehouse-ai
 cp -r /path/to/this/project/* .
 git add .
 git commit -m "Initial commit: Smart Warehouse AI Assistant"
@@ -57,7 +57,7 @@ The Space will automatically build from `requirements.txt` and launch
 `app.py` (as declared in the README's YAML front matter: `sdk: gradio`,
 `app_file: app.py`).
 
-## Enabling the LLM (recommended before sharing with Daifuku)
+## Enabling the LLM (recommended before sharing this project)
 
 By default the Space runs in **retrieval-only fallback mode** — it still
 works, but answers are extractive rather than LLM-generated. To turn on
@@ -103,14 +103,17 @@ git commit -m "Retrain models"
 git push
 ```
 
-## Sharing with Daifuku
+## Sharing this project
 
 Once it's live, share the Space URL directly:
 
 ```
-https://huggingface.co/spaces/<your-username>/daifuku-warehouse-ai
+https://huggingface.co/spaces/<your-username>/smart-warehouse-ai
 ```
 
 Consider also linking the **Model Evaluation** tab specifically in your
 application/cover letter, since it's the clearest evidence of rigorous,
-reproducible ML work rather than just a UI demo.
+reproducible ML work rather than just a UI demo. Since everything here is
+built on synthetic, self-generated data, this same Space link works as-is
+for applications to multiple companies — no company-specific data or
+branding needs to change.

README.md

@@ -21,7 +21,7 @@ with a full **Model Evaluation** tab reporting real accuracy/F1/ROC-AUC
 metrics on held-out test data.
 
 👉 **Live demo:** add your Space URL here once deployed, e.g.
-`https://huggingface.co/spaces/<your-username>/daifuku-warehouse-ai`
+`https://huggingface.co/spaces/<your-username>/smart-warehouse-ai`
 
 ## Tabs
 
@@ -50,7 +50,7 @@ metrics on held-out test data.
 
 ```bash
 git clone <this-repo>
-cd daifuku-warehouse-ai
+cd smart-warehouse-ai
 pip install -r requirements.txt
 
 # (re)generate datasets, train models, produce evaluation plots/metrics
@@ -85,7 +85,7 @@ See [`DEPLOY.md`](./DEPLOY.md) for full step-by-step instructions.
 ## Project structure
 
 ```
-daifuku-warehouse-ai/
+smart-warehouse-ai/
 ├── app.py                  # Gradio app (5 tabs)
 ├── build_artifacts.py      # generates data, trains models, evaluates, saves plots
 ├── requirements.txt

app.py

@@ -1,7 +1,7 @@
 """
 Smart Warehouse AI Assistant
 =============================
-A Daifuku-style intralogistics AI copilot demo, built for a Hugging Face
+A warehouse/intralogistics AI copilot demo, built for a Hugging Face
 Space. Combines:
 
   1. An LLM-powered assistant (RAG: TF-IDF retrieval + hosted LLM via the
@@ -15,7 +15,7 @@ Space. Combines:
   5. A Model Evaluation tab reporting real accuracy/F1/ROC-AUC metrics
      computed by build_artifacts.py.
 
-Author: (your name here) -- built as an application project for Daifuku Co., Ltd.
+Author: (your name here) -- built as a portfolio / job-application project.
 """
 
 import json
@@ -176,10 +176,20 @@ def test_llm_fn():
 ASSISTANT_EXAMPLES = [
     "The conveyor belt in Zone C is making noise",
     "How many units of SKU-1042 are in Zone B?",
+    "What's the status of order #10007?",
     "What's the difference between an AGV and an AMR?",
     "A forklift near-miss was reported in Zone A",
     "What's the fastest picking route for a high volume order?",
     "Is Crane-03 operational?",
+    "Route AGV-12 to picking station 5",
+    "What is cycle counting?",
+    "Redirect AGV-07 around the blocked aisle in Zone B",
+    "How does an AS/RS crane retrieve a pallet?",
+    "What KPIs matter most in warehouse automation?",
+    "Schedule maintenance for Sorter-02",
+    "Should we batch pick these orders together?",
+    "What is predictive maintenance?",
+    "Log a safety incident involving AMR-21",
 ]
 
 
@@ -303,30 +313,83 @@ ABOUT_MD = f"""
 # 🏭 Smart Warehouse AI Assistant
 
 **A portfolio project demonstrating an applied-AI approach to intralogistics
-operations, built as part of a job application to Daifuku Co., Ltd.**
+and warehouse automation operations.**
+
+Modern warehouse automation platforms — automated storage & retrieval
+systems (AS/RS), conveyor & sortation lines, AGVs/AMRs, and the WMS/WCS
+software that orchestrates them — generate huge volumes of operational
+data: equipment telemetry, transactions, safety logs, and ad-hoc questions
+from floor staff. This project is a compact, end-to-end example of how an
+AI layer can sit on top of that kind of system: routing requests correctly,
+answering from real operational context instead of guessing, catching
+equipment problems early, and doing all of it with **honest, reproducible
+evaluation** rather than a demo that just "looks like it works."
 
 ## What this demonstrates
 
-Daifuku builds material handling and automation systems -- AS/RS, conveyors
-and sortation, AGVs/AMRs, and the software (WMS/WCS) that orchestrates them.
-This project is a compact but end-to-end example of how an AI layer can sit
-on top of that kind of system:
-
-| Capability | Where |
-|---|---|
-| **LLM-powered natural-language assistant**, grounded with retrieval (RAG) so it answers from real warehouse-ops knowledge rather than hallucinating | *AI Assistant* tab |
-| **Intent classification** to route free-text requests (maintenance, safety, navigation, inventory, etc.) the way a real ops system would triage tickets | *AI Assistant* / *Inventory* tabs |
-| **Predictive maintenance** via unsupervised anomaly detection on conveyor/crane sensor streams -- catching bearing wear or misalignment before an unplanned stoppage | *Predictive Maintenance* tab |
-| **NL-to-structured-query** over inventory/order data, a lightweight stand-in for a WMS query tool | *Inventory & Order Query* tab |
-| **Rigorous, reproducible evaluation** of every ML component (accuracy, F1, ROC-AUC, retrieval hit-rate, latency) rather than just a demo that "looks like it works" | *Model Evaluation* tab |
+| Capability | Where | Techniques used |
+|---|---|---|
+| **LLM-powered natural-language assistant**, grounded with retrieval (RAG) so it answers from real domain knowledge rather than hallucinating | *AI Assistant* tab | TF-IDF retrieval + hosted LLM (HF Inference API) |
+| **Intent classification** to route free-text requests (maintenance, safety, navigation, inventory, etc.) the way a real ops system would triage tickets | *AI Assistant* / *Inventory* tabs | TF-IDF + Logistic Regression |
+| **Predictive maintenance** via unsupervised anomaly detection on conveyor/crane sensor streams — catching bearing wear or misalignment before an unplanned stoppage | *Predictive Maintenance* tab | Isolation Forest, unsupervised |
+| **NL-to-structured-query** over inventory/order data, a lightweight stand-in for a WMS query tool | *Inventory & Order Query* tab | Regex slot extraction + intent routing |
+| **Rigorous, reproducible evaluation** of every ML component (accuracy, F1, ROC-AUC, retrieval hit-rate, latency) rather than just a demo that "looks like it works" | *Model Evaluation* tab | scikit-learn metrics, held-out test splits |
+
+## Dataset overview — what the data is and where it's from
+
+**Every dataset in this project is synthetically generated by the project's
+own code** (`src/data_generation.py` and `src/knowledge_base.py`), not
+scraped, exported, or sourced from any real company's systems. This was a
+deliberate choice: it keeps the project fully self-contained, reproducible,
+and shareable without any data-privacy or licensing concerns, while still
+being realistic enough to demonstrate the underlying ML techniques properly.
+
+| Dataset | What it is | Size | How it's generated |
+|---|---|---|---|
+| **Knowledge base** | Original, hand-written articles on generic warehouse-automation concepts (AS/RS, AGV/AMR, WMS, sortation, picking strategy, predictive maintenance, safety, inventory accuracy, KPIs, energy efficiency) | 10 articles | Written by the developer specifically for this project |
+| **Intent queries** | Example free-text operational questions/requests across 8 categories | ~480 examples | ~8 templates per category with randomised SKU codes, zone names, order IDs, and equipment IDs slotted in |
+| **Inventory table** | SKU records with category, zone, on-hand units, reorder point, unit cost | 60 SKUs | Randomised within realistic ranges (fixed seed) |
+| **Orders table** | Order records with status, line count, priority, zone | 80 orders | Randomised within realistic ranges (fixed seed) |
+| **Sensor readings** | Conveyor/crane motor telemetry: temperature, vibration, current, belt speed | 1,000 readings (900 normal + 100 anomalous) | Normal readings drawn from realistic operating ranges; anomalies simulate known failure signatures (elevated temp/vibration/current + reduced belt speed) |
+| **Retrieval eval set** | Hand-labelled (question → expected knowledge-base article) pairs | 10 pairs | Written by the developer to check retrieval accuracy |
+
+## How each model works (function)
+
+| Model | Purpose | Algorithm | Input → Output |
+|---|---|---|---|
+| **Intent classifier** | Decide what kind of request a query is (maintenance, safety, inventory, order status, navigation, picking, system status, general FAQ) | TF-IDF + Logistic Regression | Free text → intent label + confidence |
+| **KB retriever** | Find the most relevant knowledge-base passage(s) for a query, to ground the LLM's answer | TF-IDF + cosine similarity | Free text → top-k ranked passages |
+| **LLM assistant** | Generate a natural-language answer grounded in the retrieved context | Hosted instruct LLM (HF Inference API), multi-model fallback chain | Query + context → grounded answer (or an extractive fallback if the LLM is unavailable) |
+| **Inventory/order query** | Turn a question into a filtered table lookup | Regex slot extraction (SKU / order ID / zone) + intent routing | Free text → filtered inventory or orders table |
+| **Anomaly detector** | Flag abnormal equipment sensor readings before they cause a stoppage | Isolation Forest (unsupervised), StandardScaler | 4 sensor features → anomaly / normal + anomaly score |
+
+## How to test this project
+
+1. **AI Assistant** — try one of the example questions, or ask your own
+   (e.g. *"The conveyor belt in Zone C is making noise"*). Check the
+   metadata line under each answer to see the detected intent, which
+   knowledge-base article(s) were retrieved, and whether the LLM or the
+   fallback path answered. If the LLM path isn't working, open the
+   **LLM connection diagnostics** accordion and click "Test LLM connection"
+   for a precise error message.
+2. **Inventory & Order Query** — try *"How many units of SKU-1042 are in
+   Zone B?"* or *"What's the status of order #10007?"*, or browse the full
+   synthetic tables in the accordion below the search box.
+3. **Predictive Maintenance** — load one of the presets (Normal / Early
+   bearing wear / Severe fault) or drag the sliders yourself, then click
+   *"Check for anomaly"* to see the model's verdict and recommended action.
+4. **Model Evaluation** — every chart here is generated on **held-out test
+   data** by `build_artifacts.py`, not cherry-picked from a live run. Run
+   that script yourself to reproduce every number from scratch.
 
 ## Tech stack
 
 - **UI / deployment:** [Gradio](https://gradio.app) on Hugging Face Spaces
 - **LLM:** Hosted instruct model via the Hugging Face **Inference API**
-  (`huggingface_hub.InferenceClient`), configurable via the `LLM_MODEL_ID`
-  env var. Falls back gracefully to a retrieval-only answer if no `HF_TOKEN`
-  is configured, so the public demo never breaks.
+  (`huggingface_hub.InferenceClient`), with a multi-model fallback chain and
+  auto provider routing. Configurable via the `LLM_MODEL_ID` env var. Falls
+  back gracefully to a retrieval-only answer if no API token is configured
+  or every candidate model fails, so the public demo never just breaks.
 - **Retrieval:** TF-IDF + cosine similarity over a small hand-written
   warehouse-operations knowledge base (simple, fast, fully local RAG).
 - **Intent classification:** TF-IDF + Logistic Regression (scikit-learn) --
@@ -337,7 +400,8 @@ on top of that kind of system:
   unsupervised on scaled sensor features.
 - **Evaluation:** scikit-learn metrics + matplotlib, all computed by
   `build_artifacts.py` and saved as static artifacts the app loads at
-  startup (fast, reproducible Space boot).
+  startup (fast, reproducible Space boot, self-healing if the deployed
+  scikit-learn version ever drifts from the one used to train the models).
 
 ## Architecture
 
@@ -363,19 +427,19 @@ on top of that kind of system:
    Sensor stream ───► StandardScaler ───► IsolationForest ───► anomaly / normal
 ```
 
-## Why this matters for Daifuku
+## Why this approach
 
-Modern intralogistics platforms generate huge volumes of operational data --
-equipment telemetry, WMS transactions, safety logs. The value of AI here isn't
-a flashy chatbot; it's **routing, grounding, and reliability**: correctly
-triaging a request, answering from real operational context instead of
-guessing, and flagging equipment problems before they cause downtime. This
-project tries to demonstrate that mindset in miniature, with honest,
-reproducible evaluation numbers rather than cherry-picked demo runs.
+The value of AI in a warehouse-automation context isn't a flashy chatbot —
+it's **routing, grounding, and reliability**: correctly triaging a request,
+answering from real operational context instead of guessing, and flagging
+equipment problems before they cause downtime. Every component here was
+chosen to be as simple as it can be while still doing that job well and
+being honestly evaluated, rather than reaching for the biggest available
+model by default.
 
 ## Limitations & next steps
 
-- All data here is **synthetic**, for portfolio/demo purposes -- a production
+- All data here is **synthetic**, for portfolio/demo purposes — a production
   version would connect to real WMS/WCS APIs and historical sensor logs.
 - The intent set (8 classes) and knowledge base (10 articles) are intentionally
   small to keep the demo fast and auditable; both are easy to extend.
@@ -384,8 +448,8 @@ reproducible evaluation numbers rather than cherry-picked demo runs.
   semi-supervised model once labelled failure data is available.
 
 ---
-*Built as an application project. Source code available on request / in the
-linked repository. Feedback welcome.*
+*Built as a portfolio/application project. Source code available on request
+or in the linked repository. Feedback welcome.*
 """
 
 
@@ -430,7 +494,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
             "🧪 <b>Source:</b> hand-written by the developer — 10 original knowledge-base "
             "articles on warehouse operations (AS/RS, AGV/AMR, WMS, sortation, picking, "
             "maintenance, safety) plus ~480 template-generated example queries. Not scraped "
-            "or sourced from Daifuku or any real company.<br>"
+            "or sourced from any real company.<br>"
             "<b>What it describes:</b> generic intralogistics/automation concepts and "
             "operational scenarios (equipment faults, safety incidents, order/inventory "
             "questions) — general domain knowledge, not any specific facility's live data.<br>"
@@ -460,8 +524,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
         gr.HTML(data_badge(
             f"🧪 <b>Source:</b> randomly generated by the developer's code "
             f"(`src/data_generation.py`, fixed seed) — {len(inventory_df)} synthetic SKU "
-            f"records and {len(orders_df)} synthetic orders. Not exported from Daifuku or "
-            "any real WMS.<br>"
+            f"records and {len(orders_df)} synthetic orders. Not exported from any real "
+            "company's WMS.<br>"
             "<b>What it describes:</b> a stand-in inventory table (SKU, category, zone, "
             "on-hand units, reorder point, unit cost) and orders table (order ID, status, "
             "line count, priority, zone) — realistic in shape and ranges, but fictional "
@@ -485,6 +549,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
                 "What's the status of order #10007?",
                 "Show me low stock items",
                 "Any delayed orders?",
+                "Is SKU-1015 in stock at Zone A?",
+                "Do we have enough SKU-1030 to fulfill 200 units?",
+                "Track order #10021 for me",
+                "Show the fulfillment status of #10045",
             ],
             inputs=inv_input,
         )
@@ -498,7 +566,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), css=CUSTOM_CSS, title="
         gr.HTML(data_badge(
             "🧪 <b>Source:</b> randomly generated by the developer's code "
             "(`src/data_generation.py`, fixed seed) — 1,000 synthetic sensor readings "
-            "(900 normal + 100 simulated-fault). Not logged from real Daifuku equipment.<br>"
+            "(900 normal + 100 simulated-fault). Not logged from real equipment.<br>"
             "<b>What it describes:</b> conveyor/crane motor sensor readings — temperature, "
             "vibration, current draw, and belt speed — with the 'anomaly' readings modelled "
             "on realistic failure signatures (elevated temp/vibration/current with reduced "

src/anomaly_model.py

@@ -5,7 +5,7 @@ Isolation Forest based anomaly detector for conveyor / crane motor sensor
 streams (motor temperature, vibration, current draw, belt speed). This
 powers the "Predictive Maintenance" tab -- flags abnormal equipment
 behaviour before it causes an unplanned stoppage, which is exactly the kind
-of workload Daifuku's intralogistics platforms (e.g. AS/RS, sorters, AGVs)
+of workload modern intralogistics platforms (e.g. AS/RS, sorters, AGVs)
 generate continuously in production.
 """