Advance Web Dev: Serving Data Science Models with FastAPI

For modern web developers, a data science model is only valuable if it can be consumed over standard HTTP/REST protocols. FastAPI is the premier modern Python web framework for serving high-performance, asynchronous machine learning microservices.

FastAPI and Docker Microservices Architecture

Figure 41.1: Advance Web Dev Architecture — Async FastAPI Endpoints, DuckDB-Wasm & Dockerized Serving.

Complete Production FastAPI Model Server

# main.py - Run with: uvicorn main:app --reload --port 8000
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
import joblib
import numpy as np
from contextlib import asynccontextmanager

# In-memory model cache
ml_models = {}

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Load model artifact once on server startup
    print("Loading serialized ML model artifact...")
    # Simulating loaded pre-trained model: dummy weights
    ml_models["churn_model"] = lambda x: 1 / (1 + np.exp(-(x[0]*0.2 - x[1]*0.01)))
    yield
    # Clean up on shutdown
    ml_models.clear()

app = FastAPI(
    title="Veewom Customer Churn Inference Microservice",
    description="Real-time predictive scoring API for web developers.",
    version="2.0.0",
    lifespan=lifespan
)

# Pydantic schema for strict incoming JSON validation
class CustomerFeatures(BaseModel):
    support_tickets: int = Field(..., ge=0, le=50, description="Count of support tickets opened")
    tenure_months: int = Field(..., ge=0, le=120, description="Account age in months")
    monthly_spend: float = Field(..., ge=0.0, description="Monthly recurring billing")

    class Config:
        json_schema_extra = {
            "example": {"support_tickets": 3, "tenure_months": 14, "monthly_spend": 79.99}
        }

class PredictionResponse(BaseModel):
    churn_probability: float
    churn_risk_tier: str
    action_recommended: str

@app.post("/predict", response_model=PredictionResponse)
async def predict_churn(customer: CustomerFeatures):
    try:
        model = ml_models.get("churn_model")
        if not model:
            raise HTTPException(status_code=503, detail="Model artifact unavailable.")
            
        features = np.array([customer.support_tickets, customer.tenure_months])
        prob = float(model(features))
        
        tier = "High Risk" if prob >= 0.60 else ("Medium Risk" if prob >= 0.30 else "Low Risk")
        action = "Send 20% Retention Offer" if prob >= 0.60 else "Standard Nurture Campaign"
        
        return PredictionResponse(
            churn_probability=round(prob, 4),
            churn_risk_tier=tier,
            action_recommended=action
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Interactive Swagger UI Built-In

Once your FastAPI server starts, visit http://localhost:8000/docs in your browser. FastAPI automatically generates an interactive Swagger UI where web developers can test JSON requests and review schemas in real-time!

Frequently Asked Questions (FAQ) - Student & Interview Review

Q1. Why is FastAPI superior to Flask for serving Data Science models?

FastAPI is built on Starlette and Pydantic, providing native asynchronous concurrency (async/await) capable of handling thousands of requests per second on a single worker. It provides automatic JSON request validation, Python type checking, and auto-generates interactive OpenAPI Swagger documentation.

Q2. How do you serialize and load a Scikit-Learn model efficiently?

Serialize using joblib (joblib.dump(model, 'model.joblib', compress=3)). In FastAPI, load the model once into memory during application startup using the @asynccontextmanager lifespan handler to avoid reloading on every HTTP request.

Q3. What role does Pydantic play in machine learning APIs?

Pydantic enforces strict runtime data validation on incoming JSON payloads (e.g., verifying 'age' is an integer between 18 and 100). If an invalid payload is sent, FastAPI automatically rejects it with a descriptive HTTP 422 error without crashing model inference.

Q4. What is the typical inference latency of a FastAPI model endpoint?

A well-optimized Scikit-Learn or LightGBM model served via FastAPI typically responds in 8 to 25 milliseconds for single-row inference.

Q5. How do you handle batch predictions in a REST API?

Define the Pydantic request schema to accept a list of items: List[CustomerInput]. The endpoint converts the batch into a Pandas DataFrame or NumPy array and calls model.predict() in a single vectorized pass.