Cài đặt môi trường huấn luyện AI trên máy chủ GPU

Bước 1Kiểm tra máy chủ đã nhận GPU

Trước khi cài gì, hãy chắc chắn hệ điều hành nhìn thấy card NVIDIA. Nếu lệnh nvidia-smi đã chạy được nghĩa là driver đã có sẵn — bạn có thể bỏ qua bước cài driver.

lspci | grep -i nvidia

nvidia-smi

Tài liệu chính thức: CUDA Installation Guide for Linux (bản 13.4) (mở tab mới) · nvidia-smi — tài liệu dòng lệnh (mở tab mới)

Bước 2Cài NVIDIA driver

Driver là phần mềm để hệ điều hành điều khiển GPU. Dù bạn cài thẳng lên máy hay dùng Docker, driver luôn phải nằm trên máy chủ (máy host) — container không mang driver theo.

sudo apt install linux-headers-$(uname -r)

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update

sudo apt install nvidia-open
sudo reboot

nvidia-smi
cat /proc/driver/nvidia/version

Tài liệu chính thức: NVIDIA Driver Installation Guide — Ubuntu (mở tab mới) · NVIDIA Driver Installation Guide — Post-installation Actions (mở tab mới) · CUDA Toolkit Release Notes — bảng driver tối thiểu (mở tab mới)

Bước 3Docker + NVIDIA Container Toolkit

Docker đóng gói phần mềm và thư viện vào container, chạy giống nhau trên mọi máy. NVIDIA Container Toolkit là cầu nối để container dùng được GPU của máy chủ.

sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo docker run hello-world

sudo apt-get update && sudo apt-get install -y --no-install-recommends \
   ca-certificates \
   curl \
   gnupg2

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/stable/deb/nvidia-container-toolkit.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

export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.20.0-1
  sudo apt-get install -y \
      nvidia-container-toolkit=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      nvidia-container-toolkit-base=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container-tools=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container1=${NVIDIA_CONTAINER_TOOLKIT_VERSION}

sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

sudo docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi

Tài liệu chính thức: Install Docker Engine on Ubuntu (mở tab mới) · Linux post-installation steps for Docker Engine (mở tab mới) · NVIDIA Container Toolkit — Installing (mở tab mới) · NVIDIA Container Toolkit — Running a Sample Workload (mở tab mới)

Bước 4Cài CUDA Toolkit (tuỳ chọn)Tuỳ chọn

CUDA Toolkit là bộ công cụ để biên dịch chương trình chạy trên GPU (trình biên dịch nvcc, thư viện). Theo trang cài đặt PyTorch, bạn chỉ phải tự cài CUDA khi build PyTorch từ mã nguồn. Hãy cài khi cần biên dịch mã CUDA — ví dụ build llama.cpp bản CUDA — hoặc khi thư viện bạn dùng yêu cầu.

sudo apt update
sudo apt install cuda-toolkit

export PATH=/usr/local/cuda-13.4/bin${PATH:+:${PATH}}

sudo apt-get -y install cudnn9-cuda-13

ls /usr/local/cuda-13.4/bin/

Tài liệu chính thức: CUDA Installation Guide for Linux (bản 13.4) (mở tab mới) · cuDNN — Installing on Linux (mở tab mới) · PyTorch — Get Started Locally (Stable 2.14.0) (mở tab mới) · PyTorch Release 26.08 (NGC) (mở tab mới)

Bước 5Tạo môi trường Python riêng

Môi trường ảo giữ thư viện của từng dự án tách biệt, tránh việc cài bản mới cho dự án này làm hỏng dự án khác. Chọn MỘT trong ba cách. PyTorch bản ổn định hiện yêu cầu Python 3.10 trở lên.

sudo apt install python3-venv
python3 -m venv ~/venvs/ai
source ~/venvs/ai/bin/activate

curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv --python 3.12 --seed
source .venv/bin/activate

wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh
conda create -n ai python=3.12
conda activate ai

Tài liệu chính thức: venv — Creation of virtual environments (mở tab mới) · Gói python3-venv (Ubuntu 24.04 noble) (mở tab mới) · uv — Installation (mở tab mới) · uv — Using Python environments (mở tab mới) · Miniforge README (mở tab mới) · conda — Managing environments (mở tab mới) · PyTorch — Get Started Locally (Stable 2.14.0) (mở tab mới)

Bước 6Cài PyTorch đúng bản CUDA

Mỗi bản PyTorch được đóng gói cho vài phiên bản CUDA. Chọn bản khớp với driver: driver từ 580 trở lên dùng được các bản CUDA 13.x. Lệnh dưới đây lấy từ trang “Get Started” của pytorch.org (Stable 2.14.0, Linux, pip).

pip3 install torch torchvision

pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu132

pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu126

docker run --gpus all -it --rm --ipc=host -v $HOME/work:/work nvcr.io/nvidia/pytorch:26.08-py3

import torch
x = torch.rand(5, 3)
print(x)
print(torch.cuda.is_available())

Tài liệu chính thức: PyTorch — Get Started Locally (Stable 2.14.0) (mở tab mới) · CUDA Toolkit Release Notes — bảng driver tối thiểu (mở tab mới) · PyTorch Release Notes (NGC) — Running PyTorch (mở tab mới) · PyTorch Release 26.08 (NGC) (mở tab mới)

Bước 7Chạy Jupyter an toàn qua SSH tunnel

Jupyter cho phép viết và chạy code ngay trên trình duyệt — nhưng ai vào được Jupyter là chạy được lệnh trên máy chủ của bạn. Đừng mở cổng Jupyter ra internet. Cách an toàn: để Jupyter chỉ nghe trên máy chủ, rồi dùng SSH “đào đường hầm” từ máy tính của bạn.

pip install jupyterlab
jupyter lab

docker run --gpus all -it --rm --ipc=host -p 127.0.0.1:8888:8888 -v $HOME/work:/work nvcr.io/nvidia/pytorch:26.08-py3

# bên trong container:
pip install jupyterlab
jupyter lab --ServerApp.ip=0.0.0.0

ssh -N -L 8888:localhost:8888 user@IP_MAY_CHU

Tài liệu chính thức: JupyterLab — Installation (mở tab mới) · Jupyter Server — Running a public Jupyter Server (mở tab mới) · ssh(1) — OpenBSD manual page (tuỳ chọn -L, -N) (mở tab mới) · Docker — Port publishing and mapping (mở tab mới) · Docker — Packet filtering and firewalls (Docker và ufw) (mở tab mới)

Bước 8Fine-tune bằng LoRA / QLoRA (ví dụ tối thiểu)

Fine-tune là dạy thêm cho model có sẵn bằng dữ liệu của bạn. LoRA chỉ huấn luyện một phần rất nhỏ tham số gắn thêm vào model; QLoRA nạp model gốc ở dạng nén 4-bit để giảm VRAM. Ví dụ dưới đây ghép đúng các đoạn mã trong tài liệu PEFT và Transformers.

pip install --upgrade transformers accelerate bitsandbytes
pip install peft

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# Model mở, giấy phép Apache-2.0 (xem model card trước khi dùng)
model_id = "Qwen/Qwen2.5-7B-Instruct"

config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=config)
model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(
    r=16,
    lora_alpha=8,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="qwen-lora-adapter",
    num_train_epochs=2,
    save_strategy="epoch",
    save_total_limit=3,
    report_to="tensorboard",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],  # dữ liệu đã token hoá của bạn
    data_collator=data_collator,
)
trainer.train()
model.save_pretrained("qwen-lora-adapter")

Tài liệu chính thức: PEFT — Installation (mở tab mới) · PEFT — Quicktour (LoraConfig, get_peft_model) (mở tab mới) · PEFT — Quantization (QLoRA, prepare_model_for_kbit_training) (mở tab mới) · Transformers — bitsandbytes (mở tab mới) · Transformers — Trainer / TrainingArguments (mở tab mới)

Bước 9Huấn luyện trên nhiều GPU

Khi một GPU không đủ bộ nhớ hoặc chạy quá lâu, ta chia việc cho nhiều GPU. Data parallel: mỗi GPU giữ một bản model, chia nhau dữ liệu. FSDP và DeepSpeed ZeRO: “xẻ” trạng thái optimizer, gradient, thậm chí cả tham số model ra nhiều GPU để tiết kiệm bộ nhớ. Ba công cụ khởi chạy phổ biến:

torchrun \
    --standalone \
    --nnodes=1 \
    --nproc-per-node=$NUM_TRAINERS \
    train.py

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

pip install deepspeed
deepspeed --num_gpus 4 train.py

{
  "bf16": { "enabled": "auto" },
  "zero_optimization": { "stage": 2 },
  "gradient_clipping": "auto",
  "train_micro_batch_size_per_gpu": "auto",
  "train_batch_size": "auto",
  "gradient_accumulation_steps": "auto"
}

args = TrainingArguments(
    deepspeed="ds_config.json",
    ...
)

ZeRO stage 1 chia trạng thái optimizer; stage 2 chia thêm gradient; stage 3 chia cả tham số model. Với PyTorch thuần, FSDP2 dùng hàm fully_shard() và cũng khởi chạy bằng torchrun. Nếu dùng Docker, nhớ thêm --ipc=host như mục “Cài PyTorch đúng bản CUDA”.

Tài liệu chính thức: torchrun (Elastic Launch) — PyTorch 2.14 (mở tab mới) · Accelerate — Launching distributed code (mở tab mới) · Accelerate — Fully Sharded Data Parallel (mở tab mới) · Transformers — DeepSpeed (mở tab mới) · DeepSpeed — Getting Started (mở tab mới) · DeepSpeed — ZeRO tutorial (mở tab mới) · Getting Started with Fully Sharded Data Parallel (FSDP2) (mở tab mới)

Bước 10Theo dõi GPU và quá trình huấn luyện

Theo dõi giúp phát hiện sớm GPU “ngồi chơi” (thường do nạp dữ liệu chậm), bộ nhớ sắp đầy, hay loss không giảm.

nvidia-smi -l 5
nvidia-smi dmon

pip install tensorboard
tensorboard --logdir=runs

TensorBoard cũng là một trang web — mở bằng SSH tunnel như mục “Chạy Jupyter an toàn qua SSH tunnel”, dùng đúng cổng mà TensorBoard in ra. Với Trainer, đặt report_to="tensorboard" hoặc report_to="wandb" để tự ghi log.

pip install wandb
wandb login

Tài liệu chính thức: nvidia-smi — tài liệu dòng lệnh (mở tab mới) · torch.utils.tensorboard (PyTorch 2.14) (mở tab mới) · Transformers — Trainer / TrainingArguments (mở tab mới) · Weights & Biases — Quickstart (mở tab mới) · DCGM Exporter (mở tab mới)

Bước 11Lưu checkpoint và sao lưu

Checkpoint là “bản lưu game” của quá trình huấn luyện. Máy chủ có thể khởi động lại, hết hạn thuê, hoặc bạn lỡ tay xoá — có checkpoint thì học tiếp từ chỗ dừng, không phải chạy lại từ đầu.

torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': loss,
            }, PATH)

checkpoint = torch.load(PATH, weights_only=True)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

trainer.train(resume_from_checkpoint=True)

save_total_limit giới hạn số checkpoint giữ lại để ổ đĩa không đầy. Nguyên tắc sao lưu: chép checkpoint quan trọng ra ngoài máy đang train (ví dụ kho lưu trữ riêng), vì dữ liệu chỉ nằm trên một máy là dữ liệu có thể mất.

Tài liệu chính thức: Saving and Loading Models — checkpoint (mở tab mới) · Transformers — Trainer / TrainingArguments (mở tab mới)

Bước 12Sự cố thường gặp

Ba nhóm lỗi hay gặp khi mới làm quen và hướng xử lý theo tài liệu chính thức.

1) CUDA out of memory — model, batch hoặc độ dài chuỗi vượt VRAM. Thử giảm batch size, dùng gradient accumulation, nạp model 4-bit (QLoRA) hoặc chia ra nhiều GPU (ZeRO/FSDP). PyTorch có biến môi trường PYTORCH_ALLOC_CONF để chỉnh bộ cấp phát bộ nhớ, ví dụ bật expandable_segments khi kích thước cấp phát thay đổi liên tục (tính năng thử nghiệm).

export PYTORCH_ALLOC_CONF=expandable_segments:True

2) Lệch phiên bản driver / CUDA — torch.cuda.is_available() trả về False hoặc báo driver quá cũ. So phiên bản driver (cat /proc/driver/nvidia/version) với bảng tối thiểu: CUDA 13.x cần driver từ 580, CUDA 12.x cần từ 525. Cách xử lý: nâng driver, hoặc cài bản PyTorch dựng cho CUDA thấp hơn.

3) Lỗi NCCL / treo khi chạy nhiều GPU — NCCL là thư viện để các GPU trao đổi dữ liệu. Bật log để xem lỗi dừng ở đâu. Máy có nhiều card mạng có thể chỉ định card bằng NCCL_SOCKET_IFNAME. Trong Docker, thiếu bộ nhớ chia sẻ cũng gây lỗi — thêm --ipc=host hoặc --shm-size.

export NCCL_DEBUG=INFO

Tài liệu chính thức: CUDA semantics — PYTORCH_ALLOC_CONF (PyTorch 2.14) (mở tab mới) · CUDA Toolkit Release Notes — bảng driver tối thiểu (mở tab mới) · CUDA Compatibility (mở tab mới) · NCCL Troubleshooting — Logging (mở tab mới) · NCCL — Environment Variables (mở tab mới) · PyTorch Release Notes (NGC) — Running PyTorch (mở tab mới)