Bộ tách từ (Tokenizers): Từ chuỗi byte thô đến từ vựng của LLM

Một mạng nơ-ron không biết đọc chữ cái, từ vựng hay dấu câu; nó chỉ biết cộng và nhân các vector số thực. Vì vậy, cửa ngõ đầu tiên của mọi mô hình ngôn ngữ lớn (LLM) luôn là một quy trình hai bước:

1. Tách từ (Tokenization): Cắt chuỗi văn bản đầu vào thành các mảnh rời rạc gọi là token, rồi ánh xạ mỗi mảnh sang một mã số nguyên $x_i \in \{0, 1, \dots, |V|-1\}$ trong bộ từ vựng $V$.
2. Tra cứu vector nhúng (Embedding lookup): Lấy dòng thứ $x_i$ trong ma trận nhúng $E \in \mathbb{R}^{|V| \times d}$ để đưa vào các tầng Transformer.

Nghe có vẻ chỉ là một bước tiền xử lý kỹ thuật đơn giản, nhưng như Andrej Karpathy từng nhận xét nổi tiếng: “Rất nhiều hành vi kỳ quặc, lỗi suy luận số học và giới hạn đa ngôn ngữ của LLM thực chất bắt nguồn từ chính bộ tách từ”. Trong chương này, chúng ta sẽ trả lời hai câu hỏi nền tảng:

• Tại sao mô hình ngôn ngữ không làm việc trực tiếp trên từng từ nguyên vẹn hay từng ký tự/byte thô, mà lại hội tụ về mức từ phụ (subwords)?
• Làm thế nào để thiết kế một bộ từ vựng con vừa nén chuỗi ngắn gọn cho cơ chế Self-Attention, vừa biểu diễn trọn vẹn mọi ngôn ngữ (kể cả tiếng Việt có dấu, tiếng Trung, mã nguồn Python và công thức toán) mà không bao giờ gặp lỗi từ lạ <unk>?

1. Bài toán biểu diễn văn bản đầu vào: Từ, Ký tự hay Từ phụ?

Khi thiết kế bộ tách từ cho một mô hình ngôn ngữ, quyết định đầu tiên chúng ta phải đưa ra là chọn độ mịn (granularity) của đơn vị cơ sở: một token sẽ đại diện cho cả một từ, một ký tự đơn lẻ, hay một mảnh trung gian giữa hai thái cực đó?

1.1 Mức từ (Word-level) và lời nguyền của token <unk>

Trong phần lớn Chương 0, chúng ta đã sử dụng cách tiếp cận tự nhiên nhất với con người: tách văn bản theo khoảng trắng và dấu câu để mỗi từ là một token. Trên tập dữ liệu WikiText-2 (khoảng 2 triệu từ huấn luyện), cách này tạo ra một bộ từ vựng gồm $|V| = 33{,}277$ từ.

Tuy nhiên, khi mở rộng sang quy mô dữ liệu web hàng nghìn tỷ từ, mô hình mức từ lập tức vấp phải ba rào cản không thể vượt qua:

1. Bùng nổ kích thước từ vựng và bảng nhúng: Nếu giữ lại mọi từ xuất hiện trên Internet (bao gồm tên riêng, thuật ngữ chuyên ngành, từ viết sai chính tả, mã định danh lập trình), $|V|$ sẽ vượt quá hàng triệu từ. Với chiều ẩn $d = 4{,}096$, riêng ma trận nhúng đầu vào $E \in \mathbb{R}^{|V| \times d}$ và ma trận dự đoán đầu ra $U \in \mathbb{R}^{d \times |V|}$ của một từ vựng 1 triệu từ đã tiêuốn tới $2 \times 10^6 \times 4{,}096 \approx 8.2$ tỷ tham số!
2. Mất mát thông tin vì token <unk>: Để khống chế $|V|$ (ví dụ chỉ giữ $50{,}000$ từ phổ biến nhất), mọi từ nằm ngoài danh sách khi suy luận đều bị quy về một token duy nhất là <unk> (unknown). Khi người dùng hỏi về một tên riêng hiếm gặp như "Zendaya" hay một hàm Python như "calc_loss", mô hình chỉ nhìn thấy <unk> và hoàn toàn mù tịt về nội dung chữ viết bên trong.
3. Không chia sẻ được cấu trúc hình thái học (Morphology): Trong mô hình mức từ, "learn", "learned", "learning", "learner" và "unlearned" là 5 chỉ số nguyên hoàn toàn độc lập. Mô hình phải học 5 vector nhúng riêng rẽ từ đầu mà không hề biết chúng cùng chia sẻ gốc từ "learn". Điều này càng trầm trọng hơn với các ngôn ngữ giàu biến tố (như tiếng Đức, tiếng Nga, tiếng Thổ Nhĩ Kỳ), nơi một gốc động từ có thể biến đổi thành hàng chục dạng thức khác nhau.

1.2 Mức ký tự (Character-level) và nút cổ chai chiều dài chuỗi

Để xóa sổ hoàn toàn lỗi <unk>, ta có thể đi tới thái cực ngược lại: lấy từng ký tự (hoặc từng byte) làm đơn vị token, như mô hình LSTM mức ký tự trên tập TinyShakespeare ở mục 7.3 của Chương 0. Khi đó, bộ từ vựng chỉ gồm vài chục đến vài trăm ký hiệu, bảng nhúng nhỏ gọn tuyệt đối, và mô hình có thể đọc hay拼 viết bất kỳ từ mới nào.

Thế nhưng, cái giá phải trả lại nằm ở chiều dài chuỗi $L$:

• Trong tiếng Anh hoặc tiếng Việt, một từ trung bình dài khoảng 4.5 đến 6 ký tự (tính cả khoảng trắng). Do đó, cùng một văn bản nếu biểu diễn ở mức ký tự sẽ tạo ra chuỗi dài gấp $4\text{–}6$ lần so với mức từ.
• Trong kiến trúc Transformer (mà ta sẽ mổ xẻ ở Chương 2), ma trận tự chú ý (Self-Attention) phải tính điểm tương tác giữa mọi cặp vị trí $(i, j)$ trong chuỗi, có độ phức tạp tính toán và bộ nhớ tỉ lệ bậc hai $\mathcal{O}(L^2)$. Khi chiều dài chuỗi $L$ tăng gấp 5 lần, chi phí tính toán Attention tăng gấp $5^2 = 25$ lần, đồng thời cửa sổ ngữ cảnh hiệu dụng (số lượng từ thực tế mà mô hình “nhìn thấy” được) bị co hẹp đi 5 lần.
• Hơn nữa, bản thân chữ cái rời rạc như 't', 'h', 'e' không mang ngữ nghĩa độc lập. Mạng nơ-ron phải tiêu tốn các tầng tính toán đầu tiên chỉ để học cách “đánh vần” (ghép các chữ cái thành từ) trước khi có thể suy luận về ngữ pháp và ý nghĩa.

1.3 Điểm cân bằng từ phụ (Subword-level) và sự đánh đổi $|V| - L$

Hai thái cực trên dẫn chúng ta đến nguyên lý thiết kế cốt lõi của mọi bộ tách từ hiện đại — tách từ ở mức từ phụ (Subword Tokenization):

Nguyên lý từ phụ: Các từ xuất hiện thường xuyên ("the", "model", "ngôn", "ngữ") cần được giữ nguyên làm một token duy nhất để chuỗi ngắn gọn; trong khi các từ hiếm hoặc từ phức ("tokenization", "autoregressive", "불가사의") được phân rã thành các mảnh từ phụ nhỏ hơn có tần suất cao ("token" + "ization", "auto" + "regress" + "ive").

Nhờ đó, kích thước bộ từ vựng $|V|$ được giữ ở mức vừa phải (thường từ $32{,}000$ đến $128{,}000$ token trong các LLM hiện nay), không có bất kỳ từ nào bị biến thành <unk>, các từ cùng gốc chia sẻ được mảnh gốc từ, và độ dài chuỗi $L$ chỉ dài hơn mức từ khoảng $15\%\text{–}30\%$.

Bạn có thể khám phá trực tiếp sự đánh đổi toán học giữa kích thước từ vựng $|V|$, độ dài chuỗi $L$ và chi phí Attention $\mathcal{O}(L^2)$ trên biểu đồ tương tác dưới đây.

2. Byte-Pair Encoding (BPE): Từ thuật toán nén dữ liệu đến từ vựng của LLM

Làm thế nào để máy tính tự động tìm ra danh sách các mảnh từ phụ tối ưu từ một kho văn bản thô mà không cần nhà ngôn ngữ học ngồi viết quy tắc tách gốc từ và hậu tố cho từng ngôn ngữ? Giải pháp phổ biến nhất hiện nay là thuật toán Byte-Pair Encoding (BPE).

2.1 Bảng mã Unicode, UTF-8 và biểu diễn mức byte

Trước khi đi vào thuật toán BPE, ta cần hiểu văn bản thực sự được lưu trữ trong bộ nhớ máy tính như thế nào.

Trong chuẩn Unicode, mỗi ký tự của mọi ngôn ngữ trên thế giới (từ chữ cái Latin, chữ tiếng Việt có dấu, chữ Hán, chữ Ả Rập cho đến biểu tượng cảm xúc emoji 🚀) được gán một mã số nguyên duy nhất gọi là code point (ví dụ: 'A' là U+0041 $= 65$, 'ă' là U+0103 $= 259$, 'ử' là U+1EED $= 7917$). Hiện có hơn $150{,}000$ ký tự Unicode đã được định nghĩa.

Nếu lấy trực tiếp toàn bộ hơn $150{,}000$ ký tự Unicode làm bảng chữ cái cơ sở ban đầu cho bộ tách từ, từ vựng cơ sở sẽ quá lớn và vẫn có nguy cơ gặp ký tự mới chưa từng xuất hiện trong tập huấn luyện. Thay vào đó, các LLM hiện đại (từ GPT-2 trở đi) làm việc trực tiếp trên chuỗi byte theo chuẩn mã hóa UTF-8.

Hãy kiểm chứng sự khác biệt giữa độ dài ký tự và độ dài byte UTF-8 của tiếng Việt so với tiếng Anh, cũng như điều gì xảy ra khi một ký tự đa byte bị cắt ngang trong bài tập đầu tiên dưới đây.

en_text = "Natural language processing with large language models"
vi_text = "Xử lý ngôn ngữ tự nhiên với các mô hình ngôn ngữ lớn"

print(f"EN ({len(en_text)} ký tự): {en_text}")
print(f"VI ({len(vi_text)} ký tự): {vi_text}")

EN (54 ký tự): Natural language processing with large language models
VI (52 ký tự): Xử lý ngôn ngữ tự nhiên với các mô hình ngôn ngữ lớn

EN: 54 ký tự -> 54 bytes (1.00 byte/ký tự)
VI: 52 ký tự -> 71 bytes (1.37 byte/ký tự)
Phân bố độ dài byte (VI): {1: 39, 2: 7, 3: 6}
Các ký tự 3-byte trong câu VI: ['ử', 'ữ', 'ự', 'ớ']

Từ 'ngữ' ở dạng UTF-8 bytes: [110, 103, 225, 187, 175]
Khi cắt mất 1 byte cuối (strict): UnicodeDecodeError: 'utf-8' codec can't decode bytes in position 2-3: unexpected end of data
Khi cắt mất 1 byte cuối (replace): ng�

en_text = "Natural language processing with large language models"
vi_text = "Xử lý ngôn ngữ tự nhiên với các mô hình ngôn ngữ lớn"

print(f"EN ({len(en_text)} ký tự): {en_text}")
print(f"VI ({len(vi_text)} ký tự): {vi_text}")

EN (54 ký tự): Natural language processing with large language models
VI (52 ký tự): Xử lý ngôn ngữ tự nhiên với các mô hình ngôn ngữ lớn

# (1) So sánh độ dài byte UTF-8 và phân bố số byte trên mỗi ký tự
en_bytes = en_text.encode("utf-8")
vi_bytes = vi_text.encode("utf-8")

print(f"EN: {len(en_text)} ký tự -> {len(en_bytes)} bytes "
      f"({len(en_bytes)/len(en_text):.2f} byte/ký tự)")
print(f"VI: {len(vi_text)} ký tự -> {len(vi_bytes)} bytes "
      f"({len(vi_bytes)/len(vi_text):.2f} byte/ký tự)")

byte_dist = {1: 0, 2: 0, 3: 0}
three_byte_chars = []
for ch in vi_text:
    n_b = len(ch.encode("utf-8"))
    byte_dist[n_b] += 1
    if n_b == 3 and ch not in three_byte_chars:
        three_byte_chars.append(ch)

print(f"Phân bố độ dài byte (VI): {byte_dist}")
print(f"Các ký tự 3-byte trong câu VI: {three_byte_chars}")

# (2) Kiểm tra hiện tượng đứt gãy ký tự đa byte trên từ "ngữ"
word_bytes = "ngữ".encode("utf-8")
print(f"\nTừ 'ngữ' ở dạng UTF-8 bytes: {list(word_bytes)}")

truncated = word_bytes[:-1]
try:
    truncated.decode("utf-8", errors="strict")
except UnicodeDecodeError as e:
    print(f"Khi cắt mất 1 byte cuối (strict): {type(e).__name__}: {e}")

replaced = truncated.decode("utf-8", errors="replace")
print(f"Khi cắt mất 1 byte cuối (replace): {replaced}")

EN: 54 ký tự -> 54 bytes (1.00 byte/ký tự)
VI: 52 ký tự -> 71 bytes (1.37 byte/ký tự)
Phân bố độ dài byte (VI): {1: 39, 2: 7, 3: 6}
Các ký tự 3-byte trong câu VI: ['ử', 'ữ', 'ự', 'ớ']

Từ 'ngữ' ở dạng UTF-8 bytes: [110, 103, 225, 187, 175]
Khi cắt mất 1 byte cuối (strict): UnicodeDecodeError: 'utf-8' codec can't decode bytes in position 2-3: unexpected end of data
Khi cắt mất 1 byte cuối (replace): ng�

2.2 Thuật toán gộp cặp BPE của Gage (1994) và Sennrich et al. (2016)

Năm 1994, Philip Gage giới thiệu Byte-Pair Encoding (BPE) như một thuật toán nén dữ liệu không mất mát đơn giản (Gage, 1994): tìm cặp hai byte đứng cạnh nhau xuất hiện nhiều nhất trong tệp tin, thay thế tất cả các vị trí của cặp đó bằng một byte mới chưa sử dụng, và lặp lại quá trình này cho đến khi không còn cặp nào xuất hiện nhiều hơn 1 lần.

Hai mươi hai năm sau, Rico Sennrich, Barry Haddow và Alexandra Birch nhận ra rằng chính ý tưởng nén cặp ký tự thường xuyên này là chìa khóa giải quyết bài toán từ hiếm cho Dịch máy Nơ-ron (NMT) (Sennrich et al., 2016). Thay vì nén tệp tin, họ dùng BPE để xây dựng bộ từ vựng từ phụ (subword vocabulary) từ kho văn bản huấn luyện.

Quy trình huấn luyện bộ tách từ BPE với số lượt gộp $M$ (tương ứng kích thước từ vựng đích $|V| = |V_{\text{base}}| + M$) diễn ra hoàn toàn tất định qua từng bước:

1. Khởi tạo bộ từ vựng cơ sở $V_0$: Tập hợp tất cả các đơn vị sơ cấp (các ký tự phân biệt hoặc 256 giá trị byte cơ sở). Biểu diễn toàn bộ kho văn bản huấn luyện dưới dạng chuỗi các đơn vị sơ cấp này: $$\mathcal{C}_0 = (u_1, u_2, \dots, u_N), \quad u_i \in V_0.$$
2. Lặp qua từng bước $t = 1, 2, \dots, M$:
   • Đếm tần suất cặp kề nhau: Với mọi cặp hai token liên tiếp $(a, b) \in V_{t-1} \times V_{t-1}$, tính tổng số lần chúng xuất hiện cạnh nhau trong chuỗi hiện tại $\mathcal{C}_{t-1}$: $$(a^*, b^*) = \arg\max_{(a, b)} \sum_{i=1}^{|\mathcal{C}_{t-1}| - 1} \mathbf{1}\big[\mathcal{C}_{t-1}[i] = a \;\wedge\; \mathcal{C}_{t-1}[i+1] = b\big].$$
   • Tạo token mới và ghi nhận luật gộp: Gộp hai token $(a^*, b^*)$ thành một token mới $v_{\text{new}} = a^* \circ b^*$, thêm $v_{\text{new}}$ vào từ vựng: $$V_t = V_{t-1} \cup \{v_{\text{new}}\},$$ đồng thời lưu luật gộp thứ $t$: $(a^*, b^*) \to v_{\text{new}}$.
   • Cập nhật kho văn bản: Thay thế mọi vị trí xuất hiện của cặp $(a^*, b^*)$ kề nhau trong $\mathcal{C}_{t-1}$ bằng token đơn $v_{\text{new}}$ để thu được chuỗi ngắn hơn $\mathcal{C}_t$.

Trong bài báo gốc của Sennrich et al. (Sennrich et al., 2016), mỗi từ trong kho văn bản được gắn thêm ký hiệu kết thúc từ </w> (để phân biệt tiền tố như "st" trong "star" với hậu tố "st</w>" ở cuối từ "newest" và "widest"). Hãy bấm nút Chạy tự động hoặc kéo thanh trượt trong mô phỏng dưới đây để theo dõi chính xác ví dụ kinh điển trong bài báo gốc!

Quan sát quá trình gộp 9 bước trên biểu đồ, bạn sẽ thấy một điều kỳ diệu: mặc dù thuật toán hoàn toàn “mù” về ngôn ngữ học (nó chỉ đếm số!), các token mới sinh ra lại trùng khớp với cấu trúc hình thái học của tiếng Anh:

• Bước 1–3 gộp 'e' + 's' $\to$ 'es', rồi 'es' + 't' $\to$ 'est', và 'est' + '</w>' $\to$ 'est</w>' (hậu tố so sánh nhất xuất hiện ở cả "newest" và "widest").
• Bước 4–5 gộp 'l' + 'o' $\to$ 'lo', rồi 'lo' + 'w' $\to$ 'low' (gốc từ chung của "low" và "lower").
• Nhờ đó, khi gặp một từ chưa từng xuất hiện trong tập huấn luyện như "lowest", bộ tách từ sẽ tự động phân tách thành hai mảnh đầy ý nghĩa: "low" + "est</w>"!

2.3 Giải mã và mã hóa một văn bản mới với danh sách luật gộp

Sau khi quá trình huấn luyện kết thúc, bộ tách từ BPE lưu trữ hai cấu trúc dữ liệu:

1. Bảng từ vựng (vocab): Ánh xạ hai chiều giữa mã số nguyên token_id và chuỗi byte của token đó.
2. Danh sách có thứ tự các luật gộp (merges): Danh sách $(a_1, b_1) \to v_1, \dots, (a_M, b_M) \to v_M$ theo đúng thứ tự ưu tiên lúc huấn luyện.

Khi cần mã hóa (encode) một văn bản mới lúc suy luận:

• Ta khởi đầu bằng việc tách văn bản thành dãy các byte (hoặc ký tự) cơ sở.
• Trong số tất cả các cặp kề nhau đang tồn tại trong dãy, ta tìm cặp có thứ tự ưu tiên sớm nhất (tức có chỉ số bước gộp nhỏ nhất trong danh sách merges), gộp chúng lại, và lặp lại cho đến khi không còn cặp kề nhau nào nằm trong merges.

Ngược lại, bước giải mã (decode) từ dãy mã số nguyên về văn bản chỉ đơn giản là nối các chuỗi byte của từng token lại với nhau và giải mã UTF-8.

Hãy tự tay cài đặt toàn bộ quy trình huấn luyện BPE, hàm encode và hàm decode chỉ với vài chục dòng Python trong bài tập thực hành dưới đây.

corpus = """Beautiful is better than ugly. Explicit is better than implicit.
Simple is better than complex. Complex is better than complicated.
Flat is better than nested. Sparse is better than dense.
Special cases aren't special enough to break the rules.
Although practicality beats purity, errors should never pass silently.
In the face of ambiguity, refuse the temptation to guess.
Now is better than never, although never is often better than right now.
If the implementation is hard to explain, it is a bad idea.
If the implementation is easy to explain, it may be a good idea.
Language models do not read raw text directly as words or characters.
Instead, a tokenizer converts text into a sequence of integer token IDs.
Byte-Pair Encoding starts with individual bytes and repeatedly merges
the most frequent adjacent pair of tokens into a new vocabulary entry.
Common words like the, and, model, language quickly become single tokens,
while rarer words like tokenization, autoregressive, or transformers are
split into meaningful subword pieces such as token, ization, and transform.
Subword tokenization helps neural networks generalize across different forms
of the same root word, such as train, trained, trainer, and training,
or model, models, modeled, and modeling in natural language processing.
When a tokenizer splits unseen words into smaller subwords, the language
model can still understand their meaning from the familiar roots and suffixes.
Without pre-tokenization, however, merging raw bytes directly across spaces
can fuse frequent words with punctuation marks or adjacent words."""

raw_bytes = list(corpus.encode("utf-8"))
print(f"Độ dài ban đầu: {len(raw_bytes)} bytes "
      f"({len(set(raw_bytes))} byte phân biệt)")

Độ dài ban đầu: 1591 bytes (44 byte phân biệt)

Bước   1: gộp (32, 116) -> 256 (' t', tần suất 39), còn 1552 tokens
Bước   2: gộp (115, 32) -> 257 ('s ', tần suất 35), còn 1517 tokens
Bước   3: gộp (101, 114) -> 258 ('er', tần suất 27), còn 1490 tokens
Bước  10: gộp (44, 32) -> 265 (', ', tần suất 17), còn 1343 tokens
Bước  50: gộp (101, 115) -> 305 ('es', tần suất 6), còn 983 tokens
Bước 100: gộp (44, 261) -> 355 (', i', tần suất 3), còn 773 tokens
Bước 150: gộp (404, 355) -> 405 (' to explain, i', tần suất 2), còn 661 tokens
Bước 200: gộp (454, 288) -> 455 ('ural ', tần suất 2), còn 561 tokens
Tỷ lệ nén sau 200 bước: 1591/561 = 2.84 bytes/token
Mã hóa mẫu: ['S', 'i', 'mpl', 'e ', 'language ', 'model', 's ', 're', 'ad', ' s', 'ubword', ' token', 's', '.']
Khôi phục nguyên bản: True

corpus = """Beautiful is better than ugly. Explicit is better than implicit.
Simple is better than complex. Complex is better than complicated.
Flat is better than nested. Sparse is better than dense.
Special cases aren't special enough to break the rules.
Although practicality beats purity, errors should never pass silently.
In the face of ambiguity, refuse the temptation to guess.
Now is better than never, although never is often better than right now.
If the implementation is hard to explain, it is a bad idea.
If the implementation is easy to explain, it may be a good idea.
Language models do not read raw text directly as words or characters.
Instead, a tokenizer converts text into a sequence of integer token IDs.
Byte-Pair Encoding starts with individual bytes and repeatedly merges
the most frequent adjacent pair of tokens into a new vocabulary entry.
Common words like the, and, model, language quickly become single tokens,
while rarer words like tokenization, autoregressive, or transformers are
split into meaningful subword pieces such as token, ization, and transform.
Subword tokenization helps neural networks generalize across different forms
of the same root word, such as train, trained, trainer, and training,
or model, models, modeled, and modeling in natural language processing.
When a tokenizer splits unseen words into smaller subwords, the language
model can still understand their meaning from the familiar roots and suffixes.
Without pre-tokenization, however, merging raw bytes directly across spaces
can fuse frequent words with punctuation marks or adjacent words."""

raw_bytes = list(corpus.encode("utf-8"))
print(f"Độ dài ban đầu: {len(raw_bytes)} bytes "
      f"({len(set(raw_bytes))} byte phân biệt)")

Độ dài ban đầu: 1591 bytes (44 byte phân biệt)

# (1) Hàm đếm tần suất cặp kề nhau và hàm gộp cặp thành ID mới
def get_stats(ids):
    counts = {}
    for pair in zip(ids, ids[1:]):
        counts[pair] = counts.get(pair, 0) + 1
    return counts


def merge_vocab(ids, pair, new_id):
    new_ids, i = [], 0
    while i < len(ids):
        if i < len(ids) - 1 and (ids[i], ids[i + 1]) == pair:
            new_ids.append(new_id)
            i += 2
        else:
            new_ids.append(ids[i])
            i += 1
    return new_ids


# (2) Huấn luyện BPE trong 200 bước gộp từ bảng mã 256 byte cơ sở
ids = list(raw_bytes)
merges = {}
vocab = {i: bytes([i]) for i in range(256)}

for step in range(200):
    stats = get_stats(ids)
    best_pair = max(stats, key=stats.get)
    new_id = 256 + step
    ids = merge_vocab(ids, best_pair, new_id)
    merges[best_pair] = new_id
    vocab[new_id] = vocab[best_pair[0]] + vocab[best_pair[1]]
    if step in (0, 1, 2, 9, 49, 99, 149, 199):
        s = vocab[new_id].decode("utf-8", errors="replace")
        freq = stats[best_pair]
        print(f"Bước {step+1:3d}: gộp {best_pair} -> {new_id} "
              f"({s!r}, tần suất {freq}), còn {len(ids)} tokens")

ratio = len(raw_bytes) / len(ids)
print(f"Tỷ lệ nén sau 200 bước: "
      f"{len(raw_bytes)}/{len(ids)} = {ratio:.2f} bytes/token")


# (3) Hàm mã hóa (encode) theo thứ tự ưu tiên gộp và giải mã (decode)
def encode(text):
    tokens = list(text.encode("utf-8"))
    while len(tokens) >= 2:
        stats = get_stats(tokens)
        pair = min(stats, key=lambda p: merges.get(p, float("inf")))
        if pair not in merges:
            break
        tokens = merge_vocab(tokens, pair, merges[pair])
    return tokens


def decode(token_ids):
    raw = b"".join(vocab[idx] for idx in token_ids)
    return raw.decode("utf-8", errors="replace")


sample = "Simple language models read subword tokens."
enc = encode(sample)
print("Mã hóa mẫu:", [vocab[i].decode("utf-8") for i in enc])
print("Khôi phục nguyên bản:", decode(enc) == sample)

Bước   1: gộp (32, 116) -> 256 (' t', tần suất 39), còn 1552 tokens
Bước   2: gộp (115, 32) -> 257 ('s ', tần suất 35), còn 1517 tokens
Bước   3: gộp (101, 114) -> 258 ('er', tần suất 27), còn 1490 tokens
Bước  10: gộp (44, 32) -> 265 (', ', tần suất 17), còn 1343 tokens
Bước  50: gộp (101, 115) -> 305 ('es', tần suất 6), còn 983 tokens
Bước 100: gộp (44, 261) -> 355 (', i', tần suất 3), còn 773 tokens
Bước 150: gộp (404, 355) -> 405 (' to explain, i', tần suất 2), còn 661 tokens
Bước 200: gộp (454, 288) -> 455 ('ural ', tần suất 2), còn 561 tokens
Tỷ lệ nén sau 200 bước: 1591/561 = 2.84 bytes/token
Mã hóa mẫu: ['S', 'i', 'mpl', 'e ', 'language ', 'model', 's ', 're', 'ad', ' s', 'ubword', ' token', 's', '.']
Khôi phục nguyên bản: True

3. Byte-level BPE và Pre-tokenization: Công thức của GPT-2, GPT-4 và Llama-3

Năm 2019, khi huấn luyện GPT-2 trên tập dữ liệu WebText đa dạng thu thập từ Internet, Alec Radford và các cộng sự tại OpenAI đã định hình kiến trúc chuẩn mực cho hầu hết các bộ tách từ của LLM hiện đại (Radford et al., 2019): kết hợp Byte-level BPE với Tách sơ bộ bằng Biểu thức chính quy (Regex Pre-tokenization).

3.1 Byte-level BPE: Khởi đầu từ 256 byte cơ sở

Nếu áp dụng BPE trực tiếp trên các ký tự Unicode như cách làm ban đầu trong dịch máy, bộ từ vựng cơ sở $V_0$ sẽ phải chứa hàng chục nghìn ký tự từ mọi hệ chữ viết xuất hiện trong dữ liệu web (chữ Hán, chữ Nhật, ký hiệu toán học, emoji), chiếm mất phần lớn dung lượng của một bộ từ vựng $32{,}000$ hay $50{,}000$ token. Ngược lại, nếu chỉ giữ các ký tự phổ biến trong $V_0$, mô hình lại quay về bài toán phải dùng token <unk> cho các ký tự hiếm.

GPT-2 giải quyết triệt để mâu thuẫn này bằng cách đặt $V_0$ là tập 256 giá trị byte đơn lẻ (0x00 đến 0xFF). Với $50{,}000$ lượt gộp BPE cộng thêm 1 token đặc biệt <|endoftext|> để đánh dấu ranh giới giữa các văn bản, GPT-2 có bộ từ vựng tổng cộng:

Một chi tiết thú vị trong cài đặt của GPT-2 (và RoBERTa) là không bỏ đi khoảng trắng: khoảng trắng đứng trước một từ được giữ lại như một phần của từ đó (trong các tệp cấu hình của Hugging Face, byte khoảng trắng 0x20 thường được hiển thị bằng ký tự Ġ, ví dụ " hello" được viết là "Ġhello"). Nhờ vậy, quá trình nối token khi giải mã hoàn toàn bảo toàn khoảng trắng gốc mà không cần đoán xem giữa hai từ có dấu cách hay không.

3.2 Tại sao phải tách sơ bộ bằng Biểu thức chính quy (Regex Pre-tokenization)?

Như ta đã thấy trong Bài tập 1.2b và ghi chú của bài báo GPT-2 (Radford et al., 2019), nếu chạy BPE trên một chuỗi byte liền mạch, thuật toán sẽ gộp xuyên qua khoảng trắng và gộp dính chữ cái với dấu câu hoặc chữ số.

Để ngăn chặn hiện tượng này, trước khi đưa văn bản vào thuật toán BPE, GPT-2 và GPT-4 (cl100k_base trong thư viện tiktoken, cũng được Llama-3 sử dụng) dùng một biểu thức chính quy (Regular Expression) để cắt văn bản thành các mảnh thô (pre-tokens hay chunks). Sau đó, thuật toán BPE chỉ được phép đếm và gộp các cặp byte nằm bên trong cùng một mảnh, tuyệt đối không bao giờ gộp xuyên qua ranh giới giữa hai mảnh!

Biểu thức chính quy của GPT-4 (cl100k_base) được thiết kế rất tinh tế để xử lý 5 nhóm cấu trúc ngôn ngữ và lập trình:

1. Tách các hậu tố rút gọn tiếng Anh ('(?i:[sdmt]|ll|ve|re)): Tách rời 's, 't, 're, 've, 'm, 'll, 'd khỏi từ đứng trước (ví dụ "It's" $\to$ ["It", "'s"], "don't" $\to$ ["don", "'t"]), giúp gốc động từ/danh từ không bị nhân bản.
2. Giữ khoảng trắng dẫn đầu gắn với từ chữ cái ([^\r\n\p{L}\p{N}]?\p{L}+): Mỗi từ gồm các chữ cái Unicode (\p{L}+) cùng tối đa 1 ký tự đứng ngay trước nó (thường là 1 dấu cách ' ') tạo thành một mảnh độc lập (ví dụ " language"). Dấu câu theo sau từ đó bị tách sang mảnh khác!
3. Tách các chữ số thành từng nhóm tối đa 3 chữ số (\p{N}{1,3}): Trong GPT-2, biểu thức \p{N}+ cho phép một con số dài bất kỳ đi vào cùng một mảnh, dẫn đến việc một số như 1000 là 1 token nhưng 1001 lại bị cắt thành 2 token khác nhau, làm mô hình rất khó học quy tắc cộng trừ theo hàng đơn vị, hàng chục, hàng trăm. Sang GPT-4 và Llama-3, luật \p{N}{1,3} ép mọi chuỗi số phải tách thành từng cụm từ 1 đến 3 chữ số trước khi BPE chạy!
4. Cô lập cụm dấu câu và ký hiệu toán học ( ?[^\s\p{L}\p{N}]+[\r\n]*): Các dấu ., ,, !, ?, >=, ): đứng riêng thành mảnh dấu câu, không bao giờ bị gộp dính vào từ chữ cái hay con số.
5. Gom nhóm khoảng trắng và thụt lề mã nguồn (\s*[\r\n]+|\s+(?!\S)|\s+): Giữ các chuỗi khoảng trắng liên tiếp (như 4 dấu cách hoặc 8 dấu cách thụt đầu dòng trong Python) thành một mảnh riêng để BPE có thể gộp 4 dấu cách ' ' thành 1 token duy nhất, giúp nén mã nguồn cực kỳ hiệu quả!

Hãy tương tác với biểu đồ dưới đây để so sánh cách BPE ngây thơ và BPE có Regex Pre-tokenization của GPT-4 xử lý dấu câu, chữ số và mã nguồn Python.

Hãy kiểm chứng hiệu quả của Regex Pre-tokenization bằng cách nâng cấp bộ huấn luyện BPE của bạn trong Bài tập 1.3.

import re

corpus = """Beautiful is better than ugly. Explicit is better than implicit.
Simple is better than complex. Complex is better than complicated.
Special cases aren't special enough to break the rules.
Although practicality beats purity, errors should never pass silently.
Now is better than never, although never is often better than right now.
If the implementation is hard to explain, it's a bad idea!
Language models do not read raw text directly as words or characters.
Instead, a tokenizer converts text into a sequence of integer token IDs.
Common words like model, models, model., model!, model? share the root model.
When training on numbers like 123456 or 2024, GPT-4 splits digits into
groups of at most 3 digits so arithmetic is more consistent across tokens.
Subword tokenization helps neural networks generalize across different forms
of the same root word, such as train, trained, trainer, and training,
or token, tokens, tokenizer, and tokenization in language modeling."""

# Biểu thức chính quy pre-tokenization rút gọn theo chuẩn GPT-4 (cl100k_base)
GPT4_PAT = re.compile(
    r"'(?:[sdmt]|ll|ve|re)| ?[A-Za-z]+| ?\d{1,3}| ?[^\sA-Za-z\d]+|\s+"
)
print("Tách câu thử nghiệm:",
      GPT4_PAT.findall("It's 123456: model., model!"))

Tách câu thử nghiệm: ['It', "'s", ' 123', '456', ':', ' model', '.,', ' model', '!']

Tổng số mảnh pre-tokenized: 203

Token gộp xuyên ranh giới từ/dấu câu:
  BPE ngây thơ (11/80): ['better th', 'better than', ' is better than', 's.\n', ', model', 's s', 'e model', 's t']
  BPE có Regex (0/80): []
10 token dài nhất (BPE có Regex): [' tokeniz', ' better', ' model', ' token', ' train', ' never', ' compl', 'pecial', ' mode', ' than']

import re

corpus = """Beautiful is better than ugly. Explicit is better than implicit.
Simple is better than complex. Complex is better than complicated.
Special cases aren't special enough to break the rules.
Although practicality beats purity, errors should never pass silently.
Now is better than never, although never is often better than right now.
If the implementation is hard to explain, it's a bad idea!
Language models do not read raw text directly as words or characters.
Instead, a tokenizer converts text into a sequence of integer token IDs.
Common words like model, models, model., model!, model? share the root model.
When training on numbers like 123456 or 2024, GPT-4 splits digits into
groups of at most 3 digits so arithmetic is more consistent across tokens.
Subword tokenization helps neural networks generalize across different forms
of the same root word, such as train, trained, trainer, and training,
or token, tokens, tokenizer, and tokenization in language modeling."""

# Biểu thức chính quy pre-tokenization rút gọn theo chuẩn GPT-4 (cl100k_base)
GPT4_PAT = re.compile(
    r"'(?:[sdmt]|ll|ve|re)| ?[A-Za-z]+| ?\d{1,3}| ?[^\sA-Za-z\d]+|\s+"
)
print("Tách câu thử nghiệm:",
      GPT4_PAT.findall("It's 123456: model., model!"))

Tách câu thử nghiệm: ['It', "'s", ' 123', '456', ':', ' model', '.,', ' model', '!']

# (1) Tách văn bản thành danh sách các mảnh độc lập bằng Regex
chunks = GPT4_PAT.findall(corpus)
print(f"Tổng số mảnh pre-tokenized: {len(chunks)}")


# (2) Huấn luyện BPE chỉ đếm và gộp cặp bên trong từng mảnh (chunk)
def train_bpe(chunks_list, num_merges=80):
    seqs = [list(c.encode("utf-8")) for c in chunks_list]
    vocab = {i: bytes([i]) for i in range(256)}
    for step in range(num_merges):
        counts = {}
        for seq in seqs:
            for pair in zip(seq, seq[1:]):
                counts[pair] = counts.get(pair, 0) + 1
        best_pair = max(counts, key=counts.get)
        new_id = 256 + step
        vocab[new_id] = vocab[best_pair[0]] + vocab[best_pair[1]]
        new_seqs = []
        for seq in seqs:
            merged, i = [], 0
            while i < len(seq):
                if i < len(seq) - 1 and (seq[i], seq[i + 1]) == best_pair:
                    merged.append(new_id)
                    i += 2
                else:
                    merged.append(seq[i])
                    i += 1
            new_seqs.append(merged)
        seqs = new_seqs
    return [
        vocab[256 + s].decode("utf-8", errors="replace")
        for s in range(num_merges)
    ]


# (3) So sánh BPE ngây thơ (1 chuỗi liền) và BPE có Regex pre-tokenizer
naive_tokens = train_bpe([corpus], num_merges=80)
regex_tokens = train_bpe(chunks, num_merges=80)


def is_cross_boundary(t):
    punct_alpha = any(p in t for p in ",.!?") and any(c.isalpha() for c in t)
    multi_words = len(t.strip().split()) > 1
    return punct_alpha or multi_words


bad_naive = [t for t in naive_tokens if is_cross_boundary(t)]
bad_regex = [t for t in regex_tokens if is_cross_boundary(t)]

print("\nToken gộp xuyên ranh giới từ/dấu câu:")
print(f"  BPE ngây thơ ({len(bad_naive)}/80): {bad_naive[:8]}")
print(f"  BPE có Regex ({len(bad_regex)}/80): {bad_regex}")
top_regex = sorted(regex_tokens, key=len, reverse=True)[:10]
print("10 token dài nhất (BPE có Regex):", top_regex)

Tổng số mảnh pre-tokenized: 203

Token gộp xuyên ranh giới từ/dấu câu:
  BPE ngây thơ (11/80): ['better th', 'better than', ' is better than', 's.\n', ', model', 's s', 'e model', 's t']
  BPE có Regex (0/80): []
10 token dài nhất (BPE có Regex): [' tokeniz', ' better', ' model', ' token', ' train', ' never', ' compl', 'pecial', ' mode', ' than']

4. WordPiece, Unigram LM và SentencePiece: Góc nhìn xác suất

Mặc dù BPE chiếm ưu thế trong các dòng mô hình GPT và Llama, lịch sử phát triển của NLP còn sản sinh ra hai thuật toán tách từ phụ quan trọng khác dựa trên lý thuyết xác suất và thông tin: WordPiece (dùng trong BERT, DistilBERT, Electra) và Unigram Language Model (dùng trong T5, ALBERT, mBART, Gemma).

4.1 WordPiece: Gộp cặp theo Điểm thông tin tương hỗ (Pointwise Mutual Information)

Được Mike Schuster và Kaisuke Nakajima phát triển tại Google năm 2012 cho hệ thống tìm kiếm giọng nói tiếng Nhật và tiếng Hàn (Schuster & Nakajima, 2012), sau đó được chọn làm bộ tách từ cho BERT, WordPiece cũng là một thuật toán gộp cặp từ dưới lên (bottom-up) giống BPE, nhưng khác nhau ở hai điểm cốt lõi:

1. Đánh dấu mảnh nối tiếp bằng tiền tố ##: Thay vì giữ khoảng trắng ở đầu từ như GPT-2 ("Ġization"), WordPiece tách từ theo khoảng trắng trước rồi gắn ký hiệu ## vào đầu các mảnh không phải là đầu từ. Ví dụ, từ "tokenization" được tách thành ["token", "##ization"]. Nhờ tiền tố ##, khi giải mã ta biết ngay "##ization" phải nối liền vào "token" mà không có dấu cách ở giữa.
2. Tiêu chí chọn cặp gộp cực đại hóa Hợp lý (Likelihood): Trong BPE, ta chọn cặp $(a, b)$ có tần suất xuất hiện cùng nhau $C(a, b)$ lớn nhất. Tuy nhiên, hai ký tự rất phổ biến (như 'e' và 's') có thể đứng cạnh nhau nhiều lần chỉ vì bản thân từng ký tự xuất hiện quá nhiều, chứ không phải vì chúng có mối liên kết đặc biệt. WordPiece khắc phục điều này bằng cách chia tần suất cặp cho tích tần suất của từng thành phần đơn lẻ: $$\text{Score}_{\text{WordPiece}}(a, b) = \frac{C(a, b)}{C(a) \cdot C(b)}.$$ Nếu lấy logarit của đại lượng này (nhân với kích thước kho văn bản $N$), ta thu được chính xác Điểm thông tin tương hỗ từng điểm (Pointwise Mutual Information — PMI): $$\text{PMI}(a, b) = \log \frac{P(a, b)}{P(a)\,P(b)}.$$ Như vậy, WordPiece ưu tiên gộp những cặp mảnh có tần suất đi cùng nhau cao hơn nhiều so với kỳ vọng ngẫu nhiên (ví dụ gộp "q" với "u", hoặc "##iz" với "##ation" trước khi gộp hai chữ cái phổ biến ngẫu nhiên).

Khi mã hóa một từ mới lúc suy luận, thay vì áp dụng tuần tự một danh sách luật gộp như BPE, WordPiece sử dụng thuật toán khớp tiền tố dài nhất từ trái sang phải (Longest-match-first / MaxMatch): tìm mảnh tiền tố dài nhất của từ có mặt trong bộ từ vựng $V$, cắt mảnh đó ra, thêm ## vào phần còn lại và lặp lại.

4.2 Unigram Language Model và Subword Regularization

Cả BPE lẫn WordPiece đều xây dựng từ vựng từ dưới lên (bottom-up) một cách tham lam: bắt đầu từ bảng chữ cái nhỏ và gộp dần lên. Năm 2018, Taku Kudo đề xuất một hướng tiếp cận ngược lại hoàn toàn và mang tính nguyên lý xác suất chặt chẽ hơn: Unigram Language Model (Kudo, 2018), xây dựng từ vựng từ trên xuống (top-down).

Trong mô hình Unigram của Kudo (Kudo, 2018), xác suất của một phương án tách từ $\mathbf{x} = (x_1, \dots, x_M)$ cho chuỗi đầu vào $S$ (với điều kiện nối các mảnh $x_i$ lại đúng bằng $S$) được giả định là tích xác suất độc lập của từng mảnh:

Khi đã có bộ từ vựng $V$ và xác suất $p(v)$ của từng token, phương án tách từ tối ưu $\mathbf{x}^*$ cho chuỗi $S$ được tìm một cách chính xác trong thời gian tuyến tính $\mathcal{O}(|S|)$ bằng thuật toán quy hoạch động Viterbi:

trong đó $\mathcal{S}(S)$ là tập mọi cách chia chuỗi $S$ thành các mảnh thuộc $V$.

Để huấn luyện bộ từ vựng Unigram đạt kích thước đích $|V|$:

1. Khởi tạo từ vựng siêu lớn $V_{\text{init}}$: Thu thập tất cả các chuỗi con xuất hiện thường xuyên trong kho văn bản (ví dụ $1{,}000{,}000$ chuỗi con tìm bằng thuật toán mảng hậu tố Enhanced Suffix Array) cùng toàn bộ các ký tự cơ sở.
2. Lặp lại chu trình Cực đại hóa Kỳ vọng (EM) và Cắt tỉa (Pruning):
   • Ước lượng xác suất $p(v)$ cho mọi $v \in V$ bằng thuật toán EM để cực đại hóa tổng log-likelihood $\mathcal{L} = \sum_{s \in \mathcal{D}} \log \sum_{\mathbf{x} \in \mathcal{S}(s)} P(\mathbf{x})$ của kho văn bản $\mathcal{D}$.
   • Với mỗi token $v \in V$ (trừ các ký tự cơ sở không bao giờ được xóa), tính độ sụt giảm hàm hợp lý $\Delta \mathcal{L}_v$ nếu xóa $v$ khỏi từ vựng $V$.
   • Loại bỏ $10\%\text{–}20\%$ số token có $\Delta \mathcal{L}_v$ nhỏ nhất (những token dư thừa mà nếu bỏ đi, các mảnh khác vẫn biểu diễn tốt văn bản), rồi lặp lại cho đến khi $|V|$ giảm về đúng kích thước mong muốn.

4.3 SentencePiece: Xử lý ngôn ngữ không phân tách từ bằng khoảng trắng

Hầu hết các bộ tách từ đời đầu đều mặc định bước đầu tiên là text.split(" ") — giả định rằng các từ trong ngôn ngữ luôn được ngăn cách bởi dấu cách. Nhưng trong tiếng Trung (自然语言处理), tiếng Nhật (自然言語処理), tiếng Thái hay tiếng Lào, các từ được viết liền nhau hoàn toàn không có khoảng trắng! Hơn nữa, ngay cả trong tiếng Anh hay tiếng Việt, việc tách khoảng trắng trước làm mất thông tin hoàn nguyên chuỗi gốc (ví dụ không biết dấu ngoặc kép hay dấu chấm phẩy có cách chữ trước đó hay không).

Cùng năm 2018, Taku Kudo và John Richardson tại Google ra mắt thư viện SentencePiece (Kudo & Richardson, 2018) (hỗ trợ cả hai thuật toán BPE và Unigram LM), đưa ra một triết lý thiết kế cực kỳ thanh lịch: coi khoảng trắng chỉ là một ký tự bình thường như mọi chữ cái khác.

Bảng dưới đây tổng hợp toàn cảnh 4 phương pháp tách từ phụ phổ biến nhất trong thế giới LLM:

5. Các hệ quả thực tế: Đếm chữ cái, Toán học, Glitch Tokens và Bất bình đẳng Ngôn ngữ

Hiểu rõ cơ chế hoạt động của bộ tách từ giúp chúng ta giải thích ngay lập tức hàng loạt “căn bệnh” kinh điển từng làm đau đầu người dùng LLM trong thực tế.

5.1 Tại sao LLM từng đếm sai chữ 'r' trong "strawberry" và tính nhẩm kém?

Khi bạn hỏi một mô hình ngôn ngữ câu hỏi nổi tiếng: “Có bao nhiêu chữ r trong từ strawberry?”, con người nhìn thấy một chuỗi gồm 10 chữ cái rời nhau: s-t-r-a-w-b-e-r-r-y. Nhưng mô hình ngôn ngữ không bao giờ nhìn thấy chuỗi 10 chữ cái đó!

Trong bộ tách từ cl100k_base của GPT-4, từ "strawberry" được cắt thành 3 mã số nguyên:

Đối với mạng Transformer, đầu vào chỉ là 3 vector số thực $\mathbf{e}_{496}, \mathbf{e}_{675}, \mathbf{e}_{15717}$. Bản thân vector $\mathbf{e}_{15717}$ đại diện cho khái niệm ngữ nghĩa của cả mảnh "berry", chứ không có trường thông tin tường minh nào ghi rằng bên trong nó chứa hai chữ 'r'. Để đếm đúng, mô hình buộc phải ghi nhớ thông tin chính tả của từng token trong quá trình tiền huấn luyện, hoặc bạn phải yêu cầu nó “viết tách từng chữ cái ra cách nhau bằng dấu gạch ngang trước khi đếm” (s - t - r - a - w - b - e - r - r - y) — khi đó mỗi chữ cái trở thành một token riêng lẻ và mô hình đếm đúng 100%!

Hệ quả tương tự cũng xảy ra với:

• Đảo ngược chuỗi ký tự hoặc chơi chữ (Wordle, nối âm): Vì ranh giới token không trùng với ranh giới chữ cái hay âm tiết.
• Số học nhiều chữ số: Trong các bộ tách từ đời cũ (như GPT-2 hay Llama-1/2), số 380 là 1 token nhưng 381 lại bị tách thành ["38", "1"], còn 3815 tách thành ["381", "5"]. Vị trí hàng đơn vị, hàng chục bị xáo trộn tùy theo con số cụ thể khiến thuật toán cộng cột dọc trở nên cực kỳ khó học. Đây là lý do Llama-3 và GPT-4 giới hạn mảnh số tối đa 3 chữ số (\d{1,3}), còn các mô hình chuyên toán như Llemma hay DeepSeek thậm chí tách mỗi chữ số 0..9 thành một token riêng biệt!
• Khoảng trắng cuối chuỗi (Trailing whitespace): Nếu bạn đưa một prompt kết thúc bằng "The answer is: " (có dấu cách ở cuối), bộ tách từ sẽ tách dấu cách đó thành một token riêng 220 (" "). Trong khi đó, lúc huấn luyện, dấu cách luôn được gộp vào đầu từ tiếp theo (ví dụ " Paris" là 1 token 12366). Việc xuất hiện token dấu cách đứng lẻ loi ở cuối prompt đẩy mô hình vào vùng phân phối hiếm gặp, làm giảm đáng kể chất lượng câu trả lời!

5.2 Hiện tượng “Glitch Tokens” (Các token dị biệt chưa được huấn luyện)

Năm 2023, cộng đồng nghiên cứu phát hiện ra rằng nếu yêu cầu GPT-2 hoặc GPT-3 lặp lại một số chuỗi ký tự kỳ lạ như " SolidGoldMagikarp", " petertodd" hay " davidjl", mô hình đột nhiên trả lời hoàn toàn điên loạn, bịa ra nội dung không liên quan hoặc từ chối một cách khó hiểu!

Nguyên nhân nằm ở sự lệch pha giữa dữ liệu huấn luyện Tokenizer và dữ liệu huấn luyện LLM:

1. Bộ tách từ BPE của GPT-2 được huấn luyện trên dữ liệu Reddit chứa tên tài khoản của những người dùng đăng hàng trăm nghìn bình luận trên diễn đàn đếm số (như tài khoản SolidGoldMagikarp). Vì xuất hiện quá nhiều lần, cả cụm " SolidGoldMagikarp" được gộp thành một token duy nhất trong bộ từ vựng (ID 42573).
2. Sau đó, khi lọc sạch dữ liệu để huấn luyện mạng nơ-ron GPT-2/GPT-3, các trang diễn đàn đếm số rác đó bị xóa bỏ hoàn toàn.
3. Kết quả là token ID 42573 vẫn nằm trong bảng nhúng $E \in \mathbb{R}^{|V| \times d}$, nhưng không bao giờ xuất hiện trong suốt quá trình huấn luyện LLM! Vector nhúng $\mathbf{e}_{42573}$ của nó giữ nguyên giá trị khởi tạo ngẫu nhiên ban đầu (nằm lạc lõng hoàn toàn so với đám mây vector đã được huấn luyện của các từ bình thường). Khi người dùng gõ " SolidGoldMagikarp", vector nhiễu chưa huấn luyện này đi thẳng vào các tầng Attention và làm rối loạn toàn bộ phép tính của mô hình.

5.3 Hệ số phân mảnh (Fertility) và “Thuế Token” đối với tiếng Việt

Hệ quả kinh tế và xã hội sâu sắc nhất của bộ tách từ chính là sự bất bình đẳng giữa các ngôn ngữ (Petrov & others, 2023). Để định lượng mức độ một bộ tách từ “ưu ái” hay “phân mảnh” một ngôn ngữ, người ta sử dụng hai chỉ số chuẩn:

1. Hệ số phân mảnh (Fertility): Số lượng token trung bình cần thiết để biểu diễn một từ trong ngôn ngữ đó: $$\text{Fertility} = \frac{N_{\text{tokens}}}{N_{\text{words}}} \ge 1.$$ Giá trị lý tưởng gần bằng $1.0\text{–}1.2$ (mỗi từ hầu như là 1 token nguyên vẹn).
2. Tỷ lệ nén (Bytes per token): Số byte UTF-8 trung bình được nén trong một token: $$\text{Compression Ratio} = \frac{N_{\text{bytes}}}{N_{\text{tokens}}}.$$

Đối với tiếng Việt, sự phân mảnh này bắt nguồn từ hai nguyên nhân cộng hưởng:

• Thứ nhất, chữ quốc ngữ dùng nhiều dấu phụ và dấu thanh (tốn 2–3 bytes UTF-8 cho mỗi nguyên âm có dấu như ta đã thấy ở Bài tập 1.2a).
• Thứ hai, trong các bộ tách từ thế hệ cũ như GPT-2 ($|V| = 50{,}257$, huấn luyện chủ yếu trên tiếng Anh), các nguyên âm có dấu tiếng Việt rất ít khi được gộp thành âm tiết hoàn chỉnh. Một từ đơn tiết tiếng Việt như "nghiêng" hay "trường" có thể bị cắt vụn thành 3–5 token!

Sang thế hệ GPT-4 (cl100k_base, $|V| \approx 100\text{K}$) và Llama-3 ($|V| = 128{,}256$), nhờ mở rộng gấp đôi kích thước từ vựng và tăng tỷ trọng dữ liệu đa ngôn ngữ khi huấn luyện BPE, hầu hết các âm tiết tiếng Việt thông dụng đã trở thành 1–2 token. Bạn có thể quan sát trực quan bước tiến này qua biểu đồ tương tác dưới đây.

Trong bài tập thực hành cuối cùng của chương, bạn sẽ trực tiếp sử dụng thư viện tiktoken để đo hệ số phân mảnh trên một cặp văn bản song ngữ Anh–Việt và thử mở rộng bộ từ vựng BPE cho tiếng Việt.

import tiktoken

en_doc = (
    "Large language models are trained on massive multilingual text corpora. "
    "However, when a tokenizer is trained primarily on English text, words in "
    "other languages are fragmented into many small subword or byte tokens. "
    "This increases computational cost and reduces effective context length."
)

vi_doc = (
    "Các mô hình ngôn ngữ lớn được huấn luyện trên kho văn bản đa ngữ khổng lồ. "
    "Tuy nhiên, khi bộ tách từ chủ yếu học từ tiếng Anh, các từ trong ngôn ngữ "
    "khác bị cắt vụn thành nhiều mảnh từ phụ hoặc byte nhỏ. Điều này làm tăng "
    "chi phí tính toán và thu hẹp độ dài ngữ cảnh hiệu dụng."
)

en_words = en_doc.split()
vi_words = vi_doc.split()
print(f"Số từ: EN = {len(en_words)} từ, VI = {len(vi_words)} từ")

Số từ: EN = 42 từ, VI = 63 từ

[gpt2       ] EN:  51 tokens (fertility 1.21) | VI: 251 tokens (fertility 3.98) | VI/EN = 4.92x
[cl100k_base] EN:  50 tokens (fertility 1.19) | VI: 135 tokens (fertility 2.14) | VI/EN = 2.70x

BPE tiếng Việt mở rộng (60 lượt gộp):
  Trước khi gộp (byte-level): 370 tokens (fertility 5.87)
  Sau 60 lượt gộp tiếng Việt: 162 tokens (fertility 2.57)

import tiktoken

en_doc = (
    "Large language models are trained on massive multilingual text corpora. "
    "However, when a tokenizer is trained primarily on English text, words in "
    "other languages are fragmented into many small subword or byte tokens. "
    "This increases computational cost and reduces effective context length."
)

vi_doc = (
    "Các mô hình ngôn ngữ lớn được huấn luyện trên kho văn bản đa ngữ khổng lồ. "
    "Tuy nhiên, khi bộ tách từ chủ yếu học từ tiếng Anh, các từ trong ngôn ngữ "
    "khác bị cắt vụn thành nhiều mảnh từ phụ hoặc byte nhỏ. Điều này làm tăng "
    "chi phí tính toán và thu hẹp độ dài ngữ cảnh hiệu dụng."
)

en_words = en_doc.split()
vi_words = vi_doc.split()
print(f"Số từ: EN = {len(en_words)} từ, VI = {len(vi_words)} từ")

Số từ: EN = 42 từ, VI = 63 từ

# (1) Đo hệ số phân mảnh (fertility) trên GPT-2 và GPT-4 (cl100k_base)
for name in ["gpt2", "cl100k_base"]:
    enc = tiktoken.get_encoding(name)
    en_toks = enc.encode(en_doc)
    vi_toks = enc.encode(vi_doc)
    f_en = len(en_toks) / len(en_words)
    f_vi = len(vi_toks) / len(vi_words)
    ratio = len(vi_toks) / len(en_toks)
    print(f"[{name:11s}] EN: {len(en_toks):3d} tokens "
          f"(fertility {f_en:.2f}) | VI: {len(vi_toks):3d} tokens "
          f"(fertility {f_vi:.2f}) | VI/EN = {ratio:.2f}x")


# (2) Huấn luyện 60 lượt gộp BPE tiếng Việt từ mức byte
vi_chunks = [" " + w if i > 0 else w for i, w in enumerate(vi_words)]
seqs = [list(c.encode("utf-8")) for c in vi_chunks]
init_tokens = sum(len(s) for s in seqs)

for step in range(60):
    counts = {}
    for s in seqs:
        for pair in zip(s, s[1:]):
            counts[pair] = counts.get(pair, 0) + 1
    best = max(counts, key=counts.get)
    new_id = 256 + step
    new_seqs = []
    for s in seqs:
        m, i = [], 0
        while i < len(s):
            if i < len(s) - 1 and (s[i], s[i + 1]) == best:
                m.append(new_id)
                i += 2
            else:
                m.append(s[i])
                i += 1
        new_seqs.append(m)
    seqs = new_seqs

final_tokens = sum(len(s) for s in seqs)
print("\nBPE tiếng Việt mở rộng (60 lượt gộp):")
print(f"  Trước khi gộp (byte-level): {init_tokens} tokens "
      f"(fertility {init_tokens/len(vi_words):.2f})")
print(f"  Sau 60 lượt gộp tiếng Việt: {final_tokens} tokens "
      f"(fertility {final_tokens/len(vi_words):.2f})")

[gpt2       ] EN:  51 tokens (fertility 1.21) | VI: 251 tokens (fertility 3.98) | VI/EN = 4.92x
[cl100k_base] EN:  50 tokens (fertility 1.19) | VI: 135 tokens (fertility 2.14) | VI/EN = 2.70x

BPE tiếng Việt mở rộng (60 lượt gộp):
  Trước khi gộp (byte-level): 370 tokens (fertility 5.87)
  Sau 60 lượt gộp tiếng Việt: 162 tokens (fertility 2.57)

Nếu bạn muốn đào sâu hơn nữa, dưới đây là một số bài tập thử thách mở rộng.

Tài liệu tham khảo

1. 1994 Gage. A New Algorithm for Data Compression. The C Users Journal. 2
2. 2012 Schuster & Nakajima. Japanese and Korean Voice Search. ICASSP. 4
3. 2016 Sennrich, Haddow & Birch. Neural Machine Translation of Rare Words with Subword Units. ACL. 2
4. 2018 Kudo. Subword Regularization: Improving Neural Network Translation Models with Multiple Subword Candidates. ACL. 4
5. 2018 Kudo & Richardson. SentencePiece: A simple and language independent subword tokenizer and detokenizer for Neural Text Processing. EMNLP. 4
6. 2019 Radford et al. Language Models are Unsupervised Multitask Learners. OpenAI report. 3
7. 2022 Xue et al. ByT5: Towards a Token-Free Future with Pre-trained Byte-to-Byte Models. TACL. 4
8. 2023 Petrov et al. Language Model Tokenizers Introduce Unfairness Between Languages. NeurIPS. 5