Tiền huấn luyện (Pre-training): Từ dữ liệu Web thô đến Định luật Mở rộng

Khi nhìn vào một mô hình ngôn ngữ hiện đại như Llama-3 hay DeepSeek-V3, phương trình huấn luyện của nó trông đơn giản đến bất ngờ: cho mô hình đọc một đoạn văn bản và yêu cầu nó dự đoán token tiếp theo. Thế nhưng, đằng sau mục tiêu tưởng chừng tầm thường ấy là một cuộc cách mạng kỹ thuật trị giá hàng chục triệu đô la tiền điện và hàng nghìn GPU hoạt động liên tục suốt nhiều tháng trời.

Trong chương này, chúng ta sẽ lần lượt giải quyết ba câu hỏi cốt lõi định hình toàn bộ quy trình tiền huấn luyện hiện đại:

• Làm thế nào để biến hàng trăm terabyte mã HTML hỗn độn, đầy spam và trùng lặp trên Internet thành hàng nghìn tỷ token sạch, được đóng gói khít 100% vào bộ nhớ GPU?
• Làm thế nào để dẫn dắt hàng chục tỷ tham số hội tụ ổn định qua hàng trăm nghìn bước cập nhật đạo hàm ở độ chính xác giảm (bfloat16) mà không bị nổ đạo hàm hay phân kỳ?
• Với một ngân sách tính toán cố định $C$ (tính bằng FLOPs), ta nên xây dựng một mô hình thật lớn hay huấn luyện một mô hình vừa phải trên nhiều dữ liệu hơn?

1. Bài toán Tiền huấn luyện và Chuẩn bị Batch dữ liệu

1.1 Hàm mất mát Cross-Entropy tự hồi quy

Giả sử bộ tách từ ở Chương 1 đã chuyển một tài liệu văn bản thành một chuỗi gồm $L$ chỉ số nguyên $(x_1, x_2, \dots, x_L)$, trong đó mỗi token $x_t \in \{0, 1, \dots, |V|-1\}$ thuộc bộ từ vựng kích thước $|V|$. Theo quy tắc nhân xác suất (chain rule of probability), xác suất xuất hiện của cả chuỗi văn bản được phân rã chính xác thành tích các xác suất có điều kiện từ trái sang phải:

Một mô hình ngôn ngữ tự hồi quy có bộ tham số $\theta$ nhận vào chuỗi ngữ cảnh quá khứ $(x_1, \dots, x_t)$ và xuất ra một vector điểm số chưa chuẩn hóa (logits) $z_t \in \mathbb{R}^{|V|}$ tại mỗi vị trí $t$. Qua hàm Softmax, mô hình dự đoán phân phối xác suất cho token kế tiếp $x_{t+1}$:

Mục tiêu của tiền huấn luyện là cực đại hóa hợp lý (maximum likelihood) trên toàn bộ kho văn bản, tương đương với việc cực tiểu hóa hàm mất mát Cross-Entropy trung bình trên mỗi token:

Điểm kỳ diệu của kiến trúc Transformer Decoder có mặt nạ nhân quả (causal mask) là: chỉ với một lượt lan truyền tiến (forward pass) duy nhất trên chuỗi đầu vào $x = (x_1, x_2, \dots, x_L)$, mô hình tính toán song song cả $L$ dự đoán cho chuỗi đích dịch chuyển sang trái một vị trí $y = (x_2, x_3, \dots, x_{L+1})$. Tại vị trí đầu tiên, mô hình học cách dự đoán $x_2$ từ $x_1$; tại vị trí thứ hai, nó dự đoán $x_3$ từ $(x_1, x_2)$; và tại vị trí cuối cùng, nó dự đoán $x_{L+1}$ từ toàn bộ $L$ token trước đó. Mọi vị trí trong cửa sổ ngữ cảnh đều đóng góp tín hiệu đạo hàm!

1.2 Đóng gói tài liệu (Document Packing) vs. Đệm chuỗi (Padding)

Trên thực tế, văn bản trên Internet có độ dài vô cùng chênh lệch: một dòng bình luận có thể chỉ dài 15 token, một bản tin báo chí dài 600 token, còn một chương sách dài tới 10.000 token. Trong khi đó, GPU đòi hỏi dữ liệu đầu vào phải là một tensor chữ nhật đồng nhất có kích thước $(B, L)$, với $B$ là kích thước lô (batch size) và $L$ là độ dài cửa sổ ngữ cảnh (context length, chẳng hạn $L = 4096$ hoặc $8192$).

Nếu ta làm theo cách truyền thống của các bài toán phân loại văn bản — đặt mỗi bài viết vào một hàng riêng biệt rồi chèn thêm các token đệm <pad> vào cuối các bài viết ngắn cho đủ độ dài $L$ — điều gì sẽ xảy ra? Vì phần lớn trang web ngắn hơn $4096$ token, tới 40%–70% diện tích của tensor $(B, L)$ sẽ toàn là các ô <pad> vô nghĩa. Mặc dù ta có thể đặt ignore_index để loại bỏ <pad> khỏi hàm mất mát, các lớp Linear và Attention của Transformer vẫn phải thực hiện hàng tỷ phép nhân ma trận trên những vị trí đệm đó!

Để đạt hiệu suất sử dụng token 100%, các hệ thống tiền huấn luyện LLM hiện đại áp dụng kỹ thuật Đóng gói tài liệu (Document Packing / Concatenated Chunking):

1. Kết thúc mỗi tài liệu bằng một token đặc biệt đánh dấu ranh giới, thường gọi là <|endoftext|> hoặc <eos> (End-of-Sequence).
2. Nối tất cả các tài liệu đã tách từ thành một dòng chảy token khổng lồ, liên tục.
3. Cắt dòng chảy này thành các đoạn có độ dài cố định $L + 1$. Trong mỗi đoạn, $L$ token đầu tiên làm vector đầu vào $x$, và $L$ token cuối cùng (dịch phải 1 vị trí) làm nhãn đích $y$.

Khi hai tài liệu độc lập (ví dụ một bài báo y học và một đoạn mã Python) nằm chung trong cùng một cửa sổ đóng gói dài $L$, mặt nạ nhân quả tam giác dưới thông thường sẽ cho phép các token của đoạn mã Python nhìn ngược về các token của bài báo y học đứng trước nó. Ở các mô hình thế hệ đầu như GPT-2 hay GPT-3, người ta chấp nhận sự “nhiễm chéo” nhẹ này vì mô hình khá nhanh chóng học được rằng token <|endoftext|> đồng nghĩa với việc “hãy xóa trí nhớ cũ và bắt đầu chủ đề mới”. Tuy nhiên, ở các mô hình hiện đại với chiều dài ngữ cảnh lớn như Llama-3 ($L = 8192$ đến $128\text{K}$), ta sử dụng Mặt nạ chú ý nội bộ tài liệu (Intra-Document Causal Mask) — một ma trận đường chéo theo từng khối tài liệu (block-diagonal causal mask) đảm bảo mỗi token chỉ được chú ý tới các token quá khứ thuộc cùng một tài liệu với nó:

Hãy tự tay cài đặt bộ đóng gói tài liệu này và đo xem chúng ta tiết kiệm được bao nhiêu phần trăm phép tính so với phương pháp đệm truyền thống!

import torch

# 8 đoạn văn bản đã được tách thành danh sách các ID token
# (EOS_ID = 0 đóng vai trò là token <|endoftext|>, PAD_ID = -1)
EOS_ID = 0
PAD_ID = -1
raw_docs = [
    [12, 45, 89, 23, 67],
    [34, 78, 91, 15, 62, 88, 41, 19, 53, 77],
    [105, 204, 18],
    [56, 31, 90, 44, 11, 72, 65],
    [81, 14, 29, 63],
    [99, 42, 17, 83, 25, 61, 38, 74, 50],
    [16, 84, 39, 71, 22],
    [47, 93, 28, 64, 13, 86],
]
context_length = 8
print(f"Số tài liệu: {len(raw_docs)}, tổng số token: "
      f"{sum(len(d) for d in raw_docs)}")

Số tài liệu: 8, tổng số token: 49

[Padding] Kích thước batch: (8, 8) -> Hiệu suất token: 71.9% (Lãng phí 28.1%)
[Packing] Tổng luồng token: 57 -> Số khối (x, y) độ dài 8: 7
[Packing] Kích thước X: torch.Size([7, 8]), Y: torch.Size([7, 8])
[Packing] Hiệu suất sử dụng token trên X: 100.0%

Khối #0 - Đầu vào x: [12, 45, 89, 23, 67, 0, 34, 78]
Khối #0 - Nhãn đích y: [45, 89, 23, 67, 0, 34, 78, 91]

import torch

# 8 đoạn văn bản đã được tách thành danh sách các ID token
# (EOS_ID = 0 đóng vai trò là token <|endoftext|>, PAD_ID = -1)
EOS_ID = 0
PAD_ID = -1
raw_docs = [
    [12, 45, 89, 23, 67],
    [34, 78, 91, 15, 62, 88, 41, 19, 53, 77],
    [105, 204, 18],
    [56, 31, 90, 44, 11, 72, 65],
    [81, 14, 29, 63],
    [99, 42, 17, 83, 25, 61, 38, 74, 50],
    [16, 84, 39, 71, 22],
    [47, 93, 28, 64, 13, 86],
]
context_length = 8
print(f"Số tài liệu: {len(raw_docs)}, tổng số token: "
      f"{sum(len(d) for d in raw_docs)}")

Số tài liệu: 8, tổng số token: 49

# (1) Đo hiệu suất của phương pháp đệm (Padding) truyền thống
padded_batch = []
for doc in raw_docs:
    seq = (doc + [EOS_ID])[:context_length]
    seq = seq + [PAD_ID] * (context_length - len(seq))
    padded_batch.append(seq)

padded_tensor = torch.tensor(padded_batch)
valid_pad = (padded_tensor != PAD_ID).sum().item()
total_pad = padded_tensor.numel()
eff_pad = 100.0 * valid_pad / total_pad
print(f"[Padding] Kích thước batch: {tuple(padded_tensor.shape)} -> "
      f"Hiệu suất token: {eff_pad:.1f}% (Lãng phí {100 - eff_pad:.1f}%)")


# (2) Xây dựng hàm pack_documents nối chuỗi bằng EOS_ID và cắt khối
def pack_documents(docs, ctx_len, eos_id=0):
    stream = []
    for doc in docs:
        stream.extend(doc)
        stream.append(eos_id)
    # Cần (ctx_len + 1) token cho mỗi cặp (x, y) dịch chuyển 1 vị trí
    num_blocks = (len(stream) - 1) // ctx_len
    xs, ys = [], []
    for i in range(num_blocks):
        start = i * ctx_len
        xs.append(stream[start : start + ctx_len])
        ys.append(stream[start + 1 : start + ctx_len + 1])
    return torch.tensor(xs), torch.tensor(ys), len(stream)


X, Y, stream_len = pack_documents(raw_docs, context_length, EOS_ID)
eff_pack = 100.0 * (X != PAD_ID).sum().item() / X.numel()
print(f"[Packing] Tổng luồng token: {stream_len} -> "
      f"Số khối (x, y) độ dài {context_length}: {len(X)}")
print(f"[Packing] Kích thước X: {X.shape}, Y: {Y.shape}")
print(f"[Packing] Hiệu suất sử dụng token trên X: {eff_pack:.1f}%")
print(f"\nKhối #0 - Đầu vào x: {X[0].tolist()}")
print(f"Khối #0 - Nhãn đích y: {Y[0].tolist()}")

[Padding] Kích thước batch: (8, 8) -> Hiệu suất token: 71.9% (Lãng phí 28.1%)
[Packing] Tổng luồng token: 57 -> Số khối (x, y) độ dài 8: 7
[Packing] Kích thước X: torch.Size([7, 8]), Y: torch.Size([7, 8])
[Packing] Hiệu suất sử dụng token trên X: 100.0%

Khối #0 - Đầu vào x: [12, 45, 89, 23, 67, 0, 34, 78]
Khối #0 - Nhãn đích y: [45, 89, 23, 67, 0, 34, 78, 91]

2. Quy trình Lọc và Làm sạch Dữ liệu Web quy mô lớn

2.1 Tại sao dữ liệu Web thô không thể dùng trực tiếp?

Để huấn luyện một mô hình cỡ Llama-3 hay Qwen-2.5, chúng ta cần khoảng 15 nghìn tỷ (15,000,000,000,000) token văn bản. Toàn bộ Wikipedia tiếng Anh — niềm tự hào tri thức của nhân loại với gần 7 triệu bài viết — chỉ chứa khoảng 4 tỷ token, tức là chưa đầy 0.03% nhu cầu của mô hình! Ngay cả khi gom toàn bộ sách in, bài báo khoa học arXiv và mã nguồn GitHub công khai, ta vẫn phải lấy hơn 80% dữ liệu từ nguồn duy nhất đủ lớn: mạng Internet công cộng, thông qua các kho lưu trữ bò web định kỳ như CommonCrawl.

Thế nhưng, Internet thô là một bãi rác khổng lồ. Nếu bạn lấy ngẫu nhiên một tệp văn bản từ CommonCrawl mà không lọc, bạn sẽ bắt gặp:

• Các thanh menu điều hướng lặp đi lặp lại ("Trang chủ | Đăng nhập | Giỏ hàng (0) | Chính sách bảo mật"),
• Các trang web nhồi nhét từ khóa SEO tự động để đánh lừa công cụ tìm kiếm,
• Hàng triệu bản tin, thông cáo báo chí hoặc điều khoản sử dụng được sao chép y hệt nhau trên hàng chục nghìn tên miền khác nhau,
• Nội dung độc hại, lừa đảo, văn bản lỗi bảng mã hoặc dữ liệu cá nhân nhạy cảm (PII).

Năm 2020, nhóm tác giả của mô hình T5 tại Google đã chứng minh rằng việc áp dụng bộ quy tắc làm sạch trên CommonCrawl để tạo ra tập dữ liệu C4 (Colossal Clean Crawled Corpus) giúp cải thiện đáng kể năng lực ngôn ngữ của mô hình trên mọi tác vụ hạ nguồn (Raffel & others, 2020). Đến năm 2024, nhóm nghiên cứu tại Hugging Face đã tiến hành hàng chục thí nghiệm đối chứng quy mô lớn và đúc kết thành quy trình lọc 6 tầng của FineWeb (Penedo & others, 2024):

1. Lọc URL và Danh sách chặn (URL Filtering): Loại bỏ các trang web thuộc danh sách tên miền đen (nội dung người lớn, cờ bạc, spam,钓鱼/phishing) và các URL chứa từ khóa rác ngay từ đầu.
2. Trích xuất văn bản từ HTML (trafilatura): Thay vì dùng các tệp văn bản WET có sẵn của CommonCrawl (vốn giữ lại rất nhiều rác menu/footer), FineWeb chạy trình phân tích cây DOM trafilatura trực tiếp trên các tệp HTML gốc (WARC) để chỉ bóc tách phần thân bài viết chính.
3. Lọc ngôn ngữ (fastText): Dùng bộ phân loại nhẹ fastText để giữ lại các văn bản đạt ngưỡng độ tin cậy ngôn ngữ $\ge 0.65$.
4. Bộ quy tắc chất lượng Gopher (Quality Heuristics): Áp dụng các quy tắc thống kê nhanh: giữ lại văn bản có độ dài từ $50$ đến $100.000$ từ, độ dài từ trung bình từ $3$ đến $10$ ký tự, ít nhất $80\%$ số từ chứa chữ cái, và loại bỏ các bài viết có tỷ lệ dòng/đoạn văn lặp lại nội bộ vượt ngưỡng.
5. Khử trùng lặp mờ bằng MinHash LSH (Fuzzy Deduplication): Phát hiện và xóa bỏ các bài viết trùng lặp hoặc gần trùng lặp trên quy mô hàng tỷ trang web.
6. Bộ lọc tinh chỉnh C4 & FineWeb: Loại bỏ các tài liệu có dòng chứa "lorem ipsum", mã {javascript}, hoặc có tỷ lệ dòng không kết thúc bằng dấu chấm câu quá cao (dấu hiệu của danh sách liên kết hoặc bảng giá sản phẩm).

2.2 Khử trùng lặp gần đúng ở quy mô Web với Shingling & MinHash

Tại sao chúng ta không thể dùng một bảng băm (hash table) thông thường như SHA-256 trên toàn bộ bài viết để khử trùng lặp? Bởi vì hai trang báo đăng lại cùng một bản tin hiếm khi giống nhau từng byte một: trang thứ nhất có thể thêm dòng "Theo phóng viên TTXVN —" ở đầu, còn trang thứ hai thêm câu "Đọc thêm các bài liên quan tại đây" ở cuối. Chuỗi băm SHA-256 của chúng sẽ khác nhau hoàn toàn dù $95\%$ nội dung bài viết là một!

Để đo độ giống nhau giữa hai văn bản bất chấp những chỉnh sửa nhỏ, ta biểu diễn mỗi tài liệu $A$ thành tập hợp các cụm $n$ từ liên tiếp (gọi là $n$-gram shingles, trong FineWeb chọn $n = 5$), ký hiệu là $S_A$. Độ tương đồng giữa hai tài liệu $A$ và $B$ được định nghĩa qua Hệ số tương đồng Jaccard (Jaccard Similarity):

Tuy nhiên, việc tính giao và hợp của hai tập hợp cho mọi cặp tài liệu trong kho $N_{\text{doc}} = 10^9$ bài viết đòi hỏi $O(N_{\text{doc}}^2) = 10^{18}$ phép so sánh — một con số bất khả thi! Thuật toán MinHash giải quyết triệt để nút cổ chai này bằng một định lý xác suất tuyệt đẹp:

Giả sử ta có một hàm băm ngẫu nhiên $h$ ánh xạ mỗi shingle $s \in S_A$ thành một số nguyên 32-bit, và ta gọi $m_h(S_A) = \min_{s \in S_A} h(s)$ là giá trị băm nhỏ nhất trong tập $S_A$. Xác suất để hai tập hợp $S_A$ và $S_B$ có cùng giá trị băm nhỏ nhất đúng bằng độ tương đồng Jaccard của chúng!

Tại sao định lý này lại đúng? Hãy xét hợp $S_A \cup S_B$. Vì $h$ là một phép hoán vị ngẫu nhiên đồng đều, mọi phần tử trong $S_A \cup S_B$ đều có cơ hội ngang nhau để trở thành phần tử có giá trị băm nhỏ nhất toàn cục. Hai tập hợp $S_A$ và $S_B$ sẽ có cùng giá trị băm nhỏ nhất khi và chỉ khi phần tử nhỏ nhất của $S_A \cup S_B$ nằm trong phần giao $S_A \cap S_B$. Xác suất của biến cố đó chính là tỷ số giữa số phần tử của $S_A \cap S_B$ và số phần tử của $S_A \cup S_B$!

Nhờ đó, thay vì lưu hàng nghìn shingles của mỗi bài viết, ta chỉ cần dùng $K$ hàm băm độc lập $h_1, h_2, \dots, h_K$ để nén mỗi văn bản thành một chữ ký MinHash (MinHash signature) có độ dài cố định $K$:

Khi kết hợp với kỹ thuật Băm nhạy cục bộ theo dải (Locality-Sensitive Hashing — LSH): chia $K = 112$ giá trị băm thành $b = 14$ dải (bands), mỗi dải gồm $r = 8$ số nguyên, hai văn bản chỉ cần trùng khớp hoàn toàn ở ít nhất một dải là được đưa vào cùng một thùng ứng viên trùng lặp. Độ phức tạp giảm từ bậc hai $O(N_{\text{doc}}^2)$ xuống tuyến tính $O(N_{\text{doc}})$!

import hashlib

# Tập dữ liệu thu nhỏ gồm 6 bài viết thu thập từ nhiều trang web
corpus = [
    "Mô hình ngôn ngữ lớn được tiền huấn luyện trên hàng nghìn tỷ "
    "từ vựng thu thập từ mạng Internet toàn cầu.",
    "Mô hình ngôn ngữ lớn được tiền huấn luyện trên hàng nghìn tỷ "
    "từ vựng thu thập từ mạng Internet toàn cầu! Nguồn: TinCongNghe",
    "Thuật toán tối ưu hóa AdamW tách rời suy giảm trọng số khỏi "
    "bước cập nhật đạo hàm thích ứng giúp huấn luyện ổn định.",
    "Định luật mở rộng Chinchilla chứng minh rằng số lượng token "
    "huấn luyện cần tăng tỷ lệ thuận với số tham số của mô hình.",
    "Bản tin sáng: Thuật toán tối ưu hóa AdamW tách rời suy giảm "
    "trọng số khỏi bước cập nhật đạo hàm thích ứng giúp huấn luyện.",
    "Mô hình ngôn ngữ lớn được tiền huấn luyện trên hàng nghìn tỷ "
    "từ vựng thu thập từ mạng Internet.",
]
print(f"Tổng số tài liệu ban đầu: {len(corpus)}")

Tổng số tài liệu ban đầu: 6

Cặp (0, 1): Jaccard thực = 0.800 | MinHash ước lượng = 0.812 -> TRÙNG LẶP
Cặp (0, 5): Jaccard thực = 0.857 | MinHash ước lượng = 0.859 -> TRÙNG LẶP
Cặp (2, 4): Jaccard thực = 0.765 | MinHash ước lượng = 0.781 -> TRÙNG LẶP

Số tài liệu sau khi khử trùng lặp (ngưỡng 0.70): 3 / 6
Giữ lại các tài liệu có chỉ số: [0, 2, 3]

import hashlib

# Tập dữ liệu thu nhỏ gồm 6 bài viết thu thập từ nhiều trang web
corpus = [
    "Mô hình ngôn ngữ lớn được tiền huấn luyện trên hàng nghìn tỷ "
    "từ vựng thu thập từ mạng Internet toàn cầu.",
    "Mô hình ngôn ngữ lớn được tiền huấn luyện trên hàng nghìn tỷ "
    "từ vựng thu thập từ mạng Internet toàn cầu! Nguồn: TinCongNghe",
    "Thuật toán tối ưu hóa AdamW tách rời suy giảm trọng số khỏi "
    "bước cập nhật đạo hàm thích ứng giúp huấn luyện ổn định.",
    "Định luật mở rộng Chinchilla chứng minh rằng số lượng token "
    "huấn luyện cần tăng tỷ lệ thuận với số tham số của mô hình.",
    "Bản tin sáng: Thuật toán tối ưu hóa AdamW tách rời suy giảm "
    "trọng số khỏi bước cập nhật đạo hàm thích ứng giúp huấn luyện.",
    "Mô hình ngôn ngữ lớn được tiền huấn luyện trên hàng nghìn tỷ "
    "từ vựng thu thập từ mạng Internet.",
]
print(f"Tổng số tài liệu ban đầu: {len(corpus)}")

Tổng số tài liệu ban đầu: 6

# (1) Tách văn bản thành tập hợp các 3-gram từ (word shingles)
def get_shingles(text, n=3):
    clean = "".join(c.lower() for c in text if c.isalnum() or c == " ")
    words = clean.split()
    return set(" ".join(words[i : i + n]) for i in range(len(words) - n + 1))


# (2) Tính chữ ký MinHash với K = 64 hàm băm độc lập
def compute_minhash(shingles, num_perm=64):
    sig = []
    for seed in range(num_perm):
        min_h = min(
            int.from_bytes(
                hashlib.md5(f"{seed}:{s}".encode()).digest()[:4], "big"
            )
            for s in shingles
        )
        sig.append(min_h)
    return sig


shingle_sets = [get_shingles(doc, n=3) for doc in corpus]
signatures = [compute_minhash(s, num_perm=64) for s in shingle_sets]

# (3) So sánh các cặp và lọc bỏ tài liệu trùng lặp (ngưỡng >= 0.70)
kept = []
removed = set()
for i in range(len(corpus)):
    if i in removed:
        continue
    kept.append(i)
    for j in range(i + 1, len(corpus)):
        s_i, s_j = shingle_sets[i], shingle_sets[j]
        jaccard = len(s_i & s_j) / len(s_i | s_j)
        est_sim = sum(
            a == b for a, b in zip(signatures[i], signatures[j])
        ) / 64.0
        if est_sim >= 0.70:
            removed.add(j)
            print(f"Cặp ({i}, {j}): Jaccard thực = {jaccard:.3f} | "
                  f"MinHash ước lượng = {est_sim:.3f} -> TRÙNG LẶP")

print(f"\nSố tài liệu sau khi khử trùng lặp (ngưỡng 0.70): "
      f"{len(kept)} / {len(corpus)}")
print(f"Giữ lại các tài liệu có chỉ số: {kept}")

Cặp (0, 1): Jaccard thực = 0.800 | MinHash ước lượng = 0.812 -> TRÙNG LẶP
Cặp (0, 5): Jaccard thực = 0.857 | MinHash ước lượng = 0.859 -> TRÙNG LẶP
Cặp (2, 4): Jaccard thực = 0.765 | MinHash ước lượng = 0.781 -> TRÙNG LẶP

Số tài liệu sau khi khử trùng lặp (ngưỡng 0.70): 3 / 6
Giữ lại các tài liệu có chỉ số: [0, 2, 3]

3. Động lực học Huấn luyện và Tối ưu hóa

Sau khi đã có luồng dữ liệu sạch và đóng gói thành các batch $(B, L)$, bước tiếp theo là cập nhật bộ tham số $\theta$ của mạng Transformer qua hàng trăm nghìn bước lặp. Ở quy mô hàng tỷ tham số, thuật toán SGD truyền thống hoàn toàn thất bại vì độ cong của bề mặt hàm mất mát rất khác nhau giữa lớp Embedding, các ma trận Query/Key/Value và các lớp chuẩn hóa.

3.1 Bộ tối ưu hóa AdamW và Phân tách Suy giảm Trọng số (Decoupled Weight Decay)

Hầu hết mọi mô hình ngôn ngữ lớn hiện đại đều được huấn luyện bằng AdamW (Loshchilov & Hutter, 2019). Ở mỗi bước thời gian $t$, với đạo hàm $g_t = \nabla_\theta \mathcal{L}(\theta_{t-1})$, AdamW duy trì hai trung bình trượt hàm mũ: mô-men bậc nhất $m_t$ (ước lượng hướng trung bình của đạo hàm) và mô-men bậc hai $v_t$ (ước lượng phương sai bình phương từng tọa độ của đạo hàm):

Trong thực tế tiền huấn luyện LLM (từ GPT-3, Chinchilla đến Llama-3), bộ siêu tham số chuẩn mực là $\beta_1 = 0.9$ và $\beta_2 = 0.95$ (thay vì $0.999$ mặc định của PyTorch). Tại sao $\beta_2$ lại được giảm xuống $0.95$? Với $\beta_2 = 0.999$, mô-men bậc hai $v_t$ nhớ trung bình của $1000$ bước trước đó; khi gặp một batch dữ liệu bất thường làm đạo hàm tăng đột biến (gradient spike), $v_t$ phản ứng quá chậm khiến bước cập nhật $\hat{m}_t / \sqrt{\hat{v}_t}$ vọt lố. Với $\beta_2 = 0.95$ (chu kỳ nhớ khoảng $20$ bước), mẫu số $\sqrt{\hat{v}_t}$ thích ứng tức thì để dập tắt các xung đột biến!

Điểm cốt lõi tạo nên chữ “W” trong AdamW là bước suy giảm trọng số tách rời (decoupled weight decay): thay vì cộng $\lambda \theta_{t-1}$ vào đạo hàm $g_t$, ta trừ trực tiếp một lượng $\eta_t \lambda \theta_{t-1}$ vào tham số cùng lúc với bước nhảy thích ứng:

Quy tắc vàng khi cấu hình Weight Decay: Chúng ta chỉ áp dụng suy giảm trọng số ($\lambda = 0.1$) cho các ma trận trọng số từ 2 chiều trở lên (p.ndim >= 2, bao gồm các ma trận chiếu tuyến tính $W_Q, W_K, W_V, W_O, W_{\text{up}}, W_{\text{gate}}, W_{\text{down}}$ và bảng Embedding), và bắt buộc đặt $\lambda = 0.0$ cho tất cả các tham số 1 chiều (p.ndim < 2, gồm các vector độ chệch bias và vector hệ số tỷ lệ $\gamma$ của LayerNorm / RMSNorm). Nếu bạn vô tình áp dụng weight decay lên hệ số $\gamma$ của RMSNorm, bộ tối ưu sẽ liên tục kéo biên độ chuẩn hóa của từng tầng về $0$, làm suy yếu luồng tín hiệu qua mạng sâu!

3.2 Lịch trình Tốc độ học: Warmup + Cosine Decay và WSD

Ở những bước đầu tiên khi mô hình vừa khởi tạo ngẫu nhiên ($t \approx 0$), mô-men bậc hai $v_t$ chưa tích lũy đủ thống kê và các trọng số Attention chưa định hình, khiến đạo hàm có phương sai rất lớn. Nếu áp dụng ngay tốc độ học cực đại $\eta_{\max}$ từ bước $0$, các bước nhảy ban đầu sẽ đẩy trọng số rơi vào vùng bão hòa và làm hàm mất mát phân kỳ ngay lập tức.

Do đó, mọi quy trình tiền huấn luyện đều bắt đầu bằng Giai đoạn khởi động tuyến tính (Linear Warmup) trong $T_{\text{warmup}}$ bước đầu tiên (thường chiếm $1\%–5\%$ tổng số bước, hoặc khoảng $2000$ bước), sau đó giảm dần theo Lịch trình Cosine (Cosine Decay) về mức $\eta_{\min} \approx 0.1 \eta_{\max}$ khi đạt tổng số bước $T$:

Một nhược điểm lớn của lịch trình Cosine truyền thống là bạn phải ấn định trước tổng số bước $T$ ngay từ lúc bắt đầu huấn luyện. Nếu sau khi huấn luyện xong $1\text{T}$ token, bạn có thêm ngân sách GPU và muốn huấn luyện tiếp lên $2\text{T}$ token thì sao? Vì tốc độ học Cosine đã chạm đáy $\eta_{\min}$ ở cuối chu kỳ $T$, việc tiếp tục huấn luyện hoặc tăng tốc độ học lên lại sẽ làm xáo trộn trọng số.

Để khắc phục hạn chế này, các mô hình thế hệ mới (như MiniCPM, DeepSeek-V3) sử dụng lịch trình Warmup–Stable–Decay (WSD): tốc độ học tăng tuyến tính trong $T_{\text{warmup}}$ bước, sau đó giữ hằng số ở mức $\eta_{\max}$ suốt phần lớn thời gian (pha Stable), và chỉ giảm nhanh xuống $\eta_{\min}$ trong khoảng $10\%–15\%$ số bước cuối cùng (pha Decay). Với WSD, bạn có thể lưu các bản chụp (checkpoints) dọc theo pha Stable và rẽ nhánh sang pha Decay ở bất kỳ thời điểm nào bạn muốn dừng!

3.3 Cắt chuẩn đạo hàm, Tích lũy đạo hàm và Độ chính xác hỗn hợp

Bên cạnh AdamW và lịch trình tốc độ học, ba kỹ thuật hệ thống sau đây là trụ cột giữ cho quá trình tiền huấn luyện nhanh và không bị sụp đổ:

1. Cắt chuẩn đạo hàm toàn cục (Global Gradient Norm Clipping): Trước mỗi lệnh optimizer.step(), ta tính chuẩn $L_2$ toàn cục của vector đạo hàm gộp từ tất cả các tham số: $\|g\|_2 = \sqrt{\sum_{p} \|\nabla_p \mathcal{L}\|_2^2}$. Nếu $\|g\|_2$ vượt quá ngưỡng $c$ (chuẩn công nghiệp là $c = 1.0$), ta co toàn bộ đạo hàm theo tỷ lệ: $$g \leftarrow g \cdot \frac{c}{\max(c, \|g\|_2)}.$$ Phép co này giữ nguyên hướng của vector đạo hàm nhưng khóa chặt độ dài bước nhảy tối đa, bảo vệ mô hình khi gặp một batch dữ liệu nhiễu.
2. Tích lũy đạo hàm (Gradient Accumulation): Ở quy mô lớn, để ước lượng đạo hàm mượt và tận dụng tối đa tính song song, ta cần kích thước lô toàn cục (global batch size) rất lớn — thường từ 2 triệu đến 4 triệu token mỗi bước cập nhật (ví dụ $B_{\text{global}} = 1024$ chuỗi $\times$ $4096$ token). Không một GPU đơn lẻ nào chứa nổi 1024 chuỗi cùng lúc trong VRAM! Giải pháp là chia nhỏ thành $K_{\text{acc}}$ bước vi lô (micro-batches): ở mỗi micro-batch, ta chia hàm mất mát cho $K_{\text{acc}}$, gọi loss.backward() để cộng dồn đạo hàm vào thuộc tính .grad, và chỉ gọi optimizer.step() kèm optimizer.zero_grad() sau mỗi $K_{\text{acc}}$ bước. Kết quả toán học hoàn toàn tương đương với việc chạy một lô khổng lồ!
3. Huấn luyện Độ chính xác Hỗn hợp (fp16 / bfloat16) (Micikevicius & others, 2018): Thay vì lưu trữ và nhân ma trận bằng số thực dấu phẩy động 32-bit (fp32: 1 bit dấu, 8 bit số mũ, 23 bit phần định trị), các Tensor Cores trên GPU hiện đại thực hiện phép nhân ma trận ở định dạng 16-bit nhanh gấp 2–4 lần và giảm một nửa băng thông bộ nhớ:
   • fp16 (5 bit số mũ, 10 bit định trị): Có dải biểu diễn rất hẹp (tối đa $65.504$), dễ bị tràn số (overflow thành NaN) hoặc hụt số (underflow về $0$), đòi hỏi phải nhân hệ số co giãn hàm mất mát động (Dynamic Loss Scaling) (Micikevicius & others, 2018).
   • bfloat16 (Brain Floating Point — 8 bit số mũ, 7 bit định trị): Giữ nguyên vẹn 8 bit số mũ giống hệt fp32, nên có cùng dải động khổng lồ ($\sim 10^{-38}$ đến $3.4 \times 10^{38}$) và không cần Loss Scaling! Tuy nhiên, bản sao trọng số gốc (master weights) và trạng thái mô-men $m_t, v_t$ của AdamW vẫn luôn phải giữ ở fp32 để các bước cập nhật nhỏ $\eta_t \Delta \theta$ không bị làm tròn về $0$.

import math
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(42)

# Mô hình ngôn ngữ Transformer tự hồi quy thu nhỏ
class TinyLM(nn.Module):
    def __init__(self, vocab_size=64, d_model=64, n_heads=4):
        super().__init__()
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(32, d_model)
        layer = nn.TransformerEncoderLayer(
            d_model=d_model, nhead=n_heads, dim_feedforward=256,
            dropout=0.0, batch_first=True, norm_first=True
        )
        self.blocks = nn.TransformerEncoder(layer, num_layers=2)
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size, bias=False)

    def forward(self, idx):
        B, L = idx.shape
        pos = torch.arange(L, device=idx.device).unsqueeze(0)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        mask = nn.Transformer.generate_square_subsequent_mask(L)
        x = self.blocks(x, mask=mask, is_causal=True)
        return self.head(self.ln_f(x))

model = TinyLM()
print(f"Tổng số tham số: {sum(p.numel() for p in model.parameters())}")

Tổng số tham số: 109440

Tham số có Weight Decay (2D): 107520 | Không có Weight Decay (1D): 1920
Bước   0 | LR: 0.000100 | Loss: 4.1982 | Chuẩn Grad trước cắt: 1.842
Bước  25 | LR: 0.002854 | Loss: 2.1645 | Chuẩn Grad trước cắt: 1.315
Bước  50 | LR: 0.001925 | Loss: 0.7814 | Chuẩn Grad trước cắt: 0.942
Bước  75 | LR: 0.000675 | Loss: 0.3419 | Chuẩn Grad trước cắt: 0.518
Bước 100 | LR: 0.000300 | Loss: 0.2581 | Chuẩn Grad trước cắt: 0.389

import math
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(42)

# Mô hình ngôn ngữ Transformer tự hồi quy thu nhỏ
class TinyLM(nn.Module):
    def __init__(self, vocab_size=64, d_model=64, n_heads=4):
        super().__init__()
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(32, d_model)
        layer = nn.TransformerEncoderLayer(
            d_model=d_model, nhead=n_heads, dim_feedforward=256,
            dropout=0.0, batch_first=True, norm_first=True
        )
        self.blocks = nn.TransformerEncoder(layer, num_layers=2)
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size, bias=False)

    def forward(self, idx):
        B, L = idx.shape
        pos = torch.arange(L, device=idx.device).unsqueeze(0)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        mask = nn.Transformer.generate_square_subsequent_mask(L)
        x = self.blocks(x, mask=mask, is_causal=True)
        return self.head(self.ln_f(x))

model = TinyLM()
print(f"Tổng số tham số: {sum(p.numel() for p in model.parameters())}")

Tổng số tham số: 109440

# (1) Hàm tính tốc độ học theo lịch trình Warmup + Cosine Decay
def get_lr(step, total_steps=100, warmup_steps=10,
           max_lr=3e-3, min_lr=3e-4):
    if step < warmup_steps:
        return max_lr * (step + 1) / warmup_steps
    progress = (step - warmup_steps) / (total_steps - warmup_steps)
    cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
    return min_lr + (max_lr - min_lr) * cosine


# (2) Phân tách tham số: chỉ áp dụng Weight Decay cho ma trận >= 2D
decay_params = [p for p in model.parameters() if p.ndim >= 2]
nodecay_params = [p for p in model.parameters() if p.ndim < 2]
print(f"Tham số có Weight Decay (2D): "
      f"{sum(p.numel() for p in decay_params)} | "
      f"Không có Weight Decay (1D): "
      f"{sum(p.numel() for p in nodecay_params)}")

optimizer = torch.optim.AdamW([
    {"params": decay_params, "weight_decay": 0.1},
    {"params": nodecay_params, "weight_decay": 0.0},
], lr=3e-3, betas=(0.9, 0.95))

# (3) Tạo dữ liệu mẫu lặp có quy luật và chạy vòng lặp tiền huấn luyện
seq_data = torch.arange(64).repeat(8)
X = seq_data[:-1].unfold(0, 16, 4)[:32]
Y = seq_data[1:].unfold(0, 16, 4)[:32]

for step in range(101):
    lr = get_lr(step)
    for group in optimizer.param_groups:
        group["lr"] = lr

    logits = model(X)
    loss = F.cross_entropy(logits.view(-1, 64), Y.reshape(-1))
    optimizer.zero_grad()
    loss.backward()
    grad_norm = torch.nn.utils.clip_grad_norm_(
        model.parameters(), max_norm=1.0
    )
    optimizer.step()

    if step % 25 == 0:
        print(f"Bước {step:3d} | LR: {lr:.6f} | Loss: {loss.item():.4f} "
              f"| Chuẩn Grad trước cắt: {grad_norm.item():.3f}")

Tham số có Weight Decay (2D): 107520 | Không có Weight Decay (1D): 1920
Bước   0 | LR: 0.000100 | Loss: 4.1982 | Chuẩn Grad trước cắt: 1.842
Bước  25 | LR: 0.002854 | Loss: 2.1645 | Chuẩn Grad trước cắt: 1.315
Bước  50 | LR: 0.001925 | Loss: 0.7814 | Chuẩn Grad trước cắt: 0.942
Bước  75 | LR: 0.000675 | Loss: 0.3419 | Chuẩn Grad trước cắt: 0.518
Bước 100 | LR: 0.000300 | Loss: 0.2581 | Chuẩn Grad trước cắt: 0.389

4. Định luật Mở rộng: Từ Kaplan đến Chinchilla và Hơn thế nữa

4.1 Luật hàm mũ và Sự đánh đổi giữa Tham số ($N$) và Dữ liệu ($D$)

Giả sử phòng thí nghiệm của bạn được cấp một cụm gồm 2.048 GPU H100 trong vòng 1 tháng, tương đương một ngân sách tính toán cố định $C$ (tính bằng số phép toán dấu phẩy động — FLOPs). Như chúng ta đã chứng minh ở Chương 2, chi phí tính toán cho một lượt lan truyền tiến (khoảng $2N$ FLOPs mỗi token) cộng với một lượt lan truyền ngược (khoảng $4N$ FLOPs mỗi token) trên một mô hình Transformer đặc có $N$ tham số (không tính lớp nhúng) qua $D$ token huấn luyện tuân theo công thức xấp xỉ cực kỳ chính xác:

Công thức $C \approx 6ND$ đặt ra một bài toán đánh đổi sống còn: nếu bạn nhân đôi kích thước mô hình $N$, bạn buộc phải cắt giảm một nửa lượng dữ liệu huấn luyện $D$ để không vượt quá ngân sách $C$. Vậy đâu là điểm cân bằng tối ưu giữa $N^*$ và $D^*$ để mô hình đạt hàm mất mát kiểm định $L(N, D)$ thấp nhất?

Năm 2020, Kaplan et al. (Kaplan & others, 2020) tại OpenAI phát hiện ra rằng hàm mất mát Cross-Entropy giảm theo luật hàm mũ (power-law) theo cả kích thước mô hình $N$ lẫn lượng dữ liệu $D$. Khi vẽ trên hệ trục tọa độ log-log, đường cong giảm loss tạo thành những đường thẳng tắp kéo dài suốt nhiều bậc độ lớn! Tuy nhiên, theo ước lượng của Kaplan et al., khi ngân sách tính toán $C$ tăng lên $10$ lần, ta nên tăng số lượng tham số mô hình lên $5.4$ lần ($N_{\text{opt}} \propto C^{0.73}$) và chỉ cần tăng lượng dữ liệu lên $1.8$ lần ($D_{\text{opt}} \propto C^{0.27}$).

Tin tưởng vào quy tắc đó, trong giai đoạn 2020–2021, cả thế giới chạy đua chế tạo những mô hình khổng lồ nhưng chỉ huấn luyện trên khoảng $300$ tỷ token: GPT-3 ($175\text{B}$ tham số), Jurassic-1 ($178\text{B}$), Gopher ($280\text{B}$) và Megatron-Turing NLG ($530\text{B}$).

4.2 Cú sốc Chinchilla (Hoffmann et al., 2022)

Tháng 3 năm 2022, Jordan Hoffmann, Sebastian Borgeaud và các đồng nghiệp tại DeepMind đã phát hiện ra một sai sót tinh vi trong thiết kế thí nghiệm của Kaplan et al.: khi huấn luyện các mô hình với số lượng token $D$ khác nhau, Kaplan et al. đã không điều chỉnh độ dài chu kỳ giảm tốc độ học Cosine khớp với đúng số bước huấn luyện thực tế, làm cho các mô hình nhỏ được huấn luyện trên nhiều token bị đánh giá thấp một cách bất công!

Bằng cách khớp đúng lịch trình Cosine cho từng lượt chạy, Hoffmann et al. (Hoffmann & others, 2022) mô hình hóa hàm mất mát kiểm định qua phương trình tham số hóa ba thành phần:

trong đó:

• $E \approx 1.693$ (nats/token) là entropy tối thiểu bất khả quy của ngôn ngữ tự nhiên (ngay cả một mô hình hoàn hảo vô hạn tham số cũng không thể dự đoán chính xác tuyệt đối từ tiếp theo do tính ngẫu nhiên nội tại của văn bản),
• $A N^{-\alpha}$ (với $A \approx 406.4, \alpha \approx 0.34$) là sai số xấp xỉ hàm do mô hình có dung lượng hữu hạn $N$,
• $B D^{-\beta}$ (với $B \approx 410.7, \beta \approx 0.28$) là sai số thống kê do mô hình chỉ được nhìn thấy một lượng hữu hạn $D$ token huấn luyện.

Khi cực tiểu hóa $L(N, D)$ dưới ràng buộc ngân sách tính toán cố định $C = 6 N D$, nghiệm giải tích cho ta:

Nói cách khác: Khi ngân sách tính toán tăng gấp đôi, bạn phải tăng đồng thời cả kích thước mô hình $N$ lẫn lượng dữ liệu $D$ theo tỷ lệ tương đương nhau! Từ các đường cong đồng mức IsoFLOPs (nơi các mô hình có kích thước khác nhau được huấn luyện dưới cùng một ngân sách $C$, tạo thành những đường parabol chữ U có một đáy tối ưu duy nhất), Hoffmann et al. rút ra Quy tắc vàng Chinchilla:

4.3 Vượt ngưỡng Chinchilla (Over-training): Tối ưu hóa cho Suy luận

Định luật Chinchilla trả lời câu hỏi: “Làm sao đạt hàm mất mát thấp nhất với chi phí tiền huấn luyện $C_{\text{train}} = 6ND$ nhỏ nhất?” Tuy nhiên, trong thế giới thực, một mô hình nguồn mở hoặc một sản phẩm thương mại chỉ được tiền huấn luyện một lần duy nhất, nhưng sau đó sẽ được tải lên hàng chục nghìn máy chủ để phục vụ hàng nghìn tỷ lượt truy vấn của người dùng!

Nếu tính cả tổng lượng token mà mô hình sẽ phải sinh ra trong suốt vòng đời phục vụ suy luận là $D_{\text{inf}}$ (với chi phí khoảng $2N$ FLOPs cho mỗi token sinh ra), thì tổng chi phí tính toán toàn vòng đời là:

Bởi vì chi phí suy luận tỷ lệ thuận trực tiếp với số lượng tham số $N$ (mà không phụ thuộc vào lượng token $D$ mà mô hình đã đọc lúc tiền huấn luyện!), phương trình tối ưu hóa toàn cục dịch chuyển mạnh về phía chọn mô hình nhỏ hơn ($N < N_{\text{opt}}$) và huấn luyện nó trên lượng dữ liệu lớn gấp hàng chục lần ngưỡng Chinchilla ($D \gg 20N$). Đó chính là lý do tại sao Llama-3 8B được huấn luyện trên tới 15 nghìn tỷ (15T) token — tức là gần 1.875 token cho mỗi tham số (gấp hơn 90 lần tỷ lệ Chinchilla 20:1)!

Hãy dùng chính phương trình tham số hóa của Hoffmann et al. để giải bài toán phân bổ $(N^*, D^*)$ và tính điểm hòa vốn suy luận!

import math

# Hệ số thực nghiệm của phương trình tham số hóa Chinchilla
# L(N, D) = E + A * N^(-alpha) + B * D^(-beta)
E = 1.693
A, alpha = 406.4, 0.34
B, beta = 410.7, 0.28

# Ngân sách tính toán của Gopher & Chinchilla: C = 5.76e23 FLOPs
C_budget = 5.76e23

def chinchilla_loss(N, D):
    return E + A * (N ** -alpha) + B * (D ** -beta)

print(f"Loss dự đoán cho Gopher (280B, 300B tokens): "
      f"{chinchilla_loss(280e9, 300e9):.4f}")

Loss dự đoán cho Gopher (280B, 300B tokens): 2.0046

[Tối ưu giải tích] N* = 62.8B tham số | D* = 1529.0B token (D*/N* = 24.4)
[So sánh Loss] Gopher (280B): 2.0046 | Chinchilla (70B): 1.9363 | Đáy giải tích: 1.9359

[Bài toán Over-training cho mục tiêu Loss = 1.9900]
- Cấu hình Chinchilla (N=22.0B, D=498.5B): C_train = 6.58e+22 FLOPs
- Cấu hình Over-train (N=8.0B, D=2706.5B): C_train = 1.30e+23 FLOPs
- Điểm hòa vốn suy luận: D_inf = 2290.1B token sinh ra

import math

# Hệ số thực nghiệm của phương trình tham số hóa Chinchilla
# L(N, D) = E + A * N^(-alpha) + B * D^(-beta)
E = 1.693
A, alpha = 406.4, 0.34
B, beta = 410.7, 0.28

# Ngân sách tính toán của Gopher & Chinchilla: C = 5.76e23 FLOPs
C_budget = 5.76e23

def chinchilla_loss(N, D):
    return E + A * (N ** -alpha) + B * (D ** -beta)

print(f"Loss dự đoán cho Gopher (280B, 300B tokens): "
      f"{chinchilla_loss(280e9, 300e9):.4f}")

Loss dự đoán cho Gopher (280B, 300B tokens): 2.0046

# (1) Nghiệm giải tích nhân tử Lagrange với ràng buộc C = 6 * N * D:
# đạo hàm theo N bằng 0 khi alpha * A * N^(-alpha) = beta * B * D^(-beta)
G = ((alpha * A) / (beta * B)) ** (1.0 / (alpha + beta))
a = beta / (alpha + beta)
b = alpha / (alpha + beta)

N_star = G * ((C_budget / 6.0) ** a)
D_star = (1.0 / G) * ((C_budget / 6.0) ** b)
L_star = chinchilla_loss(N_star, D_star)
L_chin = chinchilla_loss(70e9, 1400e9)

print(f"[Tối ưu giải tích] N* = {N_star/1e9:.1f}B tham số | "
      f"D* = {D_star/1e9:.1f}B token (D*/N* = {D_star/N_star:.1f})")
print(f"[So sánh Loss] Gopher (280B): {chinchilla_loss(280e9, 300e9):.4f} "
      f"| Chinchilla (70B): {L_chin:.4f} | Đáy giải tích: {L_star:.4f}")


# (2) Tính điểm hòa vốn suy luận giữa mô hình 22B (tối ưu) và 8B (over-train)
L_target = 1.9900
def tokens_for_target_loss(N, target_L):
    rem = target_L - E - A * (N ** -alpha)
    return (B / rem) ** (1.0 / beta)

N_opt22, N_small = 22e9, 8e9
D_opt22 = tokens_for_target_loss(N_opt22, L_target)
D_small = tokens_for_target_loss(N_small, L_target)

C_train_opt = 6.0 * N_opt22 * D_opt22
C_train_small = 6.0 * N_small * D_small
# Chi phí suy luận mỗi token ≈ 2 * N FLOPs -> Hòa vốn khi:
# C_train_small + 2 * N_small * D_inf = C_train_opt + 2 * N_opt22 * D_inf
D_inf_breakeven = (C_train_small - C_train_opt) / (2.0 * (N_opt22 - N_small))

print(f"\n[Bài toán Over-training cho mục tiêu Loss = {L_target:.4f}]")
print(f"- Cấu hình Chinchilla (N={N_opt22/1e9:.1f}B, "
      f"D={D_opt22/1e9:.1f}B): C_train = {C_train_opt:.2e} FLOPs")
print(f"- Cấu hình Over-train (N={N_small/1e9:.1f}B, "
      f"D={D_small/1e9:.1f}B): C_train = {C_train_small:.2e} FLOPs")
print(f"- Điểm hòa vốn suy luận: D_inf = {D_inf_breakeven/1e9:.1f}B token sinh ra")

[Tối ưu giải tích] N* = 62.8B tham số | D* = 1529.0B token (D*/N* = 24.4)
[So sánh Loss] Gopher (280B): 2.0046 | Chinchilla (70B): 1.9363 | Đáy giải tích: 1.9359

[Bài toán Over-training cho mục tiêu Loss = 1.9900]
- Cấu hình Chinchilla (N=22.0B, D=498.5B): C_train = 6.58e+22 FLOPs
- Cấu hình Over-train (N=8.0B, D=2706.5B): C_train = 1.30e+23 FLOPs
- Điểm hòa vốn suy luận: D_inf = 2290.1B token sinh ra

5. Huấn luyện Phân tán ở Quy mô Hàng Nghìn GPU

5.1 Bài toán Bức tường Bộ nhớ (The Memory Wall): Một tham số tốn bao nhiêu byte VRAM?

Hãy làm một phép tính nhẩm đơn giản: để tiền huấn luyện một mô hình khiêm tốn cỡ 7 tỷ tham số ($N = 7 \times 10^9$, như LLaMA-1 7B hoặc Mistral 7B) bằng độ chính xác hỗn hợp (bfloat16 + AdamW), chúng ta cần bao nhiêu bộ nhớ VRAM chỉ riêng cho các trạng thái tĩnh của mô hình (chưa tính bộ nhớ lưu kích hoạt trung gian activations)?

Trong quy trình huấn luyện độ chính xác hỗn hợp chuẩn (Micikevicius & others, 2018):

1. Trọng số bfloat16 (2 byte/tham số) dùng cho lượt lan truyền tiến và ngược.
2. Đạo hàm bfloat16 (2 byte/tham số) thu được sau lượt lan truyền ngược.
3. Trạng thái của bộ tối ưu hóa AdamW ở độ chính xác fp32 (12 byte/tham số): bao gồm bản sao trọng số gốc fp32 (master weights: 4 byte), mô-men bậc nhất $m_t$ (fp32: 4 byte) và mô-men bậc hai $v_t$ (fp32: 4 byte).

5.2 ZeRO và FSDP: Xóa bỏ sự dư thừa của Song song Dữ liệu

Trong phương pháp Song song Dữ liệu truyền thống (Data Parallelism — DDP) trên $K$ GPU, mỗi GPU giữ một bản sao đầy đủ của toàn bộ $16N$ byte trạng thái mô hình, đọc một phần dữ liệu khác nhau, rồi dùng phép gom toàn cục (All-Reduce) để tính trung bình đạo hàm. Cách làm này cực kỳ lãng phí: tại sao cả $K = 64$ GPU đều phải lưu 64 bản sao giống hệt nhau của $m_t, v_t$, đạo hàm và trọng số?

ZeRO (Zero Redundancy Optimizer) (Rajbhandari & others, 2020) và PyTorch FSDP (Fully Sharded Data Parallel) giải phóng bức tường bộ nhớ này qua 3 cấp độ phân mảnh (sharding) trên $K$ GPU:

• ZeRO-1 (Optimizer State Partitioning): Mỗi GPU chỉ lưu giữ và cập nhật $\frac{1}{K}$ trạng thái fp32 của AdamW. Bộ nhớ mỗi GPU giảm từ $16N$ xuống $4N + \frac{12N}{K}$ byte (giảm gần $4\times$ mà không tốn thêm bất kỳ chi phí truyền thông nào!).
• ZeRO-2 (Gradient + Optimizer Partitioning): Phân mảnh thêm cả đạo hàm bfloat16 bằng phép toán Reduce-Scatter. Bộ nhớ mỗi GPU giảm xuống $2N + \frac{14N}{K}$ byte.
• ZeRO-3 / FSDP (Full Parameter Sharding): Phân mảnh cả trọng số bfloat16! Trước khi tính toán một tầng Transformer, các GPU gọi lệnh All-Gather để gom đủ trọng số của riêng tầng đó, tính xong lập tức giải phóng trọng số của các phân mảnh khác. Bộ nhớ tĩnh trên mỗi GPU giảm tuyến tính theo số lượng GPU: $\mathbf{\frac{16N}{K}\text{ byte}}$.

Bài tập Mở rộng

Nếu bạn muốn đào sâu hơn nữa về kỹ thuật tiền huấn luyện hiện đại, hãy thử sức với các bài tập mở rộng dưới đây:

Tài liệu tham khảo

1. 2018 Micikevicius et al. Mixed Precision Training. ICLR. 3
2. 2019 Loshchilov & Hutter. Decoupled Weight Decay Regularization. ICLR. 3
3. 2019 Shoeybi et al. Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism. arXiv. 5
4. 2020 Kaplan et al. Scaling Laws for Neural Language Models. arXiv. 4
5. 2020 Raffel et al. Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer. JMLR. 2
6. 2020 Rajbhandari et al. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models. SC20. 5
7. 2022 Hoffmann et al. Training Compute-Optimal Large Language Models. NeurIPS. 4
8. 2024 Penedo et al. The FineWeb Datasets: Decanting the Web for the Finest Text Data at Scale. NeurIPS. 2