Upload 6 files

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,329 @@
+import pickle
+import numpy as np
+import sys
+import traceback
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+from fastapi.middleware.cors import CORSMiddleware
+
+# Global variables for model and scaler
+model = None
+scaler = None
+
+def load_model_with_fallback():
+    """Load model with multiple fallback methods"""
+    global model, scaler
+    
+    print("=" * 50)
+    print("Attempting to load model and scaler...")
+    
+    # Method 1: Try joblib first (more robust)
+    try:
+        import joblib
+        print("Trying joblib...")
+        model = joblib.load('diabetes_model.pkl')
+        scaler = joblib.load('scaler.pkl')
+        print("✓ Model and scaler loaded with joblib")
+        return True
+    except Exception as e:
+        print(f"Joblib failed: {e}")
+    
+    # Method 2: Try pickle with custom unpickler
+    try:
+        print("Trying pickle with custom unpickler...")
+        
+        class CustomUnpickler(pickle.Unpickler):
+            def find_class(self, module, name):
+                # Handle common module changes
+                if module.startswith('numpy._core'):
+                    module = module.replace('numpy._core', 'numpy.core')
+                elif module == 'numpy.core._multiarray_umath':
+                    module = 'numpy'
+                elif module == 'sklearn.tree._tree':
+                    module = 'sklearn.tree'
+                return super().find_class(module, name)
+        
+        with open('diabetes_model.pkl', 'rb') as f:
+            model = CustomUnpickler(f).load()
+        
+        with open('scaler.pkl', 'rb') as f:
+            scaler = CustomUnpickler(f).load()
+        
+        print("✓ Model and scaler loaded with custom unpickler")
+        return True
+    except Exception as e:
+        print(f"Custom unpickler failed: {e}")
+    
+    # Method 3: Try standard pickle
+    try:
+        print("Trying standard pickle...")
+        with open('diabetes_model.pkl', 'rb') as f:
+            model = pickle.load(f)
+        with open('scaler.pkl', 'rb') as f:
+            scaler = pickle.load(f)
+        print("✓ Model and scaler loaded with standard pickle")
+        return True
+    except Exception as e:
+        print(f"Standard pickle failed: {e}")
+        return False
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    print("Starting up...")
+    
+    # Load model
+    success = load_model_with_fallback()
+    if not success:
+        print("WARNING: Could not load model. Running in demo mode.")
+        print("Creating dummy model for testing...")
+        
+        # Create a simple logistic regression model for demo
+        from sklearn.linear_model import LogisticRegression
+        global model, scaler
+        
+        # Create dummy scaler
+        from sklearn.preprocessing import StandardScaler
+        scaler = StandardScaler()
+        scaler.fit(np.random.randn(10, 8))  # Fit with dummy data
+        
+        # Create dummy model
+        model = LogisticRegression()
+        X_dummy = np.random.randn(100, 8)
+        y_dummy = np.random.randint(0, 2, 100)
+        model.fit(X_dummy, y_dummy)
+        print("✓ Created demo model")
+    
+    yield
+    
+    # Shutdown (optional cleanup)
+    print("Shutting down...")
+
+app = FastAPI(
+    title="Diabetes Prediction API",
+    description="API for early diabetes prediction",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class DiabetesFeatures(BaseModel):
+    Pregnancies: float
+    Glucose: float
+    BloodPressure: float
+    SkinThickness: float
+    Insulin: float
+    BMI: float
+    DiabetesPedigreeFunction: float
+    Age: float
+
+class PredictionResponse(BaseModel):
+    prediction: int
+    probability: float
+    message: str
+    risk_level: str
+    demo_mode: bool = False
+
+@app.get("/")
+async def home():
+    demo_mode = model is None or "demo" in str(type(model)).lower()
+    return {
+        "message": "Diabetes Prediction API",
+        "status": "active",
+        "model_loaded": model is not None,
+        "scaler_loaded": scaler is not None,
+        "demo_mode": demo_mode,
+        "endpoints": {
+            "GET /": "This info",
+            "GET /health": "Health check",
+            "GET /features": "List of required features",
+            "POST /predict": "Single prediction",
+            "GET /test": "Test endpoint"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    demo_mode = model is None or "demo" in str(type(model)).lower()
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "scaler_loaded": scaler is not None,
+        "demo_mode": demo_mode
+    }
+
+@app.get("/features")
+async def get_features():
+    return {
+        "features": [
+            {"name": "Pregnancies", "type": "float", "description": "Number of times pregnant"},
+            {"name": "Glucose", "type": "float", "description": "Plasma glucose concentration"},
+            {"name": "BloodPressure", "type": "float", "description": "Diastolic blood pressure (mm Hg)"},
+            {"name": "SkinThickness", "type": "float", "description": "Triceps skin fold thickness (mm)"},
+            {"name": "Insulin", "type": "float", "description": "2-Hour serum insulin (mu U/ml)"},
+            {"name": "BMI", "type": "float", "description": "Body mass index (kg/m²)"},
+            {"name": "DiabetesPedigreeFunction", "type": "float", "description": "Diabetes pedigree function"},
+            {"name": "Age", "type": "float", "description": "Age (years)"}
+        ]
+    }
+
+@app.get("/test")
+async def test_endpoint():
+    """Simple test endpoint"""
+    demo_mode = model is None or "demo" in str(type(model)).lower()
+    return {
+        "status": "ok",
+        "message": "API is working",
+        "demo_mode": demo_mode,
+        "test_data": {
+            "Pregnancies": 2,
+            "Glucose": 148,
+            "BloodPressure": 72,
+            "SkinThickness": 35,
+            "Insulin": 0,
+            "BMI": 33.6,
+            "DiabetesPedigreeFunction": 0.627,
+            "Age": 50
+        }
+    }
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(features: DiabetesFeatures):
+    demo_mode = model is None or "demo" in str(type(model)).lower()
+    
+    if model is None or scaler is None:
+        raise HTTPException(status_code=503, detail="Model not available")
+    
+    try:
+        # Convert input to array
+        input_data = np.array([[
+            features.Pregnancies,
+            features.Glucose,
+            features.BloodPressure,
+            features.SkinThickness,
+            features.Insulin,
+            features.BMI,
+            features.DiabetesPedigreeFunction,
+            features.Age
+        ]], dtype=np.float64)
+        
+        # Scale the data
+        if hasattr(scaler, 'transform'):
+            scaled_data = scaler.transform(input_data)
+        else:
+            scaled_data = input_data
+        
+        # Make prediction
+        if hasattr(model, 'predict'):
+            prediction = model.predict(scaled_data)[0]
+        else:
+            # Simple rule-based fallback
+            prediction = 1 if features.Glucose > 140 else 0
+        
+        # Get probability
+        probability = 0.5
+        if hasattr(model, 'predict_proba'):
+            probability = float(model.predict_proba(scaled_data)[0][1])
+        elif hasattr(model, 'decision_function'):
+            try:
+                score = model.decision_function(scaled_data)[0]
+                probability = 1 / (1 + np.exp(-score))
+            except:
+                probability = 0.5
+        else:
+            # Estimate probability based on glucose level
+            probability = min(0.95, max(0.05, features.Glucose / 200))
+        
+        # Determine risk level
+        if probability >= 0.7:
+            risk_level = "High"
+        elif probability >= 0.4:
+            risk_level = "Medium"
+        else:
+            risk_level = "Low"
+        
+        return PredictionResponse(
+            prediction=int(prediction),
+            probability=float(probability),
+            message="Diabetic" if prediction == 1 else "Non-Diabetic",
+            risk_level=risk_level,
+            demo_mode=demo_mode
+        )
+        
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=400, detail=f"Prediction failed: {str(e)}")
+
+@app.post("/predict_simple")
+async def predict_simple(data: dict):
+    """Simplified endpoint that accepts any format"""
+    demo_mode = model is None or "demo" in str(type(model)).lower()
+    
+    try:
+        # Extract features with flexible keys
+        features_map = {
+            'Pregnancies': ['pregnancies', 'Pregnancies', 'preg'],
+            'Glucose': ['glucose', 'Glucose', 'gluc'],
+            'BloodPressure': ['blood_pressure', 'BloodPressure', 'bp', 'BP'],
+            'SkinThickness': ['skin_thickness', 'SkinThickness', 'skin'],
+            'Insulin': ['insulin', 'Insulin', 'ins'],
+            'BMI': ['bmi', 'BMI'],
+            'DiabetesPedigreeFunction': ['diabetes_pedigree', 'DiabetesPedigreeFunction', 'pedigree', 'dpf'],
+            'Age': ['age', 'Age']
+        }
+        
+        features_list = []
+        for feature_name, possible_keys in features_map.items():
+            value = 0
+            for key in possible_keys:
+                if key in data:
+                    value = float(data[key])
+                    break
+            features_list.append(value)
+        
+        input_data = np.array([features_list], dtype=np.float64)
+        
+        if scaler and hasattr(scaler, 'transform'):
+            scaled_data = scaler.transform(input_data)
+        else:
+            scaled_data = input_data
+        
+        if model and hasattr(model, 'predict'):
+            prediction = model.predict(scaled_data)[0]
+        else:
+            prediction = 1 if features_list[1] > 140 else 0  # Based on glucose
+        
+        probability = 0.5
+        if model and hasattr(model, 'predict_proba'):
+            probability = float(model.predict_proba(scaled_data)[0][1])
+        
+        return {
+            "success": True,
+            "prediction": int(prediction),
+            "probability": float(probability),
+            "message": "Diabetic" if prediction == 1 else "Non-Diabetic",
+            "demo_mode": demo_mode,
+            "features_used": features_list
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "demo_mode": demo_mode
+        }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app_gradio.py

@@ -0,0 +1,96 @@
+import numpy as np
+import gradio as gr
+import pickle
+import os
+
+# Try to load model, fallback to dummy if fails
+def load_or_create_model():
+    try:
+        if os.path.exists('diabetes_model.pkl'):
+            with open('diabetes_model.pkl', 'rb') as f:
+                model = pickle.load(f)
+            with open('scaler.pkl', 'rb') as f:
+                scaler = pickle.load(f)
+            print("✓ Loaded trained model")
+            return model, scaler, False
+    except:
+        print("⚠ Could not load model, using demo mode")
+    
+    # Create simple rule-based model
+    class SimpleModel:
+        def predict(self, X):
+            # Simple rule: glucose > 140 = diabetic
+            return [1 if x[1] > 140 else 0 for x in X]
+        def predict_proba(self, X):
+            probs = []
+            for x in X:
+                glucose = x[1]
+                prob_diabetic = min(0.95, max(0.05, glucose / 200))
+                probs.append([1 - prob_diabetic, prob_diabetic])
+            return probs
+    
+    class SimpleScaler:
+        def transform(self, X):
+            return X
+    
+    return SimpleModel(), SimpleScaler(), True
+
+model, scaler, is_demo = load_or_create_model()
+
+def predict(pregnancies, glucose, bp, skin, insulin, bmi, pedigree, age):
+    try:
+        input_data = np.array([[pregnancies, glucose, bp, skin, insulin, bmi, pedigree, age]])
+        
+        # Scale
+        if hasattr(scaler, 'transform'):
+            input_data = scaler.transform(input_data)
+        
+        # Predict
+        prediction = model.predict(input_data)[0]
+        
+        # Get probability
+        if hasattr(model, 'predict_proba'):
+            proba = model.predict_proba(input_data)[0]
+            confidence = proba[1] if prediction == 1 else proba[0]
+        else:
+            confidence = 0.5
+        
+        result = "Diabetic" if prediction == 1 else "Non-Diabetic"
+        risk = "High" if confidence > 0.7 else "Medium" if confidence > 0.4 else "Low"
+        
+        return {
+            "result": result,
+            "confidence": f"{confidence * 100:.1f}%",
+            "risk_level": risk,
+            "demo_mode": is_demo,
+            "glucose_status": "High" if glucose > 140 else "Normal" if glucose > 70 else "Low"
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict,
+    inputs=[
+        gr.Number(label="Pregnancies", value=2),
+        gr.Number(label="Glucose (mg/dL)", value=148),
+        gr.Number(label="Blood Pressure (mmHg)", value=72),
+        gr.Number(label="Skin Thickness (mm)", value=35),
+        gr.Number(label="Insulin (mu U/ml)", value=0),
+        gr.Number(label="BMI (kg/m²)", value=33.6),
+        gr.Number(label="Diabetes Pedigree", value=0.627),
+        gr.Number(label="Age (years)", value=50)
+    ],
+    outputs=gr.JSON(label="Prediction Result"),
+    title="Diabetes Risk Predictor",
+    description="Enter health metrics to assess diabetes risk",
+    examples=[
+        [2, 148, 72, 35, 0, 33.6, 0.627, 50],
+        [1, 85, 66, 29, 0, 26.6, 0.351, 31],
+        [5, 116, 74, 0, 0, 25.6, 0.201, 30]
+    ],
+    theme="soft"
+)
+
+if __name__ == "__main__":
+    iface.launch(server_name="0.0.0.0", server_port=7860)

diabetes_model.pkl

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

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+numpy==1.24.3
+scikit-learn==1.3.2
+joblib==1.3.2
+gradio==4.24.0
+numpy==1.24.3

scaler.pkl

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