Scaling Laws (Chinchilla) — Quy luật giữa model size, data và compute

Khi nghe tin "GPT-4 có 1.8 nghìn tỷ tham số" hay "Llama 3 train trên 15 nghìn tỷ token", bạn có thể nghĩ đó chỉ là cuộc đua vũ trang. Nhưng đằng sau những con số này là một khoa học nghiêm ngặt: Scaling Laws. Bài báo Chinchilla (DeepMind, 2022) đã chứng minh rằng hầu hết các mô hình trước đó — kể cả GPT-3 và Gopher — đều bị "undertrained": engine quá lớn nhưng bình xăng quá nhỏ. Hiểu đúng quy luật này giúp bạn tiết kiệm hàng triệu đô la FLOPs mà vẫn đạt hiệu năng cao hơn.

Vấn đề

Trước 2022, cộng đồng AI theo đuổi một chiến lược đơn giản: bigger is better. OpenAI's GPT-3 (175B parameters) và DeepMind's Gopher (280B parameters) đều được xây dựng với giả định rằng việc tăng kích thước model sẽ mang lại lợi ích lớn nhất cho hiệu năng. Theo paper Kaplan et al. (2020), compute budget nên được phân bổ với tỷ lệ N^0.73 × D^0.27 — nghĩa là nếu bạn có thêm compute, hãy dùng 3/4 để tăng model size và chỉ 1/4 để tăng data.

Kết quả là thảm họa về hiệu quả. Gopher 280B được train trên chỉ ~300 tỷ token — tương đương việc mua siêu xe Ferrari nhưng chỉ đổ xăng đủ chạy 100km. Model khổng lồ này "đói" dữ liệu, chưa kịp học hết patterns từ internet đã ngừng training. Ngược lại, compute budget bị lãng phí: train Gopher tốn khoảng $5-10 triệu USD, nhưng hiệu năng lại thua xa một model nhỏ hơn được train đúng cách.

Vấn đề cốt lõi: Không có công thức rõ ràng để cân bằng giữa model size (N), data size (D), và compute (C). Việc chọn sai tỷ lệ khiến bạn trả giá bằng cả tiền bạc và chất lượng.

Ý tưởng cốt lõi

Chinchilla paper (Hoffmann et al., 2022) đưa ra insight then chốt: Với một ngân sách compute cố định, loss của model phụ thuộc vào cả N và D theo power-law riêng biệt, và điểm tối ưu xảy ra khi cả hai được scale tuyến tính cùng nhau.

Hãy tưởng tượng bạn có 1 triệu đô la compute budget (tính bằng FLOPs). Bạn có thể:

• Train model 100B parameters trên 200B tokens (bự nhưng đói)
• Train model 10B parameters trên 2T tokens (nhỏ nhưng no căng)

Chinchilla cho thấy con đường thứ hai — dù model nhỏ hơn — thường cho kết quả tốt hơn trên đại đa số benchmarks. Quy tắc thực nghiệm từ paper: Mỗi parameter cần khoảng 20 tokens để train tối ưu (con số chính xác là ~20 tokens/param cho Chinchilla-optimal training, hoặc nói cách khác D ≈ 20N).

Đây là "aha moment": Bạn không cần model to hơn, bạn cần data nhiều hơn tỷ lệ thuận với model size. Nếu tăng gấp đôi parameters, bạn phải tăng gấp đôi training tokens để không lãng phí capacity. Điều này ngược hoàn toàn với trực giác Kaplan: data và model phải tăng cùng tốc độ (linear scaling), không phải model tăng nhanh hơn.

Why 20 tokens per parameter? Đây là kết quả của IsoFLOP analysis — phân tích các điểm có cùng compute budget (FLOPs ≈ 6ND). Khi vẽ đồ thị loss theo N với FLOPs cố định, bạn thấy một đường cong chữ U: model quá nhỏ underfit, model quá lớn (so với data) lại overfit hoặc undertrain. Đỉnh của chữ U — điểm tối ưu — luôn nằm ở nơi N và D tăng cùng nhau.

Tại sao nó hoạt động

Toán học đằng sau scaling laws dựa trên power-law decomposition của loss:

$L(N, D) = \frac{A}{N^\alpha} + \frac{B}{D^\beta} + L_{\infty}$

Trong đó:

• $L$ là test loss (perplexity)
• $N$ là số parameters
• $D$ là số tokens trong training data
• $L_{\infty}$ là irreducible entropy (nhiễu không thể nén)

Cả hai thành phần $A/N^\alpha$ (capacity term) và $B/D^\beta$ (data term) đều giảm theo power-law khi tăng N và D. Tại compute-optimal point, đạo hàm riêng của loss theo N và D phải cân bằng với ràng buộc FLOPs = $6ND$ (cho decoder-only transformers).

Khi giải hệ phương trình này, ta thấy rằng điểm tối ưu xảy ra khi: $N_{opt} \propto C^{0.5}, \quad D_{opt} \propto C^{0.5}$

Nghĩa là với compute budget $C$ tăng gấp 10, bạn nên tăng cả model size và data size mỗi thứ $\sqrt{10} \approx 3.16$ lần — tuyến tính với nhau, không phải model nhiều hơn.

Code intuition (pseudo-PyTorch cho FLOPs calculation):

# For a decoder-only transformer (e.g., GPT, Llama)
# FLOPs per forward pass ≈ 2 * num_params * seq_len
# Training has forward + backward (2x cost) → total 6 * N * D
def compute_flops(num_params, num_tokens):
    return 6 * num_params * num_tokens

# Example: Chinchilla 70B on 1.4T tokens
chinchilla_flops = compute_flops(70e9, 1.4e12)  # ≈ 5.9e23 FLOPs
# Gopher 280B on 300B tokens  
gopher_flops = compute_flops(280e9, 300e12)     # ≈ 5.0e23 FLOPs
# Cùng compute budget, nhưng Chinchilla thắng vì cân bằng hơn

Ý nghĩa thực tế

So sánh thực tế:

Impact thực tế:

• Tiết kiệm cost: Training Chinchilla 70B rẻ hơn Gopher 280B (do model nhỏ hơn, dù data nhiều hơn, nhưng distributed training trên nhiều GPU nhỏ hiệu quả hơn single large GPU cluster).
• Inference efficiency: Model nhỏ hơn (70B vs 280B) chạy nhanh hơn gấp 4 lần trên cùng hardware, tiết kiệm 75% inference cost khi deploy.
• Data quality awakening: Cộng đồng nhận ra data còn quan trọng hơn architecture. Điều này dẫn đến cuộc đua thu thập và lọc data chất lượng cao (Common Crawl filtering, deduplication, synthetic data).

Ai đang dùng:

• DeepMind: Chinchilla chính là nền tảng cho các model sau này (Gato, Sparrow).
• Meta: Llama 3 được train với tỷ lệ ~200 tokens/param (15T tokens cho 70B model), vượt xa ngưỡng Chinchilla nhưng vẫn theo tinh thần "data is king".
• OpenAI: GPT-4 được đồn đoán có ~1.8T params và train trên ~13T tokens, tỷ lệ ~7:1 — có vẻ thiên về model size hơn Chinchilla, nhưng vẫn cân bằng hơn GPT-3.

Các giới hạn:

• Inference-cost trade-off: Chinchilla optimal cho training, nhưng không phải cho inference. Nếu bạn serve model cho hàng triệu users, việc tăng model size để giảm số forward passes (hoặc dùng test-time compute) có thể tốt hơn dùng model nhỏ train chuẩn Chinchilla.
• Emergent capabilities: Một số khả năng (như chain-of-thought reasoning phức tạp) chỉ xuất hiện ở model >100B dù được train đủ data. Chinchilla laws mô tả trung bình, không đảm bảo capability emergence.
• Data saturation: Nếu bạn đã dùng hết high-quality internet text (~15T tokens chất lượng cao), việc tăng D thêm nữa đòi hỏi synthetic data hoặc multimodal data, có phân phối khác biệt.

Đào sâu hơn

Paper gốc:

• Hoffmann et al., "Training Compute-Optimal Large Language Models" (2022) — Paper Chinchilla chính thức, định nghĩa IsoFLOP profiles và empirical scaling laws.

Bài liên quan TroiSinh:

Cùng cụm (Training at Scale):

• Pre-training + Fine-tuning — Hiểu rõ pipeline trước khi bàn đến scale
• Data Parallelism — Cách chia batch cho nhiều GPU, prerequisite để train model Chinchilla-scale
• ZeRO Optimizer — Memory optimization để train model 70B+ trên cluster nhỏ
• Mixed Precision (FP16/BF16) — Cần thiết để giảm FLOPs thực tế khi scale up
• Gradient Checkpointing — Trade-off compute/memory khi train với context dài

Đọc tiếp (Level 1 — Breakthroughs):

• Training Efficiency — Các kỹ thuật tối ưu hơn nữa cho quá trình training ở quy mô lớn
• MoE (Mixture of Experts) — Kiến trúc thay thế để scale model size mà không tăng linear compute cost

External resources:

• Epoch AI — Scaling Laws Literature Review — Tổng hợp toán học và các bài báo follow-up sau Chinchilla
• Lambda Labs GPU Cost Calculator — Tính toán thực tế chi phí train theo various scaling strategies