Model Deployment Project

Model Training Notebook

Create model_training.ipynb that:

• Loads and preprocesses the diabetes dataset
• Trains a classification model (Random Forest, XGBoost, or similar)
• Evaluates with accuracy, precision, recall, F1, and ROC-AUC
• Saves the trained model using joblib

# model_training.ipynb
import joblib
from sklearn.ensemble import RandomForestClassifier

# Train model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Save model
joblib.dump(model, 'models/diabetes_model.joblib')
joblib.dump(scaler, 'models/scaler.joblib')

Model Interpretability Notebook

Create interpretability.ipynb that:

• Computes feature importance from tree-based models
• Generates SHAP summary plots (global and local)
• Creates LIME explanations for individual predictions
• Plots partial dependence (PDP) and ICE curves
• Saves all visualizations as PNG files

# interpretability.ipynb
import shap
import lime
from lime.lime_tabular import LimeTabularExplainer

# SHAP
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test, show=False)
plt.savefig('visualizations/shap_summary.png')

# LIME
lime_explainer = LimeTabularExplainer(X_train, feature_names=feature_names)
exp = lime_explainer.explain_instance(X_test[0], model.predict_proba)
exp.save_to_file('visualizations/lime_explanation.html')

Flask/FastAPI REST API

Create app.py that implements:

• GET /health - Health check endpoint
• POST /predict - Single prediction with probability
• POST /predict/batch - Batch predictions
• POST /explain - Prediction with SHAP explanation
• Input validation using Pydantic (FastAPI) or marshmallow (Flask)
• Proper error handling with meaningful messages

# app.py (FastAPI example)
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib

app = FastAPI(title="Diabetes Prediction API")

class PatientData(BaseModel):
    pregnancies: int
    glucose: float
    blood_pressure: float
    skin_thickness: float
    insulin: float
    bmi: float
    diabetes_pedigree: float
    age: int

@app.get("/health")
def health_check():
    return {"status": "healthy", "model_loaded": True}

@app.post("/predict")
def predict(patient: PatientData):
    # Load model, make prediction, return result
    pass

@app.post("/explain")
def explain(patient: PatientData):
    # Return prediction with SHAP values
    pass

Docker Containerization

Create Dockerfile and docker-compose.yml that:

• Uses Python 3.9+ slim base image
• Installs all dependencies from requirements.txt
• Copies model files and application code
• Exposes port 8000 for the API
• Runs the API server on container start

# Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'
services:
  diabetes-api:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - ./logs:/app/logs
    environment:
      - LOG_LEVEL=INFO

Logging & Monitoring

Create monitoring.py that:

• Implements structured logging with timestamps
• Logs all API requests with input features
• Logs predictions and response times
• Tracks prediction distribution over time
• Saves logs to file and optionally to console

# monitoring.py
import logging
import time
from functools import wraps

logging.basicConfig(
    filename='logs/predictions.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def log_prediction(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        duration = time.time() - start_time
        logging.info(f"Prediction: {result}, Duration: {duration:.4f}s")
        return result
    return wrapper

API Testing Script

Create test_api.py that:

• Tests all API endpoints
• Validates response formats and status codes
• Tests error handling with invalid inputs
• Includes at least 10 test cases

# test_api.py
import requests
import pytest

BASE_URL = "http://localhost:8000"

def test_health_endpoint():
    response = requests.get(f"{BASE_URL}/health")
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

def test_predict_valid_input():
    patient_data = {
        "pregnancies": 6, "glucose": 148, "blood_pressure": 72,
        "skin_thickness": 35, "insulin": 0, "bmi": 33.6,
        "diabetes_pedigree": 0.627, "age": 50
    }
    response = requests.post(f"{BASE_URL}/predict", json=patient_data)
    assert response.status_code == 200
    assert "prediction" in response.json()
    assert "probability" in response.json()

Documentation

Create comprehensive README.md that includes:

• Project overview and architecture diagram
• Installation instructions (local and Docker)
• API documentation with example requests/responses
• Model performance metrics
• Interpretability explanation for non-technical stakeholders
• Future improvements and scaling considerations