Machine Learning Academy · Lekcja

Powtarzalne środowiska z Dockerem na potrzeby ML

Lekcja 2 z 413 kroki

Powtarzalne środowiska z Dockerem na potrzeby ML to bezpłatna lekcja Machine Learning Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Machine Learning Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.

Problem odtwarzalności w ML

Model wytrenowany na Państwa laptopie może dawać inne wyniki na komputerze współpracownika z powodu różnic w wersjach języka Python, bibliotek lub bibliotek systemowych. Docker rozwiązuje ten problem, pakując całe środowisko — język Python, biblioteki ML i skrypt treningowy — do kontenera, który działa identycznie na dowolnym komputerze. Konteneryzowane trenowanie modeli ML stanowi podstawę odtwarzalnych badań i niezawodnych potoków CI/CD.

Koncepcje Dockera: obraz, kontener i warstwa

Obraz Docker to szablon tylko do odczytu zdefiniowany w pliku Dockerfile. Składa się ze stosu warstw: każda instrukcja w pliku Dockerfile dodaje jedną warstwę. Kontener to uruchomiona instancja obrazu. Obrazy są przenośne i wersjonowane za pomocą znaczników, takich jak my-ml-image:v1.2. Najważniejszy wniosek jest taki, że ten sam znacznik obrazu zapewnia bitowo identyczne środowisko wykonawcze wszędzie — od laptopa po chmurowe instancje GPU.

# 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

Pisanie pliku Dockerfile do trenowania modeli ML

Dockerfile to plik tekstowy zawierający kolejne instrukcje wykonywane przez Dockera podczas budowania obrazu. Należy rozpocząć od oficjalnego bazowego obrazu języka Python, ustawić katalog roboczy, skopiować plik requirements.txt, zainstalować zależności, a następnie skopiować kod treningowy. Instrukcja FROM określa obraz bazowy; do trenowania na GPU należy używać bazowych obrazów NVIDIA z obsługą CUDA.

# 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).')

Blokowanie zależności w pliku requirements.txt

Odtwarzalność wymaga użycia zablokowanych wersji w pliku requirements.txt. Należy stosować specyfikatory dokładnej wersji (==) zamiast wersji minimalnych (>=). Po przetestowaniu środowiska wygeneruj kompletny plik z zablokowanymi wersjami za pomocą pip freeze > requirements.txt. W projektach ML zawsze należy zablokować wersje scikit-learn, numpy, pandas oraz używanych frameworków, ponieważ zmiany wersji, nawet niewielkie, mogą zmienić działanie modelu.

# 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

Buforowanie warstw Dockera na potrzeby szybkiej przebudowy

Docker buduje każdą instrukcję jako osobną buforowaną warstwę. Jeśli dane wejściowe warstwy nie uległy zmianie, Docker ponownie wykorzystuje warstwę z pamięci podręcznej zamiast wykonywać instrukcję od początku. Oznacza to, że umieszczenie COPY requirements.txt i RUN pip install przed COPY . . (kopiowaniem całego kodu) sprawia, że zmiana plików kodu nie powoduje czasochłonnej ponownej instalacji pakietów. Prawidłowa kolejność instrukcji w pliku Dockerfile znacznie przyspiesza iteracyjny proces tworzenia oprogramowania.

# 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.')

Obsługa GPU: obrazy Docker z CUDA

Do trenowania modeli głębokiego uczenia na GPU należy używać oficjalnych bazowych obrazów CUDA firmy NVIDIA dostępnych w Docker Hub. Obrazy te zawierają środowisko uruchomieniowe CUDA oraz biblioteki cuDNN wymagane przez PyTorch i TensorFlow. Flaga --gpus all podczas uruchamiania kontenera udostępnia kontenerowi GPU komputera hosta. Wersja CUDA w obrazie musi być zgodna ze sterownikami zainstalowanymi na komputerze hosta.

# 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.')

Przekazywanie konfiguracji za pomocą zmiennych środowiskowych

Należy unikać wpisywania hiperparametrów na stałe w skrypcie treningowym. Zamiast tego odczytuj je ze zmiennych środowiskowych za pomocą os.getenv i przekazuj je przy użyciu flag -e podczas uruchamiania kontenera. Pozwala to uruchamiać ten sam obraz z różnymi hiperparametrami bez ponownego budowania, dzięki czemu łatwo przeprowadzać przeszukiwanie hiperparametrów, zmieniając tylko polecenie uruchomienia.

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

Montowanie woluminów na potrzeby danych i wyników

Kontenery są efemeryczne — dane zapisane wewnątrz kontenera znikają po jego zatrzymaniu. Używaj montowania woluminów (flagi -v), aby podłączyć katalog hosta do kontenera. Zamontuj katalog z danymi tylko do odczytu, a katalog wyjściowy z prawem odczytu i zapisu. Dzięki temu duże zbiory danych pozostają poza obrazem (co zmniejsza jego rozmiar), a punkty kontrolne modelu i wyniki są zachowywane po zakończeniu działania kontenera.

# 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')

Budowanie wieloetapowe: smukłe obrazy produkcyjne

Obrazy treningowe zawierają kompilatory, pliki nagłówkowe i narzędzia programistyczne, które nie są potrzebne podczas wnioskowania. Budowanie wieloetapowe wykorzystuje jeden etap do skompilowania i zainstalowania wszystkiego oraz drugi, smukły etap, do którego kopiowane są wyłącznie końcowe artefakty. Może to zmniejszyć rozmiar obrazu z 4 GB do mniej niż 200 MB, przyspieszając pobieranie i zmniejszając powierzchnię ataku w środowisku produkcyjnym.

# 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.')

Uruchamianie MLflow wewnątrz Dockera

Połącz Docker i MLflow, przekazując identyfikator URI śledzenia MLflow jako zmienną środowiskową. Kontener trenuje model, rejestruje parametry i metryki na zdalnym serwerze MLflow oraz zapisuje artefakty modelu we współdzielonym magazynie. Ten wzorzec stanowi podstawę zautomatyzowanych potoków ponownego trenowania: harmonogram uruchamia kontener Docker, który trenuje, ocenia i rejestruje nową wersję modelu bez ręcznej ingerencji.

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)

Przesyłanie obrazów do rejestru

Aby udostępniać obrazy Docker zespołowi lub wdrażać je w infrastrukturze chmurowej, należy przesyłać je do rejestru kontenerów. Docker Hub jest rejestrem publicznym, a AWS ECR, Google GCR i Azure ACR to popularne prywatne rozwiązania alternatywne. Oznacz obraz adresem URL rejestru i nazwą obrazu, a następnie prześlij go. Potoki CI/CD zazwyczaj budują nowy obraz przy każdym zatwierdzeniu i przesyłają go ze skrótem zatwierdzenia jako znacznikiem, zapewniając pełną identyfikowalność.

# 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.')

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat koncepcji uczenia maszynowego w języku Python omówionych w tej lekcji.

Odpowiedz w interaktywnej lekcji

Podsumowanie lekcji

W tej lekcji nauczyłeś się, że: kontenery Docker pakują całe środowisko języka Python, zapewniając identyczne wyniki trenowania na dowolnym komputerze, buforowanie warstw przyspiesza budowanie, gdy instalowanie zależności umieści się przed kopiowaniem kodu, a montowanie woluminów przechowuje duże zbiory danych poza obrazem i zachowuje wyniki po zakończeniu działania kontenera. W następnej części poznamy MLflow Model Registry, który służy do promowania modeli przez etapy cyklu życia: testowy i produkcyjny.

Bezpłatny start

Ucz się Python dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 30
Lekcje: 120

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Powtarzalne środowiska z Dockerem na potrzeby ML” jest bezpłatna?

Tak — pełny tekst „Powtarzalne środowiska z Dockerem na potrzeby ML” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Machine Learning Academy, przejdź na CoddyKit PRO. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Powtarzalne środowiska z Dockerem na potrzeby ML”?

Uczą się Państwo pisać Dockerfile instalujący Pythona i przypięte wersje bibliotek ML oraz kopiujący skrypt trenowania, a następnie budować i uruchamiać kontener, aby potwierdzić powtarzalność bit po… Ćwiczysz Machine Learning Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Machine Learning Academy?

Nie wymagamy żadnego doświadczenia. Machine Learning Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Powtarzalne środowiska z Dockerem na potrzeby ML”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Machine Learning Academy?

Tak. Każda lekcja Machine Learning Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Śledzenie eksperymentów za pomocą MLflow: parametry, metryki i artefakty
Powtarzalne środowiska z Dockerem na potrzeby ML
Rejestr modeli: staging, produkcja i archiwizacja
Automatyczne pipeline'y ponownego trenowania z GitHub Actions

← Powrót do Machine Learning Academy