Skip to content

BPE 与字节级 BPE(Byte-Level BPE)

详解 BPE 合并算法、Byte-Level BPE 的 UTF-8 映射、GPT-4/LLaMA 3 预分词与实现。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是 BPE(字节对编码)?

BPE(Byte Pair Encoding) 是 GPT、LLaMA、Qwen、DeepSeek 等绝大多数现代大模型共同采用的主流分词算法。它原本是一种数据压缩算法,核心思路极其朴素:从单个字符(或 UTF-8 字节)出发,不断统计语料里最常挨在一起出现的一对符号,把它们合并成一个新词元,循环几万次直到攒够目标词表大小。

这样常见词(如 the、人工智能)会合并成单个 Token,生僻词则自动拆成常见词根或字节,彻底告别“词表外未知词(UNK)”报错。

01 从 1994 年的文件压缩到 GPT-4 的统一入口 ​

如果你打开 GPT-4(tiktoken)、LLaMA 3、Qwen2.5 或 DeepSeek-V3 的底层代码,会惊讶地发现它们在入口处用的竟然是同一个核心算法——字节级 BPE(Byte-Level BPE)。

更让人意想不到的是,BPE 最初根本不是为 AI 发明的。1994 年 Philip Gage 设计它只是为了给磁盘文件做 无损数据压缩:把文件里最常挨在一起出现的两个字节替换成一个新字节,反复压缩体积。2016 年 Sennrich 等人(arXiv:1508.07909 ↗)灵机一动把它搬进神经机器翻译切分罕见词;2019 年 GPT-2 论文(Radford et al., 2019 ↗)又做了一处天才改造——不再以成千上万个 Unicode 字符起步,而是先转成 UTF-8 字节流,从固定的 256 个基础字节起步,彻底终结了 `<unk>` 未知词噩梦。

类比 · 256 块万能乐高底砖

早期字符级 BPE 就像给全世界每种语言、每个生僻汉字、每个新出的 Emoji 都单开一套模具,光是基础件就把十几万预算吃光了;而 字节级 BPE 发现,计算机里一切文字、代码和表情包底层全是由 0x00 到 0xFF 这 256 种单字节底砖 拼出来的。哪怕明天人类发明一个全新火星文符号,大不了退回几块单字节底砖拼装,永远不会卡壳!

核心设问

纯靠“哪两个挨着出现最多就把谁焊起来”,这套朴素到近乎直白的贪心算法,怎么防止把单词和标点乱粘在一起?推理编码时为什么不能图省事直接“挑最长的词切”?

02 三个直觉画面:乐高焊枪、防跨界隔板与“按辈分归约” ​

画面一:训练 = 乐高自动焊枪 ​

假设目标词表是 100,000,初始词表已有 256 个单字节,那训练只需做 99,744 轮极简循环:

  1. 扫一遍整个语料库,数一数哪两个相邻词元出镜率最高(比如 t 和 h);
  2. 拿起焊枪把语料里所有相邻的 t + h 焊成一块新积木 th,发给它 256 号身份证,并把这条规则按顺序记在《合并说明书》(Merge Table)第 1 行;
  3. 下一轮接着数,可能 th 和 e 成了新冠军,再焊成 257 号 the……如此反复,高频整词自动长成大块积木,冷门词停留在词根甚至单字节。

画面二:正则预分词 = 拼装盘里的防串味隔板 ​

如果放任焊枪满篇自由焊接,很快就会焊出 dog.、dog?、dog!、dog, 一堆只差一个标点的冗余废品,白白浪费词表名额。

类比 · 便当盒里的隔板设计

为了防串味,GPT-2 到 GPT-4 / LLaMA 3 在焊接前加了一道 正则表达式预分词(Regex Pre-tokenization),相当于在便当盒里放上硬隔板——把文本先切成英文词、中文块、1–3 位数字、标点和代码缩进空白,规定焊枪绝对不许跨过隔板把两格里的东西焊到一起。正是这几行不起眼的正则,把 Python 代码缩进压缩了近三成,还让算术数字规整地按 1–3 位对齐。

画面三:推理编码 = 严格按“出生证编号”复原 ​

很多人手写 BPE 编码时最爱犯的错,是拿着词表从左到右“能匹配多长就切多长”。这是错的!

类比 · 拆装顺序不能乱的鲁班锁

BPE 的每块大积木都有严格的“父子血缘树”。推理编码一段新文本时,必须先拆回单字节,然后每一轮只检查当前序列里所有合法相邻对,专门挑《合并说明书》里编号(rank)最小——也就是训练时最早学会焊接的那一对优先合并,循环直到再也焊不动为止。只有严格按“辈分从小到大”归约,切出来的词元序列才和预训练时的分布严丝合缝。

顺便一提:如果你翻看 GPT-2 或 HuggingFace 的 vocab.json,常会见到诡异的 Ġapple 或 Ċ。别慌,那只是早期为了把不可见的空格(0x20)和换行(0x0A)塞进纯文本 JSON 做的字符马甲;现代 Rust 引擎 tiktoken ↗ 直接在原始 bytes 上飞奔,早就不需要这层伪装了。

03 把关键公式读成人话 ​

BPE 训练每一轮都在求解一个极其干脆的离散优化:

(a∗,b∗)=arg⁡max(a,b)∑i=1Mfi∑j=1|si|−1I(ui,j=a∧ui,j+1=b)

**把训练公式读成直觉:**为了不用反复扫几百 GB 原文,工程上会先把预分词后的相同片段去重打包成 (片段 s_i, 出现次数 f_i)。公式里括号做的事就是:遍历每个去重片段,只要里面出现一次相邻的 (a, b) 就给它加上权重 f_i,最后挑总分最高的 (a*, b*) 焊成新词元。每焊一轮,整个语料库的总词元数恰好减少 count(a*, b*)——它本质上就是在贪心最大化文本压缩率。

推理编码每一步的归约规则同样只有一行:

(a∗,b∗)=arg⁡min(uj,uj+1)∈Mrank(uj,uj+1)

**把推理公式读成直觉:**在当前片段所有相邻词元对里,只看那些出现在合并表 M 中的合法组合,谁的训练诞生序号 rank 最小,就立刻先把谁焊起来,直到没有任何相邻对能匹配合并表为止。

04 它在模型里怎么工作 & 与上下游的关系 ​

字节级 BPE 是当代生成式 LLM 数据管线的核心齿轮:

  • 上游规则与语料采样:作为 分词器总览 里的主流路线,BPE 因为纯看频次,如果 预训练数据工程 里 90% 是英文,中文和代码就会被饿死;工业界训练 BPE 前必须用温度采样 piτ 刻意抬高低资源语言与代码的比例。
  • 横向流派对照:与 BPE“唯频率论”不同,另一大阵营 WordPiece 与 Unigram LM 分别用点互信息(PMI)和全局概率似然来决定子词去留,各有千秋。
  • 下游查表与推理流式输出:BPE 产出的 ID 序列进入 词嵌入层 映射为向量,压缩率越高,模型在同等算力下能装下的 长上下文 就越长;而在推理 流式解码 吐字给前端时,Byte-Level BPE 的多字节汉字特性又给工程埋下了一个必知细节。

05 三代 BPE 演化速查与三个避坑备忘 ​

演化版本典型词表数字正则策略关键进步代表模型
字符级 BPE10k∼32k简单空格切分首次将 BPE 引入 NLP,但仍有 `<unk>`早期 NMT
GPT-2 BBPE50,257\p{N}+ 不限长256 原生字节实现零 OOV,但多语言与代码缩进弱GPT-2/3、RoBERTa
cl100k / LLaMA 3100k∼128k\p{N}{1,3} 三位分块大幅优化代码缩进空白与算术切分,tiktoken 极速引擎GPT-4、LLaMA 3
o200k / Qwen2.5152k∼200k1–3 位或单数字精细区分非拉丁脚本,非英语词元消耗直降 30%~50%GPT-4o、Qwen2.5
  1. 流式输出(SSE)千万别逐 token 硬 decode:在字节级 BPE 里,生僻汉字(3 字节)或 Emoji(4 字节)常被拆成几个单字节词元依次吐出。如果你每收到 1 个 token 就调 .decode("utf-8", errors="replace"),前端会闪出一堆 `` 乱码!正确做法是维护增量字节缓冲区,凑齐完整 UTF-8 字符再吐出。
  2. 特殊控制词元必须在正则之前拦截:像 `<|eot_id|>`、`<|im_start|>` 这类对话边界标记,必须在进正则之前当作原子整体切出,否则会被拆成碎字符导致对话失控;但对普通用户输入的文本要默认禁止解析特殊词元,防 Prompt 注入攻击。
  3. 警惕“中继废品词元”与正则卡死:如果 a+b -> ab 后紧接着每次都和 c 焊成 abc,中间的 ab 留在词表里却永不单独出现,白占坑位(Picky BPE, 2024 ↗ 提出了训练期动态剔除);工程上还要防复杂正则遇到超长连续空格触发回溯卡死(ReDoS)。

需要查阅 GPT-2 到 o200k 的完整正则表达式拆解、堆 + 双向链表 O(Nlog⁡N) 优化思路以及自包含可运行的 ByteLevelBPETokenizer 完整 Python 代码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

字节对编码(Byte Pair Encoding, BPE)最初由 Philip Gage 于 1994 年提出用于通用 无损数据压缩,2016 年由 Sennrich 等人引入神经机器翻译以解决罕见词问题,并在 2019 年经由 GPT-2 改进为字节级 BPE(Byte-Level BPE, BBPE)。作为 子词分词范式 的绝对主力,从 GPT-3/GPT-4(tiktoken)、LLaMA 3 到 Qwen2.5、DeepSeek-V3,几乎所有当代旗舰生成式大语言模型均采用带正则预分词的字节级 BPE 作为核心分词引擎,将文本切分为离散 ID 后送入 词嵌入层(并与 WordPiece / Unigram 形成鲜明技术路线对比)。

直观理解

BPE 就像一款“高频积木自动拼接机”:一开始,所有文本都被拆成最基础的 256 种单字节乐高小块;接着机器反复扫描整片语料库,每轮找出相邻出现次数最多的一对小块(例如 t 和 h),把它们焊成一块新积木 th 并写进说明书(合并表);如此重复数万次,常见词就自动长成了整块大积木,而任何罕见符号或表情包大不了退回基础单字节拼装,永远不会卡壳。

问题动机与演进背景 ​

经典的字符级 BPE(Character-Level BPE)直接以语料中出现的所有 Unicode 字符作为初始基础词表。这种设计在多语言与开放域互联网文本上会遭遇严重瓶颈:Unicode 标准包含超过 14 万 个码位(汉字、生僻表意文字、各语种变音符、Emoji 与数学符号),仅初始化基础字符表就会耗尽绝大部分词表预算;若强行截断低频字符,则又重新引入了无法还原的 <unk> 未知词。

GPT-2 提出的 Byte-Level BPE 给出了极其优雅的解法:先将任意字符串编码为 UTF-8 字节流,使基础词表严格锁定为固定的 256 个单字节(0x00 至 0xFF)。任何合法 Unicode 文本都能被无损表示为这 256 个基础单元的序列,彻底消灭了 <unk>。同时,为了防止算法无休止地跨越单词与标点边界合并出如 dog.、dog?、dog! 之类的冗余变体,GPT-2 至 GPT-4/LLaMA 3 引入了日益精细的正则表达式预分词(Regex Pre-tokenization)。

核心原理与数学推导 ​

1. BPE 训练:迭代贪心频率合并 ​

设初始语料经预分词后切分为若干独立片段(Chunks),统计各片段的出现频次,得到带权词袋 W={(si,fi)}i=1M,其中每个片段 si=(ui,1,ui,2,…,ui,Li) 初始由 UTF-8 字节序列组成,初始词表 V0={0,1,…,255},目标词表大小为 Vtarget。

在第 t=1,2,…,Vtarget−256 步迭代中:

  1. 统计相邻词元对频率:对所有相邻二元组 (a,b)∈Vt−1×Vt−1,计算其在语料中的加权总频次:count(a,b)=∑i=1Mfi∑j=1|si|−1I(ui,j=a∧ui,j+1=b)
  2. 贪心选择最优合并对:选取频次最高的二元组 (a∗,b∗)=arg⁡max(a,b)count(a,b)。
  3. 注册新词元并重写语料:分配新词元 ID ct=255+t,记录有序合并规则 (a∗,b∗)→ct(赋予优先级秩 rank(a∗,b∗)=t),更新词表 Vt=Vt−1∪{ct},并将所有片段中互不重叠的相邻 (a∗,b∗) 原地替换为 ct。

容易证明,每次合并使语料总词元数严格减少 count(a∗,b∗),因此训练过程等价于在贪心意义下最大化语料压缩率。

2. BPE 编码(Inference):按合并秩顺序归约 ​

给定训练好的合并秩表 rank:(a,b)↦{1,…,K},编码一段新文本的严格算法如下:

  1. 先用相同的正则表达式将文本切分为若干互不跨界合并的预分词片段;
  2. 将每个片段编码为 UTF-8 字节序列;
  3. 在当前片段中,反复寻找所有相邻词元对里 rank(uj,uj+1) 最小(即训练时最早学会合并)的那一对,将其全部合并为新词元,直至序列中不再存在任何合法的合并对。

注意编码顺序

推理编码必须严格遵循最小合并秩优先(Lowest Rank First),而不是从左到右贪心最长匹配(Longest Prefix Match)。因为子词的构造具有层级依赖树,只有按训练合并的先后顺序归约,才能保证与训练分布切分完全一致。

3. UTF-8 字节到可见字符的双向映射 ​

早期工具链(如 HuggingFace tokenizers 沿用的 GPT-2 vocab.json)为了将不可打印字节(如 0x00 控制符、空格 0x20、换行 0x0A)可读地保存为纯 JSON 文本,定义了 bytes_to_unicode() 双射:将 ASCII 可打印字节直接映射到自身,而将空格(0x20)映射到 Ġ(U+0120)、换行(0x0A)映射到 Ċ(U+010A)等拉丁扩展字符。

需要注意的是,现代原生字节级引擎(如 OpenAI tiktoken)直接在原始 bytes 对象上运行 BPE,完全不需要 Ġ 伪装映射;但在查看词表 JSON 时理解 Ġ 代表前导空格,对排查分词问题至关重要。

4. 正则预分词演进(GPT-2 → GPT-4 cl100k → o200k / LLaMA 3) ​

正则预分词直接决定了哪些字符允许被粘在一起。对比三代典型模式的核心设计演变:

  • GPT-2: 's|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+
    • 保留英语缩写('s, 'll);将前导空格粘在单词前;数字未限长(\p{N}+ 导致长数字乱切);未忽略大小写;多个空格被拆分。
  • GPT-4(cl100k_base)与 LLaMA 3: (?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+
    • 加入 (?i:...) 支持大写缩写(如 'S);
    • 将 \p{N}+ 改为 \p{N}{1,3},强制数字最多每 3 位切分,改善算术对齐;
    • 将 \s+(?!\S) 与多空格块保留,大幅压缩 Python 代码缩进;
    • [^\r\n\p{L}\p{N}]?\p{L}+ 允许非换行标点附着在词首,减少符号碎片化。
  • GPT-4o(o200k_base): 词表扩大至 200k,进一步用 Unicode 类别区分大小写字母组合与非拉丁脚本(如中、日、韩、印度语系与阿拉伯语),使非英语文本的词元消耗降低 30%∼50%。

算法架构 / 数据流图 ​

图表加载中...

复杂度与横向对比表 ​

实现 / 演进版本基础词元集合典型词表规模预分词数字策略编码速度与工程实现代表模型
经典字符级 BPE语料 Unicode 字符集10k∼32k简单空格切分易遇 OOV 退化为 <unk>早期 NMT、RoBERTa 前身
GPT-2 Byte-Level BPE256 原始字节(映射 Ġ)50,257\p{N}+ 不限长零 OOV,英文为主,代码缩进压缩弱GPT-2、GPT-3、RoBERTa
cl100k_base / LLaMA 3256 原生字节100k∼128k\p{N}{1,3} 三位分块Rust tiktoken 吞吐达数十 MB/sGPT-4、LLaMA 3/3.1
o200k_base / Qwen2.5256 原生字节152k∼200k1-3 位或单数字强化多语言正则与代码空白压缩GPT-4o、Qwen2.5

核心 Python 参考实现 ​

下面给出一个完全自包含、可直接运行的 Byte-Level BPE(含简化正则预分词、训练、按最小秩编码与无损 UTF-8 解码) 参考实现:

python
import re
from collections import Counter


# 简化版预分词正则:分离英文缩写、带可选前导空格的词、1-3位数字、空白与标点
PRETOK_PATTERN = re.compile(
    r"""'s|'t|'re|'ve|'m|'ll|'d| ?[A-Za-z]+| ?[\u4e00-\u9fff]+|[0-9]{1,3}| ?[^\sA-Za-z0-9\u4e00-\u9fff]+|\s+(?!\S)|\s+"""
)


class ByteLevelBPETokenizer:
    """教学级字节级 BPE 分词器,完整展示训练、按最小 rank 编码与解码逻辑。"""

    def __init__(self) -> None:
        # merges: {(id_a, id_b): new_id},插入顺序即代表合并优先级 rank
        self.merges: dict[tuple[int, int], int] = {}
        # vocab: {token_id: raw_bytes}
        self.vocab: dict[int, bytes] = {i: bytes([i]) for i in range(256)}

    @staticmethod
    def _merge_once(ids: list[int], pair: tuple[int, int], new_id: int) -> list[int]:
        """在单个序列中将不重叠的相邻 pair 全部替换为 new_id。"""
        out: list[int] = []
        i, n = 0, len(ids)
        while i < n:
            if i + 1 < n and ids[i] == pair[0] and ids[i + 1] == pair[1]:
                out.append(new_id)
                i += 2
            else:
                out.append(ids[i])
                i += 1
        return out

    def train(self, text: str, vocab_size: int) -> None:
        assert vocab_size >= 256, "字节级 BPE 词表大小至少为 256"
        num_merges = vocab_size - 256

        # 1. 正则预分词并转为 UTF-8 字节列表,按频次去重加速统计
        chunk_counts = Counter(PRETOK_PATTERN.findall(text))
        sequences: list[tuple[list[int], int]] = [
            (list(chunk.encode("utf-8")), freq) for chunk, freq in chunk_counts.items()
        ]

        # 2. 迭代贪心合并最高频字节对
        for step in range(num_merges):
            pair_stats: Counter[tuple[int, int]] = Counter()
            for ids, freq in sequences:
                for a, b in zip(ids, ids[1:]):
                    pair_stats[(a, b)] += freq

            if not pair_stats:
                break

            best_pair = max(pair_stats, key=pair_stats.get)
            new_id = 256 + step
            self.merges[best_pair] = new_id
            self.vocab[new_id] = self.vocab[best_pair[0]] + self.vocab[best_pair[1]]

            sequences = [
                (self._merge_once(ids, best_pair, new_id), freq) for ids, freq in sequences
            ]

    def _encode_chunk(self, chunk_bytes: bytes) -> list[int]:
        """严格按训练时合并顺序(最小 new_id 即最小 rank)归约单个字节片段。"""
        ids = list(chunk_bytes)
        while len(ids) >= 2:
            # 找出当前序列中已注册且 rank 最小(即 new_id 最小)的相邻对
            candidates = [(self.merges[p], p) for p in zip(ids, ids[1:]) if p in self.merges]
            if not candidates:
                break
            new_id, best_pair = min(candidates, key=lambda x: x[0])
            ids = self._merge_once(ids, best_pair, new_id)
        return ids

    def encode(self, text: str) -> list[int]:
        token_ids: list[int] = []
        for chunk in PRETOK_PATTERN.findall(text):
            token_ids.extend(self._encode_chunk(chunk.encode("utf-8")))
        return token_ids

    def decode(self, ids: list[int]) -> str:
        raw_bytes = b"".join(self.vocab[i] for i in ids)
        # 使用 errors="replace" 防止模型推理截断产生不完整 UTF-8 字节序列时崩溃
        return raw_bytes.decode("utf-8", errors="replace")


if __name__ == "__main__":
    corpus = (
        "Byte-level BPE compresses repeated patterns like transformer, transformation, and transformers. "
        "大语言模型使用字节级 BPE,彻底消除了未知词问题,支持中英文和代码 2025。"
    ) * 5

    tok = ByteLevelBPETokenizer()
    tok.train(corpus, vocab_size=320)

    sample = "transformers 大语言模型 2025!"
    encoded = tok.encode(sample)
    decoded = tok.decode(encoded)
    assert decoded == sample
    print(f"原始字节数: {len(sample.encode('utf-8'))}, 编码词元数: {len(encoded)}")
    print("切分字节片段:", [tok.vocab[i] for i in encoded])

工程实践与常见陷阱 ​

工程实践

  1. 流式解码缓冲不完整 UTF-8 字节:在 Byte-Level BPE 中,单个中文汉字(3 字节)或 Emoji(4 字节)在低频时可能被拆成多个单字节词元逐步生成。流式输出(SSE Streaming)时,切勿对每个 token 单独调用 .decode("utf-8", errors="replace"),否则会出现乱码替换符(U+FFFD);应维护增量字节缓冲(或使用 codecs.getincrementaldecoder("utf-8")()),待凑齐完整 UTF-8 码位后再吐出字符。
  2. 用堆 + 双向链表实现 O(Nlog⁡N) 训练与编码:上面教学代码每步全量扫描序列,实际工程实现(如 tiktoken / Rust tokenizers)通过双向链表维护节点邻接关系,并用优先队列(最大堆)增量更新受影响相邻对的频次,可在数分钟内完成 GB 级语料的分词器训练。
  3. 跨语料域均衡采样训练分词器:BPE 是纯频次驱动的算法;若 预训练语料 中 90% 是英文、5% 是中文,中文词元配额会被严重挤压。工业界通常使用温度采样 piτ(如 τ≈0.3∼0.5)人为抬高低资源语言与代码的占比后再训练 BPE。

常见陷阱

  1. 推理阶段未正确处理特殊词元(Special Tokens):如 <|eot_id|>、<|im_start|> 必须在正则预分词之前作为原子字符串优先切出,否则会被拆成 <、|、eot 等普通子词,导致模型完全无法识别对话轮次边界;同时面向公网用户时,通常需禁用普通用户输入触发控制词元以防 Prompt 注入。
  2. 忽视正则回溯灾难(ReDoS):复杂的 PCRE/Python re 正则在面对恶意超长连续空格或重复标点时可能发生指数级回溯卡死;生产环境务必使用线性时间保证或 Rust fancy-regex / regex 引擎,并对单块预分词长度设置硬上限(如 100 字符截断)。
  3. 贪心 BPE 的“中继幽灵词元”:若合并序列 a + b -> ab 与 ab + c -> abc 连续发生,当 abc 几乎总是整体出现时,中间词元 ab 留在词表中却在编码语料时几乎从未单独出现,白白浪费一个词表槽位并产生欠训练 Embedding。近年研究(如 Picky BPE)已提出在训练期间动态剔除这类无效中继词元。

延伸阅读与参考论文 ​

  • Gage, P. (1994). A New Algorithm for Data Compression. The C Users Journal.
  • Sennrich, R., Haddow, B., & Birch, A. (2016). Neural Machine Translation of Rare Words with Subword Units. ACL 2016. arXiv:1508.07909 ↗
  • Radford, A., et al. (2019). Language Models are Unsupervised Multitask Learners (GPT-2 Byte-Level BPE). OpenAI Paper ↗
  • OpenAI tiktoken 官方仓库与 cl100k_base / o200k_base 规范(2023–2024). GitHub ↗
  • Chizhov, P., et al. (2024). BPE Gets Picky: Efficient Vocabulary Refinement During Tokenizer Training. EMNLP 2024. arXiv:2409.04599 ↗