VRAM là "RAM" mới: Hướng dẫn thực tế chạy Large Language Models trên GPU phổ thông

GPU của bạn có 8 GB VRAM, nhưng mô hình bạn muốn chạy lại yêu cầu 14 GB. Bạn sẽ làm gì?

Đây là rào cản phổ biến nhất mà mọi người gặp phải khi chạy các Large Language Models (LLM) cục bộ. Các API trên đám mây không quan tâm đến phần cứng của bạn, nhưng suy luận (inference) tại chỗ thì có. Việc hiểu rõ về VRAM chính là sự khác biệt giữa việc có được phản hồi mượt mà ở tốc độ 40 token/giây hay hệ thống của bạn bị treo cứng.

Tôi đã dành nhiều tháng để tối ưu hóa các cài đặt AI cục bộ và xây dựng công cụ xung quanh Ollama. Dưới đây là mọi thứ tôi học được về cách biến các mô hình khổng lồ vừa vặn với phần cứng phổ thông.

Tại sao VRAM quan trọng hơn bạn nghĩ

Khi bạn nạp một mô hình vào GPU, mọi tham số đều cần phải nằm trong VRAM trong quá trình suy luận. Một mô hình 7 tỷ tham số ở độ chính xác FP16 đầy đủ sẽ cần khoảng:

7 tỷ × 2 byte = ~14 GB VRAM

Con số này đã vượt quá hầu hết các GPU phổ thông dành cho người tiêu dùng. Một chiếc RTX 4060 chỉ có 8 GB. RTX 4070 là 12 GB. Ngay cả RTX 4090 cao cấp cũng chỉ dừng lại ở 24 GB.

Vậy làm thế nào mọi người chạy được các mô hình 70B trên một GPU duy nhất? Câu trả lời là: Quantization (Định lượng).

Bảng tham khảo Quantization

Quantization giúp giảm độ chính xác của trọng số mô hình. Thay vì dùng 16 bit cho mỗi tham số, bạn chỉ dùng 4 hoặc 8 bit. Dưới đây là phân tích thực tế:

Mức Quant	Bit/Tham số	Model 7B	Model 13B	Model 70B
FP16	16	~14 GB	~26 GB	~140 GB
Q8_0	8	~7.5 GB	~14 GB	~70 GB
Q6_K	6	~5.5 GB	~10.5 GB	~54 GB
Q5_K_M	5	~4.8 GB	~9 GB	~48 GB
Q4_K_M	4	~4.1 GB	~7.5 GB	~40 GB
Q3_K_M	3	~3.3 GB	~6 GB	~32 GB
Q2_K	2	~2.7 GB	~5 GB	~26 GB

Điểm ngọt (sweet spot) cho đa số người dùng: Q4_K_M. Bạn chỉ mất đi rất ít chất lượng so với FP16 trong khi cắt giảm 75% dung lượng bộ nhớ.

"Thuế" VRAM ẩn

Trọng số mô hình không phải là thứ duy nhất ngốn VRAM của bạn. Bạn cũng cần bộ nhớ cho:

• KV Cache: Lưu trữ trạng thái attention trong quá trình tạo văn bản. Tăng theo độ dài ngữ cảnh (context length) × số lớp. Một mô hình 7B với ngữ cảnh 8K tốn thêm khoảng 500 MB - 1 GB.
• CUDA overhead: Khoảng 300-500 MB chỉ cho thời gian chạy CUDA.
• Hệ điều hành/Màn hình: Trình quản lý màn hình của bạn dùng 200-500 MB VRAM.

Công thức thực tế:

Tổng VRAM cần = Trọng số model + KV cache + CUDA overhead + Dự phòng OS

Ví dụ với Llama 3.1 8B Q4_K_M, ngữ cảnh 8K:
~4.1 GB + ~0.8 GB + ~0.4 GB + ~0.3 GB = ~5.6 GB

Đó là lý do tại sao một mô hình quantization 4 GB thực tế không chạy được trên GPU 4 GB.

Các lệnh Ollama thực tế để quản lý VRAM

Ollama tự động xử lý hầu hết việc này, nhưng bạn có thể tinh chỉnh:

# Kiểm tra model nào đang được nạp và mức dùng VRAM
ollama ps

# Thiết lập kích thước ngữ cảnh (thấp hơn = ít VRAM hơn)
ollama run llama3.1 --ctx-size 4096

# Buộc suy luận chỉ bằng CPU (khi VRAM đầy)
OLLAMA_GPU_LAYERS=0 ollama run llama3.1

# Chuyển tải một phần GPU — đưa một số lớp lên GPU, phần còn lại lên CPU
OLLAMA_GPU_LAYERS=20 ollama run mixtral

# Thiết lập thời gian model lưu ở VRAM (mặc định: 5 phút)
OLLAMA_KEEP_ALIVE=10m ollama run llama3.1

# Giải phóng tất cả model khỏi VRAM ngay lập tức
curl http://localhost:11434/api/generate -d '{"model": "llama3.1", "keep_alive": 0}'

Chiến lược chia nhỏ lớp GPU

Khi một mô hình không vừa hoàn toàn trong VRAM, bạn chia nó giữa GPU và CPU. Điểm mấu chốt: lớp đầu tiên và lớp cuối cùng quan trọng nhất đối với tốc độ.

# Kiểm tra tổng số lớp trong một model
ollama show llama3.1 --modelfile | grep -i layer

# Ví dụ với model 32 lớp trên GPU 8 GB dùng Q4_K_M:
# Bắt đầu với 24 lớp GPU, điều chỉnh dựa trên dung lượng thực tế
OLLAMA_GPU_LAYERS=24 ollama run llama3.1:8b-q4_K_M

Theo dõi bằng nvidia-smi trong khi sinh văn bản:

# Xem việc sử dụng VRAM theo thời gian thực
watch -n 0.5 nvidia-smi

# Hoặc chỉ dòng bộ nhớ
nvidia-smi --query-gpu=memory.used,memory.total --format=csv -l 1

Quy tắc vàng: Nếu việc sử dụng VRAM đạt 95%+ trong quá trình sinh văn bản, hãy giảm lớp GPU đi 2-3 lớp. Bạn nên dành khoảng 500 MB trống để KV cache có thể mở rộng trong các cuộc trò chuyện dài.

Quy trình đa mô hình mà không sợ hết bộ nhớ (OOM)

Chạy nhiều mô hình đồng thời (ví dụ: model chat + model code) sẽ làm tăng gấp đôi nhu cầu VRAM. Dưới đây là các chiến lược:

1. Nạp tuần tự với timeout linh hoạt:

# Giải phóng sau 30 giây không hoạt động
OLLAMA_KEEP_ALIVE=30s

2. Kết hợp kích thước model một cách có chủ đích:

Thay vì dùng hai model 7B, hãy ghép một model 7B với một model 1.5B:

• Chat chính: llama3.1:8b-q4_K_M (~4.1 GB)
• Phân loại nhanh: qwen2.5:1.5b (~1 GB)
• Tổng cộng: ~5.1 GB — vừa vặn trên card 8 GB.

3. Chuyển model phụ sang CPU hoàn toàn:

# Chạy model nhỏ hơn trên CPU trong khi model chính dùng GPU
OLLAMA_GPU_LAYERS=0 ollama run qwen2.5:1.5b

So sánh A/B giữa các Model mà không cần nhân đôi VRAM

Đây là một mẹo tôi tích hợp vào công cụ Locally Uncensored — khi so sánh A/B giữa các model, bạn không cần nạp cả hai cùng lúc. Ứng dụng sẽ gửi cùng một lời nhắc theo tuần tự: nạp Model A, sinh, giải phóng, nạp Model B, sinh, và hiển thị song song.

So sánh tuần tự chậm hơn song song khoảng 2 lần, nhưng điều này cho phép bạn so sánh model 13B với model 7B trên GPU 8 GB. Trên card 24 GB, bạn có thể so sánh hai model 70B đã quantization mà nếu nạp cùng lúc sẽ cần đến 48 GB.

Nếu bạn làm thủ công qua API:

# Gửi đến model A
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Giải thích đường hầm lượng tử",
  "keep_alive": 0
}'

# Model A tự giải phóng, sau đó gửi đến model B
curl http://localhost:11434/api/generate -d '{
  "model": "gemma2:9b",
  "prompt": "Giải thích đường hầm lượng tử",
  "keep_alive": 0
}'

Tham số keep_alive: 0 là rất quan trọng — nó yêu cầu Ollama giải phóng model ngay sau khi sinh xong.

Thang VRAM: Nên chạy gì trên mỗi phân khúc GPU

Dựa trên kiểm thử thực tế:

4-6 GB VRAM (GTX 1660, RTX 3050):

• Model 7B ở mức Q3_K_M hoặc Q4_K_M với ngữ cảnh 2K-4K.
• Giữ nguyên quy trình một model.
• Nên cân nhắc suy luận bằng CPU cho các model lớn hơn.

8 GB VRAM (RTX 4060, RTX 3070):

• Model 7-8B ở mức Q4_K_M-Q6_K với ngữ cảnh 8K.
• Model 13B ở mức Q3_K_M với ngữ cảnh giảm.
• Điểm ngọt cho đa số người dùng tại nhà.

12 GB VRAM (RTX 4070, RTX 3060 12GB):

• Model 13B ở mức Q4_K_M-Q5_K_M với ngữ cảnh 8K.
• Model 7B ở mức Q8_0 (gần như không mất chất lượng).
• Có thể chạy một số model 30B ở mức Q3_K_M.

16 GB VRAM (RTX 4070 Ti, RTX 5060 Ti):

• Model 30B ở mức Q4_K_M với ngữ cảnh 8K.
• Model 13B ở mức Q6_K với ngữ cảnh 16K.
• Các thiết lập đa model bắt đầu khả thi.

24 GB VRAM (RTX 4090, RTX 3090):

• Model 70B ở mức Q4_K_M với ngữ cảnh 4K-8K.
• Model 30B ở mức Q6_K với ngữ cảnh đầy đủ.
• Quy trình đa model thoải mái.

Script giám sát

Lưu đoạn mã sau thành file vram-watch.sh:

#!/bin/bash
# Giám sát VRAM + các model đang nạp trên Ollama
while true; do
  clear
  echo "=== GPU VRAM ==="
  nvidia-smi --query-gpu=name,memory.used,memory.total,utilization.gpu \
    --format=csv,noheader,nounits | \
    awk -F', ' '{printf "%s: %s/%s MB (GPU: %s%%)\n", $1, $2, $3, $4}'
  echo ""
  echo "=== Loaded Models ==="
  ollama ps 2>/dev/null || echo "Ollama not running"
  echo ""
  echo "Nhấn Ctrl+C để thoát"
  sleep 2
done

Các điểm chính cần nhớ

1. Luôn tính đến "thuế ẩn": Kích thước model trên đĩa ≠ VRAM cần thiết khi chạy.
2. Q4_K_M là mức định lượng mặc định của bạn: Tỷ lệ chất lượng/kích thước tốt nhất cho GPU phổ thông.
3. Chuyển tải một phần GPU bị đánh giá thấp: 20 lớp trên GPU + phần còn lại trên CPU nhanh hơn suy luận toàn CPU từ 3-5 lần.
4. Quản lý vòng đời model: Tham số keep_alive ngăn các mô hình "chiếm dụng" VRAM của bạn.
5. Giám sát tích cực: nvidia-smi và ollama ps là những người bạn tốt nhất.

Không gian AI cục bộ đang phát triển rất nhanh. Các mô hình ngày càng hiệu quả hơn (Gemma 2 cực kỳ ấn tượng với kích thước của nó), phương pháp quantization đang được cải thiện, và các công cụ như Ollama liên tục trừu tượng hóa sự phức tạp. Việc hiểu rõ quản lý VRAM có nghĩa là bạn sẽ luôn biết cách ép kiệt hiệu suất tối đa từ bất kỳ phần cứng nào bạn đang có.

Nếu bạn muốn một giao diện GUI tự động xử lý tất cả những việc này — quản lý model, nạp nhận biết VRAM, so sánh A/B — hãy xem thử Locally Uncensored. Nó được cấp phép MIT và xây dựng riêng để chạy AI cục bộ mà không gặp rắc rối.

Bạn đang dùng GPU nào để chạy các mô hình cục bộ? Hãy chia sẻ cấu hình của bạn bên dưới — tôi luôn tò mò xem mọi người đang làm việc với phần cứng gì.