init

.gitignore

@@ -0,0 +1,3 @@
+models/*.joblib
+**/__pycache__/
+

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+# Optional system packages for faster numpy/pandas builds
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python dependencies first to leverage Docker layer caching
+COPY api/requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code and model artifacts
+COPY api ./api
+COPY models ./models
+
+# Spaces injects the listening port through the PORT env var
+ENV PORT=7860
+
+# Expose FastAPI via uvicorn
+CMD ["uvicorn", "api.main:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -0,0 +1,57 @@
+# Hugging Face Spaces Deployment
+
+This folder contains everything required to deploy the Predictive Maintenance API to Hugging Face Spaces as a Docker Space.
+
+## Contents
+
+- `api/`: FastAPI application (copied from `AC02-ML/api`)
+- `requirements.txt`: Python dependencies (now includes `huggingface_hub`)
+- `Dockerfile`: Container recipe used by Spaces
+
+## One-Time Setup
+
+1. Install the Hugging Face CLI and log in:
+   ```
+   pip install huggingface_hub
+   huggingface-cli login
+   ```
+2. (Optional) Enable Git LFS if the model artifacts exceed 10 MB:
+   ```
+   git lfs install
+   ```
+
+## Deploy Steps
+
+1. Initialize the Space repository (replace `<org>` and `<space>`):
+   ```
+   cd hf-space
+   git init
+   git remote add origin https://huggingface.co/spaces/<org>/<space>
+   ```
+2. Commit the deployment bundle:
+   ```
+   git add .
+   git commit -m "Initial Hugging Face Space"
+   git push origin main
+   ```
+3. In the Hugging Face UI:
+   - Set **Space SDK** to `Docker`.
+   - Pick hardware (`CPU Basic` is enough for CPU-only inference).
+   - Restart the Space if you tweak environment variables (e.g., secrets).
+
+Once the build succeeds, the FastAPI docs are accessible at `https://<space>.hf.space/docs` and the REST endpoints follow the paths defined in `api/main.py`.
+
+### Hosting model artifacts
+
+- Upload the serialized pipelines to the existing Hugging Face _model_ repo `deropxyz/AC02-ML`:
+  ```
+  hf upload --repo-id deropxyz/AC02-ML AC02-ML/model_pipeline_improved.joblib
+  hf upload --repo-id deropxyz/AC02-ML AC02-ML/model_pipeline.joblib
+  ```
+- `api/main.py` downloads the artifacts at startup using `HF_MODEL_REPO`, `HF_PRIMARY_MODEL`, and `HF_FALLBACK_MODEL` env vars (defaults target `deropxyz/AC02-ML`). If the model repo is private, add `HF_TOKEN` in the Space settings (Variables & secrets).
+- No large binaries are stored inside this repo; the runtime pulls them from the Hub cache.
+
+## Keeping the Space Updated
+
+- Copy any new code from `AC02-ML` into this folder, commit, and push.
+- When retraining, upload the new model artifact to the Hub model repo and update the env vars if filenames change.

api/README.md

@@ -0,0 +1,379 @@
+# Predictive Maintenance FastAPI
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Run API Server
+```bash
+# Development mode with auto-reload
+python main.py
+
+# Or using uvicorn directly
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+### 3. Access API
+- **HTML Test Interface**: Open `index.html` in browser (recommended for testing)
+- **Interactive Docs**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+- **Health Check**: http://localhost:8000/health
+
+### 4. Quick Testing (Windows)
+```bash
+# Install dependencies
+install_requirements.bat
+
+# Start server
+start_server.bat
+
+# Open test interface
+open_test_interface.bat
+```
+
+---
+
+## 📡 API Endpoints
+
+### 1. Single Prediction: `POST /predict`
+
+**Request Body:**
+```json
+{
+  "machine_id": "M_L_01",
+  "air_temperature": 298.1,
+  "process_temperature": 308.6,
+  "rotational_speed": 1551,
+  "torque": 42.8,
+  "tool_wear": 0,
+  "type": "M"
+}
+```
+
+**Response (Enhanced with Features & Anomaly Detection):**
+```json
+{
+  "machine_id": "M_L_01",
+  "timestamp": "2024-11-26T10:30:00.123456",
+  "prediction": "HEALTHY",
+  "confidence": 0.9234,
+  "diagnostics": {
+    "primary_cause": "Normal Operation",
+    "sensor_alert": "All parameters within optimal range. Health score: 100%.",
+    "recommended_action": "CONTINUE NORMAL OPERATION. Next scheduled maintenance as planned.",
+    "severity": "LOW"
+  },
+  "features": {
+    "Air_temp_K": 298.1,
+    "Process_temp_K": 308.6,
+    "Speed_rpm": 1551,
+    "Torque_Nm": 42.8,
+    "Tool_wear_min": 0,
+    "Tool_wear_hours": 0.0,
+    "Temperature_Diff": 10.5,
+    "Power_W": 6951.2,
+    "Type_Encoded": 1
+  },
+  "anomalies": [],
+  "overall_health": "🟢 EXCELLENT HEALTH - All systems operating optimally within normal parameters."
+}
+```
+
+### 2. Batch Prediction (CSV Download): `POST /predict/batch`
+
+**Request:**
+- Upload CSV file (any size)
+- **Flexible CSV Format** - accepts columns with:
+  - UPPERCASE/lowercase/MixedCase names
+  - Units in brackets: `air_temperature_[k]`, `Air Temperature [K]`, etc.
+  - Extra columns (will be ignored)
+  - Any column order
+
+**Required Columns (flexible naming):**
+- `air_temperature` or `air_temperature_[k]`
+- `process_temperature` or `process_temperature_[k]`
+- `rotational_speed` or `rotational_speed_[rpm]`
+- `torque` or `torque_[nm]`
+- `tool_wear` or `tool_wear_[min]`
+- `type`
+- Optional: `machine_id`
+
+**Response:**
+- CSV file download with added columns:
+  - `Prediction`: HEALTHY or FAILURE
+  - `Confidence`: 0.0 to 1.0
+  - `Primary_Cause`: Root cause analysis
+  - `Sensor_Alert`: Specific sensor readings
+  - `Recommended_Action`: Actionable maintenance advice
+  - `Severity`: LOW, MEDIUM, HIGH, CRITICAL
+  - `Processed_At`: Timestamp
+
+### 3. Batch Prediction (JSON for UI): `POST /predict/batch/json`
+
+**Request:**
+- Upload CSV file (max 500 rows)
+- Same flexible format as `/predict/batch`
+
+**Response:**
+```json
+{
+  "summary": {
+    "total_records": 5,
+    "predictions": {
+      "failure": 2,
+      "healthy": 3,
+      "errors": 0
+    },
+    "failure_rate": 40.0
+  },
+  "results": [
+    {
+      "row_number": 1,
+      "machine_id": "M_001",
+      "prediction": "HEALTHY",
+      "confidence": 0.9234,
+      "diagnostics": {...},
+      "features": {...},
+      "anomalies": [...],
+      "overall_health": "🟢 EXCELLENT HEALTH",
+      "input_data": {...}
+    }
+  ],
+  "processed_at": "2024-11-26T10:30:00"
+}
+```
+
+---
+
+## 🧠 Diagnostic Engine Rules
+
+### Priority 1: CRITICAL
+- **Tool Wear > 200 min**: Immediate tool replacement required
+
+### Priority 2: HIGH
+- **Power > 9000 W** or **Torque > 60 Nm**: Mechanical overload detected
+- **ML Anomaly (Confidence > 80%)**: Unusual pattern detected
+
+### Priority 3: MEDIUM
+- **Temperature Diff < 8.0 K at Speed > 1300 RPM**: Cooling system issue
+- **Temperature Diff > 15.0 K**: Excessive thermal stress
+- **Speed > 2500 RPM**: High-speed operation risk
+
+### Priority 4: LOW
+- **All parameters normal**: Continue operation
+
+---
+
+## 🔬 Feature Engineering (Physics-Based)
+
+The API automatically calculates:
+
+1. **Temperature_Diff** = `process_temperature` - `air_temperature`
+   - Indicates thermal stress
+   - Optimal range: 8-12 K
+
+2. **Power_W** = `torque` × `rotational_speed` × (2π / 60)
+   - Mechanical power output
+   - Safety limit: 9000 W
+
+3. **Type_Encoded** = {L: 0, M: 1, H: 2}
+   - Machine type categorization
+
+---
+
+## 📊 Example cURL Commands
+
+### Single Prediction
+```bash
+curl -X POST "http://localhost:8000/predict" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "machine_id": "M_L_01",
+    "air_temperature": 298.1,
+    "process_temperature": 308.6,
+    "rotational_speed": 1551,
+    "torque": 42.8,
+    "tool_wear": 0,
+    "type": "M"
+  }'
+```
+
+### Batch Prediction
+```bash
+curl -X POST "http://localhost:8000/predict/batch" \
+  -F "file=@test_data.csv" \
+  -o predictions_output.csv
+```
+
+### Health Check
+```bash
+curl http://localhost:8000/health
+```
+
+### Model Info
+```bash
+curl http://localhost:8000/model/info
+```
+
+---
+
+## 🛠️ Python Client Example
+
+```python
+import requests
+import pandas as pd
+
+# Single prediction
+url = "http://localhost:8000/predict"
+data = {
+    "machine_id": "M_L_01",
+    "air_temperature": 298.1,
+    "process_temperature": 308.6,
+    "rotational_speed": 1551,
+    "torque": 42.8,
+    "tool_wear": 0,
+    "type": "M"
+}
+
+response = requests.post(url, json=data)
+result = response.json()
+print(f"Prediction: {result['prediction']}")
+print(f"Confidence: {result['confidence']}")
+print(f"Action: {result['diagnostics']['recommended_action']}")
+
+# Batch prediction
+url_batch = "http://localhost:8000/predict/batch"
+files = {'file': open('test_data.csv', 'rb')}
+response = requests.post(url_batch, files=files)
+
+with open('predictions.csv', 'wb') as f:
+    f.write(response.content)
+```
+
+---
+
+## 📂 CSV Format for Batch Processing (FLEXIBLE!)
+
+### ✅ Format 1: Simple (Recommended)
+```csv
+machine_id,air_temperature,process_temperature,rotational_speed,torque,tool_wear,type
+M_L_01,298.1,308.6,1551,42.8,0,M
+M_L_02,299.2,310.1,1450,38.5,150,L
+M_H_01,297.5,312.8,1800,65.2,220,H
+```
+
+### ✅ Format 2: With Units (Dataset Format)
+```csv
+machine_id,air_temperature_[k],process_temperature_[k],rotational_speed_[rpm],torque_[nm],tool_wear_[min],type
+M_L_01,298.1,308.6,1551,42.8,0,M
+M_L_02,299.2,310.1,1450,38.5,150,L
+```
+
+### ✅ Format 3: Mixed Case with Spaces
+```csv
+Machine ID,Air Temperature [K],Process Temperature [K],Rotational Speed [RPM],Torque [Nm],Tool Wear [min],TYPE
+M_L_01,298.1,308.6,1551,42.8,0,M
+```
+
+### ✅ Format 4: Extra Columns (Will be Ignored)
+```csv
+machine_id,timestamp,air_temperature,process_temperature,rotational_speed,torque,tool_wear,type,location,operator
+M_L_01,2024-11-26,298.1,308.6,1551,42.8,0,M,Factory_A,John
+```
+
+**All formats above are automatically handled by the API!**
+
+**Output CSV** (additional columns):
+```csv
+...,Prediction,Confidence,Primary_Cause,Sensor_Alert,Recommended_Action,Severity,Processed_At
+...,HEALTHY,0.9234,Normal Operation,All parameters within optimal range...,CONTINUE NORMAL OPERATION...,LOW,2024-11-26T10:30:00
+...,HEALTHY,0.8876,Normal Operation,All parameters within optimal range...,CONTINUE NORMAL OPERATION...,LOW,2024-11-26T10:30:01
+...,FAILURE,0.9567,Tool End of Life,Tool wear (220 min) exceeds safety threshold...,IMMEDIATE ACTION: Replace cutting tool...,CRITICAL,2024-11-26T10:30:02
+```
+
+---
+
+## 🔐 Production Deployment
+
+### Environment Variables
+```bash
+export MODEL_PATH="/path/to/model_pipeline.joblib"
+export API_HOST="0.0.0.0"
+export API_PORT="8000"
+export LOG_LEVEL="info"
+```
+
+### Docker Deployment
+```dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+### Run with Gunicorn (Production)
+```bash
+pip install gunicorn
+gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
+```
+
+---
+
+## 📈 Performance Metrics
+
+- **Model**: RandomForest Classifier (Optimized with Ensemble)
+- **Features**: 9 engineered features (including Tool_wear_hours)
+- **F1-Score**: ~75-85% (after optimization)
+- **Inference Time**: ~10-20ms per prediction
+- **Batch Processing**: 
+  - CSV Download: Unlimited rows
+  - JSON Response: Max 500 rows (for UI display)
+  - Throughput: ~100-200 records/second
+- **Anomaly Detection**: 7 parameter checks (Real-time)
+- **Overall Health Assessment**: 4 levels (EXCELLENT/GOOD/FAIR/POOR)
+
+---
+
+## 🐛 Troubleshooting
+
+### Model Not Loading
+```bash
+# Check if model file exists
+ls ../models/model_pipeline_improved.joblib
+ls ../models/model_pipeline.joblib
+
+# Verify model structure
+python -c "import joblib; m = joblib.load('../models/model_pipeline.joblib'); print(m.keys())"
+```
+
+### CORS Issues
+- Already configured for `allow_origins=["*"]`
+- Modify in `main.py` if needed for specific domains
+
+### Port Already in Use
+```bash
+# Change port in main.py or use:
+uvicorn main:app --port 8001
+```
+
+---
+
+## 📞 API Support
+
+For issues or questions:
+1. Check `/health` endpoint for model status
+2. Review logs for detailed error messages
+3. Validate input data matches schema in `/docs`
+
+---
+
+**Built with FastAPI 🚀 | Production-Ready | ML + Physics-Based Diagnostics**

api/index.html

@@ -0,0 +1,1155 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Predictive Maintenance API - Test Interface</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 30px;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+        }
+
+        .header p {
+            font-size: 1.1em;
+            opacity: 0.9;
+        }
+
+        .tabs {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+
+        .tab-button {
+            flex: 1;
+            padding: 15px;
+            background: white;
+            border: none;
+            border-radius: 10px 10px 0 0;
+            font-size: 1.1em;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .tab-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 8px rgba(0, 0, 0, 0.15);
+        }
+
+        .tab-button.active {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+
+        .tab-content {
+            display: none;
+            background: white;
+            border-radius: 0 0 10px 10px;
+            padding: 30px;
+            box-shadow: 0 8px 16px rgba(0, 0, 0, 0.2);
+        }
+
+        .tab-content.active {
+            display: block;
+            animation: fadeIn 0.3s;
+        }
+
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .form-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+
+        .form-group {
+            display: flex;
+            flex-direction: column;
+        }
+
+        label {
+            font-weight: 600;
+            margin-bottom: 8px;
+            color: #333;
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .info-icon {
+            font-size: 0.9em;
+            color: #667eea;
+            cursor: help;
+        }
+
+        input,
+        select {
+            padding: 12px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            font-size: 1em;
+            transition: all 0.3s;
+        }
+
+        input:focus,
+        select:focus {
+            outline: none;
+            border-color: #667eea;
+            box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+        }
+
+        .button-group {
+            display: flex;
+            gap: 15px;
+            margin-top: 20px;
+        }
+
+        button {
+            flex: 1;
+            padding: 15px 30px;
+            font-size: 1.1em;
+            font-weight: 600;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: all 0.3s;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .btn-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 12px rgba(102, 126, 234, 0.4);
+        }
+
+        .btn-secondary {
+            background: #f0f0f0;
+            color: #333;
+        }
+
+        .btn-secondary:hover {
+            background: #e0e0e0;
+        }
+
+        .result-container {
+            margin-top: 30px;
+            padding: 25px;
+            border-radius: 10px;
+            display: none;
+            animation: slideIn 0.4s;
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateX(-20px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateX(0);
+            }
+        }
+
+        .result-container.success {
+            background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%);
+            border: 2px solid #667eea;
+            display: block;
+        }
+
+        .result-container.error {
+            background: #fff0f0;
+            border: 2px solid #ff4444;
+            display: block;
+        }
+
+        .prediction-header {
+            display: flex;
+            align-items: center;
+            gap: 15px;
+            margin-bottom: 20px;
+            padding-bottom: 15px;
+            border-bottom: 2px solid #e0e0e0;
+        }
+
+        .prediction-badge {
+            padding: 10px 20px;
+            border-radius: 25px;
+            font-weight: 700;
+            font-size: 1.2em;
+            text-transform: uppercase;
+        }
+
+        .badge-healthy {
+            background: #4caf50;
+            color: white;
+        }
+
+        .badge-failure {
+            background: #ff4444;
+            color: white;
+        }
+
+        .confidence-bar {
+            flex: 1;
+            height: 30px;
+            background: #e0e0e0;
+            border-radius: 15px;
+            overflow: hidden;
+            position: relative;
+        }
+
+        .confidence-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-weight: 600;
+            transition: width 0.5s ease;
+        }
+
+        .diagnostics-grid {
+            display: grid;
+            gap: 15px;
+        }
+
+        .diagnostic-item {
+            padding: 15px;
+            background: white;
+            border-radius: 8px;
+            border-left: 4px solid #667eea;
+        }
+
+        .diagnostic-label {
+            font-weight: 600;
+            color: #667eea;
+            margin-bottom: 5px;
+            text-transform: uppercase;
+            font-size: 0.9em;
+        }
+
+        .diagnostic-value {
+            color: #333;
+            line-height: 1.6;
+        }
+
+        .severity-badge {
+            display: inline-block;
+            padding: 5px 15px;
+            border-radius: 15px;
+            font-weight: 600;
+            font-size: 0.9em;
+        }
+
+        .severity-low {
+            background: #4caf50;
+            color: white;
+        }
+
+        .severity-medium {
+            background: #ff9800;
+            color: white;
+        }
+
+        .severity-high {
+            background: #ff5722;
+            color: white;
+        }
+
+        .severity-critical {
+            background: #f44336;
+            color: white;
+            animation: pulse 1.5s infinite;
+        }
+
+        @keyframes pulse {
+
+            0%,
+            100% {
+                opacity: 1;
+            }
+
+            50% {
+                opacity: 0.7;
+            }
+        }
+
+        .upload-area {
+            border: 3px dashed #667eea;
+            border-radius: 10px;
+            padding: 40px;
+            text-align: center;
+            cursor: pointer;
+            transition: all 0.3s;
+            background: #f8f9ff;
+        }
+
+        .upload-area:hover {
+            background: #eef1ff;
+            border-color: #764ba2;
+        }
+
+        .upload-area.dragging {
+            background: #e0e7ff;
+            border-color: #4f46e5;
+        }
+
+        .upload-icon {
+            font-size: 3em;
+            color: #667eea;
+            margin-bottom: 15px;
+        }
+
+        .file-name {
+            margin-top: 15px;
+            padding: 10px;
+            background: white;
+            border-radius: 8px;
+            font-weight: 600;
+            color: #667eea;
+        }
+
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 20px;
+        }
+
+        .loading.active {
+            display: block;
+        }
+
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 15px;
+        }
+
+        @keyframes spin {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        .preset-buttons {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+            flex-wrap: wrap;
+        }
+
+        .preset-btn {
+            padding: 8px 16px;
+            background: #f0f0f0;
+            border: 2px solid #667eea;
+            border-radius: 20px;
+            cursor: pointer;
+            transition: all 0.3s;
+            font-size: 0.9em;
+            font-weight: 600;
+            color: #667eea;
+        }
+
+        .preset-btn:hover {
+            background: #667eea;
+            color: white;
+        }
+
+        .api-status {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            padding: 10px 20px;
+            background: white;
+            border-radius: 25px;
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            font-weight: 600;
+        }
+
+        .status-dot {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            animation: blink 2s infinite;
+        }
+
+        .status-online {
+            background: #4caf50;
+        }
+
+        .status-offline {
+            background: #ff4444;
+        }
+
+        @keyframes blink {
+
+            0%,
+            100% {
+                opacity: 1;
+            }
+
+            50% {
+                opacity: 0.5;
+            }
+        }
+
+        @media (max-width: 768px) {
+            .form-grid {
+                grid-template-columns: 1fr;
+            }
+
+            .button-group {
+                flex-direction: column;
+            }
+
+            .header h1 {
+                font-size: 1.8em;
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <div class="api-status" id="apiStatus">
+        <div class="status-dot status-offline" id="statusDot"></div>
+        <span id="statusText">Checking...</span>
+    </div>
+
+    <div class="container">
+        <div class="header">
+            <h1>🔧 Predictive Maintenance</h1>
+            <p>ML-Powered Equipment Failure Prediction & Diagnostics</p>
+        </div>
+
+        <div class="tabs">
+            <button class="tab-button active" onclick="switchTab('single')">
+                📊 Single Prediction
+            </button>
+            <button class="tab-button" onclick="switchTab('batch')">
+                📁 Batch Processing
+            </button>
+        </div>
+
+        <!-- SINGLE PREDICTION TAB -->
+        <div id="singleTab" class="tab-content active">
+            <h2 style="margin-bottom: 20px; color: #333;">🎯 Single Machine Prediction</h2>
+
+            <div class="preset-buttons">
+                <button class="preset-btn" onclick="loadPreset('healthy')">✅ Healthy Machine</button>
+                <button class="preset-btn" onclick="loadPreset('toolwear')">🔨 Tool Wear Critical</button>
+                <button class="preset-btn" onclick="loadPreset('overstrain')">⚡ Power Overstrain</button>
+                <button class="preset-btn" onclick="loadPreset('cooling')">❄️ Cooling Issue</button>
+            </div>
+
+            <form id="predictionForm" onsubmit="handleSinglePredict(event)">
+                <div class="form-grid">
+                    <div class="form-group">
+                        <label for="machine_id">
+                            Machine ID <span class="info-icon" title="Optional identifier">ℹ️</span>
+                        </label>
+                        <input type="text" id="machine_id" placeholder="e.g., M_L_01">
+                    </div>
+
+                    <div class="form-group">
+                        <label for="type">
+                            Machine Type <span class="info-icon" title="L=Low, M=Medium, H=High">ℹ️</span>
+                        </label>
+                        <select id="type" required>
+                            <option value="">Select Type</option>
+                            <option value="L">L - Low Quality</option>
+                            <option value="M">M - Medium Quality</option>
+                            <option value="H">H - High Quality</option>
+                        </select>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="air_temperature">
+                            Air Temperature (K) <span class="info-icon" title="Range: 250-350 K">ℹ️</span>
+                        </label>
+                        <input type="number" id="air_temperature" step="0.1" min="250" max="350" required
+                            placeholder="e.g., 298.1">
+                    </div>
+
+                    <div class="form-group">
+                        <label for="process_temperature">
+                            Process Temperature (K) <span class="info-icon" title="Range: 250-400 K">ℹ️</span>
+                        </label>
+                        <input type="number" id="process_temperature" step="0.1" min="250" max="400" required
+                            placeholder="e.g., 308.6">
+                    </div>
+
+                    <div class="form-group">
+                        <label for="rotational_speed">
+                            Rotational Speed (RPM) <span class="info-icon" title="Range: 0-3000 RPM">ℹ️</span>
+                        </label>
+                        <input type="number" id="rotational_speed" min="0" max="3000" required placeholder="e.g., 1551">
+                    </div>
+
+                    <div class="form-group">
+                        <label for="torque">
+                            Torque (Nm) <span class="info-icon" title="Range: 0-100 Nm">ℹ️</span>
+                        </label>
+                        <input type="number" id="torque" step="0.1" min="0" max="100" required placeholder="e.g., 42.8">
+                    </div>
+
+                    <div class="form-group">
+                        <label for="tool_wear">
+                            Tool Wear (min) <span class="info-icon" title="Range: 0-300 minutes">ℹ️</span>
+                        </label>
+                        <input type="number" id="tool_wear" min="0" max="300" required placeholder="e.g., 0">
+                    </div>
+                </div>
+
+                <div class="button-group">
+                    <button type="submit" class="btn-primary">🔍 Analyze & Predict</button>
+                    <button type="button" class="btn-secondary" onclick="resetForm()">🔄 Reset Form</button>
+                </div>
+            </form>
+
+            <div class="loading" id="loading">
+                <div class="spinner"></div>
+                <p>Analyzing machine data...</p>
+            </div>
+
+            <div id="result" class="result-container"></div>
+        </div>
+
+        <!-- BATCH PREDICTION TAB -->
+        <div id="batchTab" class="tab-content">
+            <h2 style="margin-bottom: 20px; color: #333;">📁 Batch Processing</h2>
+
+            <div class="upload-area" id="uploadArea" onclick="document.getElementById('csvFile').click()">
+                <div class="upload-icon">📤</div>
+                <h3>Click or Drag & Drop CSV File</h3>
+                <p style="margin-top: 10px; color: #666;">Upload a CSV file with machine data for batch prediction</p>
+                <input type="file" id="csvFile" accept=".csv" style="display: none;" onchange="handleFileSelect(event)">
+                <div id="fileName" class="file-name" style="display: none;"></div>
+            </div>
+
+            <div style="margin-top: 20px; padding: 20px; background: #f8f9ff; border-radius: 10px;">
+                <h4 style="margin-bottom: 10px;">📋 Required CSV Columns:</h4>
+                <ul style="list-style: none; padding-left: 0;">
+                    <li>✓ <code>air_temperature</code> - Air temperature in Kelvin</li>
+                    <li>✓ <code>process_temperature</code> - Process temperature in Kelvin</li>
+                    <li>✓ <code>rotational_speed</code> - Rotational speed in RPM</li>
+                    <li>✓ <code>torque</code> - Torque in Nm</li>
+                    <li>✓ <code>tool_wear</code> - Tool wear in minutes</li>
+                    <li>✓ <code>type</code> - Machine type (L, M, or H)</li>
+                    <li>⭕ <code>machine_id</code> - Optional machine identifier</li>
+                </ul>
+            </div>
+
+            <div class="button-group" style="margin-top: 20px;">
+                <button class="btn-primary" onclick="uploadBatch()" id="uploadBtn" disabled>📊 Process Batch</button>
+                <button class="btn-secondary" onclick="downloadTemplate()">⬇️ Download Template CSV</button>
+            </div>
+
+            <div class="loading" id="batchLoading">
+                <div class="spinner"></div>
+                <p>Processing batch predictions...</p>
+            </div>
+
+            <div id="batchResult" class="result-container"></div>
+        </div>
+    </div>
+
+    <script>
+        const API_URL = 'http://localhost:8000';
+        let selectedFile = null;
+
+        // Check API status on load
+        async function checkApiStatus() {
+            try {
+                const response = await fetch(`${API_URL}/health`);
+                const data = await response.json();
+                document.getElementById('statusDot').className = 'status-dot status-online';
+                document.getElementById('statusText').textContent = 'API Online';
+            } catch (error) {
+                document.getElementById('statusDot').className = 'status-dot status-offline';
+                document.getElementById('statusText').textContent = 'API Offline';
+            }
+        }
+
+        // Switch between tabs
+        function switchTab(tab) {
+            document.querySelectorAll('.tab-button').forEach(btn => btn.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+
+            if (tab === 'single') {
+                document.querySelector('.tab-button:nth-child(1)').classList.add('active');
+                document.getElementById('singleTab').classList.add('active');
+            } else {
+                document.querySelector('.tab-button:nth-child(2)').classList.add('active');
+                document.getElementById('batchTab').classList.add('active');
+            }
+        }
+
+        // Load preset values
+        function loadPreset(type) {
+            const presets = {
+                healthy: {
+                    machine_id: 'M_L_01',
+                    type: 'M',
+                    air_temperature: 298.1,
+                    process_temperature: 308.6,
+                    rotational_speed: 1551,
+                    torque: 42.8,
+                    tool_wear: 0
+                },
+                toolwear: {
+                    machine_id: 'M_H_03',
+                    type: 'H',
+                    air_temperature: 297.5,
+                    process_temperature: 312.8,
+                    rotational_speed: 1800,
+                    torque: 52.0,
+                    tool_wear: 220
+                },
+                overstrain: {
+                    machine_id: 'M_H_05',
+                    type: 'H',
+                    air_temperature: 298.5,
+                    process_temperature: 316.0,
+                    rotational_speed: 1900,
+                    torque: 72.5,
+                    tool_wear: 150
+                },
+                cooling: {
+                    machine_id: 'M_M_02',
+                    type: 'M',
+                    air_temperature: 299.8,
+                    process_temperature: 305.2,
+                    rotational_speed: 1650,
+                    torque: 45.0,
+                    tool_wear: 100
+                }
+            };
+
+            const preset = presets[type];
+            Object.keys(preset).forEach(key => {
+                const element = document.getElementById(key);
+                if (element) element.value = preset[key];
+            });
+        }
+
+        // Handle single prediction
+        async function handleSinglePredict(event) {
+            event.preventDefault();
+
+            const formData = {
+                machine_id: document.getElementById('machine_id').value || null,
+                type: document.getElementById('type').value,
+                air_temperature: parseFloat(document.getElementById('air_temperature').value),
+                process_temperature: parseFloat(document.getElementById('process_temperature').value),
+                rotational_speed: parseInt(document.getElementById('rotational_speed').value),
+                torque: parseFloat(document.getElementById('torque').value),
+                tool_wear: parseInt(document.getElementById('tool_wear').value)
+            };
+
+            document.getElementById('loading').classList.add('active');
+            document.getElementById('result').style.display = 'none';
+
+            try {
+                console.log('Sending request to API:', formData); // Debug log
+
+                const response = await fetch(`${API_URL}/predict`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(formData)
+                });
+
+                console.log('Response status:', response.status); // Debug log
+
+                const data = await response.json();
+                console.log('Response data:', data); // Debug log
+
+                if (!response.ok) {
+                    throw new Error(data.detail || 'Prediction failed');
+                }
+
+                displayResult(data);
+            } catch (error) {
+                console.error('Error during prediction:', error); // Debug log
+                displayError(error.message);
+            } finally {
+                document.getElementById('loading').classList.remove('active');
+            }
+        }
+
+        // Display prediction result
+        function displayResult(data) {
+            console.log('Displaying result:', data); // Debug log
+
+            const resultDiv = document.getElementById('result');
+            const isFailure = data.prediction === 'FAILURE';
+            const severityClass = `severity-${data.diagnostics.severity.toLowerCase()}`;
+
+            // Calculate probability/confidence percentage
+            const probability = (data.confidence * 100).toFixed(1);
+
+            resultDiv.className = 'result-container success';
+            resultDiv.style.display = 'block'; // FORCE DISPLAY
+            resultDiv.innerHTML = `
+                <h3 style="margin-bottom: 15px;">🔍 Prediction Result</h3>
+                
+                <!-- Prediction Badge and Confidence Bar -->
+                <div class="prediction-header">
+                    <span class="prediction-badge ${isFailure ? 'badge-failure' : 'badge-healthy'}">
+                        ${data.prediction}
+                    </span>
+                    <div class="confidence-bar">
+                        <div class="confidence-fill" style="width: ${probability}%">
+                            ${probability}% Confidence
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Severity and Risk Level -->
+                <div style="display: flex; gap: 10px; margin: 15px 0;">
+                    <span class="severity-badge ${severityClass}" style="font-size: 14px; padding: 8px 16px;">
+                        ${data.diagnostics.severity} SEVERITY
+                    </span>
+                </div>
+
+                <!-- Main Diagnostics Grid -->
+                <div class="diagnostics-grid">
+                    <div class="diagnostic-item">
+                        <div class="diagnostic-label">🎯 Primary Cause</div>
+                        <div class="diagnostic-value">${data.diagnostics.primary_cause}</div>
+                    </div>
+
+                    <div class="diagnostic-item">
+                        <div class="diagnostic-label">📊 Sensor Alert</div>
+                        <div class="diagnostic-value">${data.diagnostics.sensor_alert}</div>
+                    </div>
+
+                    <div class="diagnostic-item">
+                        <div class="diagnostic-label">🔧 Recommended Action</div>
+                        <div class="diagnostic-value">${data.diagnostics.recommended_action}</div>
+                    </div>
+
+                    ${data.machine_id ? `
+                    <div class="diagnostic-item">
+                        <div class="diagnostic-label">🏷️ Machine ID</div>
+                        <div class="diagnostic-value">${data.machine_id}</div>
+                    </div>
+                    ` : ''}
+
+                    <div class="diagnostic-item">
+                        <div class="diagnostic-label">⏰ Timestamp</div>
+                        <div class="diagnostic-value">${new Date(data.timestamp).toLocaleString()}</div>
+                    </div>
+                </div>
+
+                <!-- Engineered Features Section -->
+                ${data.features && Object.keys(data.features).length > 0 ? `
+                <div style="margin-top: 25px;">
+                    <h4 style="margin-bottom: 15px; color: #667eea;">📊 Engineered Features Analysis</h4>
+                    <div class="feature-grid" style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 12px;">
+                        ${Object.entries(data.features).map(([key, value]) => `
+                            <div class="feature-item" style="background: white; padding: 12px; border-radius: 8px; border-left: 3px solid #667eea;">
+                                <div class="feature-label" style="font-size: 11px; color: #6c757d; margin-bottom: 4px; text-transform: uppercase;">
+                                    ${key.replace(/_/g, ' ')}
+                                </div>
+                                <div class="feature-value" style="font-size: 16px; font-weight: 600; color: #333;">
+                                    ${typeof value === 'number' ? value.toFixed(2) : value}
+                                </div>
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+                ` : ''}
+
+                <!-- Anomaly Detection Section (if available) -->
+                ${data.anomalies && data.anomalies.length > 0 ? `
+                <div style="margin-top: 25px; padding: 20px; background: #f8f9fa; border-radius: 10px; border-left: 5px solid #667eea;">
+                    <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
+                        <h4 style="margin: 0; color: #667eea;">🔧 Parameter Anomaly Analysis</h4>
+                        <span style="color: #667eea; font-weight: 600; font-size: 14px;">
+                            ${data.anomalies.length} anomalies detected
+                        </span>
+                    </div>
+                    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 15px;">
+                        ${data.anomalies.map(anomaly => `
+                            <div style="background: white; padding: 15px; border-radius: 10px; border-left: 4px solid ${anomaly.status === 'CRITICAL' ? '#dc3545' : anomaly.status === 'WARNING' ? '#ffc107' : '#28a745'};">
+                                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
+                                    <strong style="font-size: 16px;">${anomaly.parameter}</strong>
+                                    <span style="font-size: 12px; padding: 4px 8px; border-radius: 10px; font-weight: 600; background: ${anomaly.status === 'CRITICAL' ? '#f8d7da' : anomaly.status === 'WARNING' ? '#fff3cd' : '#d4edda'}; color: ${anomaly.status === 'CRITICAL' ? '#721c24' : anomaly.status === 'WARNING' ? '#856404' : '#155724'};">
+                                        ${anomaly.status}
+                                    </span>
+                                </div>
+                                <div style="font-size: 18px; font-weight: 600; color: #333; margin: 5px 0;">
+                                    Current: ${anomaly.value}
+                                </div>
+                                <div style="font-size: 12px; color: #6c757d; margin: 5px 0;">
+                                    Normal range: ${anomaly.normal_range}
+                                </div>
+                                <div style="font-size: 13px; color: #495057; margin-top: 10px; padding: 8px; background: #f1f3f4; border-radius: 6px;">
+                                    ${anomaly.explanation}
+                                </div>
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+                ` : ''}
+
+                <!-- Overall Health Summary (if available) -->
+                ${data.overall_health ? `
+                <div style="margin-top: 20px; padding: 15px; border-radius: 10px; font-weight: 600; text-align: center; background: ${data.overall_health.includes('EXCELLENT') ? '#d4edda' : data.overall_health.includes('GOOD') ? '#d1ecf1' : data.overall_health.includes('FAIR') ? '#fff3cd' : '#f8d7da'}; color: ${data.overall_health.includes('EXCELLENT') ? '#155724' : data.overall_health.includes('GOOD') ? '#0c5460' : data.overall_health.includes('FAIR') ? '#856404' : '#721c24'}; border: 2px solid ${data.overall_health.includes('EXCELLENT') ? '#28a745' : data.overall_health.includes('GOOD') ? '#17a2b8' : data.overall_health.includes('FAIR') ? '#ffc107' : '#dc3545'};">
+                    🏥 ${data.overall_health}
+                </div>
+                ` : ''}
+            `;
+        }
+
+        // Display error
+        function displayError(message) {
+            console.error('Displaying error:', message); // Debug log
+
+            const resultDiv = document.getElementById('result');
+            resultDiv.className = 'result-container error';
+            resultDiv.style.display = 'block'; // FORCE DISPLAY
+            resultDiv.innerHTML = `
+                <h3 style="color: #ff4444; margin-bottom: 10px;">❌ Error</h3>
+                <p>${message}</p>
+            `;
+        }
+
+        // Reset form
+        function resetForm() {
+            document.getElementById('predictionForm').reset();
+            document.getElementById('result').style.display = 'none';
+        }
+
+        // File upload handlers
+        const uploadArea = document.getElementById('uploadArea');
+
+        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+            uploadArea.addEventListener(eventName, preventDefaults, false);
+        });
+
+        function preventDefaults(e) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+
+        ['dragenter', 'dragover'].forEach(eventName => {
+            uploadArea.addEventListener(eventName, () => {
+                uploadArea.classList.add('dragging');
+            }, false);
+        });
+
+        ['dragleave', 'drop'].forEach(eventName => {
+            uploadArea.addEventListener(eventName, () => {
+                uploadArea.classList.remove('dragging');
+            }, false);
+        });
+
+        uploadArea.addEventListener('drop', (e) => {
+            const files = e.dataTransfer.files;
+            if (files.length > 0) {
+                handleFile(files[0]);
+            }
+        }, false);
+
+        function handleFileSelect(event) {
+            const file = event.target.files[0];
+            if (file) {
+                handleFile(file);
+            }
+        }
+
+        function handleFile(file) {
+            if (!file.name.endsWith('.csv')) {
+                alert('Please upload a CSV file');
+                return;
+            }
+
+            selectedFile = file;
+            document.getElementById('fileName').style.display = 'block';
+            document.getElementById('fileName').textContent = `📄 ${file.name}`;
+            document.getElementById('uploadBtn').disabled = false;
+        }
+
+        // Upload batch
+        async function uploadBatch() {
+            if (!selectedFile) return;
+
+            const formData = new FormData();
+            formData.append('file', selectedFile);
+
+            document.getElementById('batchLoading').classList.add('active');
+            document.getElementById('batchResult').style.display = 'none';
+
+            try {
+                console.log('Uploading batch file:', selectedFile.name);
+
+                const response = await fetch(`${API_URL}/predict/batch/json`, {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(error.detail || 'Batch processing failed');
+                }
+
+                const data = await response.json();
+                console.log('Batch response:', data);
+
+                displayBatchResults(data);
+
+            } catch (error) {
+                console.error('Batch processing error:', error);
+                const resultDiv = document.getElementById('batchResult');
+                resultDiv.className = 'result-container error';
+                resultDiv.style.display = 'block';
+                resultDiv.innerHTML = `
+                    <h3 style="color: #ff4444; margin-bottom: 10px;">❌ Batch Processing Error</h3>
+                    <p>${error.message}</p>
+                    <p style="margin-top: 10px; font-size: 0.9em; color: #666;">
+                        Make sure your CSV has the required columns: air_temperature, process_temperature, 
+                        rotational_speed, torque, tool_wear, type
+                    </p>
+                `;
+            } finally {
+                document.getElementById('batchLoading').classList.remove('active');
+            }
+        }
+
+        // Display batch results
+        function displayBatchResults(data) {
+            const resultDiv = document.getElementById('batchResult');
+            resultDiv.className = 'result-container success';
+            resultDiv.style.display = 'block';
+
+            const summary = data.summary;
+            const results = data.results;
+
+            let html = `
+                <h3 style="margin-bottom: 20px;">📊 Batch Processing Results</h3>
+                
+                <!-- Summary Statistics -->
+                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 15px; margin-bottom: 25px;">
+                    <div style="background: white; padding: 20px; border-radius: 10px; text-align: center; border-left: 4px solid #667eea;">
+                        <div style="font-size: 32px; font-weight: 700; color: #667eea;">${summary.total_records}</div>
+                        <div style="font-size: 14px; color: #666; margin-top: 5px;">Total Records</div>
+                    </div>
+                    <div style="background: white; padding: 20px; border-radius: 10px; text-align: center; border-left: 4px solid #4caf50;">
+                        <div style="font-size: 32px; font-weight: 700; color: #4caf50;">${summary.predictions.healthy}</div>
+                        <div style="font-size: 14px; color: #666; margin-top: 5px;">Healthy</div>
+                    </div>
+                    <div style="background: white; padding: 20px; border-radius: 10px; text-align: center; border-left: 4px solid #ff4444;">
+                        <div style="font-size: 32px; font-weight: 700; color: #ff4444;">${summary.predictions.failure}</div>
+                        <div style="font-size: 14px; color: #666; margin-top: 5px;">Failures</div>
+                    </div>
+                    <div style="background: white; padding: 20px; border-radius: 10px; text-align: center; border-left: 4px solid #ff9800;">
+                        <div style="font-size: 32px; font-weight: 700; color: #ff9800;">${summary.failure_rate}%</div>
+                        <div style="font-size: 14px; color: #666; margin-top: 5px;">Failure Rate</div>
+                    </div>
+                </div>
+
+                <!-- Individual Results -->
+                <h4 style="margin: 25px 0 15px 0; color: #333;">🔍 Detailed Analysis</h4>
+                <div style="display: flex; flex-direction: column; gap: 20px;">
+            `;
+
+            // Display each result
+            results.forEach((result, index) => {
+                const isFailure = result.prediction === 'FAILURE';
+                const severityClass = result.diagnostics ? `severity-${result.diagnostics.severity.toLowerCase()}` : '';
+                const probability = (result.confidence * 100).toFixed(1);
+
+                html += `
+                    <div style="background: white; padding: 20px; border-radius: 10px; border-left: 5px solid ${isFailure ? '#ff4444' : '#4caf50'};">
+                        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px; padding-bottom: 15px; border-bottom: 2px solid #e0e0e0;">
+                            <div style="display: flex; align-items: center; gap: 15px;">
+                                <span style="font-size: 14px; font-weight: 600; color: #666;">Row ${result.row_number}</span>
+                                <span style="font-size: 14px; font-weight: 600; color: #667eea;">${result.machine_id}</span>
+                                <span class="prediction-badge ${isFailure ? 'badge-failure' : 'badge-healthy'}" style="font-size: 14px; padding: 6px 14px;">
+                                    ${result.prediction}
+                                </span>
+                                ${result.diagnostics ? `
+                                <span class="severity-badge ${severityClass}" style="font-size: 12px; padding: 4px 10px;">
+                                    ${result.diagnostics.severity}
+                                </span>
+                                ` : ''}
+                            </div>
+                            <div style="background: #e0e0e0; height: 20px; width: 120px; border-radius: 10px; overflow: hidden;">
+                                <div style="height: 100%; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); width: ${probability}%; display: flex; align-items: center; justify-content: center; font-size: 11px; color: white; font-weight: 600;">
+                                    ${probability}%
+                                </div>
+                            </div>
+                        </div>
+
+                        ${result.diagnostics ? `
+                        <div style="display: grid; grid-template-columns: 1fr 2fr; gap: 15px; margin-bottom: 15px;">
+                            <div style="padding: 12px; background: #f8f9fa; border-radius: 8px;">
+                                <div style="font-size: 11px; color: #667eea; font-weight: 600; margin-bottom: 5px; text-transform: uppercase;">🎯 Primary Cause</div>
+                                <div style="font-size: 13px; color: #333;">${result.diagnostics.primary_cause}</div>
+                            </div>
+                            <div style="padding: 12px; background: #f8f9fa; border-radius: 8px;">
+                                <div style="font-size: 11px; color: #667eea; font-weight: 600; margin-bottom: 5px; text-transform: uppercase;">🔧 Recommended Action</div>
+                                <div style="font-size: 13px; color: #333;">${result.diagnostics.recommended_action}</div>
+                            </div>
+                        </div>
+                        ` : ''}
+
+                        ${result.anomalies && result.anomalies.length > 0 ? `
+                        <div style="margin-top: 15px; padding: 15px; background: #f8f9fa; border-radius: 8px;">
+                            <div style="font-size: 12px; color: #667eea; font-weight: 600; margin-bottom: 10px;">
+                                ⚠️ ${result.anomalies.length} Anomalies Detected
+                            </div>
+                            <div style="display: flex; flex-wrap: wrap; gap: 10px;">
+                                ${result.anomalies.map(anomaly => `
+                                    <span style="font-size: 11px; padding: 4px 8px; border-radius: 12px; background: ${anomaly.status === 'CRITICAL' ? '#f8d7da' : anomaly.status === 'WARNING' ? '#fff3cd' : '#d4edda'}; color: ${anomaly.status === 'CRITICAL' ? '#721c24' : anomaly.status === 'WARNING' ? '#856404' : '#155724'};">
+                                        ${anomaly.parameter}
+                                    </span>
+                                `).join('')}
+                            </div>
+                        </div>
+                        ` : ''}
+
+                        ${result.overall_health ? `
+                        <div style="margin-top: 15px; padding: 10px; border-radius: 8px; text-align: center; font-size: 13px; font-weight: 600; background: ${result.overall_health.includes('EXCELLENT') ? '#d4edda' : result.overall_health.includes('GOOD') ? '#d1ecf1' : result.overall_health.includes('FAIR') ? '#fff3cd' : '#f8d7da'}; color: ${result.overall_health.includes('EXCELLENT') ? '#155724' : result.overall_health.includes('GOOD') ? '#0c5460' : result.overall_health.includes('FAIR') ? '#856404' : '#721c24'};">
+                            ${result.overall_health}
+                        </div>
+                        ` : ''}
+
+                        ${result.error ? `
+                        <div style="margin-top: 10px; padding: 10px; background: #fff0f0; border-radius: 8px; color: #ff4444; font-size: 13px;">
+                            <strong>Error:</strong> ${result.error}
+                        </div>
+                        ` : ''}
+                    </div>
+                `;
+            });
+
+            html += `
+                </div>
+
+                <!-- Download CSV Button -->
+                <div style="margin-top: 25px; text-align: center;">
+                    <button onclick="downloadBatchCSV()" class="btn-secondary" style="padding: 12px 24px;">
+                        ⬇️ Download Results as CSV
+                    </button>
+                </div>
+            `;
+
+            resultDiv.innerHTML = html;
+        }
+
+        // Download batch results as CSV
+        async function downloadBatchCSV() {
+            if (!selectedFile) return;
+
+            try {
+                const formData = new FormData();
+                formData.append('file', selectedFile);
+
+                const response = await fetch(`${API_URL}/predict/batch`, {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    throw new Error('CSV download failed');
+                }
+
+                // Download the result CSV
+                const blob = await response.blob();
+                const url = window.URL.createObjectURL(blob);
+                const a = document.createElement('a');
+                a.href = url;
+                a.download = `predictions_${new Date().getTime()}.csv`;
+                document.body.appendChild(a);
+                a.click();
+                window.URL.revokeObjectURL(url);
+                document.body.removeChild(a);
+            } catch (error) {
+                alert('Failed to download CSV: ' + error.message);
+            }
+        }
+
+        // Download template CSV
+        function downloadTemplate() {
+            const template = `machine_id,air_temperature,process_temperature,rotational_speed,torque,tool_wear,type
+M_L_01,298.1,308.6,1551,42.8,0,M
+M_L_02,299.2,310.1,1450,38.5,150,L
+M_H_01,297.5,312.8,1800,65.2,220,H`;
+
+            const blob = new Blob([template], { type: 'text/csv' });
+            const url = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = 'template.csv';
+            document.body.appendChild(a);
+            a.click();
+            window.URL.revokeObjectURL(url);
+            document.body.removeChild(a);
+        }
+
+        // Initialize
+        checkApiStatus();
+        setInterval(checkApiStatus, 10000); // Check every 10 seconds
+    </script>
+</body>
+
+</html>

api/install_requirements.bat

@@ -0,0 +1,50 @@
+@echo off
+echo ========================================
+echo   Installing Requirements
+echo ========================================
+echo.
+
+REM Check if Python is installed
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python is not installed or not in PATH
+    echo Please install Python 3.11+ from https://www.python.org/
+    pause
+    exit /b 1
+)
+
+echo Python version:
+python --version
+echo.
+
+REM Check if pip is available
+python -m pip --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: pip is not available
+    echo Installing pip...
+    python -m ensurepip --default-pip
+)
+
+echo.
+echo Installing packages from requirements.txt...
+echo.
+
+python -m pip install -r requirements.txt
+
+if errorlevel 1 (
+    echo.
+    echo ERROR: Failed to install some packages
+    echo Please check the error messages above
+    pause
+    exit /b 1
+)
+
+echo.
+echo ========================================
+echo   Installation Complete!
+echo ========================================
+echo.
+echo All packages have been installed successfully.
+echo You can now run: start_server.bat
+echo.
+pause

api/main.py

@@ -0,0 +1,886 @@
+"""
+FastAPI Predictive Maintenance API with Rule-Based Diagnostics
+Senior Backend Engineer & Reliability Engineer Implementation
+
+Features:
+- ML-based failure prediction using XGBoost
+- Physics-based diagnostic engine
+- Single prediction and batch processing endpoints
+- Production-ready with proper error handling
+"""
+
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field, validator
+from typing import Optional, Dict, Any, List
+import joblib
+import numpy as np
+import pandas as pd
+from datetime import datetime
+from pathlib import Path
+import os
+import io
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI
+app = FastAPI(
+    title="Predictive Maintenance API",
+    description="ML + Rule-Based Diagnostics for Industrial Equipment",
+    version="1.0.0"
+)
+
+# CORS Configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+from huggingface_hub import hf_hub_download
+
+# Global model pipeline
+MODEL_PIPELINE = None
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "deropxyz/AC02-ML")
+PRIMARY_MODEL_FILENAME = os.getenv("HF_PRIMARY_MODEL", "model_pipeline_improved.joblib")
+FALLBACK_MODEL_FILENAME = os.getenv("HF_FALLBACK_MODEL", "model_pipeline.joblib")
+HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+
+
+def download_model_artifact(filename: str) -> Path:
+    """
+    Download a model artifact from Hugging Face Hub and return the local cache path.
+    """
+    if not filename:
+        raise ValueError("Filename must be provided for model download")
+
+    logger.info("Downloading model '%s' from repo '%s'...", filename, HF_MODEL_REPO)
+    cache_path = hf_hub_download(
+        repo_id=HF_MODEL_REPO,
+        filename=filename,
+        repo_type="model",
+        token=HF_TOKEN,
+    )
+    return Path(cache_path)
+
+
+# ============================================================================
+# REQUEST/RESPONSE SCHEMAS
+# ============================================================================
+
+class PredictionRequest(BaseModel):
+    """Single prediction request schema matching dataset columns"""
+    machine_id: Optional[str] = Field(None, description="Machine identifier (e.g., M_L_01)")
+    air_temperature: float = Field(..., ge=250, le=350, description="Air temperature in Kelvin")
+    process_temperature: float = Field(..., ge=250, le=400, description="Process temperature in Kelvin")
+    rotational_speed: int = Field(..., ge=0, le=3000, description="Rotational speed in RPM")
+    torque: float = Field(..., ge=0, le=100, description="Torque in Nm")
+    tool_wear: int = Field(..., ge=0, le=300, description="Tool wear in minutes")
+    type: str = Field(..., description="Machine type: L (Low), M (Medium), H (High)")
+    
+    @validator('type')
+    def validate_type(cls, v):
+        if v not in ['L', 'M', 'H']:
+            raise ValueError('Type must be L, M, or H')
+        return v
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "machine_id": "M_L_01",
+                "air_temperature": 298.1,
+                "process_temperature": 308.6,
+                "rotational_speed": 1551,
+                "torque": 42.8,
+                "tool_wear": 0,
+                "type": "M"
+            }
+        }
+
+
+class DiagnosticResult(BaseModel):
+    """Diagnostic analysis result"""
+    primary_cause: str
+    sensor_alert: str
+    recommended_action: str
+    severity: str  # LOW, MEDIUM, HIGH, CRITICAL
+
+
+class AnomalyDetail(BaseModel):
+    """Anomaly detection detail"""
+    parameter: str
+    value: str
+    normal_range: str
+    status: str  # NORMAL, WARNING, CRITICAL
+    explanation: str
+
+
+class PredictionResponse(BaseModel):
+    """Single prediction response"""
+    machine_id: Optional[str]
+    timestamp: str
+    prediction: str  # HEALTHY or FAILURE
+    confidence: float
+    diagnostics: DiagnosticResult
+    features: Optional[Dict[str, Any]] = None  # Engineered features
+    anomalies: Optional[List[AnomalyDetail]] = None  # Parameter anomaly analysis
+    overall_health: Optional[str] = None  # Overall health status
+
+
+# ============================================================================
+# STARTUP EVENT: LOAD MODEL
+# ============================================================================
+
+@app.on_event("startup")
+async def load_model():
+    """Download and load model pipeline on startup"""
+    global MODEL_PIPELINE
+
+    last_error: Optional[Exception] = None
+    for candidate in [PRIMARY_MODEL_FILENAME, FALLBACK_MODEL_FILENAME]:
+        if not candidate:
+            continue
+        try:
+            model_path = download_model_artifact(candidate)
+            MODEL_PIPELINE = joblib.load(model_path)
+            logger.info("✅ Model loaded from %s", candidate)
+            break
+        except Exception as err:
+            last_error = err
+            logger.error("Failed to load model '%s': %s", candidate, err)
+
+    if MODEL_PIPELINE is None:
+        raise RuntimeError(f"Unable to load any model artifact: {last_error}") from last_error
+
+    # Validate model structure
+    required_keys = ['model', 'scaler', 'features']
+    for key in required_keys:
+        if key not in MODEL_PIPELINE:
+            raise ValueError(f"Model pipeline missing key: {key}")
+
+    logger.info("Model type: %s", type(MODEL_PIPELINE['model']).__name__)
+    logger.info("Features: %s", MODEL_PIPELINE['features'])
+
+
+# ============================================================================
+# FEATURE ENGINEERING (Must match training logic)
+# ============================================================================
+
+def engineer_features(data: Dict[str, Any]) -> pd.DataFrame:
+    """
+    Apply physics-based feature engineering matching training pipeline
+    
+    Features:
+    - Temperature_Diff: Thermal stress indicator
+    - Power_W: Mechanical power (P = τω)
+    - Type_Encoded: Categorical encoding
+    - Tool_wear_hours: Tool wear converted to hours
+    """
+    # Create base dataframe
+    df = pd.DataFrame([{
+        'Air_temp_K': data['air_temperature'],
+        'Process_temp_K': data['process_temperature'],
+        'Speed_rpm': data['rotational_speed'],
+        'Torque_Nm': data['torque'],
+        'Tool_wear_min': data['tool_wear']
+    }])
+    
+    # Physics-based features
+    df['Tool_wear_hours'] = df['Tool_wear_min'] / 60.0  # Convert minutes to hours
+    df['Temperature_Diff'] = df['Process_temp_K'] - df['Air_temp_K']
+    df['Power_W'] = df['Torque_Nm'] * df['Speed_rpm'] * (2 * np.pi / 60)
+    
+    # Type encoding
+    type_mapping = {'L': 0, 'M': 1, 'H': 2}
+    df['Type_Encoded'] = type_mapping[data['type']]
+    
+    # Ensure correct feature order matching training
+    feature_cols = MODEL_PIPELINE['features']
+    return df[feature_cols]
+
+
+# ============================================================================
+# DIAGNOSTIC ENGINE (Rule-Based Intelligence)
+# ============================================================================
+
+def analyze_condition(
+    data: Dict[str, Any],
+    pred_class: int,
+    pred_proba: float,
+    engineered_features: pd.DataFrame
+) -> DiagnosticResult:
+    """
+    Advanced diagnostic engine combining ML predictions with physics-based rules
+    
+    Priority Rules:
+    1. Tool Wear Failure (CRITICAL)
+    2. Power Overstrain (HIGH)
+    3. Heat Dissipation Issue (MEDIUM)
+    4. ML Anomaly Detection (VARIABLE)
+    5. Healthy Operation (LOW)
+    """
+    
+    # Extract values for rule evaluation
+    temp_diff = engineered_features['Temperature_Diff'].iloc[0]
+    power_w = engineered_features['Power_W'].iloc[0]
+    torque = data['torque']
+    tool_wear = data['tool_wear']
+    speed = data['rotational_speed']
+    air_temp = data['air_temperature']
+    process_temp = data['process_temperature']
+    
+    # ========================================================================
+    # RULE 1: TOOL WEAR FAILURE (CRITICAL PRIORITY)
+    # ========================================================================
+    if tool_wear > 200:
+        return DiagnosticResult(
+            primary_cause="Tool End of Life",
+            sensor_alert=f"Tool wear ({tool_wear} min) exceeds safety threshold (200 min)",
+            recommended_action="IMMEDIATE ACTION: Replace cutting tool before catastrophic failure. "
+                             "Schedule downtime within 4 hours.",
+            severity="CRITICAL"
+        )
+    
+    # ========================================================================
+    # RULE 2: POWER OVERSTRAIN (HIGH PRIORITY)
+    # ========================================================================
+    if power_w > 9000 or torque > 60:
+        cause_details = []
+        if power_w > 9000:
+            cause_details.append(f"Power output ({power_w:.0f} W) exceeds design limit (9000 W)")
+        if torque > 60:
+            cause_details.append(f"Torque ({torque:.1f} Nm) exceeds safety limit (60 Nm)")
+        
+        return DiagnosticResult(
+            primary_cause="Power Overstrain / Mechanical Overload",
+            sensor_alert=" | ".join(cause_details),
+            recommended_action="URGENT: Reduce operational load immediately. "
+                             "Inspect shaft alignment, bearing condition, and drive belt tension. "
+                             "Check for material jamming or obstruction.",
+            severity="HIGH"
+        )
+    
+    # ========================================================================
+    # RULE 3: HEAT DISSIPATION ISSUE (MEDIUM PRIORITY)
+    # ========================================================================
+    if temp_diff < 8.0 and speed > 1300:
+        return DiagnosticResult(
+            primary_cause="Inefficient Cooling System",
+            sensor_alert=f"Temperature differential ({temp_diff:.1f} K) too low at high speed ({speed} RPM). "
+                        f"Expected ≥8.0 K for proper heat dissipation.",
+            recommended_action="MAINTENANCE REQUIRED: Inspect cooling system within 24 hours. "
+                             "Check heat exchanger efficiency, coolant flow rate, and radiator fins. "
+                             "Verify coolant temperature and pressure.",
+            severity="MEDIUM"
+        )
+    
+    # ========================================================================
+    # RULE 4: THERMAL STRESS (MEDIUM PRIORITY)
+    # ========================================================================
+    if temp_diff > 15.0:
+        return DiagnosticResult(
+            primary_cause="Excessive Thermal Stress",
+            sensor_alert=f"Temperature differential ({temp_diff:.1f} K) exceeds normal range (8-12 K). "
+                        f"Process temp: {process_temp:.1f} K, Air temp: {air_temp:.1f} K",
+            recommended_action="MONITOR CLOSELY: High thermal gradient detected. "
+                             "Check process parameters and reduce processing intensity if possible. "
+                             "Verify insulation integrity and ambient conditions.",
+            severity="MEDIUM"
+        )
+    
+    # ========================================================================
+    # RULE 5: HIGH-SPEED OPERATION RISK (MEDIUM PRIORITY)
+    # ========================================================================
+    if speed > 2500:
+        return DiagnosticResult(
+            primary_cause="High-Speed Operation Risk",
+            sensor_alert=f"Rotational speed ({speed} RPM) in critical range (>2500 RPM). "
+                        f"Vibration and wear accelerate exponentially.",
+            recommended_action="PREVENTIVE ACTION: Monitor vibration levels closely. "
+                             "Perform balance check and bearing inspection. "
+                             "Consider reducing speed if not operationally critical.",
+            severity="MEDIUM"
+        )
+    
+    # ========================================================================
+    # RULE 6: ML DETECTED ANOMALY (VARIABLE PRIORITY)
+    # ========================================================================
+    if pred_class == 1:
+        # ML model detected failure but no specific rule matched
+        confidence_level = "high" if pred_proba > 0.8 else "moderate"
+        
+        return DiagnosticResult(
+            primary_cause="ML-Detected Anomaly Pattern",
+            sensor_alert=f"Machine learning model detected failure risk with {confidence_level} confidence ({pred_proba:.1%}). "
+                        f"No specific rule violation identified.",
+            recommended_action="DIAGNOSTIC SCAN REQUIRED: Perform comprehensive machine diagnostic. "
+                             "Check for: (1) Unusual vibration patterns, (2) Bearing wear, "
+                             "(3) Lubrication quality, (4) Electrical anomalies, (5) Sensor calibration. "
+                             "Review recent maintenance history.",
+            severity="HIGH" if pred_proba > 0.8 else "MEDIUM"
+        )
+    
+    # ========================================================================
+    # RULE 7: HEALTHY OPERATION (LOW PRIORITY)
+    # ========================================================================
+    # Calculate health score
+    health_indicators = {
+        'tool_wear_ok': tool_wear <= 150,
+        'power_ok': power_w <= 8000,
+        'temp_ok': 8.0 <= temp_diff <= 12.0,
+        'speed_ok': speed <= 2000,
+        'torque_ok': torque <= 50
+    }
+    health_score = sum(health_indicators.values()) / len(health_indicators) * 100
+    
+    return DiagnosticResult(
+        primary_cause="Normal Operation",
+        sensor_alert=f"All parameters within optimal range. Health score: {health_score:.0f}%. "
+                    f"Tool wear: {tool_wear}/200 min, Power: {power_w:.0f}/9000 W, "
+                    f"Temp diff: {temp_diff:.1f} K, Speed: {speed}/2500 RPM",
+        recommended_action="CONTINUE NORMAL OPERATION. Next scheduled maintenance as planned. "
+                         "Continue routine monitoring.",
+        severity="LOW"
+    )
+
+
+# ============================================================================
+# ANOMALY DETECTION & HEALTH ASSESSMENT
+# ============================================================================
+
+def detect_anomalies(data: Dict[str, Any], features_df: pd.DataFrame) -> List[AnomalyDetail]:
+    """
+    Detect anomalies in sensor readings and engineered features
+    Returns list of anomaly details for visualization
+    """
+    anomalies = []
+    
+    # Extract values
+    air_temp = data['air_temperature']
+    process_temp = data['process_temperature']
+    speed = data['rotational_speed']
+    torque = data['torque']
+    tool_wear = data['tool_wear']
+    temp_diff = features_df['Temperature_Diff'].iloc[0]
+    power_w = features_df['Power_W'].iloc[0]
+    
+    # Define normal ranges and check each parameter
+    
+    # 1. Air Temperature
+    if air_temp < 290 or air_temp > 310:
+        status = "CRITICAL" if air_temp < 285 or air_temp > 315 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Air Temperature",
+            value=f"{air_temp:.1f} K",
+            normal_range="290-310 K",
+            status=status,
+            explanation=f"Air temperature is {'too low' if air_temp < 290 else 'too high'}. This can affect cooling efficiency and equipment performance."
+        ))
+    
+    # 2. Process Temperature
+    if process_temp < 300 or process_temp > 315:
+        status = "CRITICAL" if process_temp < 295 or process_temp > 320 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Process Temperature",
+            value=f"{process_temp:.1f} K",
+            normal_range="300-315 K",
+            status=status,
+            explanation=f"Process temperature is {'below optimal' if process_temp < 300 else 'exceeding optimal'} range. May indicate cooling system issues or excessive load."
+        ))
+    
+    # 3. Temperature Differential
+    if temp_diff < 8.0 or temp_diff > 12.0:
+        status = "CRITICAL" if temp_diff < 5.0 or temp_diff > 15.0 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Temperature Differential",
+            value=f"{temp_diff:.1f} K",
+            normal_range="8.0-12.0 K",
+            status=status,
+            explanation=f"Temperature gradient is {'insufficient' if temp_diff < 8.0 else 'excessive'}. This indicates {'poor heat dissipation' if temp_diff < 8.0 else 'thermal stress'}."
+        ))
+    
+    # 4. Rotational Speed
+    if speed < 1200 or speed > 2000:
+        status = "CRITICAL" if speed < 1000 or speed > 2500 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Rotational Speed",
+            value=f"{speed} RPM",
+            normal_range="1200-2000 RPM",
+            status=status,
+            explanation=f"Speed is {'below normal' if speed < 1200 else 'above normal'} operating range. This affects wear rate and vibration levels."
+        ))
+    
+    # 5. Torque
+    if torque > 50:
+        status = "CRITICAL" if torque > 60 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Torque",
+            value=f"{torque:.1f} Nm",
+            normal_range="20-50 Nm",
+            status=status,
+            explanation=f"Torque is {'significantly ' if torque > 60 else ''}exceeding normal range. This indicates mechanical overload or obstruction."
+        ))
+    
+    # 6. Tool Wear
+    if tool_wear > 150:
+        status = "CRITICAL" if tool_wear > 200 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Tool Wear",
+            value=f"{tool_wear} min",
+            normal_range="0-150 min",
+            status=status,
+            explanation=f"Tool wear is {'critically high' if tool_wear > 200 else 'elevated'}. {'IMMEDIATE replacement required' if tool_wear > 200 else 'Schedule replacement soon'}."
+        ))
+    
+    # 7. Power Output
+    if power_w > 8000:
+        status = "CRITICAL" if power_w > 9000 else "WARNING"
+        anomalies.append(AnomalyDetail(
+            parameter="Power Output",
+            value=f"{power_w:.0f} W",
+            normal_range="3000-8000 W",
+            status=status,
+            explanation=f"Power consumption is {'critically ' if power_w > 9000 else ''}high. This suggests mechanical resistance or overload conditions."
+        ))
+    
+    return anomalies
+
+
+def determine_overall_health(prediction: int, confidence: float, severity: str, anomaly_count: int) -> str:
+    """
+    Determine overall machine health status based on multiple factors
+    Returns: EXCELLENT, GOOD, FAIR, or POOR health status
+    """
+    if prediction == 1:
+        # Failure predicted
+        if severity == "CRITICAL" or confidence > 0.9:
+            return "🔴 POOR HEALTH - Critical failure risk detected. Immediate action required."
+        elif severity == "HIGH" or confidence > 0.75:
+            return "🟠 POOR HEALTH - High failure risk. Urgent maintenance needed."
+        else:
+            return "🟡 FAIR HEALTH - Moderate failure risk detected. Schedule maintenance soon."
+    else:
+        # No failure predicted
+        if anomaly_count == 0:
+            return "🟢 EXCELLENT HEALTH - All systems operating optimally within normal parameters."
+        elif anomaly_count <= 2:
+            return "🟢 GOOD HEALTH - Minor anomalies detected but within acceptable limits."
+        else:
+            return "🟡 FAIR HEALTH - Multiple anomalies detected. Monitor closely and address issues."
+
+
+# ============================================================================
+# ENDPOINT 1: SINGLE PREDICTION
+# ============================================================================
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_single(request: PredictionRequest):
+    """
+    Predict failure risk for a single machine reading
+    
+    Returns:
+    - Prediction (HEALTHY/FAILURE)
+    - Confidence score
+    - Detailed diagnostics with actionable recommendations
+    """
+    try:
+        # Convert request to dict
+        data = request.dict()
+        
+        # Feature engineering
+        features_df = engineer_features(data)
+        
+        # Scale features
+        features_scaled = MODEL_PIPELINE['scaler'].transform(features_df)
+        
+        # Predict
+        prediction = MODEL_PIPELINE['model'].predict(features_scaled)[0]
+        prediction_proba = MODEL_PIPELINE['model'].predict_proba(features_scaled)[0]
+        
+        # Get confidence (probability of predicted class)
+        confidence = float(prediction_proba[prediction])
+        
+        # Run diagnostic engine
+        diagnostics = analyze_condition(data, prediction, confidence, features_df)
+        
+        # Prepare features dict for display
+        features_dict = features_df.iloc[0].to_dict()
+        
+        # Detect anomalies
+        anomalies = detect_anomalies(data, features_df)
+        
+        # Determine overall health
+        overall_health = determine_overall_health(prediction, confidence, diagnostics.severity, len(anomalies))
+        
+        # Format response
+        return PredictionResponse(
+            machine_id=request.machine_id,
+            timestamp=datetime.now().isoformat(),
+            prediction="FAILURE" if prediction == 1 else "HEALTHY",
+            confidence=round(confidence, 4),
+            diagnostics=diagnostics,
+            features=features_dict,
+            anomalies=anomalies,
+            overall_health=overall_health
+        )
+        
+    except Exception as e:
+        logger.error(f"Prediction error: {e}")
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+
+# ============================================================================
+# ENDPOINT 2: BATCH PREDICTION (CSV UPLOAD)
+# ============================================================================
+
+@app.post("/predict/batch")
+async def predict_batch(file: UploadFile = File(...)):
+    """
+    Batch prediction from CSV upload
+    
+    Input: CSV file with columns matching PredictionRequest
+    Output: CSV with added columns: Prediction, Probability, Primary_Cause, 
+            Sensor_Alert, Recommended_Action, Severity
+    """
+    try:
+        # Validate file type
+        if not file.filename.endswith('.csv'):
+            raise HTTPException(status_code=400, detail="File must be CSV format")
+        
+        # Read CSV
+        contents = await file.read()
+        df = pd.read_csv(io.StringIO(contents.decode('utf-8')))
+        
+        # Normalize column names (handle case-insensitive, spaces, brackets, etc)
+        df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_').str.replace('[', '_').str.replace(']', '').str.replace('__', '_').str.rstrip('_')
+        
+        # Create column mapping for different formats
+        column_mapping = {
+            'air_temperature_k': 'air_temperature',
+            'process_temperature_k': 'process_temperature',
+            'rotational_speed_rpm': 'rotational_speed',
+            'torque_nm': 'torque',
+            'tool_wear_min': 'tool_wear'
+        }
+        
+        # Apply mapping if columns have units
+        df.rename(columns=column_mapping, inplace=True)
+        
+        # Validate required columns
+        required_columns = [
+            'air_temperature', 'process_temperature', 'rotational_speed',
+            'torque', 'tool_wear', 'type'
+        ]
+        missing_cols = [col for col in required_columns if col not in df.columns]
+        if missing_cols:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Missing required columns: {missing_cols}. Found columns: {list(df.columns)}"
+            )
+        
+        # Initialize result columns
+        predictions = []
+        probabilities = []
+        causes = []
+        alerts = []
+        actions = []
+        severities = []
+        
+        # Process each row
+        for idx, row in df.iterrows():
+            try:
+                # Prepare data
+                data = {
+                    'machine_id': row.get('machine_id', f'MACHINE_{idx}'),
+                    'air_temperature': float(row['air_temperature']),
+                    'process_temperature': float(row['process_temperature']),
+                    'rotational_speed': int(row['rotational_speed']),
+                    'torque': float(row['torque']),
+                    'tool_wear': int(row['tool_wear']),
+                    'type': str(row['type'])
+                }
+                
+                # Feature engineering
+                features_df = engineer_features(data)
+                
+                # Scale and predict
+                features_scaled = MODEL_PIPELINE['scaler'].transform(features_df)
+                prediction = MODEL_PIPELINE['model'].predict(features_scaled)[0]
+                prediction_proba = MODEL_PIPELINE['model'].predict_proba(features_scaled)[0]
+                confidence = float(prediction_proba[prediction])
+                
+                # Diagnostics
+                diagnostics = analyze_condition(data, prediction, confidence, features_df)
+                
+                # Append results
+                predictions.append("FAILURE" if prediction == 1 else "HEALTHY")
+                probabilities.append(round(confidence, 4))
+                causes.append(diagnostics.primary_cause)
+                alerts.append(diagnostics.sensor_alert)
+                actions.append(diagnostics.recommended_action)
+                severities.append(diagnostics.severity)
+                
+            except Exception as e:
+                logger.warning(f"Row {idx} processing error: {e}")
+                predictions.append("ERROR")
+                probabilities.append(0.0)
+                causes.append("Processing Error")
+                alerts.append(str(e))
+                actions.append("Review input data")
+                severities.append("UNKNOWN")
+        
+        # Add results to dataframe
+        df['Prediction'] = predictions
+        df['Confidence'] = probabilities
+        df['Primary_Cause'] = causes
+        df['Sensor_Alert'] = alerts
+        df['Recommended_Action'] = actions
+        df['Severity'] = severities
+        df['Processed_At'] = datetime.now().isoformat()
+        
+        # Convert to CSV
+        output = io.StringIO()
+        df.to_csv(output, index=False)
+        output.seek(0)
+        
+        # Return as downloadable file
+        return StreamingResponse(
+            iter([output.getvalue()]),
+            media_type="text/csv",
+            headers={
+                "Content-Disposition": f"attachment; filename=predictions_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Batch prediction error: {e}")
+        raise HTTPException(status_code=500, detail=f"Batch prediction failed: {str(e)}")
+
+
+# ============================================================================
+# ENDPOINT 3: BATCH PREDICTION JSON (For UI Display)
+# ============================================================================
+
+@app.post("/predict/batch/json")
+async def predict_batch_json(file: UploadFile = File(...)):
+    """
+    Batch prediction from CSV upload - returns detailed JSON for UI display
+    
+    Input: CSV file with required columns
+    Output: JSON with detailed predictions, features, and anomalies for each row
+    """
+    try:
+        # Validate file type
+        if not file.filename.endswith('.csv'):
+            raise HTTPException(status_code=400, detail="File must be CSV format")
+        
+        # Read CSV
+        contents = await file.read()
+        df = pd.read_csv(io.StringIO(contents.decode('utf-8')))
+        
+        # Normalize column names
+        df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_')
+        
+        # Validate required columns
+        required_columns = [
+            'air_temperature', 'process_temperature', 'rotational_speed',
+            'torque', 'tool_wear', 'type'
+        ]
+        missing_cols = [col for col in required_columns if col not in df.columns]
+        if missing_cols:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Missing required columns: {missing_cols}. Found columns: {list(df.columns)}"
+            )
+        
+        # Limit batch size for JSON response (increased for better UX)
+        if len(df) > 1000:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Batch JSON endpoint limited to 500 rows. Your file has {len(df)} rows. Use /predict/batch for larger files or download CSV results."
+            )
+        
+        results = []
+        
+        # Process each row
+        for idx, row in df.iterrows():
+            try:
+                # Prepare data
+                data = {
+                    'machine_id': row.get('machine_id', f'MACHINE_{idx+1}'),
+                    'air_temperature': float(row['air_temperature']),
+                    'process_temperature': float(row['process_temperature']),
+                    'rotational_speed': int(row['rotational_speed']),
+                    'torque': float(row['torque']),
+                    'tool_wear': int(row['tool_wear']),
+                    'type': str(row['type']).strip().upper()
+                }
+                
+                # Feature engineering
+                features_df = engineer_features(data)
+                
+                # Scale and predict
+                features_scaled = MODEL_PIPELINE['scaler'].transform(features_df)
+                prediction = MODEL_PIPELINE['model'].predict(features_scaled)[0]
+                prediction_proba = MODEL_PIPELINE['model'].predict_proba(features_scaled)[0]
+                confidence = float(prediction_proba[prediction])
+                
+                # Diagnostics
+                diagnostics = analyze_condition(data, prediction, confidence, features_df)
+                
+                # Features dict
+                features_dict = features_df.iloc[0].to_dict()
+                
+                # Detect anomalies
+                anomalies = detect_anomalies(data, features_df)
+                
+                # Overall health
+                overall_health = determine_overall_health(prediction, confidence, diagnostics.severity, len(anomalies))
+                
+                # Append result
+                results.append({
+                    "row_number": idx + 1,
+                    "machine_id": data['machine_id'],
+                    "timestamp": datetime.now().isoformat(),
+                    "prediction": "FAILURE" if prediction == 1 else "HEALTHY",
+                    "confidence": round(confidence, 4),
+                    "diagnostics": {
+                        "primary_cause": diagnostics.primary_cause,
+                        "sensor_alert": diagnostics.sensor_alert,
+                        "recommended_action": diagnostics.recommended_action,
+                        "severity": diagnostics.severity
+                    },
+                    "features": features_dict,
+                    "anomalies": [
+                        {
+                            "parameter": a.parameter,
+                            "value": a.value,
+                            "normal_range": a.normal_range,
+                            "status": a.status,
+                            "explanation": a.explanation
+                        } for a in anomalies
+                    ],
+                    "overall_health": overall_health,
+                    "input_data": {
+                        "air_temperature": data['air_temperature'],
+                        "process_temperature": data['process_temperature'],
+                        "rotational_speed": data['rotational_speed'],
+                        "torque": data['torque'],
+                        "tool_wear": data['tool_wear'],
+                        "type": data['type']
+                    }
+                })
+                
+            except Exception as e:
+                logger.warning(f"Row {idx+1} processing error: {e}")
+                results.append({
+                    "row_number": idx + 1,
+                    "machine_id": row.get('machine_id', f'MACHINE_{idx+1}'),
+                    "timestamp": datetime.now().isoformat(),
+                    "prediction": "ERROR",
+                    "confidence": 0.0,
+                    "diagnostics": {
+                        "primary_cause": "Processing Error",
+                        "sensor_alert": str(e),
+                        "recommended_action": "Review input data format and values",
+                        "severity": "UNKNOWN"
+                    },
+                    "error": str(e)
+                })
+        
+        # Summary statistics
+        total = len(results)
+        failures = sum(1 for r in results if r.get('prediction') == 'FAILURE')
+        healthy = sum(1 for r in results if r.get('prediction') == 'HEALTHY')
+        errors = sum(1 for r in results if r.get('prediction') == 'ERROR')
+        
+        return {
+            "summary": {
+                "total_records": total,
+                "predictions": {
+                    "failure": failures,
+                    "healthy": healthy,
+                    "errors": errors
+                },
+                "failure_rate": round(failures / total * 100, 2) if total > 0 else 0
+            },
+            "results": results,
+            "processed_at": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Batch JSON prediction error: {e}")
+        raise HTTPException(status_code=500, detail=f"Batch processing failed: {str(e)}")
+
+
+# ============================================================================
+# HEALTH CHECK ENDPOINTS
+# ============================================================================
+
+@app.get("/")
+async def root():
+    """API root endpoint"""
+    return {
+        "service": "Predictive Maintenance API",
+        "version": "1.0.0",
+        "status": "operational",
+        "model_loaded": MODEL_PIPELINE is not None,
+        "endpoints": {
+            "single_prediction": "/predict",
+            "batch_prediction": "/predict/batch",
+            "health": "/health",
+            "model_info": "/model/info"
+        }
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy" if MODEL_PIPELINE is not None else "unhealthy",
+        "timestamp": datetime.now().isoformat(),
+        "model_loaded": MODEL_PIPELINE is not None,
+        "model_path": str(MODEL_PATH if MODEL_PATH.exists() else FALLBACK_MODEL_PATH)
+    }
+
+
+@app.get("/model/info")
+async def model_info():
+    """Get model information"""
+    if MODEL_PIPELINE is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    return {
+        "model_type": type(MODEL_PIPELINE['model']).__name__,
+        "features": MODEL_PIPELINE['features'],
+        "model_name": MODEL_PIPELINE.get('model_name', 'Unknown'),
+        "performance": MODEL_PIPELINE.get('performance', {}),
+        "training_config": MODEL_PIPELINE.get('training_config', {}),
+        "random_state": MODEL_PIPELINE.get('random_state', None)
+    }
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

api/open_test_interface.bat

@@ -0,0 +1,34 @@
+@echo off
+echo ========================================
+echo   Opening Test Interface
+echo ========================================
+echo.
+
+REM Check if index.html exists
+if not exist "index.html" (
+    echo ERROR: index.html not found in current directory
+    echo Please ensure you are running this from the 'api' folder
+    pause
+    exit /b 1
+)
+
+echo Opening index.html in default browser...
+echo.
+echo Make sure the API server is running!
+echo If not, run: start_server.bat
+echo.
+echo API should be available at: http://localhost:8000
+echo.
+
+REM Open in default browser
+start "" "index.html"
+
+echo.
+echo Test interface opened successfully!
+echo.
+echo Tips:
+echo   1. Check API status indicator (top-right corner)
+echo   2. Try preset scenarios: Healthy, Tool Wear, Overstrain, Cooling
+echo   3. For batch processing, upload CSV with required columns
+echo.
+pause

api/requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.115.5
+uvicorn==0.32.1
+pydantic==2.10.3
+joblib==1.5.2
+numpy==2.3.5
+scikit-learn==1.7.2
+xgboost==3.1.2
+python-multipart==0.0.9
+pandas==2.2.3
+huggingface_hub==1.1.5

api/start_server.bat

@@ -0,0 +1,50 @@
+@echo off
+echo ========================================
+echo   Starting FastAPI Server
+echo ========================================
+echo.
+
+REM Check if Python is installed
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python is not installed or not in PATH
+    echo Please run: install_requirements.bat first
+    pause
+    exit /b 1
+)
+
+REM Check if model exists
+if not exist "..\models\model_pipeline_improved.joblib" (
+    if not exist "..\models\model_pipeline.joblib" (
+        echo WARNING: Model file not found!
+        echo Please ensure model file exists in ../models/ directory
+        echo.
+    )
+)
+
+echo Starting server at http://localhost:8000
+echo.
+echo Available endpoints:
+echo   - HTML Test Interface: Open index.html in browser
+echo   - API Documentation: http://localhost:8000/docs
+echo   - Health Check: http://localhost:8000/health
+echo.
+echo Press Ctrl+C to stop the server
+echo ========================================
+echo.
+
+REM Start the server
+python main.py
+
+if errorlevel 1 (
+    echo.
+    echo ERROR: Server failed to start
+    echo Please check the error messages above
+    echo.
+    echo Common issues:
+    echo   1. Port 8000 is already in use
+    echo   2. Missing dependencies (run: install_requirements.bat)
+    echo   3. Model file not found
+    pause
+    exit /b 1
+)

api/test_batch.csv

@@ -0,0 +1,6 @@
+machine_id,air_temperature,process_temperature,rotational_speed,torque,tool_wear,type,extra_column
+M_001,298.1,308.6,1551,42.8,0,M,some_data
+M_002,297.5,312.8,1800,52.0,220,H,other_data
+M_003,298.5,316.0,1900,72.5,150,H,more_data
+M_004,299.8,305.2,1650,45.0,100,M,extra_info
+M_005,300.2,310.5,1400,38.5,50,L,additional

api/test_data.csv

@@ -0,0 +1,7 @@
+machine_id,air_temperature,process_temperature,rotational_speed,torque,tool_wear,type
+M_L_01,298.1,308.6,1551,42.8,0,M
+M_L_02,299.2,310.1,1450,38.5,150,L
+M_H_01,297.5,312.8,1800,65.2,220,H
+M_M_03,300.1,311.5,2600,55.0,180,M
+M_L_04,296.8,305.2,1200,35.0,50,L
+M_H_05,298.5,316.0,1900,72.5,210,H