NLP 基础：Tokenizer、BPE 与 Embedding

本章对应课件：《2.1 自然语言处理》。核心内容：文本如何变成 token、三种切分粒度、BPE 训练与编码、BBPE、Tokenizer 评估、Embedding 查表、Word2Vec。

6.1 Tokenization：文本如何变成数字

例如：

I love coding  →  ["I", "love", "coding"]  →  [51, 872, 16372]

Token 是模型处理文本的基本单位。注意：

6.2 三种切分粒度

Word-based（按词）

learning / learned / learns / learner  →  4 个不同 token

问题：

• 词表爆炸（英文常用词几十万，加上变形、专名、拼写错误会更多）；
• 新词 superhyperGPT 直接 OOV（Out-of-Vocabulary），只能映射到 <UNK>。

Character-based（按字符）

l e a r n i n g

• 优点：几乎不会 OOV（字符集有限）；
• 缺点：序列太长——一句话变成几十个 token，训练慢、上下文利用率低，而且单个字符语义太弱。

Subword-based（子词）——现代主流

learning → learn + ing
unbelievable → un + believ + able

兼顾三者：

6.3 BPE：字节对编码 ★

假设语料统计如下：

low      ×5
lower    ×2
newest   ×6
widest   ×3

第 0 轮：全部拆成字符（词尾加 </w> 标记）：

l o w</w>
l o w e r</w>
n e w e s t</w>
w i d e s t</w>

第 1 轮：统计相邻 pair 的频率。e + s 出现最多（newest 6 次 + widest 3 次 = 9 次）→ 合并：

e s → es

第 2 轮：es + t 现在频率最高 → 合并：

es t → est

第 3 轮：est + </w> → 合并：

est </w> → est</w>

第 4 轮：l + o → 合并 lo。

第 5 轮：lo + w → 合并 low。

以此类推，直到达到预设的词表大小或没有可合并的 pair。

初始化：每个词 = 字符序列 + </w>
循环：
  1. 统计所有相邻 token pair 的频率（按词频加权）
  2. 选频率最高的 pair (a, b)
  3. 把所有出现的 a b 合并为 ab
  4. 记录 merge rule: a + b → ab
直到：词表达到目标大小 或 无 pair 可合并

from collections import Counter

def get_pairs(words):
    pairs = Counter()
    for word, freq in words.items():
        symbols = word.split()
        for i in range(len(symbols) - 1):
            pairs[(symbols[i], symbols[i+1])] += freq
    return pairs

def merge(words, pair):
    new_words = {}
    bigram = " ".join(pair)
    for word, freq in words.items():
        new_words[word.replace(bigram, "".join(pair))] = freq
    return new_words

corpus = {"l o w </w>": 5, "l o w e r </w>": 2,
          "n e w e s t </w>": 6, "w i d e s t </w>": 3}

for i in range(10):
    pairs = get_pairs(corpus)
    if not pairs: break
    best = max(pairs, key=pairs.get)
    corpus = merge(corpus, best)
    print(f"merge {i+1}: {best[0]} + {best[1]} -> {best[0]+best[1]}  (freq={pairs[best]})")

6.4 BPE Training 与 Encoding 必须分开理解 ★

Training tokenizer：在大语料上学习 merge rules：

e + s → es
es + t → est
est + </w> → est</w>
l + o → lo
lo + w → low
...

Encoding：来了新词 slowest，按学到的规则顺序逐步应用：

s l o w e s t
↓ (e+s)
s l o w es t
↓ (es+t)
s l o w est
↓ (est+</w>)     ← 词尾标记
s l o w est</w>
↓ (l+o)
s lo w est</w>
↓ (lo+w)
s low est</w>

最终：

["s", "low", "est</w>"]

再查词表得到 token IDs。

6.5 BBPE：字节级 BPE

BBPE（Byte-Level BPE）的流程：

文本 "你好" → UTF-8 字节 [E4 BD A0 E5 A5 BD] → 对字节序列做 BPE

优点：

• 零 OOV：任何输入都能拆到字节；
• 多语言统一：所有语言共享同一套字节基础；
• 处理特殊符号：emoji、控制字符都不成问题。

代价：

• 一个汉字通常是 3 个 UTF-8 字节，所以在 BBPE 下中文的 token 数往往比英文多——同样的信息量，中文消耗的上下文更多。

现代很多 tokenizer 都受这种思路影响。课件第 10 页专门介绍 BBPE，并把它和 UTF-8 联系起来。

6.6 如何评价一个 Tokenizer

压缩率

一句文本被拆成多少 token。如果：

• tokenizer A：一句中文 → 30 token；
• tokenizer B：同一句 → 12 token。

后者通常更节省上下文和算力。

OOV

是否出现无法编码的字符/词。BBPE 基本解决了这个问题。

多语言公平性

同样的信息量：

英文：20 tokens
中文：80 tokens

意味着中文的上下文成本是英文的 4 倍。

6.7 Embedding：从 one-hot 到稠密向量 ★

token id 例如 15236 只是编号。数字大小没有语义：

dog id = 100
cat id = 101

不代表 cat 比 dog 大 1。所以要用 embedding table 查表：

如果 $V = 100000$、$d = 4096$，token 15236 对应：

one-hot vs 稠密向量

import torch, torch.nn as nn

emb = nn.Embedding(num_embeddings=100000, embedding_dim=4096)
ids = torch.tensor([[51, 872, 16372]])       # [B=1, S=3]
vecs = emb(ids)
print(vecs.shape)                             # [1, 3, 4096]

# 它本质上就是一个可学习的查表：
# forward 等价于 one_hot(ids) @ E

6.8 Word2Vec：让词向量带上语义

两个经典任务：

CBOW（Continuous Bag of Words）

根据上下文预测中间词：

I ___ machine learning     →  预测 learning

即：$\text{context} \rightarrow \text{target}$。

Skip-Gram

给定中心词预测周围词：

learning  →  I, machine, ...（周围词）

即：$\text{target} \rightarrow \text{context}$。

# 现代等价的「预测」：语言模型头
logits = model.transformer(...)     # [B, S, d_model]
logits = lm_head(logits)            # [B, S, vocab_size]
loss = F.cross_entropy(logits[:, :-1].reshape(-1, V), ids[:, 1:].reshape(-1))