Upload app.py

app.py

@@ -6,7 +6,7 @@ FastAPI application for Hugging Face Spaces deployment
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
-from typing import List, Dict
+from typing import List, Dict, Any
 import numpy as np
 import joblib
 from pathlib import Path
@@ -45,18 +45,42 @@ BACKEND_ALLOWED_DISEASES = {
 # Pydantic models
 class PatientData(BaseModel):
     """Patient biomarker data for prediction"""
-    features: List[float] = Field(
-        ...,
-        description="List of biomarker values in the correct order",
-        json_schema_extra={"example": [13.2, 165, 245, 280, 7.5, 4.8, 42, 88, 28, 33, 18, 32.5, 145, 92, 210, 7.8, 145, 38, 35, 28, 78, 1.1, 0.01, 2.8]}
-    )
+    Glucose: float
+    Cholesterol: float
+    Hemoglobin: float
+    Platelets: float
+    White_Blood_Cells: float = Field(..., alias="White Blood Cells")
+    Red_Blood_Cells: float = Field(..., alias="Red Blood Cells")
+    Hematocrit: float
+    Mean_Corpuscular_Volume: float = Field(..., alias="Mean Corpuscular Volume")
+    Mean_Corpuscular_Hemoglobin: float = Field(..., alias="Mean Corpuscular Hemoglobin")
+    Mean_Corpuscular_Hemoglobin_Concentration: float = Field(..., alias="Mean Corpuscular Hemoglobin Concentration")
+    Insulin: float
+    BMI: float
+    Systolic_Blood_Pressure: float = Field(..., alias="Systolic Blood Pressure")
+    Diastolic_Blood_Pressure: float = Field(..., alias="Diastolic Blood Pressure")
+    Triglycerides: float
+    HbA1c: float
+    LDL_Cholesterol: float = Field(..., alias="LDL Cholesterol")
+    HDL_Cholesterol: float = Field(..., alias="HDL Cholesterol")
+    ALT: float
+    AST: float
+    Heart_Rate: float = Field(..., alias="Heart Rate")
+    Creatinine: float
+    Troponin: float
+    C_reactive_Protein: float = Field(..., alias="C-reactive Protein")
+    
+    class Config:
+        populate_by_name = True
 
 
 class PredictionResponse(BaseModel):
     """Response model for disease prediction"""
-    predicted_disease: str
+    prediction: str
     confidence: float
-    top_3_predictions: List[Dict[str, float]]
+    top_5_predictions: List[Dict[str, float]]
+    raw_values: Dict[str, float]
+    model_info: Dict[str, Any]
 
 
 class HealthResponse(BaseModel):
@@ -158,17 +182,17 @@ def predict_disease(patient_features: np.ndarray):
     disease = label_encoder.inverse_transform([y_pred])[0]
     confidence = float(y_proba[y_pred])
     
-    # Get top 3 predictions
-    top_3_idx = np.argsort(y_proba)[-3:][::-1]
-    top_3 = [
+    # Get top 5 predictions
+    top_5_idx = np.argsort(y_proba)[-5:][::-1]
+    top_5 = [
         {
             "disease": label_encoder.inverse_transform([idx])[0],
-            "confidence": float(y_proba[idx])
+            "probability": float(y_proba[idx])
         }
-        for idx in top_3_idx
+        for idx in top_5_idx
     ]
     
-    return disease, confidence, top_3
+    return disease, confidence, top_5
 
 
 @app.get("/")
@@ -178,15 +202,16 @@ async def root():
         "message": "MediGuard Disease Prediction API",
         "version": "1.0.0",
         "endpoints": {
-            "health": "/health",
-            "predict": "/predict (POST)",
-            "features": "/features",
+            "health": "/api/health",
+            "predict": "/api/predict (POST)",
+            "features": "/api/features",
+            "diseases": "/api/diseases",
             "docs": "/docs"
         }
     }
 
 
-@app.get("/health", response_model=HealthResponse)
+@app.get("/api/health", response_model=HealthResponse)
 async def health_check():
     """Health check endpoint"""
     return HealthResponse(
@@ -196,7 +221,7 @@ async def health_check():
     )
 
 
-@app.get("/features", response_model=Dict[str, List[str]])
+@app.get("/api/features")
 async def get_features():
     """Get list of required features"""
     if feature_cols is None:
@@ -209,13 +234,13 @@ async def get_features():
     }
 
 
-@app.post("/predict", response_model=PredictionResponse)
+@app.post("/api/predict", response_model=PredictionResponse)
 async def predict(patient_data: PatientData):
     """
     Predict disease from patient biomarker data
     
     Args:
-        patient_data: PatientData object with list of feature values
+        patient_data: PatientData object with biomarker key-value pairs
         
     Returns:
         PredictionResponse with predicted disease and confidence
@@ -228,18 +253,34 @@ async def predict(patient_data: PatientData):
         )
     
     try:
-        # Convert to numpy array
-        features = np.array(patient_data.features, dtype=np.float32)
+        # Convert Pydantic model to dict and extract values in correct order
+        input_dict = patient_data.model_dump(by_alias=True)
+        
+        # Build features array in the order expected by feature_cols
+        features = []
+        for feature_name in feature_cols:
+            if feature_name not in input_dict:
+                raise ValueError(f"Missing feature: {feature_name}")
+            features.append(float(input_dict[feature_name]))
+        
+        features = np.array(features, dtype=np.float32)
         
         # Predict
-        disease, confidence, top_3 = predict_disease(features)
+        disease, confidence, top_5 = predict_disease(features)
         
         logger.info(f"Prediction: {disease} ({confidence*100:.2f}%)")
         
         return PredictionResponse(
-            predicted_disease=disease,
+            prediction=disease,
             confidence=confidence,
-            top_3_predictions=top_3
+            top_5_predictions=top_5,
+            raw_values=input_dict,
+            model_info={
+                "base_models": 2,  # rf_model and nn_model
+                "features_used": len(feature_cols),
+                "meta_input_shape": [1, len(label_encoder.classes_) * 2],
+                "n_classes": len(label_encoder.classes_)
+            }
         )
         
     except ValueError as e: