Tham số và siêu tham số — 7 tỷ tham số nghĩa là gì

TL;DR: Dev đọc thông báo phát hành model "7 tỷ tham số" thường hỏi hai câu: con số đó đếm cái gì, và máy mình có nạp nổi không? Tham số trong ML là toàn bộ trọng số w và bias b mà model tự điều chỉnh trong lúc train — đây là "kiến thức" model tích luỹ được. Siêu tham số là thứ khác hẳn: learning rate, số lớp, batch size — do người chọn trước khi train bắt đầu, gradient descent không chạm tới chúng. Từ số tham số ước lượng được bộ nhớ tối thiểu để nạp model lúc inference: 7 tỷ × 2 byte ≈ 14 GB trọng số ở độ chính xác 16-bit.

1. Thông báo phát hành viết "7 tỷ tham số" — đó là con số gì?

Mỗi lần một model mới ra mắt, bạn thấy dòng tiêu đề kiểu: "Llama 3 8B", "Mistral 7B", "Phi-3 Mini 3.8B". Con số đi kèm với chữ "B" (billion = tỷ) đó đếm cái gì — và máy bạn có đủ RAM/VRAM để nạp không? Bài này trả lời cả hai câu hỏi thực dụng đó.

Trước tiên cần làm rõ một bẫy thuật ngữ: "tham số" trong ML khác hoàn toàn với "tham số hàm" trong lập trình. Trong Java hay Python, int x là tham số bạn truyền vào lúc gọi hàm — đó là biến đầu vào. Trong ML, "tham số" chỉ một thứ rất cụ thể: những giá trị số mà model TỰ học ra trong quá trình train — bạn không đặt chúng, gradient descent đặt chúng. Hai khái niệm dùng chung từ nhưng có nghĩa hoàn toàn khác nhau.

2. Tham số: những số mà model tự học ra

Tham số (parameter) của một neural net là tập hợp tất cả các w và b trong toàn mạng. Khi người ta nói "model 7 tỷ tham số", họ nói model có 7.000.000.000 con số kiểu này — 7 tỷ "núm vặn" mà quá trình train đã điều chỉnh để model học tốt nhất có thể trên tập dữ liệu.

Tham số = bộ nhớ học được của model. Nếu bạn tải model về máy (file .gguf, .safetensors, hay .pth), đó chính là file chứa tất cả giá trị w và b đã được train. Xoá file đó là xoá toàn bộ kiến thức — model trở về trạng thái ngẫu nhiên ban đầu.

Tham số chỉ thay đổi trong lúc train. Khi model được deploy và đang trả lời câu hỏi của bạn qua API, tất cả tham số đóng băng — model chỉ đọc chúng để tính toán đầu ra, không ghi thêm gì.

3. Một lớp fully-connected có bao nhiêu tham số?

Để đếm tổng tham số của một mạng, cần biết công thức cho từng lớp. Xét một lớp fully-connected (mỗi neuron đầu ra nối với mọi neuron đầu vào): nếu lớp nhận m đầu vào và có n neuron đầu ra, thì:

• Trọng số: mỗi trong n neuron đầu ra có m trọng số riêng → tổng m × n trọng số.
• Bias: mỗi neuron đầu ra có 1 bias riêng → tổng n bias.
• Tổng tham số của lớp này: m × n + n.

Đáp án — tính chi tiết:

• Lớp 1 (3 → 4 neuron): 3 × 4 = 12 trọng số + 4 bias = 16 tham số.
• Lớp 2 (4 → 1 neuron): 4 × 1 = 4 trọng số + 1 bias = 5 tham số.
• Tổng toàn mạng: 16 + 5 = 21 tham số.

Kiểm tra bằng script:

node -e "
  const l1 = 3*4 + 4;
  const l2 = 4*1 + 1;
  console.log('Lop 1:', l1, '  Lop 2:', l2, '  Tong:', l1+l2);
"
// Ket qua: Lop 1: 16   Lop 2: 5   Tong: 21

21 tham số cho mạng đồ chơi. Transformer thực tế có hàng chục đến hàng trăm lớp với chiều rộng hàng nghìn neuron — số tham số leo tới hàng tỷ khi nhân lên theo công thức trên.

4. Siêu tham số: người chọn, gradient không đụng tới

Bên cạnh tham số, khi thiết lập một model bạn phải đưa ra hàng loạt quyết định trước khi train bắt đầu: dùng bao nhiêu lớp? mỗi lớp rộng bao nhiêu neuron? tốc độ học là bao nhiêu? xử lý bao nhiêu mẫu mỗi lần? train trong bao nhiêu vòng?

Những quyết định đó là siêu tham số (hyperparameter) — người chọn, không phải model học ra.

Vì sao gradient descent không thể học siêu tham số? Gradient descent tính đạo hàm trên không gian liên tục. Số lớp hay kích thước lớp là lựa chọn rời rạc — không có đạo hàm để tính — và hơn nữa chúng quyết định hình dạng của đồ thị tính toán mà gradient descent đang chạy trên đó. Bạn không thể tối ưu một thứ đang là cơ sở hạ tầng của chính quá trình tối ưu.

Bảng dưới so sánh hai loại theo ba trục quan trọng với dev:

5. Biết số tham số, cần bao nhiêu bộ nhớ để nạp model?

Tham số là số thực — mỗi số chiếm một lượng bộ nhớ phụ thuộc vào kiểu số (dtype). Hai mức phổ biến: float32 (4 byte/tham số) thường dùng khi train; float16 / BFloat16 (2 byte/tham số) thường dùng khi inference để tiết kiệm bộ nhớ.

Đáp án:

7.000.000.000 tham so × 2 byte/tham so = 14.000.000.000 byte ≈ 14 GB

Kiểm tra (đã verify ở bước chuẩn bị bài):

node -e "
  const params = 7e9;
  console.log('float16 (2 byte):', params * 2 / 1e9, 'GB');
  console.log('float32 (4 byte):', params * 4 / 1e9, 'GB');
"
// float16 (2 byte): 14 GB
// float32 (4 byte): 28 GB

Quy tắc ngón tay cái: mỗi 1 tỷ tham số ở float16 tốn khoảng 2 GB — nên "X tỷ tham số × 2 ≈ X×2 GB VRAM ở float16" là ước lượng nhanh khi đọc thông báo model mới.

Đây là mức sàn cho trọng số, không phải tổng bộ nhớ cần dùng. Bộ nhớ phát sinh thêm từ KV cache (tăng theo độ dài context), activation trung gian, và overhead framework — tổng thực tế thường cao hơn đáng kể.

Lượng hoá (quantization) là kỹ thuật giảm số byte mỗi tham số xuống 8-bit hoặc 4-bit — giúp model 7B có thể chạy trên máy consumer với RAM 8 GB. Bài này chỉ nhắc tên; quantization là chủ đề riêng.

6. Chọn siêu tham số bằng validation set, không phải test set

Quy trình đúng dùng bộ ba tập tách biệt: train set để model học, validation set để bạn đo hiệu năng và chọn siêu tham số, test set chỉ dùng một lần duy nhất ở cuối để đánh giá chất lượng thực sự.

Quy tắc đơn giản: validation set để chỉnh, test set để chốt. Chỉ chạm test set một lần duy nhất — sau khi đã cố định hoàn toàn mọi quyết định về kiến trúc và siêu tham số.

7. Ba cái bẫy thường gặp

Bẫy 1 — Nhầm "tham số" ML với tham số hàm. Khi đồng nghiệp nói "model này 7B params", đừng nghĩ tới function arguments. Trong ngữ cảnh ML, "params" hay "parameters" luôn chỉ trọng số học được từ dữ liệu. Hai khái niệm khác nhau dùng cùng một từ — context quyết định nghĩa.

Bẫy 2 — Nhiều tham số không có nghĩa là thông minh hơn. Model lớn có sức chứa (capacity) cao hơn, nhưng nếu dữ liệu train không đủ lớn so với kích thước model, model sẽ overfit — học thuộc tập train thay vì khái quát hoá. Nghiên cứu Chinchilla (Hoffmann et al., 2022) cho thấy kích thước model và lượng dữ liệu train cần tăng cùng nhau — xem section Đào sâu.

Bẫy 3 — Nhầm "14 GB trọng số" với "14 GB đủ để chạy". Overhead runtime (KV cache, activation, OS, các process khác) đẩy tổng tiêu thụ lên đáng kể. Ngoài ra, nhiều framework yêu cầu trọng số trong VRAM (GPU) chứ không phải RAM thông thường — một máy 16 GB RAM với GPU 8 GB VRAM không thể chạy model 7B float16 trong VRAM. Kết luận từ phép tính trên giấy cần xác nhận bằng thử nghiệm thực tế.

8. Đào sâu

Nếu bạn muốn tìm hiểu thêm về cách kích thước model và dữ liệu tương tác nhau:

• Kaplan et al. (2020) — "Scaling Laws for Neural Language Models" · arXiv:2001.08361: Nhóm OpenAI chứng minh hiệu năng LLM tuân theo quy luật lũy thừa khi tăng kích thước model, lượng dữ liệu, và lượng tính toán — và các quan hệ này ổn định qua nhiều bậc độ lớn, cho phép dự đoán hiệu năng model lớn từ thực nghiệm model nhỏ.

• Hoffmann et al. (2022) — "Training Compute-Optimal Large Language Models" · arXiv:2203.15556: Chinchilla paper (DeepMind). Phát hiện trung tâm: để tối ưu compute, kích thước model và lượng dữ liệu train cần tăng tỉ lệ với nhau — khi tăng gấp đôi model thì cũng cần gấp đôi lượng token train. Bài báo cho thấy nhiều model lớn thời điểm đó bị train với quá ít dữ liệu so với kích thước. Lưu ý: Kaplan et al. và Chinchilla đưa ra kết luận khác nhau về tỉ lệ tối ưu — hai bài đang trong cuộc đối thoại khoa học về cùng câu hỏi scaling.

9. Liên hệ các bài khác

• Bài 1 — Neuron và trọng số: Nguồn gốc của tham số — w và b xuất hiện lần đầu ở bài đó; tham số toàn mạng chỉ là tổng hợp mọi w và b đó lại.
• Bài 2 — Xếp lớp và phi tuyến: Số lớp và số neuron mỗi lớp là siêu tham số kiến trúc — bài đó giải thích vì sao chúng ảnh hưởng tới sức chứa của model.
• Bài 4 — Gradient descent: Cơ chế model dùng để tự chỉnh tham số — learning rate (siêu tham số) kiểm soát bước điều chỉnh của gradient descent.
• Bài 6 — Representation học được: Bài tiếp theo đi sâu vào thứ mà tham số thực sự học được: các biểu diễn ẩn trong tầng giữa của mạng.

Bài tiếp theo: Representation — tầng ẩn tự học ra đặc trưng dữ liệu

10. Tóm tắt

• Tham số = tất cả w và b trong mạng — model TỰ chỉnh qua gradient descent, thay đổi liên tục trong train, đóng băng khi inference.
• Siêu tham số = quyết định kiến trúc và cấu hình (learning rate, số lớp, số neuron/lớp, batch size, epochs) — người chọn trước khi train, gradient descent không đụng tới.
• Công thức đếm tham số: lớp fully-connected m→n đóng góp m×n + n tham số.
• Ước lượng bộ nhớ trọng số: số_tham_số × byte/tham_số — 7 tỷ × 2 byte ≈ 14 GB (float16); đây là mức sàn, overhead runtime sẽ cao hơn.
• Chọn siêu tham số qua validation set; test set chỉ dùng một lần sau cùng để đánh giá.

11. Tự kiểm tra