文本预处理：WordPiece子词分词

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

子词切分概述：三箱积木

阿乐面前摆着三箱积木。第一箱是“整词积木”——每个单词一个模具，词库里有多少词就得有多少种模具。今天"play"、"plays"、"playing"、“played“就是四种不同的积木，明天新造一个词”playful“，仓库又没有模具了，只好挂一个”未知零件“（UNK）的牌子。这是词级切分的痛点：词表爆炸、开放词表脆弱。第二个箱子里全是1×1的小方粒，26个字母就能拼一切，但拼一个”playing”要七块，句子一长就积木成灾，模型要处理的序列长度让人头大。这是字符级切分的短板：序列过长、单个字符几乎不携带语义。

WordPiece从这两个极端里找到第三条路：子词级切分。它把单词切成有意义的中间粒度，比如"playing" → "play" + “##ing“。这样既不扩大词表到失控，又能让”play“这个语义核心在”player”"playground"里反复复用。子词的词表规模可控，常见词保留整体，罕见词被拆成常见块，模型既能看到词根又不会面对无穷无尽的整词。

回到积木的比喻，子词就是那些设计精良的标准砖块：尺寸适中、可复用率高、拼法灵活。整词积木太笨重，1×1小粒太琐碎，标准积木才是阿乐眼里性价比最高的一套。

合并准则：看稳固性，不看出镜率

假设阿乐要决定仓库里添置哪种新积木，候选有“th“和”##pi“两对。如果按BPE的作风，他会先统计语料里哪对积木被用到最多——”th“出现在the、this、that里，出镜率高达987次；而”##pi“只出现在pianist里，才34次。于是BPE毫不犹豫先生产”th”。但阿乐是WordPiece派的建筑师，他的做法是：把两对积木各拼上去试一试，然后问一个更本质的问题——拼上去之后，整片语料世界的可预测性提升哪边更大？ 他计算的是合并前后的语言模型似然变化。

这就是WordPiece的核心合并准则：给定当前词表，把每个候选子词对合并成新符号后，重新计算语料整体的对数似然，选择增益最大的一对执行合并，而不是选择频次最高的一对。

其中，语料似然定义为所有单词在分词后子词序列上的概率乘积：

所以，BPE像是按“出镜率”决定砖块生产，WordPiece却像给每座城堡做“风洞测试”：哪怕某对砖不常露面，只要拼上后整体结构显著优化——比如让pianist不再碎成八块——它就可能胜出。频次看的是局部，似然看的是全局可预测性，这是两者最本质的分野。

##前缀机制：榫头标记的秘密

阿乐的标准积木侧面都有一排凸起的榫头，标记为“##“。一块积木如果带着榫头，说明它不是一座城堡的起点，而是要塞进前一块积木里的。比如”playing“这座城堡，”play“是不带##的底座积木，”##ing“是带##的拼接块。如果看到”##playing“，那就意味着”playing“这个词本身出现在另一个更长的词内部，比如”##playing“可能是”outplaying”的后半截。

这套标记在数学上可以写成一个简单的重构公式：

有了榫头标记，分词器能精确地知道词边界在哪里：一个词的第一个子词决定了词的起始，所有带##的块都自动归属于当前词内部。这让WordPiece在跨语言场景中尤其稳健——德语的长复合词、英语的派生词缀、中文的拼音切分，都能用同一套“榫头”逻辑处理，语言之间的差异被吸收进统一的拼接规则里，模型不需要为每种语言单独设计边界策略。

词表规模权衡：三万种积木的仓库

阿乐的仓库不是无限大的。设计词表时，他会面临一个绕不开的权衡：词表越大，城堡越容易“整块出厂”，但找积木、搬运积木的成本也越高；词表越小，很多城堡就不得不拆成细碎的小粒，拼起来费劲、结构也不稳定。BERT最终选定的规模是大约3万个子词（精确地说是30522个），这正是工程上的一个平衡点。

3万词表覆盖了绝大多数英文语料的常用形态：常见单词“play“整体入库，常见词缀”##ing”“##ness“单独入库，长尾的罕见词如”unhappiness“则拆成”un + ##happi + ##ness“组合拼装。如果某一对子词极不常见，比如某个生僻词的独有碎片，词表会果断放弃它——当子词在词表中找不到时，编码器会逐级回退，最终退化为一个个单字符子词，保证任何词都能被表示，只是”拼得碎一点”而已。

这就像阿乐仓库里的抽屉数固定：3万个抽屉既装得下高频的标准件，又不会让低频的怪异模具挤占空间。词表太小则什么都要零散地拼，词表太大则每个抽屉里的积木样本稀疏、统计不可靠，模型参数也急剧膨胀。3万是覆盖率与效率之间一个经过实践检验的甜点位置。

训练流程：建筑师的五步流水线

阿乐每次从零开始建设词表，都遵循一套固定的流水线。第一步，盘点语料里出现的所有字符，把它们做成最基础的1×1积木块（包括带##的字符变体），形成初始词表。第二步，把语料中的每个单词用当前词表切分，并统计所有相邻子词对。第三步，对每个候选对，临时把它合并成一个新符号，重新计算语料整体的对数似然，得到合并增益。第四步，选出增益最大的那一对，真正把它加入词表。第五步，回到第二步，重复迭代，直到词表达到目标大小，或者最佳增益低于预设阈值就收工。

整个过程是一个贪心式的迭代合并算法，每轮只做一次合并决策。写成递推式就是：

这个流程看起来很像BPE的训练流程，但关键差别藏在第三步：“出镜率最高”和“似然增益最大”经常指向不同的候选对。正是这一步的评判标准，决定了词表里装的是“网红积木”还是“承重积木”。阿乐完工后，仓库里的每一块积木都经过了“拼上去能让全城更稳定”的检验。

应用实践：BERT的全球积木工厂

阿乐的流水线很快被一家大工厂看中了——它就是BERT。BERT的输入构建依赖WordPiece：原始文本先按单词切分，再用约3万子词的词表把每个单词编码成子词ID序列，前面加上[CLS]，后面加上[SEP]，送入Transformer。可以说，WordPiece是BERT理解文本的第一道门，模型看到的一切都从子词序列开始。

这套方案还展现了出色的跨语言稳健性。多语言BERT（mBERT）使用同样的WordPiece流程处理104种语言，从英语到德语再到日语，统一在同一个子词空间里做预训练。德语长篇复合词被拆成常见块，中文按字/词边界切分，罕见拼写也不会变成UNK——因为任何词最终都能用子词块拼出来。相比之下，SentencePiece是另一种子词框架，它把BPE和Unigram等算法整合为一个通用的无监督分词工具；WordPiece定义的是合并准则，SentencePiece定义的是实现框架，两者常被混为一谈，但在实际工程中，BERT系模型用的是WordPiece准则，而T5、LLaMA等模型则常走SentencePiece的路线。

对今天的大模型开发者来说，理解WordPiece不只是考古：当你微调BERT做文本分类、做检索、做命名实体识别时，子词切分方式直接决定了输入表示的质量。甚至可以效仿阿乐的流水线，在自己的领域语料上重新训练词表，让罕见术语拥有稳定的子词表示，这往往是提升领域模型效果性价比最高的一步。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""教学版 WordPiece 子词分词：训练 + 贪心编码""" import mathfrom collections import Counter CORPUS = [    "the pianist plays",    "the playing field",    "play the piano",    "she is running",    "the pianist is happy",] def get_words(corpus):    cnt = Counter()    for line in corpus:        for w in line.lower().split():            cnt[w] += 1    return cnt def initial_vocab(chars):    vocab = set()    for ch in chars:        vocab.add(ch)        vocab.add("##" + ch)    vocab.add("[UNK]")    return vocab def merge_pair(a, b):    if a.startswith("##"):        if b.startswith("##"):            return "##" + a[2:] + b[2:]        return "##" + a[2:] + b    if b.startswith("##"):        return a + b[2:]    return a + b def encode(word, vocab):    if word in vocab:        return [word]    start = 0    toks = []    while start < len(word):        end = len(word)        found = False        while end > start:            piece = word[start:end] if start == 0 else "##" + word[start:end]            if piece in vocab:                toks.append(piece)                start = end                found = True                break            end -= 1        if not found:            toks.append(word[start] if start == 0 else "##" + word[start])            start += 1    return toks def corpus_ll(word_counts, vocab):    tok_counts = Counter()    for w, f in word_counts.items():        for t in encode(w, vocab):            tok_counts[t] += f    total = sum(tok_counts.values())    ll = 0.0    for w, f in word_counts.items():        for t in encode(w, vocab):            ll += f * math.log(tok_counts[t] / total)    return ll def train_wordpiece(corpus, target_vocab=None):    words = get_words(corpus)    chars = set("".join(words.keys()))    vocab = initial_vocab(chars)    if target_vocab is None:        target_vocab = len(vocab) + 12    base_ll = corpus_ll(words, vocab)    print("初始词表大小:", len(vocab), " 初始语料似然: %.2f" % base_ll)    while len(vocab) < target_vocab:        candidates = {}        for w, f in words.items():            toks = encode(w, vocab)            for a, b in zip(toks, toks[1:]):                m = merge_pair(a, b)                if m not in vocab:                    candidates[(a, b, m)] = candidates.get((a, b, m), 0) + f        if not candidates:            break        best_pair = None        best_gain = 0.0        for (a, b, m) in candidates:            ll = corpus_ll(words, vocab | {m})            gain = ll - base_ll            if gain > best_gain:                best_gain = gain                best_pair = (a, b, m)        if best_pair is None or best_gain <= 0:            break        vocab.add(best_pair[2])        base_ll += best_gain        print("合并 %s + %s -> %s  似然增益: %.4f" % (            best_pair[0], best_pair[1], best_pair[2], best_gain))    return vocab if __name__ == "__main__":    print("训练语料:")    for s in CORPUS:        print("  ", s)    v = train_wordpiece(CORPUS)    print("\n训练得到的词表:", sorted(v))    print("\n分词结果:")    words = get_words(CORPUS)    for w in sorted(words):        print("  %s => %s" % (w, " + ".join(encode(w, v))))

1. def merge_pair(a, b):处理两个子词拼接时的##前缀合并规则，这是##机制的代码体现。
2. piece = word[start:end] if start == 0 else "##" + word[start:end]贪心最长匹配的核心，首块不带##、后续块加##。
3. ll += f * math.log(tok_counts[t] / total)用unigram语言模型估计子词概率，累加得到语料对数似然。
4. candidates[(a, b, m)] = candidates.get((a, b, m), 0) + f收集所有候选合并对并统计频次，但注意后面并不按它选。
5. ll = corpus_ll(words, vocab | {m})临时把新子词并入词表，重算语料似然，得到合并增益。
6. if gain > best_gain:关键区别：选出似然增益最大而非频次最高的候选对，这正是WordPiece与BPE的分水岭。

常见误区

面试题