Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+ENV PORT=7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

database.py

@@ -0,0 +1,66 @@
+import sqlite3
+import os
+from datetime import datetime
+
+DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'patient_history.db')
+
+def init_db():
+    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()
+
+def get_history():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('SELECT * FROM predictions ORDER BY timestamp DESC LIMIT 100')
+    rows = cursor.fetchall()
+    
+    # Get column names
+    col_names = [description[0] for description in cursor.description]
+    
+    conn.close()
+    
+    # Format as list of dicts
+    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

@@ -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

main.py

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

model/classes.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a72e398999fbcd2495f31ec5f28f07e8325e903d836d2f2fbef872d6da2785bb
+size 440

model/knn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fd25eec3d294ae23ef7fcce62dad8c695f585a149935845bdcd4771b3271e61
+size 6440614

model/label_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da67513db74567d59333258b4d1982743cfdc80e54a59feb67922e7ea1bb92a9
+size 543

model/logreg.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f065ca55b8b3017459446e339341e947635c15b9919b7e033707e261d451662f
+size 1615

model/rf.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e9d9d36ed1ae8016273c4c72d77043ea059db8e359059f29b05f40885441daa
+size 171569

model/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d084c7de7a9421241c7eda590f17b42175ca4b042162377056f45351d0bc82f4
+size 1127

model/small_nn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4aa30676f4f08388fa0bcb22823e4dfc0ef001ef834b56d0caafe6ced207c0f9
+size 22664

model/svm.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb1d7c34921c17009437b565526ed302366625bcf74a8068f8e6e2e71e2d9ce6
+size 899439

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()

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)

requirements.txt

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