ZHY's Blog
A UNIVERSE OF IDEAS · BY ZHANG HAOYI
让好奇心 点亮知识宇宙
在代码、模型与思想之间自由漫游。这里持续记录人工智能、机器学习、软件工程与成长实践，让每次阅读都成为一次新的发现。
ARTICLE NOTE
在大型语言模型（LLM）的整个技术栈中，分词器（Tokenizer）常常是被最多人忽视、却又最容易引发各种“诡异问题”的环节。
Andrej Karpathy在一次著名的讲座中指出：LLM中大量的奇怪行为和问题都可以追溯到分词器——比如模型为何无法正确处理简单的字符串反转任务，为何在非英语语言上性能显著下降，为何在看到特定字符串时会“宕机” —— 这些问题的根源往往不在模型架构，而在于文本进入模型之前的“第一公里” —— 如何将原始文本转化为模型可以理解的数字序列。
本文将从零开始逐行实现一个完整的 字节级BPE（Byte-Pair Encoding）分词器。深入理解BPE算法的每一个设计决策，剖析GPT-2风格预分词策略的微妙之处，并最终在TinyStories数据集上训练出一个可用的分词器。
本文配套的代码实现参考了Stanford CS336课程作业的设计思路，所有核心逻辑均从零编写，不依赖任何第三方分词库。
在探讨BPE的具体实现之前，我们有必要先理解一个问题：为什么大语言模型不直接用空格分词？
最直观的分词方式是按空格和标点将文本切分为单词。对于英语这样的语言，这种方法看似自然，但存在两个致命缺陷：
<UNK>（Unknown）标记，这意味着模型彻底丢失了该词的任何信息。一个极端是直接用单个字符作为token。这彻底解决了OOV问题，但带来了新的麻烦：序列长度急剧膨胀。一个英文单词平均5-6个字符，这意味着模型需要处理5-6倍长度的序列，而Transformer的注意力机制复杂度是的——序列每增长一倍，计算量增长四倍。
BPE（Byte-Pair Encoding） 提供了一条中间道路。它不把单词当作不可分割的最小单元，也不退回到单个字符，而是学习出一套子词（subword） 的词汇表。
BPE的核心思想极其简洁：从最细的粒度（单个字节或字符）出发，反复合并数据中出现频率最高的相邻单元对，直到词汇表达到预定大小。
这种做法的妙处在于：
<UNK>；BPE最初是1994年提出的一种数据压缩算法，2015年被Sennrich等人引入神经机器翻译，随后被GPT-2采用并推广为LLM分词的事实标准。今天，GPT、Llama、Mistral等所有主流LLM都在使用BPE或其变体来训练分词器。
传统BPE在字符级别操作——词汇表初始化为训练语料中出现的所有字符。但这种方法有一个隐患：如果测试时遇到训练语料中从未出现过的Unicode字符（比如一个罕见的表情符号），它依然会被映射为<UNK>。
GPT-2引入了一个巧妙的改进：不在字符级别操作，而在UTF-8字节级别操作。UTF-8编码中，任何字符（包括所有Unicode字符）都可以表示为一个或多个字节的序列。字节只有256种可能 —— 这恰好构成了BPE的初始词汇表：
vocab = {i: bytes([i]) for i in range(256)} # 256个基础字节这意味着任何文本——无论是英语、中文、阿拉伯语，还是emoji、特殊符号——都可以被无损地表示为这256个基础字节的组合。OOV问题在字节级BPE中从根本上不存在了。
当然，直接使用字节序列会有代价：一个中文字符在UTF-8中占3个字节，如果完全不做合并，序列长度会膨胀3倍。而BPE的合并过程正是要解决这个问题——通过迭代合并高频字节对，逐步将常见的字节序列（如某个中文字符的3个字节、常见英文词缀等）压缩为单个token。
在train_bpe函数中，基础词汇表的初始化正是从256个字节开始的：
vocab: Dict[int, bytes] = {i: bytes([i]) for i in range(256)}cur_id: int = 256 # 新token的id从256开始分配vocab是一个从token ID到字节序列的映射。ID 0-255 分别对应单个字节b'\x00'到b'\xff'。所有后续通过合并产生的新token，其ID将从256开始依次递增。
在初始化基础词汇表之后，BPE训练需要做的第一件事是将特殊token（special tokens）加入词汇表。
特殊token是永远不会被拆分成多个子词、始终被视为一个整体的标记。它们通常用于标记文本中的特殊结构：
<|endoftext|>：GPT系列使用的文档结束标记[CLS] / [SEP]：BERT使用的分类标记和分隔标记<s> / </s>：某些模型使用的句子开始/结束标记这些token在训练和推理中具有特殊的语义含义，必须保证它们在分词过程中保持完整，不能被BPE的合并规则拆散。
for spe_t in special_tokens: if len(vocab) >= vocab_size: break spe_b = spe_t.encode("utf-8") if spe_b not in cur_bytes: vocab[cur_id] = spe_b cur_bytes.add(spe_b) cur_id += 1这段逻辑的关键点在于：
特殊token的引入是在BPE训练开始之前完成的 —— 它们不参与后续的合并过程，也不会被拆散。
BPE的核心操作是“合并相邻的token对”。但这里有一个微妙的问题：我们是否允许跨单词边界进行合并？
如果允许跨单词合并，那么”hello world”中的”lo”（来自”hello”的末尾）和” wo”（来自” world”的开头）可能会被合并，产生跨越单词边界的token —— 这显然不符合我们对语言结构的直觉。
预分词（Pre-tokenization） 的作用正是在BPE合并之前，将文本切分成若干边界明确的片段，确保BPE的合并操作不会跨越这些边界。
GPT-2引入的预分词策略已经成为后续模型的事实标准。其核心是一个精心设计的正则表达式。
GPT-2的预分词正则表达式如下：
PRETOKENIZER_PATTERN = r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""这个表达式由多个子模式通过|（或）连接而成，匹配时按从左到右的顺序尝试。下面逐一拆解每个子模式的设计意图：
子模式1：'(?:[sdmt]|ll|ve|re)
's、'd、'm、't、'll、've、're。例如：“they’re” → 被拆分为 "they" 和 "'re"；“don’t” → 被拆分为 "don" 和 "'t"子模式2：?\p{L}+
\p{L}是Unicode属性，匹配任何语言的字母字符（拉丁字母、汉字、阿拉伯字母等）。前面的?表示可选的一个空格。"hello" → 匹配为 "hello"；" hello" → 匹配为 " hello"（保留前导空格）；"世界" → 匹配为 "世界"（中文汉字同样被\p{L}匹配）子模式3：?\p{N}+
\p{N}匹配任何数字字符（不限于0-9，还包括全角数字等）。子模式4：?[^\s\p{L}\p{N}]+
.、,、!、?等）；emoji表情（😊、🎉等）；特殊符号（@、#、$等）子模式5：\s+(?!\S)
(?!\S)是一个否定前瞻断言，确保后面不跟非空白字符——即只匹配末尾的空白。子模式6：\s+
空格要保留在token前面的原因
?\p{L}+等模式中的空格是放在字母前面的（?在\p{L}+之前）。这意味着匹配结果中，空格是作为token的前缀被保留的，如" hello"而非"hello "。这个设计有深刻的用意：在GPT-2的BPE词表中，空格是有意义的——“apple”和” apple”会被视为不同的token（后者在实现中通常表示为
Ġapple，Ġ代表空格）。这种设计使得模型能够区分”词首”和”词中”的同一单词，有助于学习词边界信息。
在train_bpe中，预分词分为两步：
第一步：按特殊token分割文本
text_chunks = regex.split('|'.join(map(regex.escape, special_tokens)), text)这确保特殊token被单独分离出来，不会与普通文本混在一起参与BPE训练。
第二步：对每个chunk应用GPT-2预分词正则
token_freqs = defaultdict(int)for chunk in text_chunks: for word in regex.findall(PRETOKENIZER_PATTERN, chunk): word_bytes = word.encode("utf-8") bytes_list = [bytes([b]) for b in word_bytes] token_freqs[tuple(bytes_list)] += 1每个匹配到的“词”（即预分词片段）被转换为单字节的元组，并记录其频率。token_freqs的键是tuple[bytes]（如(b'h', b'e', b'l', b'l', b'o')），值是这个词在语料中出现的总次数。
关键设计决策：token_freqs存储的是每个预分词片段内部的字节序列，不同片段之间的字节不会被统计为相邻对。这确保了BPE的合并永远不会跨越预分词边界。
BPE训练的本质是一个贪心压缩过程：每次选择当前语料中出现频率最高的相邻token对进行合并，将合并后的新token加入词汇表，然后重复这一过程，直到词汇表达到预定大小或没有更多可合并的对。
其高层伪代码如下：
在深入训练循环之前，先理解代码中使用的关键数据结构：
token_freqs : Dict[Tuple[bytes, ...], int] —— 键是预分词片段的字节序列（元组形式），值是该片段在语料中出现的总次数。pair_freqs : Dict[Tuple[bytes, bytes], int] —— 键是相邻的token对（两个字节序列），值是该对在所有片段中出现的总次数。token_seq_to_pairs : Dict[Tuple[bytes, ...], Set[Tuple[bytes, bytes]]] —— 缓存每个片段中包含的所有相邻token对，用于加速“哪些片段受本次合并影响”的查找。token_seq_to_pairs是一个关键的性能优化。如果没有这个缓存，每次合并后都需要遍历所有片段并检查其中是否包含best_pair —— 复杂度为。有了这个缓存，便可以在时间内判断一个片段是否受某次合并影响。
在开始迭代合并之前，我们需要统计所有相邻token对的初始频率：
pair_freqs = defaultdict(int)for token_seq, freq in token_freqs.items(): for i in range(len(token_seq) - 1): pair = (token_seq[i], token_seq[i+1]) pair_freqs[pair] += freq对于每个预分词片段（如(b'h', b'e', b'l', b'l', b'o')），我们遍历其中所有相邻的token对(token_seq[i], token_seq[i+1])，将该对的频率加上该片段的出现频率。
while len(vocab) < vocab_size: if not pair_freqs: break
# 1. 选择频率最高的合并对 max_freq = max(pair_freqs.values()) most_freq_pairs = [pair for pair, freq in pair_freqs.items() if freq == max_freq] best_pair = max(most_freq_pairs) # 频率相同时选择字典序最大的
# 2. 创建新token并更新词汇表 new_token = best_pair[0] + best_pair[1] vocab[cur_id] = new_token merges.append(best_pair) cur_id += 1
# 3. 找出受本次合并影响的片段 affected_tokens_freqs = [ (token_seq, freq) for token_seq, freq in token_freqs.items() if best_pair in token_seq_to_pairs[token_seq] ]
# 4. 更新受影响的片段 for token_seq, freq in affected_tokens_freqs: # 4a. 从pair_freqs中移除旧token对的贡献 for i in range(len(token_seq) - 1): old_pair = (token_seq[i], token_seq[i+1]) pair_freqs[old_pair] -= freq if pair_freqs[old_pair] <= 0: del pair_freqs[old_pair]
# 4b. 构建新的token序列（将所有best_pair替换为new_token） new_token_seq = [] i = 0 while i < len(token_seq): if i < len(token_seq) - 1 and (token_seq[i], token_seq[i+1]) == best_pair: new_token_seq.append(new_token) i += 2 else: new_token_seq.append(token_seq[i]) i += 1 new_token_seq = tuple(new_token_seq)
# 4c. 将新token序列产生的对频率添加到pair_freqs for i in range(len(new_token_seq) - 1): new_pair = (new_token_seq[i], new_token_seq[i+1]) pair_freqs[new_pair] += freq
# 4d. 更新token_freqs和token_seq_to_pairs del token_freqs[token_seq] token_freqs[new_token_seq] = freq del token_seq_to_pairs[token_seq] new_pairs_set = set() for i in range(len(new_token_seq) - 1): new_pairs_set.add((new_token_seq[i], new_token_seq[i+1])) token_seq_to_pairs[new_token_seq] = new_pairs_set步骤1：选择最高频的相邻对
当多个token对具有相同的最高频率时，代码选择字典序最大的那个。这是一种确定性的tie-breaking策略。不同的tie-breaking策略（如字典序最小、随机选择）会产生略微不同的合并结果，但在大规模语料上差异通常很小。
步骤2：创建新token
新token就是两个被合并token的字节序列拼接。例如，如果best_pair = (b'h', b'e')，则new_token = b'he'
步骤3-4：更新频率表（核心难点）
这是BPE训练中最微妙的部分。将best_pair合并为new_token后，所有包含best_pair的片段都发生了变化，进而影响到哪些相邻token对仍然存在（旧的被移除，新的被加入）；这些相邻token对的频率。
采用先减后加的策略：
pair_freqs中减去该片段的频率；pair_freqs中。这种做法的正确性依赖于一个关键事实：每次合并只影响包含best_pair的片段。不包含best_pair的片段，其内部的所有相邻对都不变。
训练在以下两种情况下终止：
len(vocab) >= vocab_size）；pair_freqs为空）。在真实训练中，第二种情况很少发生——只要语料足够大，总会有频率至少为1的相邻对存在。
训练完成后，得到了两个产物：
vocab : 从token ID到字节序列的映射merges : 按训练顺序排列的合并规则列表现在需要用它们来编码新的文本 —— 将任意输入字符串转换为token ID序列。
编码的核心挑战是如何确定性地应用合并规则？
给定一个字节序列，可能存在多种应用合并规则的方式。例如，假设合并规则包含(b'a', b'b') -> b'ab'和(b'b', b'c') -> b'bc'，对于字节序列b'abc'，是先合并ab还是先合并bc？
答案是：按照合并规则被学习的顺序（优先级）来应用。最早被学习的合并规则具有最高优先级。在编码时，每一步都选择当前序列中存在的、优先级最高的合并规则来执行。
class Tokenizer: def __init__(self, vocab, merges, special_tokens=None): self.vocab = vocab self.merges = merges self.special_tokens = special_tokens or [] self.merge_priorities: Dict[Tuple[bytes, bytes], int] = { pair: i for i, pair in enumerate(self.merges) } self.byte_to_id: Dict[bytes, int] = {v: k for k, v in self.vocab.items()}merge_priorities是一个从token对到优先级索引的映射 —— 索引越小，优先级越高（越早被学习）。这使得编码时可以在时间内查询任意token对的合并优先级。
def _apply_bpe_merge(self, bytes_seq: bytes) -> List[bytes]: cur_bytes: List[bytes] = [bytes([b]) for b in bytes_seq]
while len(cur_bytes) > 1: # 1. 找出当前序列中所有可合并的token对 exist_pairs: Set[Tuple[bytes, bytes]] = set() for i in range(len(cur_bytes) - 1): pair = (cur_bytes[i], cur_bytes[i+1]) if pair in self.merge_priorities: exist_pairs.add(pair) if not exist_pairs: break
# 2. 选择优先级最高的token对 best_pair = min(exist_pairs, key=lambda pair: self.merge_priorities[pair])
# 3. 执行合并 new_bytes: List[bytes] = [] i = 0 while i < len(cur_bytes): if i < len(cur_bytes) - 1 and (cur_bytes[i], cur_bytes[i+1]) == best_pair: new_bytes.append(cur_bytes[i] + cur_bytes[i+1]) i += 2 else: new_bytes.append(cur_bytes[i]) i += 1
cur_bytes = new_bytes
return cur_bytes这个算法的核心逻辑是贪心应用最高优先级的合并：
merge_priorities值最小）的一对；关键点：每次只合并一个token对（优先级最高的那个），而不是一次性合并所有可合并的对。这是因为合并一个对之后，可能会产生新的可合并对（如合并ab后产生abc），这些新对的优先级可能高于原本第二优先级的对。
def encode(self, text: str) -> List[int]: if not text: return []
# 1. 构建特殊token的正则模式 sorted_special_tokens = sorted(self.special_tokens, key=len, reverse=True) special_token_pattern = '|'.join(map(regex.escape, sorted_special_tokens))
# 2. 按特殊token分割文本 if self.special_tokens: chunks = regex.split(f'({special_token_pattern})', text) else: chunks = [text]
# 3. 处理每个chunk token_ids: List[int] = [] for chunk in chunks: if not chunk: continue
if chunk in self.special_tokens: # 特殊token直接编码 special_token_bytes = chunk.encode("utf-8") special_token_id = self.byte_to_id[special_token_bytes] token_ids.append(special_token_id) else: # 普通文本：预分词 -> BPE合并 -> 查表 for token in regex.findall(PAT, chunk): bpe_token_bytes = self._apply_bpe_merge(token.encode("utf-8")) for token_bytes in bpe_token_bytes: token_id = self.byte_to_id[token_bytes] token_ids.append(token_id)
return token_ids编码流程可以概括为四个层次：
_apply_bpe_merge进行合并；byte_to_id查找对应的token ID。解码是编码的逆过程，但简单得多：
def decode(self, token_ids: List[int]) -> str: bytes_seq = b''.join(self.vocab[id] for id in token_ids) return bytes_seq.decode("utf-8", errors="replace")解码不需要BPE合并规则 —— 只需要将每个token ID映射回对应的字节序列，将所有字节序列拼接，然后用UTF-8解码为字符串。
errors="replace"参数确保即使遇到无效的UTF-8字节序列（鲁棒性考虑），也不会抛出异常，而是用�（U+FFFD）替换无效字节。
if __name__ == "__main__": special_tokens = ["<|endoftext|>"] vocab, merges = train_bpe( "data/TinyStoriesV2-GPT4-valid.txt", 20000, special_tokens ) print(f"训练完成，最终词汇表大小: {len(vocab)}") # 18017 print(f"生成了 {len(merges)} 次合并。") # 17760在TinyStories验证集（约4.5MB文本）上训练，目标词汇表大小为20,000：
在训练过程中，pair_freqs在某些迭代中可能为空（没有更多可合并的对），或者某些特殊token的加入占用了词汇表空间但并未增加合并次数。
.dat文件训练好的分词器可以用于将文本数据集转换为token ID序列，以便后续的模型训练：
def text_to_dat(text_file, dat_file, tokenizer): with open(text_file, 'r', encoding='utf-8') as f: text = f.read()
tokens = tokenizer.encode(text) token_array = np.array(tokens, dtype=np.uint16)
fp = np.memmap(dat_file, dtype=np.uint16, mode='w+', shape=token_array.shape) fp[:] = token_array[:] fp.flush()这里使用np.memmap将token序列直接写入磁盘，便于后续高效加载——模型训练时可以直接内存映射这个文件，无需一次性将全部数据加载到内存中。
不同vocab_size的选择对分词效果有显著影响：
| 词汇表大小 | 优点 | 缺点 |
|---|---|---|
| 较小（如1K-5K） | 嵌入层参数少，模型更紧凑 | 序列较长，罕见词被拆分为过多子词 |
| 较大（如20K-100K） | 序列更短，常见词保留完整 | 嵌入层参数多，训练和推理开销大 |
在实际应用中，词表大小需要在编码效率（序列长度）和模型复杂度（词表大小）之间权衡。GPT-2使用50,257的词表，GPT-4进一步扩展，Llama系列使用32K，而DeepSeek-V3则扩展到了128K词汇表以优化多语言压缩效率。
总结本文从零实现了完整的字节级BPE分词器，涵盖了从训练到编码解码的全流程。深入理解了以下几个关键设计决策：
- 字节级BPE：以256个基础字节为起点，从根本上消除了OOV问题；
- 预分词：GPT-2风格的正则表达式确保合并不会跨越词边界，同时保留空格信息；
- 贪心合并：每次选择频率最高的相邻token对进行合并，这是一种简单而有效的压缩策略；
- 优先级编码：编码时按照合并被学习的顺序应用规则，保证确定性。
BPE分词器虽然只是LLM技术栈中很小的一环，但它决定了模型“看到”的输入是什么样的——分词器的质量直接影响模型的泛化能力和鲁棒性。理解分词器的工作原理，是深入理解LLM行为的基础。
按顺序完成这组文章，循序渐进地掌握主题
发现错误、内容过时或有改进想法？欢迎告诉我
根据本文分类与标签，为你推荐可能感兴趣的内容
系统讲解如何将Transformer的各个组件组合成完整的可训练语言模型：从TransformerBlock的Pre-Norm与Post-Norm架构对比入手，剖析残差连接如何保障深层网络梯度流动；深入模块化设计中的权重加载接口；拆解TransformerLM四大核心组件（Token Embedding → N层TransformerBlock → Final RMSNorm → LM Head）及其超参数设计的权衡考量；完整跟踪从token ID到logits的前向传播数据流（形状变换全程）。
阅读文章
系统讲解Transformer注意力机制的核心原理与完整实现：从数值稳定的Softmax出发，推导缩放点积注意力的数学公式与几何意义；深入剖析因果掩码的下三角矩阵机制及其在自回归语言模型中的关键作用；详解多头注意力的拆分与合并逻辑及并行计算优势；最后阐述RoPE旋转位置编码如何直接融入注意力计算，与因果掩码协同实现带位置感知的因果注意力。
阅读文章
系统讲解Transformer核心模块的从零实现：从线性层的矩阵乘法本质与截断正态初始化策略出发，深入词嵌入层的查表机制与参数规模计算；推导RMSNorm相比LayerNorm的归一化原理与计算效率优势；剖析SwiGLU门控激活函数的三矩阵结构（W₁/W₂/W₃）及其参数量权衡；最后完整推导RoPE旋转位置编码的数学原理——从二维平面旋转矩阵到复数视角的高维扩展，以及theta参数对旋转频率的控制与编码质量的影响。
阅读文章请使用微信扫描二维码分享
当前文章会保持在原页面