1. What is MLOps?

MLOps (Machine Learning Operations) is the practice of applying software engineering and DevOps principles to the complete machine-learning lifecycle. A typical ML project involves:

Data
  ↓
Preprocessing
  ↓
Training
  ↓
Evaluation
  ↓
Model Registry
  ↓
Deployment
  ↓
Monitoring
  ↓
Retraining

MLOps automates and manages this entire workflow.

Why MLOps is needed

A model working inside a Jupyter Notebook is not enough for a production application. An ML system needs to handle:

Data ingestion
Data preprocessing
Model training
Model evaluation
Experiment tracking
Model versioning
Model deployment
API serving
Monitoring
Retraining
Automation

2. Traditional ML vs MLOps

Without MLOps

Developer
   ↓
Jupyter Notebook
   ↓
Train Model
   ↓
Save model.pkl
   ↓
Manually deploy

Problems:

Difficult to reproduce experiments
Model versions can be confusing
Manual deployment
Difficult to monitor
Difficult to retrain
Difficult to track data/model changes

With MLOps

Data
 ↓
Pipeline
 ↓
Training
 ↓
MLflow
 ↓
Model Registry
 ↓
FastAPI
 ↓
Docker
 ↓
Prometheus
 ↓
Grafana

3. End-to-End MLOps Pipeline

The main pipeline can be divided into four stages:

INGEST
   ↓
TRAIN
   ↓
SERVE
   ↓
MONITOR

1. Ingest

Collect and prepare data.

Dataset
   ↓
Validation
   ↓
Preprocessing
   ↓
Training Data

2. Train

Train and evaluate the ML model.

Training Data
     ↓
Model Training
     ↓
Evaluation
     ↓
MLflow

3. Serve

Expose the trained model through an API.

Registered Model
      ↓
    FastAPI
      ↓
Prediction API

4. Monitor

Monitor the deployed application.

FastAPI
   ↓
Prometheus
   ↓
Grafana

4. Project Structure

A simple MLOps project can be organized as:

Day 49 - MLOps Pipeline/
│
├── data/
│   └── data.csv
│
├── models/
│
├── scripts/
│   ├── train.py
│   ├── serve.py
│   └── monitor.py
│
├── mlops_demo.ipynb
├── requirements.txt
├── mlflow.db
└── .gitignore

For the learning example, the pipeline will use the Diabetes dataset from scikit-learn.

5. Technologies Used

Tool	Purpose
Python	Pipeline implementation
Pandas	Data processing
Scikit-learn	Model training
MLflow	Experiment tracking and model registry
FastAPI	Model serving
Uvicorn	API server
Prometheus	Metrics collection
Grafana	Metrics visualization
Docker	Containerization
GitHub Actions	CI/CD automation

6. Step 1 – Data Ingestion

Data ingestion means obtaining data and making it available to the ML pipeline. For this example, use the Diabetes dataset.

Cell 1 – Imports

import pandas as pd

from sklearn.datasets import load_diabetes

Cell 2 – Load Dataset

data = load_diabetes(as_frame=True)

df = data.frame

print(df.head())
print("Shape:", df.shape)

Example output:

        age       sex       bmi  ...        s5        s6       target
0  0.038076  0.050680  0.061696  ...  0.019907 -0.017646  151.0
1 -0.001882 -0.044642 -0.051474  ... -0.068330 -0.092204   75.0
...

Cell 3 – Save Data

import os

os.makedirs("data", exist_ok=True)

df.to_csv("data/data.csv", index=False)

print("data.csv created successfully")

The resulting structure:

data/
└── data.csv

7. Step 2 – Data Preparation

Separate the features and target.

X = df.drop("target", axis=1)

y = df["target"]

print("Features:", X.shape)
print("Target:", y.shape)

Here:

X → Input features
y → Target value

8. Step 3 – Train/Test Split

The dataset is divided into training and testing data.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

print("Training data:", X_train.shape)
print("Testing data:", X_test.shape)

Why split the dataset?

The training set is used to learn patterns. The testing set is used to evaluate how well the model performs on unseen data.

Dataset
   │
   ├── 80% → Training
   │
   └── 20% → Testing

9. Step 4 – Model Training

Use Linear Regression.

from sklearn.linear_model import LinearRegression

model = LinearRegression()

model.fit(X_train, y_train)

print("Model trained successfully")

10. Step 5 – Model Evaluation

Generate predictions:

predictions = model.predict(X_test)

Calculate metrics:

from sklearn.metrics import mean_squared_error, r2_score

mse = mean_squared_error(y_test, predictions)

rmse = mse ** 0.5

r2 = r2_score(y_test, predictions)

print("MSE:", mse)
print("RMSE:", rmse)
print("R2:", r2)

Important metrics

MSE

MSE = average((actual - predicted)²)

RMSE

RMSE = √MSE

R² Measures how much of the target variation is explained by the model.

11. Step 6 – Experiment Tracking with MLflow

MLflow records information about ML experiments. It can track:

Parameters
Metrics
Models
Artifacts
Experiments
Runs

For example:

Experiment: MLOps Demo 1

Run 1
├── model = LinearRegression
├── test_size = 0.2
├── random_state = 42
├── mse = ...
├── rmse = ...
└── r2 = ...

12. MLflow Configuration

Install MLflow:

pip install mlflow

Then configure it.

Cell 4 – MLflow

import mlflow
import mlflow.sklearn

mlflow.set_tracking_uri("sqlite:///mlflow.db")

mlflow.set_experiment("MLOps Demo 1")

print("MLflow experiment configured")

13. Step 7 – Log the Training Run

with mlflow.start_run():

    model = LinearRegression()

    model.fit(X_train, y_train)

    predictions = model.predict(X_test)

    mse = mean_squared_error(y_test, predictions)

    rmse = mse ** 0.5

    r2 = r2_score(y_test, predictions)

    # Parameters
    mlflow.log_param("model", "LinearRegression")
    mlflow.log_param("test_size", 0.2)
    mlflow.log_param("random_state", 42)

    # Metrics
    mlflow.log_metric("mse", mse)
    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)

    print("Training run logged successfully")

14. Step 8 – Register the Model

The trained model can be registered in MLflow.

with mlflow.start_run():

    model = LinearRegression()

    model.fit(X_train, y_train)

    predictions = model.predict(X_test)

    mse = mean_squared_error(y_test, predictions)
    rmse = mse ** 0.5
    r2 = r2_score(y_test, predictions)

    mlflow.log_param("model", "LinearRegression")

    mlflow.log_metric("mse", mse)
    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)

    mlflow.sklearn.log_model(
        model,
        name="diabetes_model",
        registered_model_name="DiabetesRegression"
    )

    print("Model registered successfully")

MLflow will create something like:

DiabetesRegression
└── Version 1

If another model is registered later:

DiabetesRegression
├── Version 1
└── Version 2

15. Viewing MLflow UI

Start MLflow from the project directory:

mlflow ui \
  --backend-store-uri sqlite:///mlflow.db \
  --port 5000

On Git Bash, this can also be written as:

mlflow ui --backend-store-uri sqlite:///mlflow.db --port 5000

Open:

http://127.0.0.1:5000

The UI allows inspection of:

Experiments
    ↓
Runs
    ↓
Parameters
    ↓
Metrics
    ↓
Artifacts
    ↓
Registered Models

16. Step 9 – Model Serving

After registering the model, expose it through FastAPI. Create:

scripts/serve.py

import mlflow
import mlflow.sklearn

from fastapi import FastAPI
from pydantic import BaseModel


app = FastAPI(title="Diabetes Prediction API")


mlflow.set_tracking_uri("sqlite:///mlflow.db")

model = mlflow.sklearn.load_model(
    "models:/DiabetesRegression/1"
)


class PredictionInput(BaseModel):

    features: list[float]


@app.get("/")
def home():

    return {
        "message": "Diabetes Prediction API"
    }


@app.post("/predict")
def predict(data: PredictionInput):

    prediction = model.predict(
        [data.features]
    )

    return {
        "prediction": float(prediction[0])
    }

17. Start FastAPI

From the project root:

uvicorn scripts.serve:app --reload

API:

http://127.0.0.1:8000

Swagger documentation:

http://127.0.0.1:8000/docs

18. Test the Prediction API

The Diabetes dataset contains 10 features, so the request should contain 10 values. Example:

{
    "features": [
        0.038,
        0.050,
        0.061,
        0.021,
        -0.044,
        -0.034,
        -0.043,
        -0.002,
        0.019,
        -0.017
    ]
}

Example response:

{
    "prediction": 152.34
}

19. Step 10 – Monitoring

Once the model is deployed, the application should be monitored. Important metrics include:

Request count
Request latency
Error count
CPU usage
Memory usage
Prediction statistics

Prometheus collects metrics. Grafana visualizes them.

FastAPI
   ↓
/metrics
   ↓
Prometheus
   ↓
Grafana

20. Prometheus Metrics

Install:

pip install prometheus-client

Example:

from prometheus_client import Counter, generate_latest
from fastapi.responses import Response

Create a counter:

request_counter = Counter(
    "api_requests_total",
    "Total number of API requests"
)

Increment it:

request_counter.inc()

Expose /metrics:

@app.get("/metrics")
def metrics():

    return Response(
        content=generate_latest(),
        media_type="text/plain"
    )

Prometheus can then scrape:

http://host.docker.internal:8000/metrics

21. Prometheus Configuration

Create:

prometheus.yml

global:
  scrape_interval: 5s

scrape_configs:

  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "fastapi"
    static_configs:
      - targets: ["host.docker.internal:8000"]

22. Run Prometheus with Docker

From Git Bash:

MSYS_NO_PATHCONV=1 docker run -d \
  --name prometheus \
  -p 9090:9090 \
  -v "$(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml" \
  prom/prometheus

Open:

http://localhost:9090

Check:

Status
→ Targets

You should see:

fastapi
1 / 1 up

23. Query API Metrics

In Prometheus, go to:

Graph

Run:

api_requests_total

After requesting:

http://127.0.0.1:8000/

the counter increases. For example:

api_requests_total = 5

24. Grafana

Grafana provides dashboards for visualizing Prometheus metrics. Architecture:

FastAPI
   ↓
Prometheus
   ↓
Grafana

Typical dashboard panels:

┌─────────────────────────────┐
│ Total API Requests          │
├─────────────────────────────┤
│ Request Rate                │
├─────────────────────────────┤
│ API Errors                  │
├─────────────────────────────┤
│ Request Latency             │
└─────────────────────────────┘

Prometheus:

http://localhost:9090

Grafana commonly runs at:

http://localhost:3000

25. Step 11 – Docker

Docker packages the application and its dependencies. Instead of:

Python
MLflow
FastAPI
Scikit-learn
Dependencies

being manually installed on every machine, Docker creates a reproducible environment. Example:

Dockerfile
     ↓
Docker Image
     ↓
Docker Container

Build:

docker build -t diabetes-api .

Run:

docker run -p 8000:8000 diabetes-api

26. Step 12 – Automation

An MLOps pipeline should eventually be automated. For example:

Git Push
   ↓
GitHub Actions
   ↓
Run Tests
   ↓
Build Docker Image
   ↓
Push Image
   ↓
Deploy

This removes many manual steps.

27. Complete MLOps Architecture

The complete learning architecture is:

                    ┌──────────────┐
                    │    Dataset   │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │ Data Ingest  │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │ Model Train  │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │   MLflow     │
                    │ Experiment   │
                    │  Tracking    │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │    Model     │
                    │   Registry   │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │   FastAPI    │
                    │   Serving    │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │    Docker    │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │  Prometheus  │
                    └──────┬───────┘
                           ↓
                    ┌──────────────┐
                    │   Grafana    │
                    └──────────────┘

28. Automation with Scripts

Instead of putting everything into one notebook, production pipelines usually separate responsibilities.

`train.py`

Load data
   ↓
Preprocess
   ↓
Train
   ↓
Evaluate
   ↓
MLflow
   ↓
Register model

`serve.py`

Load registered model
        ↓
FastAPI
        ↓
Prediction endpoint

`monitor.py`

Application metrics
        ↓
Prometheus

29. Example `train.py`

A simple standalone training script:

import mlflow
import mlflow.sklearn

from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score


# Load data
data = load_diabetes(as_frame=True)

df = data.frame

X = df.drop("target", axis=1)
y = df["target"]


# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)


# MLflow
mlflow.set_tracking_uri("sqlite:///mlflow.db")

mlflow.set_experiment("MLOps Demo 1")


with mlflow.start_run():

    # Train
    model = LinearRegression()

    model.fit(X_train, y_train)

    # Predict
    predictions = model.predict(X_test)

    # Metrics
    mse = mean_squared_error(
        y_test,
        predictions
    )

    rmse = mse ** 0.5

    r2 = r2_score(
        y_test,
        predictions
    )

    # Log parameters
    mlflow.log_param(
        "model",
        "LinearRegression"
    )

    mlflow.log_param(
        "test_size",
        0.2
    )

    # Log metrics
    mlflow.log_metric("mse", mse)
    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)

    # Register model
    mlflow.sklearn.log_model(
        model,
        name="diabetes_model",
        registered_model_name="DiabetesRegression"
    )

    print("Training completed")
    print(f"MSE: {mse:.4f}")
    print(f"RMSE: {rmse:.4f}")
    print(f"R2: {r2:.4f}")

Run:

python scripts/train.py

30. MLOps Pipeline Execution

The complete execution becomes:

Step 1 — Install dependencies

pip install pandas scikit-learn mlflow fastapi uvicorn prometheus-client

Step 2 — Train

python scripts/train.py

Step 3 — Start MLflow

mlflow ui --backend-store-uri sqlite:///mlflow.db --port 5000

Step 4 — Start FastAPI

uvicorn scripts.serve:app --reload

Step 5 — Start Prometheus

MSYS_NO_PATHCONV=1 docker run -d \
  --name prometheus \
  -p 9090:9090 \
  -v "$(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml" \
  prom/prometheus

Step 6 — Start Grafana

docker run -d \
  --name grafana \
  -p 3000:3000 \
  grafana/grafana

31. Important MLOps Concepts

These are important topics to understand beyond the basic pipeline:

Experiment Tracking

Track:

Parameters
Metrics
Artifacts
Models

Tool:

MLflow

Model Registry

Store and manage:

Model
Version
Stage/status
Metadata

Model Versioning

Example:

DiabetesRegression
├── v1
├── v2
└── v3

Model Serving

Expose models through:

REST API
FastAPI
Flask

Containerization

Package the application using:

Docker

Monitoring

Track:

Latency
Errors
Requests
Resource usage
Model behavior

Tools:

Prometheus
Grafana

CI/CD

Automate:

Testing
Building
Deployment

Tool:

GitHub Actions

Data Drift

A change in the distribution of input data over time.

Training Data
      ↓
   Model
      ↓
Production Data
      ↓
Distribution changes
      ↓
Data Drift

Model Drift

When model performance decreases because the relationship between inputs and target changes.

Model accuracy
     ↓
  95%
     ↓
  90%
     ↓
  82%
     ↓
Model Drift

Retraining

When drift or new data requires the model to be trained again:

New Data
   ↓
Validation
   ↓
Retraining
   ↓
Evaluation
   ↓
Register New Version
   ↓
Deploy

32. Final MLOps Lifecycle

              ┌───────────────┐
              │     DATA      │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │   INGESTION   │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │  PREPROCESS   │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │    TRAIN      │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │   EVALUATE    │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │    MLFLOW     │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │ MODEL REGISTRY│
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │    SERVE      │
              │   FastAPI     │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │    DOCKER     │
              └───────┬───────┘
                      ↓
              ┌───────────────┐
              │   MONITOR     │
              │ Prometheus    │
              │ Grafana       │
              └───────┬───────┘
                      ↓
                Detect Drift
                      ↓
                  RETRAIN
                      │
                      └──────────→ TRAIN

Key takeaway

The main idea of MLOps is:

Build
  ↓
Track
  ↓
Register
  ↓
Deploy
  ↓
Monitor
  ↓
Improve
  ↓
Retrain

For this project, the practical flow is:

Diabetes Dataset
      ↓
Python / Scikit-learn
      ↓
MLflow Tracking
      ↓
MLflow Model Registry
      ↓
FastAPI
      ↓
Docker
      ↓
Prometheus
      ↓
Grafana
      ↓
Monitoring

​1. What is MLOps?

​Why MLOps is needed

​2. Traditional ML vs MLOps

​Without MLOps

​With MLOps

​3. End-to-End MLOps Pipeline

​1. Ingest

​2. Train

​3. Serve

​4. Monitor

​4. Project Structure

​5. Technologies Used

​6. Step 1 – Data Ingestion

​Cell 1 – Imports

​Cell 2 – Load Dataset

​Cell 3 – Save Data

​7. Step 2 – Data Preparation

​8. Step 3 – Train/Test Split

​Why split the dataset?

​9. Step 4 – Model Training

​10. Step 5 – Model Evaluation

​Important metrics

​11. Step 6 – Experiment Tracking with MLflow

​12. MLflow Configuration

​Cell 4 – MLflow

​13. Step 7 – Log the Training Run

​14. Step 8 – Register the Model

​15. Viewing MLflow UI

​16. Step 9 – Model Serving

​17. Start FastAPI

​18. Test the Prediction API

​19. Step 10 – Monitoring

​20. Prometheus Metrics

​21. Prometheus Configuration

​22. Run Prometheus with Docker

​23. Query API Metrics

​24. Grafana

​25. Step 11 – Docker

​26. Step 12 – Automation

​27. Complete MLOps Architecture

​28. Automation with Scripts

​train.py

​serve.py

​monitor.py

​29. Example train.py

​30. MLOps Pipeline Execution

​Step 1 — Install dependencies

​Step 2 — Train

​Step 3 — Start MLflow

​Step 4 — Start FastAPI

​Step 5 — Start Prometheus

​Step 6 — Start Grafana

​31. Important MLOps Concepts

​Experiment Tracking

​Model Registry

​Model Versioning

​Model Serving

​Containerization

​Monitoring

​CI/CD

​Data Drift

​Model Drift

​Retraining

​32. Final MLOps Lifecycle

​Key takeaway

1. What is MLOps?

Why MLOps is needed

2. Traditional ML vs MLOps

Without MLOps

With MLOps

3. End-to-End MLOps Pipeline

1. Ingest

2. Train

3. Serve

4. Monitor

4. Project Structure

5. Technologies Used

6. Step 1 – Data Ingestion

Cell 1 – Imports

Cell 2 – Load Dataset

Cell 3 – Save Data

7. Step 2 – Data Preparation

8. Step 3 – Train/Test Split

Why split the dataset?

9. Step 4 – Model Training

10. Step 5 – Model Evaluation

Important metrics

11. Step 6 – Experiment Tracking with MLflow

12. MLflow Configuration

Cell 4 – MLflow

13. Step 7 – Log the Training Run

14. Step 8 – Register the Model

15. Viewing MLflow UI

16. Step 9 – Model Serving

17. Start FastAPI

18. Test the Prediction API

19. Step 10 – Monitoring

20. Prometheus Metrics

21. Prometheus Configuration

22. Run Prometheus with Docker

23. Query API Metrics

24. Grafana

25. Step 11 – Docker

26. Step 12 – Automation

27. Complete MLOps Architecture

28. Automation with Scripts

`train.py`

`serve.py`

`monitor.py`

29. Example `train.py`

30. MLOps Pipeline Execution

Step 1 — Install dependencies

Step 2 — Train

Step 3 — Start MLflow

Step 4 — Start FastAPI

Step 5 — Start Prometheus

Step 6 — Start Grafana

31. Important MLOps Concepts

Experiment Tracking

Model Registry

Model Versioning

Model Serving

Containerization

Monitoring

CI/CD

Data Drift

Model Drift

Retraining

32. Final MLOps Lifecycle

Key takeaway