MLOps & Model Deployment

1Why MLOps? From notebook to production

Training is maybe 10% of a real ML project. The other 90% is everything around it: data pipelines, versioning, serving, monitoring and retraining. MLOps brings software-engineering rigour (and DevOps ideas) to machine learning.

2Saving & versioning models

Step one of deployment: persist the trained model so you can load it elsewhere without retraining. For scikit-learn, joblib is the standard.

Save and load

import joblib

# Save the entire fitted pipeline (preprocessing + model together)
joblib.dump(pipeline, 'model.joblib')

# Later, in a totally different process:
loaded = joblib.load('model.joblib')
print(loaded.predict(X_new[:3]))

[1 0 1]

Version everything that makes a model

• Code — Git (you already do this).
• Data — DVC or dataset hashes, so you know what it trained on.
• Model artefacts — a model registry with versions and stages (Staging → Production).
• Environment — pinned requirements.txt so dependencies match.

3Experiment tracking with MLflow

Real projects train dozens of models with different features and settings. MLflow logs each run's parameters, metrics and artefacts so you can compare them and reproduce the winner — no more “which notebook had the 0.94 model?”

Track a run

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier

with mlflow.start_run(run_name='rf-200-trees'):
    params = {'n_estimators': 200, 'max_depth': 10}
    model = RandomForestClassifier(**params, random_state=42).fit(X_tr, y_tr)
    acc = model.score(X_te, y_te)

    mlflow.log_params(params)
    mlflow.log_metric('accuracy', acc)
    mlflow.sklearn.log_model(model, 'model')
    print('Logged accuracy:', round(acc, 3))

Logged accuracy: 0.958

Run mlflow ui and open http://localhost:5000 to browse every run side by side — sort by metric, inspect parameters, and download any model.

4Serving a model with FastAPI

To make predictions available to apps, wrap the model in a web API. FastAPI is the modern Python choice: fast, with automatic validation and interactive docs.

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI(title='Churn Predictor')
model = joblib.load('model.joblib')      # loaded once at startup

class Customer(BaseModel):               # auto-validated request schema
    features: list[float]

@app.post('/predict')
def predict(item: Customer):
    proba = model.predict_proba([item.features])[0, 1]
    return {'churn_probability': round(float(proba), 4)}

# Run it, then call it
uvicorn app:app --reload

curl -X POST http://localhost:8000/predict \
  -H 'Content-Type: application/json' \
  -d '{"features": [0.2, 45.0, 1.0, 3.0]}'

{"churn_probability": 0.8123}

5Packaging with Docker

“It works on my machine” is not deployment. Docker packages your code, dependencies and runtime into a single image that runs identically on any machine — your laptop, a colleague's, or a cloud server.

A Dockerfile for the API

FROM python:3.11-slim

WORKDIR /app

# Install dependencies first (better layer caching)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the app and the trained model
COPY app.py model.joblib ./

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

# Build the image, then run a container
docker build -t churn-api .
docker run -p 8000:8000 churn-api

INFO:     Uvicorn running on http://0.0.0.0:8000
INFO:     Application startup complete.

6Monitoring, drift & retraining

A deployed model is not done — it is on probation. The world changes, and the data it sees in production drifts away from its training data, quietly eroding accuracy. Monitoring catches this before users do.

Two kinds of drift

• Data drift: the input distribution shifts (e.g. new customer demographics).
• Concept drift: the relationship between inputs and target changes (e.g. behaviour after a price change or a pandemic).

Detect drift in code

from scipy import stats

# Compare a feature's training vs recent-production distribution
stat, p = stats.ks_2samp(train_feature, live_feature)
print(f'KS statistic: {stat:.3f}, p-value: {p:.4f}')

if p < 0.05:
    print('Drift detected -- flag for review / retraining')

KS statistic: 0.214, p-value: 0.0008
Drift detected -- flag for review / retraining