上一章遗留的作业:在 squid/tokenizer/bpe.py 里实现三个函数:train_bpe(学合并表)、encode(按表切分)、decode(还原)。先小语料跑通往返,再上博客语料测压缩率。

说实话,开工前我觉得自己写不出来。但拆成小函数之后,一个一个都拿下了。

三个零件

count_pairs:用滑动窗口把 i 和 i+1 的 id 配成 key,统计每个 key 出现的次数。

def count_pairs(ids: list[int]) -> dict[tuple[int, int], int]:
    counts = {}
    for a, b in zip(ids, ids[1:]):
        key = (a, b)
        if key not in counts:
            counts[key] = 1
        else:
            counts[key] += 1
    return counts

merge:把 ids 里所有出现过的 pair 替换成新 id。比如 pair=(1,2)、ids=[1,2,1,2,3,4,5]、new_id=9,结果就是 [9, 9, 3, 4, 5]。

def merge(ids: list[int], pair: tuple[int, int], new_id: int) -> list[int]:
    new_idx = []
    i = 0
    while i < len(ids):
        if i < len(ids) - 1 and (ids[i], ids[i + 1]) == pair:
            new_idx.append(new_id)
            i = i + 2
        else:
            new_idx.append(ids[i])
            i = i + 1
    return new_idx

这里有个容易写错的点:统计是滑动窗口(允许重叠),替换是贪心扫描(命中消费两格,不匹配消费一格)。所以用 while 手动控制步长,for i in range 里修改 i 下一轮会被覆盖。

train_bpe:vocab 初始 256 项(所有单字节),每轮取 count_pairs 里 value 最大的 key 合并,新 id 从 256 开始累加。

def train_bpe(text: str, num_merges: int):
    ids = list(text.encode("utf-8"))
    vocab = {i: bytes([i]) for i in range(256)}
    merges = {}

    for _ in range(num_merges):
        counts = count_pairs(ids)
        if not counts:
            break
        best = max(counts, key=counts.get)
        new_id = 256 + len(merges)
        ids = merge(ids, best, new_id)
        merges[best] = new_id
        vocab[new_id] = vocab[best[0]] + vocab[best[1]]

    return vocab, merges

注意最后一行:best 里装的是 id 不是字符,要先查 vocab 取出 bytes 再拼接,不能直接 best[0] + best[1](那是两个整数相加)。

encode / decode 与往返无损

def decode(ids: list[int], vocab) -> str:
    return b"".join(vocab[i] for i in ids).decode("utf-8")

def encode(text: str, merges) -> list[int]:
    ids = list(text.encode("utf-8"))
    for pair, new_id in merges.items():
        ids = merge(ids, pair, new_id)
    return ids

decode 是查词表把 ids 还原成文本,必须先在 bytes 世界拼完整再 decode,不然中文多字节字符会被切碎。encode 是把训练学到的合并规则按学习顺序在新文本上重放一遍——merges 存的是规则不是结果,不重放,新 token 不会出现。

往返验收过了:decode(encode(text, merges), vocab) == text。

Python 里 bytes 和 str 的转换我目前还不熟,记入欠账,后面找机会补。

封装成 SquidTokenizer

class MyBPETokenizer(SquidTokenizer):
    def __init__(self, vocab, merges, eos_id=None):
        self.vocab = vocab
        self.merges = merges
        self._eos_id = eos_id if eos_id is not None else len(vocab)
        self.vocab.setdefault(self._eos_id, b"<|endoftext|>")

    def encode(self, text: str) -> list[int]:
        return bpe.encode(text, self.merges)

    def decode(self, idx: list[int]) -> str:
        return bpe.decode(idx, self.vocab)

    @classmethod
    def from_directory(cls, path):
        vocab, merges = bpe.load_bpe(path)
        return cls(vocab, merges)

    @property
    def eos_id(self) -> int:
        return self._eos_id

这段学到的 Python 点:

  1. 三元表达式是 值A if 条件 else 值B,所以 eos_id 那行就是“传了用传入的,没传用词表大小”
  2. @classmethod 是挂在类上的方法,类似 Java 静态工厂。cls(vocab, merges) 就是调用 __init__,但比 Java static 多一层:cls 是类本身,子类调用返回子类实例
  3. @property 把方法伪装成属性,访问不用加括号
  4. self._* 下划线只是约定,不是 private,依然能访问

实验一:压缩率曲线与甜点区

分别训练了 [64, 128, 256, 512, 1024, 2000, 4000, 8000, 16000] 次的词表,在 held-out 文本上测压缩率(len(text.encode("utf-8")) / len(tokenizer.encode(text)),即 bytes/token,越高越省):

merges=   64  tokens=10588  bytes/token=1.29
merges=  128  tokens= 9631  bytes/token=1.42
merges=  256  tokens= 8346  bytes/token=1.64
merges=  512  tokens= 7009  bytes/token=1.95
merges= 1024  tokens= 5944  bytes/token=2.30
merges= 2000  tokens= 5043  bytes/token=2.71
merges= 4000  tokens= 4287  bytes/token=3.19
merges= 8000  tokens= 3869  bytes/token=3.54
merges=16000  tokens= 3704  bytes/token=3.69

token 数一直在降,bytes/token 一直在涨,但看每次翻倍的收益:前期稳定 +17% 左右,4000→8000 掉到 +11%,8000→16000 只剩 +4%。甜点区在 4000-8000,再往后基本是在背语料。

直观例子:手机号最好学成 3-4-4 的片段,merges 一直增大就会学成整个 11 位号码——每个号码独一无二,embedding 永远学不到,模型也无法对号码内部做推理。所以并不是 merges 越多越好,每个 token 携带的信息越大,模型训练时也需要更强的能力去掌握它。

另一个好玩的发现:512 次合并时“大模型”还排不上号(语料里只出现 31 次),2000 次之后它终于“拥有姓名”,被切成了一个完整 token。词表大小决定了多低频的词才配拥有姓名。

实验二:BPB,把模型拉上一起评

和 DeepSeek 讨论后确认:评估分词器不能只看 bytes/token,那只是在评分词器本身,还得看“模型+词表”的整体效果。这个指标叫 BPB(Bits Per Byte):

BPB = (val_loss / ln2) ÷ bytes/token

含义:给这段文本编码,平均每个字节要花多少比特。val_loss 是模型每预测一个 token 的代价(nats),除以 ln2 换成比特;再除以 bytes/token,就把“每个 token 的成本”折算成“每个字节的成本”。越低越好——它同时惩罚两种情况:词表太碎(bytes/token 小)和模型没学好(val_loss 高)。

实验设计

四组:512 / 2000 / 4000 / 8000,同一个微型模型配置(emb_dim=64、n_layers=2、context=128),同一份 train/held-out 文本,只换分词器。

一个关键的控制变量:统一步数,不是统一 epoch。 因为词表越大,同样文本的 ids 越短,定长窗口切出的窗口数越少,每 epoch 的训练步数也越少:

窗口数 = (len(ids) - max_length) / stride
每 epoch 步数 = 窗口数 / batch_size

如果只统一 epoch,大词表模型等于“饿着肚子考试”。所以给 pretrain_model 加了 max_steps 参数,四组都固定走 500 步。

完整实验代码:

import math
from pathlib import Path
import torch
from squid.data.pretrain import create_pretrain_loader
from squid.device import get_device
from squid.model.gpt import GPTModel
from squid.tokenizer.my_bpe_tokenizer import MyBPETokenizer
from squid.train.common import calc_loss_loader
from squid.train.pretrain import pretrain_model

ROOT = Path(__file__).resolve().parents[1]
DATA = ROOT / "data" / "blog"

def train_model_with_nums_merge(num_merges: str):
    vocab_data = ROOT / "data" / "blog" / num_merges
    tokenizer = MyBPETokenizer.from_directory(vocab_data)
    cfg = {
        "vocab_size": len(tokenizer.vocab),
        "context_length": 128,
        "emb_dim": 64,
        "n_heads": 2,
        "n_layers": 2,
        "drop_rate": 0.0,
        "qkv_bias": False,
    }
    device = get_device()
    model = GPTModel(cfg)
    model.to(device)

    train_text = open(DATA / "train.txt", encoding="utf-8").read()
    val_text = open(DATA / "heldout-手搓LLM笔记07-指令微调.txt", encoding="utf-8").read()
    val_text = val_text + "\n" + open(DATA / "heldout-我想把家里的设备组成一个私人AI实验室.txt",
                                      encoding="utf-8").read()

    train_loader = create_pretrain_loader(train_text, tokenizer, 128, 128,
                                          batch_size=8, shuffle=True)
    val_loader = create_pretrain_loader(val_text, tokenizer, 128, 128,
                                        batch_size=8, shuffle=False, drop_last=False)
    optimizer = torch.optim.AdamW(model.parameters())
    train_losses, val_losses, tokens_seen = pretrain_model(
        model=model, train_loader=train_loader, val_loader=val_loader,
        optimizer=optimizer, device=device, num_epochs=100, max_steps=500, eval_freq=100, eval_iter=100
    )
    val_loss = calc_loss_loader(val_loader, model, device)
    density = len(val_text.encode("utf-8")) / len(tokenizer.encode(val_text))
    bpb = val_loss / math.log(2) / density
    print(f"val_loss={val_loss:.3f}  bytes/token={density:.2f}  BPB={bpb:.3f}")


if __name__ == '__main__':
    train_model_with_nums_merge("m512")
    train_model_with_nums_merge("m2000")
    train_model_with_nums_merge("m4000")
    train_model_with_nums_merge("m8000")

结果

m512 : val_loss=4.819  bytes/token=1.99  BPB=3.494
m2000: val_loss=6.551  bytes/token=2.80  BPB=3.373
m4000: val_loss=7.584  bytes/token=3.30  BPB=3.315
m8000: val_loss=8.378  bytes/token=3.66  BPB=3.300

为什么 val_loss 一路涨? val_loss 是“每个 token 的预测难度”,词表变大之后,大量 token 在 117KB 语料里只出现几次,embedding 学不充分,预测它们接近靠蒙,困惑度自然上升。这不是词表变差,是“大 token 更难预测”的固有代价。

但 BPB 在降——因为每个 token 装的字节更多了,折算回每字节成本反而便宜。而且看边际收益:512→2000 降 0.121,2000→4000 降 0.058,4000→8000 只降 0.015。BPB 的甜点同样在 4000 附近,和压缩率实验互相印证。

结论:val_loss 上升不等于词表不好,BPB 才是整体账;但 BPB 的边际收益也会递减,4000 之后再合并基本没红利。

BPE 的三个哲学点

实验做完再回头看,BPE 的底层逻辑其实就三句话:

  1. 原子由数据决定。 什么是“思考的最小单位”,不是人预先规定的,是语料的统计分布决定的。代码语料出 def、();,中文博客语料出“模型”、“训练”——词表是语料的指纹,换语料就要重新训词表。
  2. 频率决定谁先成为原子。 BPE 每轮只合并最高频的相邻对,它只认频率,不认语义重要性。“大模型”再重要,出现 31 次也得往后排。
  3. 预算决定多低频才配拥有姓名。 词表大小(合并次数)就是预算:高频组合早早拿到独立 token_id,低频组合要等预算够了才有机会。512 次时“大模型”没姓名,2000 次才有了。

工程收获

  • 训练产物(vocab/merges)用 JSON 存成中间文件(save_bpe / load_bpe),实验和训练可以分开重跑
  • 不同配置分目录存(data/blog/m512/、m2000/……),不然实验产物互相覆盖,回头根本对不上号
  • 路径用 Path(__file__).resolve().parents[N] 锚定,不再受 IDE 工作目录的摆布

欠账与下一步

  • Python 的 bytes/str、pathlib 这些基础用法还不熟,找时间补
  • M2 预训练:token 流打包、梯度累积、bpb 指标,这次 BPB 实验就是预习

一句话总结 M1:BPE 的目标不是把文本压到最短,是在压缩率、词表规模、可学习性、组合泛化之间找平衡。