How to Develop a Sepsis Prediction App Using FastAPI

Are you interested in building a powerful sepsis prediction application that leverages machine learning and real-time data analysis? This article will guide you through developing a sepsis prediction app using FastAPI, a high-performance Python web framework. When you combine exploratory data analysis (EDA), model building, and API integration, you can create a robust application that assesses the likelihood of sepsis based on a patient's health parameters.

Exploratory Data Analysis (EDA)

First, let's delve into the crucial step of exploratory data analysis. Carefully examine and preprocess the dataset, to gain valuable insights into the factors contributing to sepsis. In my GitHub repository, you can find a Jupyter Notebook that contains the necessary code snippets to perform EDA.

Secondly, load and analyze the dataset. You can clean the data and extract relevant features using Pandas, a popular data manipulation library. Finally, employ visualizations and statistical analyses to uncover patterns and relationships within the dataset. These insights will help you understand the data and make informed decisions during model development.

# correlation heatmap df
correlation = df_train.corr()
sns.heatmap(correlation, annot=True, fmt='.2f')        

Model Building?

With the insights gained from EDA, it's time to construct a machine-learning model for sepsis prediction. Check out this notebook for code snippets that guide you through this process. Begin by splitting the dataset into training and testing sets using sci-kit-learn, a comprehensive machine learning library.

Next, define the features and labels necessary for training the model. Please choose an appropriate machine learning algorithm, such as logistic regression or random forests, and fine-tune its hyperparameters for optimal performance. Train the model using the training data and evaluate its accuracy using suitable metrics.

Write codes that will allow you to have a trained machine-learning model capable of predicting sepsis based on input health parameters.

# Define the models
logreg_model = LogisticRegression(random_state=42)
rf_model = RandomForestClassifier(random_state=42)
gb_model = GradientBoostingClassifier(random_state=42)
KNN_model = ?KNeighborsClassifier()
dt_model = DecisionTreeClassifier(random_state=42)



# Fit the models
logreg = logreg_model.fit(X_train, y_train)
rf = rf_model.fit(X_train, y_train)
gb = gb_model.fit(X_train, y_train)
KNN = KNN_model.fit(X_train,y_train)
dt = dt_model.fit(X_train, y_train)


# Make predictions
logreg_preds = logreg.predict(X_eval)
rf_preds = rf.predict(X_eval)
gb_preds = gb.predict(X_eval)
KNN_preds = KNN.predict(X_eval)
dt_preds = dt.predict(X_eval)


# Calculate evaluation metrics
logreg_accuracy = accuracy_score(y_eval, logreg_preds)
rf_accuracy = accuracy_score(y_eval, rf_preds)
gb_accuracy = accuracy_score(y_eval, gb_preds)
KNN_accuracy = accuracy_score(y_eval, KNN_preds)
dt_accuracy = accuracy_score(y_eval, dt_preds)


logreg_precision = precision_score(y_eval, logreg_preds)
rf_precision = precision_score(y_eval, rf_preds)
gb_precision = precision_score(y_eval, gb_preds)
KNN_precision = precision_score(y_eval, KNN_preds)
dt_precision = precision_score(y_eval, dt_preds)



logreg_recall = recall_score(y_eval, logreg_preds)
rf_recall = recall_score(y_eval, rf_preds)
gb_recall = recall_score(y_eval, gb_preds)
KNN_recall = recall_score(y_eval, KNN_preds)
dt_recall = recall_score(y_eval, dt_preds)



logreg_f1 = f1_score(y_eval, logreg_preds)
rf_f1 = f1_score(y_eval, rf_preds)
gb_f1 = f1_score(y_eval, gb_preds)
KNN_f1 = f1_score(y_eval, KNN_preds)
dt_f1 = f1_score(y_eval, dt_preds)



logreg_roc_auc = roc_auc_score(y_eval, logreg_preds)
rf_roc_auc = roc_auc_score(y_eval, rf_preds)
gb_roc_auc = roc_auc_score(y_eval, gb_preds)
KNN_roc_auc = roc_auc_score(y_eval, KNN_preds)
dt_roc_auc = roc_auc_score(y_eval, dt_preds)        

Sepsis API Integration

Let's integrate the trained sepsis prediction model into a FastAPI framework to create a robust and efficient API. FastAPI's simplicity and high performance make it an ideal choice for developing web applications with real-time capabilities.

You can create an API endpoint that accepts patient health parameter inputs using the code snippets provided in the notebook. These inputs are then processed and passed through the trained model to obtain a sepsis prediction. The API returns the prediction as a response, allowing users to access real-time sepsis risk assessments.

import pickle
from fastapi import FastAPI
from pydantic import BaseModel


# Define your ML model input schema
class PredictionInput(BaseModel):
? ? PRG: int
? ? PL: int
? ? PR: int
? ? SK: int
? ? TS: int
? ? M11: float
? ? BD2: float
? ? Age: int
? ? Insurance: int


# Load the exported objects
with open('/content/encoder.pkl', 'rb') as file:
? ? encoder = pickle.load(file)


with open('/content/scaler.pkl', 'rb') as file:
? ? scaler = pickle.load(file)


with open('/content/model.pkl', 'rb') as file:
? ? model = pickle.load(file)


# Create the FastAPI app
app = FastAPI(title='Sepsis API', description='An API that takes input and displays the predictions', version='0.1.0')


# Define the prediction endpoint
@app.post('/Sepsis')
def predict(input_data: PredictionInput):
? ? # Preprocess the input features
? ? encoded_features = encoder.transform([[input_data.PRG, input_data.PL, input_data.PR, input_data.SK, input_data.TS, input_data.M11, input_data.BD2, input_data.Age, input_data.Insurance]])
? ? scaled_features = scaler.transform(encoded_features)


? ? # Make predictions using the model
? ? predictions = model.predict(scaled_features)


? ? # Labeling Model output
? ? if prediction[0] < 0.5:
? ? ? ? prediction_label = "Negative. This person does not have Sepsis."
? ? else:
? ? ? ? prediction_label = "Positive. This person has Sepsis."


? ? # Return the predictions
? ? return {'predictions': predictions.tolist()}        

Congratulations! Following the steps outlined in this article puts you on your way to developing a sepsis prediction app using FastAPI. Through exploratory data analysis, model building, and API integration, you have harnessed the power of machine learning and real-time data analysis to enhance sepsis detection and improve patient care.

By leveraging FastAPI's speed and efficiency, your application can promptly provide accurate sepsis risk assessments. You can revolutionize healthcare technology and contribute to better disease management with further advancements and refinements.

So, what are you waiting for? Dive into the provided code snippets, unleash your creativity, and build a sepsis prediction app to impact patient outcomes positively.