MLOps & Cloud

Chapter 10.1 – Git & GitHub

• Git is the backbone of modern software development and MLOps.

Every AI engineer, Data Engineer, Software Engineer, and MLOps Engineer uses Git every day to track code changes, collaborate with teams, and manage projects.

Learning Objectives

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

• Understand Version Control Systems (VCS).
• Learn Git architecture.
• Install Git.
• Use essential Git commands.
• Work with branches.
• Merge code changes.
• Resolve merge conflicts.
• Use GitHub effectively.
• Collaborate using Pull Requests.
• Understand GitHub Actions.

Apply Git best practices in AI/ML projects.

1. Introduction

Imagine you are developing a Machine Learning model.

Day 1

You create

• house_price_model.py
• Day 5
• You improve the model.
• Day 10

You accidentally delete an important section of code.

How do you recover it?

Without Git

• Very difficult.

With Git

✅ Simply restore the previous version.

This is why Git exists.

2. What is Git?

Definition

Git is a distributed Version Control System (VCS) that tracks changes in files, allowing developers to collaborate, maintain history, and restore previous versions.

Git was created by Linus Torvalds in 2005 to support Linux kernel development.

3. What is Version Control?

Version Control is the process of tracking changes made to files over time.

Instead of

• Project_Final.py
• Project_Final2.py
• Project_Final3.py
• Project_Final_Final.py
• Project_Final_Really_Final.py

Git stores every change in an organized history.

4. Why Do We Need Git?

Suppose three developers work on the same project.

Without Git

• Files get overwritten.
• Changes are lost.
• Collaboration becomes difficult.

With Git

• Everyone works independently.
• Changes are merged safely.
• History is preserved.

5. What is GitHub?

Git stores your project locally.

GitHub is a cloud platform that hosts Git repositories online, making collaboration easier.

Think of it this way

6. Git Architecture

Working Directory

│

git add

▼

Staging Area

│

git commit

▼

Local Repository

│

git push

▼

GitHub Repository

7. Working Directory

The Working Directory contains your project files.

Example

Project/

app.py

model.py

requirements.txt

Changes here are not yet tracked until you stage them.

8. Staging Area

The Staging Area is a temporary place where you choose which changes will be included in the next commit.

Example

git add app.py

Only app.py is staged.

9. Commit

A commit is a snapshot of your project at a specific point in time.

Example

git commit -m "Added prediction API"

Good commit messages describe what changed and, when useful, why.

10. Local Repository

The Local Repository stores the complete history of your project on your computer.

Example

11. Remote Repository

The Remote Repository is hosted on platforms such as GitHub.

Example

Local Repository

↓

git push

↓

GitHub

This enables collaboration and backup.

12. Git Workflow

Modify Files

│

▼

git status

│

▼

git add

│

▼

git commit

│

▼

git push

13. Installing Git

Windows

Download Git from

https://git-scm.com/

Verify Installation

git --version

Example Output

git version 2.45.0

(The version number will vary.)

14. Configure Git

Before using Git

git config --global user.name "Sreehari"
git config --global user.email "your_email@example.com"

Check configuration

git config --list

15. Initialize a Repository

Create a new Git repository.

git init

Output

Initialized empty Git repository

16. Check Repository Status

git status

Example Output

On branch main

Untracked files

app.py

17. Add Files

Add one file

git add app.py

Add all files

git add .

18. Commit Changes

git commit -m "Initial commit"

This creates the first snapshot.

19. View Commit History

git log

Example

• Commit 1
• Commit 2
• Commit 3

A more compact view

git log --oneline

20. Clone a Repository

Download an existing repository

git clone https://github.com/user/project.git

21. Connect to GitHub

Add a remote repository

git remote add origin https://github.com/user/project.git

View configured remotes

git remote -v

22. Push Changes

Upload commits

git push origin main

23. Pull Changes

Download updates

git pull origin main

This fetches changes from the remote repository and merges them into your current branch.

24. Branches

Branches allow multiple developers to work independently.

25. Create a Branch

git branch feature-api

Switch to it

git checkout feature-api

Or create and switch in one command

git checkout -b feature-api

Modern Git also supports

git switch -c feature-api

26. Merge Branches

git checkout main
git merge feature-api

Now the feature becomes part of the main branch.

27. Merge Conflict

Suppose

Developer A edits

learning_rate = 0.01

Developer B edits

learning_rate = 0.001

Git cannot decide automatically.

Conflict markers appear

<<<<<<< HEAD

learning_rate = 0.01

=======

learning_rate = 0.001

>>>>>>> feature

Resolve manually.

Then

git add .
git commit

28. Pull Requests (PR)

Instead of merging directly,

developers create a Pull Request.

Workflow

Benefits

• Code review
• Automated testing
• Team collaboration

29. GitHub Actions (CI)

GitHub Actions automate workflows.

Example

Every push

↓

Example workflow file

name: Python Tests

on: [push]

jobs

test

runs-on: ubuntu-latest

30. Common Git Commands

31. Git in Machine Learning Projects

Example project

HousePricePrediction/

│

├── data/

├── notebooks/

├── models/

├── src/

├── app/

• ├── requirements.txt
• ├── README.md
• └── .gitignore

Git tracks

• Source code
• Configuration files
• Documentation

Large datasets and trained models are often managed using tools like DVC, cloud storage, or model registries rather than storing them directly in Git.

32. The .gitignore File

Some files should not be committed.

Example

• __pycache__/
• .env
• *.log
• venv/
• .ipynb_checkpoints/

This prevents unnecessary or sensitive files from entering the repository.

33. Best Practices

• Write meaningful commit messages.
• Commit small, logical changes.
• Pull before pushing to avoid conflicts.
• Use feature branches.
• Review Pull Requests before merging.
• Never commit secrets (API keys, passwords).
• Keep the main branch stable.

34. Common Mistakes

• Committing passwords or API keys.
• Working directly on the main branch.
• Making one huge commit with unrelated changes.
• Ignoring merge conflicts.
• Forgetting to pull before pushing.

35. Interview Questions

Beginner

• What is Git?
• What is GitHub?
• What is Version Control?
• What is a Commit?
• What is the Staging Area?

Intermediate

• Difference between Git and GitHub?
• What is a Branch?
• What is Merge?
• What is a Pull Request?
• What is a Merge Conflict?

Advanced

• Explain the Git workflow.
• What is GitHub Actions?
• How would you manage large ML datasets in Git?
• Why should secrets never be committed?
• How do you resolve merge conflicts?

Mini Project

Version-Control an ML Project

• Objective
• Create a Git repository for a machine learning project.
• Tasks
• Initialize a repository.
• Add a .gitignore file.
• Commit the initial project.
• Create a feature branch.
• Add a new prediction feature.

Merge the branch using a Pull Request.

Push the project to GitHub.

Chapter Summary

Git is a distributed version control system that tracks changes to your code, while GitHub is a cloud-based platform for hosting Git repositories and collaborating with others. Together, they enable developers to work efficiently, maintain a complete project history, review code through Pull Requests, and automate workflows using GitHub Actions. Git is a foundational skill for software engineering, data engineering, machine learning, and MLOps.

Git Workflow Cheat Sheet

Create Project

│

▼

git init

│

▼

Modify Files

│

▼

git status

│

▼

git add .

│

▼

git commit -m "message"

│

▼

git push origin main

│

▼

GitHub Repository

What's Next?

In Chapter 10.2 – Docker, you'll learn how to package your machine learning application—including Python code, dependencies, and configuration—into a portable container that runs consistently on your laptop, a server, or the cloud. Docker is one of the most important technologies in modern MLOps because it eliminates the classic "it works on my machine" problem.

Chapter 10.2 – Docker

• Docker is one of the most important technologies in MLOps.

Almost every production AI application—whether it's deployed on Azure, AWS, Google Cloud, or Kubernetes—runs inside a Docker container.

Learning Objectives

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

• Understand what Docker is.
• Learn why Docker is important.
• Understand Containers vs Virtual Machines.
• Learn Docker Architecture.
• Work with Docker Images and Containers.
• Write Dockerfiles.
• Use Docker Compose.
• Build Docker images.
• Deploy ML applications in Docker.
• Learn Docker best practices.

1. Introduction

• Imagine you build a Machine Learning application on your laptop.
• It works perfectly.
• You send it to another developer.

They run it and get

ModuleNotFoundError

No module named 'scikit-learn'

Another developer gets

Python version not supported

Someone else gets

TensorFlow version mismatch

This problem is called

"It works on my machine."

Docker solves this problem.

2. What is Docker?

Definition

Docker is an open-source platform that packages an application along with its dependencies, libraries, and runtime into a portable container that can run consistently on any system that supports Docker.

• Think of Docker as a shipping container.
• Just as a shipping container carries goods safely across ships, trains, and trucks,
• Docker containers carry software safely across laptops, servers, and cloud platforms.

3. Why Do We Need Docker?

Suppose your ML application requires

• Python 3.11
• TensorFlow 2.18
• NumPy 2.x
• Pandas
• FastAPI
• CUDA libraries

Without Docker

Every server must be configured manually.

With Docker

Everything is packaged together.

Run

docker run house-price-api

The application runs the same everywhere.

4. Containers vs Virtual Machines

Virtual Machine

Each Virtual Machine contains its own operating system.

Advantages

Strong isolation

Disadvantages

• Large size
• Slower startup
• Higher memory usage
• Docker Container

Containers share the host operating system kernel.

Advantages

• Lightweight
• Fast startup
• Lower memory usage
• Easier to deploy
• Containers vs Virtual Machines

5. Docker Architecture

│

▼

Docker Engine

│

┌─────────────┴─────────────┐

▼ ▼

Docker Images Docker Containers

6. Docker Components

Docker Client

This is where you type commands.

Example

docker build

• Docker Engine
• The service that creates and manages containers.
• Docker Image

An Image is a blueprint or template for creating containers.

Example

Docker Container

A Container is a running instance of an image.

Example

Docker Image

↓

docker run

↓

Running Container

7. Image vs Container

Example

• Container 2
• Container 3
• One image can create multiple containers.

8. Installing Docker

Windows

• Download
• Docker Desktop
• After installation

Check version

docker --version

• Example Output
• Docker version 27.x.x
• (The version number will vary.)

9. First Docker Command

docker run hello-world

Docker will

• Download the image (if needed).
• Create a container.
• Run the program.
• Display a success message.

10. Docker Workflow

Application

│

▼

Dockerfile

│

docker build

▼

Docker Image

│

docker run

▼

Docker Container

11. Dockerfile

A Dockerfile contains instructions to build an image.

Example

• FROM python:3.11
• WORKDIR /app
• COPY . .
• RUN pip install -r requirements.txt
• CMD ["python", "app.py"]

Explanation

• FROM → Base image.
• WORKDIR → Working directory.
• COPY → Copy project files.
• RUN → Execute commands during image build.
• CMD → Default command when the container starts.

12. Build Docker Image

docker build -t house-price-api .

Meaning

docker build

↓

house-price-api

13. View Images

docker images

Example

14. Run a Container

docker run house-price-api

If your application is a web API, expose a port

docker run -p 8000:8000 house-price-api

Here

First 8000 → Host machine port.

Second 8000 → Container port.

15. Running Containers

List running containers

docker ps

List all containers

docker ps -a

16. Stop a Container

docker stop container_id

17. Remove a Container

docker rm container_id

18. Remove an Image

docker rmi image_name

19. Docker Hub

Docker Hub is a cloud repository for Docker images.

Examples

• Python
• Ubuntu
• PostgreSQL
• Redis
• MongoDB
• Nginx

Workflow

20. Docker Compose

Suppose your project uses

• FastAPI
• PostgreSQL
• Redis
• Instead of starting each container manually,
• Docker Compose starts them together.

Example

version: "3"

services

app

build: .

ports

- "8000:8000"

db

image: postgres

redis

image: redis

Start everything

docker compose up

21. Docker Volumes

Containers are temporary.

• If a container is deleted,
• its internal data may also be lost.
• Volumes store data outside the container.

Example

• Database files
• Model files
• Logs
• Uploaded documents

22. Docker Networking

Containers communicate through networks.

Example

23. Docker for Machine Learning

Typical ML project

Your Docker image may contain

• Python
• NumPy
• Pandas
• Scikit-learn
• FastAPI
• Trained Model
• API Code
• Everything is packaged together.

24. Dockerizing a FastAPI Model

Project

HousePriceAPI/

│

• ├── app.py
• ├── model.pkl
• ├── requirements.txt
• └── Dockerfile

Dockerfile

• FROM python:3.11
• WORKDIR /app
• COPY . .
• RUN pip install -r requirements.txt
• EXPOSE 8000

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

This creates a production-ready API container.

25. Docker in MLOps Pipeline

Train Model

│

▼

Save Model

│

▼

FastAPI

│

▼

Docker Image

│

▼

Docker Registry

│

▼

Kubernetes

│

▼

Production

26. Advantages

• Consistent environments.
• Easy deployment.
• Lightweight.
• Portable.
• Faster than virtual machines.
• Simplifies dependency management.

27. Limitations

• Containers share the host kernel, so they are not the same as full virtual machines.
• Large ML images can become very large if unnecessary packages are included.
• GPU support requires additional configuration (for example, NVIDIA Container Toolkit).

28. Best Practices

• Use lightweight base images when possible.
• Pin dependency versions.
• Keep images small.
• Use .dockerignore to exclude unnecessary files.
• Store secrets outside the image.
• Use multi-stage builds for production images when appropriate.

29. Common Mistakes

• Copying unnecessary files into the image.
• Running applications as the root user when avoidable.
• Hardcoding passwords or API keys.
• Forgetting to expose the required port.
• Building very large images with unused packages.

30. Interview Questions

Beginner

• What is Docker?
• What is a Container?
• What is an Image?
• What is Docker Hub?
• Difference between Image and Container?

Intermediate

• Docker vs Virtual Machine?
• What is Docker Compose?
• What is a Dockerfile?
• What are Docker Volumes?
• What are Docker Networks?

Advanced

• How would you Dockerize a Machine Learning application?
• How would you reduce Docker image size?
• Why use Docker in MLOps?
• How do containers communicate?
• How would you deploy a FastAPI application using Docker?

Mini Project

• Dockerize a House Price Prediction API
• Project Structure
• HousePriceAPI/
• ├── app.py
• ├── model.pkl
• ├── requirements.txt
• ├── Dockerfile
• └── .dockerignore
• Tasks
• Train a regression model.
• Save it as model.pkl.
• Build a FastAPI prediction API.
• Create a Dockerfile.
• Build the Docker image.
• Run the container.

Test the API using a browser or Postman.

Chapter Summary

Docker packages an application and all of its dependencies into a portable container, ensuring it runs consistently across development, testing, and production environments. It has become a cornerstone of modern MLOps because it simplifies deployment, improves reproducibility, and integrates seamlessly with orchestration platforms like Kubernetes and cloud services.

Docker Workflow Cheat Sheet

Application

│

▼

Dockerfile

│

docker build

▼

Docker Image

│

docker run

▼

Container

│

▼

Docker Hub / Registry

│

▼

Kubernetes / Cloud

What's Next?

In Chapter 10.3 – Kubernetes, you'll learn how to deploy and manage multiple Docker containers at scale. You'll explore concepts such as Pods, Deployments, Services, ReplicaSets, Auto Scaling, and Rolling Updates, which enable highly available and production-ready AI applications.

Chapter 10.3 – Kubernetes

• Docker creates containers. Kubernetes manages them.

Modern companies such as Google, Microsoft, Amazon, Netflix, Uber, Spotify, and OpenAI use Kubernetes (often abbreviated as K8s) to deploy, scale, and manage thousands of containerized applications.

Learning Objectives

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

• Understand what Kubernetes is.
• Learn why Kubernetes is needed.
• Understand Kubernetes architecture.
• Learn Pods, Nodes, Clusters, Deployments, ReplicaSets, and Services.
• Understand Load Balancing and Auto Scaling.
• Deploy Machine Learning models on Kubernetes.
• Learn Kubernetes best practices.
• Prepare for Kubernetes interview questions.

1. Introduction

Imagine you built an AI model using FastAPI and Docker.

You deploy it.

Initially

10 Users

Everything works well.

One month later

100,000 Users

Problems begin

• Server crashes.
• API becomes slow.
• Memory usage reaches 100%.
• Some containers stop unexpectedly.

How do you automatically

• Restart failed containers?
• Scale to handle more users?
• Distribute traffic?
• Update applications without downtime?

Kubernetes solves these problems.

2. What is Kubernetes?

Definition

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, networking, and management of containerized applications.

Kubernetes was originally developed by Google based on its internal container management systems and is now maintained by the Cloud Native Computing Foundation (CNCF).

3. Why Do We Need Kubernetes?

Docker can run containers.

Example

But Docker alone doesn't automatically handle

• High availability
• Auto scaling
• Load balancing
• Self-healing
• Rolling updates
• Kubernetes provides these capabilities.

4. Kubernetes vs Docker

Important: Kubernetes uses container runtimes—it does not replace Docker images. Modern Kubernetes clusters commonly use runtimes such as containerd or CRI-O, while still running images built with Docker.

5. Kubernetes Architecture

Kubernetes Cluster

│

┌─────────────────┴─────────────────┐

│ │

▼ ▼

Control Plane Worker Nodes

│ │

│ ┌────────┴────────┐

▼ ▼ ▼

Scheduler Pod 1 Pod 2

API Server (Container) (Container)

Controller

etcd

6. What is a Cluster?

A Cluster is a group of computers (nodes) working together.

Example

• Cluster
• ├── Node 1
• ├── Node 2
• ├── Node 3
• └── Node 4
• Together, they run your application reliably.

7. What is a Node?

A Node is a physical or virtual machine in a Kubernetes cluster.

Each node contains

• Operating System
• Container Runtime
• Kubelet
• Running Pods

8. Control Plane vs Worker Node

9. What is a Pod?

A Pod is the smallest deployable unit in Kubernetes.

A Pod usually contains one application container, though it can contain multiple closely related containers.

Example

10. Pod Example

Node

│

├── Pod A

│ └── FastAPI

│

├── Pod B

│ └── FastAPI

│

└── Pod C

└── FastAPI

11. Why Pods?

Instead of running containers directly,

Kubernetes manages Pods because they provide

• Networking
• Shared storage
• Lifecycle management
• Health monitoring

12. ReplicaSet

Suppose you need

3 API Instances

ReplicaSet ensures

• Pod 1
• Pod 2
• Pod 3
• If Pod 2 crashes,
• Kubernetes automatically creates another Pod.
• This behavior is called self-healing.

13. Deployment

A Deployment manages ReplicaSets and Pods.

Example

Benefits

• Rolling updates
• Rollbacks
• Scaling
• Self-healing

14. Kubernetes Service

• Pods receive dynamic IP addresses.
• Users should not connect directly to Pods.
• A Service provides a stable endpoint.

15. Load Balancing

Suppose there are four Pods.

• Pod 2
• Pod 3
• Pod 4

Incoming requests are distributed across the Pods.

This improves performance and reliability.

16. Auto Scaling

Initially

2 Pods

Traffic increases.

Kubernetes automatically scales

8 Pods

Traffic decreases.

Scale back to

2 Pods

This helps optimize resource usage.

17. Self-Healing

Suppose

Kubernetes detects the failure.

Automatically

Create New Pod

No manual intervention required.

18. Rolling Updates

Instead of stopping everything,

Kubernetes updates Pods gradually.

Users continue accessing the application during the rollout.

19. Rollback

Suppose Version 2 has a bug.

Kubernetes can roll back to Version 1.

20. Kubernetes Objects

21. ConfigMap

Store configuration separately.

Example

• DATABASE_NAME
• API_URL
• MODEL_PATH

This allows configuration changes without rebuilding the image.

22. Secret

Sensitive values should never be stored in source code.

Examples

• Database Password
• API Key
• Azure Credentials
• AWS Keys
• Store them securely using Secrets.

23. Ingress

Instead of exposing many services separately,

Ingress routes external traffic.

Example

24. Kubernetes Workflow

Application

│

▼

Docker Image

│

▼

Deployment

│

▼

ReplicaSet

│

▼

Pods

│

▼

Service

│

▼

Users

25. Kubernetes Commands

Create deployment

kubectl create deployment ml-api --image=house-price-api

View Pods

kubectl get pods

View Deployments

kubectl get deployments

View Services

kubectl get services

Delete Pod

kubectl delete pod pod-name

Scale Deployment

kubectl scale deployment ml-api --replicas=5

26. Kubernetes YAML

Example Deployment

apiVersion: apps/v1

kind: Deployment

metadata

name: ml-api

spec

replicas: 3

selector

matchLabels

app: ml-api

template

metadata

labels

app: ml-api

spec

containers

- name: api

image: house-price-api

This configuration ensures three replicas of the application.

27. Kubernetes in MLOps

A typical production workflow

Train Model

│

▼

Save Model

│

▼

Docker Image

│

▼

Container Registry

│

▼

Kubernetes Deployment

│

▼

REST API

│

▼

Users

28. Real-World Example

Suppose Netflix receives

10 Million Requests

One server is not enough.

Kubernetes automatically

• Creates additional Pods.
• Distributes traffic.
• Restarts failed Pods.
• Updates applications without downtime.

The same concepts apply to large-scale ML inference services.

29. Advantages

• Automatic scaling.
• Self-healing.
• High availability.
• Rolling updates.
• Rollbacks.
• Load balancing.
• Portable across cloud providers.

30. Limitations

• Steeper learning curve than Docker alone.
• More operational complexity.
• Requires careful monitoring and resource management.
• Small projects may not need Kubernetes.

31. Best Practices

• Use Docker images with Kubernetes.
• Define CPU and memory requests/limits.
• Store secrets using Kubernetes Secrets.
• Use health probes (liveness and readiness).
• Monitor clusters using tools such as Prometheus and Grafana.
• Use rolling updates instead of deleting all Pods at once.

32. Common Mistakes

• Running everything in a single Pod.
• Hardcoding passwords.
• Ignoring resource limits.
• Not using health checks.
• Deploying directly to production without testing.

33. Interview Questions

Beginner

• What is Kubernetes?
• What is a Pod?
• What is a Node?
• What is a Cluster?
• Difference between Docker and Kubernetes?

Intermediate

• What is a Deployment?
• What is a ReplicaSet?
• What is a Kubernetes Service?
• What is Ingress?
• What is ConfigMap?

Advanced

• Explain Kubernetes Architecture.
• How does Kubernetes perform self-healing?
• How do rolling updates work?
• How would you deploy a FastAPI application?
• How would you deploy an ML model on Kubernetes?

Mini Project

• Deploy a House Price Prediction API on Kubernetes
• Project Structure
• HousePriceAPI/
• ├── app.py
• ├── model.pkl
• ├── Dockerfile
• ├── deployment.yaml
• └── service.yaml
• Tasks
• Build the Docker image.
• Push the image to a container registry.
• Create a Kubernetes Deployment.
• Expose it with a Service.
• Scale to five replicas.
• Verify load balancing.

Perform a rolling update with a new image version.

Chapter Summary

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, networking, and management of containerized applications. While Docker packages applications into containers, Kubernetes ensures those containers remain available, scalable, and resilient in production through features such as Pods, Deployments, ReplicaSets, Services, Auto Scaling, Self-Healing, and Rolling Updates.

Kubernetes Workflow Cheat Sheet

Build Application

│

▼

Docker Image

│

▼

Container Registry

│

▼

Kubernetes Deployment

│

▼

ReplicaSet

│

▼

Pods

│

▼

Service

│

▼

Load Balancer

│

▼

Users

What's Next?

In Chapter 10.4 – MLflow, you'll learn how to track machine learning experiments, compare model performance, store trained models in a Model Registry, manage model versions, and streamline the transition from experimentation to production—one of the core practices in modern MLOps.

Chapter 10.4 – MLflow

• MLflow is one of the most widely used open-source MLOps platforms for managing the complete Machine Learning lifecycle.

It helps Data Scientists and ML Engineers track experiments, compare models, register models, and deploy them to production.

Learning Objectives

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

• Understand what MLflow is.
• Learn why MLflow is important.
• Understand experiment tracking.
• Learn about parameters, metrics, and artifacts.
• Understand the Model Registry.
• Learn model versioning.
• Deploy models using MLflow.
• Build an end-to-end ML workflow.
• Prepare for MLflow interview questions.

1. Introduction

• Imagine you are training a Machine Learning model.
• Experiment 1
• Algorithm: Random Forest
• Trees: 100
• Accuracy: 91%
• Experiment 2
• Algorithm: Random Forest
• Trees: 200
• Accuracy: 93%
• Experiment 3
• Algorithm: XGBoost
• Learning Rate: 0.05
• Accuracy: 95%

After one month your manager asks

• Which model was the best?
• What parameters did you use?
• Can you reproduce Experiment 2?
• If you didn't record everything,
• you probably won't remember.
• MLflow solves this problem.

2. What is MLflow?

Definition

MLflow is an open-source MLOps platform that manages the Machine Learning lifecycle, including experiment tracking, model packaging, model registry, and deployment.

MLflow was originally developed by Databricks and is now maintained as an open-source project.

3. Why Do We Need MLflow?

Suppose you train

• 20 Random Forest models
• 15 XGBoost models
• 12 Neural Networks

Questions arise

• Which model performed best?
• Which hyperparameters produced the best accuracy?
• Which model is in production?
• Which dataset version was used?

MLflow automatically stores this information.

4. Machine Learning Without MLflow

Experiment 1

Accuracy = 92%
------------------
Experiment 2

Accuracy = ??

------------------

• Experiment 3
• Learning Rate = ??
• After a few weeks,

it becomes difficult to remember what was done.

5. Machine Learning With MLflow

Everything is tracked automatically.

6. MLflow Components

MLflow consists of four main components

• MLflow
• ├── Tracking
• ├── Projects
• ├── Models
• └── Model Registry

7. MLflow Tracking

Tracking records every experiment.

It stores

• Parameters
• Metrics
• Model
• Artifacts
• Tags
• Execution Time

Example

8. Parameters

Parameters are values chosen before training.

Examples

Learning Rate = 0.01

Batch Size = 32

Epochs = 100

Max Depth = 10

These influence model training.

9. Metrics

Metrics measure model performance after or during training.

Examples

• Accuracy
• Precision
• Recall
• F1 Score
• ROC-AUC
• RMSE
• MAE

Example

Accuracy = 96%
F1 Score = 0.94

Precision = 0.95

10. Artifacts

Artifacts are files generated during training.

Examples

• Trained Model
• Confusion Matrix
• ROC Curve
• Feature Importance Plot
• Log Files
• Training Dataset Sample

Example

11. Experiments

An experiment is a collection of related training runs.

Example

House Price Prediction

│

• ├── Run 1
• ├── Run 2
• ├── Run 3
• └── Run 4

Each run stores different hyperparameters and results.

12. Runs

Every training execution is called a Run.

Example

Run 1

Algorithm = Random Forest
Accuracy = 91%
------------------
Run 2

Algorithm = XGBoost
Accuracy = 95%

Runs can be compared easily.

13. MLflow Architecture

ML Training

│

▼

MLflow Tracking

│

▼

Experiment Database

│

▼

Artifacts

│

▼

Model Registry

│

▼

Deployment

14. Install MLflow

Install using pip

pip install mlflow

Check version

mlflow --version

15. Start MLflow UI

• mlflow ui
• Default URL
• http://127.0.0.1:5000

The UI displays

• Experiments
• Runs
• Metrics
• Parameters
• Artifacts

16. First MLflow Example

import mlflow

with mlflow.start_run()

mlflow.log_param("learning_rate", 0.01)

mlflow.log_metric("accuracy", 0.95)

Now MLflow records

Learning Rate = 0.01

Accuracy = 95%
17. Logging Parameters

mlflow.log_param("epochs",100)

mlflow.log_param("batch_size",32)

18. Logging Metrics

• mlflow.log_metric("accuracy",0.97)
• mlflow.log_metric("precision",0.95)
• mlflow.log_metric("recall",0.94)

19. Logging Artifacts

mlflow.log_artifact("model.pkl")

Or save a chart

mlflow.log_artifact("roc_curve.png")

20. Logging Models

Example using Scikit-learn

import mlflow.sklearn

• mlflow.sklearn.log_model(
• model,
• "house_price_model"

)

MLflow stores the trained model along with metadata.

21. Model Registry

The Model Registry is a centralized repository for trained models.

It helps manage different versions of a model.

22. Model Stages

A model typically moves through stages

• None
• Newly registered model.
• Staging
• Being tested.
• Production
• Currently serving users.
• Archived

Retained for history but no longer active.

23. Model Versioning

Suppose

House Price Model

If Version 3 performs poorly,

you can roll back to Version 2.

24. Compare Experiments

MLflow UI displays

Choosing the best model becomes much easier.

25. MLflow Projects

MLflow Projects package ML code into a reusable format.

Typical structure

• HousePriceProject/
• ├── MLproject
• ├── train.py
• ├── requirements.txt

└── data/

This improves reproducibility.

26. MLflow Models

MLflow supports many frameworks.

Examples

• Scikit-learn
• TensorFlow
• PyTorch
• XGBoost
• LightGBM
• CatBoost

27. Deploy Model

Serve a model locally

mlflow models serve \

-m runs:/RUN_ID/model

MLflow creates a REST API endpoint for inference.

28. MLflow Workflow

Train Model

│

▼

Log Parameters

│

▼

Log Metrics

│

▼

Log Artifacts

│

▼

Register Model

│

▼

Deploy

29. MLflow in MLOps

MLflow fits naturally into an end-to-end MLOps pipeline.

30. Real-World Example

Suppose you build a Customer Churn Prediction model.

You try

• Logistic Regression
• Random Forest
• XGBoost
• LightGBM

MLflow records

• Hyperparameters
• Accuracy
• Precision
• Recall
• F1 Score
• Training Time
• Model File

You compare results and promote the best model to Production.

31. Advantages

• Complete experiment tracking.
• Easy model comparison.
• Centralized model registry.
• Framework independent.
• Supports reproducibility.
• Integrates well with cloud platforms.

32. Limitations

• Requires storage for artifacts and metadata.
• Team deployments benefit from configuring a shared tracking server.
• Does not replace orchestration tools such as Kubernetes or Airflow.
• Large-scale deployments require proper infrastructure planning.

33. Best Practices

• Log every experiment.
• Track all important hyperparameters.
• Save evaluation metrics.
• Store important artifacts.
• Register only validated models.
• Use meaningful experiment names.
• Version datasets separately (for example, with DVC).

34. Common Mistakes

• Forgetting to log hyperparameters.
• Logging only accuracy.
• Not saving trained models.
• Overwriting production models without validation.
• Ignoring experiment organization.

35. Interview Questions

Beginner

• What is MLflow?
• Why is MLflow used?
• What is Experiment Tracking?
• What are Parameters?
• What are Metrics?

Intermediate

• What are Artifacts?
• What is Model Registry?
• What is Model Versioning?

Explain MLflow Architecture.

How do you compare experiments?

Advanced

• How would you use MLflow in a production ML pipeline?
• How do you deploy a model using MLflow?
• How would you manage multiple model versions?
• How does MLflow integrate with Docker and Kubernetes?
• How would you track experiments for hundreds of models?

Mini Project

• MLflow Experiment Tracking for House Price Prediction
• Project Structure
• HousePricePrediction/
• ├── train.py

├── data/

• ├── models/
• ├── requirements.txt
• └── MLproject
• Tasks
• Train three different algorithms (Linear Regression, Random Forest, XGBoost).
• Log all hyperparameters.
• Log Accuracy/RMSE/MAE (depending on the problem type).
• Save trained models.
• Compare experiments in the MLflow UI.
• Register the best-performing model.
• Serve the model locally using MLflow.
• MLflow Workflow Cheat Sheet
• Train Model

│

▼

Log Parameters

│

▼

Log Metrics

│

▼

Log Artifacts

│

▼

Register Model

│

▼

Deploy

│

▼

Production

Chapter Summary

MLflow is an open-source MLOps platform that simplifies the machine learning lifecycle by tracking experiments, logging parameters and metrics, storing artifacts, registering models, and supporting deployment. It helps teams build reproducible, organized, and production-ready machine learning workflows, making it an essential tool for modern MLOps.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

You now know how to

• Version your code with Git.
• Package applications using Docker.
• Orchestrate containers with Kubernetes.

Track and manage machine learning experiments using MLflow.

What's Next?

In Chapter 10.5 – DVC (Data Version Control), you'll learn how to version datasets, trained models, and ML pipelines. While Git tracks your source code, DVC manages large data files and ensures your machine learning experiments are fully reproducible. This combination of Git + DVC + MLflow forms the foundation of many production MLOps workflows.

Chapter 10.5 – DVC (Data Version Control)

• Git is excellent for versioning code, but it is not designed for large datasets and machine learning models.

DVC (Data Version Control) solves this problem by versioning datasets, models, and ML pipelines while working seamlessly with Git.

Learning Objectives

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

• Understand what DVC is.
• Learn why DVC is needed.
• Understand Git vs DVC.
• Track datasets and ML models.
• Version machine learning pipelines.
• Use remote storage.
• Build reproducible ML workflows.
• Integrate DVC with Git and MLflow.
• Prepare for DVC interview questions.

1. Introduction

Imagine you're building a customer churn prediction model.

Your project contains

• Source Code
• 20 MB
• Dataset
• 15 GB
• Trained Model
• 3 GB

Git works perfectly for the source code.

But Git struggles with

• Large datasets
• Large model files
• Frequent updates to binary files

This is where DVC comes in.

2. What is DVC?

Definition

DVC (Data Version Control) is an open-source version control system for machine learning datasets, models, and pipelines that integrates with Git.

Think of DVC as Git for Data.

Git tracks

Python Code

DVC tracks

• Datasets
• Models
• ML Pipelines

3. Why Do We Need DVC?

• Suppose your project evolves over time.
• Version 1
• Dataset
• 10,000 Rows
• Version 2
• Dataset
• 100,000 Rows
• Version 3
• Dataset
• 2 Million Rows

Now imagine someone asks

Which dataset was used to train Model Version 2?

Without DVC

• Difficult to answer.

With DVC

✅ Every dataset version is linked to the corresponding Git commit.

4. Git vs DVC

5. How DVC Works

Instead of storing a 10 GB dataset inside Git

Git remains lightweight while DVC manages large files efficiently.

6. DVC Architecture

Project

│

▼

Git Repository

│

▼

DVC Metadata

│

▼

Remote Storage

(Azure, AWS, GCP, Local)

7. Install DVC

Install using pip

pip install dvc

Check version

dvc version

8. Initialize DVC

Inside your Git repository

dvc init

This creates

.dvc/

.dvcignore

Commit the initialization

git add .
git commit -m "Initialize DVC"

9. Add a Dataset

Suppose you have

data/

customer.csv

Track it with DVC

dvc add data/customer.csv

DVC creates

customer.csv.dvc

The .dvc file stores metadata such as the file hash and location.

10. Commit Dataset Metadata

git add customer.csv.dvc
git commit -m "Track customer dataset"

Notice

Git stores only the small metadata file—not the large dataset itself.

11. Remote Storage

Large files are stored in remote storage.

Supported options include

• Local Storage
• Amazon S3
• Azure Blob Storage
• Google Cloud Storage
• SSH Server
• Network File System

Example

12. Configure Remote Storage

Example

dvc remote add -d storage s3://my-dvc-storage

Or Azure Blob Storage

dvc remote add -d storage azure://mlstorage

(Additional authentication configuration is required.)

13. Push Data

Upload datasets

dvc push

Workflow

14. Pull Data

Download datasets

dvc pull

Useful when another developer clones the repository.

15. DVC Pipeline

A Machine Learning pipeline consists of multiple stages.

Example

DVC can define and reproduce these stages.

16. Create a Pipeline Stage

Example

• dvc stage add \
• -n train \
• -d train.py \
• -d data/customer.csv \
• -o model.pkl \

python train.py

This tells DVC

• Input files
• Output files
• Command to execute

17. Reproduce Pipeline

Run

• dvc repro
• DVC checks whether dependencies have changed.
• If data or code changed,
• only the necessary stages are executed.

18. Pipeline Graph

Raw Data

│

▼

Cleaning

│

▼

Feature Engineering

│

▼

Training

│

▼

Evaluation

Each stage depends on the previous one.

19. DVC Lock File

DVC creates

dvc.lock

This file records

• Input versions
• Output versions
• Command used
• Dependency hashes
• It enables reproducibility.

20. Versioning Models

Suppose

model.pkl

Track it

dvc add model.pkl

Now every trained model version is linked to a Git commit.

21. DVC + Git + MLflow

Together they provide a complete MLOps workflow.

────────────

────────────

Responsibilities

• Git → Source code
• DVC → Data and models
• MLflow → Experiments and model lifecycle

22. Typical MLOps Workflow

23. Real-World Example

Suppose you build a loan approval model.

Using DVC,

you can always identify

• Which dataset trained each model.
• Which Git commit contains the code.
• Which MLflow run contains the metrics.

24. Advantages

• Handles large datasets efficiently.
• Version controls ML models.
• Works with Git.
• Supports cloud storage.
• Creates reproducible ML pipelines.
• Enables collaboration among teams.

25. Limitations

• Requires remote storage for large teams.
• Adds additional tooling to the workflow.
• Team members need to understand both Git and DVC.
• Binary file transfers can still take time.

26. Best Practices

• Store datasets using DVC—not Git.
• Commit .dvc files to Git.
• Use remote storage.
• Version trained models.
• Build reproducible pipelines.
• Keep datasets organized.

27. Common Mistakes

• Committing 20 GB datasets directly to Git.
• Forgetting to run dvc push.
• Not versioning trained models.
• Ignoring dvc.lock.
• Mixing temporary files with tracked datasets.

28. Interview Questions

Beginner

• What is DVC?
• Why do we need DVC?
• Difference between Git and DVC?
• What is a .dvc file?
• What is dvc.lock?

Intermediate

• How does DVC store large datasets?
• What is dvc push?
• What is dvc pull?
• What is a DVC pipeline?
• How does DVC ensure reproducibility?

Advanced

• Explain Git + DVC + MLflow architecture.
• How would you version datasets?
• How would you reproduce an ML experiment?
• How would you manage multiple dataset versions?
• How would you build a production ML pipeline using DVC?

29. Mini Project

• Version a House Price Dataset
• Project Structure
• HousePricePrediction/

├── data/

│ └── house_prices.csv

│

• ├── train.py
• ├── model.pkl
• ├── dvc.yaml
• ├── dvc.lock

└── .dvc/

• Tasks
• Initialize DVC.
• Track the dataset.
• Configure remote storage.
• Build a training pipeline.
• Track the trained model.
• Push data to remote storage.
• Clone the project on another machine.
• Pull the dataset.
• Reproduce the pipeline.

30. Complete MLOps Architecture

Developer

│

▼

Git Repository

│

▼

DVC

(Data Versioning)

│

▼

MLflow

(Experiment Tracking)

│

▼

Docker

│

▼

Kubernetes

│

▼

Cloud Deployment

Chapter Summary

DVC extends Git by providing version control for datasets, machine learning models, and ML pipelines. It stores lightweight metadata in Git while keeping large files in external storage, making collaboration and reproducibility practical for machine learning projects. When combined with Git for source code and MLflow for experiment tracking, DVC becomes a key component of modern MLOps workflows.

DVC Workflow Cheat Sheet

Dataset

│

▼

dvc add

│

▼

.dvc Metadata

│

▼

Git Commit

│

▼

dvc push

│

▼

Remote Storage

│

▼

Another Developer

│

▼

git clone

│

▼

dvc pull

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

You have now learned how to

• Version source code with Git.
• Package applications with Docker.
• Orchestrate containers using Kubernetes.
• Track experiments with MLflow.
• Version datasets and machine learning pipelines with DVC.
• Together, these technologies form the foundation of a professional MLOps workflow.
• What's Next?

In Chapter 10.6 – FastAPI, you'll learn how to expose your trained machine learning models as REST APIs. You'll build high-performance prediction services, generate interactive API documentation automatically, validate input data, and prepare your models for production deployment using Docker and Kubernetes.

Chapter 10.6 – FastAPI

• FastAPI is one of the most popular frameworks for deploying Machine Learning and AI models as REST APIs.

Companies such as Microsoft, Netflix, Uber, NVIDIA, and many AI startups use FastAPI because it is fast, modern, easy to use, and automatically generates API documentation.

Learning Objectives

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

• Understand what FastAPI is.
• Learn why FastAPI is widely used.
• Build REST APIs.
• Create GET and POST endpoints.
• Validate request data using Pydantic.
• Deploy Machine Learning models.
• Understand asynchronous programming.
• Generate API documentation.
• Deploy FastAPI with Docker and Kubernetes.
• Prepare for FastAPI interview questions.

1. Introduction

Imagine you've trained a House Price Prediction Model.

You want a website to use your model.

Without an API

With FastAPI

FastAPI acts as the bridge between your model and the outside world.

2. What is FastAPI?

Definition

FastAPI is a modern, high-performance Python web framework used to build REST APIs quickly with automatic data validation, documentation, and support for asynchronous programming.

It is built on

Starlette (web framework)

Pydantic (data validation)

3. Why FastAPI?

Suppose you build an AI model.

Many applications need to use it

• Mobile App
• Website
• Chatbot
• Power BI
• Other APIs

FastAPI allows all of them to communicate with the model.

4. Why Not Just Run Python?

Without FastAPI

model.py

↓

Runs only on your computer

With FastAPI

The model becomes accessible over the network.

5. REST API

FastAPI creates REST APIs.

REST (Representational State Transfer) is an architectural style for building web services using HTTP.

Example

6. HTTP Methods

7. Install FastAPI

pip install fastapi

Install an ASGI server (Uvicorn)

pip install uvicorn

8. First FastAPI Program

from fastapi import FastAPI
app = FastAPI()

@app.get("/")

def home():
return {"message": "Welcome to FastAPI"}

Save as

app.py

Run

uvicorn app:app --reload

Output

INFO: Uvicorn running on http://127.0.0.1:8000

9. Access API

Open

http://127.0.0.1:8000

Output

{

"message":"Welcome to FastAPI"

}

10. Automatic API Documentation

• One of FastAPI's biggest advantages is automatic documentation.
• Swagger UI
• http://127.0.0.1:8000/docs
• Interactive documentation where you can test APIs.
• ReDoc
• http://127.0.0.1:8000/redoc
• Alternative documentation interface.

11. GET API Example

from fastapi import FastAPI
app = FastAPI()

@app.get("/hello")

def hello():
return {"message":"Hello World"}

• Request
• GET /hello
• Response

{

"message":"Hello World"

}

12. Path Parameters

@app.get("/square/{number}")

def square(number: int):
return {"square": number * number}

• Request
• GET /square/5
• Response

{

"square":25

}

13. Query Parameters

@app.get("/add")

def add(a: int, b: int):
return {"sum": a + b}

• Request
• /add?a=10&b=20
• Response

{

"sum":30

}

14. POST API

POST is commonly used for ML predictions.

Example

from pydantic import BaseModel
class Student(BaseModel):
    name: str

age: int

@app.post("/student")

def create_student(student: Student):
return student

Request

{

"name":"Hari",

"age":30

}

Response

{

"name":"Hari",

"age":30

}

15. What is Pydantic?

Pydantic automatically validates input data.

Example

class Person(BaseModel):
    age: int

If the client sends

{

"age":"ABC"

}

FastAPI returns an error because "ABC" is not an integer.

16. Machine Learning Prediction API

Suppose you trained

house_price_model.pkl

Load model

import joblib
model = joblib.load("model.pkl")

Create request model

class House(BaseModel):
    area: float

• bedrooms: int
• Prediction endpoint
• @app.post("/predict")

def predict(data: House):
prediction = model.predict(

)

return {

"predicted_price"

prediction[0]

}

17. Request Example

{

"area":1500,

"bedrooms":3

}

Response

{

"predicted_price":7500000

}

18. API Workflow

19. Asynchronous Programming

FastAPI supports asynchronous endpoints.

Example

@app.get("/status")

async def status()

return {"status":"Running"}

• Benefits
• Better concurrency
• Efficient I/O handling
• High throughput for many simultaneous requests

Use async mainly for operations like database queries, API calls, or file access. CPU-intensive ML inference may still run synchronously or be handled using background workers.

20. Error Handling

Example

from fastapi import HTTPException

@app.get("/user/{id}")

def get_user(id:int):
    if id < 1:
        raise HTTPException(
            status_code=400,
            detail="Invalid ID"
        )

return {"id":id}

21. Dependency Injection

FastAPI provides dependency injection.

Example

from fastapi import Depends
def verify_api_key():
return True

@app.get("/secure")

def secure(
auth=Depends(verify_api_key)

)

return {"message":"Authorized"}

Useful for

• Authentication
• Database connections
• Logging
• Configuration

22. Project Structure

HousePriceAPI/

│

• ├── app.py
• ├── model.pkl
• ├── schemas.py
• ├── services.py
• ├── requirements.txt
• ├── Dockerfile
• └── tests/

Large applications should separate routes, business logic, schemas, and utilities.

23. Docker + FastAPI

• Dockerfile
• FROM python:3.11
• WORKDIR /app
• COPY . .
• RUN pip install -r requirements.txt
• EXPOSE 8000
• CMD [
• "uvicorn",
• "app:app",

"--host",

"0.0.0.0",

"--port",

"8000"

]

Run

docker build -t house-api .
docker run -p 8000:8000 house-api

24. FastAPI in Kubernetes

Multiple FastAPI instances can serve requests simultaneously.

25. FastAPI in MLOps

26. Real-World Applications

• Banking
• Loan approval prediction
• Healthcare
• Disease prediction APIs
• Retail
• Recommendation systems
• Manufacturing
• Predictive maintenance
• Agriculture
• Crop disease prediction
• Chatbots
• LLM inference APIs

27. Advantages

• Very high performance.
• Automatic validation.
• Automatic API documentation.
• Built-in type hints.
• Easy integration with ML libraries.
• Async support.

28. FastAPI vs Flask

Both frameworks are excellent; FastAPI is often preferred for new ML APIs because of its built-in validation and documentation.

29. Best Practices

• Use Pydantic models.
• Separate business logic from routes.
• Validate all inputs.
• Handle exceptions gracefully.
• Use environment variables for secrets.
• Add logging and monitoring.
• Write automated tests.

30. Common Mistakes

• Loading the model inside every request instead of once at startup.
• Hardcoding database credentials.
• Returning unhandled exceptions.
• Skipping input validation.
• Mixing routing and business logic in one large file.

31. Interview Questions

Beginner

• What is FastAPI?
• Why is FastAPI used?
• What is REST API?
• What is Pydantic?
• What is Swagger UI?

Intermediate

• Difference between GET and POST?
• What are path parameters?
• What are query parameters?
• What is async in FastAPI?
• How does FastAPI validate input?

Advanced

• How would you deploy an ML model using FastAPI?
• FastAPI vs Flask?
• How would you secure a FastAPI application?
• How would you scale FastAPI with Kubernetes?
• How would you monitor a FastAPI service in production?

Mini Project

• House Price Prediction API
• Project Structure
• HousePriceAPI/
• ├── app.py
• ├── model.pkl
• ├── schemas.py
• ├── requirements.txt
• ├── Dockerfile
• └── tests/
• Features
• Predict house prices.
• Input validation using Pydantic.
• Interactive Swagger documentation.
• Docker support.
• Kubernetes-ready deployment.
• Complete FastAPI Workflow
• Train Model

│

▼

Save model.pkl

│

▼

FastAPI API

│

▼

Swagger Documentation

│

▼

Docker

│

▼

Kubernetes

│

▼

Production

Chapter Summary

FastAPI is a modern Python framework for building high-performance REST APIs. It is particularly well suited for serving machine learning models because it provides automatic request validation, interactive API documentation, excellent performance, and straightforward integration with Docker, Kubernetes, and cloud platforms. These features make it one of the most widely adopted frameworks for production AI services.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

You have now learned how to

• Manage source code with Git.
• Package applications using Docker.
• Orchestrate containers with Kubernetes.
• Track ML experiments with MLflow.
• Version datasets using DVC.
• Serve ML models through FastAPI.

Together, these technologies form the backbone of a modern production MLOps platform.

What's Next?

In Chapter 10.7 – Flask, you'll learn another popular Python web framework used for building web applications and REST APIs. You'll compare Flask and FastAPI, understand their strengths and trade-offs, and learn when to choose one over the other in machine learning and production environments.

Chapter 10.7 – Flask

• Flask is one of the most popular lightweight Python web frameworks for building web applications and REST APIs.

Before FastAPI became popular, Flask was the preferred framework for deploying Machine Learning models. Even today, thousands of production systems use Flask because of its simplicity, flexibility, and large ecosystem.

Learning Objectives

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

• Understand what Flask is.
• Learn Flask architecture.
• Build REST APIs.
• Create GET and POST endpoints.
• Deploy Machine Learning models using Flask.
• Understand Flask project structure.
• Compare Flask and FastAPI.
• Deploy Flask using Docker.
• Prepare for Flask interview questions.

1. Introduction

Suppose you have trained a Customer Churn Prediction Model.

The model exists as

model.pkl

Your company wants

• A website
• A mobile application
• Power BI dashboards
• Other applications
• to use the model.
• How can they communicate with your Python model?

The answer is

Flask REST API

2. What is Flask?

Definition

Flask is a lightweight Python web framework used to build web applications and REST APIs.

It provides the essentials needed to create web services while allowing developers to choose additional libraries as required.

3. Why Flask?

Suppose your Machine Learning model predicts house prices.

Without Flask

With Flask

The model becomes accessible over the network.

4. Features of Flask

• Lightweight
• Easy to learn
• Flexible
• REST API support
• Template engine (Jinja2)
• Large ecosystem
• Works well with ML models

5. Install Flask

pip install flask

Check installation

python -c "import flask; print(flask.__version__)"

6. First Flask Application

from flask import Flask
app = Flask(__name__)

@app.route("/")

def home():
    return "Welcome to Flask!"
    if __name__ == "__main__":
        app.run(debug=True)

Run

python app.py

Output

Running on http://127.0.0.1:5000

7. Flask Architecture

│

▼

│

▼

HTTP Response

8. Routing

Routes define URLs.

Example

@app.route("/hello")

def hello():
return "Hello World"

Access

http://127.0.0.1:5000/hello

Response

Hello World

9. GET Request

@app.route("/square/<int:number>")

def square(number):
    return {
        "square": number * number
    }

Request

GET /square/5

Response

{

"square":25

}

10. POST Request

from flask import request

@app.route("/add", methods=["POST"])

def add():
    data = request.json
    total = data["a"] + data["b"]
    return {
        "sum": total
    }

Request

{

"a":10,

"b":20

}

Response

{

"sum":30

}

11. Request Object

Flask provides the request object to access client data.

Examples

• request.json
• request.form
• request.args
• request.files

These are used for

• JSON payloads
• HTML forms
• Query parameters
• File uploads

12. Returning JSON

from flask import jsonify

@app.route("/status")

def status():
    return jsonify({
        "status":"Running"
    })

Response

{

"status":"Running"

}

13. Machine Learning API

Load model

import joblib
model = joblib.load("model.pkl")

Prediction API

@app.route("/predict", methods=["POST"])

def predict():
    data = request.json
    prediction = model.predict([[
        data["area"],
        data["bedrooms"]
    ]])

return jsonify({

"prediction"

prediction[0]

})

14. Request Example

{

"area":1500,

"bedrooms":3

}

Response

{

"prediction":7500000

}

15. Templates

Flask supports HTML templates using Jinja2.

Project

templates/

index.html

Example

from flask import render_template

@app.route("/")

def home():
return render_template("index.html")

Useful for building traditional web applications with server-rendered HTML.

16. Static Files

• Store CSS, JavaScript, and images.
• static/
• style.css
• app.js
• logo.png

17. Flask Project Structure

HousePriceAPI/

│

• ├── app.py
• ├── model.pkl
• ├── templates/
• ├── static/
• ├── requirements.txt
• ├── Dockerfile
• └── tests/

For larger applications, routes, models, and services are often separated into multiple modules or packages.

18. Error Handling

from flask import abort

@app.route("/user/<int:id>")

def user(id):
    if id < 1:
        abort(400)

return {"id": id}

Flask returns an HTTP 400 Bad Request error.

19. Flask Workflow

20. Flask + Docker

• Dockerfile
• FROM python:3.11
• WORKDIR /app
• COPY . .
• RUN pip install -r requirements.txt
• EXPOSE 5000
• CMD ["python","app.py"]
• Build

docker build -t flask-api .

Run

docker run -p 5000:5000 flask-api

21. Flask in MLOps

22. Flask Extensions

Popular extensions include

• Flask-SQLAlchemy (database ORM)
• Flask-Login (authentication)
• Flask-Migrate (database migrations)
• Flask-CORS (Cross-Origin Resource Sharing)
• Flask-JWT-Extended (JWT authentication)

23. Flask vs FastAPI

24. When to Choose Flask?

Choose Flask when

• Building traditional web applications.
• You need complete flexibility over project structure.
• Working with an existing Flask codebase.
• Your application doesn't require advanced async features.

Choose FastAPI when

Building new REST APIs.

• Serving Machine Learning models.
• Automatic validation and API documentation are important.
• High concurrency is required.

25. Advantages

• Easy to learn.
• Flexible architecture.
• Large community.
• Extensive extension ecosystem.
• Good integration with Machine Learning projects.

26. Limitations

• Request validation is mostly manual.
• No built-in interactive API documentation.
• Asynchronous support is more limited compared to FastAPI.
• Large projects require careful organization.

27. Best Practices

• Organize routes into blueprints for larger projects.
• Separate business logic from route handlers.
• Validate all input data.
• Store configuration in environment variables.
• Write unit tests.
• Add logging and monitoring.

28. Common Mistakes

• Putting all code into a single app.py file.
• Hardcoding database credentials.
• Not validating input.
• Returning raw exceptions to users.
• Loading the ML model for every request instead of once during startup.

29. Interview Questions

Beginner

• What is Flask?
• Why is Flask popular?
• What is routing?
• What is the request object?
• What is jsonify()?

Intermediate

• Difference between GET and POST?
• What are Flask templates?
• What are static files?
• How would you deploy an ML model using Flask?
• How do you handle errors in Flask?

Advanced

• Flask vs FastAPI?
• How would you Dockerize a Flask application?
• How would you scale Flask using Kubernetes?
• How would you secure a Flask REST API?
• How would you structure a large Flask project?

30. Mini Project

• Customer Churn Prediction API
• Project Structure
• CustomerChurnAPI/
• ├── app.py
• ├── model.pkl
• ├── requirements.txt
• ├── Dockerfile
• ├── templates/
• └── static/
• Features
• Predict customer churn.
• JSON API.
• HTML dashboard.
• Docker support.
• Kubernetes deployment.
• Logging.

31. Flask Workflow Cheat Sheet

Train Model

│

▼

Save model.pkl

│

▼

Flask API

│

▼

JSON Response

│

▼

Docker

│

▼

Kubernetes

│

▼

Production

32. Flask vs FastAPI Decision Guide

Need a modern ML REST API?

│

├── Yes ──► FastAPI

│

└── No

│

Need a traditional web application?

│

├── Yes ──► Flask

│

└── API only?

│

├── High performance ──► FastAPI

└── Existing Flask project ──► Flask

Chapter Summary

Flask is a lightweight and flexible Python web framework used to build web applications and REST APIs. It has long been a popular choice for deploying Machine Learning models because of its simplicity and extensive ecosystem. While FastAPI has become the preferred option for many new AI APIs due to its automatic validation, documentation, and async capabilities, Flask remains a strong choice for many production systems, especially existing applications and traditional web projects.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

You now know how to

• Track code with Git.
• Package applications using Docker.
• Manage containers with Kubernetes.
• Track ML experiments using MLflow.
• Version datasets with DVC.
• Build modern APIs using FastAPI.
• Build web applications and APIs using Flask.
• What's Next?

In Chapter 10.8 – Streamlit, you'll learn how to build interactive AI and Machine Learning web applications without needing frontend technologies like HTML, CSS, or JavaScript. You'll create dashboards, data visualizations, and ML prediction interfaces that can be shared with users in just a few lines of Python code.

Chapter 10.8 – Streamlit

• Streamlit is one of the easiest and most popular Python frameworks for building interactive Data Science, Machine Learning, and AI web applications.

It allows Data Scientists and ML Engineers to build professional web applications without writing HTML, CSS, or JavaScript.

Learning Objectives

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

• Understand what Streamlit is.
• Learn why Streamlit is widely used.
• Build interactive ML web applications.
• Create forms, buttons, sliders, and file uploaders.
• Display tables, charts, and images.
• Integrate Machine Learning models.
• Deploy Streamlit applications.
• Build AI dashboards.
• Prepare for Streamlit interview questions.

1. Introduction

Imagine you've built a House Price Prediction Model.

Normally, users would need to

• Install Python.
• Install libraries.
• Run scripts.
• Use the command line.
• That's not practical.

Instead, you create a simple web application

---------------------------------------

House Price Prediction

Area: [1500]

Bedrooms: [3]

Predicted Price

₹75,00,000

---------------------------------------

The user simply opens a browser and uses the application.

This is where Streamlit shines.

2. What is Streamlit?

Definition

Streamlit is an open-source Python framework that allows developers to build interactive web applications for data science, machine learning, and AI using only Python.

Unlike traditional web development,

you don't need

• HTML
• CSS
• JavaScript
• Everything is written in Python.

3. Why Streamlit?

Without Streamlit

With Streamlit

It provides a user-friendly interface for your model.

4. Install Streamlit

pip install streamlit

Check installation

streamlit --version

5. First Streamlit App

Create

app.py

Code

import streamlit as st

st.title("Welcome to Streamlit")

st.write("My First Streamlit Application")

Run

streamlit run app.py

Your browser opens automatically.

6. Streamlit Architecture

7. Titles and Headers

import streamlit as st

• st.title("Machine Learning Dashboard")
• st.header("House Price Prediction")
• st.subheader("Enter Property Details")

Output

• Machine Learning Dashboard
• House Price Prediction
• Enter Property Details

8. Display Text

• st.write("Welcome")
• st.text("Simple Text")
• st.markdown("**Bold Text**")
• st.success("Prediction Successful")
• st.warning("Missing Data")
• st.error("Model Not Found")

9. User Input

Text Box

name = st.text_input("Enter Name")

Number Input

age = st.number_input("Age")

Slider

area = st.slider(
    "Area",
    500,
    5000,
    1500
)

Select Box

city = st.selectbox(
    "City",
    [
        "Hyderabad",
        "Bangalore",
        "Chennai"
    ]
)

Radio Button

gender = st.radio(
    "Gender",
    [
        "Male",
        "Female"
    ]
)

Checkbox

agree = st.checkbox(
    "Accept Terms"
)

10. Buttons

if st.button("Predict"):
    st.write("Prediction Started")

11. Columns

col1, col2 = st.columns(2)

with col1

st.write("Left")

with col2

st.write("Right")

Useful for creating professional dashboards.

12. Sidebar

st.sidebar.title("Navigation")

model = st.sidebar.selectbox(
    "Model",
    [
        "Random Forest",
        "XGBoost"
    ]
)

Sidebar is commonly used for settings and navigation.

13. Display Tables

import pandas as pd
df = pd.DataFrame({
    "Name":["A","B"],
    "Age":[20,25]
})

st.dataframe(df)

Interactive features include sorting and scrolling.

14. Display Charts

import pandas as pd
chart = pd.DataFrame({
    "Sales":[10,15,8,20]
})

st.line_chart(chart)

Other built-in chart options include

Bar charts

Area charts

For advanced visualizations, you can integrate libraries such as Matplotlib, Plotly, or Altair.

15. Display Images

from PIL import Image
image = Image.open("house.jpg")

st.image(image)

16. File Upload

uploaded = st.file_uploader(
    "Upload CSV"
)

Supported uploads include

• CSV
• Excel
• PDF
• Images
• Text files

17. Machine Learning Prediction

Load model

import joblib
model = joblib.load(
    "model.pkl"
)

User input

area = st.number_input(
    "Area"
)

bedrooms = st.number_input(
    "Bedrooms"
)

Prediction

if st.button("Predict"):
prediction = model.predict(

)

st.success(

prediction[0]

)

18. Complete Workflow

19. Session State

Session State remembers values during a user's interaction.

Example

if "count" not in st.session_state:
    st.session_state.count = 0

if st.button("Click"):
    st.session_state.count += 1

st.write(st.session_state.count)

Useful for

• Chat history
• Login state
• Multi-step workflows

20. Multipage Applications

Example structure

├── pages/

│ Prediction.py

│ Dashboard.py

│ Reports.py

Each file becomes a page in the Streamlit app.

21. Streamlit + FastAPI

A common production architecture

• Why?
• Streamlit handles the frontend.
• FastAPI serves the backend API.
• They can be deployed independently.

22. Streamlit + Docker

• Dockerfile
• FROM python:3.11
• WORKDIR /app
• COPY . .
• RUN pip install -r requirements.txt
• EXPOSE 8501
• CMD [
• "streamlit",

"run",

"app.py",

"--server.address=0.0.0.0"

]

Run

docker build -t streamlit-app .
docker run -p 8501:8501 streamlit-app

23. Streamlit in MLOps

24. Real-World Applications

House Price Prediction

Input property details.

↓

• Display predicted price.
• Customer Churn Dashboard
• Display churn probability.
• Stock Market Dashboard
• Interactive charts.
• Medical Diagnosis
• Upload reports.

↓

AI prediction.

ChatGPT Interface

Build a conversational chatbot using Streamlit as the frontend.

25. Streamlit vs Flask vs FastAPI

26. Advantages

• Very easy to learn.
• Rapid application development.
• Excellent for AI demos.
• Interactive widgets.
• Built-in chart support.
• Pure Python development.

27. Limitations

• Less customizable than full frontend frameworks like React or Angular.
• Not ideal for very large, highly customized web applications.
• Complex authentication often requires additional components.
• High-traffic production systems may benefit from separating the frontend and backend.

28. Best Practices

• Keep business logic separate from UI code.
• Cache expensive operations using Streamlit caching features.
• Validate user input.
• Store secrets securely.
• Organize multipage apps.
• Add logging and error handling.

29. Common Mistakes

• Loading the model every time a widget changes.
• Mixing model training and UI code.
• Not validating uploaded files.
• Keeping all code in one large file.
• Hardcoding API keys.

30. Interview Questions

Beginner

• What is Streamlit?
• Why is Streamlit popular?
• How do you create a Streamlit app?
• How do you take user input?
• What is st.write()?

Intermediate

• What is Session State?
• How do you upload files?
• How do you display charts?
• How do you integrate ML models?
• Streamlit vs Flask?

Advanced

• Streamlit vs FastAPI?
• How would you deploy Streamlit using Docker?
• How would you build an AI dashboard?
• How would you integrate Streamlit with Kubernetes?
• How would you optimize Streamlit performance?

31. Mini Project

• House Price Prediction Dashboard
• Project Structure
• HousePriceDashboard/
• ├── app.py
• ├── model.pkl
• ├── requirements.txt
• ├── Dockerfile
• ├── pages/
• └── images/
• Features
• Enter house details.
• Predict house prices.
• Display charts.
• Upload CSV files.
• Compare predictions.
• Deploy using Docker.

32. Enterprise AI Dashboard

User

│

▼

Streamlit Dashboard

│

┌─────────┴─────────┐

▼ ▼

FastAPI API MLflow Metrics

│ │

▼ ▼

ML Model Service Experiment Logs

│

▼

Prediction Result

33. Chapter Summary

Streamlit is a Python framework for rapidly building interactive web applications for Machine Learning, Data Science, and AI. It enables developers to create dashboards, prediction tools, and data exploration interfaces using only Python. Combined with FastAPI, Docker, and Kubernetes, Streamlit forms an excellent frontend for modern MLOps applications.

Streamlit Workflow Cheat Sheet

Train Model

│

▼

Save Model

│

▼

Streamlit App

│

▼

User Input

│

▼

Prediction

│

▼

Display Result

│

▼

Deploy with Docker

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

You now have all the essential tools to build a complete AI application

• Git → Version control
• Docker → Containerization
• Kubernetes → Container orchestration
• MLflow → Experiment tracking
• DVC → Dataset and model versioning
• FastAPI → High-performance backend APIs
• Flask → Lightweight web framework
• Streamlit → Interactive AI dashboards

Together, these technologies form the foundation of a modern production-ready MLOps stack.

What's Next?

In Chapter 10.9 – Azure Machine Learning, you'll learn how to use Microsoft's cloud platform to train, register, deploy, monitor, and manage machine learning models at scale. You'll explore Azure ML Workspaces, Compute Instances, Pipelines, Model Registry, Managed Endpoints, AutoML, and Responsible AI, enabling enterprise-grade AI deployments on Azure.

Chapter 10.9 – Azure Machine Learning

• Azure Machine Learning (Azure ML) is Microsoft's cloud platform for building, training, deploying, monitoring, and managing Machine Learning models at enterprise scale.

It provides a complete MLOps platform that integrates with GitHub, Azure DevOps, MLflow, Docker, Kubernetes, Azure Storage, Azure Data Factory, Synapse Analytics, Power BI, and Azure Monitor.

Learning Objectives

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

• Understand Azure Machine Learning.
• Learn Azure ML architecture.
• Create an Azure ML Workspace.
• Understand Compute Instances and Compute Clusters.
• Work with Datasets and Datastores.
• Train Machine Learning models.
• Register models.
• Deploy models as online endpoints.
• Monitor deployed models.
• Build Azure ML Pipelines.
• Understand AutoML and Responsible AI.
• Prepare for Azure ML interview questions.

1. Introduction

Imagine your company has developed a Customer Churn Prediction Model.

Management wants it to

• Serve predictions to millions of customers.
• Scale automatically.
• Track model versions.
• Monitor performance.
• Retrain models when data changes.
• Integrate with enterprise systems.

Doing all of this manually is difficult.

Azure Machine Learning provides a managed platform to accomplish these tasks.

2. What is Azure Machine Learning?

Definition

Azure Machine Learning is a cloud-based platform for the complete Machine Learning lifecycle, including data preparation, model training, experiment tracking, deployment, monitoring, and MLOps automation.

Azure ML supports

• Machine Learning
• Deep Learning
• NLP
• Computer Vision
• Generative AI
• Responsible AI
• MLOps

3. Why Azure ML?

Suppose you train a model on your laptop.

Problems

• Limited CPU/GPU.
• Difficult collaboration.
• Manual deployment.
• No centralized model management.

Azure ML solves these by providing scalable cloud infrastructure and managed services.

4. Azure ML Architecture

Azure Machine Learning

│

┌───────────────────────┼────────────────────────┐

│ │ │

▼ ▼ ▼

Workspace Compute Datastores

│ │ │

▼ ▼ ▼

Experiments Training Jobs Datasets

│

▼

Model Registry

│

▼

Managed Online Endpoint

│

▼

Applications / Users

5. Azure ML Workspace

The Workspace is the central resource for Azure ML.

It stores

• Experiments
• Models
• Compute resources
• Datasets
• Endpoints
• Pipelines
• Monitoring information

Think of it as the "project folder" for all ML resources.

6. Azure ML Components

7. Compute Instance

A Compute Instance is a managed virtual machine for development.

Typical uses

• Jupyter notebooks
• VS Code
• Data exploration
• Model development
• Debugging

8. Compute Cluster

A Compute Cluster is used for scalable training.

Example

Clusters can automatically scale up when jobs are submitted and scale down when idle.

9. Datastore

A Datastore securely connects Azure ML to external storage.

Common storage options

• Azure Blob Storage
• Azure Data Lake Storage Gen2
• Azure Files
• SQL Database

The datastore stores connection information, not the data itself.

10. Data Assets (Datasets)

Azure ML manages datasets as reusable Data Assets.

Example

Benefits

• Reusability
• Versioning
• Team collaboration

11. Training a Model

Typical workflow

Training can use CPUs or GPUs depending on the workload.

12. Azure ML Experiment

An Experiment groups multiple training runs.

Example

House Price Prediction

│

• ├── Run 1
• ├── Run 2
• └── Run 3

Each run logs metrics, parameters, and outputs.

13. Experiment Tracking

Azure ML records

• Hyperparameters
• Accuracy
• Precision
• Recall
• F1 Score
• Training duration
• Logs
• Artifacts

Azure ML also supports MLflow, allowing familiar experiment tracking workflows.

14. Model Registry

After training, register the model.

Benefits

• Centralized storage
• Version management
• Easier deployment

15. Model Deployment

Azure ML supports multiple deployment targets.

Deployment options include

• Managed Online Endpoints
• Kubernetes (AKS)
• Batch Endpoints

16. Online Endpoints

Use Online Endpoints for real-time predictions.

Example

Typical use cases

• Fraud detection
• Recommendation systems
• Chatbots
• Price prediction

17. Batch Endpoints

Use Batch Endpoints for large-scale offline inference.

Example

Ideal for nightly or scheduled processing.

18. Azure ML Pipelines

Automate ML workflows.

Pipelines improve reproducibility and automation.

19. AutoML

AutoML automatically tries multiple algorithms and hyperparameters.

Example

Useful when you want Azure ML to search for a strong baseline model.

20. Responsible AI

Azure ML provides tools for

• Model explainability
• Fairness analysis
• Error analysis
• Data insights

These features help teams build trustworthy AI systems.

21. Monitoring

After deployment, monitor

• Latency
• Request volume
• Errors
• Resource usage
• Prediction performance

Monitoring helps detect issues before they affect users.

22. End-to-End Azure ML Workflow

Prepare Data

│

▼

Upload Data

│

▼

Train Model

│

▼

Track Experiment

│

▼

Register Model

│

▼

Deploy Endpoint

│

▼

Monitor

│

▼

Retrain

23. Integration with Azure Services

Azure ML integrates with many Azure services.

24. Azure ML + MLOps

This creates a complete cloud-based MLOps workflow.

25. Real-World Example

A bank builds a loan approval model.

Workflow

• Data stored in Azure Data Lake.
• Azure ML trains multiple models.
• Best model registered.
• Model deployed as an online endpoint.
• Loan application portal calls the endpoint.
• Azure Monitor tracks usage and performance.
• New data triggers retraining through pipelines.

26. Advantages

• Fully managed ML platform.
• Scalable CPU and GPU training.
• Integrated experiment tracking.
• Built-in model registry.
• Managed deployment.
• Enterprise security.
• Deep integration with Azure services.

27. Limitations

• Azure costs depend on compute and storage usage.
• Initial setup can be complex.
• Requires understanding of Azure resources.
• Cloud permissions and networking must be managed carefully.

28. Best Practices

• Use separate workspaces for development, testing, and production.
• Register every production model.
• Use managed identities where possible instead of storing credentials.
• Automate deployments using CI/CD.
• Monitor endpoints continuously.
• Use versioned data assets and pipelines.

29. Common Mistakes

• Training large models on a small compute instance.
• Deploying models without monitoring.
• Not versioning datasets or models.
• Hardcoding secrets instead of using Azure Key Vault.
• Skipping testing before production deployment.

30. Interview Questions

Beginner

• What is Azure Machine Learning?
• What is an Azure ML Workspace?
• What is a Compute Instance?
• What is a Compute Cluster?
• What is a Model Registry?

Intermediate

• Difference between Online Endpoint and Batch Endpoint?
• What is AutoML?
• What are Azure ML Pipelines?
• How do you track experiments?
• What are Data Assets?

Advanced

• Design an end-to-end Azure ML architecture.
• How would you deploy a model to production?
• How would you integrate Azure ML with GitHub Actions?
• How would you monitor production models?
• Explain an enterprise MLOps workflow using Azure ML.

31. Mini Project

• Customer Churn Prediction on Azure ML
• Project Workflow
• Customer Dataset

│

▼

Azure Blob Storage

│

▼

Azure ML Data Asset

│

▼

Training Job

│

▼

Experiment Tracking

│

▼

Model Registry

│

▼

Managed Online Endpoint

│

▼

• Customer Prediction API
• Tasks
• Create an Azure ML Workspace.
• Upload the dataset as a Data Asset.
• Train a classification model.
• Register the best model.
• Deploy it as a Managed Online Endpoint.
• Test predictions using REST API.
• Monitor endpoint performance.

32. Azure ML Workflow Cheat Sheet

Workspace

│

▼

Data Asset

│

▼

Training Job

│

▼

Experiment

│

▼

Model Registry

│

▼

Online Endpoint

│

▼

Applications

│

▼

Monitoring

Chapter Summary

Azure Machine Learning is Microsoft's cloud platform for building, training, deploying, and managing machine learning models at scale. It provides managed infrastructure, experiment tracking, model versioning, automated pipelines, online and batch deployment options, and enterprise-grade security. Azure ML is a core service for organizations implementing production MLOps on Microsoft Azure.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

At this point, you have learned the essential building blocks of an enterprise MLOps platform:

• Git for source code management.
• Docker for containerization.
• Kubernetes for orchestration.
• MLflow for experiment tracking.
• DVC for data and model versioning.
• FastAPI and Flask for serving models.
• Streamlit for interactive dashboards.

Azure Machine Learning for cloud-based model training, deployment, and lifecycle management.

What's Next?

In Chapter 10.10 – AWS SageMaker, you'll learn Amazon's managed Machine Learning platform. You'll explore SageMaker Studio, training jobs, processing jobs, model registry, hosted endpoints, batch inference, monitoring, and MLOps integration, and compare it with Azure Machine Learning.

Chapter 10.10 – AWS SageMaker

• Amazon SageMaker is Amazon Web Services' fully managed Machine Learning platform that enables data scientists and ML engineers to build, train, deploy, monitor, and manage machine learning models at scale.

It provides everything needed for an end-to-end ML lifecycle, from data preparation to production deployment, without managing the underlying infrastructure.

Learning Objectives

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

• Understand Amazon SageMaker.
• Learn SageMaker architecture.
• Understand SageMaker Studio.
• Train Machine Learning models.
• Process datasets.
• Register and version models.
• Deploy models to endpoints.
• Perform batch inference.
• Monitor deployed models.
• Integrate SageMaker with MLOps.
• Compare SageMaker with Azure ML.
• Prepare for SageMaker interview questions.

1. Introduction

Suppose your company wants to build an AI-powered fraud detection system.

Requirements

• Train on 100 million transactions.
• Use GPUs for deep learning.
• Deploy globally.
• Handle thousands of requests per second.
• Automatically monitor models.
• Retrain models periodically.
• Managing servers manually would be difficult.

Amazon SageMaker provides managed infrastructure to simplify these tasks.

2. What is Amazon SageMaker?

Definition

Amazon SageMaker is a fully managed Machine Learning service provided by AWS that enables developers to build, train, deploy, and monitor ML models at scale.

It supports

• Machine Learning
• Deep Learning
• Computer Vision
• Natural Language Processing
• Generative AI
• Reinforcement Learning

3. Why SageMaker?

Without SageMaker

With SageMaker

AWS manages the underlying infrastructure.

4. SageMaker Architecture

Amazon SageMaker

│

┌─────────────────────────┼─────────────────────────┐

▼ ▼ ▼

Studio Training Jobs Processing Jobs

│

▼

Model Registry

│

▼

Endpoints

│

▼

Applications

5. SageMaker Components

6. SageMaker Studio

SageMaker Studio is the primary development environment.

Features

• Jupyter notebooks
• Experiment management
• Model development
• Visualization
• Debugging
• Collaboration

Think of it as an integrated IDE for Machine Learning on AWS.

7. Notebook Instance

Notebook Instances provide managed Jupyter notebook environments.

Typical uses

• Data exploration
• Feature engineering
• Model development
• Visualization

8. Processing Jobs

Processing Jobs prepare data before training.

Typical workflow

Common tasks

• Missing value handling
• Encoding categorical variables
• Feature scaling
• Data validation

9. Training Jobs

Training Jobs execute model training on managed compute.

You can choose different instance types depending on workload.

10. Built-in Algorithms

SageMaker provides several built-in algorithms.

Examples

• Linear Learner
• XGBoost
• Random Cut Forest
• K-Means
• PCA
• Object Detection
• Image Classification

You can also use custom training code with frameworks such as TensorFlow, PyTorch, and Scikit-learn.

11. Bring Your Own Algorithm

If your model isn't built using SageMaker's built-in algorithms,

you can package it inside a Docker container.

Example

12. Experiment Tracking

SageMaker records

• Parameters
• Metrics
• Logs
• Model artifacts

It also integrates with MLflow if your organization prefers a common experiment tracking platform.

13. Model Registry

The Model Registry stores approved models.

Each version includes

• Metadata
• Approval status
• Associated artifacts

14. Deploying Models

Deploy the registered model

Endpoints provide real-time inference.

15. Real-Time Endpoints

Use when predictions are needed immediately.

Examples

• Fraud detection
• Loan approval
• Recommendation systems
• Chatbots

16. Batch Transform

Batch Transform performs predictions on large datasets.

Example

Ideal for nightly or scheduled inference jobs.

17. SageMaker Pipelines

Automate ML workflows.

18. Model Monitor

Model Monitor continuously checks production models.

It monitors

• Data quality
• Feature distributions
• Prediction quality
• Drift

Example

19. Automatic Scaling

Suppose

100 Users

↓

One endpoint instance.

Traffic increases

100,000 Users

↓

Additional endpoint instances are created automatically (if auto scaling is configured).

20. Security

AWS provides

• IAM (Identity and Access Management)
• Encryption
• VPC Integration
• CloudTrail Auditing
• AWS KMS
• These help secure ML workloads.

21. SageMaker Workflow

↓

Applications

↓

Monitoring

22. Integration with AWS Services

23. SageMaker + MLOps

24. Real-World Example

An e-commerce company builds a product recommendation system.

Workflow

• Customer data stored in Amazon S3.
• Processing Jobs clean the data.
• Training Jobs build recommendation models.
• Best model registered.
• Endpoint serves recommendations.
• Model Monitor checks prediction quality.
• Pipeline retrains periodically.

25. Azure ML vs SageMaker

26. Advantages

• Fully managed platform.
• Excellent scalability.
• GPU support.
• Strong AWS integration.
• Built-in monitoring.
• Enterprise security.
• Flexible deployment options.

27. Limitations

• Costs can increase with large compute resources.
• Many AWS services require learning.
• Initial setup can be complex.
• Proper IAM permissions are essential.

28. Best Practices

• Store datasets in Amazon S3.
• Register every production model.
• Monitor deployed endpoints.
• Automate training with SageMaker Pipelines.
• Use infrastructure as code where possible.
• Optimize instance selection to control costs.

29. Common Mistakes

• Using oversized instances unnecessarily.
• Ignoring endpoint monitoring.
• Not versioning models.
• Hardcoding AWS credentials.
• Deploying without testing.

30. Interview Questions

Beginner

• What is Amazon SageMaker?
• What is SageMaker Studio?
• What is a Training Job?
• What is Batch Transform?
• What is a Model Registry?

Intermediate

• Difference between Processing Job and Training Job?
• What is a SageMaker Endpoint?
• What is Model Monitor?
• What are SageMaker Pipelines?
• Difference between Batch Transform and Real-Time Endpoints?

Advanced

• Design a SageMaker architecture for fraud detection.
• Azure ML vs SageMaker?
• How would you deploy a deep learning model?
• How would you automate retraining?
• How would you build an enterprise MLOps workflow on AWS?

31. Mini Project

Customer Churn Prediction using SageMaker

Workflow

• Tasks
• Upload dataset to Amazon S3.
• Create a Processing Job.
• Train a classification model.
• Register the model.
• Deploy it to a real-time endpoint.
• Test predictions.
• Configure Model Monitor.
• Create a retraining pipeline.

32. Complete SageMaker Workflow

Chapter Summary

Amazon SageMaker is AWS's fully managed Machine Learning platform for developing, training, deploying, and monitoring ML models. It simplifies infrastructure management while providing scalable compute, experiment tracking, model versioning, automated pipelines, real-time and batch inference, and production monitoring. SageMaker is a core service for organizations building MLOps solutions on AWS.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

│

▼

• AWS SageMaker

You now understand the two largest cloud ML platforms

Azure Machine Learning for Microsoft Azure.

Amazon SageMaker for AWS.

Both platforms provide managed services for training, deployment, monitoring, and MLOps, but they are optimized for their respective cloud ecosystems.

What's Next?

In Chapter 10.11 – Google Vertex AI, you'll learn Google's unified AI platform. You'll explore Vertex AI Workbench, custom training, AutoML, Pipelines, Feature Store, Model Registry, online prediction endpoints, and MLOps integration, and compare Vertex AI with Azure Machine Learning and AWS SageMaker.

Chapter 10.11 – Google Vertex AI

• Google Vertex AI is Google Cloud Platform's unified Machine Learning platform that enables developers to build, train, deploy, monitor, and manage Machine Learning and Generative AI models using a single cloud service.

It combines Google's expertise in AI (TensorFlow, DeepMind, Gemini, Kubernetes, and BigQuery) into one enterprise-grade MLOps platform.

Learning Objectives

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

• Understand Google Vertex AI.
• Learn Vertex AI architecture.
• Work with Vertex AI Workbench.
• Train ML models.
• Use AutoML.
• Deploy prediction endpoints.
• Manage Model Registry.
• Build ML Pipelines.
• Monitor deployed models.
• Understand Feature Store.
• Integrate Vertex AI with MLOps.

Compare Vertex AI with Azure ML and AWS SageMaker.

Prepare for Vertex AI interview questions.

1. Introduction

Suppose you're building an AI application that predicts crop diseases.

Requirements

• Store millions of images.
• Train deep learning models on GPUs.
• Deploy globally.
• Serve predictions in real time.
• Monitor model performance.
• Automatically retrain models.

Google Cloud provides Vertex AI to manage the entire lifecycle.

2. What is Vertex AI?

Definition

Vertex AI is Google Cloud's unified Machine Learning platform for building, training, deploying, monitoring, and managing AI and ML models at scale.

It supports

• Machine Learning
• Deep Learning
• NLP
• Computer Vision
• Time Series Forecasting
• Reinforcement Learning
• Generative AI
• Foundation Models

3. Why Vertex AI?

Without Vertex AI

With Vertex AI

Most infrastructure management is handled by Google Cloud.

4. Vertex AI Architecture

Google Vertex AI

│

┌──────────────────────┼────────────────────────┐

▼ ▼ ▼

Workbench Training Jobs AutoML

│

▼

Model Registry

│

▼

Prediction Endpoints

│

▼

Applications

5. Vertex AI Components

6. Vertex AI Workbench

Workbench is Google's managed notebook environment.

Features

• JupyterLab
• Python development
• GPU support
• BigQuery integration
• Git integration
• TensorFlow & PyTorch support

Developers write code here before submitting training jobs.

7. Datasets

Datasets can include

• CSV files
• Images
• Videos
• Audio
• Text

Example

8. Training Jobs

Training Jobs execute model training on managed infrastructure.

Supported frameworks include

• TensorFlow
• PyTorch
• Scikit-learn
• XGBoost
• Custom Docker containers

9. AutoML

AutoML enables users to build ML models without writing extensive code.

Example

AutoML supports

• Tabular data
• Images
• Text
• Video

10. Custom Training

For complete flexibility

You control

• Training code
• Framework
• Libraries
• Hyperparameters

11. Model Registry

Store trained models.

Benefits

• Version history
• Deployment tracking
• Rollback capability

12. Prediction Endpoints

Deploy models for real-time inference.

Common use cases

• Chatbots
• Fraud detection
• Medical diagnosis
• Recommendation engines

13. Batch Prediction

Used when predicting on very large datasets.

Example

Suitable for

• Nightly scoring
• Reporting
• Bulk predictions

14. Vertex AI Pipelines

Automate ML workflows.

Pipelines support reproducible and repeatable ML processes.

15. Feature Store

A Feature Store stores reusable ML features.

Example

Customer Age

Purchase History

Benefits

• Reuse
• Consistency
• Faster development

16. Model Monitoring

Monitor production models.

Track

• Prediction latency
• Data drift
• Feature drift
• Prediction quality
• Resource usage
• If problems are detected,
• alerts can trigger retraining workflows.

17. Vertex AI Workflow

18. Generative AI Support

Vertex AI supports modern Generative AI workflows.

Examples

• Large Language Models
• Chatbots
• Document Summarization
• Code Generation
• Image Generation

Google also provides managed access to foundation models through Vertex AI.

19. Integration with Google Cloud Services

20. Vertex AI + MLOps

21. Real-World Example

Suppose an agricultural company wants to detect crop diseases.

Workflow

The mobile application sends leaf images to Vertex AI.

The endpoint predicts the disease in real time.

22. Azure ML vs SageMaker vs Vertex AI

23. Advantages

• Fully managed ML platform.
• Strong TensorFlow integration.
• AutoML support.
• Excellent support for Generative AI.
• Feature Store.
• Scalable infrastructure.
• Enterprise-grade security.

24. Limitations

• Costs increase with GPU usage.
• Google Cloud knowledge is required.
• Large projects require proper IAM configuration.
• Managing cloud resources requires planning.

25. Best Practices

• Store datasets in Cloud Storage.
• Version every model.
• Monitor deployed endpoints.
• Use Pipelines for automation.
• Reuse features with Feature Store.
• Separate development, testing, and production environments.

26. Common Mistakes

• Deploying models without monitoring.
• Ignoring feature drift.
• Hardcoding credentials.
• Not versioning datasets.
• Training large models on insufficient compute resources.

27. Interview Questions

Beginner

• What is Vertex AI?
• What is Vertex AI Workbench?
• What is AutoML?
• What is a Prediction Endpoint?
• What is Feature Store?

Intermediate

• Difference between Batch Prediction and Online Prediction?
• What is Model Registry?
• What are Vertex AI Pipelines?
• What is Model Monitoring?
• What is Custom Training?

Advanced

• Explain Vertex AI architecture.
• Azure ML vs SageMaker vs Vertex AI?
• How would you deploy a deep learning model?
• How would you automate retraining?
• Design an enterprise MLOps solution using Vertex AI.

28. Mini Project

Crop Disease Detection using Vertex AI

Workflow

• Tasks
• Upload image dataset.
• Create a Vertex AI Dataset.
• Train an image classification model.
• Register the trained model.
• Deploy it to a Prediction Endpoint.
• Test predictions.
• Enable Model Monitoring.
• Build an automated retraining pipeline.

29. Complete Vertex AI Workflow

Chapter Summary

Google Vertex AI is Google Cloud's unified AI and Machine Learning platform. It provides managed tools for data preparation, training, AutoML, model versioning, deployment, monitoring, Feature Store, and MLOps automation. It also supports modern Generative AI applications, making it one of the most comprehensive AI platforms available today.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

│

▼

• AWS SageMaker

│

▼

• Google Vertex AI

At this stage, you've learned the three major enterprise cloud ML platforms

• Azure Machine Learning (Microsoft Azure)
• Amazon SageMaker (AWS)
• Google Vertex AI (Google Cloud Platform)

Although the interfaces differ, they all provide the same core capabilities

• Managed model training
• Experiment tracking
• Model registry
• Real-time and batch deployment
• Monitoring
• Automated ML pipelines
• MLOps integration
• Cloud Platform Comparison

What's Next?

In Chapter 10.12 – CI/CD, you'll learn how to automatically build, test, validate, and deploy machine learning applications whenever code changes are pushed to Git. You'll explore tools such as GitHub Actions, Azure DevOps, Jenkins, and AWS CodePipeline, and build a complete automated MLOps deployment pipeline.

Chapter 10.12 – CI/CD (Continuous Integration & Continuous Deployment)

• CI/CD is the backbone of modern DevOps and MLOps.

Every time a developer pushes code to GitHub, automated pipelines can build, test, package, and deploy the application without manual intervention.

Companies like Google, Microsoft, Amazon, Netflix, Meta, Uber, and OpenAI rely heavily on CI/CD to deliver software and machine learning models quickly and reliably.

Learning Objectives

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

• Understand CI/CD concepts.
• Learn Continuous Integration (CI).
• Learn Continuous Deployment (CD).
• Build CI/CD pipelines.
• Use GitHub Actions.
• Understand Azure DevOps and Jenkins.
• Automate ML model deployment.
• Integrate CI/CD with Docker, Kubernetes, and MLflow.
• Learn CI/CD best practices.
• Prepare for CI/CD interview questions.

1. Introduction

Imagine you're working on a Machine Learning project with five developers.

Every day, developers

• Fix bugs
• Improve models
• Update APIs
• Add new features

Without automation

Problems

• Human errors
• Slow deployments
• Missed tests
• Inconsistent environments
• CI/CD automates the entire process.

2. What is CI/CD?

CI/CD stands for

Continuous Integration (CI)

Continuous Delivery (CD) or Continuous Deployment (CD)

It is a practice that automates building, testing, and deploying software.

3. Continuous Integration (CI)

Definition

Continuous Integration is the practice of frequently merging code changes into a shared repository where automated builds and tests are executed.

Instead of merging code once every month,

developers merge changes several times a day.

Example

4. Why Continuous Integration?

Suppose

Developer A modifies

predict()

Developer B modifies

train()

Developer C modifies

database.py

CI automatically

• Builds the application.
• Runs tests.
• Detects integration issues early.

5. Continuous Delivery vs Continuous Deployment

Continuous Delivery

Deployment requires human approval.

Continuous Deployment

No manual approval is required once all checks pass.

6. CI/CD Workflow

Every code change follows the same automated path.

7. CI/CD Pipeline

A pipeline is a sequence of automated steps.

Typical stages

8. Popular CI/CD Tools

9. GitHub Actions

GitHub Actions is GitHub's built-in CI/CD platform.

Workflow

10. GitHub Actions Workflow File

Create

.github/workflows/python.yml

Example

name: Python CI

on

push

branches

- main

jobs

build

runs-on: ubuntu-latest

steps

- uses: actions/checkout@v4

- uses: actions/setup-python@v5

with

• python-version: "3.11"
• - run: pip install -r requirements.txt
• - run: pytest

Whenever code is pushed to the main branch

• Code is checked out.
• Python is installed.
• Dependencies are installed.
• Tests are executed.

11. Build Stage

Typical tasks

• Install dependencies.
• Compile code (if needed).
• Validate syntax.
• Build Docker image.

Example

docker build -t ml-api .

12. Testing Stage

Tests ensure code quality.

Common tests

• Unit Tests
• Integration Tests
• API Tests
• Model Validation

Example

pytest

13. Packaging Stage

Package the application.

Example

The image is pushed to

• Docker Hub
• Azure Container Registry
• Amazon ECR
• Google Artifact Registry

14. Deployment Stage

Deploy the Docker image.

Example

15. CI/CD for Machine Learning

Machine Learning pipelines often include additional stages.

Unlike traditional software, ML pipelines may retrain models before deployment.

16. CI/CD + MLflow

MLflow tracks

• Parameters
• Metrics
• Artifacts
• Models
• Only approved models move to deployment.

17. CI/CD + Docker

This ensures the same container is tested and deployed.

18. CI/CD + Kubernetes

Kubernetes updates applications with minimal downtime.

19. Azure DevOps

Azure DevOps provides

• Git repositories
• Boards
• Pipelines
• Test Plans
• Artifacts

Typical workflow

20. Jenkins

Jenkins is an open-source automation server.

Workflow

Jenkins supports thousands of plugins.

21. AWS CodePipeline

AWS CodePipeline automates

22. Google Cloud Build

Google Cloud Build integrates with Vertex AI.

23. Complete MLOps Pipeline

24. Real-World Example

Suppose a bank updates its fraud detection model.

Pipeline

If tests fail,

deployment stops automatically.

25. Advantages

• Faster deployments.
• Fewer human errors.
• Consistent releases.
• Better collaboration.
• Automatic testing.
• Reliable deployments.
• Easier rollback.

26. Limitations

• Initial setup takes time.
• Pipeline maintenance is required.
• Poorly designed tests reduce effectiveness.

Training large ML models can make pipelines slow if not optimized.

27. Best Practices

• Commit small changes frequently.
• Run automated tests.
• Build Docker images automatically.
• Version models.
• Use infrastructure as code.
• Monitor production deployments.
• Keep secrets in secure vaults (never in source code).

28. Common Mistakes

• Deploying without testing.
• Ignoring failed builds.
• Hardcoding passwords or API keys.
• Building huge Docker images unnecessarily.
• Skipping model validation before deployment.

29. Interview Questions

Beginner

• What is CI/CD?
• What is Continuous Integration?
• What is Continuous Deployment?
• What is GitHub Actions?
• Why do we automate deployments?

Intermediate

• Explain a CI/CD pipeline.
• GitHub Actions vs Jenkins?
• What happens after a Git push?
• How do Docker and Kubernetes fit into CI/CD?
• How do you automate testing?

Advanced

• Design a CI/CD pipeline for a Machine Learning project.
• How would you integrate MLflow into CI/CD?
• How would you automate model deployment?
• How would you roll back a failed deployment?
• How would you build an enterprise MLOps pipeline?

30. Mini Project

• End-to-End CI/CD Pipeline for a House Price Prediction API
• Project Structure
• HousePriceAPI/
• ├── app.py
• ├── model.pkl
• ├── Dockerfile
• ├── requirements.txt
• ├── tests/

└── .github/

• └── workflows/
• └── python.yml
• Pipeline Tasks
• Push code to GitHub.
• Run unit tests.
• Build a Docker image.
• Push the image to a container registry.
• Deploy to Kubernetes.
• Run health checks.
• Notify the team on success or failure.

31. Complete Enterprise CI/CD Architecture

Developer

│

▼

GitHub Repository

│

▼

GitHub Actions

│

▼

Run Tests

│

▼

Train ML Model

│

▼

MLflow Registry

│

▼

Docker Build

│

▼

Container Registry

│

▼

Kubernetes

│

▼

Production

│

▼

Monitoring

32. CI/CD Workflow Cheat Sheet

Write Code

│

▼

Git Commit

│

▼

Git Push

│

▼

CI Pipeline

│

▼

Build

│

▼

Test

│

▼

Package

│

▼

Deploy

│

▼

Monitor

Chapter Summary

CI/CD (Continuous Integration and Continuous Delivery/Deployment) automates the software and machine learning delivery process. It ensures that every code change is automatically built, tested, packaged, and deployed, reducing manual effort and improving software quality. In MLOps, CI/CD extends beyond application code to include model training, validation, experiment tracking, containerization, deployment, and monitoring, making it an essential practice for production AI systems.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

│

▼

• AWS SageMaker

│

▼

• Google Vertex AI

│

▼

• CI/CD

At this stage, you have covered the complete workflow from writing code to deploying AI applications automatically. You now understand:

• Version control with Git
• Containerization using Docker
• Orchestration with Kubernetes
• Experiment tracking with MLflow
• Data versioning using DVC
• API development using FastAPI and Flask
• Interactive dashboards with Streamlit
• Cloud ML platforms (Azure ML, SageMaker, Vertex AI)
• Automated software and ML delivery using CI/CD
• What's Next?

In Chapter 10.13 – Model Monitoring, you'll learn how to monitor machine learning models after deployment by tracking prediction latency, accuracy, resource utilization, failures, and data quality. You'll also explore how to detect performance degradation and trigger alerts or retraining, which is critical for maintaining reliable AI systems in production.

Chapter 10.13 – Model Monitoring

• Deploying a Machine Learning model is not the end of the project—it is the beginning of production operations.

A model that performs well today may perform poorly tomorrow because data changes, user behavior changes, or system performance degrades.

Model Monitoring continuously observes deployed models to ensure they remain accurate, reliable, and efficient.

Learning Objectives

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

• Understand Model Monitoring.
• Learn why monitoring is important.
• Monitor prediction quality.
• Monitor system performance.
• Detect model degradation.
• Understand alerts and dashboards.
• Learn monitoring architecture.
• Integrate monitoring with MLOps.
• Prepare for Model Monitoring interview questions.

1. Introduction

Imagine you build a Loan Approval Model.

During testing

• Accuracy
• 97%
• After deployment,
• everything works well.
• Six months later,
• customers complain.

The model now performs

• Accuracy
• 81%
• What happened?

Possible reasons

• Customer behavior changed.
• Economic conditions changed.
• New types of applicants appeared.
• Input data quality declined.
• Without monitoring,

you may not notice the problem until users report it.

2. What is Model Monitoring?

Definition

Model Monitoring is the continuous process of observing the health, performance, quality, and behavior of machine learning models after deployment.

Monitoring helps answer questions such as

• Is the model responding quickly?
• Are predictions still accurate?
• Has input data changed?
• Is the system available?
• Should the model be retrained?

3. Why Model Monitoring?

Training accuracy

98%

Production accuracy

82%

Without monitoring

• The issue may remain hidden.

With monitoring

✅ Teams receive alerts and can investigate or retrain the model.

4. Monitoring Architecture

5. What Should Be Monitored?

A production ML system should monitor

• Prediction latency
• Throughput
• Error rate
• Resource usage
• Data quality
• Model quality
• Data drift
• Concept drift
• Business metrics

6. Prediction Latency

Latency measures how long the model takes to respond.

Example

Low latency is important for

• Chatbots
• Fraud detection
• Recommendation systems
• Search

7. Throughput

Throughput measures how many requests the system handles.

Example

500 Requests

Per Second

High throughput is essential for large-scale applications.

8. Error Rate

Monitor failed requests.

Example

Total Requests

5

Error Rate

0.5%

A sudden increase may indicate deployment issues.

9. CPU and Memory Usage

Monitor infrastructure resources.

Example

• CPU
• 65%
• Memory
• 72%

High resource usage can increase response times or cause failures.

10. Prediction Distribution

Track how predictions are distributed over time.

Example

• Approved Loans
• 85%
• Rejected Loans
• 15%
• If the distribution changes dramatically,

the model or input data may require investigation.

11. Data Quality Monitoring

Check for problems such as

• Missing values
• Invalid values
• Duplicate records
• Unexpected formats
• Out-of-range values

Example

• Age
• Expected
• 18–80
• Received
• -25
• This indicates invalid input data.

12. Model Quality Monitoring

If actual outcomes become available,

compare predictions with reality.

Example

Prediction

Rejected

Metrics include

• Accuracy
• Precision
• Recall
• F1 Score
• RMSE (Regression)

13. Drift Monitoring

There are two major types of drift.

These are covered in detail in the next chapter.

14. Business Metrics

Technical metrics alone are not enough.

Business metrics include

• Revenue
• Customer satisfaction
• Conversion rate
• Fraud losses
• Loan defaults

Sometimes technical metrics remain stable while business outcomes decline.

15. Logging Predictions

Example log

Logs help diagnose production issues.

16. Dashboards

Monitoring dashboards visualize system health.

Typical dashboard

Accuracy

96%

──────────────

Latency

105 ms

──────────────

Requests

1200/min

──────────────

Error Rate

0.3%

Popular dashboard tools

• Grafana
• Azure Monitor
• Amazon CloudWatch
• Google Cloud Monitoring

17. Alerts

Alerts notify engineers when thresholds are exceeded.

Example

Other alert conditions

• High error rate
• CPU usage > 90%
• Data drift detected
• Endpoint unavailable

18. Monitoring Workflow

19. Model Monitoring in MLOps

Monitoring creates a continuous feedback loop.

20. Monitoring Tools

21. Real-World Example

Suppose a fraud detection model is deployed.

Monitoring dashboard shows

Latency

At the same time

CPU

Investigation finds a sudden traffic spike.

Solution

• Scale additional containers.
• Optimize the model.
• Increase infrastructure capacity.

22. Healthcare Example

Disease prediction model

Training Accuracy

98%

Production Accuracy

84%

Monitoring identifies

New disease patterns.

Outdated training data.

The model is retrained with recent data.

23. End-to-End Monitoring Architecture

24. Advantages

• Detects performance degradation.
• Improves reliability.
• Reduces downtime.
• Identifies data quality issues.
• Supports proactive maintenance.
• Helps maintain business performance.

25. Limitations

• Monitoring infrastructure adds operational cost.
• Some quality metrics require delayed ground-truth labels.
• Thresholds must be tuned carefully.
• Large-scale logging requires storage and governance.

26. Best Practices

• Monitor both technical and business metrics.
• Create dashboards for different audiences.
• Configure meaningful alerts.
• Store prediction logs securely.
• Review trends regularly.
• Monitor data quality continuously.
• Combine monitoring with automated retraining workflows.

27. Common Mistakes

• Monitoring only CPU usage.
• Ignoring business metrics.
• No alerting mechanism.
• Never reviewing monitoring dashboards.
• Assuming training accuracy guarantees production performance.

28. Interview Questions

Beginner

• What is Model Monitoring?
• Why is monitoring important?
• What is prediction latency?
• What is throughput?
• What is error rate?

Intermediate

• What metrics should be monitored?
• What are business metrics?
• How would you monitor an ML model?
• What tools are commonly used?
• Why is monitoring necessary after deployment?

Advanced

• Design a monitoring architecture for an ML API.
• How would you detect model degradation?
• How would you monitor a fraud detection model?
• How would you create production alerts?
• Explain the role of monitoring in an MLOps pipeline.

29. Mini Project

Monitoring a House Price Prediction API

Architecture

• Tasks
• Deploy the prediction API.
• Record every prediction request.
• Measure latency and throughput.
• Create Grafana dashboards.

Configure alerts for high latency and error rates.

Analyze production metrics weekly.

30. Complete Monitoring Workflow

Prediction Request

│

▼

Model Response

│

▼

Logging

│

▼

Metrics Collection

│

▼

Dashboard

│

▼

Alert

│

▼

Investigation

│

▼

Retraining (if required)

Chapter Summary

Model Monitoring is the continuous observation of machine learning models after deployment. It ensures that models remain accurate, reliable, scalable, and responsive by tracking technical metrics (such as latency, throughput, and resource utilization), data quality, prediction quality, and business outcomes. Effective monitoring enables organizations to detect issues early, respond quickly, and maintain production-grade AI systems.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

│

▼

• AWS SageMaker

│

▼

• Google Vertex AI

│

▼

• CI/CD

│

▼

• Model Monitoring

You have now learned how to deploy and operate machine learning systems in production. Monitoring closes the loop between deployment and continuous improvement.

What's Next?

In Chapter 10.14 – Data Drift, you'll learn one of the most important causes of model degradation. You'll explore data drift, concept drift, target drift, methods to detect them statistically, and strategies for retraining models when production data changes over time. This topic is fundamental to maintaining accurate AI systems in real-world environments.

Chapter 10.14 – Data Drift

• One of the biggest reasons Machine Learning models fail in production is Data Drift.

A model may achieve 98% accuracy during training, but after several months, its performance may fall significantly because the data seen in production no longer resembles the data used during training.

Detecting and handling Data Drift is one of the most important responsibilities in MLOps.

Learning Objectives

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

• Understand Data Drift.
• Differentiate Data Drift, Concept Drift, and Target Drift.
• Learn the causes of drift.
• Detect drift using statistical methods.
• Monitor drift in production.
• Mitigate drift through retraining and feature engineering.
• Integrate drift detection into MLOps pipelines.
• Prepare for Data Drift interview questions.

1. Introduction

Suppose you trained a House Price Prediction Model using data from 2022.

The model achieved

Training Accuracy

97%

Now it's 2026.

House prices have changed due to

• Inflation
• Interest rates
• New government policies
• Population growth

The model now performs

• Production Accuracy
• 82%
• The model wasn't necessarily built incorrectly.
• The data changed.

This is called Data Drift.

2. What is Data Drift?

Definition

Data Drift occurs when the statistical distribution of input features changes between the training data and the production data.

In simple words

The model learned from one type of data,

but now receives different data.

3. Example of Data Drift

Training data

Average income

₹5,00,000

Production data

Average income

₹12,33,333

The income distribution has changed.

This is Data Drift.

4. Why Does Data Drift Occur?

Common causes include

• Economic changes
• Seasonal trends
• Customer behavior changes
• Market changes
• Policy changes
• Sensor changes
• New products
• Geographic expansion

Example

A food delivery app trained on weekday orders may see different patterns during holidays.

5. Types of Drift

Three common types

├── Concept Drift

└── Target Drift

6. Data Drift

Only the input features change.

Example

Training

Customer Age

20–40

Production

Customer Age

45–70

The relationship between features and labels may remain the same, but the input distribution changes.

7. Concept Drift

Definition

Concept Drift occurs when the relationship between input features and the target variable changes over time.

Example

Before COVID

During COVID

Customer behavior changed.

The model's learned relationship is no longer valid.

8. Target Drift

Target Drift occurs when the distribution of the target variable changes.

Example

Fraud detection

Training

Fraud Cases

2%

Production

Fraud Cases

8%

The proportion of positive and negative labels has changed.

9. Visualizing Drift

Training distribution

Feature Value

*****

***********

***************

***********

*****

Production distribution

Feature Value

***********

********************

***************

*******

**

The shapes differ, indicating potential drift.

10. Why Drift Matters

Without drift

With drift

Even a well-trained model can degrade when data changes.

11. Drift Detection

The general workflow

12. Statistical Methods

Common methods include

• Kolmogorov–Smirnov (KS) Test
• Chi-Square Test
• Population Stability Index (PSI)
• Jensen-Shannon Distance
• Wasserstein Distance

Each compares the training and production distributions in different ways.

13. Population Stability Index (PSI)

PSI is commonly used in banking and finance.

Typical interpretation

Example

PSI = 0.32

↓

Significant Drift

14. Kolmogorov–Smirnov (KS) Test

The KS Test compares two continuous distributions.

Example

A larger difference suggests stronger evidence that the distributions differ.

15. Monitoring Drift

Typical production workflow

16. Drift Dashboard

Example

• Feature Drift
• Income
• High

──────────────

Age

Low

──────────────

City

None

──────────────

Loan Amount

Medium

The dashboard helps identify which features have changed the most.

17. Drift Alerts

Example rules

Or

KS Statistic

Alerts enable proactive action.

18. Handling Data Drift

Common strategies

• Collect new data.
• Retrain the model.
• Add new features.
• Remove outdated features.
• Adjust feature engineering.
• Monitor continuously.

Retraining is often the most effective solution when drift is persistent.

19. Automated Retraining

This is common in mature MLOps systems.

20. Drift in Different Industries

• Banking
• Income changes.
• Credit scores change.
• Fraud patterns evolve.
• Retail
• Seasonal buying behavior.
• Holiday sales.
• New products.
• Healthcare
• New diseases.
• New treatment protocols.
• Population changes.
• Agriculture
• Rainfall.
• Temperature.
• Soil conditions.
• Crop diseases.
• Manufacturing
• Sensor calibration changes.
• Machine wear.
• New equipment.

21. Real-World Example

Loan approval model

Training

Average Salary

₹6 Lakhs

Production

• Average Salary
• ₹10 Lakhs
• The salary feature has drifted.
• The monitoring system detects this,
• and a retraining pipeline is started.

22. Data Drift in MLOps

This continuous cycle keeps the model relevant.

23. Data Drift vs Concept Drift

24. Advantages of Drift Monitoring

• Detects changing data patterns.
• Improves model reliability.
• Enables proactive retraining.
• Maintains prediction quality.
• Supports long-term production stability.

25. Limitations

• Requires historical reference data.
• Some drift metrics need careful threshold selection.
• Not every detected drift requires retraining.

Label availability may be delayed, making concept drift harder to detect.

26. Best Practices

• Monitor important features separately.
• Store training data statistics.
• Automate drift detection.
• Create dashboards.
• Set meaningful alert thresholds.
• Retrain only after proper evaluation.
• Track drift trends over time.

27. Common Mistakes

• Ignoring production data.
• Retraining after every small drift.
• Monitoring only accuracy.
• Using outdated reference datasets forever.
• Ignoring business context.

28. Interview Questions

Beginner

• What is Data Drift?
• Why does Data Drift occur?
• What is Concept Drift?
• What is Target Drift?
• Why is drift monitoring important?

Intermediate

• How do you detect Data Drift?
• What is Population Stability Index (PSI)?
• What is the KS Test?
• How do you monitor drift in production?
• How would you respond to detected drift?

Advanced

• Design a drift monitoring architecture.
• How would you automate retraining?
• How would you detect drift in a fraud detection model?
• Explain Data Drift vs Concept Drift with examples.
• How would you integrate drift detection into an MLOps pipeline?

29. Mini Project

Drift Detection for a Loan Approval Model

Architecture

• Tasks
• Store baseline training statistics.
• Collect production data daily.
• Calculate PSI for important features.
• Run KS Tests for continuous variables.
• Display drift dashboards.
• Send alerts when thresholds are exceeded.
• Retrain and evaluate the model if necessary.

30. Complete Drift Detection Workflow

Training Data

│

▼

Production Data

│

▼

Statistical Comparison

│

▼

Drift Detection

│

▼

Dashboard

│

▼

Alert

│

▼

Retraining

│

▼

Production

Chapter Summary

Data Drift occurs when the statistical properties of production input data differ from the data used to train the model. If left unmanaged, it can reduce prediction quality over time. Effective MLOps systems continuously compare production data with training data, detect meaningful drift using statistical techniques such as PSI and the KS Test, and trigger investigation or retraining when appropriate. Understanding the distinction between Data Drift, Concept Drift, and Target Drift is essential for maintaining reliable machine learning systems.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

│

▼

• AWS SageMaker

│

▼

• Google Vertex AI

│

▼

• CI/CD

│

▼

• Model Monitoring

│

▼

• Data Drift

You now understand one of the most important operational challenges in production AI systems: keeping models accurate as real-world data evolves.

What's Next?

In Chapter 10.15 – Feature Store, you'll learn how organizations manage, version, and share machine learning features across multiple teams and models. You'll explore online and offline feature stores, feature engineering workflows, feature reuse, consistency between training and serving, and enterprise Feature Store architectures used by companies such as Uber, Airbnb, Netflix, and Google.

Chapter 10.15 – Feature Store

• A Feature Store is a centralized repository for storing, managing, versioning, and serving Machine Learning features.

Instead of every Data Scientist creating the same features repeatedly, a Feature Store allows teams to build once, reuse many times, ensuring consistency between training and production.

Learning Objectives

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

• Understand what a Feature Store is.
• Learn why Feature Stores are important.
• Understand features and feature engineering.
• Learn online and offline Feature Stores.
• Understand feature versioning.
• Prevent training-serving skew.
• Integrate Feature Stores into MLOps pipelines.
• Prepare for Feature Store interview questions.

1. Introduction

Suppose your company has three Machine Learning projects

• Loan Approval
• Credit Card Fraud Detection
• Customer Churn Prediction

All three models use

• Customer Age
• Income
• Credit Score
• Account Balance

Without a Feature Store

------------------

------------------

The same work is repeated multiple times.

A Feature Store solves this problem.

2. What is a Feature?

A feature is an input variable used by a Machine Learning model.

Example

Predict house prices.

Features

• Area
• Bedrooms
• House Age

Target

Price

3. What is Feature Engineering?

Feature Engineering is the process of creating useful input variables from raw data.

Raw Data

Raw Data

Raw Data

Better features often lead to better model performance.

4. What is a Feature Store?

Definition

A Feature Store is a centralized platform that stores, manages, versions, and serves machine learning features for both model training and real-time inference.

It ensures the same feature definitions are used across the organization.

5. Why Do We Need a Feature Store?

Without Feature Store

------------------

(Different Calculation)

------------------

(Another Calculation)

This leads to inconsistent models.

With Feature Store

6. Feature Store Architecture

Raw Data

│

▼

Feature Engineering

│

▼

Feature Store

┌─────────┴─────────┐

▼ ▼

Offline Store Online Store

│ │

▼ ▼

Model Training Real-Time Prediction

7. Offline Feature Store

The Offline Feature Store stores historical features.

Used for

• Model training
• Batch inference
• Data analysis
• Experimentation

Example

8. Online Feature Store

The Online Feature Store serves features with very low latency.

Used for

• Real-time APIs
• Fraud detection
• Recommendations
• Chatbots

Example

9. Offline vs Online Feature Store

10. Feature Versioning

Features evolve over time.

Example

Version 1

Income

Version 2

Income

+

Bonus

Version 3

Income

+

Bonus

+

Investments

A Feature Store keeps track of these versions.

11. Training-Serving Skew

One of the biggest ML problems.

Training

Age = Current Year - Birth Year

Production

Age = Entered Manually

Different calculations produce different values.

This difference is called Training-Serving Skew.

12. Preventing Training-Serving Skew

Feature Store Solution

Both training and inference use the exact same feature logic.

13. Feature Pipeline

Features are generated once and reused.

14. Feature Metadata

A Feature Store maintains metadata such as

• Feature name
• Data type
• Owner
• Description
• Creation date
• Version
• Source table
• Update frequency

Example

15. Feature Freshness

Some features update frequently.

Examples

Freshness is important for accurate predictions.

16. Feature Lineage

Lineage tracks where a feature comes from.

Example

This improves transparency and debugging.

17. Feature Monitoring

Monitor

• Missing values
• Feature drift
• Feature freshness
• Data quality
• Update failures

Example

• Credit Score
• Expected
• 300–900
• Received

18. Feature Store Workflow

19. Popular Feature Stores

Azure Machine Learning integrates with feature management capabilities, although it does not currently provide a native Feature Store service equivalent to some other platforms.

20. Feature Store in MLOps

21. Real-World Example

Fraud Detection

Features

• Average Transaction Amount
• Transactions Last Hour
• Country
• Device Type
• Login Frequency
• Instead of recalculating them for every model,

the Feature Store provides them to

• Fraud Detection
• Risk Analysis
• Credit Approval

22. Banking Example

Multiple models reuse these standardized features.

23. E-Commerce Example

These features can also support churn prediction and marketing models.

24. Advantages

• Eliminates duplicate feature engineering.
• Improves consistency.
• Prevents training-serving skew.
• Supports feature reuse.
• Simplifies collaboration.
• Improves model quality.
• Enables feature versioning.

25. Limitations

• Additional infrastructure is required.
• Governance and ownership are important.
• Feature design still requires domain expertise.
• Real-time synchronization can be complex.

26. Best Practices

• Use consistent feature definitions.
• Version important features.
• Monitor feature freshness.
• Document feature metadata.
• Reuse existing features before creating new ones.
• Monitor feature drift.
• Automate feature pipelines.

27. Common Mistakes

• Duplicating feature logic across teams.
• Ignoring feature versioning.
• Mixing training and production calculations.
• Not documenting feature definitions.
• Serving stale features.

28. Interview Questions

Beginner

• What is a Feature?
• What is a Feature Store?
• Why is a Feature Store needed?
• What is Feature Engineering?
• What is Training-Serving Skew?

Intermediate

• Difference between Online and Offline Feature Stores?
• What is Feature Versioning?
• What is Feature Lineage?
• What is Feature Freshness?
• How do Feature Stores improve collaboration?

Advanced

• Design an enterprise Feature Store architecture.
• How would you prevent Training-Serving Skew?
• How would you monitor feature quality?
• How would you integrate a Feature Store into an MLOps pipeline?
• Compare Feast, SageMaker Feature Store, and Vertex AI Feature Store.

29. Mini Project

Feature Store for Customer Churn Prediction

Architecture

├─────────────┐

│ │

▼ ▼

Offline Store Online Store

│ │

▼ ▼

Training Real-Time API

• Features
• Customer Age
• Monthly Spending
• Average Session Time
• Number of Purchases
• Customer Lifetime Value
• Tasks
• Create reusable features.
• Store feature metadata.
• Version features.
• Train a churn model using the Offline Store.
• Serve real-time predictions using the Online Store.
• Monitor feature freshness and drift.

30. Enterprise Feature Store Architecture

Raw Data Sources

│

▼

ETL / Data Engineering

│

▼

Feature Engineering

│

▼

Feature Store

┌───────────────┐

│ │

▼ ▼

Offline Store Online Store

│ │

▼ ▼

Model Training Real-Time Inference

│

▼

MLflow

│

▼

Model Registry

│

▼

Deployment

Chapter Summary

A Feature Store is a centralized system for storing, managing, versioning, and serving machine learning features. It enables organizations to reuse features across projects, maintain consistency between training and inference, reduce duplicated work, and improve collaboration among teams. Modern MLOps platforms use Feature Stores to ensure reliable, scalable, and reproducible machine learning systems.

Learning Progress

• Git & GitHub

│

▼

• Docker

│

▼

• Kubernetes

│

▼

• MLflow

│

▼

• DVC

│

▼

• FastAPI

│

▼

• Flask

│

▼

• Streamlit

│

▼

• Azure Machine Learning

│

▼

• AWS SageMaker

│

▼

• Google Vertex AI

│

▼

• CI/CD

│

▼

• Model Monitoring

│

▼

• Data Drift

│

▼

• Feature Store

You now understand how enterprise organizations standardize feature engineering, eliminate duplicate work, and ensure that the same feature definitions are used consistently for both model training and production inference.

What's Next?

In Chapter 10.16 – Deployment Strategies, you'll learn how to safely deploy new machine learning models into production using techniques such as Blue-Green Deployment, Canary Deployment, Rolling Updates, Shadow Deployment, and A/B Testing. These strategies help minimize downtime, reduce deployment risk, and validate new models before exposing them to all users.

Chapter 10.16 – Deployment Strategies

• Training a Machine Learning model is only half the job. Deploying it safely is equally important.

A new model may have higher accuracy during testing, but if it contains hidden bugs or behaves unexpectedly in production, it can impact thousands or even millions of users.

Deployment Strategies help organizations release new models safely while minimizing downtime and business risk.

Learning Objectives

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

• Understand deployment strategies.
• Learn Blue-Green Deployment.
• Learn Rolling Deployment.
• Learn Canary Deployment.
• Learn Shadow Deployment.
• Learn A/B Testing.
• Understand rollback strategies.
• Deploy ML models safely.
• Integrate deployment strategies into MLOps.
• Prepare for deployment interview questions.

1. Introduction

Suppose your bank has deployed a Loan Approval Model (Version 1).

Current performance

• Accuracy
• 94%
• You develop a new model.

New performance

Accuracy

97%

Question

• Should you immediately replace the old model?
• No.
• If the new model has hidden issues,
• millions of loan decisions could be affected.
• Instead, use a deployment strategy.

2. What is a Deployment Strategy?

Definition

A Deployment Strategy is a controlled approach for releasing a new version of an application or Machine Learning model into production while minimizing downtime and reducing deployment risk.

Deployment strategies determine

• Who receives the new model.
• When they receive it.
• How failures are handled.
• How rollbacks occur.

3. Why Deployment Strategies?

Without strategy

With strategy

Risk is significantly reduced.

4. Deployment Workflow

Monitoring remains essential after deployment.

5. Blue-Green Deployment

Blue-Green Deployment uses two identical production environments.

──────────────

Initially

Users access

After validation

The switch is almost instantaneous.

6. Blue-Green Rollback

Suppose Green fails.

Rollback

Rollback is quick because the previous environment is still running.

7. Advantages of Blue-Green Deployment

• Near-zero downtime.
• Fast rollback.
• Easy testing.
• Low deployment risk.

8. Limitations

• Requires duplicate infrastructure.
• Higher cloud costs.
• Database migrations require careful planning.

9. Rolling Deployment

Instead of replacing every server,

replace them gradually.

Example

Server 1

Version 2

──────────

Server 2

Version 1

──────────

Server 3

Version 1

Then

Finally

10. Rolling Update Workflow

This approach is commonly used in Kubernetes.

11. Advantages

• No downtime.
• Lower infrastructure cost.
• Gradual rollout.

12. Limitations

• Multiple versions run simultaneously.
• Rollback can take longer than Blue-Green.
• Compatibility between versions is important.

13. Canary Deployment

Deploy to a small percentage of users first.

Example

If everything works well

14. Canary Workflow

15. Advantages

• Very low deployment risk.
• Real production testing.
• Easy to detect issues early.

16. Limitations

• Requires traffic routing.
• More operational complexity.
• Monitoring must be accurate.

17. Shadow Deployment

Shadow Deployment sends production traffic to both models.

────────────

• (Not Used)
• Users only receive responses from Version 1.
• Version 2 is evaluated silently.

18. Advantages

• Safe evaluation.
• No customer impact.
• Uses real production traffic.

19. Limitations

• Double infrastructure cost.
• Higher resource usage.
• Additional logging required.

20. A/B Testing

• Two models actively serve different user groups.
• Users
• ├── Group A

│

▼

Model A

────────────

Users

├── Group B

│

▼

Model B

Compare