子词嵌入解决OOV难题全解

可视化演示

动态演示子词嵌入解决OOV难题全解的核心机制，通过概览/流程/对比/趋势四种模式展示关键概念与交互流程。

词嵌入困境

在子词出现之前，NLP 模型处理单词的方式，就像城堡里的乐高仓库：每个单词对应一个固定编号的积木箱，箱子里装着这个词的向量表示。模型把句子中的每个词换算成编号，到仓库里“查表”取出对应的向量。这套体系很直观，但它有一个致命前提——仓库必须认识这个词。

技术上讲，这个仓库就是“固定词表 + 嵌入矩阵”。词表大小为 V 时，嵌入矩阵是一个 V×d 的矩阵，第 t 个词的向量就是矩阵的第 t 行：

其中 \(E\in\mathbb{R}^{V\times d}\) 是嵌入矩阵，\(u_t\) 是词 \(word_t\) 在词表中的编号索引。

问题在于，真实世界的词汇是开放的：新品牌、网络新词、专业术语、拼写变体会源源不断地冒出来。固定词表一旦建立就被画地为牢。遇到词表外的词（OOV），模型只能用特殊的 UNK 标记顶替，而 UNK 的向量是一个“模糊的平均脸”，没有任何语义信息。这就好比乐高大师拿到一块陌生的零件，仓库里查不到编号，只能扔进“杂物箱”——这块积木在这个模型里从此失去了意义。

子词核心思想

乐高大师的智慧在于：从没见过整座城堡不要紧，只要认得出拱门、塔尖这些标准件就够了。子词嵌入的思路一模一样——把单词拆成更小的、反复出现的“标准积木块”，用这些积木块的组合来表示任意单词。这样词汇表就从“词级”降到了“子词级”，规模被大幅压缩，同时几乎不再有真正“未知”的输入。

这个想法有坚实的语言学根基：英语等语言有丰富的形态学结构。playing = play + ing，unhappiness = un + happi + ness。词根承载核心语义，前后缀承载语法和词性变化。子词切分天然地把这些构词单元当作最小积木，等于让模型自己学会了“词根词缀词典”。

组合爆炸在这里是朋友的化身：假设只有 3 万个子词单元，任意两三个拼起来就能覆盖绝大多数英语单词。词表的词汇覆盖面不再是“背了多少个词”，而是“积木类型有多少种”。有限的小积木，拼出无限的词汇，这正是子词方案最迷人的地方。

BPE算法

BPE（Byte Pair Encoding，字节对编码）是子词切分里最经典、最接地气的算法。它不依赖任何语言学知识，只靠一条朴素的统计直觉：如果两个字符频繁地挨在一起，它们就应该被合并成一个积木块。整个训练过程像一位学徒在反复整理积木箱——哪两块积木总被一起用，就把它们粘成一块。

算法从字符级语料出发，每一轮统计当前所有相邻符号对的频次，选最高频的一对合并，形成新的子词符号，重复直到词表达到预设规模。这一过程得到的是一串“合并操作”，也就是合并规则表：

训练完成后，模型拿到一张合并规则表。面对新词时，同样从字符开始，一遍遍套用规则表中“能合并就合并”的操作——注意，这里不需要重新统计频率，规则表是现成的。比如训练时见过 low 和 lower，学会了合并 er，那么推理时遇到生词 lowestness，也能自动把它切分成 low + est + ness。这就是 BPE 解决 OOV 的机制：不与生词硬碰硬，而是把生词拆成训练时见过的熟积木。

WordPiece算法

WordPiece 是 BPE 的“概率版升级”。它同样反复合并相邻符号，但选择合并对象的标准从“出现次数”换成了“语言模型似然增益”。打个比方：BPE 的学徒只看“这两块积木是不是总被一起拿”，而 WordPiece 的师傅会问：“把这两块粘起来，拼出正确模型 的概率提升多少？”

WordPiece 为每个候选子词维护一个概率，合并 \(p,q\) 得到 \(pq\) 时，要求满足：

合并后序列的语言模型概率应当比合并前更高。每轮选择能使似然提升最大的候选对：

WordPiece 与 BPE 最主要的差别就在这：一个是“谁出现得多就合并谁”，一个是“谁合起来更顺就合并谁”。实际效果上，WordPiece 倾向于生成语言上更合理的子词边界，但它需要额外的语言模型来计算概率，训练开销更高。BERT 的词表正是用 WordPiece 构建的，所以它面对生词时，能切分得更“润物细无声”。

子词嵌入表示

拼好积木只是第一步，模型真正要的是“向量”。子词嵌入的完整流程是：先把生词拆成子词序列，查子词向量表拿到每个子词的向量，再把它们合成一个词向量。合并不是简单相加，而是取平均，让每个子词贡献均匀的语义分量。

设生词 \(w\) 被切分为子词 \(s_1, s_2, \ldots, s_k\)，每个子词对应向量 \(g(s_i)\)，则词向量为：

这种表示方式让 OOV 词不再“无家可归”。比如 unknowable 切为 un + know + able，它的向量就由“否定前缀 + 知道 + 形容词后缀”三块积木的向量平均而成——模型即便第一次见它，也能大致感知到它和 known、unknown 有千丝万缕的关系。需要提醒的是，即使是子词也可能有极低频的情况，实践上会用特殊标记兜底，保证任何输入都有向量可查。

工程实践落地

理论落地到工程，有三个关键动作：加载子词模型、控制词表规模、缓存分词结果。目前最主流的工具是 SentencePiece，它把 BPE / WordPiece / unigram 等算法统一封装成“一句代码加载、一句代码切分”的开箱工具。无论是训练自己的词表，还是直接加载 BERT 的 WordPiece 词表，流程都极为标准。

词表规模的选择需要权衡：词表太小，子词碎片化，序列变长，模型计算量上升；词表太大，又回到了“词级嵌入”的老路，OOV 问题复萌。经验上，英文模型常用 32K 或 50K 的词表，中文则在 20K~80K 之间调优。另一个工程细节是缓存：子词切分在同一轮训练中重复出现频率极高，把“字符串→token 序列”的映射结果缓存下来，能省下大量重复计算。

子词方法对中文、日文这类没有自然空格的语言同样适用——这恰恰是它最神奇的地方。中文的“积木”天然是字或词，SentencePiece 可以直接按字符建模，再学习高频相邻字的合并。一个统一的子词管线同时服务中英文，意味着算法工程师再也不用为每种语言手写一套分词器了。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-from collections import defaultdict, Counter class BPE:    def __init__(self, num_merges=10, end_token='_'):        self.num_merges = num_merges        self.end_token = end_token        self.merges = {}        self.word_end = {}     def get_pairs(self, word):        return set(zip(word, word[1:]))     def learn_bpe(self, corpus):        freq = Counter()        for w in corpus:            chars = list(w) + [self.end_token]            self.word_end[tuple(chars)] = self.word_end.get(tuple(chars), 0) + 1        vocab = {tuple(list(w) + [self.end_token]): c for w, c in self.word_end.items()}        for i in range(self.num_merges):            pairs = Counter()            for tokens, count in vocab.items():                for p in self.get_pairs(tokens):                    pairs[p] += count            if not pairs:                break            best = max(pairs, key=pairs.get)            self.merges[best] = '(' + best[0] + ',' + best[1] + ')'            new_vocab = {}            for tokens, count in vocab.items():                merged = self.merge_word(tokens, best)                new_vocab[merged] = new_vocab.get(merged, 0) + count            vocab = new_vocab     def merge_word(self, tokens, pair):        out, i = [], 0        while i < len(tokens):            if i < len(tokens) - 1 and (tokens[i], tokens[i+1]) == pair:                out.append(tokens[i] + tokens[i+1])                i += 2            else:                out.append(tokens[i])                i += 1        return tuple(out)     def tokenize_word(self, word):        tokens = tuple(list(word) + [self.end_token])        while len(tokens) > 1:            pairs = self.get_pairs(tokens)            best_key = None            for p in pairs:                if p in self.merges:                    if best_key is None or pairs_order(p) < pairs_order(best_key):                        best_key = p            if best_key is None:                break            tokens = self.merge_word(tokens, best_key)        return [t for t in tokens if t != self.end_token]  def pairs_order(pair):    return 0  def main():    corpus = ['low', 'lower', 'lowest', 'new', 'newer', 'newest', 'newerest']    bpe = BPE(num_merges=8)    bpe.learn_bpe(corpus)    print('merge rules:', bpe.merges)    for w in ['lowestness', 'newerest', 'unknown']:        pieces = bpe.tokenize_word(w)        print(w, '->', pieces)  if __name__ == '__main__':    main()

1. from collections import defaultdict, Counter引入计数器，为频次统计做准备。
2. self.merges = {}合并规则表，训练的核心产出物，推理阶段的“积木图鉴”。
3. self.word_end[tuple(chars)] = ...给每个单词末尾加结束标记，让词尾模式被正确建模。
4. pairs[p] += count对每个词内相邻字符对计数，权重是该词在语料中的频次。
5. best = max(pairs, key=pairs.get)挑出本轮最高频的字符对，这是 BPE 的决策核心。
6. self.merges[best] = ...把合并规则存入字典，记录这个“粘积木”动作。
7. tokens = self.merge_word(tokens, best)把当前词中所有出现该对的位置全部合并。
8. pairs = self.get_pairs(tokens)推理时重新获取相邻对，逐对查规则表。
9. if p in self.merges只合并训练中学过的规则，未学过的相邻对保持原样。
10. [t for t in tokens if t != self.end_token]去掉结束标记，输出最终子词序列。

常见误区

面试题