Upload folder using huggingface_hub

.dockerignore

@@ -3,3 +3,5 @@ __pycache__/
 *.pyc
 .pytest_cache/
 .DS_Store
+frontend/
+

Dockerfile

@@ -11,10 +11,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY backend/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy necessary directories for the backend to run
-COPY backend/ ./backend/
-COPY model/ ./model/
-COPY data/ ./data/
+# Copy all necessary files and directories
+COPY . .
 
 # Hugging Face Spaces mandates port 7860
 EXPOSE 7860

database.py

@@ -1,98 +0,0 @@
-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()

ensemble.py

@@ -1,48 +0,0 @@
-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

frontend/.streamlit/config.toml

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

frontend/Home.py

@@ -1,310 +0,0 @@
-import streamlit as st
-import requests
-import os
-import time
-import pandas as pd
-import plotly.graph_objects as go
-import numpy as np
-from datetime import timedelta
-
-API_URL = os.getenv("API_URL", "http://localhost:8000")
-if "hf.space" in os.getenv("SPACE_ID", ""):
-    # On HF Spaces, the backend might be on a subpath or the same port
-    # But for this setup, we assume it's running on localhost:8000 internally as per app.py
-    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)
-    
-    # Convert UTC timestamp to IST for display
-    # Use pandas to handle the epoch conversion and then add offset
-    ts = pd.to_datetime(t_epoch, unit='s')
-    if "hf.space" in os.getenv("SPACE_ID", ""):
-        ts = ts + timedelta(hours=5, minutes=30)
-        
-    return {"time": ts, "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

@@ -1,326 +0,0 @@
-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")
-if "hf.space" in os.getenv("SPACE_ID", ""):
-    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

@@ -1,221 +0,0 @@
-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")
-if "hf.space" in os.getenv("SPACE_ID", ""):
-    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):
-                df = pd.DataFrame(data)
-                # Normalize column names: strip whitespace and ensure common naming
-                df.columns = [c.strip() for c in df.columns]
-                # Fix common encoding issues for temperature
-                df.columns = [c.replace('°C', '°C') for c in df.columns]
-                return df
-            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.")
-    
-    # ── Safety Check for Column Names ──
-    available_cols = df.columns.tolist()
-    target_x = "Predicted Disease"
-    
-    if target_x not in available_cols:
-        # Fallback to similar name if exact match fails
-        matches = [c for c in available_cols if "Disease" in c or "Condition" in c]
-        if matches:
-            target_x = matches[0]
-        else:
-            st.error(f"Required column '{target_x}' missing from dataset. Found: {available_cols}")
-            st.stop()
-
-    st.markdown("### 🫀 Vital Signs Distribution by Condition")
-    
-    # Define possible vitals and filter by what's actually in the DF
-    vitals_all = ["Heart Rate (bpm)", "SpO2 Level (%)", "Systolic Blood Pressure (mmHg)", "Diastolic Blood Pressure (mmHg)", "Body Temperature (°C)"]
-    vitals = [v for v in vitals_all if v in available_cols]
-    
-    if not vitals:
-        st.error(f"No clinical vital sign columns found in dataset. Found: {available_cols}")
-        st.stop()
-        
-    selected_vital = st.selectbox("Select Vital Sign", vitals)
-    
-    fig_box = px.box(
-        df, x=target_x, y=selected_vital,
-        color=target_x,
-        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)")
-        # Safety check for scatter columns
-        x_scatter = "Heart Rate (bpm)" if "Heart Rate (bpm)" in available_cols else None
-        y_scatter = "SpO2 Level (%)" if "SpO2 Level (%)" in available_cols else None
-        
-        if x_scatter and y_scatter:
-            fig_scatter = px.scatter(
-                df, x=x_scatter, y=y_scatter,
-                color=target_x,
-                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)
-        else:
-            st.warning("Scatter plot unavailable: Required columns missing.")
-        
-    with c2:
-        st.markdown("##### Temperature by Condition (Violin Plot)")
-        y_violin = "Body Temperature (°C)" if "Body Temperature (°C)" in available_cols else None
-        
-        if y_violin:
-            fig_violin = px.violin(
-                df, x=target_x, y=y_violin,
-                color=target_x,
-                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)
-        else:
-            st.warning("Violin plot unavailable: Temperature column missing.")
-    
-    st.markdown("---")
-    
-    c3, c4 = st.columns(2)
-    with c3:
-        st.markdown("##### 🏥 Disease Distribution (Population Count)")
-        counts = df[target_x].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)")
-        x_heat = "Systolic Blood Pressure (mmHg)" if "Systolic Blood Pressure (mmHg)" in available_cols else None
-        y_heat = "Diastolic Blood Pressure (mmHg)" if "Diastolic Blood Pressure (mmHg)" in available_cols else None
-        
-        if x_heat and y_heat:
-            fig_density = px.density_heatmap(
-                df, x=x_heat, y=y_heat,
-                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)
-        else:
-            st.warning("Density heatmap unavailable: Blood Pressure columns missing.")
-    
-    st.markdown("---")
-    st.markdown("### 📈 Patient-Specific Real-Time Monitoring")
-    # Use Patient Number if available
-    id_col = "Patient Number" if "Patient Number" in available_cols else available_cols[0]
-    p_id = st.selectbox("Select Patient ID to view live telemetry:", df[id_col].unique()[:50])
-    
-    if p_id:
-        patient_data = df[df[id_col] == p_id].iloc[0]
-        disease = patient_data[target_x]
-        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')
-        
-        # Safe access for real-time emulation
-        base_hr = patient_data.get('Heart Rate (bpm)', 75)
-        base_spo2 = patient_data.get('SpO2 Level (%)', 98)
-        base_temp = patient_data.get('Body Temperature (°C)', 37.0)
-        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

@@ -1,87 +0,0 @@
-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

@@ -1,79 +0,0 @@
-import streamlit as st
-import requests
-import pandas as pd
-import os
-from datetime import datetime, timedelta
-
-st.set_page_config(page_title="Patient History", page_icon="🗄️", layout="wide")
-API_URL = os.getenv("API_URL", "http://localhost:8000")
-if "hf.space" in os.getenv("SPACE_ID", ""):
-    API_URL = "http://localhost:8000"
-
-st.title("🗄️ Patient Prediction History")
-st.markdown("Live database of all patient predictions and vitals logged by the system. Times shown in **IST (UTC+5:30)**.")
-
-def convert_to_ist(utc_time_str):
-    try:
-        utc_dt = datetime.strptime(utc_time_str, "%Y-%m-%d %H:%M:%S")
-        ist_dt = utc_dt + timedelta(hours=5, minutes=30)
-        return ist_dt.strftime("%Y-%m-%d %H:%M:%S")
-    except:
-        return utc_time_str
-
-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)
-            if "timestamp" in df.columns:
-                df["timestamp"] = df["timestamp"].apply(convert_to_ist)
-            
-            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

@@ -1,48 +0,0 @@
-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")
-if "hf.space" in os.getenv("SPACE_ID", ""):
-    API_URL = "http://localhost:8000"
-
-st.title("🔄 MLOps & Retraining")
-st.markdown("Dynamically update the TinyML ensemble models by providing a new dataset. The system uses an **append-only** strategy to maintain data integrity.")
-
-with st.expander("📊 Data Submission Guide (Required Schema)", expanded=True):
-    st.markdown("""
-    To ensure the retraining pipeline succeeds, your CSV **must** include the following columns (case-sensitive):
-    
-    1.  **Patient Number**: Unique identifier for the patient.
-    2.  **Heart Rate (bpm)**: Numeric value.
-    3.  **SpO2 Level (%)**: Numeric value.
-    4.  **Systolic Blood Pressure (mmHg)**: Numeric value.
-    5.  **Diastolic Blood Pressure (mmHg)**: Numeric value.
-    6.  **Body Temperature (°C)**: Numeric value.
-    7.  **Fall Detection**: 'Yes' or 'No'.
-    8.  **Predicted Disease**: The target label (e.g., Healthy, Heart Disease).
-    
-    *Note: If you submit a file with a different schema, the system will reject the update to prevent dashboard crashes.*
-    """)
-
-st.info("💡 **Safety Logic:** New data will be validated and appended to the existing dataset. The original records are always preserved.")
-
-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

@@ -1,196 +0,0 @@
-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@300;400;500;600;700;800&display=swap');
-
-html, body, [class*="css"] { 
-    font-family: 'Inter', sans-serif; 
-    color: #FAFAFA;
-}
-
-.main {
-    background-color: #0e1117;
-}
-
-h1 {
-    font-weight: 800 !important;
-    letter-spacing: -1.5px !important;
-    color: #FFFFFF !important;
-    font-size: 3.2rem !important;
-    margin-bottom: 0.8rem !important;
-}
-
-h3 {
-    font-weight: 700 !important;
-    color: #AED9E0 !important; /* Sky Blue Pastel */
-    margin-top: 2.5rem !important;
-    font-size: 2rem !important;
-    letter-spacing: -0.5px !important;
-}
-
-p, li, div {
-    font-size: 1.15rem !important;
-    line-height: 1.7 !important;
-    color: #E0E0E0 !important;
-}
-
-.tech-badge {
-    display: inline-block; 
-    padding: 8px 18px; 
-    margin: 0 10px 12px 0;
-    border-radius: 50px; 
-    font-size: 0.95rem; 
-    font-weight: 600;
-    background: rgba(174, 217, 224, 0.1); /* Sky Blue Tint */
-    border: 1px solid rgba(174, 217, 224, 0.3);
-    color: #AED9E0; 
-    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-}
-
-.tech-badge:hover { 
-    background: rgba(174, 217, 224, 0.2); 
-    border-color: #AED9E0; 
-    transform: translateY(-3px);
-    box-shadow: 0 6px 20px rgba(174, 217, 224, 0.15);
-}
-
-.live-link {
-    text-decoration: none; 
-    font-weight: 600; 
-    color: #AED9E0;
-    border-bottom: 1px dashed rgba(174, 217, 224, 0.5);
-    transition: all 0.2s ease;
-}
-
-.live-link:hover { 
-    color: #FFFFFF;
-    border-bottom: 1px solid #FFFFFF;
-}
-
-/* Enhanced Glass cards */
-div[data-testid="stExpander"], .stAlert {
-    background: rgba(255, 255, 255, 0.04) !important;
-    border: 1px solid rgba(255, 255, 255, 0.08) !important;
-    border-radius: 20px !important;
-    backdrop-filter: blur(16px) saturate(180%);
-    padding: 1.5rem !important;
-}
-
-/* Clinical Contrast for Info Blocks */
-.stAlert p, .stAlert div, .stAlert b, .stAlert strong {
-    color: #FFFFFF !important;
-    font-size: 1.15rem !important;
-}
-
-.stMarkdown {
-    margin-bottom: 1.2rem;
-}
-
-</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.3', 'fontsize': '12'}, 
-                         graph_attr={'rankdir': 'TB', 'splines': 'ortho', 'nodesep': '1.0', 'bgcolor': 'transparent', 'fontcolor': 'white'})
-
-# Define UI & API nodes at the top
-graph.node('UI', 'Streamlit Frontend\nInteractive Dashboard (IST)', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#FF4B4B', penwidth='2.5')
-graph.node('API', 'FastAPI Backend\nInternal Routing (UTC)', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#00D1FF', penwidth='2.5')
-graph.node('HUB', 'HF Hub Dataset\nCentralized History Store', shape='folder', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#FFD700', penwidth='2.5')
-graph.node('DB', 'SQLite DB\nLocal Instance Cache', shape='cylinder', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#BF5AF2', penwidth='2.5')
-
-# Core connections
-graph.edge('UI', 'API', label=' internal localhost:8000', color='#475569', fontcolor='#94A3B8')
-graph.edge('API', 'DB', label=' Read/Write', color='#475569', fontcolor='#94A3B8')
-graph.edge('API', 'HUB', label=' HfApi Sync (Persistent)', color='#475569', fontcolor='#94A3B8')
-
-# Machine Learning Subgraph
-with graph.subgraph(name='cluster_ml') as ml:
-    ml.attr(label='Machine Learning & Inference Pipeline', style='dashed', color='#334155', fontcolor='#94A3B8')
-    ml.node('ENS', 'Ensemble Engine\nSoft-Voting Aggregator', shape='diamond', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#FF9F0A', penwidth='2.5')
-    ml.node('MODELS', 'Classifiers\n(RF, SVM, LogReg, NN, KNN)', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#FF9F0A', penwidth='2.5')
-    ml.node('SHAP', 'SHAP Explainer\nFeature Impact Analysis', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#FF9F0A', penwidth='2.5')
-
-# Hardware Export Subgraph
-with graph.subgraph(name='cluster_edge') as edge:
-    edge.attr(label='Hardware & Edge AI Export', style='dashed', color='#334155', fontcolor='#94A3B8')
-    edge.node('TRANS', 'C-Code Transpiler\nINT8 Quantization', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#32D74B', penwidth='2.5')
-    edge.node('HEADER', 'tinyml_model.h\nOptimized Header File', shape='note', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#32D74B', penwidth='2.5')
-    edge.node('MCU', 'ESP32 / ARM Cortex-M\nMicrocontroller Node', fillcolor='#1c1f26', fontcolor='#FFFFFF', color='#32D74B', penwidth='2.5')
-
-# Map Cross-cluster edges
-graph.edge('API', 'ENS', label=' Predict', color='#CBD5E1', fontcolor='#CBD5E1')
-graph.edge('ENS', 'MODELS', color='#CBD5E1')
-
-graph.edge('API', 'SHAP', label=' Explain', color='#CBD5E1', fontcolor='#CBD5E1')
-graph.edge('SHAP', 'MODELS', style='dashed', label=' Analyzes Trees', fontcolor='#CBD5E1', color='#CBD5E1')
-
-graph.edge('API', 'TRANS', label=' Export Config', color='#CBD5E1', fontcolor='#CBD5E1')
-graph.edge('TRANS', 'HEADER', label=' Scale FP32 to INT8', fontcolor='#CBD5E1', color='#CBD5E1')
-graph.edge('HEADER', 'MCU', label=' Flash Firmware', color='#CBD5E1', fontcolor='#CBD5E1')
-
-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("""
-    **🔍 Data Synchronization & Localization**\n
-    To support a distributed architecture, the system centralizes its **Patient History** on the Hugging Face Hub as a persistent storage layer. 
-    The platform is fully time-zone aware: while the **Backend API** operates on a robust **UTC** standard for data integrity, the **Frontend Dashboard** automatically localizes all telemetry and history logs to **IST (Indian Standard Time, UTC+5:30)**.
-    """)
-    
-    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

@@ -1,9 +0,0 @@
-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

main.py

@@ -1,501 +0,0 @@
-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)}

models.py

@@ -1,39 +0,0 @@
-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()

preprocessing.py

@@ -1,62 +0,0 @@
-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)