Basic Model Deployment: Model Persistence, FastAPI & Production Inference

In machine learning, model deployment means taking the mathematical parameters learned during offline training and integrating them into a running software application or web API so users and downstream services can obtain live predictions on demand.

A common mistake junior engineers make is writing joblib.dump(classifier, 'model.joblib'). In production, an isolated estimator is useless because incoming raw JSON requests contain unscaled numbers (e.g. monthly_spend = $1,200) and raw string categories (e.g. plan_type = 'Enterprise').

Model persistence allows you to train an algorithm once, serialize its internal state to disk, and load it into a web server in milliseconds. However, different serialization formats make distinct tradeoffs between speed, language independence, and security:

Pickle and joblib serialize internal Python memory structures rather than mathematical equations. If you train a model in scikit-learn 1.9.1 and attempt to deserialize it inside a container running scikit-learn 1.1.0, it will fail with an AttributeError or silently calculate incorrect predictions.

# Production Inference Dependencies (Strictly Pinned)
scikit-learn==1.9.1
numpy==2.1.2
pandas==2.2.3
fastapi>=0.115.0
uvicorn[standard]>=0.30.0
pydantic>=2.8.0
joblib==1.4.2

FastAPI is Python's leading web framework for machine learning serving due to its sub-millisecond async performance, automatic OpenAPI documentation, and robust type validation powered by Pydantic.

{
  "status": "success",
  "prediction": 0,
  "label": "not_churned",
  "churn_probability": 0.184,
  "latency_ms": 1.4
}

In production web applications, deserializing a 100MB model from disk takes 80–150ms. If you execute joblib.load() inside the HTTP endpoint function, every incoming request pays that severe disk penalty.

Modern FastAPI introduces the lifespan context manager (replacing older startup events) to load model weights into RAM once when the server boots:

from contextlib import asynccontextmanager
from pathlib import Path
import joblib
from fastapi import FastAPI, HTTPException
import pandas as pd

# Dictionary to hold the shared model in memory
ml_models = {}

@asynccontextmanager
async def lifespan(app: FastAPI):
    # 1. Runs ONCE on server startup: load model from disk into RAM
    model_path = Path(__file__).resolve().parent / "model" / "churn_pipeline.joblib"
    try:
        ml_models["pipeline"] = joblib.load(model_path)
        print("Model loaded successfully into RAM.")
    except Exception as e:
        print(f"Error loading model: {e}")
        ml_models["pipeline"] = None
    
    yield
    
    # 2. Runs ONCE on server shutdown: cleanup memory
    ml_models.clear()

app = FastAPI(title="Churn Inference Service", lifespan=lifespan)

@app.post("/predict")
def predict(payload: CustomerData):
    pipeline = ml_models.get("pipeline")
    if pipeline is None:
        raise HTTPException(status_code=503, detail="Model unavailable")
    
    df = pd.DataFrame([payload.model_dump()])
    pred = pipeline.predict(df)[0]
    prob = pipeline.predict_proba(df)[0][1]
    return {"prediction": int(pred), "churn_probability": float(prob)}

Machine learning models cannot handle arbitrary input data. If an API accepts unvalidated payloads, a client sending negative support tickets (support_tickets = -50) or string numbers will corrupt mathematical calculations or crash the worker process.

{
  "status": "success",
  "prediction": 0,
  "churn_probability": 0.142
}

When your FastAPI endpoint receives a validated Pydantic model, convert it into a single-row pandas DataFrame matching the exact feature column names used during training. Passing this DataFrame into pipeline.predict(df) automatically triggers:

In production software engineering, ML projects are separated into training pipelines, serialized artifacts, and serving applications:

churn-prediction-service/
├── app/
│   ├── __init__.py
│   ├── main.py            # FastAPI endpoints (lifespan, /predict, /health)
│   ├── schemas.py         # Pydantic V2 request & response models
│   └── model/
│       └── churn_pipeline.joblib   # Saved Pipeline artifact
├── training/
│   ├── __init__.py
│   └── train.py           # Training script that fits and exports pipeline
├── Dockerfile             # Production container definition
├── requirements.txt       # Pinned library dependencies
└── README.md

Docker encapsulates the operating system, exact Python version, pinned dependencies, model artifact, and FastAPI application into a single immutable container image. This guarantees that if it works on your machine, it will run identically on AWS, GCP, or Azure:

# 1. Official lightweight Python base image
FROM python:3.12-slim

# 2. Set working directory
WORKDIR /app

# 3. Prevent Python from buffering stdout/stderr and writing .pyc files
ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

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

# 5. Copy application code and model artifact
COPY app/ ./app/

# 6. Expose default FastAPI port
EXPOSE 8000

# 7. Start production Uvicorn server
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

A professional inference service never exposes only /predict. It provides observational endpoints:

{
  "status": "healthy",
  "service": "customer-churn-api",
  "timestamp": "2026-09-18T20:50:00Z"
}

Exposing machine learning models via web APIs introduces serious security considerations. Follow these foundational security mandates:

You have successfully completed the core Machine Learning track! You now understand the full lifecycle: from exploratory data analysis and feature engineering, through core algorithms (regression, classification, clustering) and statistical evaluation, to deploying modular, containerized inference microservices.