2.2 BPE:从数据压缩到子词词表

本页范围:第 2 章第 2 节 | 整理时间:2026-09-22

快速浏览

核心问题子词词表不是人工制定的,而是从语料里学出来的。BPE 用什么规则、按什么顺序把字符一步步合并成子词?
本节主张BPE 分两个阶段:训练阶段统计语料中最高频的相邻符号对并反复合并,学出一个词表和一串有序的合并规则;编码阶段对新文本按同样的顺序贪心应用这些规则。
一句话结论BPE 用“高频片段合并成词、低频词退回字符(或字节)”的策略,在词表大小与序列长度之间取得平衡;byte-level BPE 把基础词表定为 256 个字节,从根上消灭了 OOV。
关键词
BPE合并规则词表Byte-level BPEGPT-2tiktoken

  2.1 节给出了方向:子词切分是词级与字符级之间的出路。但子词词表不是人工制定的,是从语料里学出来的,怎么学?本节讲最主流的学法 BPE,它的核心动作只有一个:统计最高频的相邻符号对,合并,再统计,再合并。为了把这个动作看透,本节用一份只有 5 个词的迷你语料,把训练过程从头到尾手算一遍,再上升到伪代码和工业界的字节级变体:

  1. 起源:从数据压缩到神经机器翻译(2.2.1):一个 1994 年的压缩算法,如何被搬进 NLP 解决 OOV;
  2. 训练阶段:手工演算一遍(2.2.2):词频统计、初始拆分、逐轮合并,五步流程全程可手算;
  3. 编码阶段:按合并顺序贪心应用(2.2.3):没见过的词如何借助已有片段被拼出来;
  4. 训练算法伪代码(2.2.4):把演算过程压缩成一个 while 循环;
  5. Byte-level BPE:GPT-2 的选择(2.2.5):合并对象换成 UTF-8 字节,基础词表恒定 256,OOV 从机制上消失。

  读完本节,你应该能徒手跑完一轮 BPE 训练,也能说清 GPT-2 词表 50257 这个数字是怎么凑出来的。

  BPE 坐在链路的第二站:文本进门后的第一道加工。先看它的上下游都是谁:

原创示意图 · 非论文原图 原始文本: 「我爱中国」 (输入起点) 分词器: 本节内容:BPE (第 2 章) Embedding 层: 查表:ID → 词向量 (3.1 节) 位置编码: 注入“第几格” (3.2–3.5 节) Transformer 层: 注意力与前馈 ×N (第 4 章) 输出投影: 算各 token 的概率 (4.6 节) 采样: 吐出下一个 token (第 12 章) 生成的新 token 接回输入,继续循环(自回归,第 12 章) 浅色实线框:输入起点 紫底框:本节内容 虚线框:后续章节
图 1:BPE 分词在前向链路中的位置。它是链路的第二站:原始文本先进来,切成 token ID 后交给 Embedding(3.1 节),后面各站在对应章节展开。

  「切成 token ID」这个动作放大看,就是一套逐对合并的流程。用「我爱中国」在 minimind 分词器上的真实结果画出来:

原创示意图 · 非论文原图 局部放大:分词器——输入文本,输出 3 个 token ID 输入:原始文本(minimind 分词器实测) 「我爱中国」 ① 拆成单字 我 爱 中 国 每个字先自成一个 token ② 逐对合并 我 爱 中 国 最优先的对:中 + 国(合并表第 1113 位,共 6108 条) 其余各对在合并表中没有更优先的规则,停止合并 ③ 输出 我 爱 中国 ID = 463 ID = 2043 ID = 1405 这 3 个 ID 交给 Embedding 层查词向量(3.1 节)
图 2:BPE 分词的逐对合并流程(数字均为 minimind 分词器实测)。先把每个字拆成单字 token,再按合并表的优先级逐对合并:「中 + 国」是这里最优先的对(合并表第 1113 位,共 6108 条规则),合成一整块;没有更优先的对之后停止,输出 3 个 token 及其 ID。词表与合并表如何从语料统计出来,见 2.2.2 节的手工演算。

2.2.1 起源:从数据压缩到神经机器翻译

  BPE 的全称是 Byte Pair Encoding(字节对编码)。它本来是 1994 年 Philip Gage 发表在 C Users Journal 上的一种数据压缩算法,思路朴素:反复把数据里出现次数最多的相邻字节对替换成一个没用过的新字节,一份数据就能用更少的符号写下来。

  2016 年,Sennrich、Haddow 和 Birch 在 ACL 论文《Neural Machine Translation of Rare Words with Subword Units》中把这个压缩算法搬到了神经机器翻译里。他们的动机正是 2.1 节讲的 OOV 痛点:翻译系统的词表再大,也总会遇到没收录的稀有词、人名、外来词。BPE 给出的解法是让词表自己从语料中长出来:核心动作只有一个——数数,然后合并,统计语料里最高频的相邻符号对,捏成一个新符号,反复进行,直到词表长到目标大小。这样常见词整块留下,稀有词拆成高频片段,任何词都有出路。此后 BPE 成为神经机器翻译的标配,又被 GPT 系列沿用,成了今天主流 LLM 分词器的基底算法。

2.2.2 训练阶段:手工演算一遍

  训练 BPE 的目标是学出两样东西:一个词表,和一串有先后顺序的合并规则。下面用一个出自 Hugging Face LLM Course 第 6 章的经典小例子,从零开始完整走一遍。先把本节要用到的几个词立清楚,后面每一步都会用到:

术语含义在本例中是什么
语料(corpus)用来训练分词器的全部文本,真实场景是几十亿条人能看懂的完整句子。句子要先预切成词、统计词频,才轮到 BPE 登场极度简化:整个语料只有 5 个词——hug、pug、pun、bun、hugs,连同各自词频
词频每个词在语料中出现的次数。统计相邻对时要按词频加权,出现 10 次的词里的相邻对要算 10 次hug 出现 10 次,pun 出现 12 次,依此类推
拆分表算法的内部工作区:记录每个词此刻被切成了哪些符号。它会随每轮合并不断变化。注意它是加工中间产物,不是语料的原貌一开始每个词被拆成单字符,如 hug → h u g
相邻符号对拆分表里紧挨着的两个符号,是统计和合并的对象h u g 里有 (h,u) 和 (u,g) 两对
词表(vocabulary)训练结束时所有合法符号的清单,从单字符开始,随合并不断增长初始 7 个字符,最终 10 个符号
合并规则每轮合并留下的一条记录 (A, B)→AB。规则的先后顺序本身就是训练产物,编码时要严格按序应用(u,g)→ug 是第 1 条,(u,n)→un 是第 2 条

  术语就位后,整个训练流程是五步:语料 → 词频统计 → 初始拆分 → 反复合并 → 收敛产出。逐步来看。

第 0 步:准备语料,统计词频

  BPE 不直接吃句子。真实场景里,语料是一个超长的句子清单,可以想象成一个几百 GB 的 txt 文件,一行一句话,几十亿行。先要按空格和标点把句子预切成词,统计每个词出现过多少次,得到一张词频表,BPE 从这张表起步。

  为了让每一步都能手算,本例把语料极度简化:假设全部语料只有 5 个拼写相近的词,不多也不少。它们共享字母组合,正好适合观察合并过程。词频表如下:

词hugpugpunbunhugs
词频1051245

第 1 步:把每个词拆成单字符,得到初始拆分表

  BPE 的思路是从小往大长:一开始假装不认识任何多字母组合,只认识单个字符,把每个词打散成字符序列,再从统计中逐步发现哪些字符老粘在一起。「打散」这个动作逐词展示如下——第一行是拆分前的原词,第二行是拆分后的字符序列,整张表就是初始拆分表:

拆分前(原词)hugpugpunbunhugs
拆分后(字符序列)h u gp u gp u nb u nh u g s

  再强调一次:这张表是算法的内部表示,语料本身一直是那些完整句子和单词,拆散只发生在这张内部工作表里。拆散只是为了让合并有一个最小的起点——如果不先拆成字符,算法连第一对「相邻符号」都找不到。

第 2 步:初始化词表

  把拆分表里出现过的所有字符收进词表,共 7 个:[b, g, h, n, p, s, u]。这是词表的起点,接下来每合并出一个新符号,词表就长一格。

第 3 步:进入「统计 → 合并 → 更新」循环

  每一轮做三件事:数出拆分表里所有相邻符号对的频次(按词频加权),把最高的那一对合并成新符号,再用新符号更新拆分表。逐轮演算:

  1. 第 1 轮:统计所有相邻符号对,按词频加权。u-g 出现在 hug(10 次)、pug(5 次)、hugs(5 次)中,共 20 次,全场最高。合并 u + g 得到新符号 ug,加入词表。拆分表更新:hug → h ug,pug → p ug,hugs → h ug s。
  2. 第 2 轮:基于新拆分重新统计。u-n 出现在 pun(12 次)、bun(4 次)中,共 16 次,最高。合并 u + n 得到 un。拆分表更新:pun → p un,bun → b un。
  3. 第 3 轮:h-ug 出现在 hug(10 次)、hugs(5 次)中,共 15 次,最高。合并 h + ug 得到 hug。拆分表更新:hug → hug(整词),hugs → hug s。

第 4 步:达到目标大小,收敛产出

  假设此时词表达到了预设的目标大小,训练停止。最终词表为 [b, g, h, n, p, s, u, ug, un, hug],合并规则按学习顺序记录为 (u,g)→ug、(u,n)→un、(h,ug)→hug。注意规则的顺序本身就是训练产物,编码时要严格按这个顺序应用。

  BPE 学到的词表是频率驱动的:出现得越多的片段越早成为独立 token。训练语料的构成因此直接决定词表的内容,换一批语料就要重新训练分词器,不能拿来即用。

2.2.3 编码阶段:按合并顺序贪心应用

  词表和合并规则学好后,编码一个新词的方法是先把它拆成字符,再按训练时学到的先后顺序逐条尝试合并规则,能合就合,不能合就跳过:

  • bug:拆成 b、u、g。第 1 条规则 (u,g)→ug 适用,得到 b、ug;后两条规则不适用。最终切分为 b + ug。bug 这个词从未在训练语料里出现,但借助 ug 这个片段被顺利表示,这正是子词泛化能力的体现。
  • hugs:拆成 h、u、g、s。应用 (u,g)→ug 得 h、ug、s;再应用 (h,ug)→hug 得 hug、s。最终切分为 hug + s。
  • 没参与任何合并的字符保留原样,落回基础词表里的单字符 token。

  因为基础词表覆盖了语料中所有字符,这个例子里不存在编码失败的词。经典的 BPE 分词器还会先做预切分(比如按空格和标点把句子切成词),再在每个片段内部跑上述合并流程(不设预切分的 SentencePiece 是例外,见 2.4 节)。

  把 2.2.2 和 2.2.3 合起来看,整条流水线是:分词器训练一次并封存,产出词表和有序合并规则;之后模型训练和推理阶段的所有文本,都按这套冻结的规则切词查 ID,模型只认这套词表。新词永远进不了词表,只是被词表里已有的零件拼出来——词表有限,能表示的词无限。也正因如此,词表一旦封盘就不能换:换词表等于 Embedding 矩阵行数对不上,整个模型要重训。

2.2.4 训练算法伪代码

  把上面的过程写成算法,就是下面这个循环:

function 训练BPE(语料, 目标词表大小):
    词频表 ← 统计语料中每个词的出现次数
    拆分表 ← 每个词拆成字符序列
    词表   ← 所有出现过的字符
    合并规则 ← 空列表
    while 词表大小 < 目标词表大小:
        频次表 ← 按词频加权,统计拆分表中所有相邻符号对的频次
        (A, B) ← 频次最高的符号对
        词表   ← 词表 ∪ {AB}          # 新符号入词表
        合并规则 ← 合并规则 + [(A, B)]  # 顺序即优先级
        拆分表 ← 所有 (A, B) 替换为 AB  # 更新拆分,进入下一轮
    return 词表, 合并规则

  编码函数同样简单:把输入拆成字符后,从合并规则列表的第一条开始扫描,凡是能应用的就应用,直到没有规则可匹配。两份产物合在一起就是一个完整的 BPE 分词器。

2.2.5 Byte-level BPE:GPT-2 的选择

  字符级 BPE 有一个隐蔽的漏洞:基础词表是“语料里出现过的字符”。多语言场景下字符集极大,汉字、 emoji、各种变音符号加起来数以万计,基础词表还没开始合并就已经很臃肿,而且语料里没出现过的字符依然会 OOV。

  GPT-2(Radford et al., 2019)给出的解法是把 BPE 直接跑在 UTF-8 字节上,称为 byte-level BPE:

  • 任何文本按 UTF-8 编码后都是一串字节,字节只有 256 种取值,所以基础词表固定为 256 个字节,与语料无关;
  • 汉字、emoji、乱码、罕见符号都能拆成字节表示,从机制上杜绝了 OOV;
  • GPT-2 的词表大小为 50257:256 个字节 + 50000 条合并规则学出的符号 + 1 个特殊 token。
Byte-level BPE 在 UTF-8 字节序列上运行的 BPE

合并的对象从字符换成字节,其余逻辑一字不改。好处是基础词表恒定 256 且对任意文本封闭:一个汉字在 UTF-8 下占 3 个字节,即使词表里没有这个汉字本身,也总能用字节把它拼出来。

  工程实现上,OpenAI 开源的 tiktoken 是 GPT 系列模型的官方 byte-level BPE 分词器,用 Rust 实现、速度极快;想读一份短小清晰的教学实现,可以看 Andrej Karpathy 的 minbpe,几百行 Python 完整复现了训练与编码两条路径。

  词表大小是一个超参数,由人在训练分词器前指定,不是算法学出来的。BPE 学到的是“在这个预算下选哪些合并”。词表越大,平均序列越短、语义越完整,但 Embedding 层参数越多、稀有 token 训练越不充分;主流 LLM 的取值从 3 万到 25 万不等。GPT-2 选了 5 万条合并,只是一个具体的工程取值。

  BPE 的故事到这里就完整了:一个压缩算法被改造成词表学习器,又在字节层面补上了最后的 OOV 缺口。下一节看另外两条子词路线:WordPiece 和 Unigram,它们换了合并(或剪枝)的评分标准,思路各有千秋。

🧭本节要点回顾
BPE 为什么要先训练学规则,再谈编码?
词表和合并顺序是从语料频率中学出来的,编码只是按学到的顺序贪心重放。没有这个顺序,同一串字符可能有多种合并不确定性,切分结果就不唯一,模型输入也就不稳定。
byte-level BPE 为什么能彻底杜绝 OOV?
任何文本按 UTF-8 编码后都是字节序列,而字节只有 256 种,全部收进基础词表。再罕见的字符、再新的词都能拆成字节兜底,不存在词表之外的输入。
词表大小由什么决定?
它是人工设定的超参数:训练时合并到目标大小就停(如 GPT-2 的 50000 条合并加 256 字节加 1 个特殊 token)。取值要在序列长度、Embedding 参数量和稀有 token 训练充分性之间权衡。

参考来源

  • Gage, 1994. A New Algorithm for Data Compression(C Users Journal,BPE 压缩算法的原始出处)。
  • Sennrich, Haddow & Birch, 2016. Neural Machine Translation of Rare Words with Subword Units(ACL,arXiv:1508.07909,BPE 引入神经机器翻译的原始论文)。
  • Radford et al., 2019. Language Models are Unsupervised Multitask Learners(GPT-2 报告,byte-level BPE 与词表大小 50257 的出处)。
  • Hugging Face LLM Course, Chapter 6: Tokenization(hug/pug/pun/bun/hugs 手工演算例子与训练伪代码)。
  • Karpathy, minbpe(github.com/karpathy/minbpe,byte-level BPE 教学实现);OpenAI tiktoken(GPT 系列官方分词器)。