scratch2modern
第一章 · 训练

1.05 Tokenizer

这一节换一种切 token 的方式:BPE
结果同样的步数,bpb 从 2.39 降到 1.20,降了一半

到目前为止,模型都是一个字符一个 token。前面训练出来的故事还读不通:模型每一步只猜一个字母,一个单词要一个字母一个字母地拼出来,光一个 the 就要连着猜对三次。那能不能换一种切法,让一个 token 装下更多的内容?

一个字符一个 token
limed and the and saided ig the toy to a and her and the sto the marked and happy in the the kne a had band the dother belly it the wanted to the to the happy. "Wher and and a and and little had bight the dis wen to the mon the wanted to the om the the a
BPE,4096 种 token
One day, a little boy named Tim went to a big, a big cat named Tim. Tim was very happy. He loved to play with his friends. He had a toy car. Tim wanted to help him to learn a toy. He said, "Hi, you, I want to play with you, Lily. The cat was very happy. They had fun.

同样的模型、同样的训练步数,只换了 tokenizer,生成的故事。右边的情节还有点乱,但已经是能读的句子了。

把文本切成 token 的那一步叫 tokenize,做这件事的程序就叫 tokenizer。这一节对比四种:

  1. char:一个字符一个 token,就是我们一直在用的。词表是数据里出现过的 89 个字符。
  2. byte:一个字节一个 token,词表固定是 256 个。任何语言的文本都能编码,不会遇到没见过的字符。
  3. BPE:从 256 个字节出发,把经常一起出现的 token 合并成新 token。我们在 TinyStories 上自己训练,词表取 512、1024、4096 三种大小。
  4. gpt2:OpenAI 在网页文本上训练的 BPE,词表 50257 个。

BPE(Byte Pair Encoding)的想法很简单:数一数整个训练文本里,哪两个相邻的 token 一起出现的次数最多,就把它们合并成一个新 token,加进词表;然后再数,再合并,一直到词表达到想要的大小。在 TinyStories 上,最先学到的几次合并是(␣ 表示空格):

␣ + t → ␣th + e → he␣ + a → ␣a␣ + s → ␣s␣ + w → ␣w␣t + he → ␣the

第一次合并的空格加 t,在训练文本里出现了 57.7 万次。合并到 4096 个以后,常见的词基本都成了一个 token。比如下面两句话,53 个字节切成了 13 个 token,26 个字节切成了 5 个:

Once␣upon␣a␣time,␣there␣was␣a␣little␣girl␣named␣Lily.
The␣farmer␣was␣frightened.

可以看到,词前面的空格是跟着词走的。合并之前,会先按 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 篇故事。

运行结果

char(89) 2.3922 s byte(257) 2.3823 s bpe512(512) 1.8324 s bpe1024(1024) 1.5027 s bpe4096(4096) 1.2060 s gpt2(50257) 1.17409 s tokenizer(词表)验证集 bpb,越低越好;灰字是训练时间

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 万。

1.05 原结果 上下文字节数对齐 参数量对齐 1.0 1.5 2.0 2.5 验证集 bpb,越低越好 char byte bpe512 bpe1024 bpe4096

上下文变长,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 维)。词表并不是越大越好,要和模型大小一起选。