Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.
Quy luật toán học dự đoán hiệu suất mô hình dựa trên kích thước tham số, dữ liệu và compute.
lesson98 minHuấn luyện & AlignmentAI Researcher
Dự đoán
Gấp 10× tham số KHÔNG cho gấp 10× hiệu suất! Scaling laws là power law: với α ≈ 0.076 (Kaplan) hoặc α ≈ 0.34 (Chinchilla sau khi đã trừ data term), gấp 10× N → loss giảm vài chục phần trăm — không phải 10×. Hiểu quy luật này giúp các lab AI quyết định đầu tư compute một cách thông minh, không đơn thuần 'xây model to hơn'.
Biểu đồ Chinchilla
Hãy tưởng tượng bạn có một ngân sách xây nhà. Bạn có thể dồn tiền vào diện tích (rộng nhưng sơ sài), hoặc vào nội thất (nhỏ nhưng sang trọng). Với cùng ngân sách, luôn có một điểm cân bằng cho chất lượng sống cao nhất.
Trong LLM, "diện tích" là số tham số N, "nội thất" là lượng dữ liệu D, và "ngân sách" là compute C ≈ 6·N·D. Chinchilla (Hoffmann et al., 2022) đã tìm ra điểm cân bằng đó: D* ≈ 20 · N*. Dưới đây là biểu đồ log-log cho bạn thấy các model thực tế nằm ở đâu so với đường compute-optimal.
Khoảnh khắc A-ha
Hiệu suất của LLM không phải là nghệ thuật huyền bí — nó tuân theo một công thức toán học mà bạn có thể viết lên bảng. Biết công thức này, các lab AI có thể tính trước loss cho model trị giá nhiều triệu đô trước khi bỏ một đồng đầu tư.
Chinchilla đã đảo ngược niềm tin "càng to càng tốt": với cùng ngân sách compute, model 70B train trên 1.4T token đánh bại model 280B train trên 300B token. Cân bằng > to đùng.
Thử thách #1
Chinchilla thắng rõ rệt trên hầu hết benchmark. Lý do: với ~5.76 · 10^23 FLOPs compute chung, GPT-3 dùng compute để tăng N (175B) nhưng thiếu data (300B, D/N ≈ 1.7 — undertrained); Chinchilla dùng compute để cân bằng N (70B) với D (1.4T, D/N ≈ 20). Kết quả: loss Chinchilla thấp hơn, knowledge broader hơn.
Thử thách #2
Chinchilla tối ưu cho chi phí HUẤN LUYỆN. Nhưng khi một model phục vụ hàng tỷ request, chi phí inference áp đảo. Overtrain model nhỏ → chất lượng cao như model lớn + inference rẻ hơn hẳn. Đây là 'inference-aware scaling' — một hướng đi mới sau Chinchilla, được Meta, Mistral, Anthropic áp dụng rộng rãi từ 2024.
Giải thích chi tiết
Scaling laws là tập hợp các quy luật toán học, xác định bằng thực nghiệm, mô tả cách loss của LLM thay đổi khi ta thay đổi số tham số N, lượng dữ liệu D, và compute C. Kết quả chính: loss giảm theo power law (lũy thừa âm) đối với cả N và D, có một thành phần irreducible loss không thể giảm được.
Công thức Chinchilla (Hoffmann et al., 2022):
L(N,D)=E+NαA+DβB
Với các hằng số thực nghiệm: E ≈ 1.69, A ≈ 406.4, B ≈ 410.7, α ≈ 0.34, β ≈ 0.28. Ba số hạng có ý nghĩa riêng biệt:
E — irreducible loss: giới hạn dưới lý thuyết, tương ứng entropy Shannon của văn bản tự nhiên. Dù có vô hạn N và D, bạn không giảm loss xuống dưới E được.
A/N^α — model-size term: giảm khi tăng N. Với α ≈ 0.34, gấp đôi N giảm term này ~22%.
B/D^β — data-size term: giảm khi tăng D. Với β ≈ 0.28, gấp đôi D giảm term này ~18%.
Compute budget xấp xỉ bằng C≈6⋅N⋅D FLOPs — hằng số 6 đến từ: 2 FLOPs/param cho forward × 3 (forward + backward qua Transformer tiêu chuẩn). Đây là công thức giúp ta biến bài toán tối ưu L(N, D) với ràng buộc C thành một bài toán Lagrange đơn giản.
Cách các lab AI xác định các hằng số E, A, B, α, β: họ train hàng chục model với (N, D) khác nhau, đo loss, và fit least-squares vào công thức. Dưới đây là code thực tế:
fit_scaling_law.py — fit Chinchilla L(N,D) từ data thực nghiệm
"""
Fit hàm L(N, D) = E + A/N^alpha + B/D^beta vào các điểm thực nghiệm.
Dữ liệu thực tế thường có dạng:
runs = [
(N_params_in_billions, D_tokens_in_billions, final_loss),
...
]
Mỗi điểm là một lần huấn luyện riêng biệt — rất tốn kém, nên các lab
thường chỉ fit với 30–100 điểm trải trên vài quy mô.
"""importnumpyasnpfromscipy.optimizeimportcurve_fitdefchinchilla_loss(X,E,A,B,alpha,beta):"""
X: mảng (2, n) với hàng đầu là N (tham số), hàng sau là D (tokens).
Trả về loss dự đoán.
"""N,D=XreturnE+A/np.power(N,alpha)+B/np.power(D,beta)deffit_scaling_law(runs):"""
runs: list of (N_in_billions, D_in_billions, loss)
Trả về các hệ số đã fit.
"""# Chuyển về đơn vị tuyệt đối (N và D tính theo 'đơn vị' — ở đây là B).N_arr=np.array([r[0]forrinruns],dtype=float)D_arr=np.array([r[1]forrinruns],dtype=float)L_arr=np.array([r[2]forrinruns],dtype=float)X=np.vstack([N_arr,D_arr])# Khởi tạo gần đúng (lấy từ Chinchilla paper)p0=[1.69,406.4,410.7,0.34,0.28]# curve_fit dùng Levenberg-Marquardt theo mặc định — ổn với# bài toán này vì Jacobian tính được analytical.popt,pcov=curve_fit(chinchilla_loss,X,L_arr,p0=p0,maxfev=10000)E,A,B,alpha,beta=poptreturn{"E":E,"A":A,"B":B,"alpha":alpha,"beta":beta,"covariance":pcov,}defoptimal_N_D_for_compute(C_flops,alpha=0.34,beta=0.28):"""
Given compute budget C (FLOPs), return compute-optimal N, D.
Giả sử C ≈ 6 * N * D.
"""# Tỷ lệ tối ưu: N ∝ C^(beta/(alpha+beta)), D ∝ C^(alpha/(alpha+beta))ratio_N=beta/(alpha+beta)ratio_D=alpha/(alpha+beta)# Chuẩn hóa sao cho N * D = C / 6# → dùng hệ số từ paper; ở đây rút gọn bằng sqrt khi alpha ≈ beta.N=(C_flops/6)**ratio_ND=(C_flops/6)**ratio_D# Áp rule thực nghiệm D ≈ 20 * NreturnN,Dif__name__=="__main__":# Ví dụ giả lập 5 điểm dữ liệuruns_demo=[(1,5,3.10),# model nhỏ, data ít(1,50,2.60),# model nhỏ, nhiều data(10,50,2.30),(10,500,1.95),(70,1400,1.75),# giống Chinchilla]fit=fit_scaling_law(runs_demo)print("Fitted coefficients:",fit)# Dự đoán loss cho model mớiN_new,D_new=100,2000# 100B params, 2T tokenspred=chinchilla_loss(np.array([[N_new],[D_new]]),fit["E"],fit["A"],fit["B"],fit["alpha"],fit["beta"],)print(f"Predicted loss for 100B/2T: {pred[0]:.3f}")
Khi đã fit được L(N, D), ta có thể phân bổ compute budget một cách tối ưu. Dưới đây là hàm chọn N*, D* để loss thấp nhất với ràng buộc C:
allocate_compute.py — phân bổ compute tối ưu theo Chinchilla
"""
Cho compute budget C (FLOPs) và ràng buộc C = 6·N·D,
tìm (N*, D*) cực tiểu L(N, D) = E + A/N^alpha + B/D^beta.
Dùng Lagrange multiplier:
∂L/∂N + λ · 6 · D = 0
∂L/∂D + λ · 6 · N = 0
Giải ra: A·alpha / N^(alpha+1) = B·beta / D^(beta+1) · (N/D)
→ tỷ lệ D/N phụ thuộc (A, B, alpha, beta) nhưng gần 20 với
hằng số Chinchilla.
"""importnumpyasnpfromscipy.optimizeimportminimize# Hằng số ChinchillaE,A,B=1.69,406.4,410.7alpha,beta=0.34,0.28defloss_at(N,D):returnE+A/N**alpha+B/D**betadefoptimal_allocation(compute_flops):"""
Trả về (N*, D*) tối ưu cho compute budget C.
Ràng buộc: 6 * N * D = C → D = C / (6 * N).
Tối ưu trên một biến (N).
"""C=compute_flopsdefneg_objective(logN):N=np.exp(logN)D=C/(6*N)returnloss_at(N,D)# Khởi tạo tại N ≈ sqrt(C/120)N0=np.sqrt(C/120)res=minimize(neg_objective,x0=[np.log(N0)],method="Nelder-Mead",options={"xatol":1e-6,"fatol":1e-8},)N_opt=np.exp(res.x[0])D_opt=C/(6*N_opt)returnN_opt,D_opt,loss_at(N_opt,D_opt)defcompare_allocations(compute_flops,tried=None):"""
So sánh cách phân bổ khác nhau với cùng compute budget.
"""N_opt,D_opt,L_opt=optimal_allocation(compute_flops)print(f"Compute: {compute_flops:.2e} FLOPs")print(f" Compute-optimal: N={N_opt/1e9:.1f}B, D={D_opt/1e9:.1f}B, L={L_opt:.3f}")iftried:forname,N,Dintried:L=loss_at(N,D)overhead_pct=(L-L_opt)/L_opt*100print(f" {name}: N={N/1e9:.1f}B, D={D/1e9:.1f}B, L={L:.3f} (+{overhead_pct:.1f}%)")if__name__=="__main__":# Budget giống Chinchilla paperC=5.76e23compare_allocations(C,tried=[("GPT-3-like",175e9,300e9),("Chinchilla",70e9,1.4e12),("LLaMA 3 8B-like",8e9,15e12),])
Cách các lab fit scaling law
Để fit L(N, D) đáng tin cậy, các lab cần:
Train 30–100 model nhỏ (10M–1B params) với (N, D) đa dạng — trải N từ 10⁷ đến 10⁹, D từ 10⁸ đến 10¹¹.
Chạy đủ lâu để loss bão hòa — không được early-stop trong pha huấn luyện training runs for fitting.
Fit bằng weighted least-squares trong không gian log, để các điểm loss nhỏ (model lớn) không bị trọng số quá ít.
Kiểm tra extrapolation: chia dữ liệu thành train và hold-out theo (N, D). Scaling law tốt phải dự đoán chính xác loss cho hold-out nằm ngoài range đã fit.
Lặp lại quá trình cho mỗi kiến trúc mới — MoE, SSM, mixed precision... đều cho các hằng số khác.
Chi phí tổng cho việc "fit một scaling law" có thể lên đến hàng triệu đô (ước lượng theo nguồn bài, chưa kiểm chứng) chỉ để chạy các model nhỏ. Tuy vậy, tiết kiệm được hàng chục triệu khi train model cuối cùng nên vẫn đáng.
Chứng minh Chinchilla rule từ Lagrange
Bài toán: cực tiểu L(N,D)=E+A/Nα+B/Dβ với ràng buộc C=6ND.
Lagrangian:
L=E+NαA+DβB+λ(6ND−C)
Điều kiện cực trị:
∂N∂L=−Nα+1αA+6λD=0
∂D∂L=−Dβ+1βB+6λN=0
Chia hai phương trình:
Nα+1αA⋅βBDβ+1=ND
Rút gọn, kết hợp với C = 6ND, ta được công thức đóng:
N∗=(βBαA)α+β1⋅(6C)α+ββ
D∗=(αAβB)α+β1⋅(6C)α+βα
Thay α = 0.34, β = 0.28, A = 406.4, B = 410.7 → tỷ lệ D*/N* ≈ 20. Đó là "Chinchilla rule" dưới dạng công thức đóng.
Ba chế độ scaling và sai lầm thường gặp
Ba chế độ scaling bạn sẽ gặp trong thực tế:
Chế độ
Tỷ lệ D/N
Tối ưu cho
Ví dụ model
Undertrained
< 10
(Lịch sử) — hạn chế data
GPT-3 (1.7), Gopher (1.1)
Balanced (Chinchilla)
~20
Chi phí training thấp nhất
Chinchilla (20), LLaMA 1 (21)
Overtrained
> 30
Chi phí inference thấp
LLaMA 3 8B (1875), Phi-3 (≫100)
Các sai lầm thường gặp khi áp dụng scaling laws:
Dùng hằng số Chinchilla cho mọi kiến trúc: MoE, SSM (Mamba), state-space hybrid đều có α, β khác. Không ngoại suy mù quáng.
Bỏ qua chất lượng data: scaling law giả định data phân phối đều. Filter data kém → A/N^α term bị lệch. Model training on "nguyên liệu tốt" vượt xa model training on data thô cùng D.
Quên overhead giao tiếp khi scale lên cluster 10.000+ GPU: C thực tế < 6·N·D một đáng kể do all-reduce, gradient sync.
Fit scaling law chỉ trên 3–5 điểm: quá ít để tin cậy. Nên > 30 điểm trải trên 3+ bậc N, D.
Áp Chinchilla khi chi phí inference đáng kể: với product phục vụ hàng tỷ request, dùng inference-aware allocation thay vì Chinchilla thuần.
Ứng dụng thực tế
Ứng dụng thực tế của scaling laws:
Quyết định compute budget trước khi đầu tư: Anthropic, OpenAI dùng scaling laws để ước lượng loss của GPT-4, Claude 3 trước khi chi hàng trăm triệu đô.
Thiết kế kiến trúc mới: khi ra MoE, người ta fit scaling law để chứng minh tiết kiệm compute so với dense.
Báo cáo tiến bộ học thuật: paper LLM mới thường báo cáo "scaling law của chúng tôi có alpha tốt hơn" — kiểu đo lường chuẩn mực.
Định giá compute: AWS/GCP dựa vào scaling laws để dự báo nhu cầu GPU cho năm tới.
Lựa chọn model để fine-tune: với budget fine-tune cố định, bạn nên chọn base model ở đúng điểm compute-optimal thay vì model lớn hơn bạn cần.
Tóm tắt
Scaling laws là power law: L(N, D) = E + A/N^α + B/D^β. Loss giảm dự đoán được khi tăng N, D, C.
Diminishing returns: gấp 10× tham số chỉ giảm loss vài chục phần trăm — không bao giờ là 10×.
Chinchilla rule: D* ≈ 20 · N* cho compute-optimal. GPT-3 và Gopher là undertrained vì D/N quá thấp.
C ≈ 6·N·D là công thức vàng để biến tối ưu hai biến thành một biến duy nhất.
LLaMA 3 và xu hướng hiện đại: overtrain có chủ đích để tiết kiệm inference — đánh đổi training cost lấy serving cost.
Scaling laws không phải định luật vật lý: hằng số phụ thuộc kiến trúc, data, tokenizer. Kiểm chứng bằng thực nghiệm.