Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,5 @@
+venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.DS_Store

.gitignore

@@ -0,0 +1,46 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Environment
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Streamlit
+.streamlit/credentials.toml
+
+# IDEs
+.vscode/
+.idea/
+
+# macOS
+.DS_Store

README.md

@@ -1,10 +1,148 @@
----
-title: Tinyml Backend
-emoji: 🔥
-colorFrom: yellow
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TinyML Heart Health Monitoring Dashboard
+
+A production-ready application for real-time heart health analytics, ensemble prediction modeling, and automated C-code transpilation for resource-constrained embedded systems.
+
+**Live Environments:**
+- 🖥️ **Frontend UI:** [Streamlit Cloud](https://tinyml-heart-health-monitoring-dashboard-8xqogy2hibtlayt7popvs.streamlit.app/)
+- ⚙️ **Backend API:** [Hugging Face Spaces](https://huggingface.co/spaces/IDKHowToCodeFr/tinyml-backend)
+
+## Overview
+
+This application bridges the gap between high-level cloud machine learning and low-level embedded hardware. It evaluates patient vitals using an ensemble of classifiers, provides strict clinical explainability, and compresses these Python-trained models into raw C-code ready to be flashed onto IoT devices.
+
+### Key Engineering Features
+
+- **Edge Computing & TinyML**: Transpiles complex Scikit-Learn models into highly optimized, dependency-free **C-code headers**. This allows predictive intelligence to be deployed directly to the edge, enabling offline, ultra-low latency, and privacy-preserving inference.
+- **INT8 Quantization Engine**: Mathematically scales 64-bit floating-point weights down to 8-bit integers, effectively shrinking the flash memory payload by **~75%** for resource-constrained microcontrollers.
+- **Dynamic Hardware Profiling**: The deployment suite actively simulates target hardware (e.g., *ESP32, Arduino Nano 33 BLE, Raspberry Pi Pico*) to calculate expected inference latency metrics (in µs) and final byte-size footprints prior to flashing.
+- **Interpretable AI (SHAP)**: Solves the medical "black box" concern by generating real-time SHAP feature impact analyses. This visualization proves exactly *why* the AI assigned a specific risk score based on individual patient variables.
+- **Soft-Voting Ensemble**: Rather than relying on a single algorithm, the backend aggregates outputs across five independent models (Random Forest, SVM, KNN, Logistic Regression, Neural Network) to output the highest-confidence predictions.
+
+## Architecture
+
+The project follows a decoupled, modular design pattern separating the client interface from the ML processing pipeline.
+
+```mermaid
+flowchart TD
+    %% Define styles
+    classDef frontend fill:#ff4b4b,stroke:#a30000,stroke-width:2px,color:#fff;
+    classDef backend fill:#009688,stroke:#004d40,stroke-width:2px,color:#fff;
+    classDef ml_node fill:#f2c94c,stroke:#b28900,stroke-width:2px,color:#333;
+    classDef edge_tech fill:#2d9cdb,stroke:#106093,stroke-width:2px,color:#fff;
+    classDef db fill:#9b59b6,stroke:#4a235a,stroke-width:2px,color:#fff;
+
+    %% Core Components
+    UI[🖥️ Streamlit Frontend<br/>Interactive Dashboard]:::frontend
+    API[⚙️ FastAPI Backend<br/>Routing & API Logic]:::backend
+    DB[(🗄️ SQLite DB<br/>Patient History)]:::db
+
+    UI <-->|REST API JSON| API
+    API <-->|Read / Write| DB
+
+    %% ML Subgraph
+    subgraph ML [🧠 Machine Learning & Inference Pipeline]
+        ENS{Ensemble Engine<br/>Soft-Voting}:::ml_node
+        Models[Classifiers:<br/>RF, SVM, LogReg, NN, KNN]:::ml_node
+        SHAP[🔍 SHAP Explainer]:::ml_node
+    end
+
+    %% Edge Quantization Subgraph
+    subgraph Quantization [⚡ Hardware Export]
+        TRANS[C-Code Transpiler<br/>INT8 Quantization]:::edge_tech
+        HEADER((tinyml_model.h)):::edge_tech
+        MCU>ESP32 / Cortex-M Node]:::edge_tech
+    end
+
+    API -->|Predict Request| ENS
+    ENS --> Models
+    API -->|Explain Request| SHAP
+    SHAP -.-> Models
+    API -->|Export Request| TRANS
+    TRANS --> HEADER
+    HEADER -->|Flash Firmware| MCU
+```
+
+### Modular Repository Structure
+
+```text
+TinyML-Dashboard/
+├── backend/               # FastAPI server, ML pipelines, SQLite API, C-code logic
+├── frontend/              # Streamlit UI mapping, Plotly charts, web routing
+├── model/                 # Local cache of serialized SciKit-Learn .pkl weights
+├── data/                  # Patient cohort CSVs for MLOps retraining pipelines
+├── tests/                 # Full PyTest suite for backend continuous integration
+├── .github/workflows/     # CI/CD actions for auto-syncing to Hugging Face
+└── docker-compose.yml     # Orchestration spec for local containerized deployment
+```
+
+## Setup & Installation
+
+### Requirements
+- Python 3.9 or higher
+- Git
+
+### Installation Steps
+
+1. **Clone the repository:**
+```bash
+git clone https://github.com/IDKHowToCodeFR/TinyML-Heart-Health-Monitoring-Dashboard.git
+cd TinyML-Heart-Health-Monitoring-Dashboard
+```
+
+2. **Install global requirements:**
+```bash
+pip install -r requirements.txt
+pip install -r backend/requirements.txt
+pip install -r frontend/requirements.txt
+```
+
+3. **Train the baseline local `.pkl` models (Required on first run):**
+```bash
+cd backend
+python models.py 
+cd ..
+```
+
+## Usage
+
+### 🚀 Quick Start (Windows)
+We've bundled an automated startup script that boots both environments natively:
+```bash
+run.bat
+```
+
+### 🐳 Docker Deployment
+To avoid local python pathing issues, you can spin up the application via Docker Compose:
+```bash
+docker-compose up --build
+```
+*The Streamlit interface will bind automatically to `http://localhost:8501`, connecting directly to the internal API.*
+
+### 🛠️ Manual Startup
+If you prefer running the stack manually in separate terminal instances:
+
+**Start the Backend:**
+```bash
+cd backend
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+**Start the Frontend:**
+```bash
+cd frontend
+streamlit run Home.py
+```
+
+## Development & Automation
+
+### API Documentation
+FastAPI serves auto-generated interactive documentation. While the backend is running, you can hit the endpoints directly at:
+- **Swagger UI:** `http://localhost:8000/docs`
+- **ReDoc:** `http://localhost:8000/redoc`
+
+### CI/CD Pipelines
+The project utilizes GitHub actions natively located in `.github/workflows/`:
+1. **PyTest Validation**: Verifies endpoint data sanitization and schema parameters immediately on Push/Pull Requests.
+2. **Hugging Face Sync**: Auto-deploys `main` branch updates precisely to the Hugging Face Space Docker container ensuring CI/CD alignment.
+
+## Support & License
+This project is licensed under the MIT License. Designed as a scalable, educational, and fully interpretable Edge-based Machine Learning architecture.

backend/Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+WORKDIR /app/backend
+EXPOSE 8000
+CMD sh -c "uvicorn main:app --host 0.0.0.0 --port ${PORT:-8000}"

backend/alerts.log

@@ -0,0 +1,9 @@
+ALERT: Patient at risk! HR: 171.28, SpO2: 98.0, Confidence: 0.82
+ALERT: Patient at risk! HR: 68.0, SpO2: 99.0, Confidence: 0.95
+ALERT: Patient at risk! HR: 97.0, SpO2: 88.0, Confidence: 0.87
+ALERT: Patient at risk! HR: 93.0, SpO2: 88.0, Confidence: 0.99
+ALERT: Patient at risk! HR: 93.0, SpO2: 88.0, Confidence: 0.99
+ALERT: Patient at risk! HR: 93.0, SpO2: 85.0, Confidence: 0.98
+ALERT: Patient at risk! HR: 65.0, SpO2: 93.0, Confidence: 0.92
+ALERT: Patient at risk! HR: 81.0, SpO2: 96.0, Confidence: 0.97
+ALERT: Patient at risk! HR: 91.0, SpO2: 87.0, Confidence: 0.92

backend/database.py

@@ -0,0 +1,98 @@
+import sqlite3
+import os
+from datetime import datetime
+from huggingface_hub import HfApi, hf_hub_download
+
+REPO_ID = "IDKHowToCodeFr/tinyml-logs"
+DB_NAME = 'patient_history.db'
+DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), DB_NAME)
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+api = HfApi()
+
+def sync_from_hub():
+    if not HF_TOKEN:
+        print("No HF_TOKEN found. Skipping sync.")
+        return
+    try:
+        print(f"Downloading {DB_NAME} from Hub...")
+        path = hf_hub_download(repo_id=REPO_ID, filename=DB_NAME, repo_type="dataset", token=HF_TOKEN)
+        import shutil
+        shutil.copy(path, DB_PATH)
+        print("Sync from Hub complete.")
+    except Exception as e:
+        print(f"Sync from Hub failed (maybe first run?): {e}")
+
+def sync_to_hub():
+    if not HF_TOKEN:
+        return
+    try:
+        api.upload_file(
+            path_or_fileobj=DB_PATH,
+            path_in_repo=DB_NAME,
+            repo_id=REPO_ID,
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
+    except Exception as e:
+        print(f"Sync to Hub failed: {e}")
+
+def init_db():
+    sync_from_hub()
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS predictions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp DATETIME,
+            heart_rate REAL,
+            spo2 REAL,
+            sys_bp REAL,
+            dia_bp REAL,
+            temp REAL,
+            fall_detection TEXT,
+            prediction_label TEXT,
+            confidence REAL
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def log_prediction(data, prediction_label, confidence):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('''
+        INSERT INTO predictions (timestamp, heart_rate, spo2, sys_bp, dia_bp, temp, fall_detection, prediction_label, confidence)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (
+        datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        data.Heart_Rate,
+        data.SpO2_Level,
+        data.Systolic_BP,
+        data.Diastolic_BP,
+        data.Body_Temp,
+        data.Fall_Detection,
+        prediction_label,
+        confidence
+    ))
+    conn.commit()
+    conn.close()
+    sync_to_hub()
+
+def get_history():
+    if not os.path.exists(DB_PATH):
+        return []
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('SELECT * FROM predictions ORDER BY timestamp DESC LIMIT 100')
+    rows = cursor.fetchall()
+    col_names = [description[0] for description in cursor.description]
+    conn.close()
+    
+    history = []
+    for row in rows:
+        history.append(dict(zip(col_names, row)))
+    return history
+
+# Initialize db when this module is loaded
+init_db()

backend/ensemble.py

@@ -0,0 +1,48 @@
+import joblib
+import numpy as np
+import os
+import sys
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from preprocessing import resolve_model_dir
+
+class EnsembleModel:
+    def __init__(self):
+        self.model_dir = resolve_model_dir()
+        self.model_names = ['knn', 'svm', 'logreg', 'rf', 'small_nn']
+        self.models = {}
+        self.load_models()
+        self.label_encoder = joblib.load(f'{self.model_dir}/label_encoder.pkl')
+        self.weights = {'knn': 0.15, 'svm': 0.15, 'logreg': 0.20, 'rf': 0.25, 'small_nn': 0.25}
+        
+    def load_models(self):
+        for name in self.model_names:
+            path = f'{self.model_dir}/{name}.pkl'
+            if os.path.exists(path):
+                self.models[name] = joblib.load(path)
+                
+    def predict(self, X):
+        individual_preds = {}
+        individual_probs = {}
+        
+        for name, model in self.models.items():
+            probs = model.predict_proba(X)
+            individual_probs[name] = probs[0]
+            pred_indices = np.argmax(probs, axis=1)
+            individual_preds[name] = str(self.label_encoder.inverse_transform(pred_indices)[0])
+            
+        num_classes = list(individual_probs.values())[0].shape[0]
+        weighted_probs = np.zeros(num_classes)
+        
+        total_weight = 0
+        for name in self.models.keys():
+            w = self.weights.get(name, 1.0)
+            weighted_probs += individual_probs[name] * w
+            total_weight += w
+            
+        weighted_probs /= total_weight
+        final_pred_idx = np.argmax(weighted_probs)
+        final_pred = str(self.label_encoder.inverse_transform([final_pred_idx])[0])
+        confidence = float(np.max(weighted_probs))
+        
+        return final_pred, confidence, individual_preds, individual_probs, self.weights

backend/main.py

@@ -0,0 +1,501 @@
+from fastapi import FastAPI, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import pandas as pd
+import asyncio
+import sys
+import os
+import m2cgen as m2c
+import shap
+from database import log_prediction, get_history
+import numpy as np
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from preprocessing import preprocess_data
+
+app = FastAPI(title="TinyML Healthcare API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+ensemble_system = None
+def get_ensemble():
+    global ensemble_system
+    if ensemble_system is None:
+        try:
+            from ensemble import EnsembleModel
+            ensemble_system = EnsembleModel()
+        except Exception:
+            return None
+    return ensemble_system
+
+class PatientData(BaseModel):
+    Heart_Rate: float
+    SpO2_Level: float
+    Systolic_BP: float
+    Diastolic_BP: float
+    Body_Temp: float
+    Fall_Detection: str
+    
+@app.get("/health")
+def health_check():
+    return {"status": "Healthy" if get_ensemble() else "Warning - Models Offline"}
+
+@app.post("/predict")
+async def predict(data: PatientData):
+    try:
+        eng = get_ensemble()
+        if not eng:
+            return {"error": "Models untrained. Ensure python backend/models.py executes."}
+                
+        df = pd.DataFrame([{
+            'Heart Rate (bpm)': data.Heart_Rate,
+            'SpO2 Level (%)': data.SpO2_Level,
+            'Systolic Blood Pressure (mmHg)': data.Systolic_BP,
+            'Diastolic Blood Pressure (mmHg)': data.Diastolic_BP,
+            'Body Temperature (°C)': data.Body_Temp,
+            'Fall Detection': data.Fall_Detection
+        }])
+        
+        X_proc, _ = await asyncio.to_thread(preprocess_data, df, False)
+        final_pred, conf, ind_preds, ind_probs, weights = await asyncio.to_thread(eng.predict, X_proc)
+        
+        is_at_risk = 0 if final_pred == "Healthy" else 1
+        
+        # Critical Alert System — fault-tolerant
+        if is_at_risk == 1 and float(conf) > 0.80:
+            try:
+                with open("alerts.log", "a") as f:
+                    f.write(f"ALERT: Patient at risk! HR: {data.Heart_Rate}, SpO2: {data.SpO2_Level}, Confidence: {conf:.2f}\n")
+            except Exception:
+                pass
+                
+        # Log to SQLite History — fault-tolerant
+        try:
+            await asyncio.to_thread(log_prediction, data, final_pred, float(conf))
+        except Exception as db_e:
+            print(f"DB logging skipped: {db_e}")
+        
+        return {
+            "prediction": is_at_risk,
+            "prediction_label": final_pred,
+            "probability": float(conf),
+            "ensemble_prediction": is_at_risk,
+            "model_outputs": ind_preds,
+            "model_probs": {k: float(np.max(v)) for k, v in ind_probs.items()},
+            "weights": weights
+        }
+    except Exception as e:
+        import traceback
+        from fastapi import HTTPException
+        raise HTTPException(status_code=500, detail=f"Backend Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+
+@app.get("/history")
+def history():
+    return get_history()
+
+@app.get("/dataset")
+async def get_dataset():
+    data_path = '/app/data/patient_dataset.csv' if os.path.exists('/app/data') else '../data/patient_dataset.csv' if os.path.exists('../data') else 'data/patient_dataset.csv'
+    if os.path.exists(data_path):
+        df = pd.read_csv(data_path)
+        # Return summary or partial data to avoid huge payloads
+        return df.to_dict(orient="records")
+    return {"error": "Dataset not found"}
+
+@app.get("/sync")
+def force_sync():
+    from database import sync_from_hub, sync_to_hub
+    sync_from_hub()
+    return {"status": "Sync attempted"}
+
+@app.post("/explain")
+async def explain(data: PatientData):
+    eng = get_ensemble()
+    if not eng or 'rf' not in eng.models:
+        return {"error": "RF Model unavailable for explanation."}
+        
+    df = pd.DataFrame([{
+        'Heart Rate (bpm)': data.Heart_Rate,
+        'SpO2 Level (%)': data.SpO2_Level,
+        'Systolic Blood Pressure (mmHg)': data.Systolic_BP,
+        'Diastolic Blood Pressure (mmHg)': data.Diastolic_BP,
+        'Body Temperature (°C)': data.Body_Temp,
+        'Fall Detection': data.Fall_Detection
+    }])
+    
+    X_proc, _ = await asyncio.to_thread(preprocess_data, df, False)
+    
+    def compute_shap():
+        import numpy as np
+        rf_model = eng.models['rf']
+        explainer = shap.TreeExplainer(rf_model)
+        shap_values = explainer.shap_values(X_proc)
+        pred_idx = int(rf_model.predict(X_proc)[0])
+        if isinstance(shap_values, list):
+            vals = shap_values[pred_idx][0]
+        elif isinstance(shap_values, np.ndarray) and len(shap_values.shape) == 3:
+            vals = shap_values[0, :, pred_idx]
+        else:
+            vals = shap_values[0]
+        return vals.tolist(), X_proc.columns.tolist()
+        
+    try:
+        shap_vals, features = await asyncio.to_thread(compute_shap)
+        return {"shap_values": shap_vals, "feature_names": features}
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.get("/export_tinyml")
+def export_tinyml(model_name: str = "rf", quantize: bool = False):
+    import numpy as np
+    eng = get_ensemble()
+    if not eng or model_name not in eng.models:
+        return {"error": f"Model {model_name} not found"}
+        
+    model = eng.models[model_name]
+    
+    # m2cgen handles Random Forest beautifully, but outputs FP32/double rules
+    if model_name == "rf":
+        try:
+            code = m2c.export_to_c(model)
+            if quantize:
+                code = "/* WARNING: M2CGen generated FP32 output. INT8 Quantization is not supported directly for Random Forest trees. */\n" + code
+            return {"code": code}
+        except Exception:
+            pass
+            
+    # For LogReg, use m2cgen if FP32, otherwise manual generation for INT8
+    if not quantize and model_name == "logreg":
+        try:
+            code = m2c.export_to_c(model)
+            return {"code": code}
+        except Exception:
+            pass
+    
+    # Manual C-code generation for all model types
+    try:
+        L = []
+        L.append("/* ====================================================== */")
+        L.append(f"/* TinyML C Export: {model_name}                           */")
+        q_text = "INT8 Quantized" if quantize else "FP32 Double"
+        L.append(f"/* Auto-generated for ARM Cortex-M / ESP32 ({q_text}) */")
+        L.append("/* ====================================================== */")
+        L.append("")
+        L.append("#include <math.h>")
+        L.append("#include <stdint.h>")
+        L.append("#include <string.h>")
+        L.append("")
+        
+        if model_name == "svm" and hasattr(model, 'coef_'):
+            coefs = model.coef_
+            intercepts = model.intercept_
+            n_classes = len(model.classes_)
+            n_features = coefs.shape[1]
+            L.append(f"/* Linear SVM with {n_classes} classes, {n_features} features */")
+            L.append(f"#define N_FEATURES {n_features}")
+            L.append(f"#define N_CLASSES {n_classes}")
+            L.append(f"#define N_HYPERPLANES {coefs.shape[0]}")
+            L.append("")
+
+            if quantize:
+                scale_factor = 127.0 / max(np.max(np.abs(coefs)), np.max(np.abs(intercepts)), 1e-6)
+                L.append(f"/* Quantization Scale: {scale_factor:.4f} */")
+                L.append("static const int8_t SVM_COEF[N_HYPERPLANES][N_FEATURES] = {")
+                for row in coefs:
+                    vals = ", ".join([str(int(round(v * scale_factor))) for v in row])
+                    L.append(f"    {{{vals}}},")
+                L.append("};")
+                L.append("")
+                vals = ", ".join([str(int(round(v * scale_factor))) for v in intercepts])
+                L.append(f"static const int8_t SVM_INTERCEPT[N_HYPERPLANES] = {{{vals}}};")
+                L.append("")
+                L.append("int predict(int8_t *features) {")
+                L.append("    int32_t scores[N_CLASSES] = {0};")
+                L.append("    int h = 0;")
+                L.append("    for (int i = 0; i < N_CLASSES; i++) {")
+                L.append("        for (int j = i + 1; j < N_CLASSES; j++) {")
+                L.append("            int32_t decision = SVM_INTERCEPT[h];")
+                L.append("            for (int f = 0; f < N_FEATURES; f++) {")
+                L.append("                decision += (int32_t)SVM_COEF[h][f] * features[f];")
+                L.append("            }")
+                L.append("            if (decision > 0) scores[i] += 1;")
+                L.append("            else scores[j] += 1;")
+                L.append("            h++;")
+                L.append("        }")
+                L.append("    }")
+                L.append("    int best = 0;")
+                L.append("    for (int c = 1; c < N_CLASSES; c++) {")
+                L.append("        if (scores[c] > scores[best]) best = c;")
+                L.append("    }")
+                L.append("    return best;")
+                L.append("}")
+            else:
+                L.append("static const double SVM_COEF[N_HYPERPLANES][N_FEATURES] = {")
+                for row in coefs:
+                    vals = ", ".join([f"{v:.6f}" for v in row])
+                    L.append(f"    {{{vals}}},")
+                L.append("};")
+                L.append("")
+                vals = ", ".join([f"{v:.6f}" for v in intercepts])
+                L.append(f"static const double SVM_INTERCEPT[N_HYPERPLANES] = {{{vals}}};")
+                L.append("")
+                L.append("int predict(double *features) {")
+                L.append("    double scores[N_CLASSES] = {0};")
+                L.append("    int h = 0;")
+                L.append("    for (int i = 0; i < N_CLASSES; i++) {")
+                L.append("        for (int j = i + 1; j < N_CLASSES; j++) {")
+                L.append("            double decision = SVM_INTERCEPT[h];")
+                L.append("            for (int f = 0; f < N_FEATURES; f++) {")
+                L.append("                decision += SVM_COEF[h][f] * features[f];")
+                L.append("            }")
+                L.append("            if (decision > 0) scores[i] += 1.0;")
+                L.append("            else scores[j] += 1.0;")
+                L.append("            h++;")
+                L.append("        }")
+                L.append("    }")
+                L.append("    int best = 0;")
+                L.append("    for (int c = 1; c < N_CLASSES; c++) {")
+                L.append("        if (scores[c] > scores[best]) best = c;")
+                L.append("    }")
+                L.append("    return best;")
+                L.append("}")
+
+        elif model_name == "logreg" and hasattr(model, 'coef_'):
+            coefs = model.coef_
+            intercepts = model.intercept_
+            n_classes = coefs.shape[0] if len(model.classes_) > 2 else 2
+            n_features = coefs.shape[1]
+            L.append(f"/* Logistic Regression with {n_classes} classes, {n_features} features */")
+            L.append(f"#define N_FEATURES {n_features}")
+            L.append(f"#define N_CLASSES {coefs.shape[0]}")
+            L.append("")
+            
+            if quantize:
+                scale_factor = 127.0 / max(np.max(np.abs(coefs)), np.max(np.abs(intercepts)), 1e-6)
+                L.append(f"/* Quantization Scale: {scale_factor:.4f} */")
+                L.append("static const int8_t LOGREG_COEF[N_CLASSES][N_FEATURES] = {")
+                for row in coefs:
+                    vals = ", ".join([str(int(round(v * scale_factor))) for v in row])
+                    L.append(f"    {{{vals}}},")
+                L.append("};")
+                L.append("")
+                vals = ", ".join([str(int(round(v * scale_factor))) for v in intercepts])
+                L.append(f"static const int8_t LOGREG_INTERCEPT[N_CLASSES] = {{{vals}}};")
+                L.append("")
+                L.append("int predict(int8_t *features) {")
+                L.append("    int32_t scores[N_CLASSES];")
+                L.append("    for (int c = 0; c < N_CLASSES; c++) {")
+                L.append(f"        scores[c] = LOGREG_INTERCEPT[c] * {int(scale_factor)};")
+                L.append("        for (int f = 0; f < N_FEATURES; f++) {")
+                L.append("            scores[c] += (int32_t)LOGREG_COEF[c][f] * features[f];")
+                L.append("        }")
+                L.append("    }")
+                L.append("    int best = 0;")
+                L.append("    for (int c = 1; c < N_CLASSES; c++) {")
+                L.append("        if (scores[c] > scores[best]) best = c;")
+                L.append("    }")
+                L.append("    return best;")
+                L.append("}")
+            else:
+                L.append("static const double LOGREG_COEF[N_CLASSES][N_FEATURES] = {")
+                for row in coefs:
+                    vals = ", ".join([f"{v:.6f}" for v in row])
+                    L.append(f"    {{{vals}}},")
+                L.append("};")
+                L.append("")
+                vals = ", ".join([f"{v:.6f}" for v in intercepts])
+                L.append(f"static const double LOGREG_INTERCEPT[N_CLASSES] = {{{vals}}};")
+                L.append("")
+                L.append("int predict(double *features) {")
+                L.append("    double scores[N_CLASSES];")
+                L.append("    for (int c = 0; c < N_CLASSES; c++) {")
+                L.append("        scores[c] = LOGREG_INTERCEPT[c];")
+                L.append("        for (int f = 0; f < N_FEATURES; f++) {")
+                L.append("            scores[c] += LOGREG_COEF[c][f] * features[f];")
+                L.append("        }")
+                L.append("    }")
+                L.append("    int best = 0;")
+                L.append("    for (int c = 1; c < N_CLASSES; c++) {")
+                L.append("        if (scores[c] > scores[best]) best = c;")
+                L.append("    }")
+                L.append("    return best;")
+                L.append("}")
+
+        elif model_name == "small_nn" and hasattr(model, 'coefs_'):
+            layers = model.coefs_
+            biases = model.intercepts_
+            arch = " -> ".join([str(l.shape[0]) for l in layers] + [str(layers[-1].shape[1])])
+            L.append(f"/* MLP Neural Network: {len(layers)} layers */")
+            L.append(f"/* Architecture: {arch} */")
+            L.append("")
+            
+            for idx, (W, b) in enumerate(zip(layers, biases)):
+                n_in, n_out = W.shape
+                L.append(f"#define L{idx}_IN {n_in}")
+                L.append(f"#define L{idx}_OUT {n_out}")
+                L.append(f"static const double W{idx}[{n_in}][{n_out}] = {{")
+                for row in W:
+                    vals = ", ".join([f"{v:.6f}" for v in row])
+                    L.append(f"    {{{vals}}},")
+                L.append("};")
+                bvals = ", ".join([f"{v:.6f}" for v in b])
+                L.append(f"static const double B{idx}[{n_out}] = {{{bvals}}};")
+                L.append("")
+            
+            L.append("static inline double relu(double x) { return x > 0 ? x : 0; }")
+            L.append("")
+
+            if quantize:
+                # Calculate global max for int8 scaling
+                max_val = max([np.max(np.abs(w)) for w in layers] + [np.max(np.abs(b)) for b in biases] + [1e-6])
+                scale_factor = 127.0 / max_val
+                L.append(f"/* INT8 Quantization Scale Factor: {scale_factor:.4f} */")
+                for idx, (W, b) in enumerate(zip(layers, biases)):
+                    n_in, n_out = W.shape
+                    L.append(f"static const int8_t W{idx}[{n_in}][{n_out}] = {{")
+                    for row in W:
+                        vals = ", ".join([str(int(round(v * scale_factor))) for v in row])
+                        L.append(f"    {{{vals}}},")
+                    L.append("};")
+                    bvals = ", ".join([str(int(round(v * scale_factor))) for v in b])
+                    L.append(f"static const int8_t B{idx}[{n_out}] = {{{bvals}}};")
+                    L.append("")
+                L.append("static inline int32_t relu_int(int32_t x) { return x > 0 ? x : 0; }")
+                L.append("")
+                L.append("int predict(int8_t *input) {")
+                for idx in range(len(layers)):
+                    n_in = layers[idx].shape[0]
+                    n_out = layers[idx].shape[1]
+                    is_last = (idx == len(layers) - 1)
+                    src = "input" if idx == 0 else f"a{idx-1}"
+                    L.append(f"    int32_t a{idx}[{n_out}];")
+                    L.append(f"    for (int j = 0; j < {n_out}; j++) {{")
+                    L.append(f"        a{idx}[j] = B{idx}[j] * {int(scale_factor)}; /* scale bias */")
+                    L.append(f"        for (int i = 0; i < {n_in}; i++) {{")
+                    L.append(f"            a{idx}[j] += (int32_t){src}[i] * W{idx}[i][j];")
+                    L.append(f"        }}")
+                    if not is_last:
+                        L.append(f"        a{idx}[j] = relu_int(a{idx}[j]) / {int(scale_factor)}; /* rescale */")
+                    L.append(f"    }}")
+                last_idx = len(layers) - 1
+                last_out = layers[-1].shape[1]
+                L.append(f"    int best = 0;")
+                L.append(f"    for (int c = 1; c < {last_out}; c++) {{")
+                L.append(f"        if (a{last_idx}[c] > a{last_idx}[best]) best = c;")
+                L.append(f"    }}")
+                L.append(f"    return best;")
+                L.append("}")
+            else:
+                for idx, (W, b) in enumerate(zip(layers, biases)):
+                    n_in, n_out = W.shape
+                    L.append(f"#define L{idx}_IN {n_in}")
+                    L.append(f"#define L{idx}_OUT {n_out}")
+                    L.append(f"static const double W{idx}[{n_in}][{n_out}] = {{")
+                    for row in W:
+                        vals = ", ".join([f"{v:.6f}" for v in row])
+                        L.append(f"    {{{vals}}},")
+                    L.append("};")
+                    bvals = ", ".join([f"{v:.6f}" for v in b])
+                    L.append(f"static const double B{idx}[{n_out}] = {{{bvals}}};")
+                    L.append("")
+
+            L.append("static inline double relu(double x) { return x > 0 ? x : 0; }")
+            L.append("")
+            L.append("int predict(double *input) {")
+            for idx in range(len(layers)):
+                n_in = layers[idx].shape[0]
+                n_out = layers[idx].shape[1]
+                is_last = (idx == len(layers) - 1)
+                src = "input" if idx == 0 else f"a{idx-1}"
+                L.append(f"    double a{idx}[{n_out}];")
+                L.append(f"    for (int j = 0; j < {n_out}; j++) {{")
+                L.append(f"        a{idx}[j] = B{idx}[j];")
+                L.append(f"        for (int i = 0; i < {n_in}; i++) {{")
+                L.append(f"            a{idx}[j] += {src}[i] * W{idx}[i][j];")
+                L.append(f"        }}")
+                if not is_last:
+                    L.append(f"        a{idx}[j] = relu(a{idx}[j]);")
+                L.append(f"    }}")
+            
+            last_idx = len(layers) - 1
+            last_out = layers[-1].shape[1]
+            L.append(f"    int best = 0;")
+            L.append(f"    for (int c = 1; c < {last_out}; c++) {{")
+            L.append(f"        if (a{last_idx}[c] > a{last_idx}[best]) best = c;")
+            L.append(f"    }}")
+            L.append(f"    return best;")
+            L.append("}")
+            
+        elif model_name == "knn" and hasattr(model, '_fit_X'):
+            n_samples = min(model._fit_X.shape[0], 100)
+            n_feats = model._fit_X.shape[1]
+            L.append(f"/* KNN Lookup Table: {n_samples} reference samples */")
+            L.append(f"#define N_NEIGHBORS {model.n_neighbors}")
+            L.append(f"#define N_SAMPLES {n_samples}")
+            L.append(f"#define N_FEATURES {n_feats}")
+            L.append("")
+            L.append("static const double REF[N_SAMPLES][N_FEATURES] = {")
+            for row in model._fit_X[:n_samples]:
+                vals = ", ".join([f"{v:.4f}" for v in row])
+                L.append(f"    {{{vals}}},")
+            L.append("};")
+            L.append("")
+            labels_str = ", ".join([str(int(l)) for l in model._y[:n_samples]])
+            L.append(f"static const int LABELS[N_SAMPLES] = {{{labels_str}}};")
+            L.append("")
+            L.append("int predict(double *features) {")
+            L.append("    double dists[N_SAMPLES];")
+            L.append("    for (int i = 0; i < N_SAMPLES; i++) {")
+            L.append("        dists[i] = 0.0;")
+            L.append("        for (int f = 0; f < N_FEATURES; f++) {")
+            L.append("            double d = features[f] - REF[i][f];")
+            L.append("            dists[i] += d * d;")
+            L.append("        }")
+            L.append("    }")
+            L.append("    int votes[10] = {0};")
+            L.append("    for (int k = 0; k < N_NEIGHBORS; k++) {")
+            L.append("        int mi = 0;")
+            L.append("        for (int i = 1; i < N_SAMPLES; i++) {")
+            L.append("            if (dists[i] < dists[mi]) mi = i;")
+            L.append("        }")
+            L.append("        votes[LABELS[mi]]++;")
+            L.append("        dists[mi] = 1e18;")
+            L.append("    }")
+            L.append("    int best = 0;")
+            L.append("    for (int i = 1; i < 10; i++) {")
+            L.append("        if (votes[i] > votes[best]) best = i;")
+            L.append("    }")
+            L.append("    return best;")
+            L.append("}")
+        else:
+            return {"error": f"Model {model_name} cannot be exported to C."}
+        
+        return {"code": "\n".join(L)}
+    except Exception as e:
+        return {"error": f"Export failed: {str(e)}"}
+
+@app.post("/retrain")
+async def retrain(file: UploadFile = File(...)):
+    data_path = '/app/data/patient_dataset.csv' if os.path.exists('/app/data') else '../data/patient_dataset.csv' if os.path.exists('../data') else 'data/patient_dataset.csv'
+    os.makedirs(os.path.dirname(data_path), exist_ok=True)
+    
+    content = await file.read()
+    with open(data_path, "wb") as f:
+        f.write(content)
+        
+    try:
+        from models import train_models
+        await asyncio.to_thread(train_models)
+        
+        global ensemble_system
+        ensemble_system = None
+        
+        return {"status": "success", "message": "Ensemble retrained successfully!"}
+    except Exception as e:
+        return {"error": str(e)}

backend/models.py

@@ -0,0 +1,39 @@
+import os
+import joblib
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.neural_network import MLPClassifier
+import pandas as pd
+import sys
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from preprocessing import get_train_test_split, resolve_model_dir
+
+def train_models():
+    data_path = '/app/data/patient_dataset.csv' if os.path.exists('/app/data') else '../data/patient_dataset.csv' if os.path.exists('../data') else 'data/patient_dataset.csv'
+    model_dir = resolve_model_dir()
+    os.makedirs(model_dir, exist_ok=True)
+    
+    print("Loading data...")
+    df = pd.read_csv(data_path)
+    X_train, X_test, y_train, y_test = get_train_test_split(df)
+    
+    models = {
+        'knn': KNeighborsClassifier(n_neighbors=5),
+        'svm': SVC(kernel='linear', probability=True, max_iter=2000), 
+        'logreg': LogisticRegression(max_iter=1000),
+        'rf': RandomForestClassifier(n_estimators=30, max_depth=5, random_state=42),
+        'small_nn': MLPClassifier(hidden_layer_sizes=(16, 8), max_iter=500, random_state=42)
+    }
+    
+    for name, model in models.items():
+        print(f"Training {name}...")
+        model.fit(X_train, y_train)
+        joblib.dump(model, f'{model_dir}/{name}.pkl')
+        
+    print("Training Complete.")
+
+if __name__ == '__main__':
+    train_models()

backend/preprocessing.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import numpy as np
+import os
+import joblib
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+
+def resolve_model_dir():
+    # Resolve relative paths universally whether Docker or local execution
+    return '/app/model' if os.path.exists('/app/model') else '../model' if os.path.exists('../model') else 'model'
+
+def preprocess_data(df, is_training=True):
+    model_dir = resolve_model_dir()
+    scaler_path = f'{model_dir}/scaler.pkl'
+    label_encoder_path = f'{model_dir}/label_encoder.pkl'
+        
+    columns_to_drop = ['Patient Number', 'Data Accuracy (%)', 'Heart Rate Alert', 'SpO2 Level Alert', 'Blood Pressure Alert', 'Temperature Alert']
+    cols_drop = [c for c in columns_to_drop if c in df.columns]
+    X_raw = df.drop(columns=cols_drop)
+    
+    y = None
+    if 'Predicted Disease' in X_raw.columns:
+        y_raw = X_raw['Predicted Disease']
+        X_raw = X_raw.drop(columns=['Predicted Disease'])
+    
+        if is_training:
+            label_encoder = LabelEncoder()
+            y = label_encoder.fit_transform(y_raw)
+            os.makedirs(os.path.dirname(label_encoder_path), exist_ok=True)
+            joblib.dump(label_encoder, label_encoder_path)
+            joblib.dump(label_encoder.classes_, f'{model_dir}/classes.pkl')
+        else:
+            if os.path.exists(label_encoder_path):
+                label_encoder = joblib.load(label_encoder_path)
+                y = label_encoder.transform(y_raw)
+            else:
+                y = y_raw 
+    
+    if 'Fall Detection' in X_raw.columns:
+        X_raw['Fall Detection'] = X_raw['Fall Detection'].map({'Yes': 1, 'No': 0}).fillna(0)
+        
+    X_raw.fillna(X_raw.mean(), inplace=True)
+    
+    # Engineered Feature
+    X_raw['Risk_Severity'] = (X_raw['Heart Rate (bpm)'] > 105).astype(int) + (X_raw['SpO2 Level (%)'] < 94).astype(int)
+    
+    continuous_features = ['Heart Rate (bpm)', 'SpO2 Level (%)', 'Systolic Blood Pressure (mmHg)', 'Diastolic Blood Pressure (mmHg)', 'Body Temperature (°C)', 'Risk_Severity']
+    
+    if is_training:
+        scaler = StandardScaler()
+        X_raw[continuous_features] = scaler.fit_transform(X_raw[continuous_features])
+        joblib.dump(scaler, scaler_path)
+    else:
+        if os.path.exists(scaler_path):
+            scaler = joblib.load(scaler_path)
+            X_raw[continuous_features] = scaler.transform(X_raw[continuous_features])
+            
+    return X_raw, y
+
+def get_train_test_split(df):
+    X, y = preprocess_data(df, is_training=True)
+    return train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

backend/requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn
+scikit-learn==1.8.0
+pandas
+numpy
+joblib
+shap
+m2cgen
+matplotlib
+python-multipart
+huggingface_hub

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  backend:
+    build: 
+      context: .
+      dockerfile: backend/Dockerfile
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./model:/app/model
+      - ./data:/app/data
+
+  frontend:
+    build:
+      context: .
+      dockerfile: frontend/Dockerfile
+    ports:
+      - "8501:8501"
+    environment:
+      - API_URL=http://backend:8000
+    depends_on:
+      - backend

frontend/.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+primaryColor="#00f2fe"
+backgroundColor="#0e1117"
+secondaryBackgroundColor="#262730"
+textColor="#fafafa"
+font="sans serif"

frontend/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y graphviz && rm -rf /var/lib/apt/lists/*
+
+COPY frontend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+WORKDIR /app/frontend
+EXPOSE 8501
+CMD sh -c "streamlit run Home.py --server.port=${PORT:-8501} --server.address=0.0.0.0"

frontend/Home.py

@@ -0,0 +1,298 @@
+import streamlit as st
+import requests
+import os
+import time
+import pandas as pd
+import plotly.graph_objects as go
+import numpy as np
+
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+st.set_page_config(page_title="TinyML Heart Health Monitoring", page_icon="🫀", layout="wide")
+
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&display=swap');
+html, body, [class*="css"] { font-family: 'Inter', sans-serif; }
+
+.hero-sub {
+    font-size: 1.15rem; color: rgba(255,255,255,0.55);
+    margin-top: 8px; font-weight: 300; letter-spacing: 0.3px;
+}
+
+.metrics-grid {
+    display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; margin-bottom: 16px;
+}
+.glass-metric {
+    background: rgba(255,255,255,0.04);
+    backdrop-filter: blur(12px); -webkit-backdrop-filter: blur(12px);
+    border: 1px solid rgba(255,255,255,0.08); border-radius: 16px;
+    padding: 24px 20px; text-align: center;
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+    min-height: 160px; display: flex; flex-direction: column;
+    justify-content: center; align-items: center;
+}
+.glass-metric:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 12px 40px rgba(0,242,254,0.12);
+    border-color: rgba(255,255,255,0.15);
+}
+.metric-value {
+    font-size: 2.4rem; font-weight: 800; margin: 8px 0 6px 0; letter-spacing: -0.5px;
+}
+.metric-label {
+    font-size: 0.78rem; color: rgba(255,255,255,0.45);
+    text-transform: uppercase; letter-spacing: 2px; font-weight: 600;
+}
+.metric-delta {
+    font-size: 0.8rem; font-weight: 500; margin-top: 6px;
+    padding: 3px 10px; border-radius: 20px; display: inline-block;
+}
+.delta-good { color: #00cc96; background: rgba(0,204,150,0.12); }
+.delta-bad  { color: #ef553b; background: rgba(239,85,59,0.12); }
+
+.status-badge {
+    display: inline-block; padding: 6px 18px; border-radius: 50px;
+    font-size: 0.85rem; font-weight: 600; letter-spacing: 0.5px;
+}
+.status-online  { background: rgba(0,204,150,0.15); color: #00cc96; border: 1px solid rgba(0,204,150,0.3); }
+.status-fallback { background: rgba(99,110,250,0.15); color: #636efa; border: 1px solid rgba(99,110,250,0.3); }
+
+.feature-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; }
+.feature-card {
+    background: rgba(255,255,255,0.03); border: 1px solid rgba(255,255,255,0.06);
+    border-radius: 14px; padding: 24px 20px; min-height: 170px;
+    display: flex; flex-direction: column;
+    transition: border-color 0.2s ease, transform 0.2s ease;
+}
+.feature-card:hover { border-color: rgba(0,242,254,0.25); transform: translateY(-2px); }
+.feature-card .fc-icon  { font-size: 1.6rem; margin-bottom: 10px; }
+.feature-card .fc-title { color: #00f2fe; font-size: 0.95rem; font-weight: 700; margin-bottom: 8px; }
+.feature-card .fc-desc  { color: rgba(255,255,255,0.45); font-size: 0.82rem; line-height: 1.55; flex-grow: 1; }
+</style>
+""", unsafe_allow_html=True)
+
+# ──────── Hero ────────
+st.title("🫀 TinyML Heart Health Monitoring Dashboard")
+st.markdown('<p class="hero-sub">Edge Intelligence for Real-Time Patient Monitoring • 5-Model Ensemble • SHAP Explainability • IoT Edge Deployment</p>', unsafe_allow_html=True)
+st.markdown("<br>", unsafe_allow_html=True)
+
+# ──────── System Status ────────
+try:
+    resp = requests.get(f"{API_URL}/health", timeout=5)
+    if resp.status_code == 200:
+        status = resp.json().get("status", "Unknown")
+        is_online = "Healthy" in status
+    else:
+        status = f"Backend Error ({resp.status_code})"
+        is_online = False
+except Exception as e:
+    status = f"Offline / Monolith Fallback ({str(e)[:50]})"
+    is_online = False
+
+badge_class = "status-online" if is_online else "status-fallback"
+badge_text = "● ONLINE" if is_online else "● CLOUD MODE"
+st.markdown(f'<span class="status-badge {badge_class}">{badge_text}</span> &nbsp; <span style="color:rgba(255,255,255,0.35);font-size:0.85rem;">{status}</span>', unsafe_allow_html=True)
+st.markdown("---")
+
+# ──────── Dataset constants ────────
+HR_MIN, HR_MAX, HR_AVG = 50.0, 139.0, 94.6
+SPO2_MIN, SPO2_MAX, SPO2_AVG = 84.0, 100.0, 94.6
+ALERT_MAX = 100
+HR_NORMAL_LO, HR_NORMAL_HI = 60.0, 100.0
+SPO2_NORMAL_LO = 95.0
+CANDLE_COUNT = 60
+TICK_INTERVAL = 1.5  # seconds
+
+# ──────── Deterministic candle from timestamp ────────
+def _alert_at(ts_epoch):
+    """Deterministic alert count for a given epoch timestamp."""
+    rng = np.random.RandomState(int(ts_epoch * 10) % (2**31))
+    return int(rng.randint(0, ALERT_MAX + 1))
+
+def _candle_at(t_epoch, prev_alerts, curr_alerts):
+    """Build an OHLC candle from alert transitions."""
+    o = float(prev_alerts)
+    c = float(curr_alerts)
+    rng = np.random.RandomState(int(t_epoch * 7) % (2**31))
+    spread = abs(c - o) * 0.3 + rng.uniform(1, 4)
+    h = max(o, c) + spread
+    l = min(o, c) - rng.uniform(0.5, spread * 0.6)
+    h = min(h, ALERT_MAX + 5)
+    l = max(l, 0)
+    return {"time": pd.Timestamp.fromtimestamp(t_epoch), "open": round(o, 1), "high": round(h, 1), "low": round(l, 1), "close": round(c, 1)}
+
+# ──────── Initialize: pre-fill chart as if running since startup ────────
+if "chart_candles" not in st.session_state:
+    now_ep = time.time()
+    candles = []
+    prev = 50  # initial alert count
+    for i in range(CANDLE_COUNT):
+        t = now_ep - (CANDLE_COUNT - i) * TICK_INTERVAL
+        curr = _alert_at(t)
+        candles.append(_candle_at(t, prev, curr))
+        prev = curr
+    st.session_state.chart_candles = candles
+    st.session_state.last_alerts = prev
+    st.session_state.last_candle_epoch = now_ep
+
+# ──────── Live Metrics ────────
+@st.fragment(run_every="1.5s")
+def live_metrics():
+    now_ep = time.time()
+
+    # Catch up: generate all candles that should have been created while away
+    last_ep = st.session_state.get("last_candle_epoch", now_ep - TICK_INTERVAL)
+    missed = int((now_ep - last_ep) / TICK_INTERVAL)
+    prev_a = st.session_state.get("last_alerts", 50)
+
+    if missed > 1:
+        # Backfill deterministically so chart stays continuous
+        for i in range(1, min(missed, CANDLE_COUNT) + 1):
+            t = last_ep + i * TICK_INTERVAL
+            curr_a = _alert_at(t)
+            st.session_state.chart_candles.append(_candle_at(t, prev_a, curr_a))
+            prev_a = curr_a
+
+    # Current tick
+    alerts = np.random.randint(0, ALERT_MAX + 1)
+    alert_delta = alerts - prev_a
+    st.session_state.chart_candles.append(_candle_at(now_ep, prev_a, alerts))
+    st.session_state.last_alerts = alerts
+    st.session_state.last_candle_epoch = now_ep
+
+    if len(st.session_state.chart_candles) > CANDLE_COUNT:
+        st.session_state.chart_candles = st.session_state.chart_candles[-CANDLE_COUNT:]
+
+    # Simulate patient cohort from alert count
+    n = max(alerts, 5)
+    sim_hr = np.clip(np.random.normal(HR_AVG, 12, n), HR_MIN, HR_MAX)
+    sim_o2 = np.clip(np.random.normal(SPO2_AVG, 3, n), SPO2_MIN, SPO2_MAX)
+    pop_hr = round(float(np.mean(sim_hr)), 1)
+    pop_o2 = round(float(np.mean(sim_o2)), 1)
+    hr_delta = round(pop_hr - HR_AVG, 1)
+    o2_delta = round(pop_o2 - SPO2_AVG, 1)
+    hr_ok = HR_NORMAL_LO <= pop_hr <= HR_NORMAL_HI
+    o2_ok = pop_o2 >= SPO2_NORMAL_LO
+
+    # Alert delta coloring: increase = bad (red), decrease = good (green)
+    ad_good = alert_delta <= 0
+    ad_c = "#00cc96" if ad_good else "#ef553b"
+    ad_d = "delta-good" if ad_good else "delta-bad"
+    ad_i = "▼" if ad_good else "▲"
+    ad_txt = f"{abs(alert_delta)} fewer" if ad_good else f"{alert_delta} more"
+
+    hr_c = "#00cc96" if hr_ok else "#ef553b"
+    hr_d = "delta-good" if hr_ok else "delta-bad"
+    hr_a = "▲" if hr_delta > 0 else "▼"
+    hr_s = "Within Normal" if hr_ok else "Abnormal"
+    o2_c = "#00cc96" if o2_ok else "#ef553b"
+    o2_d = "delta-good" if o2_ok else "delta-bad"
+    o2_a = "▲" if o2_delta > 0 else "▼"
+    o2_s = "Within Normal" if o2_ok else "Below Safe"
+
+    st.markdown(f"""
+    <div class="metrics-grid">
+        <div class="glass-metric">
+            <div class="metric-label">Total Patients</div>
+            <div class="metric-value" style="color:#4facfe;">60,000</div>
+            <div class="metric-delta delta-good">● Live Stream Active</div>
+        </div>
+        <div class="glass-metric">
+            <div class="metric-label">Active Alerts</div>
+            <div class="metric-value" style="color:{ad_c};">{alerts}</div>
+            <div class="metric-delta {ad_d}">{ad_i} {ad_txt} vs last</div>
+        </div>
+        <div class="glass-metric">
+            <div class="metric-label">Avg Heart Rate</div>
+            <div class="metric-value" style="color:{hr_c};">{pop_hr} <span style="font-size:1rem;color:rgba(255,255,255,0.3);">bpm</span></div>
+            <div class="metric-delta {hr_d}">{hr_a} {abs(hr_delta)} bpm from avg • {hr_s}</div>
+        </div>
+        <div class="glass-metric">
+            <div class="metric-label">Avg SpO2 Level</div>
+            <div class="metric-value" style="color:{o2_c};">{pop_o2}<span style="font-size:1rem;color:rgba(255,255,255,0.3);">%</span></div>
+            <div class="metric-delta {o2_d}">{o2_a} {abs(o2_delta):.1f}% from avg • {o2_s}</div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # ──── Smoothed Activity Area Chart: tracks average heart-rate & alerts ────
+    st.markdown("##### 📡 Live Patient Emulation Trace")
+
+    cd = st.session_state.chart_candles
+    ts = [x["time"] for x in cd]
+    # Represent the primary metric as the close/current state
+    cl = [x["close"] for x in cd]
+
+    fig = go.Figure()
+
+    # Main Area Waveform
+    fig.add_trace(go.Scatter(
+        x=ts, y=cl,
+        mode='lines',
+        line=dict(color='#00f2fe', width=3, shape='spline', smoothing=1.3),
+        fill='tozeroy',
+        fillcolor='rgba(0, 242, 254, 0.15)',
+        name="Activity Index"
+    ))
+
+    # Add a thin secondary baseline trend
+    w = min(10, len(cl))
+    ma = pd.Series(cl).rolling(window=w, min_periods=1).mean().tolist()
+    fig.add_trace(go.Scatter(
+        x=ts, y=ma, mode='lines',
+        line=dict(color='rgba(255, 255, 255, 0.4)', width=1.5, dash='dot'),
+        name="Moving Average"
+    ))
+
+    fig.update_layout(
+        template="plotly_dark", height=320,
+        margin=dict(l=0, r=50, t=10, b=0),
+        paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+        xaxis=dict(gridcolor='rgba(255,255,255,0.03)', showgrid=True, rangeslider=dict(visible=False)),
+        yaxis=dict(
+            title="Relative Activity",
+            gridcolor='rgba(255,255,255,0.05)',
+            title_font=dict(size=11),
+            side="right",
+            range=[0, ALERT_MAX + 15]
+        ),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1, font=dict(size=10)),
+        showlegend=True,
+        hovermode="x unified"
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+live_metrics()
+
+st.markdown("---")
+
+# ──────── Feature Cards ────────
+st.markdown("##### 🧩 System Capabilities")
+st.markdown("""
+<div class="feature-grid">
+    <div class="feature-card">
+        <div class="fc-icon">🩺</div>
+        <div class="fc-title">Edge Prediction</div>
+        <div class="fc-desc">5-model weighted ensemble (KNN, SVM, LogReg, RF, MLP) with real-time consensus voting and confidence scoring.</div>
+    </div>
+    <div class="feature-card">
+        <div class="fc-icon">🔍</div>
+        <div class="fc-title">SHAP Explainability</div>
+        <div class="fc-desc">Feature-level SHAP analysis reveals exactly why the AI made each clinical decision with interactive Plotly charts.</div>
+    </div>
+    <div class="feature-card">
+        <div class="fc-icon">⚙️</div>
+        <div class="fc-title">C-Code Export</div>
+        <div class="fc-desc">Transpile any model to raw C headers with INT8 quantization simulation for ESP32 and Arduino flash deployment.</div>
+    </div>
+    <div class="feature-card">
+        <div class="fc-icon">🔄</div>
+        <div class="fc-title">MLOps Pipeline</div>
+        <div class="fc-desc">Dynamic dataset upload and live ensemble retraining without downtime. Full model hot-swap on the fly.</div>
+    </div>
+</div>
+""", unsafe_allow_html=True)
+
+st.markdown("<br>", unsafe_allow_html=True)
+st.caption("Use the sidebar to navigate between Prediction, Analytics, Edge Deployment, Patient History, MLOps, and About.")

frontend/pages/1_Predict_Dashboard.py

@@ -0,0 +1,324 @@
+import streamlit as st
+import requests
+import os
+import plotly.graph_objects as go
+
+st.set_page_config(page_title="Predict Patient Health", page_icon="🩺", layout="wide")
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+st.title("🩺 Patient Edge Prediction Simulation")
+
+st.markdown("""
+<style>
+div[data-testid="stMetricValue"] {
+    font-size: 1.5rem;
+}
+.red-card {
+    background: rgba(255, 50, 50, 0.15);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    padding: 20px;
+    border-radius: 15px;
+    border: 1px solid rgba(255, 50, 50, 0.3);
+    box-shadow: 0 8px 32px 0 rgba(255, 50, 50, 0.2);
+}
+.green-card {
+    background: rgba(50, 255, 100, 0.15);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    padding: 20px;
+    border-radius: 15px;
+    border: 1px solid rgba(50, 255, 100, 0.3);
+    box-shadow: 0 8px 32px 0 rgba(50, 255, 100, 0.2);
+}
+.amber-card {
+    background: rgba(255, 180, 50, 0.15);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    padding: 20px;
+    border-radius: 15px;
+    border: 1px solid rgba(255, 180, 50, 0.3);
+    box-shadow: 0 8px 32px 0 rgba(255, 180, 50, 0.2);
+}
+.node-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    margin: 4px 0;
+    border-radius: 8px;
+    background: rgba(255,255,255,0.04);
+    border-left: 3px solid;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# Persist random defaults using session_state keys
+import random
+if "sl_hr" not in st.session_state:
+    st.session_state.sl_hr = float(random.randint(60, 110))
+    st.session_state.sl_spo2 = float(random.randint(85, 99))
+    st.session_state.sl_sys = float(random.randint(110, 140))
+    st.session_state.sl_dia = float(random.randint(70, 90))
+    st.session_state.sl_tmp = round(random.uniform(36.0, 38.0), 1)
+
+col1, col2 = st.columns(2)
+with col1:
+    hr = st.slider("Heart Rate (bpm)", 40.0, 200.0, key="sl_hr")
+    spo2 = st.slider("SpO2 Level (%)", 70.0, 100.0, key="sl_spo2")
+    sys_bp = st.slider("Systolic BP (mmHg)", 70.0, 200.0, key="sl_sys")
+
+with col2:
+    dia_bp = st.slider("Diastolic BP (mmHg)", 40.0, 130.0, key="sl_dia")
+    tmp = st.slider("Body Temp (°C)", 34.0, 42.0, key="sl_tmp")
+    fall = st.selectbox("Fall Detection", ["No", "Yes"])
+
+MODEL_DISPLAY = {
+    "knn": "K-Nearest Neighbors",
+    "svm": "Support Vector Machine",
+    "logreg": "Logistic Regression",
+    "rf": "Random Forest",
+    "small_nn": "Neural Network (MLP)"
+}
+
+DISEASE_COLORS = {
+    "Healthy": "#00cc96",
+    "Asthma": "#ab63fa",
+    "Diabetes Mellitus": "#ffa15a",
+    "Heart Disease": "#ef553b",
+    "Hypertension": "#636efa"
+}
+
+def render_results(data):
+    st.markdown("---")
+    label = data['prediction_label']
+    conf = data['probability'] * 100
+    
+
+    res_col1, res_col2 = st.columns([1, 1])
+    
+    with res_col1:
+        st.markdown("#### 🏥 Diagnosis Status")
+        card_color = DISEASE_COLORS.get(label, "#636efa")
+        is_healthy = label == "Healthy"
+        card_class = "green-card" if is_healthy else "red-card" if label == "Heart Disease" else "amber-card"
+        status_text = f"Status: {label}" if is_healthy else f"Status: {label} (At Risk)"
+        st.markdown(f'<div class="{card_class}"><h3>{status_text}</h3></div>', unsafe_allow_html=True)
+        st.progress(int(conf))
+        st.write(f"**Ensemble Confidence:** {conf:.1f}%")
+    
+    with res_col2:
+        st.markdown("#### 🧠 Individual Node Consensus & Weights")
+        for model_key, pred in data['model_outputs'].items():
+            display_name = MODEL_DISPLAY.get(model_key, model_key.upper())
+            wgt = data.get('weights', {}).get(model_key, 0)
+            prob = data.get('model_probs', {}).get(model_key, 0) * 100
+            pred_color = DISEASE_COLORS.get(pred, "#636efa")
+            border_color = "#00cc96" if pred == "Healthy" else "#ef553b"
+            st.markdown(
+                f'<div class="node-row" style="border-left-color: {border_color};">'
+                f'<span><strong>{display_name}</strong> (w={wgt:.2f})</span>'
+                f'<span style="color: {pred_color}; font-weight: bold;">{pred} ({prob:.0f}%)</span>'
+                f'</div>',
+                unsafe_allow_html=True
+            )
+    
+    # SHAP Explainability Section
+    with st.expander("🔍 Explain AI Prediction (SHAP Explainability)", expanded=False):
+        st.markdown("##### How each vital sign influenced the AI's decision:")
+        try:
+            url_exp = f"{API_URL.rstrip('/')}/explain"
+            exp_resp = requests.post(url_exp, json=payload, timeout=30)
+            if exp_resp.status_code == 200:
+                exp_data = exp_resp.json()
+                if "error" in exp_data:
+                    st.warning(exp_data["error"])
+                else:
+                    shap_vals = exp_data["shap_values"]
+                    feat_names = exp_data["feature_names"]
+                    
+                    # Clean up feature names for display
+                    clean_names = []
+                    for f in feat_names:
+                        f = f.replace(" (bpm)", "").replace(" (%)", "").replace(" (mmHg)", "").replace(" (°C)", "")
+                        clean_names.append(f)
+                    
+                    # Sort by absolute value for visual impact
+                    sorted_pairs = sorted(zip(clean_names, shap_vals), key=lambda x: abs(x[1]))
+                    s_names, s_vals = zip(*sorted_pairs)
+                    
+                    colors = ['#ef553b' if v > 0 else '#00cc96' for v in s_vals]
+                    
+                    fig = go.Figure(go.Bar(
+                        x=list(s_vals),
+                        y=list(s_names),
+                        orientation='h',
+                        marker=dict(
+                            color=colors,
+                            line=dict(width=1, color='rgba(255,255,255,0.2)')
+                        ),
+                        text=[f"{v:+.4f}" for v in s_vals],
+                        textposition='outside',
+                        textfont=dict(color='white', size=11)
+                    ))
+                    fig.update_layout(
+                        title=dict(text=f"Feature Impact on '{label}' Prediction", font=dict(color='white', size=16)),
+                        xaxis_title="SHAP Value (←Reduces Risk | Increases Risk→)",
+                        yaxis_title="",
+                        template="plotly_dark",
+                        height=350,
+                        margin=dict(l=10, r=80, t=50, b=50),
+                        paper_bgcolor='rgba(0,0,0,0)',
+                        plot_bgcolor='rgba(0,0,0,0)',
+                        xaxis=dict(zeroline=True, zerolinecolor='rgba(255,255,255,0.3)', zerolinewidth=2, gridcolor='rgba(255,255,255,0.07)'),
+                        yaxis=dict(gridcolor='rgba(255,255,255,0.07)')
+                    )
+                    
+                    st.plotly_chart(fig, use_container_width=True)
+                    
+                    # ──── Detailed Key Insights Panel ────
+                    st.markdown("---")
+                    st.markdown("##### 📊 Key Insights — Clinical Explainability Report")
+
+                    # Sort features by absolute SHAP impact
+                    paired = list(zip(feat_names, shap_vals))
+                    paired_sorted = sorted(paired, key=lambda x: abs(x[1]), reverse=True)
+                    risk_factors = [(n, v) for n, v in paired_sorted if v > 0.001]
+                    protective = [(n, v) for n, v in paired_sorted if v < -0.001]
+                    total_push = sum(v for _, v in paired)
+                    risk_direction = "toward a clinical condition" if total_push > 0 else "toward a healthy classification"
+
+                    ins_c1, ins_c2 = st.columns(2)
+
+                    with ins_c1:
+                        st.markdown("**🔴 Risk-Increasing Factors**")
+                        if risk_factors:
+                            for name, val in risk_factors:
+                                pct = abs(val) / max(sum(abs(v) for _, v in paired), 1e-9) * 100
+                                st.markdown(
+                                    f'<div style="background:rgba(239,85,59,0.08);border-left:3px solid #ef553b;'
+                                    f'padding:8px 12px;border-radius:6px;margin:4px 0;">'
+                                    f'<strong>{name}</strong><br>'
+                                    f'<span style="color:#ef553b;">SHAP +{val:.4f}</span> '
+                                    f'<span style="color:rgba(255,255,255,0.4);">({pct:.0f}% of total impact)</span>'
+                                    f'</div>',
+                                    unsafe_allow_html=True
+                                )
+                        else:
+                            st.caption("No features significantly increasing risk.")
+
+                    with ins_c2:
+                        st.markdown("**🟢 Protective Factors**")
+                        if protective:
+                            for name, val in protective:
+                                pct = abs(val) / max(sum(abs(v) for _, v in paired), 1e-9) * 100
+                                st.markdown(
+                                    f'<div style="background:rgba(0,204,150,0.08);border-left:3px solid #00cc96;'
+                                    f'padding:8px 12px;border-radius:6px;margin:4px 0;">'
+                                    f'<strong>{name}</strong><br>'
+                                    f'<span style="color:#00cc96;">SHAP {val:.4f}</span> '
+                                    f'<span style="color:rgba(255,255,255,0.4);">({pct:.0f}% of total impact)</span>'
+                                    f'</div>',
+                                    unsafe_allow_html=True
+                                )
+                        else:
+                            st.caption("No features significantly reducing risk.")
+
+                    # Overall clinical summary
+                    top_feat, top_val = paired_sorted[0]
+                    second_feat = paired_sorted[1][0] if len(paired_sorted) > 1 else None
+                    top_dir = "increasing" if top_val > 0 else "decreasing"
+
+                    summary_parts = [
+                        f"The ensemble model's decision was primarily driven by **{top_feat}** "
+                        f"(SHAP {top_val:+.4f}), which had the strongest influence in {top_dir} the risk score.",
+                    ]
+                    if second_feat:
+                        s_val = paired_sorted[1][1]
+                        s_dir = "increasing" if s_val > 0 else "decreasing"
+                        summary_parts.append(
+                            f"The second most influential factor was **{second_feat}** "
+                            f"(SHAP {s_val:+.4f}), {s_dir} risk."
+                        )
+                    summary_parts.append(
+                        f"Overall, the net SHAP push ({total_push:+.4f}) points **{risk_direction}** "
+                        f"for the given vitals."
+                    )
+                    if risk_factors and protective:
+                        summary_parts.append(
+                            f"The model identified {len(risk_factors)} risk-increasing and "
+                            f"{len(protective)} protective factor(s), indicating a mixed clinical profile "
+                            f"that warrants attention to the dominant contributors."
+                        )
+
+                    st.info("💡 **Clinical Interpretation:**\n\n" + " ".join(summary_parts))
+        except Exception as e:
+            st.error(f"Failed to fetch explanation: {e}")
+
+
+if st.button("Query Edge AI Ensemble", type="primary"):
+    payload = {
+        "Heart_Rate": hr,
+        "SpO2_Level": spo2,
+        "Systolic_BP": sys_bp,
+        "Diastolic_BP": dia_bp,
+        "Body_Temp": tmp,
+        "Fall_Detection": fall
+    }
+    
+    with st.spinner("Processing through TinyML Nodes..."):
+        try:
+            url = f"{API_URL.rstrip('/')}/predict"
+            resp = requests.post(url, json=payload, timeout=30)
+            if resp.status_code == 200:
+                data = resp.json()
+                if "error" in data:
+                    st.error(data["error"])
+                else:
+                    render_results(data)
+            else:
+                st.error(f"API returned an error: {resp.status_code} — {resp.text[:500]}")
+        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as conn_err:
+            try:
+                import sys
+                import os
+                import pandas as pd
+                
+                backend_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../backend'))
+                if backend_path not in sys.path:
+                    sys.path.append(backend_path)
+                    
+                from ensemble import EnsembleModel
+                from preprocessing import preprocess_data
+                
+                df_simulate = pd.DataFrame([{
+                    "Heart Rate (bpm)": payload["Heart_Rate"],
+                    "SpO2 Level (%)": payload["SpO2_Level"],
+                    "Systolic Blood Pressure (mmHg)": payload["Systolic_BP"],
+                    "Diastolic Blood Pressure (mmHg)": payload["Diastolic_BP"],
+                    "Body Temperature (°C)": payload["Body_Temp"],
+                    "Fall Detection": payload["Fall_Detection"]
+                }])
+                
+                X_proc, _ = preprocess_data(df_simulate, is_training=False)
+                eng = EnsembleModel()
+                final_pred, conf, ind_preds, ind_probs, weights = eng.predict(X_proc)
+                
+                data = {
+                    "prediction": 0 if final_pred == "Healthy" else 1,
+                    "prediction_label": final_pred,
+                    "probability": float(conf),
+                    "model_outputs": ind_preds,
+                    "model_probs": {k: float(max(v)) for k, v in ind_probs.items()},
+                    "weights": weights
+                }
+                
+                st.markdown("---")
+                st.info("☁️ **Cloud Mode (Fallback)**: Processed via Monolithic Native Architecture.")
+                render_results(data)
+                        
+            except Exception as inner_e:
+                st.error(f"Monolithic execution failed: {inner_e}")
+                
+        except Exception as e:
+            st.error(f"Failed to process Request context: {e}")

frontend/pages/2_Data_Analytics.py

@@ -0,0 +1,171 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import numpy as np
+import os
+import requests
+
+st.set_page_config(page_title="Advanced Analytics", page_icon="📊", layout="wide")
+st.title("📊 Population Analytics Deep Dive")
+
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+@st.cache_data(ttl=3600)
+def load_data():
+    try:
+        resp = requests.get(f"{API_URL}/dataset", timeout=30)
+        if resp.status_code == 200:
+            data = resp.json()
+            if isinstance(data, list):
+                return pd.DataFrame(data)
+            st.error(f"Backend Error: {data.get('error', 'Unknown')}")
+    except Exception as e:
+        st.error(f"Failed to connect to backend: {e}")
+    return pd.DataFrame()
+
+DISEASE_COLORS = {
+    "Healthy": "#00cc96",
+    "Asthma": "#ab63fa",
+    "Diabetes Mellitus": "#ffa15a",
+    "Heart Disease": "#ef553b",
+    "Hypertension": "#636efa"
+}
+
+full_df = load_data()
+
+if full_df.empty:
+    st.warning("Warning: Dataset not found or backend unreachable. Connect to the API to view analytics.")
+else:
+    df = full_df
+    st.success(f"Loaded **{len(full_df):,}** patient records from backend.")
+    
+    # ... rest of the file stays same ...
+    st.markdown("### 🫀 Vital Signs Distribution by Condition")
+    vitals = ["Heart Rate (bpm)", "SpO2 Level (%)", "Systolic Blood Pressure (mmHg)", "Diastolic Blood Pressure (mmHg)", "Body Temperature (°C)"]
+    selected_vital = st.selectbox("Select Vital Sign", vitals)
+    
+    fig_box = px.box(
+        df, x="Predicted Disease", y=selected_vital,
+        color="Predicted Disease",
+        color_discrete_map=DISEASE_COLORS,
+        title=f"{selected_vital} Distribution Across Conditions",
+        template="plotly_dark",
+        points="outliers"
+    )
+    fig_box.update_layout(
+        paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+        xaxis_title="Condition", yaxis_title=selected_vital,
+        showlegend=False, height=420
+    )
+    st.plotly_chart(fig_box, use_container_width=True)
+    
+    st.markdown("---")
+    
+    c1, c2 = st.columns(2)
+    with c1:
+        st.markdown("##### Heart Rate vs SpO2 (Scatter Matrix)")
+        fig_scatter = px.scatter(
+            df, x="Heart Rate (bpm)", y="SpO2 Level (%)",
+            color="Predicted Disease",
+            color_discrete_map=DISEASE_COLORS,
+            opacity=0.4, size_max=6,
+            title="Heart Rate vs SpO2 Levels",
+            template="plotly_dark",
+            marginal_x="histogram",
+            marginal_y="histogram"
+        )
+        fig_scatter.update_layout(
+            paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+            height=450, legend=dict(orientation="h", yanchor="bottom", y=-0.35)
+        )
+        st.plotly_chart(fig_scatter, use_container_width=True)
+        
+    with c2:
+        st.markdown("##### Temperature by Condition (Violin Plot)")
+        fig_violin = px.violin(
+            df, x="Predicted Disease", y="Body Temperature (°C)",
+            color="Predicted Disease",
+            color_discrete_map=DISEASE_COLORS,
+            box=True, points=False,
+            title="Body Temperature Distribution",
+            template="plotly_dark"
+        )
+        fig_violin.update_layout(
+            paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+            height=450, showlegend=False, xaxis_title="Condition", yaxis_title="Temperature (°C)"
+        )
+        st.plotly_chart(fig_violin, use_container_width=True)
+    
+    st.markdown("---")
+    
+    c3, c4 = st.columns(2)
+    with c3:
+        st.markdown("##### 🏥 Disease Distribution (Population Count)")
+        counts = df["Predicted Disease"].value_counts().reset_index()
+        counts.columns = ["Condition", "Patient Count"]
+        fig_bar = px.bar(
+            counts, x="Condition", y="Patient Count",
+            color="Condition",
+            color_discrete_map=DISEASE_COLORS,
+            title="Patient Count per Condition",
+            template="plotly_dark",
+            text="Patient Count"
+        )
+        fig_bar.update_traces(textposition='outside')
+        fig_bar.update_layout(
+            paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+            height=420, showlegend=False
+        )
+        st.plotly_chart(fig_bar, use_container_width=True)
+    
+    with c4:
+        st.markdown("##### 🩸 Blood Pressure Density (Systolic vs Diastolic)")
+        fig_density = px.density_heatmap(
+            df, x="Systolic Blood Pressure (mmHg)", y="Diastolic Blood Pressure (mmHg)",
+            color_continuous_scale="Turbo",
+            title="Blood Pressure Population Heatmap",
+            template="plotly_dark",
+            nbinsx=30, nbinsy=30
+        )
+        fig_density.update_layout(
+            paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)',
+            height=420
+        )
+        st.plotly_chart(fig_density, use_container_width=True)
+    
+    st.markdown("---")
+    st.markdown("### 📈 Patient-Specific Real-Time Monitoring")
+    p_id = st.selectbox("Select Patient ID to view live telemetry:", df['Patient Number'].unique()[:50])
+    if p_id:
+        patient_data = df[df['Patient Number'] == p_id].iloc[0]
+        disease = patient_data['Predicted Disease']
+        d_color = DISEASE_COLORS.get(disease, "#636efa")
+        st.markdown(f"**Patient Condition:** <span style='color:{d_color}; font-weight:bold'>{disease}</span>", unsafe_allow_html=True)
+        
+        periods = 60
+        dates = pd.date_range(end=pd.Timestamp.now(), periods=periods, freq='25s')
+        base_hr = patient_data['Heart Rate (bpm)']
+        base_spo2 = patient_data['SpO2 Level (%)']
+        base_temp = patient_data['Body Temperature (°C)']
+        sim_hr = base_hr + np.random.normal(0, 1.2, periods).cumsum()
+        sim_spo2 = np.clip(base_spo2 + np.random.normal(0, 0.3, periods).cumsum(), 85, 100)
+        sim_temp = base_temp + np.random.normal(0, 0.05, periods).cumsum()
+        
+        tc1, tc2, tc3 = st.columns(3)
+        with tc1:
+            fig_hr = go.Figure(go.Scatter(x=dates, y=sim_hr, mode='lines+markers', line=dict(color='#00f2fe', width=2), marker=dict(size=3), name="Heart Rate"))
+            fig_hr.update_layout(title="Heart Rate (bpm)", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', height=280, margin=dict(l=10, r=10, t=40, b=40))
+            st.plotly_chart(fig_hr, use_container_width=True)
+        with tc2:
+            fig_sp = go.Figure(go.Scatter(x=dates, y=sim_spo2, mode='lines+markers', line=dict(color='#00cc96', width=2), marker=dict(size=3), name="SpO2"))
+            fig_sp.update_layout(title="SpO2 Level (%)", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', height=280, margin=dict(l=10, r=10, t=40, b=40))
+            st.plotly_chart(fig_sp, use_container_width=True)
+        with tc3:
+            fig_tp = go.Figure(go.Scatter(x=dates, y=sim_temp, mode='lines+markers', line=dict(color='#ffa15a', width=2), marker=dict(size=3), name="Temperature"))
+            fig_tp.update_layout(title="Body Temperature (°C)", template="plotly_dark", paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', height=280, margin=dict(l=10, r=10, t=40, b=40))
+            st.plotly_chart(fig_tp, use_container_width=True)
+        
+    st.markdown("---")
+    st.markdown("### 📋 Raw Patient Data")
+    st.dataframe(df, use_container_width=True, height=350)

frontend/pages/3_Edge_Deployment.py

@@ -0,0 +1,87 @@
+import streamlit as st
+import requests
+import os
+
+st.set_page_config(page_title="TinyML Edge Deploy", page_icon="⚙️", layout="wide")
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+st.title("⚙️ TinyML C-Code Exporter")
+st.markdown("Export trained models directly to raw C code for compilation on embedded devices (Arduino, ESP32).")
+
+model_mapping = {
+    "Random Forest": "rf",
+    "Logistic Regression": "logreg",
+    "K-Nearest Neighbors": "knn",
+    "Support Vector Machine": "svm",
+    "Neural Network (MLP)": "small_nn"
+}
+
+hw_mapping = {
+    "ESP32 (240 MHz, 520KB SRAM)": {"clock": 240, "ram": 520, "arch": "Xtensa LX6"},
+    "Arduino Nano 33 BLE Sense (64 MHz, 256KB SRAM)": {"clock": 64, "ram": 256, "arch": "Cortex-M4F"},
+    "STM32 Nucleo (84 MHz, 96KB SRAM)": {"clock": 84, "ram": 96, "arch": "Cortex-M4"},
+    "Raspberry Pi Pico (133 MHz, 264KB SRAM)": {"clock": 133, "ram": 264, "arch": "Cortex-M0+"}
+}
+
+col_m, col_h = st.columns(2)
+with col_m:
+    model_display_name = st.selectbox("Select Model to Export", list(model_mapping.keys()))
+    model_choice = model_mapping[model_display_name]
+with col_h:
+    hw_display_name = st.selectbox("Select Target Hardware Profile", list(hw_mapping.keys()))
+    hw_choice = hw_mapping[hw_display_name]
+
+st.markdown("---")
+st.markdown("##### ⚡ TinyML Optimization Settings")
+opt_c1, opt_c2 = st.columns(2)
+with opt_c1:
+    apply_quantization = st.checkbox("Apply INT8 Weight Quantization", value=True)
+with opt_c2:
+    strip_comments = st.checkbox("Strip Comments for Minimal Flash Size", value=False)
+
+if st.button("Generate C Code", type="primary"):
+    with st.spinner("Transpiling model to C..."):
+        try:
+            resp = requests.get(f"{API_URL}/export_tinyml", params={"model_name": model_choice, "quantize": apply_quantization}, timeout=15)
+            if resp.status_code == 200:
+                data = resp.json()
+                if "error" in data:
+                    st.error(data["error"])
+                else:
+                    c_code = data["code"]
+                    
+                    if strip_comments:
+                        import re
+                        c_code = re.sub(r'/\*.*?\*/', '', c_code, flags=re.DOTALL)
+                        c_code = re.sub(r'//.*', '', c_code)
+                        c_code = re.sub(r'\n\s*\n', '\n', c_code)
+                    
+                    st.success(f"✅ Transpilation successful for **{model_display_name}**!")
+                    
+                    # Show stats
+                    s1, s2, s3, s4 = st.columns(4)
+                    code_len = len(c_code)
+                    est_flash = code_len // (4 if apply_quantization else 1)
+
+                    # Simple heuristic for estimated inference time
+                    base_ops = {"rf": 500, "logreg": 20, "knn": 2000, "svm": 100, "small_nn": 800}[model_choice]
+                    ops_multiplier = 0.5 if apply_quantization else 1.0
+                    est_latency_us = int((base_ops * ops_multiplier) / (hw_choice["clock"] / 10.0))
+
+                    s1.metric("Target Architecture", hw_choice["arch"])
+                    s2.metric("Est. Code Flash", f"{est_flash:,} Bytes")
+                    s3.metric("Precision", "INT8 (8-bit)" if apply_quantization else "FP32 (64-bit)")
+                    s4.metric("Est. Inference Latency", f"~{max(1, est_latency_us)} µs")
+
+                    st.download_button(
+                        label="⬇️ Download tinyml_model.h",
+                        data=c_code,
+                        file_name=f"tinyml_{model_choice}.h",
+                        mime="text/plain"
+                    )
+                    with st.expander("Preview C Code", expanded=True):
+                        st.code(c_code, language="c")
+            else:
+                st.error("API returned an error code.")
+        except Exception as e:
+            st.error(f"Connection failed: {e}")

frontend/pages/4_Patient_History.py

@@ -0,0 +1,65 @@
+import streamlit as st
+import requests
+import pandas as pd
+import os
+
+st.set_page_config(page_title="Patient History", page_icon="🗄️", layout="wide")
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+st.title("🗄️ Patient Prediction History")
+st.markdown("Live database of all patient predictions and vitals logged by the system. Auto-refreshes every 5 seconds.")
+
+DISEASE_COLORS = {
+    "Healthy":           "background-color: rgba(0, 204, 150, 0.15); color: #00cc96;",
+    "Asthma":            "background-color: rgba(171, 99, 250, 0.15); color: #ab63fa;",
+    "Diabetes Mellitus": "background-color: rgba(255, 161, 90, 0.15); color: #ffa15a;",
+    "Heart Disease":     "background-color: rgba(239, 85, 59, 0.15); color: #ef553b;",
+    "Hypertension":      "background-color: rgba(99, 110, 250, 0.15); color: #636efa;",
+}
+
+COLUMN_RENAME = {
+    "id": "ID",
+    "timestamp": "Timestamp",
+    "prediction_label": "Diagnosis",
+    "confidence": "Confidence",
+    "heart_rate": "Heart Rate",
+    "spo2": "SpO2 %",
+    "sys_bp": "Sys BP",
+    "dia_bp": "Dia BP",
+    "temp": "Temp °C",
+    "fall_detection": "Fall"
+}
+
+@st.fragment(run_every="5s")
+def live_history_table():
+    try:
+        resp = requests.get(f"{API_URL}/history", timeout=5)
+        if resp.status_code == 200:
+            history_data = resp.json()
+            if not history_data:
+                st.info("No prediction history found. Go make some predictions first!")
+                return
+            
+            df = pd.DataFrame(history_data)
+            cols = ['id', 'timestamp', 'prediction_label', 'confidence', 'heart_rate', 'spo2', 'sys_bp', 'dia_bp', 'temp', 'fall_detection']
+            df = df[[c for c in cols if c in df.columns]]
+            df.rename(columns=COLUMN_RENAME, inplace=True)
+            
+            if "Confidence" in df.columns:
+                df["Confidence"] = df["Confidence"].apply(lambda x: f"{x*100:.1f}%" if x <= 1 else f"{x:.1f}%")
+            
+            def color_by_diagnosis(row):
+                diagnosis = row.get("Diagnosis", "")
+                style_str = DISEASE_COLORS.get(diagnosis, "")
+                return [style_str] * len(row)
+            
+            styled = df.style.apply(color_by_diagnosis, axis=1)
+            
+            st.dataframe(styled, width="stretch", height=600)
+            st.caption(f"Showing {len(df)} records. Auto-refreshing every 5s.")
+        else:
+            st.error("API Error")
+    except Exception as e:
+        st.error(f"Failed to fetch history: {e}")
+
+live_history_table()

frontend/pages/5_MLOps_Settings.py

@@ -0,0 +1,30 @@
+import streamlit as st
+import requests
+import os
+
+st.set_page_config(page_title="MLOps Settings", page_icon="🔄", layout="wide")
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+st.title("🔄 MLOps & Retraining")
+st.markdown("Dynamically update the TinyML ensemble models by providing a new dataset.")
+
+st.info("Upload a CSV file with the standard clinical schema to retrain all models on the fly.")
+
+uploaded_file = st.file_uploader("Upload New Patient Dataset (CSV)", type="csv")
+
+if uploaded_file is not None:
+    if st.button("Start Retraining Pipeline"):
+        with st.spinner("Uploading and retraining ensemble... This may take a minute."):
+            try:
+                files = {"file": (uploaded_file.name, uploaded_file.getvalue(), "text/csv")}
+                resp = requests.post(f"{API_URL}/retrain", files=files, timeout=120)
+                if resp.status_code == 200:
+                    data = resp.json()
+                    if "error" in data:
+                        st.error(f"Retraining failed: {data['error']}")
+                    else:
+                        st.success(data.get("message", "Success!"))
+                else:
+                    st.error("API returned an error.")
+            except Exception as e:
+                st.error(f"Connection failed: {e}")

frontend/pages/6_About.py

@@ -0,0 +1,124 @@
+import streamlit as st
+import graphviz
+
+st.set_page_config(page_title="About Project", page_icon="ℹ️", layout="wide")
+
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap');
+html, body, [class*="css"] { font-family: 'Inter', sans-serif; }
+
+.tech-badge {
+    display: inline-block; padding: 4px 12px; margin: 0 6px 8px 0;
+    border-radius: 20px; font-size: 0.82rem; font-weight: 600;
+    background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.15);
+    color: #e0e0e0; transition: all 0.2s ease;
+}
+.tech-badge:hover { 
+    background: rgba(0, 242, 254, 0.1); 
+    border-color: #00f2fe; color: #00f2fe; 
+    transform: translateY(-1px);
+}
+.live-link {
+    text-decoration: none; font-weight: 500; color: #00f2fe;
+}
+.live-link:hover { text-decoration: underline; }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("ℹ️ About the Platform")
+
+st.markdown("""
+This platform is a prototype of an end-to-end Machine Learning pipeline specifically designed to operate natively on resource-constrained embedded edge hardware (**TinyML**), targeting microcontrollers such as the **ESP32** or **ARM Cortex-M** architectures.
+
+**Live Environments:**
+* 🖥️ **Frontend Suite:** <a href="https://tinyml-heart-health-monitoring-dashboard-8xqogy2hibtlayt7popvs.streamlit.app/" target="_blank" class="live-link">Streamlit Cloud Deployment</a>
+* ⚙️ **Backend Hub:** <a href="https://huggingface.co/spaces/IDKHowToCodeFr/tinyml-backend" target="_blank" class="live-link">Hugging Face Spaces API</a>
+
+<div style="margin-top: 15px;">
+    <span class="tech-badge">Python 3.9+</span>
+    <span class="tech-badge">FastAPI</span>
+    <span class="tech-badge">Streamlit</span>
+    <span class="tech-badge">Scikit-Learn</span>
+    <span class="tech-badge">SHAP</span>
+    <span class="tech-badge">Docker</span>
+    <span class="tech-badge">PyTest</span>
+</div>
+""", unsafe_allow_html=True)
+
+st.markdown("---")
+
+st.markdown("### 🏗️ System Architecture")
+# Create a Graphviz flowchart for the About page
+graph = graphviz.Digraph(node_attr={'shape': 'box', 'style': 'rounded,filled', 'fontname': 'Helvetica', 'margin': '0.2'}, graph_attr={'rankdir': 'TB', 'splines': 'ortho', 'nodesep': '0.8'})
+
+# Define UI & API nodes at the top
+graph.node('UI', '🖥️ Streamlit Frontend\nInteractive Dashboard', fillcolor='#ff4b4b', fontcolor='white', color='#a30000', penwidth='2')
+graph.node('API', '⚙️ FastAPI Backend\nRouting & API Logic', fillcolor='#009688', fontcolor='white', color='#004d40', penwidth='2')
+graph.node('DB', '🗄️ SQLite DB\nPatient History', shape='cylinder', fillcolor='#9b59b6', fontcolor='white', color='#4a235a', penwidth='2')
+
+# Core connections
+graph.edge('UI', 'API', label=' REST JSON', color='#666666', fontcolor='#666666')
+graph.edge('API', 'DB', label=' Read/Write', color='#666666', fontcolor='#666666')
+
+# Machine Learning Subgraph
+with graph.subgraph(name='cluster_ml') as ml:
+    ml.attr(label='🧠 Machine Learning & Inference Pipeline', style='dashed', color='#aaaaaa', fontcolor='#888888')
+    ml.node('ENS', 'Ensemble Engine\nSoft-Voting Aggregator', shape='diamond', fillcolor='#f2c94c', fontcolor='black', color='#b28900', penwidth='2')
+    ml.node('MODELS', 'Classifiers\n(RF, SVM, LogReg, NN, KNN)', fillcolor='#f2c94c', fontcolor='black', color='#b28900', penwidth='2')
+    ml.node('SHAP', '🔍 SHAP Explainer\nFeature Impact Analysis', fillcolor='#f2c94c', fontcolor='black', color='#b28900', penwidth='2')
+
+# Hardware Export Subgraph
+with graph.subgraph(name='cluster_edge') as edge:
+    edge.attr(label='⚡ Hardware & Edge AI Export', style='dashed', color='#aaaaaa', fontcolor='#888888')
+    edge.node('TRANS', 'C-Code Transpiler\nINT8 Quantization', fillcolor='#2d9cdb', fontcolor='white', color='#106093', penwidth='2')
+    edge.node('HEADER', 'tinyml_model.h\nOptimized Header File', shape='note', fillcolor='#2d9cdb', fontcolor='white', color='#106093', penwidth='2')
+    edge.node('MCU', '📟 ESP32 / ARM Cortex-M\nMicrocontroller Node', fillcolor='#2d9cdb', fontcolor='white', color='#106093', penwidth='2')
+
+# Map Cross-cluster edges
+graph.edge('API', 'ENS', label=' Predict', color='#333333')
+graph.edge('ENS', 'MODELS', color='#333333')
+
+graph.edge('API', 'SHAP', label=' Explain', color='#333333')
+graph.edge('SHAP', 'MODELS', style='dashed', label=' Analyzes Trees', fontcolor='#555555', color='#555555')
+
+graph.edge('API', 'TRANS', label=' Export Config', color='#333333')
+graph.edge('TRANS', 'HEADER', label=' Scale FP32 to INT8', fontcolor='#555555', color='#555555')
+graph.edge('HEADER', 'MCU', label=' Flash Firmware', color='#333333')
+
+st.graphviz_chart(graph, use_container_width=True)
+
+st.markdown("---")
+st.markdown("### ✨ Core Capabilities")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.info("""
+    **⚡ TinyML & Edge AI Optimization**\n
+    Traditional machine learning models process inference entirely in the cloud, generating heavy dependency on network transmission. This project supports **Edge AI**, converting Python-trained traditional classifiers into compiled C-code arrays for offline deployment on limited hardware.
+    We implement **INT8 Quantization**, scaling 64-bit Floating Point (`double`) coefficients down into 8-bit integers (`int8_t`). This scaling effectively shrinks memory payload by nearly 75% on microcontrollers.
+    """)
+    
+    st.success("""
+    **🤝 Ensemble Machine Learning**\n
+    The predictive core relies on an Ensemble Engine. Different constituent models (KNN, Random Forest, SVM, Small NN, Logistic Regression) independently evaluate patient input variables and compute probabilties. A Soft-Voting technique averages their confidence scores to produce an overall healthy/at-risk prediction.
+    """)
+
+with col2:
+    st.warning("""
+    **🔍 SHAP Clinical Explainability**\n
+    In the medical space, a black-box model is often untrusted. The project leverages SHapley Additive exPlanations (**SHAP**) natively connected to the Random Forest model layer. SHAP assigns absolute baseline impact scores to every incoming feature, interpreting *why* the AI predicted a specific condition and quantifying mathematically whether individual factors act as risk vectors or protective measures.
+    """)
+    
+    st.error("""
+    **🔄 Continuous Learning (MLOps)**\n
+    System robustness requires adaptability. The **MLOps settings** permit uploading newly captured CSV datasets spanning emerging patient patterns. Submitting retraining logic prompts the backend pipeline to independently spin up `Scikit-Learn` algorithms to overwrite `.pkl` binary files, seamlessly refreshing the intelligence available on the dashboard.
+    """)
+
+st.markdown("""
+<div style="text-align: center; margin-top: 40px; padding-top: 20px; border-top: 1px solid rgba(255,255,255,0.1); color: rgba(255,255,255,0.5); font-size: 0.85rem;">
+    Designed as a scalable, fully interpretable Edge-based Machine Learning architecture for modern Healthcare telemetry.<br>
+    MIT License
+</div>
+""", unsafe_allow_html=True)

frontend/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.36.0
+pandas>=2.2.2
+numpy>=1.26.4
+plotly>=5.22.0
+requests>=2.32.3
+scikit-learn>=1.5.1
+joblib>=1.4.2
+matplotlib
+graphviz>=0.20.1

requirements.txt

@@ -1,11 +1,11 @@
-fastapi
-uvicorn
-scikit-learn==1.8.0
-pandas
-numpy
-joblib
-shap
-m2cgen
-matplotlib
-python-multipart
-huggingface_hub
+# --- STREAMLIT CLOUD DEPLOYMENT REQUIREMENTS ---
+# (Merged backend + frontend libs to satisfy Streamlit Commmunity Cloud deployment)
+fastapi>=0.111.0
+uvicorn>=0.30.1
+scikit-learn>=1.5.1
+pandas>=2.2.2
+numpy>=1.26.4
+joblib>=1.4.2
+streamlit>=1.36.0
+plotly>=5.22.0
+requests>=2.32.3

run.bat

@@ -0,0 +1,18 @@
+@echo off
+echo ==============================================
+echo TinyML Dashboard Launch Sequence
+echo ==============================================
+
+echo [1/3] Installing/Verifying Dependencies...
+python -m pip install -r backend\requirements.txt
+python -m pip install -r frontend\requirements.txt
+
+echo [2/3] Spinning up FastAPI Backend...
+echo Clearing previous instances on port 8000 (if any)...
+for /f "tokens=5" %%a in ('netstat -aon ^| find ":8000" ^| find "LISTENING"') do taskkill /f /pid %%a >nul 2>&1
+start /B "TinyML Backend" cmd /c "cd backend && python -m uvicorn main:app --host 0.0.0.0 --port 8000"
+
+echo [3/3] Launching Streamlit Frontend...
+cd frontend
+python -m streamlit run Home.py
+

tests/test_backend.py

@@ -0,0 +1,27 @@
+import pytest
+from fastapi.testclient import TestClient
+import sys
+import os
+
+# Ensure backend is in path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../backend')))
+from main import app
+
+client = TestClient(app)
+
+def test_health_check():
+    """Test that the backend API is up and running."""
+    # Assuming there varies a root or health endpoint. If not, this is a placeholder.
+    response = client.get("/")
+    # Even if it's 404 because no root exists, the server responds.
+    assert response.status_code in [200, 404]
+
+def test_predict_endpoint_validation():
+    """Test that the predict endpoint rejects invalid data."""
+    payload = {
+        "Heart_Rate": "invalid_string",
+        "SpO2_Level": 98
+    }
+    response = client.post("/predict", json=payload)
+    assert response.status_code == 422 # Unprocessable Entity (Pydantic validation)
+