Docker for ML workloads in MLOps - Step-by-Step Execution

Process Flow - Docker for ML workloads

Write Dockerfile

↓

Build Docker Image

↓

Run Container with ML Code

↓

Container Executes ML Task

↓

Output Results / Logs

↓

Stop Container / Save Model

This flow shows how you create a Docker image for ML, run it as a container to execute ML tasks, and then get results or save models.

Execution Sample

MLOps

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

This Dockerfile sets up a Python environment, installs ML dependencies, copies code, and runs training.

Process Table

Step	Action	Details	Result
1	Read Dockerfile	FROM python:3.12-slim	Base image set to Python 3.12 slim
2	Set working directory	WORKDIR /app	Working directory inside container is /app
3	Copy requirements.txt	COPY requirements.txt ./	requirements.txt copied to /app
4	Install dependencies	RUN pip install -r requirements.txt	Python packages installed
5	Copy source code	COPY . ./	All local files copied to /app
6	Set command	CMD ["python", "train.py"]	Container will run train.py on start
7	Build image	docker build -t ml-train .	Docker image 'ml-train' created
8	Run container	docker run ml-train	Container starts and runs training script
9	Training executes	train.py runs ML training	Model trains and outputs logs
10	Container stops	Training completes	Container exits after job done

💡 Training script finishes, container stops automatically

Status Tracker

Variable	Start	After Step 4	After Step 8	Final
Docker Image	None	Created with Python and dependencies	Used to start container	Image remains for reuse
Container State	Not running	Not running	Running training script	Stopped after training
Model Output	None	None	Being generated	Saved or logged after training

Key Moments - 3 Insights

Why do we copy requirements.txt and run pip install before copying all code?

Because installing dependencies first uses Docker cache efficiently, so if code changes but dependencies don't, Docker skips reinstalling packages (see execution_table steps 3 and 4).

What happens when the container finishes running the training script?

The container stops automatically after the CMD command completes (see execution_table step 10). You must save outputs outside the container if needed.

Why use a slim Python base image?

A slim image is smaller and faster to download, making builds and deployments quicker without unnecessary files (see execution_table step 1).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the Docker image created?

A Step 9

B Step 4

C Step 7

D Step 2

💡 Hint

Check the 'Result' column for the step mentioning 'Docker image created'

At which step does the container start running the ML training script?

A Step 6

B Step 8

C Step 10

D Step 3

💡 Hint

Look for the step where the container 'starts and runs training script'

If you change only the source code but not requirements.txt, which step's action can Docker skip during rebuild?

A Install dependencies

B Copy source code

C Copy requirements.txt

D Set working directory

💡 Hint

Refer to key moment about Docker cache and execution_table steps 3 and 4

Concept Snapshot

Docker for ML workloads:
- Write Dockerfile with base Python image
- Copy requirements.txt and install dependencies first
- Copy ML code and set CMD to run training
- Build image with 'docker build'
- Run container with 'docker run' to execute ML task
- Container stops when training finishes
- Save outputs outside container if needed

Full Transcript

This visual execution shows how Docker helps run machine learning workloads. First, you write a Dockerfile starting from a Python base image. Then you copy the requirements.txt file and install dependencies to use Docker's cache efficiently. Next, you copy your ML code and set the command to run your training script. You build the Docker image, which packages everything needed. Running the container starts the training script inside an isolated environment. When training finishes, the container stops automatically. To keep your model or logs, save them outside the container. This process makes ML workloads portable and consistent across machines.