Chapter 22: MLOps, Deployment, Ethics, and the Future

Bloom's Taxonomy Progression

Learning Objectives

By the end of this chapter, you will be able to:

• Architect a complete MLOps pipeline from data versioning through CI/CD to production monitoring — and know exactly where each tool (DVC, MLflow, W&B, Docker, Kubernetes) fits
• Deploy models using FastAPI, TorchServe, TF Serving, and Triton Inference Server — choosing the right framework for your latency, throughput, and team constraints
• Optimize models for production using quantization (INT8/FP16), pruning, knowledge distillation, and ONNX conversion — shrinking models by 4× without meaningful accuracy loss
• Deploy to edge using TensorRT, TFLite, CoreML, and Raspberry Pi — serving inference where internet connectivity is unreliable
• Evaluate AI systems for bias and fairness across gender, caste, and religion (Indian context) and race, gender, age (global context), applying LIME, SHAP, and Grad-CAM for explainability
• Compare India's DPDPA 2023, the EU's GDPR, and the EU AI Act — understanding their implications for deploying AI in production
• Navigate the frontier landscape: foundation models, multimodal AI, AI agents, neuromorphic computing, and quantum ML
• Chart a detailed career path from Indian IT services to FAANG, from research to startups, with specific skill milestones

Opening Hook

The Intuition First

The Restaurant Analogy

Think of building an ML model like perfecting a recipe in your home kitchen. You've tested it with your family — they love it. But now you want to open a restaurant. Suddenly, you need:

• Supply Chain (Data Pipeline): Consistent ingredients, delivered fresh every morning — not whatever's in the fridge
• Kitchen Equipment (Infrastructure): Industrial ovens, not a home microwave — Docker containers, GPU servers
• Recipe Cards (Model Registry): Written-down, versioned recipes so any chef can reproduce the dish — MLflow, model versioning
• Quality Control (Monitoring): Every plate checked before serving — data drift detection, A/B testing
• Health Inspector (Ethics & Compliance): FSSAI in India, FDA in USA — DPDPA, GDPR, EU AI Act
• Food Truck (Edge Deployment): Taking the kitchen on the road, with limited power and space — TFLite, TensorRT

The "Aha" Question

If you train a model that's 95% accurate on today's data, what guarantee do you have that it'll be 95% accurate in 6 months? (Spoiler: absolutely none. And that's why you need this chapter.)

22.1 The MLOps Pipeline — End to End

22.1.1 Data Versioning with DVC

Git versions your code. But what about your data? A 50GB training dataset can't live in Git. Enter DVC (Data Version Control) — Git for data.

bash
# Initialize DVC in a Git repo
$ git init my-ml-project && cd my-ml-project
$ dvc init

# Track a large dataset
$ dvc add data/training_images/    # Creates data/training_images.dvc
$ git add data/training_images.dvc data/.gitignore
$ git commit -m "Add training images v1"

# Configure remote storage (S3 example)
$ dvc remote add -d myremote s3://my-bucket/dvc-store
$ dvc push                         # Upload data to S3

# Reproduce exactly: checkout code + data
$ git checkout v1.0
$ dvc checkout                     # Pulls the matching data version

22.1.2 Experiment Tracking — MLflow & Weights & Biases

You've run 47 experiments. Which hyperparameters gave the best F1 score? Which dataset version? What was the learning rate? Without experiment tracking, you're navigating without a map.

python
import mlflow
import mlflow.pytorch

# Start an experiment
mlflow.set_experiment("crop-disease-detection")

with mlflow.start_run(run_name="resnet50-lr0.001"):
    # Log hyperparameters
    mlflow.log_param("learning_rate", 0.001)
    mlflow.log_param("batch_size", 32)
    mlflow.log_param("model_arch", "ResNet50")
    mlflow.log_param("dataset_version", "v2.3")

    # Train your model (simplified)
    model, metrics = train_model(config)

    # Log metrics
    mlflow.log_metric("val_accuracy", metrics["accuracy"])
    mlflow.log_metric("val_f1", metrics["f1"])
    mlflow.log_metric("val_loss", metrics["loss"])

    # Log the model artifact
    mlflow.pytorch.log_model(model, "model")

    # Log training curves as artifact
    mlflow.log_artifact("training_curves.png")

22.1.3 Model Registry & CI/CD

A model registry is like a warehouse for your trained models. Each model has versions, stages (Staging → Production → Archived), and metadata. When a new model passes all tests, CI/CD automatically promotes it.

python
# Register a model in MLflow
from mlflow.tracking import MlflowClient

client = MlflowClient()

# Register model from a run
result = mlflow.register_model(
    "runs:/abc123/model",
    "crop-disease-classifier"
)

# Transition to staging
client.transition_model_version_stage(
    name="crop-disease-classifier",
    version=3,
    stage="Staging"
)

# After testing, promote to production
client.transition_model_version_stage(
    name="crop-disease-classifier",
    version=3,
    stage="Production"
)

yaml — github actions CI/CD
# .github/workflows/ml-deploy.yml
name: ML Model CI/CD
on:
  push:
    branches: [main]

jobs:
  test-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run unit tests
        run: pytest tests/ -v

      - name: Run model validation
        run: |
          python scripts/validate_model.py \
            --min-accuracy 0.92 \
            --min-f1 0.89 \
            --max-latency-ms 50

      - name: Build Docker image
        run: docker build -t ml-app:${{ github.sha }} .

      - name: Push to registry
        run: |
          docker tag ml-app:${{ github.sha }} \
            gcr.io/my-project/ml-app:${{ github.sha }}
          docker push gcr.io/my-project/ml-app:${{ github.sha }}

      - name: Deploy to Cloud Run
        run: |
          gcloud run deploy ml-service \
            --image gcr.io/my-project/ml-app:${{ github.sha }} \
            --region asia-south1 \
            --memory 2Gi --cpu 2

22.1.4 Monitoring & Drift Detection

python
import numpy as np
from scipy import stats

def calculate_psi(expected, actual, bins=10):
    """Population Stability Index for drift detection."""
    # Bin the distributions
    breakpoints = np.linspace(0, 1, bins + 1)
    expected_pct = np.histogram(expected, breakpoints)[0] / len(expected)
    actual_pct = np.histogram(actual, breakpoints)[0] / len(actual)

    # Avoid division by zero
    expected_pct = np.clip(expected_pct, 1e-6, None)
    actual_pct = np.clip(actual_pct, 1e-6, None)

    # PSI formula
    psi = np.sum((actual_pct - expected_pct) * np.log(actual_pct / expected_pct))
    return psi

# Usage: compare training distribution vs production
train_scores = model.predict_proba(X_train)[:, 1]
prod_scores = model.predict_proba(X_production)[:, 1]

psi_value = calculate_psi(train_scores, prod_scores)
print(f"PSI = {psi_value:.4f}")
if psi_value > 0.2:
    print("⚠️ ALERT: Significant drift detected! Retrain recommended.")

22.2 Model Serving — Getting Predictions to Users

FastAPI: Your First Production Server

python — app.py
import torch
import torchvision.transforms as T
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
from PIL import Image
import io, time, logging

app = FastAPI(title="Crop Disease Classifier", version="1.0")
logger = logging.getLogger(__name__)

# Load model at startup (not per request!)
MODEL_PATH = "models/resnet50_crop_disease.pt"
CLASSES = ["Healthy", "Bacterial Blight", "Leaf Rust", "Powdery Mildew"]
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = torch.load(MODEL_PATH, map_location=device)
model.eval()

transform = T.Compose([
    T.Resize((224, 224)),
    T.ToTensor(),
    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

@app.get("/health")
async def health_check():
    return {"status": "healthy", "model_loaded": model is not None}

@app.post("/predict")
async def predict(file: UploadFile = File(...)):
    if not file.content_type.startswith("image/"):
        raise HTTPException(400, "File must be an image")

    start = time.perf_counter()

    # Read and preprocess
    image_bytes = await file.read()
    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
    tensor = transform(image).unsqueeze(0).to(device)

    # Inference
    with torch.no_grad():
        outputs = model(tensor)
        probs = torch.nn.functional.softmax(outputs, dim=1)
        confidence, predicted = torch.max(probs, 1)

    latency = (time.perf_counter() - start) * 1000
    logger.info(f"Prediction: {CLASSES[predicted.item()]} | Latency: {latency:.1f}ms")

    return {
        "prediction": CLASSES[predicted.item()],
        "confidence": round(confidence.item(), 4),
        "all_probabilities": {c: round(p, 4) for c, p in zip(CLASSES, probs[0].tolist())},
        "latency_ms": round(latency, 1)
    }

22.3 Containerization — Docker for ML

Docker solves the most infamous problem in software: "It works on my machine." A Docker container packages your code, model, Python version, all dependencies, and the exact OS configuration into a single, reproducible unit.

Multi-Stage Docker Build for ML

dockerfile
# Stage 1: Builder — install all dependencies
FROM python:3.11-slim AS builder

WORKDIR /app

# Install system deps for PyTorch
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc g++ && rm -rf /var/lib/apt/lists/*

# Install Python deps (cached layer if requirements unchanged)
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

# Stage 2: Runtime — minimal image
FROM python:3.11-slim AS runtime

WORKDIR /app

# Copy only installed packages (not build tools)
COPY --from=builder /install /usr/local

# Copy application code and model
COPY app.py .
COPY models/ ./models/

# Non-root user for security
RUN adduser --disabled-password --gecos '' mluser
USER mluser

# Health check
HEALTHCHECK --interval=30s --timeout=5s \
    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"

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

22.4 Model Optimization — Making Models Smaller and Faster

The Optimization Landscape

Quantization — The Physicist's View

python — PyTorch quantization
import torch
import torch.quantization

# Post-training static quantization
model = load_trained_model()
model.eval()

# Step 1: Fuse operations (Conv + BN + ReLU)
model_fused = torch.quantization.fuse_modules(
    model, [["conv1", "bn1", "relu"]]
)

# Step 2: Prepare for quantization (insert observers)
model_fused.qconfig = torch.quantization.get_default_qconfig("fbgemm")
model_prepared = torch.quantization.prepare(model_fused)

# Step 3: Calibrate with representative data
with torch.no_grad():
    for batch in calibration_loader:
        model_prepared(batch)

# Step 4: Convert to quantized model
model_quantized = torch.quantization.convert(model_prepared)

# Compare sizes
print(f"Original:   {get_model_size(model):.1f} MB")
print(f"Quantized:  {get_model_size(model_quantized):.1f} MB")
# Original:   97.8 MB
# Quantized:  24.6 MB  (4× smaller!)

Knowledge Distillation — Teacher-Student

python
import torch
import torch.nn.functional as F

def distillation_loss(student_logits, teacher_logits, labels, T=4.0, alpha=0.7):
    """
    Hinton's Knowledge Distillation Loss.

    T = temperature (higher → softer probabilities → more knowledge transfer)
    alpha = weight for soft targets vs hard targets
    """
    # Soft targets from teacher
    soft_teacher = F.softmax(teacher_logits / T, dim=1)
    soft_student = F.log_softmax(student_logits / T, dim=1)

    # KL divergence between soft distributions
    distill_loss = F.kl_div(soft_student, soft_teacher, reduction="batchmean") * (T ** 2)

    # Standard cross-entropy with true labels
    hard_loss = F.cross_entropy(student_logits, labels)

    # Combined loss
    return alpha * distill_loss + (1 - alpha) * hard_loss

# Training loop
teacher_model.eval()  # Frozen large model (e.g., ResNet152)
student_model.train()  # Small model (e.g., MobileNetV3)

for images, labels in train_loader:
    with torch.no_grad():
        teacher_logits = teacher_model(images)
    student_logits = student_model(images)

    loss = distillation_loss(student_logits, teacher_logits, labels)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

ONNX — The Universal Format

python
import torch
import onnx
import onnxruntime as ort

# Export PyTorch model to ONNX
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(
    model, dummy_input, "model.onnx",
    input_names=["image"],
    output_names=["prediction"],
    dynamic_axes={"image": {0: "batch_size"}},
    opset_version=17
)

# Run inference with ONNX Runtime (2-3× faster!)
session = ort.InferenceSession("model.onnx")
result = session.run(None, {"image": input_array})

22.5 Edge Deployment — Intelligence at the Source

Edge deployment means running inference on the device itself — a phone, a Raspberry Pi, a camera, a car — rather than sending data to the cloud. This is critical when:

• Network is unreliable: Rural India (2G/3G in many villages), remote construction sites
• Latency matters: Self-driving cars can't wait 200ms for a cloud response
• Privacy is paramount: Medical imaging on-device, never sending patient data to the cloud
• Cost matters: Sending terabytes of video to the cloud is expensive

python — TFLite conversion for Raspberry Pi
import tensorflow as tf

# Load a trained Keras model
model = tf.keras.models.load_model("crop_disease_model.h5")

# Convert to TFLite with INT8 quantization
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# Representative dataset for calibration
def representative_dataset():
    for image, _ in calibration_data.take(100):
        yield [tf.cast(image, tf.float32)]

converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8

tflite_model = converter.convert()

# Save — this will be ~4× smaller than the original
with open("crop_model_int8.tflite", "wb") as f:
    f.write(tflite_model)

print(f"Original:  {os.path.getsize('crop_disease_model.h5') / 1e6:.1f} MB")
print(f"TFLite:    {len(tflite_model) / 1e6:.1f} MB")

22.6 AI Ethics & Regulation — Building Responsibly

You've built a model that works. It's deployed, fast, and cheap to run. But here's the question that separates an engineer from a responsible engineer: Who does your model hurt?

22.6.1 Bias and Fairness

AI systems don't create bias — they amplify existing biases in data and society. In India, this takes unique forms:

Measuring Fairness — Key Metrics

python — Fairness audit
import numpy as np
import pandas as pd

def fairness_audit(predictions, labels, protected_attribute):
    """
    Comprehensive fairness audit for a binary classifier.

    predictions: array of 0/1 predictions
    labels: array of 0/1 true labels
    protected_attribute: array of group labels (e.g., 'male'/'female')
    """
    groups = np.unique(protected_attribute)
    results = {}

    for group in groups:
        mask = (protected_attribute == group)
        group_preds = predictions[mask]
        group_labels = labels[mask]

        # Selection rate (positive prediction rate)
        selection_rate = group_preds.mean()

        # True positive rate (equal opportunity)
        positives = group_labels == 1
        tpr = group_preds[positives].mean() if positives.sum() > 0 else 0

        # False positive rate
        negatives = group_labels == 0
        fpr = group_preds[negatives].mean() if negatives.sum() > 0 else 0

        results[group] = {
            "count": mask.sum(),
            "selection_rate": round(selection_rate, 4),
            "true_positive_rate": round(tpr, 4),
            "false_positive_rate": round(fpr, 4)
        }

    # Compute Disparate Impact Ratio
    rates = [r["selection_rate"] for r in results.values()]
    max_rate = max(rates)
    for group in results:
        results[group]["disparate_impact"] = round(
            results[group]["selection_rate"] / max_rate, 4
        )
        results[group]["passes_4_5ths"] = results[group]["disparate_impact"] >= 0.8

    return pd.DataFrame(results).T

# Example usage with Indian loan data
audit = fairness_audit(
    predictions=loan_preds,
    labels=loan_labels,
    protected_attribute=applicant_gender
)
print(audit)

22.6.2 Regulations Compared — DPDPA vs GDPR vs EU AI Act

22.6.3 Explainability — LIME, SHAP, Grad-CAM

If your model denies someone a loan, they have a right to know why. Explainability isn't optional — it's increasingly a legal requirement.

python — SHAP for tabular data
import shap

# Create SHAP explainer
explainer = shap.TreeExplainer(trained_model)

# Explain a single prediction
sample = X_test.iloc[42:43]  # One applicant
shap_values = explainer.shap_values(sample)

# Visualize: which features drove this decision?
shap.waterfall_plot(shap.Explanation(
    values=shap_values[0],
    base_values=explainer.expected_value,
    data=sample.values[0],
    feature_names=sample.columns.tolist()
))
# Output: "Income: +0.32, PIN code: -0.18, Age: +0.05, ..."
# This tells the applicant exactly why they were accepted/rejected.

python — Grad-CAM for image classification
import torch
import torch.nn.functional as F

def grad_cam(model, image_tensor, target_class, target_layer):
    """
    Generate Grad-CAM heatmap showing WHERE the model is looking.

    This answers: "The model classified this X-ray as pneumonia —
    but IS it looking at the lungs, or at the hospital's label sticker?"
    """
    activations = {}
    gradients = {}

    # Hook to capture forward activations
    def forward_hook(module, input, output):
        activations["value"] = output

    # Hook to capture backward gradients
    def backward_hook(module, grad_input, grad_output):
        gradients["value"] = grad_output[0]

    handle_f = target_layer.register_forward_hook(forward_hook)
    handle_b = target_layer.register_full_backward_hook(backward_hook)

    # Forward pass
    output = model(image_tensor)
    model.zero_grad()

    # Backward pass for target class
    one_hot = torch.zeros_like(output)
    one_hot[0, target_class] = 1
    output.backward(gradient=one_hot)

    # Grad-CAM computation
    weights = gradients["value"].mean(dim=[2, 3], keepdim=True)  # Global avg pool of grads
    cam = (weights * activations["value"]).sum(dim=1, keepdim=True)
    cam = F.relu(cam)  # Only positive contributions
    cam = F.interpolate(cam, size=image_tensor.shape[2:], mode="bilinear")
    cam = cam / cam.max()  # Normalize to [0, 1]

    handle_f.remove()
    handle_b.remove()

    return cam.squeeze().detach().numpy()

22.7 The Future — Where Deep Learning Is Headed

22.7.1 Foundation Models & Large Language Models

The shift from task-specific models to foundation models is the most significant paradigm change since deep learning itself. Instead of training a new model for each task, you train one massive model on vast data and then adapt it to downstream tasks.

22.7.2 Multimodal AI

The next frontier isn't just text or just images — it's models that understand everything at once. GPT-4V, Gemini, and Claude can process text, images, audio, video, and code in a unified framework.

22.7.3 AI Agents and Tool Use

The next evolution beyond chatbots: AI agents that can plan, execute multi-step tasks, use tools (search engines, code interpreters, APIs), and achieve complex goals autonomously.

22.7.4 Neuromorphic Computing

Traditional computers process information using the von Neumann architecture — separate memory and compute units. Your brain doesn't work this way. It processes information where it's stored, using ~20 watts (compared to ~300 watts for a GPU). Neuromorphic chips try to replicate this.

22.7.5 Quantum ML — A Brief Glimpse

Quantum Machine Learning (QML) uses quantum computing principles — superposition, entanglement — to potentially speed up certain ML tasks exponentially. It's early-stage, but worth knowing about.

22.8 Career Roadmap — Your Path Forward

Worked Examples

Example 1: By-Hand — Computing PSI for Drift Detection

Example 2: Indian Industry — Infosys Nia MLOps Pipeline

Example 3: US Industry — Netflix ML Platform

Python Implementation

From-Scratch: Simple Model Server (No Frameworks)

python — minimal_server.py (from scratch, no FastAPI)
import json
import numpy as np
from http.server import HTTPServer, BaseHTTPRequestHandler
import pickle

# Load a simple sklearn model (for demonstration)
with open("model.pkl", "rb") as f:
    model = pickle.load(f)

class MLHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/health":
            self._respond(200, {"status": "healthy"})
        else:
            self._respond(404, {"error": "Not found"})

    def do_POST(self):
        if self.path == "/predict":
            # Read request body
            length = int(self.headers["Content-Length"])
            body = json.loads(self.rfile.read(length))

            # Extract features and predict
            features = np.array(body["features"]).reshape(1, -1)
            prediction = model.predict(features)[0]
            probability = model.predict_proba(features)[0].tolist()

            self._respond(200, {
                "prediction": int(prediction),
                "probabilities": probability
            })

    def _respond(self, code, data):
        self.send_response(code)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(data).encode())

print("Server running on port 8000...")
HTTPServer(("", 8000), MLHandler).serve_forever()

Production: FastAPI + Docker + Monitoring

python — production_app.py
import time, logging
from collections import deque
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
import numpy as np
import torch

app = FastAPI(title="Production ML Service")
logger = logging.getLogger(__name__)

# ── Monitoring: track predictions for drift detection ──
prediction_buffer = deque(maxlen=1000)
latency_buffer = deque(maxlen=1000)

class PredictRequest(BaseModel):
    features: list[float] = Field(..., min_length=10, max_length=10)

class PredictResponse(BaseModel):
    prediction: int
    confidence: float
    latency_ms: float

@app.post("/predict", response_model=PredictResponse)
async def predict(req: PredictRequest):
    start = time.perf_counter()

    tensor = torch.FloatTensor(req.features).unsqueeze(0)
    with torch.no_grad():
        logits = model(tensor)
        probs = torch.softmax(logits, dim=1)
        confidence, pred = torch.max(probs, 1)

    latency = (time.perf_counter() - start) * 1000

    # Track for monitoring
    prediction_buffer.append(pred.item())
    latency_buffer.append(latency)

    return PredictResponse(
        prediction=pred.item(),
        confidence=confidence.item(),
        latency_ms=round(latency, 2)
    )

@app.get("/metrics")
async def metrics():
    """Prometheus-compatible metrics endpoint."""
    preds = list(prediction_buffer)
    lats = list(latency_buffer)
    return {
        "total_predictions": len(preds),
        "prediction_distribution": {
            str(i): preds.count(i) for i in set(preds)
        },
        "avg_latency_ms": round(np.mean(lats), 2) if lats else 0,
        "p99_latency_ms": round(np.percentile(lats, 99), 2) if lats else 0,
    }

Visual Aids

The MLOps Maturity Model

Model Optimization Decision Tree

Ethics Decision Framework

Common Misconceptions

GATE/Exam Corner

GATE Prediction Table (2025-2028)

Interview Prep

Conceptual Questions

Coding Question

Case Study Question (India Focus)

Hands-On Lab / Mini-Project

🚀 Project: End-to-End MLOps Pipeline for Crop Disease Detection

Objective: Build a complete pipeline from data versioning to deployed API with monitoring and fairness evaluation.

Phase 1: Data & Training (Week 1)

• Use PlantVillage dataset (38 classes, 87K images)
• Initialize Git + DVC for versioning
• Train ResNet18 with MLflow experiment tracking
• Target: > 90% validation accuracy

Phase 2: Optimization & Packaging (Week 2)

• Quantize to INT8 using PyTorch quantization
• Export to ONNX format
• Build FastAPI server with /predict, /health, /metrics endpoints
• Create multi-stage Dockerfile

Phase 3: Deploy & Monitor (Week 3)

• Deploy to Google Cloud Run or AWS Lambda
• Set up GitHub Actions CI/CD pipeline
• Implement PSI-based drift detection
• Add Grafana dashboard for monitoring

Phase 4: Ethics & Documentation (Week 4)

• Run Grad-CAM on misclassified images — is the model looking at relevant leaf regions?
• Test for geographic bias — does model accuracy differ for images from Indian farms vs US farms?
• Write model card documenting capabilities, limitations, and intended use

Rubric

Exercises (25 Questions)

Section A: Conceptual (5 Questions)

Section B: Mathematical / Analytical (8 Questions)

Section C: Coding (4 Questions)

Section D: Critical Thinking (3 Questions)

★ Starred Research Questions (2 Questions)

Connections

Chapter Summary

Further Reading

🇮🇳 Indian Resources

• NPTEL: "MLOps: Machine Learning Operations" — IIT Kharagpur (free, certificate available)
• NPTEL: "Ethics in AI" — IISc Bangalore
• DPDPA 2023 Full Text: MeitY Official Website
• NITI Aayog: "Responsible AI for All" — India's AI strategy document
• IndiaAI: indiaai.gov.in — Government AI portal

🌍 Global Resources

• Paper: Sculley et al., "Hidden Technical Debt in Machine Learning Systems" (NeurIPS 2015) — the foundational MLOps paper
• Paper: Hinton et al., "Distilling the Knowledge in a Neural Network" (2015) — knowledge distillation original
• Paper: Mehrabi et al., "A Survey on Bias and Fairness in Machine Learning" (ACM Computing Surveys, 2021)
• Book: Chip Huyen, "Designing Machine Learning Systems" (O'Reilly, 2022)
• Course: Stanford CS 329S "Machine Learning Systems Design"
• Tool Docs: MLflow, DVC, Weights & Biases
• 3Blue1Brown: Neural Networks series (visual intuition for the math behind everything in this textbook)
• Distill.pub: Archived — but the attention visualization and interpretability articles remain the best visual explanations