Optimizarea Ubuntu pentru antrenarea LLM-urilor

Configurare noua (How To)

Situatie

Solutie

Distribuție: recomandat Ubuntu LTS (22.04 sau 24.04).
Kernel: începe cu linux-generic (HWE pe 22.04); treci la oem/lowlatency doar dacă ai motiv clar (latențe audio sau driver-e specifice).
Sistem de fișiere:

  • XFS pe SSD/NVMe pentru seturi mari de fișiere; ext4 dacă vrei simplitate + compat.
  • Montează dataset-urile cu noatime și, dacă e doar citire, ro.
  • Rulează fstrim.timer pentru NVMe.
sudo apt update && sudo apt -y full-upgrade
sudo apt install -y build-essential cmake git htop nvme-cli numactl lsb-release gnupg p7zip-full zip unzip
sudo systemctl enable fstrim.timer --now

NVMe I/O scheduler: (pe kerneluri moderne, none e OK pentru NVMe)

echo none | sudo tee /sys/block/nvme0n1/queue/scheduler

BIOS/UEFI & hardware housekeeping

  • Activează Resizable BAR/Above 4G Decoding pentru PCIe.
  • Setează NUMA corect (pe dual‑socket, leagă GPU-urile de CPU-ul apropiat).
  • Dezactivează C‑states profunde dacă urmărești latență minimă; păstrează Turbo Boost activ.
  • Actualizează firmware-ul placii de bază/NVMe.
  • Pentru GPU enterprise: ECC ON (stabilitate>viteză).

Driver & runtime GPU

NVIDIA (CUDA)

# Driver recomandat (metapachet):
sudo ubuntu-drivers autoinstall
# sau alege o versiune: nvidia-driver-550 / 560 (exemplu)

# NVIDIA Container Toolkit (pentru Docker):
# 1) repo
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit.gpg
curl -fsSL https://nvidia.github.io/libnvidia-container/ubuntu$(. /etc/os-release; echo $VERSION_ID)/libnvidia-container.list \
 | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit.gpg] https://#' \
 | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt update && sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# sanity check
nvidia-smi

AMD (ROCm)

  • Folosește ROCm din repo-urile oficiale pentru versiunea ta de Ubuntu.
  • Verifică suportul pentru GPU-ul tău (ex: MI, RX 7000).
  • Pe PyTorch/Transformers, verifică matricea versiuni ROCm⇄Torch.

Python stack: reproducibilitate fără dureri

Opțiunea A: Conda/Mamba

# Mamba este mult mai rapid
curl -L https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj bin/micromamba
./bin/micromamba shell init -s bash -p ~/micromamba
source ~/.bashrc
micromamba create -y -n llm python=3.11
micromamba activate llm

# Instalează PyTorch potrivit GPU-ului tău (alege rocm/cuda/no-cuda)
pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu*   # sau rocm* / cpu

# Restul ecosistemului
pip install transformers datasets accelerate bitsandbytes deepspeed flash-attn xformers

Opțiunea B: venv + pip

python3 -m venv ~/.venvs/llm
source ~/.venvs/llm/bin/activate
pip install --upgrade pip wheel
# apoi pachetele ca mai sus

Sfaturi:

  • Păstrează un fișier env.lock cu versiunile exacte (pip freeze > env.lock).
  • Evită mixul apt Python packages ⇄ pip.
  • Pentru build-uri native, ai nevoie de gcc, g++, ninja, cmake.

Containere: izolare și portabilitate

sudo apt install -y docker.io
sudo usermod -aG docker $USER
# logout/login

# Rulează un container CUDA
docker run --gpus all --rm nvidia/cuda:12.4.1-runtime-ubuntu22.04 nvidia-smi

# Imagine minimală pentru PyTorch
cat > Dockerfile <<'EOF'
FROM nvidia/cuda:12.4.1-devel-ubuntu22.04
RUN apt-get update && apt-get install -y python3 python3-pip git && rm -rf /var/lib/apt/lists/*
RUN pip3 install --upgrade pip
RUN pip3 install torch --index-url https://download.pytorch.org/whl/cu124
RUN pip3 install transformers datasets accelerate
WORKDIR /workspace
EOF

docker build -t llm-cuda:base .

Tips: montează dataset-urile cu -v /data:/data:ro, pune cache-ul HF în /data/.cache/huggingface (persistență).

Tuning de sistem (CPU, memorie, I/O)

Guvernor CPU & frecvențe

sudo apt install -y cpufrequtils
cat | sudo tee /etc/default/cpufrequtils <<EOF
GOVERNOR="performance"
EOF
sudo systemctl disable --now ondemand || true
sudo systemctl enable --now cpufrequtils

Memory & swap

# Swappiness mic, dar NU elimina complet swap-ul (ajută la evitarea OOM)
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.d/99-llm.conf
# THP: "madvise" e un compromis bun pentru workload ML
echo 'never' | sudo tee /sys/kernel/mm/transparent_hugepage/defrag
sudo bash -c 'echo always > /sys/kernel/mm/transparent_hugepage/enabled'  # sau "madvise", testează

sudo sysctl --system

I/O pe NVMe

# Crește read-ahead pe volumele cu dataset-uri secvențiale
sudo blockdev --setra 4096 /dev/nvme0n1

NUMA & afinități (multi‑socket / multi‑GPU)

  • Inspectează topologia:
nvidia-smi topo -m
numactl --hardware
  • Leagă procesul de CPU-ul „aproape” de GPU:
numactl --cpunodebind=0 --membind=0 python train.py
  • Pentru multi‑GPU, setează CUDA_VISIBLE_DEVICES și folosește DistributedDataParallel.

Rețea și inter‑GPU (NCCL/UCX)

  • Instalează drivere pentru Infiniband/RoCE dacă ai interconect rapid.
  • Variabile utile NCCL (testează, nu există „one‑size‑fits‑all”):
export NCCL_DEBUG=INFO
export NCCL_IB_HCA=mlx5
export NCCL_SOCKET_NTHREADS=4
export NCCL_NSOCKS_PERTHREAD=2
export NCCL_MIN_NRINGS=4
# Dacă ai NIC-uri multiple:
export NCCL_IB_GID_INDEX=3
  • Pentru multi‑nod: sincronizează ceasurile cu chrony, configurează passwordless SSH, DNS/hosts stabil.

Power & răcire (stabilitatea > 1–2% performanță)

# Persistență driver & limite de putere (datacenter GPUs)
sudo nvidia-smi -pm 1
sudo nvidia-smi -pl 300            # adaptează la model
# Monitorizare live
nvidia-smi dmon -s pucvmet
  • Asigură airflow bun; curăță filtrele; urmărește temperaturi < 80–83°C.

Securitate & acces remote

sudo apt install -y ufw fail2ban openssh-server
sudo ufw allow OpenSSH
sudo ufw enable
sudo systemctl enable --now fail2ban
  • Creează un user dedicat pentru training, fără sudo.
  • Chei SSH, dezactivează loginul cu parolă.
  • Activează actualizări de securitate:
sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure --priority=low unattended-upgrades

Cache & date: Hugging Face, şantiere curate

# Mută cache-ul pe volum rapid
export HF_HOME=/data/.cache/huggingface
export TRANSFORMERS_CACHE=$HF_HOME/transformers
export HF_DATASETS_CACHE=$HF_HOME/datasets
  • Folosește dataset streaming când e posibil; comprimă cu zstd.

GPUDirect Storage (avansat)

  • Pe NVIDIA, GDS poate reduce latența I/O: necesită kernel/driver compatibil și nvidia-fs.
  • Testează cu gdscheck și profilări I/O reale; beneficii apar la citiri masive secvențiale.

Tooling pentru monitorizare & profilare

  • CLI: nvtop, nvitop, iostat, dstat, iotop, perf, py-spy.
  • SDK: NVML/DCGM, PyTorch Profiler.
  • Exporteri Prometheus: node_exporter, dcgm-exporter + Grafana.

Rețete de antrenare eficiente (PyTorch + Accelerate)

DDP + gradient checkpointing + mixed precision

# train.py (schematic)
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
import torch

model_id = "gpt2"  # exemplu
model = AutoModelForCausalLM.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)

model.gradient_checkpointing_enable()

args = TrainingArguments(
    output_dir="out",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    fp16=True,                     # sau bf16 pe Ada/Hopper
    optim="adamw_torch",
    lr_scheduler_type="cosine",
    warmup_steps=200,
    logging_steps=10,
    save_steps=2000,
    ddp_find_unused_parameters=False,
)

# tokenizer.pad_token = tokenizer.eos_token (dacă e nevoie)

# ... Dataset & Trainer ...

Lansare multi‑GPU

accelerate config default
accelerate launch --multi_gpu --num_processes=4 train.py

Tips LLM:

  • bf16 > fp16 pe Ada/Hopper; flash-attn pentru atenție rapidă.
  • checkpoint‑uri locale (evită NFS lent).
  • Gradient checkpointing + ZeRO (DeepSpeed) pentru modele mari.
  • Paged optimizers (bitsandbytes) pentru mem eficientă.

Automatizare, job control & reziliență

  • tmux/screen pentru sesiuni persistente.
  • systemd service pentru job-uri lungi:
# /etc/systemd/system/llm-train.service
[Unit]
Description=LLM Training
After=network.target docker.service

[Service]
User=trainer
WorkingDirectory=/opt/llm
Environment=HF_HOME=/data/.cache/huggingface
ExecStart=/usr/bin/bash -lc 'micromamba activate llm && accelerate launch train.py'
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Troubleshooting rapid

  • Out‑of‑memory (GPU): reduce per_device_train_batch_size, crește gradient_accumulation_steps, activează gradient_checkpointing.
  • Fragmentare memorie: repornește procesul; setează PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb=128.
  • NCCL hangs: verifică conectivitatea între noduri, firewall, setează NCCL_DEBUG=INFO; testează nccl-tests.
  • Thermal throttling: verifică praful, airflow, nvidia-smi -q -d TEMPERATURE.
  • I/O lent: confirmă noatime, read‑ahead, iostat -x 1.

Checklisturi scurte

Workstation single‑GPU

  • Ubuntu LTS, full-upgrade
  • Driver GPU stabil + nvidia-smi OK
  • Micromamba/venv, mediu python=3.11
  • HF_HOME pe NVMe, noatime, fstrim.timer
  • swappiness=10, governor performance
  • tmux, UFW, fail2ban, SSH cu chei

Server multi‑GPU

  • Topologie verificată (nvidia-smi topo -m)
  • NUMA pinning, DDP/DeepSpeed
  • NCCL/UCX variabile validate
  • Monitoring (DCGM, Grafana)
  • systemd pentru job-uri.

Tip solutie

Permanent

Voteaza

Up Down
(1 din 2 persoane apreciaza acest articol)
Share
Tweet
Share

Despre Autor

Leave A Comment?