Docker pentru IA

Datorită containerelor, expresia „funcționează pe calculatorul meu” devine de domeniul trecutului.

Tip: Construire Limbaje: Docker Cerințe preliminare: Faza 0, lecțiile 01 și 03 Durată: ~60 de minute

Obiective de învățare

• Construirea, pe baza unui Dockerfile, a unei imagini Docker cu suport pentru GPU, care include CUDA, PyTorch și biblioteci pentru IA
• Montarea directoarelor de pe sistemul-gazdă ca volume, pentru a păstra modelele, seturile de date și codul între reconstruirile containerului
• Configurarea NVIDIA Container Toolkit pentru a expune GPU-urile în interiorul containerelor
• Orchestrarea aplicațiilor IA cu mai multe servicii (server de inferență + bază de date vectorială) folosind Docker Compose

Problema

Ați antrenat un model pe laptop cu PyTorch 2.3, CUDA 12.4 și Python 3.12. Colegul dumneavoastră are PyTorch 2.1, CUDA 11.8 și Python 3.10. Modelul se blochează pe calculatorul său. Dockerfile-ul dumneavoastră funcționează pe ambele calculatoare.

Gestionarea dependențelor în proiectele de IA poate deveni un coșmar. O stivă obișnuită include Python, PyTorch, drivere CUDA, cuDNN, biblioteci C de sistem și pachete specializate precum flash-attn, care necesită versiuni exacte ale compilatorului. Docker împachetează toate aceste componente într-o singură imagine, care rulează identic peste tot.

Conceptul

Docker reunește codul, mediul de execuție, bibliotecile și instrumentele de sistem într-o unitate izolată numită container. Gândiți-vă la acesta ca la o mașină virtuală ușoară; spre deosebire de o mașină virtuală obișnuită, containerul partajează nucleul sistemului de operare al gazdei în loc să ruleze propriul nucleu, astfel încât pornește în câteva secunde, nu în câteva minute.

De ce proiectele de IA au nevoie de Docker mai mult decât majoritatea proiectelor

1. Driverele GPU sunt sensibile la versiuni. Codul pentru CUDA 12.4 nu rulează pe CUDA 11.8. Docker izolează setul de instrumente CUDA în interiorul containerului și, prin NVIDIA Container Toolkit, partajează cu acesta driverul GPU al sistemului-gazdă.

2. Ponderile modelelor sunt voluminoase. Un model cu 7 miliarde de parametri ocupă 14 GB în fp16. Nu este de dorit să îl descărcați din nou la fiecare reconstruire. Volumele Docker vă permit să montați un director cu modele de pe sistemul-gazdă.

3. Arhitecturile cu mai multe servicii sunt frecvente. O aplicație IA reală nu este doar un script Python. Ea include un server de inferență, o bază de date vectorială pentru RAG și, eventual, o interfață web. Docker Compose orchestrează toate aceste componente printr-o singură comandă.

Vocabular esențial

Termen	Ce înseamnă
Imagine	Un șablon doar în citire. Rețeta dumneavoastră. Este construită dintr-un Dockerfile.
Container	O instanță în execuție a unei imagini. Bucătăria dumneavoastră.
Dockerfile	Instrucțiuni pentru construirea unei imagini, strat cu strat.
Volum	Spațiu de stocare persistent, care supraviețuiește repornirilor containerului.
docker-compose	Un instrument pentru definirea în YAML a aplicațiilor cu mai multe containere.

Modele uzuale de utilizare a containerelor în IA

Container de dezvoltare
  Set complet de instrumente. Integrare cu editorul. Jupyter. Instrumente de depanare.
  Utilizat în timpul dezvoltării și experimentării.

Container de antrenare
  Minimal. Conține doar scriptul de antrenare și dependențele.
  Rulează pe clustere GPU. Fără editor, fără Jupyter.

Container de inferență
  Optimizat pentru servirea modelelor. Imagine mică. Pornire la rece rapidă.
  Rulează în producție în spatele unui echilibrator de sarcină (load balancer).

Construirea soluției

Pasul 1: Instalați Docker

# macOS
brew install --cask docker
open /Applications/Docker.app

# Ubuntu
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# Log out and back in for group change to take effect

Verificați instalarea:

docker --version
docker run hello-world

Pasul 2: Instalați NVIDIA Container Toolkit (Linux cu GPU NVIDIA)

Acest instrument le permite containerelor Docker să acceseze GPU-ul. Utilizatorii de macOS și Windows (WSL2) pot omite acest pas; Docker Desktop gestionează diferit accesul containerelor la GPU pe aceste platforme.

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Testați accesul la GPU din interiorul unui container:

docker run --rm --gpus all nvidia/cuda:12.4.1-base-ubuntu22.04 nvidia-smi

Dacă sunt afișate informațiile despre GPU, setul de instrumente funcționează.

Pasul 3: Înțelegeți imaginile de bază

Alegerea imaginii de bază potrivite vă scutește de ore întregi de depanare.

nvidia/cuda:12.4.1-devel-ubuntu22.04
  Set complet de instrumente CUDA. Include compilatoare.
  Utilizare: construirea pachetelor care necesită nvcc (flash-attn, bitsandbytes)
  Dimensiune: ~4 GB

nvidia/cuda:12.4.1-runtime-ubuntu22.04
  Numai mediul de execuție CUDA. Fără compilatoare.
  Utilizare: rularea codului precompilat
  Dimensiune: ~1,5 GB

pytorch/pytorch:2.3.1-cuda12.4-cudnn9-runtime
  PyTorch preinstalat peste CUDA.
  Utilizare: omiterea pasului de instalare a PyTorch
  Dimensiune: ~6 GB

python:3.12-slim
  Fără CUDA. Numai CPU.
  Utilizare: inferență pe CPU, instrumente ușoare
  Dimensiune: ~150 MB

Pasul 4: Scrieți un Dockerfile pentru dezvoltarea aplicațiilor IA

Mai jos este Dockerfile-ul din code/Dockerfile. Să îl parcurgem:

FROM nvidia/cuda:12.4.1-devel-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

RUN apt-get update && apt-get install -y --no-install-recommends \
    python3.12 \
    python3.12-venv \
    python3.12-dev \
    python3-pip \
    git \
    curl \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.12 1

RUN python -m pip install --no-cache-dir --upgrade pip setuptools wheel

RUN python -m pip install --no-cache-dir \
    torch==2.3.1 \
    torchvision==0.18.1 \
    torchaudio==2.3.1 \
    --index-url https://download.pytorch.org/whl/cu124

RUN python -m pip install --no-cache-dir \
    numpy \
    pandas \
    scikit-learn \
    matplotlib \
    jupyter \
    transformers \
    datasets \
    accelerate \
    safetensors

WORKDIR /workspace

VOLUME ["/workspace", "/models"]

EXPOSE 8888

CMD ["python"]

Construiți imaginea:

docker build -t ai-dev -f phases/00-setup-and-tooling/07-docker-for-ai/code/Dockerfile .

Prima construire durează ceva timp, deoarece sunt descărcate imaginea de bază CUDA și PyTorch. Construirile ulterioare folosesc straturile din cache.

Rulați imaginea:

docker run --rm -it --gpus all \
    -v $(pwd):/workspace \
    -v ~/models:/models \
    ai-dev python -c "import torch; print(f'PyTorch {torch.__version__}, CUDA: {torch.cuda.is_available()}')"

Rulați Jupyter în interiorul containerului:

docker run --rm -it --gpus all \
    -v $(pwd):/workspace \
    -v ~/models:/models \
    -p 8888:8888 \
    ai-dev jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root

Pasul 5: Montarea volumelor pentru date și modele

Montarea volumelor este esențială pentru activitatea din domeniul IA. Fără volume, modelele de 14 GB pe care le-ați descărcat dispar atunci când containerul se oprește.

# Mount your code
-v $(pwd):/workspace

# Mount a shared models directory
-v ~/models:/models

# Mount datasets
-v ~/datasets:/data

În scriptul de antrenare, încărcați modelul din calea montată:

from transformers import AutoModel

model = AutoModel.from_pretrained("/models/llama-7b")

Modelul se află în sistemul de fișiere al gazdei. Puteți reconstrui containerul ori de câte ori doriți, fără să descărcați din nou modelul.

Pasul 6: Docker Compose pentru aplicații IA cu mai multe servicii

O aplicație RAG reală necesită un server de inferență și o bază de date vectorială. Docker Compose le rulează pe ambele printr-o singură comandă.

Consultați code/docker-compose.yml:

services:
  ai-dev:
    build:
      context: .
      dockerfile: Dockerfile
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    volumes:
      - ../../../:/workspace
      - ~/models:/models
      - ~/datasets:/data
    ports:
      - "8888:8888"
    stdin_open: true
    tty: true
    command: jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root

  qdrant:
    image: qdrant/qdrant:v1.12.5
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - qdrant_data:/qdrant/storage

volumes:
  qdrant_data:

Porniți toate serviciile:

cd phases/00-setup-and-tooling/07-docker-for-ai/code
docker compose up -d

Acum, containerul de dezvoltare IA poate accesa baza de date vectorială la adresa http://qdrant:6333, folosind numele serviciului. Docker Compose creează automat o rețea partajată.

Testați conexiunea din interiorul containerului IA:

from qdrant_client import QdrantClient

client = QdrantClient(host="qdrant", port=6333)
print(client.get_collections())

Opriți toate serviciile:

docker compose down

Adăugați opțiunea -v pentru a șterge și volumul Qdrant:

docker compose down -v

Pasul 7: Comenzi Docker utile pentru activitatea din domeniul IA

# List running containers
docker ps

# List all images and their sizes
docker images

# Remove unused images (reclaim disk space)
docker system prune -a

# Check GPU usage inside a running container
docker exec -it <container_id> nvidia-smi

# Copy a file from container to host
docker cp <container_id>:/workspace/results.csv ./results.csv

# View container logs
docker logs -f <container_id>

Utilizarea soluției

Acum aveți un mediu reproductibil pentru dezvoltarea aplicațiilor IA. Pentru restul acestui curs:

• Utilizați docker compose up pentru a porni împreună mediul de dezvoltare și baza de date vectorială
• Montați codul, modelele și datele ca volume, astfel încât nimic să nu se piardă între reconstruiri
• Când o lecție necesită un pachet Python nou, adăugați-l în Dockerfile și reconstruiți imaginea
• Partajați Dockerfile-ul cu membrii echipei. Aceștia vor obține exact același mediu.

Nu aveți GPU?

Eliminați opțiunea --gpus all și blocul NVIDIA deploy. Containerul funcționează în continuare pentru lecțiile bazate pe CPU. PyTorch detectează automat absența CUDA și trece la CPU.

Exerciții

1. Construiți imaginea din Dockerfile și rulați python -c "import torch; print(torch.__version__)" în interiorul containerului
2. Porniți stiva docker-compose și verificați dacă Qdrant este accesibil din containerul IA la adresa http://qdrant:6333/collections
3. Adăugați flask în Dockerfile, reconstruiți imaginea și rulați un server API simplu pe portul 5000. Mapați portul cu -p 5000:5000
4. Măsurați dimensiunea imaginii cu docker images. Încercați să înlocuiți imaginea de bază devel cu runtime și comparați dimensiunile

Termeni-cheie

Termen	Formulare uzuală	Ce înseamnă de fapt
Container	„Mașină virtuală ușoară”	Un proces izolat care utilizează nucleul sistemului-gazdă și are propriul sistem de fișiere și propria rețea
Strat al imaginii	„Pas memorat în cache”	Fiecare instrucțiune din Dockerfile creează un strat. Straturile neschimbate sunt păstrate în cache, astfel încât reconstruirile sunt rapide.
NVIDIA Container Toolkit	„GPU în Docker”	Un mecanism al mediului de execuție care expune GPU-urile gazdei către containere prin opțiunea --gpus
Montarea unui volum	„Director partajat”	Un director de pe gazdă mapat în container. Modificările persistă după oprirea containerului.
Imagine de bază	„Punct de pornire”	Imaginea specificată prin FROM, peste care Dockerfile-ul adaugă propriile straturi. Aceasta determină componentele preinstalate.

---

Sursă: Docker for AI — original Navigare: înapoi: 00.06 — Medii Python · Faza 0 — Configurare și instrumente · Catalog complet · înainte: 00.08 — Configurarea editorului.