1.05 Tokenizer
到目前为止,模型都是一个字符一个 token。前面训练出来的故事还读不通:模型每一步只猜一个字母,一个单词要一个字母一个字母地拼出来,光一个 the 就要连着猜对三次。那能不能换一种切法,让一个 token 装下更多的内容?
同样的模型、同样的训练步数,只换了 tokenizer,生成的故事。右边的情节还有点乱,但已经是能读的句子了。
把文本切成 token 的那一步叫 tokenize,做这件事的程序就叫 tokenizer。这一节对比四种:
- char:一个字符一个 token,就是我们一直在用的。词表是数据里出现过的 89 个字符。
- byte:一个字节一个 token,词表固定是 256 个。任何语言的文本都能编码,不会遇到没见过的字符。
- BPE:从 256 个字节出发,把经常一起出现的 token 合并成新 token。我们在 TinyStories 上自己训练,词表取 512、1024、4096 三种大小。
- gpt2:OpenAI 在网页文本上训练的 BPE,词表 50257 个。
BPE(Byte Pair Encoding)的想法很简单:数一数整个训练文本里,哪两个相邻的 token 一起出现的次数最多,就把它们合并成一个新 token,加进词表;然后再数,再合并,一直到词表达到想要的大小。在 TinyStories 上,最先学到的几次合并是(␣ 表示空格):
第一次合并的空格加 t,在训练文本里出现了 57.7 万次。合并到 4096 个以后,常见的词基本都成了一个 token。比如下面两句话,53 个字节切成了 13 个 token,26 个字节切成了 5 个:
可以看到,词前面的空格是跟着词走的。合并之前,会先按 GPT-2 的规则把文本切成词和标点,合并不会跨过它们的边界,所以 ␣dog 可以成为一个 token,dog. 不行。核心代码就这么几十行(完整文件在 GitHub):
1BPE训练和编码
# 先按 GPT-2 的规则把文本切成词和标点,合并不会跨过它们的边界
pattern = regex.compile(r"""'(?:[sdmt]|ll|ve|re)| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")
# 相同的词只存一份,记下它出现了多少次;每个词先拆成字节
chunk_counts = Counter(chunk for doc in train_docs for chunk in pattern.findall(doc))
words = {tuple(chunk.encode('utf-8')): n for chunk, n in chunk_counts.items()}
# 把 ids 里所有相邻的 pair 换成 new_id
def merge(ids, pair, new_id):
out, i = [], 0
while i < len(ids):
if i < len(ids) - 1 and (ids[i], ids[i + 1]) == pair:
out.append(new_id)
i += 2
else:
out.append(ids[i])
i += 1
return tuple(out)
merges = {} # (id, id) -> 新 id,按学到的顺序
vocab = [bytes([i]) for i in range(256)] # 每个 token 对应的字节
for new_id in range(256, vocab_size - 1): # 最后一个 id 留给 BOS
# 数一数所有相邻的两个 token 一共一起出现了多少次
pairs = Counter()
for ids, n in words.items():
for pair in zip(ids, ids[1:]):
pairs[pair] += n
# 最多的那一对合并成新 token
pair = max(pairs, key=pairs.get)
merges[pair] = new_id
vocab.append(vocab[pair[0]] + vocab[pair[1]])
words = {merge(ids, pair, new_id): n for ids, n in words.items()}
# 编码一个词:从字节出发,每次合并"最早学到"的那一对,直到没有可合并的
def encode_chunk(chunk):
ids = tuple(chunk.encode('utf-8'))
while len(ids) >= 2:
pair = min(zip(ids, ids[1:]), key=lambda p: merges.get(p, float('inf')))
if pair not in merges:
break
ids = merge(ids, pair, merges[pair])
return ids换了 tokenizer 以后,loss 就不能直接比了。loss 是平均每个 token 的损失,可同样一句话,char 切成 53 个 token,bpe4096 只切成 13 个,一个 token 里装的文本长短完全不一样。所以要换一个分母:不按 token 平均,而按字节平均。把整个验证集上的 loss 加起来,再除以验证集的总字节数,就是平均每个字节的损失。不管怎么切,验证集的字节数都一样,这个数就可以直接比了。
习惯上还会把 loss 从以 e 为底换成以 2 为底(除以 ln 2),单位就成了 bit,所以叫 bits per byte(bpb),越低越好。一个字节是 8 bit,模型完全瞎猜的话,bpb 就是 8。
token_bytes = torch.tensor([len(b) for b in vocab]) # 每个 token 是几个字节
def val_bpb():
nats = ... # 整个验证集上 loss 的总和(以 e 为底)
val_bytes = ... # 验证集一共多少字节
return nats / math.log(2) / val_bytes
所有 tokenizer 用同样的设置:TinyStories,batch 16,上下文 256 个 token,训练 4096 步,模型宽度 16,在 GPU 上跑。验证集固定是同样的 500 篇故事。
运行结果
BPE 的提升非常大。同样的步数,bpe4096 的 bpb 只有 char 的一半。词表越大越好,但收益递减:512、1024、4096 依次是 1.83、1.50、1.20。char 和 byte 几乎一样,因为 TinyStories 基本是英文,几乎没有多字节的字符。
gpt2 只比 bpe4096 好 0.03,代价却大得多:参数多 12 倍,时间多 7 倍。bpe4096 是在 TinyStories 上训练的,正好贴合这类文本;gpt2 的 5 万个词大多是为网页文本准备的,这里用不上,却每一步都要在 5 万个词上算 softmax。
速度上,词表在 1024 以下时,时间主要花在注意力上,训练时间基本不变,都在 22 到 27 秒。词表再大,输出层 lm_head 和 softmax 的开销就开始占主导,gpt2 的 409 秒几乎全花在这上面。
最后补充一点:BPE 到底好在哪?除了切法不同,这里还混着两个因素。一是上下文:上下文都是 256 个 token,char 只能看到 256 个字节,bpe4096 能看到约 1000 个字节,差不多是一整篇故事。二是参数量:词表越大,输入的 wte 和输出的 lm_head 就越大,char 一共只有 1.0 万个参数,bpe4096 有 13.8 万。所以我们又做了两组实验,每组只把其中一个因素向 bpe4096 看齐:第一组把上下文调到约 1000 个字节,第二组把模型加宽到参数总量约 13.8 万。
上下文变长,char 反而变差了,从 2.39 到 2.64,BPE 几乎不变。所以 BPE 的好处,不是"一次能装下更多文本"。
参数对齐后,char 从 2.39 降到 1.52,和 bpe4096 的差距从 1.19 缩小到 0.32,大约 70% 的差距消失了。BPE 的优势,有一大半是靠词表上的参数堆出来的。剩下的部分,来自每个 token 本身更有意义:不用逐字母拼写,同样的文本要猜的次数也更少。
还有一个有意思的地方:参数一样多时,bpe1024 比 bpe4096 还好。bpe4096 的参数 95% 都在词表上,模型本身只有 16 维;bpe1024 把更多参数留给了模型(48 维)。词表并不是越大越好,要和模型大小一起选。