Machine Learning Academy · Ders

Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak

Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak, CoddyKit'te ücretsiz bir Machine Learning Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Machine Learning Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Machine Learning Academy kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

The Reproducibility Problem in ML

A model trained on your laptop may produce different results on a colleague's machine because of different Python versions, library versions, or system libraries. Docker solves this by packaging your entire environment — Python, ML libraries, and your training script — into a container that runs identically on any machine. Containerised ML training is the foundation of reproducible research and reliable CI/CD pipelines.

Docker Concepts: Image, Container, Layer

A Docker image is a read-only template defined by a Dockerfile. It consists of stacked layers: each instruction in the Dockerfile adds a layer. A container is a running instance of an image. Images are portable and versioned via tags like my-ml-image:v1.2. The key insight is that the same image tag produces bitwise-identical runtime environments everywhere, from your laptop to cloud GPU instances.

# Basic Docker commands for ML workflows

# Build an image from Dockerfile in current directory
# docker build -t my-ml-trainer:v1 .

# Run a training script inside the container
# docker run --rm --gpus all my-ml-trainer:v1 python train.py

# List running containers
# docker ps

# Inspect image layers (shows what changed at each step)
# docker history my-ml-trainer:v1

Writing a Dockerfile for ML Training

A Dockerfile is a text file with sequential instructions that Docker executes to build an image. Start from an official Python base image, set the working directory, copy a requirements.txt, install dependencies, then copy your training code. The FROM instruction specifies the base image; for GPU training use NVIDIA's CUDA-enabled base images.

# Dockerfile
# FROM python:3.11-slim
#
# WORKDIR /app
#
# # Copy and install dependencies first (layer caching)
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
#
# # Copy training code
# COPY train.py .
# COPY data/ data/
#
# # Default command
# CMD ['python', 'train.py']

print('Dockerfile structure shown above (Python comment).')

Pinning Dependencies in requirements.txt

Reproducibility requires pinned versions in requirements.txt. Use exact version specifiers (==) rather than minimum versions (>=). Generate a complete pinned requirements file with pip freeze > requirements.txt after testing your environment. For ML projects, always pin scikit-learn, numpy, pandas, and any framework versions, as minor version changes can alter model behaviour.

# requirements.txt (pinned versions for reproducibility)
# scikit-learn==1.4.2
# numpy==1.26.4
# pandas==2.2.1
# matplotlib==3.8.4
# mlflow==2.13.0
# torch==2.3.0
# transformers==4.40.2
# xgboost==2.0.3
# lightgbm==4.3.0
# imbalanced-learn==0.12.2
# joblib==1.4.2

# Generate from your current environment:
# pip freeze > requirements.txt

Docker Layer Caching for Fast Rebuilds

Docker builds each instruction as a separate cached layer. If a layer's inputs have not changed, Docker reuses the cached layer instead of re-executing the instruction. This means that placing COPY requirements.txt and RUN pip install before COPY . . (copying all code) ensures that changing code files does not trigger a slow re-installation of packages. Good Dockerfile order dramatically speeds up iterative development.

# Optimised Dockerfile layer order
# FROM python:3.11-slim
#
# WORKDIR /app
#
# # Step 1: Install system packages (rarely changes)
# RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
#
# # Step 2: Install Python deps (changes only when requirements.txt changes)
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
#
# # Step 3: Copy code (changes most often -- put last)
# COPY . .
#
# CMD ['python', 'train.py']

print('Layer order shown above.')

GPU Support: CUDA Docker Images

For training deep learning models on GPU, use NVIDIA's official CUDA base images from Docker Hub. These images include the CUDA runtime and cuDNN libraries required by PyTorch and TensorFlow. The --gpus all flag when running the container exposes the host GPU to the container. The CUDA version in the image must match the drivers installed on the host machine.

# Dockerfile for GPU training with PyTorch
# FROM nvidia/cuda:12.1-cudnn8-runtime-ubuntu22.04
#
# # Install Python
# RUN apt-get update && apt-get install -y python3.11 python3-pip
# RUN ln -s /usr/bin/python3.11 /usr/bin/python
#
# WORKDIR /app
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
# COPY train.py .
#
# CMD ['python', 'train.py']

# Run with GPU:
# docker run --rm --gpus all my-gpu-trainer:v1
print('GPU Dockerfile structure shown above.')

Passing Configuration via Environment Variables

Avoid hard-coding hyperparameters in your training script. Instead, read them from environment variables with os.getenv and pass them via -e flags at container run time. This lets you launch the same image with different hyperparameters without rebuilding, making it easy to run hyperparameter sweeps by simply changing the run command.

import os

# In train.py -- read config from environment variables
LEARNING_RATE = float(os.getenv('LEARNING_RATE', '0.001'))
N_ESTIMATORS = int(os.getenv('N_ESTIMATORS', '100'))
MAX_DEPTH = int(os.getenv('MAX_DEPTH', '5'))
OUTPUT_DIR = os.getenv('OUTPUT_DIR', '/app/outputs')

print(f'Training with lr={LEARNING_RATE}, n={N_ESTIMATORS}, depth={MAX_DEPTH}')

# Run with custom config:
# docker run -e LEARNING_RATE=0.01 -e N_ESTIMATORS=200 my-ml-trainer:v1

Mounting Volumes for Data and Outputs

Containers are ephemeral — data written inside a container disappears when it stops. Use volume mounts (-v flag) to bind a host directory into the container. Mount your data directory read-only and an output directory read-write. This keeps large datasets outside the image (reducing image size) and ensures model checkpoints and results persist after the container exits.

# Mount host data/ and outputs/ into container
# docker run --rm \
#   -v /host/path/data:/app/data:ro \
#   -v /host/path/outputs:/app/outputs \
#   -e N_ESTIMATORS=200 \
#   my-ml-trainer:v1

# In train.py, read from /app/data and write to /app/outputs
import os

data_dir = '/app/data'
output_dir = '/app/outputs'
os.makedirs(output_dir, exist_ok=True)

print('Data dir:', os.listdir(data_dir) if os.path.exists(data_dir) else 'not mounted')

Multi-Stage Builds: Slim Production Images

Training images include compilers, header files, and dev tools that are unnecessary for inference. Multi-stage builds use one stage to compile/install everything and a second slim stage that copies only the final artifacts. This can reduce image size from 4 GB to under 200 MB, speeding up pulls and reducing the attack surface in production.

# Multi-stage Dockerfile
# --- Stage 1: Build ---
# FROM python:3.11 AS builder
# WORKDIR /app
# COPY requirements.txt .
# RUN pip install --no-cache-dir --user -r requirements.txt
#
# --- Stage 2: Runtime ---
# FROM python:3.11-slim
# WORKDIR /app
# COPY --from=builder /root/.local /root/.local
# COPY serve.py .
# COPY model/ model/
# ENV PATH=/root/.local/bin:$PATH
#
# CMD ['python', 'serve.py']

print('Multi-stage Dockerfile shown above.')

Running MLflow Inside Docker

Combine Docker and MLflow by passing the MLflow tracking URI as an environment variable. The container trains the model, logs parameters and metrics to the remote MLflow server, and saves model artifacts to shared storage. This pattern is the building block of automated retraining pipelines: a scheduler triggers a Docker container that trains, evaluates, and registers a new model version without any manual intervention.

import os
import mlflow
from sklearn.ensemble import RandomForestClassifier

# Read from environment (set by docker run -e)
MLFLOW_URI = os.getenv('MLFLOW_TRACKING_URI', 'http://localhost:5000')
mlflow.set_tracking_uri(MLFLOW_URI)
mlflow.set_experiment('docker_training')

with mlflow.start_run():
    n_est = int(os.getenv('N_ESTIMATORS', '100'))
    mlflow.log_param('n_estimators', n_est)

    clf = RandomForestClassifier(n_estimators=n_est, random_state=42)
    # clf.fit(X_train, y_train)  -- assume data is mounted
    # acc = accuracy_score(y_test, clf.predict(X_test))
    # mlflow.log_metric('accuracy', acc)
    # mlflow.sklearn.log_model(clf, 'model')
    print('Logged to:', MLFLOW_URI)

Pushing Images to a Registry

To share Docker images with your team or deploy them to cloud infrastructure, push them to a container registry. Docker Hub is the public registry; AWS ECR, Google GCR, and Azure ACR are popular private alternatives. Tag your image with the registry URL and your image name, then push. CI/CD pipelines typically build a new image on every commit and push it with the commit SHA as the tag for full traceability.

# Tag and push to Docker Hub
# docker tag my-ml-trainer:v1 yourusername/my-ml-trainer:v1
# docker push yourusername/my-ml-trainer:v1

# Tag and push to AWS ECR
# aws ecr get-login-password --region eu-west-1 | \
#   docker login --username AWS --password-stdin 123456789.dkr.ecr.eu-west-1.amazonaws.com
# docker tag my-ml-trainer:v1 123456789.dkr.ecr.eu-west-1.amazonaws.com/my-ml-trainer:v1
# docker push 123456789.dkr.ecr.eu-west-1.amazonaws.com/my-ml-trainer:v1

print('Registry push commands shown above.')

Quick Check

Test your understanding of Machine Learning with Python concepts from this lesson.

Lesson Recap

In this lesson you learned: Docker containers package the entire Python environment ensuring identical training results on any machine, layer caching makes builds fast by placing requirements installation before code copies, and volume mounts keep large datasets outside the image and persist outputs after the container exits. Next up we explore the MLflow Model Registry for promoting models through staging and production lifecycle stages.

Sıkça Sorulan Sorular

“Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak” dersi ücretsiz mi?

Evet — “Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Machine Learning Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Machine Learning Academy kursu toplamda 4 dersten oluşur.

“Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak” dersinde ne öğreneceğim?

Kursiyerler Python'u ve sürümleri sabitlenmiş makine öğrenimi kütüphanelerini kuran, ardından bir eğitim betiğini kopyalayan bir Dockerfile yazacak; bit düzeyinde tekrarlanabilirliği doğrulamak için… Machine Learning Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Machine Learning Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Machine Learning Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Machine Learning Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Machine Learning Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

MLflow ile Deney Takibi: Parametreleri, Ölçütleri ve Yapıtları Günlüğe Kaydetme
Makine Öğrenimi İçin Docker ile Tekrarlanabilir Ortamlar Oluşturmak
Model Kayıt Defteri: Hazırlama, Üretim ve Arşivleme
GitHub Actions ile Otomatik Yeniden Eğitim İşlem Hatları

← Machine Learning Academy Sayfasına Dön