Run this notebook: Open in Colab Open in Kaggle

MLOps: Machine Learning in Production¶

🎯 What You’ll Learn¶

This series covers the complete MLOps lifecycle:

Experiment Tracking - MLflow, Weights & Biases
API Development - FastAPI for model serving
Deployment - Docker, cloud platforms
Monitoring - Observability and alerts
CI/CD - Automated ML pipelines
Production Best Practices - Scalability, reliability

Why MLOps?¶

The Problem: Most ML models never make it to production

Jupyter notebooks are great for experimentation
But production requires different skills
Need to handle scale, reliability, monitoring

The Solution: MLOps practices

Version control for models and data
Automated testing and deployment
Continuous monitoring and improvement

The MLOps Lifecycle¶

┌─────────────────────────────────────────────────────┐
│                   ML LIFECYCLE                      │
├─────────────────────────────────────────────────────┤
│                                                     │
│  Data → Experiment → Train → Evaluate → Deploy     │
│   ↑                                          ↓      │
│   └────────────── Monitor & Retrain ─────────┘      │
│                                                     │
└─────────────────────────────────────────────────────┘

Key Components¶

Experiment Tracking
- Log hyperparameters, metrics, artifacts
- Compare different runs
- Reproduce experiments
Model Registry
- Version control for models
- Track model lineage
- Manage staging/production models
Model Serving
- REST APIs (FastAPI, Flask)
- Batch predictions
- Real-time inference
Monitoring
- Model performance metrics
- Data drift detection
- System health (latency, errors)

Quick Demo: Simple ML API¶

Let’s build a minimal model serving API:

# Install dependencies (uncomment to run)
# !pip install fastapi uvicorn scikit-learn joblib

# Simple model training
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import joblib

# Train model
iris = load_iris()
model = RandomForestClassifier(n_estimators=10, random_state=42)
model.fit(iris.data, iris.target)

# Save model
joblib.dump(model, 'iris_model.pkl')
print("✓ Model trained and saved")

# Create FastAPI application
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np

app = FastAPI(title="Iris Classifier API")

# Load model
model = joblib.load('iris_model.pkl')

class PredictionRequest(BaseModel):
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

class PredictionResponse(BaseModel):
    species: str
    confidence: float

@app.post("/predict", response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    # Prepare features
    features = np.array([[
        request.sepal_length,
        request.sepal_width,
        request.petal_length,
        request.petal_width
    ]])
    
    # Predict
    prediction = model.predict(features)[0]
    probabilities = model.predict_proba(features)[0]
    
    species_names = ['setosa', 'versicolor', 'virginica']
    
    return PredictionResponse(
        species=species_names[prediction],
        confidence=float(probabilities[prediction])
    )

@app.get("/health")
async def health():
    return {"status": "healthy"}

print("✓ API created")
print("Run with: uvicorn main:app --reload")

Testing the API¶

To test this API:

# Start server
uvicorn main:app --reload

# Test with curl
curl -X POST "http://localhost:8000/predict" \
  -H "Content-Type: application/json" \
  -d '{"sepal_length": 5.1, "sepal_width": 3.5, "petal_length": 1.4, "petal_width": 0.2}'

Or visit: http://localhost:8000/docs for interactive API documentation

What’s Next?¶

In the following notebooks, you’ll learn:

Experiment Tracking - Track and compare models
FastAPI Deep Dive - Advanced API features
Model Deployment - Production serving strategies
Docker - Containerize your applications
Monitoring - Observe model behavior in production
CI/CD - Automate your ML pipeline
Cloud Deployment - Deploy to AWS/Azure/GCP

🚀 Ready to take ML to production!