AI & Machine Learning

Scaling law: mô hình lớn hơn, dữ liệu nhiều hơn thì giỏi thêm bao nhiêu

Scaling law (luật tỉ lệ) là các công thức thực nghiệm cho biết mất mát của mô hình ngôn ngữ giảm bao nhiêu khi tăng số tham số, số token huấn luyện và lượng tính toán. Nó trả lời câu hỏi đắt tiền nhất khi huấn luyện mô hình lớn: với một ngân sách cố định, nên làm mô hình to hơn hay cho nó đọc nhiều dữ liệu hơn. Bài này đọc thẳng ba bài báo gốc (Kaplan 2020, Chinchilla 2022, Llama 3 2024) và tự tính điểm tối ưu bằng numpy.

Ý chính
  • Scaling law là quan hệ dạng lũy thừa giữa mất mát (loss) và ba đại lượng: số tham số N, số token D, lượng tính toán C ≈ 6ND phép tính. Trên đồ thị log-log, nó là một đường thẳng.
  • Kaplan và cộng sự (2020) khuyên dồn phần lớn ngân sách vào mô hình: số tham số tăng theo lũy thừa 0,73 của lượng tính toán, dữ liệu chỉ cần tăng chậm.
  • Chinchilla (2022) sửa lại: tham số và token nên tăng đều nhau, khoảng 20 token cho mỗi tham số. Chinchilla 70 tỷ tham số học 1,4 nghìn tỷ token thắng Gopher 280 tỷ tham số dùng cùng ngân sách.
  • Scaling law dự đoán mất mát, không dự đoán thẳng một kỹ năng. Hằng số trong công thức phụ thuộc dữ liệu và bộ tách từ, nên mỗi nhóm phải đo lại trên dữ liệu của mình.

Code trong bài là Python 3 dùng numpy (máy viết bài dùng numpy 2.5.4). Mọi số liệu lấy từ bản PDF của các bài báo trên arXiv, đọc ngày 12/11/2026.

Scaling law là gì

Bài mô hình ngôn ngữ lớn hoạt động thế nào giải thích mô hình học bằng cách đoán token kế tiếp. Mức đoán sai được đo bằng mất mát entropy chéo (cross-entropy loss), tính bằng nats cho mỗi token. Scaling law nối con số đó với quy mô huấn luyện.

Năm 2020, nhóm Kaplan ở OpenAI huấn luyện các Transformer có từ 768 đến 1,5 tỷ tham số (không tính phần nhúng) và thấy mất mát giảm theo luật lũy thừa rất đều. Khi chỉ bị giới hạn bởi số tham số N (không tính phần nhúng), họ đo được:

\[\begin{aligned} L(N) &= \left(\frac{N_c}{N}\right)^{\alpha_N} \\ \alpha_N &\approx 0{,}076,\quad N_c \approx 8{,}8 \times 10^{13} \end{aligned}\]

Lấy log hai vế, \(\log L = \alpha_N \log N_c - \alpha_N \log N\): một đường thẳng có độ dốc \(-\alpha_N\) trên đồ thị log-log. Mỗi lần gấp đôi số tham số, mất mát nhân với \(2^{-0{,}076} \approx 0{,}95\), tức giảm khoảng 5%. Dữ liệu và lượng tính toán có hai đường tương tự, số mũ khoảng 0,095 và 0,050. Các quan hệ này đúng qua sáu bậc độ lớn của số tham số, và bài báo nhắc rằng mất mát chắc chắn phải chững lại trước khi chạm 0.

Ba đại lượng: tham số, token và FLOPs

N là số tham số, D là số token mô hình đọc khi huấn luyện, C là lượng tính toán đo bằng số phép tính dấu phẩy động (FLOPs). Kaplan ước lượng một lượt truyền xuôi tốn khoảng 2N phép tính cho mỗi token (mỗi tham số một phép nhân, một phép cộng), lượt lan truyền ngược tốn gấp đôi, nên tổng cộng khoảng 6N cho mỗi token:

\[C \approx 6ND\]

Chinchilla có 70 tỷ tham số, học 1,4 nghìn tỷ token, nên \(C \approx 6 \times (7 \times 10^{10}) \times (1{,}4 \times 10^{12})\), tức khoảng \(5{,}9 \times 10^{23}\) FLOPs. Mỗi GPU chỉ làm được một số FLOPs nhất định mỗi giây, nên C quy thẳng ra số giờ thuê máy. Câu hỏi trung tâm vì thế rất cụ thể: với C cho trước, chọn N và D thế nào để mất mát nhỏ nhất.

Kaplan 2020: dồn ngân sách vào mô hình

Nhóm Kaplan suy ra rằng khi lượng tính toán tăng, số tham số tối ưu tăng theo \(C^{0{,}73}\), còn dữ liệu chỉ cần tăng cỡ \(C^{0{,}27}\). Theo bài báo, cách dùng tính toán hiệu quả nhất là huấn luyện mô hình rất lớn trên lượng dữ liệu vừa phải và dừng trước khi hội tụ. Họ còn có quy tắc tránh quá khớp: mô hình to gấp 8 thì dữ liệu chỉ cần gấp khoảng 5.

Kết luận này định hình thế hệ mô hình ngay sau đó. Bảng 1 của bài Chinchilla liệt kê GPT-3 (175 tỷ tham số), Jurassic (178 tỷ) và Gopher (280 tỷ) đều học khoảng 300 tỷ token. Mô hình to dần, số token gần như đứng yên.

Chinchilla 2022: tham số và token tăng đều nhau

Nhóm Hoffmann ở DeepMind làm lại thí nghiệm với hơn 400 mô hình, từ 70 triệu đến hơn 16 tỷ tham số, học từ 5 đến 500 tỷ token. Họ ước lượng điểm tối ưu bằng ba cách độc lập: lấy đáy trên các đường huấn luyện, cắt theo những lát cùng ngân sách, và khớp một công thức mất mát. Cả ba cho \(N_{opt} \propto C^{a}\) với \(a\) từ 0,46 đến 0,50: gấp đôi mô hình thì cũng nên gấp đôi dữ liệu.

Bảng 3 (cách thứ nhất) cho quy tắc dễ nhớ: mô hình tối ưu học khoảng 20 token cho mỗi tham số. Mô hình 1 tỷ tham số cần 20,2 tỷ token; với ngân sách đã dùng cho Gopher, cỡ tối ưu là 67 tỷ tham số học khoảng 1,5 nghìn tỷ token. Gopher 280 tỷ tham số học 300 tỷ token vừa quá to vừa học quá ít.

Để kiểm chứng, họ huấn luyện Chinchilla: 70 tỷ tham số, 1,4 nghìn tỷ token, cùng ngân sách với Gopher. Trên MMLU với 5 ví dụ mẫu trong prompt, Chinchilla đạt 67,6% so với 60,0% của Gopher (Bảng 6), lại nhỏ hơn bốn lần nên rẻ hơn hẳn khi chạy.

Vì sao Kaplan lệch? Bài Chinchilla nêu hai lý do. Nhóm Kaplan dùng cùng một lịch giảm tốc độ học (learning rate schedule) dài cho mọi lần chạy rồi đọc mất mát ở những điểm giữa chừng, nên các lần chạy ít token trông kém hơn thật. Và phần lớn mô hình của Kaplan nhỏ, nhiều cái dưới 100 triệu tham số.

Tự tính điểm tối ưu bằng numpy

Cách thứ ba của Chinchilla khớp toàn bộ thí nghiệm vào một công thức (phương trình 10):

\[L(N, D) = E + \frac{A}{N^{\alpha}} + \frac{B}{D^{\beta}}\]

với \(E = 1{,}69\), \(A = 406{,}4\), \(B = 410{,}7\), \(\alpha = 0{,}34\), \(\beta = 0{,}28\). \(E\) là phần mất mát không thể bớt của văn bản, số hạng thứ hai là phần thiệt vì mô hình chỉ có N tham số, số hạng thứ ba là phần thiệt vì chỉ học D token. Thay \(D = C/(6N)\) rồi tìm cực tiểu, bài báo có nghiệm đóng (phương trình 4):

\[\begin{aligned} N_{opt} &= G \left(\frac{C}{6}\right)^{a},\quad a = \frac{\beta}{\alpha + \beta} \\ G &= \left(\frac{\alpha A}{\beta B}\right)^{1/(\alpha + \beta)} \end{aligned}\]

Đoạn code làm cả hai cách: dò trên lưới 200.001 giá trị N theo thang log, và tính thẳng nghiệm đóng. Hai cách phải ra cùng một điểm; nếu tự viết lại, đó là phép thử đầu tiên cho code của bạn.

"""Tìm cách chia ngân sách tính toán giữa số tham số và số token theo công thức của Chinchilla.

Công thức mất mát (Hoffmann và cộng sự 2022, phương trình 10, hằng số đã làm tròn trong bài báo):
    L(N, D) = E + A / N**alpha + B / D**beta
Ngân sách tính toán dùng xấp xỉ C = 6 * N * D phép tính dấu phẩy động (FLOPs).
Chạy: python chinchilla.py
"""
import numpy as np

E, A, B = 1.69, 406.4, 410.7
ALPHA, BETA = 0.34, 0.28


def mat_mat(N, D):
    """Mất mát dự đoán (nats cho mỗi token) của mô hình N tham số học D token."""
    return E + A / N**ALPHA + B / D**BETA


def toi_uu_do_luoi(C, so_diem=200_001):
    """Dò trên lưới log: mỗi N ứng với D = C / (6N); chọn N có mất mát nhỏ nhất."""
    N = np.logspace(8, 13, so_diem)  # từ 100 triệu tới 10 nghìn tỷ tham số
    D = C / (6 * N)
    L = mat_mat(N, D)
    i = int(np.argmin(L))
    return N[i], D[i], L[i]


def toi_uu_cong_thuc(C):
    """Nghiệm đóng (phương trình 4 của bài báo): N = G (C/6)^a, D = (C/6)^b / G."""
    a = BETA / (ALPHA + BETA)
    b = ALPHA / (ALPHA + BETA)
    G = (ALPHA * A / (BETA * B)) ** (1 / (ALPHA + BETA))
    return G * (C / 6) ** a, (C / 6) ** b / G


if __name__ == "__main__":
    C = 5.76e23  # ngân sách FLOPs dùng để huấn luyện Gopher (Bảng 3 bài Chinchilla)
    N, D, L = toi_uu_do_luoi(C)
    N2, D2 = toi_uu_cong_thuc(C)
    print(f"Ngân sách C = {C:.2e} FLOPs")
    print(f"  dò lưới  : N = {N / 1e9:.1f} tỷ, D = {D / 1e12:.2f} nghìn tỷ token, L = {L:.4f}")
    print(f"  công thức: N = {N2 / 1e9:.1f} tỷ, D = {D2 / 1e12:.2f} nghìn tỷ token")
    for ten, n in [("70 tỷ (cỡ Chinchilla)", 70e9), ("280 tỷ (cỡ Gopher)", 280e9)]:
        d = C / (6 * n)
        print(f"  {ten}: D = {d / 1e12:.2f} nghìn tỷ token, L = {mat_mat(n, d):.4f}")

Bảng dưới giữ nguyên ngân sách của Gopher, \(5{,}76 \times 10^{23}\) FLOPs, và đổi cỡ mô hình: mô hình càng to càng được học ít token.

Cỡ mô hình Số token cùng ngân sách Mất mát dự đoán
32,2 tỷ (đáy của công thức) 2,98 nghìn tỷ 1,9307
70 tỷ (cỡ Chinchilla) 1,37 nghìn tỷ 1,9376
280 tỷ (cỡ Gopher) 0,34 nghìn tỷ 1,9840
Cùng 5,76 × 10²³ FLOPs: chọn cỡ mô hình nào? Mất mát dự đoán theo công thức Chinchilla, số token D = C / (6N) 1,93 1,96 1,99 2,02 10 tỷ 30 tỷ 100 tỷ 300 tỷ mất mát số tham số N (thang log) Tối ưu ≈ 32 tỷ 70 tỷ (Chinchilla) 280 tỷ (Gopher) đáy phẳng: 32 → 70 tỷ chỉ thêm 0,007
Cùng 5,76 × 10²³ FLOPs chọn cỡ mô hình nào? 1,93 1,98 2,02 10 tỷ 100 tỷ mất mát số tham số N (thang log) Tối ưu ≈ 32 tỷ 70 tỷ (Chinchilla) 280 tỷ (Gopher)
Hình 1. Giữ cố định 5,76 × 10²³ FLOPs, mô hình N tham số chỉ được học C/(6N) token. Đường mất mát dự đoán có đáy rộng quanh 32 tỷ tham số; cỡ 70 tỷ gần như ngang đáy, cỡ 280 tỷ kém rõ.

Ba điều rút ra. Một, đáy rất phẳng: từ 32 tỷ lên 70 tỷ tham số mất mát chỉ tăng 0,007, lên 280 tỷ thì tăng 0,053. Vì vậy ba cách trong bài báo cho điểm tối ưu khác nhau (67 tỷ, 63 tỷ và 40 tỷ) nhưng đều đồng ý 280 tỷ là quá to. Hai, điểm tối ưu rất nhạy với số mũ: code dùng hằng số đã làm tròn nên ra 32 tỷ thay vì 40 tỷ như bài báo, vì \(a\) nhân với \(\ln(C/6) \approx 53\) nên lệch 0,01 ở \(a\) đã đổi kết quả khoảng 1,7 lần. Ba, cách 3 cho nhiều token cho mỗi tham số hơn hẳn quy tắc 20 token của cách 1: hằng số đã làm tròn trong code cho khoảng 93, còn điểm 40 tỷ của bài báo ứng với khoảng 2,4 nghìn tỷ token, tức khoảng 60; Bảng A3 của bài báo cho mô hình 67 tỷ tham số học 4,1 nghìn tỷ token, khoảng 61 token cho mỗi tham số. Đọc một con số N tối ưu, hãy hỏi nó tính bằng cách nào và làm tròn ra sao.

Scaling law trong thực tế: Llama 3

Bài báo Llama 3 của Meta huấn luyện các mô hình từ 40 triệu đến 16 tỷ tham số với ngân sách từ \(6 \times 10^{18}\) đến \(10^{22}\) FLOPs, vẽ các đường cùng ngân sách như Hình 1, lấy đáy mỗi đường rồi khớp số token tối ưu theo dạng \(A C^{\alpha}\). Ngoại suy tới ngân sách thật \(3{,}8 \times 10^{25}\) FLOPs, công thức gợi ý mô hình 402 tỷ tham số học 16,55 nghìn tỷ token. Meta chọn 405 tỷ tham số học 15,6 nghìn tỷ token, vì đáy đường cong càng phẳng khi ngân sách càng lớn.

Phần chữ của bài báo ghi \((\alpha, A) = (0{,}53;\ 0{,}29)\), còn Hình 3 ghi \((0{,}537;\ 0{,}299)\). Bộ số trong hình cho khoảng 16,3 nghìn tỷ token, sát con số 16,55 nghìn tỷ; bộ số đã làm tròn chỉ cho khoảng 10,5 nghìn tỷ. Ngoại suy qua hơn ba bậc độ lớn thì chữ số thứ ba của số mũ cũng quan trọng.

Meta còn cố ý huấn luyện các bản nhỏ (8B, 70B) lâu hơn hẳn mức tối ưu, vì mô hình nhỏ rẻ hơn khi phục vụ người dùng; bài báo ghi các bản này tốt hơn mô hình tối ưu có cùng chi phí khi chạy. Scaling law tối ưu chi phí huấn luyện, còn sản phẩm thật phải tính cả chi phí của mỗi lần trả lời.

Giới hạn của scaling law

Scaling law dự đoán mất mát, không dự đoán kỹ năng. Bài Llama 3 viết rõ các scaling law có sẵn thường chỉ dự đoán mất mát của token kế tiếp chứ không dự đoán điểm một bài đo, và có thể nhiễu vì xây từ các lần chạy nhỏ. Meta phải thêm một bước nối mất mát với độ chính xác bằng đường cong hình chữ S mới dự đoán được điểm ARC Challenge. Cách đọc điểm bài đo có trong bài benchmark AI là gì.

Các hằng số cũng không phải hằng số vũ trụ. Kaplan ghi giá trị của \(N_c\) và \(D_c\) phụ thuộc kích thước bộ từ vựng và cách tách từ, nên không mang ý nghĩa cơ bản. Đổi dữ liệu hay bộ tách từ thì phải đo lại.

Cuối cùng là dữ liệu: theo Bảng 3 của Chinchilla, mô hình 1 nghìn tỷ tham số cần khoảng 21,2 nghìn tỷ token. Các nhóm lấy và lọc dữ liệu thế nào có trong bài dữ liệu huấn luyện AI. Còn một trục mới là tính toán lúc trả lời: mô hình suy luận tiêu thêm FLOPs khi trả lời, như bài mô hình suy luận phân tích.

Cẩn thận
  • Coi quy tắc 20 token cho mỗi tham số là luật cứng: đó là kết quả của một cách ước lượng, trên một bộ dữ liệu, với cách đếm FLOPs gần đúng.
  • So mất mát giữa hai mô hình dùng bộ tách từ khác nhau: nats cho mỗi token không cùng thước đo khi token khác nhau.
  • Ngoại suy một đường thẳng log-log xa nhiều bậc độ lớn mà không nói về sai số của số mũ.
  • Nghĩ rằng mô hình to hơn luôn tốt hơn: cùng ngân sách, mô hình quá to học quá ít token sẽ thua.

Câu hỏi thường gặp

Scaling law có đúng mãi không?

Không ai chứng minh được điều đó. Các bài báo chỉ thấy xu hướng giữ đều trong vùng đã đo, và Kaplan ghi rõ mất mát phải chững lại trước khi chạm 0.

Quy tắc 20 token cho mỗi tham số lấy từ đâu?

Từ Bảng 3 bài Chinchilla, cách ước lượng thứ nhất: 1 tỷ tham số ứng với 20,2 tỷ token, 10 tỷ tham số ứng với 205,1 tỷ token. Cách thứ ba cho tỷ lệ cao hơn.

Vì sao mô hình nhỏ ngày nay học nhiều token hơn mức Chinchilla?

Vì chi phí chạy sau khi huấn luyện. Meta cố ý huấn luyện Llama 3 bản 8B và 70B lâu hơn mức tối ưu, trả thêm chi phí huấn luyện để có mô hình nhỏ mà giỏi.

Học sinh có tự thử scaling law được không?

Được, ở quy mô nhỏ: huấn luyện vài mô hình nhỏ các cỡ khác nhau trên cùng dữ liệu, vẽ mất mát theo cỡ trên thang log, rồi xem các điểm có nằm gần một đường thẳng không.

Học tiếp

Nếu bạn muốn học Python và học máy bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.

Muốn học bài bản cùng giảng viên?

Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.

Xem Khóa AI

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483