Phase 3: REST API

from fastapi import FastAPI
from patient import Patient

import train as tr
import predict as pr


app = FastAPI()


@app.post("/train")
def train():
    """
    Exposes an endpoint to train a machine learning model.
    """
    return tr.train()


@app.post("/predict")
def predict(patient: Patient):
    """
    Exposes an endpoint to make a prediction based on patient information.

    Parameters:
    - patient: A Patient object containing the patient's input information.

    Returns:
    - A dictionary with a prediction message.
    """
    return pr.predict(patient)

from pydantic import BaseModel


class Patient(BaseModel):
    """
    Represents a patient with their respective attributes.

    Attributes:
    - gender (str): Patient's gender (Female, Male, Other)
    - age (int): Patient's age
    - hypertension (int): Hypertension disease (1: yes, 0: no)
    - heart_disease (int): Heart disease (1: yes, 0: no)
    - smoking_history (str): Patient's smoking history (not current, former, No Info, current, never, ever.)
    - bmi (float): Patient's body mass index
    - HbA1c_level (float): Patient's hemoglobin A1c level
    - blood_glucose_level (int): Patient's blood sugar level
    """

    gender: str
    age: int
    hypertension: int
    heart_disease: int
    smoking_history: str
    bmi: float
    HbA1c_level: float
    blood_glucose_level: int

from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from imblearn.combine import SMOTEENN
from loguru import logger
import os
import pandas as pd
import pickle


model_file = "model.pkl"  # Model file path
data_file = "train.csv"  # Training data file path
overwrite = True  # Overwrite existing model

def train():
    """
    Trains a machine learning model using data from 'train.csv' 
    and saves the trained model to 'model.pkl'.
    """

    try:
        # Check if model file already exists
        if os.path.isfile(model_file):
            if overwrite:
                logger.info(f"overwriting existing model file {model_file}")
            else:
                logger.info(
                    f"model file {model_file} exists. exitting. use --overwrite_model option"
                )
                exit(-1)

        # Load training data
        logger.info("loading train data")
        z = pd.read_csv(data_file)

        # Encode training data
        logger.info("encoding train data")
        gender_dict = {"Female": 0, "Male": 1, "Other": 2}
        smoking_history_dict = {
            "No Info": 0,
            "current": 1,
            "ever": 2,
            "former": 3,
            "never": 4,
            "not current": 5,
        }
        z = z.replace({"gender": gender_dict, "smoking_history": smoking_history_dict})

        # Separate features (Xtr) and labels (ytr)
        Xtr = z.drop("diabetes", axis=1)
        ytr = z[["diabetes"]]

        # Scale training data
        logger.info("scaling train data")
        scaler = StandardScaler()
        Xtr = scaler.fit_transform(Xtr)

        # Apply oversampling and undersampling with SMOTEENN
        smote_enn = SMOTEENN(random_state=42)
        Xtr, ytr = smote_enn.fit_resample(Xtr, ytr)

        # Train the model
        logger.info("fitting model")
        m = RandomForestClassifier()
        m.fit(Xtr, ytr)

        # Save model to file
        logger.info(f"saving model to {model_file}")
        with open(model_file, "wb") as f:
            pickle.dump(m, f)

        return {"message": "Model successfully trained"}

    except:
        return {"message": "Something went wrong"}

from patient import Patient
from sklearn.preprocessing import StandardScaler
from imblearn.combine import SMOTEENN
from loguru import logger
import os
import pandas as pd
import pickle


model_file = "model.pkl"  # Model file path

def predict(patient: Patient):
    """
    Makes a prediction based on the input patient information.

    Parameters:
    - patient: A Patient object containing the patient's input information.

    Returns:
    - A dictionary with a prediction message.
    """

    try:
        # Load input data
        Xts = pd.DataFrame([patient.model_dump()])

        # Verify model file exists
        if not os.path.isfile(model_file):
            logger.error(f"model file {model_file} does not exist")
            exit(-1)

        # Encode input data
        logger.info("encoding data")
        gender_dict = {"Female": 0, "Male": 1, "Other": 2}
        smoking_history_dict = {
            "No Info": 0,
            "current": 1,
            "ever": 2,
            "former": 3,
            "never": 4,
            "not current": 5,
        }
        Xts = Xts.replace({"gender": gender_dict, "smoking_history": smoking_history_dict})

        # Scale input data
        logger.info("scaling data")
        scaler = StandardScaler()
        Xts = scaler.fit_transform(Xts)

        # Load model
        logger.info("loading model")
        with open(model_file, "rb") as f:
            m = pickle.load(f)

        # Make predictions
        logger.info("making predictions")
        preds = m.predict(Xts)

        return {"message": "Tiene diabetes" if preds[0] == 1 else "No tiene diabetes"}
    
    except:
        return {"message": "Something went wrong"}

# Select Python base image
FROM python:3.12

# Set working directory
WORKDIR /app

# Copy necessary files to application directory
ADD .. /app

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Run the application
CMD ["fastapi", "run", "apirest.py", "--port", "80"]

fastapi==0.111.0 
scikit-learn==1.4.1.post1
loguru==0.7.2
pandas==2.2.1
imbalanced-learn==0.12.0

import requests

class DiabetesPredictor:
    def __init__(self, base_url="http://localhost"):
        self.base_url = base_url
    
    def train_model(self):
        """Train the diabetes prediction model."""
        response = requests.post(f"{self.base_url}/train")
        response.raise_for_status()
        return response.json()
    
    def predict(self, patient_data):
        """Make a prediction for a patient."""
        response = requests.post(
            f"{self.base_url}/predict",
            json=patient_data
        )
        response.raise_for_status()
        return response.json()

# Usage
predictor = DiabetesPredictor()

# Train model
result = predictor.train_model()
print(result)  # {'message': 'Model successfully trained'}

# Make prediction
patient = {
    "gender": "Female",
    "age": 36,
    "hypertension": 0,
    "heart_disease": 0,
    "smoking_history": "current",
    "bmi": 32.27,
    "HbA1c_level": 6.2,
    "blood_glucose_level": 220
}

prediction = predictor.predict(patient)
print(prediction)  # {'message': 'Tiene diabetes'}

import { useState } from 'react';

function DiabetesForm() {
  const [patient, setPatient] = useState({
    gender: 'Female',
    age: 36,
    hypertension: 0,
    heart_disease: 0,
    smoking_history: 'never',
    bmi: 25.0,
    HbA1c_level: 5.5,
    blood_glucose_level: 100
  });
  
  const [prediction, setPrediction] = useState(null);
  
  const handleSubmit = async (e) => {
    e.preventDefault();
    
    const response = await fetch('http://localhost/predict', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify(patient)
    });
    
    const result = await response.json();
    setPrediction(result.message);
  };
  
  return (
    <form onSubmit={handleSubmit}>
      <input
        type="number"
        value={patient.age}
        onChange={(e) => setPatient({...patient, age: parseInt(e.target.value)})}
      />
      {/* Other inputs */}
      <button type="submit">Predict</button>
      {prediction && <div>Result: {prediction}</div>}
    </form>
  );
}