Hướng dẫn dùng AI

Token và tokenizer: AI cắt chữ thế nào

Bạn gửi cho mô hình một câu tiếng Việt, nhưng thứ mô hình thật sự nhận là một dãy số. Bước biến chữ thành dãy số đó do tokenizer, hay bộ tách token, đảm nhận. Hiểu bộ tách làm gì giúp bạn giải thích nhiều chuyện tưởng lạ: vì sao giá API tính theo token, vì sao cùng một câu mà tiếng Việt tốn hơn tiếng Anh, vì sao mô hình đôi khi đếm sai số chữ cái trong một từ. Bài này tự cài một bộ tách BPE nhỏ bằng Python để bạn thấy tận mắt.

Ý chính
  • Mô hình ngôn ngữ không đọc chữ cái hay từ, mà đọc token: những mảnh chữ đã được đánh số. Bộ tách (tokenizer) là bước cắt văn bản thành các mảnh đó.
  • Phần lớn bộ tách hiện nay dùng biến thể của BPE: bắt đầu từ ký tự hoặc byte, lặp lại việc gộp cặp hay đi cùng nhau nhất.
  • Chữ tiếng Việt có dấu chiếm 2 đến 3 byte trong UTF-8, và tiếng Việt thường ít xuất hiện hơn tiếng Anh trong dữ liệu học, nên một câu tiếng Việt hay bị cắt thành nhiều token hơn.
  • Mỗi mô hình có bộ tách riêng. Muốn biết chính xác một đoạn tốn bao nhiêu token, hãy đếm bằng công cụ của đúng mô hình đó.

Bài dùng Python thuần, không cần thư viện ngoài. Các nguồn tham khảo gồm chương BPE trong khóa học LLM của Hugging Face, bài báo của Sennrich và cộng sự năm 2016, trang Token counting của Claude và tài liệu module unicodedata, đọc ngày 11/11/2026.

Mô hình đọc gì

Mạng nơ-ron chỉ làm việc với số. Để đưa một câu vào mô hình, ta cần một cách biến chữ thành dãy số nguyên, mỗi số ứng với một mục trong một bảng từ vựng cố định. Mỗi mục trong bảng gọi là một token. Sau đó mỗi số được đổi thành một vectơ, như bài embedding là gì đã trình bày, rồi mới đi vào các lớp tính toán.

Câu hỏi là nên cắt chữ ở mức nào. Cắt theo từ thì bảng từ vựng phải cực lớn, và gặp từ mới như tên riêng, lỗi chính tả, tiếng lóng thì không biết làm gì. Cắt theo từng ký tự thì bảng nhỏ, nhưng câu trở nên rất dài, mô hình phải xử lý nhiều bước hơn và khó nắm nghĩa. Giải pháp phổ biến nằm ở giữa: cắt theo mảnh từ (subword). Từ hay gặp thành một token trọn vẹn; từ hiếm bị tách thành vài mảnh nhỏ hơn mà mô hình đã biết.

BPE học cách cắt như thế nào

BPE, viết tắt của byte pair encoding, vốn là một thuật toán nén dữ liệu. Năm 2016, Sennrich và cộng sự đưa nó vào dịch máy để xử lý từ hiếm, và từ đó nó trở thành nền của nhiều bộ tách. Khóa học của Hugging Face liệt kê GPT, GPT-2, RoBERTa, BART và DeBERTa là các mô hình dùng BPE.

Cách học rất đơn giản. Ban đầu, mỗi từ trong kho chữ được viết thành dãy ký tự, kèm một dấu kết thúc từ. Thuật toán đếm xem cặp ký hiệu đứng cạnh nhau nào xuất hiện nhiều nhất trong toàn kho, rồi gộp cặp đó thành một ký hiệu mới và ghi lại thành một luật gộp. Lặp lại việc đếm và gộp cho tới khi đủ số luật mong muốn. Bảng từ vựng cuối cùng gồm các ký tự ban đầu cộng các ký hiệu sinh ra từ những lần gộp.

Khi gặp văn bản mới, bộ tách áp dụng lần lượt các luật đã học theo đúng thứ tự. Từ nào đã gặp nhiều lần trong kho sẽ được gộp trọn thành một token. Từ chưa từng gặp vẫn tách được, chỉ là thành nhiều mảnh nhỏ hơn, trong trường hợp xấu nhất là từng ký tự.

Bộ tách BPE học thế nào Gộp dần các cặp hay đi cùng nhau 1. Từng ký tựh, ọ, c, _25 token 2. Đếm cặpCặp hay gặp nhấtđầu tiên: t + r 3. Gộp, lặp lại10 luật: 15 token30 luật: 5 token 4. Từ lạTách mảnh nhỏtrìu: tr, ì, u Kho chữ trong ví dụ rất nhỏ, do bài tự viết
Bộ tách BPE học thế nào 1. Từng ký tựh, ọ, c, _25 token 2. Đếm cặpCặp hay gặp nhấtđầu tiên: t + r 3. Gộp, lặp lại10 luật: 15 token30 luật: 5 token 4. Từ lạTách mảnh nhỏtrìu: tr, ì, u Kho chữ trong ví dụ rất nhỏ, do bài tự viết
Hình 1. Bộ tách BPE học bằng cách gộp dần các cặp hay đi cùng nhau: (1) bắt đầu từ từng ký tự như h, ọ, c và dấu kết thúc từ, câu mẫu có 25 token; (2) đếm cặp hay gặp nhất, cặp đầu tiên được gộp là t với r; (3) gộp và lặp lại, sau 10 luật câu còn 15 token, sau 30 luật còn 5 token; (4) từ lạ như "trìu" vẫn tách được thành tr, ì, u. Kho chữ trong ví dụ rất nhỏ, do bài tự viết.

Ví dụ bằng Python

Chương trình mẫu tự cài BPE trong khoảng năm mươi dòng. Hàm so_byte cho biết một chữ chiếm bao nhiêu byte khi mã hóa UTF-8. Hàm hoc_bpe nhận kho chữ và số luật cần học. Hàm tach cắt một từ bằng các luật đã học. Kho chữ là vài câu về học lập trình do bài tự viết, lặp lại ba lần, nên rất nhỏ so với kho chữ thật.

"""Token và tokenizer: tự cài một bộ tách BPE (byte pair encoding) cỡ nhỏ để thấy mô hình "cắt chữ" thế nào.

- so_byte: một chữ tiếng Việt có dấu chiếm bao nhiêu byte UTF-8 (đơn vị gốc của nhiều bộ tách hiện nay);
  cùng chữ "ệ" nhưng viết dạng dựng sẵn (NFC) hay tổ hợp (NFD) cho số byte khác nhau.
- hoc_bpe: bắt đầu từ từng ký tự, lặp lại việc gộp cặp ký hiệu đứng cạnh nhau hay gặp nhất (theo Sennrich và cộng sự, 2016).
- tach: dùng các luật gộp đã học để cắt một từ mới thành token.
Kho chữ trong ví dụ là vài câu tự viết, rất nhỏ; bộ tách của mô hình thật học từ kho chữ khổng lồ nên kết quả khác.
"""
import unicodedata
from collections import Counter

KET = "_"  # dấu kết thúc từ, để "an" cuối từ khác "an" giữa từ


def so_byte(chu):
    return len(chu.encode("utf-8"))


def _dem_cap(tu_dien):
    dem = Counter()
    for ky_hieu, so_lan in tu_dien.items():
        for a, b in zip(ky_hieu, ky_hieu[1:]):
            dem[(a, b)] += so_lan
    return dem


def _gop(ky_hieu, cap):
    ra, i = [], 0
    while i < len(ky_hieu):
        if i + 1 < len(ky_hieu) and (ky_hieu[i], ky_hieu[i + 1]) == cap:
            ra.append(ky_hieu[i] + ky_hieu[i + 1])
            i += 2
        else:
            ra.append(ky_hieu[i])
            i += 1
    return tuple(ra)


def hoc_bpe(van_ban, so_luat):
    tu_dien = Counter(tuple(t) + (KET,) for t in van_ban.lower().split())
    luat = []
    for _ in range(so_luat):
        dem = _dem_cap(tu_dien)
        if not dem:
            break
        cap = max(dem, key=lambda c: (dem[c], c))  # hòa thì lấy theo thứ tự chữ, để lần nào chạy cũng như nhau
        luat.append(cap)
        tu_dien = Counter({_gop(k, cap): v for k, v in tu_dien.items()})
    return luat


def tach(tu, luat):
    ky_hieu = tuple(tu.lower()) + (KET,)
    for cap in luat:
        ky_hieu = _gop(ky_hieu, cap)
    return list(ky_hieu)


def dem_token(cau, luat):
    return sum(len(tach(t, luat)) for t in cau.split())


KHO = ("học lập trình học thuật toán học trí tuệ nhân tạo lập trình python "
       "thuật toán sắp xếp thuật toán tìm kiếm học máy học sâu trí tuệ nhân tạo "
       "lập trình thi đấu lập trình web học lập trình mỗi ngày") * 3


def chay_thu():
    dong = []
    for chu in ["a", "ă", "ệ", "học", "trình", "learn"]:
        dong.append(f"'{chu}': {len(chu)} ký tự, {so_byte(chu)} byte")
    to_hop = unicodedata.normalize("NFD", "ệ")
    dong.append(f"'ệ' viết dạng tổ hợp (NFD): {len(to_hop)} ký tự, {so_byte(to_hop)} byte")
    cau = "học lập trình thuật toán"
    for n in [0, 10, 30]:
        luat = hoc_bpe(KHO, n)
        dong.append(f"{n} luật gộp: '{cau}' -> {dem_token(cau, luat)} token")
    luat = hoc_bpe(KHO, 30)
    dong.append(f"Từ đã gặp 'trình' -> {tach('trình', luat)}")
    dong.append(f"Từ chưa gặp 'trìu' -> {tach('trìu', luat)}")
    print("\n".join(dong))
    return dong


if __name__ == "__main__":
    chay_thu()

Kết quả cho thấy ba điều. Thứ nhất, chữ "a" chiếm 1 byte, "ă" chiếm 2 byte, "ệ" chiếm 3 byte; từ "học" có 3 ký tự nhưng 5 byte, còn "learn" có 5 ký tự và đúng 5 byte. Thứ hai, câu "học lập trình thuật toán" có 25 token khi chưa gộp gì (20 ký tự cộng 5 dấu kết thúc từ), còn 15 token sau 10 luật và chỉ 5 token sau 30 luật, tức mỗi từ thành một token. Thứ ba, từ "trình" đã gặp nhiều lần nên thành một token trọn vẹn, còn "trìu" chưa từng xuất hiện nên bị cắt thành ba mảnh.

Cũng nên để ý dòng về chữ "ệ" viết dạng tổ hợp. Cùng một chữ trên màn hình, nhưng nếu được gõ thành chữ "e" cộng hai dấu rời (dạng NFD theo chuẩn Unicode) thì nó là 3 ký tự và 5 byte, thay vì 1 ký tự và 3 byte ở dạng dựng sẵn NFC. Văn bản tiếng Việt chép từ nhiều nguồn có thể trộn hai dạng này. Hàm unicodedata.normalize trong thư viện chuẩn đưa về một dạng thống nhất; nên làm bước đó trước khi đếm, so sánh hay tìm kiếm chữ.

Vì sao tiếng Việt tốn token hơn

Bộ tách của nhiều mô hình hiện nay làm việc trên byte chứ không trên ký tự. Khóa học Hugging Face giải thích rằng bộ tách của GPT-2 nhìn chữ dưới dạng byte, nên bảng gốc chỉ có 256 mục mà vẫn biểu diễn được mọi ký tự, không bao giờ gặp ký tự lạ. Cái giá là chữ có dấu bắt đầu từ 2 hoặc 3 byte thay vì 1.

Điều quan trọng hơn là dữ liệu học. Luật gộp được học từ kho chữ, mà kho chữ của các mô hình lớn thường có tiếng Anh chiếm phần nhiều. Những cụm tiếng Anh hay gặp được gộp thành token trọn vẹn sớm; những âm tiết tiếng Việt ít gặp hơn thì có thể vẫn bị cắt thành vài mảnh. Ví dụ trong bài thể hiện đúng hiện tượng này ở quy mô nhỏ: từ có trong kho chữ được gộp trọn, từ vắng mặt bị cắt vụn. Kết quả là cùng một ý, bản tiếng Việt thường tốn nhiều token hơn bản tiếng Anh. Mức chênh cụ thể tùy mô hình, nên bài không nêu con số chung.

Token ảnh hưởng gì tới bạn

Token là đơn vị tính tiền và đơn vị đo giới hạn. Giá API ghi theo triệu token đầu vào và đầu ra; cửa sổ ngữ cảnh, tức lượng chữ mô hình đọc được trong một lần, cũng tính bằng token. Một tài liệu dài vừa vặn với bản tiếng Anh có thể vượt giới hạn khi là bản tiếng Việt.

Mỗi mô hình có bộ tách riêng, nên đừng dùng số đếm của mô hình này cho mô hình khác. Trang Token counting của Claude ghi rằng từ Claude Opus 4.7 trở đi các mô hình dùng bộ tách mới, cùng một đoạn văn cho số token cao hơn khoảng 30% so với các mô hình trước đó, và khuyên đếm lại trên đúng mô hình định dùng. Cách đếm qua API được trình bày trong bài đếm token khi gọi API; tài liệu cũng lưu ý con số trả về là ước lượng, có thể lệch chút ít so với lúc gửi thật.

Bộ tách còn giải thích vài lỗi quen thuộc. Mô hình thấy "strawberry" là vài token chứ không phải mười chữ cái, nên câu hỏi kiểu "từ này có mấy chữ r" có thể khó với nó. Tương tự, phép tính trên số dài, đảo ngược một chuỗi hay đếm ký tự đều làm việc ở mức nhỏ hơn token, nên dễ sai. Gặp việc như vậy, hãy nhờ mô hình viết một đoạn code thay vì tự làm trong đầu.

Thử với bộ tách thật

Sau khi hiểu ý tưởng, bạn có thể thử các bộ tách thật. Thư viện tokenizers và transformers của Hugging Face cho phép tải bộ tách của nhiều mô hình mở và xem một câu bị cắt thế nào, kèm số hiệu của từng token. Với mô hình đóng như Claude, cách chắc chắn nhất là gọi công cụ đếm token mà nhà cung cấp đưa ra. Một bài tập hay là lấy cùng một đoạn văn, viết bằng tiếng Việt có dấu, tiếng Việt không dấu và tiếng Anh, rồi so số token trên vài bộ tách khác nhau. Ghi kết quả lại kèm tên mô hình và ngày đo, vì bộ tách có thể đổi khi ra phiên bản mới.

Nếu muốn đi sâu hơn, hãy mở rộng code mẫu: chuyển từ làm việc trên ký tự sang làm việc trên byte, thêm bước chuẩn hóa NFC, rồi thử học trên một kho chữ lớn hơn như vài chục bài báo. Bạn sẽ thấy các âm tiết tiếng Việt quen thuộc lần lượt được gộp thành token trọn vẹn khi kho chữ đủ lớn.

Cẩn thận
  • Coi một token bằng một từ hay một chữ cái.
  • Dùng số token đếm trên mô hình này để ước chi phí cho mô hình khác.
  • Trộn chữ dựng sẵn và chữ tổ hợp trong cùng một tập dữ liệu mà không chuẩn hóa.
  • Nhờ mô hình đếm ký tự hay đảo chuỗi trong đầu thay vì viết code.
  • Tin một tỉ lệ "một token bằng bốn ký tự" cho cả tiếng Việt.

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

Một token bằng bao nhiêu chữ?

Không cố định. Từ hay gặp có thể là một token; từ hiếm bị cắt thành vài mảnh. Muốn chắc thì đếm bằng công cụ của mô hình.

Viết tiếng Việt không dấu có tiết kiệm token không?

Có thể tốn ít token hơn, nhưng mô hình dễ hiểu sai nghĩa. Thường không đáng đánh đổi.

Các mô hình có dùng chung bộ tách không?

Không. Mỗi họ mô hình có bộ tách riêng, đôi khi đổi giữa các phiên bản.

Bộ tách có học cùng lúc với mô hình không?

Thường bộ tách được học trước, trên kho chữ, rồi giữ cố định trong lúc huấn luyện mô hình.

Học tiếp

Nếu bạn muốn học Python và AI 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