第 5 章 LLMGPT深度学习

第 5 章 在无标注数据上预训练

第 5 章 在无标注数据上预训练

本章来源:本文整理自 LLMs-from-scratch 仓库的 ch05/01_main-chapter-code/ch05.ipynb,原书为 Sebastian Raschka《Build a Large Language Model (From Scratch)》。

这章要解决什么问题

前面四章,我们把 GPT 的"骨架"搭好了:分词、注意力、Transformer 块、整个 GPT 模型。但那时的模型只是个空壳——参数是随机的,你给它"Hello, I am",它回你一串乱码。

这一章要干的事就一句话:把这个空壳喂饱,让它学会说人话。

具体要解决四件事:

  1. 怎么判断它"说得变好了"? —— 得有个能打分的尺子(交叉熵、困惑度)。
  2. 怎么让它一步步变好? —— 写训练循环,反复"预测 → 对比 → 修正"。
  3. 训练完怎么让它"说话"? —— 温度和 top-k 采样,控制输出是保守还是天马行空。
  4. 没钱从头训练怎么办? —— 最后我们直接加载 OpenAI 公开的 GPT-2 权重,"抄近道"拿到一个会说话的模型。

一句话概括:第 4 章造了个乐器,这一章教它调音、试奏,最后干脆换上一把名厂成品琴。

用大白话讲原理

训练之前,先得有一把"尺子"

你没法改进一件你无法衡量的东西。模型吐出一段文本,怎么用数字说清它"好不好"?

这里有个巧妙的地方:语言模型的训练目标是"预测下一个词",所以"标准答案"是现成的——文本里下一个词本来就在那儿。于是我们可以这样打分:看模型给"正确答案"打了多高的概率。

  • 如果模型给正确答案的概率很高(比如 0.9),说明它"押对了",损失小。
  • 如果概率很低(比如 0.001),说明它完全没想到,损失大。

把这套想法写成公式,就是交叉熵损失(cross-entropy loss):

L=−1N∑i=1Nlog⁡p(ti)\mathcal{L} = -\frac{1}{N}\sum_{i=1}^{N} \log p(t_i)

别看公式吓人,逐字读就是:对每个位置 ii,取模型给正确词 tit_i 的概率 p(ti)p(t_i),取对数,前面加个负号,最后求平均。

为什么要取对数、加负号? 两个朴素的原因:

  • 概率越接近 1,log⁡p\log p 越接近 0,我们希望它越大越好,所以取"对数概率的平均值"更容易优化。
  • 但深度学习圈的惯例是"最小化损失",所以我们把"最大化对数概率"反过来,变成最小化负对数概率——这就是交叉熵。从 -10.77 去接近 0,等价于从 10.77 去接近 0,后者符合"损失越小越好"的习惯。

困惑度:把损失换算成"模型有多懵"

损失是个负数、动不动 -10 开外,不太好直观感受。于是有个衍生指标叫困惑度(perplexity):

perplexity=exp⁡(L)\text{perplexity} = \exp(\mathcal{L})

也就是交叉熵损失的指数。它的解释很妙:可以理解成模型每一步"在多少个候选词里瞎猜"。困惑度是 48,725,就意味着模型每次预测,心里大概有近 5 万个词在打架、拿不定主意;困惑度越低,说明它越笃定、越接近真实分布。

打个比方:困惑度就像考试时的"选项数量"。选项越多(困惑度越高),越说明这题你没底。

为什么只能拿一篇小故事来练手

真正的 LLM 训练贵到离谱。书里给了个触目惊心的数字:训练 Llama 2 7B 要 184,320 个 A100 GPU 小时,按 AWS 上 8 卡 A100 每小时约 30 美元粗算,光算力就得花 69 万美元。

我们当然烧不起。所以本章用一篇公有领域的短篇小说《The Verdict》来练手——它只有 5,145 个 token,几分钟就能在笔记本上跑完。这不是为了训出好模型,而是为了让你完整跑通流程、亲眼看到损失下降。 真要好模型,本章最后有"抄近道"的办法。

一个训练循环,其实就四步循环

不管多复杂,训练循环的本质就四件事,反复做:

  1. 前向:把一批数据喂进模型,拿到预测。
  2. 算损失:拿预测和标准答案比,算出交叉熵。
  3. 反向:算出每个参数"该往哪个方向调"(梯度)。
  4. 更新:按梯度微调参数一步。

用代码说就是 optimizer.zero_grad() → loss.backward() → optimizer.step(),一遍遍循环。本书第 6 章以后的微调、第 2 章的数据加载,都是围绕这四步转。

训练中的两个"防退化"技巧

跑训练循环时,你会反复听到两个词,这里先用大白话交代:

  • 过拟合(overfitting):模型"死记硬背"训练数据,把原文一字不差背下来,却在没见过的文本上表现糟糕。就像一个学生把答案背下来但没理解,换道题就露馅。判断信号:训练损失一路降,验证损失却开始上升、二者分叉。
  • dropout / 权重衰减(weight decay):两种对抗过拟合的手段。dropout 是训练时随机"关掉"一部分神经元,逼模型不能依赖某几个特定神经元;权重衰减则是给参数一个"别长太大"的惩罚,让模型更简洁。这章训练时用的是 AdamW 优化器 + weight_decay=0.1。

进阶旁白:预热和余弦退火(附录 D)

书里的主训练函数故意做得简单。工业界训练大模型还会叠加几个技巧,附录 D 有实现:

  • 学习率预热(warmup):训练最初几步把学习率从小逐渐调大,避免一开始步子太大把参数带偏。
  • 余弦退火(cosine annealing):学习率按余弦曲线从大慢慢衰减到接近 0,后期"小步慢走",收敛更稳。
  • 梯度裁剪(gradient clipping):给梯度设个上限,防止某一批数据产生的巨大梯度"炸飞"训练。

一句话理解:预热是"起步别太猛",退火是"临近终点放慢脚",裁剪是"别让某一步迈太大"。

训练完怎么让模型"说话":温度与 top-k

模型输出的是一个"下一个词的概率分布"。怎么从这个分布里挑词,决定了文本的风格,这套挑法叫解码策略(decoding strategy)。

  • 贪婪解码(greedy):每次直接选概率最高的那个词。优点是稳定,缺点是永远吐同一句话,很无聊。
  • 温度缩放(temperature scaling):给概率分布"调温度"。温度 > 1,分布变平、小概率词也有机会,输出更发散;温度 < 1,分布变尖、更保守。
  • top-k 采样:只在概率最高的 k 个词里抽签,把那些荒谬的候选(比如"pizza")直接踢掉,既能提高多样性又不会胡说八道。

一句话:温度决定"敢不敢冒险",top-k 决定"允许在多大的候选池里冒险"。

站在巨人肩膀上:直接加载 OpenAI 的权重

好消息是——我们不必花几十万美元从零训练。OpenAI 早把 GPT-2 的预训练权重公开了,而我们的 GPTModel 架构和它完全同构,只是"零件命名"不一样。所以本章最后一节,我们写一个 load_weights_into_gpt,把 OpenAI 的权重逐个"对号入座"搬进我们的模型。

搬完之后,模型立刻就能写出连贯的英文。这既验证了我们的架构实现是对的,也让你亲手拥有一个能用的 GPT-2。

5.1 评估生成式文本模型

先把第 4 章的模型实例化出来,再用它讲清楚"怎么评估"。

5.1.1 用 GPT 生成文本

我们沿用第 4 章的 GPTModel,按 124M 参数规模配一套配置 GPT_CONFIG_124M(词汇表 50,257、嵌入维度 768、12 个头、12 层),再用一个固定的随机种子实例化模型,并切到 eval 模式关掉 dropout。

这套配置里 dropout 设的是 0.1,不过如今训练 LLM 不用 dropout 也相当常见。现代 LLM 在查询、键、值矩阵的 nn.Linear 层里也不用偏置向量(早期 GPT 模型用),这可以通过配置里的 "qkv_bias": False 关掉。

这里还有个关键改动:我们把上下文长度(context_length)从 1024 砍到只有 256 个 token,为的是少烧点算力。

  • 这是为了让更多读者能在普通笔记本上把代码跑起来。
  • 你完全可以把它改回 1024(不需要改动任何其它代码)。
  • 稍后我们从预训练权重加载的模型,用的就是完整的 1024。

接下来,我们用第 4 章的 generate_text_simple 生成文本。因为本章会反复在"文本 ↔ token"之间来回转换,还得准备两个便捷函数:text_to_token_ids 把一段文本编码成带 batch 维度的张量,token_ids_to_text 反过来把 token ID 张量解码回文本。有了它们,我们就能用起始提示 "Every effort moves you" 让模型顺着往后写若干 token。

模型此时说的不是人话——因为它压根还没被训练。那么问题来了:怎么用数字量化"文本好不好",好让我们在训练过程中盯着它?下一小节就来解决这个尺子的问题。评估模型质量的其它方法(比如微调阶段的手段)会在后续章节讲。

5.1.2 计算文本生成损失:交叉熵和困惑度

先构造一个迷你例子。假设有个 inputs 张量,包含 2 个训练样本(每行一个)的 token ID;对应的 targets 是我们希望模型生成的正确 token ID。注意 targets 就是 inputs 向右移一位——这正是第 2 章做数据加载器时讲的"预测下一个词"。比如第一批样本是 ["every effort moves"],它对应的目标就是 [" effort moves you"]。

把 inputs 喂给模型,会得到 2 个样本(各 3 个 token)的 logits 向量,每个 token 是一个 50,257 维向量(对应词汇表大小)。套上 softmax,就能把这些 logits 转成同样维度的概率分布。

上一章已经讲过怎么把概率转回文本:用 argmax 取出每个 token 概率向量里最大概率的位置,那就是预测的 token ID。因为我们是 2 个样本各 3 个 token,所以得到 2×3 的预测结果。如果把这两批解码出来,你会发现它们和"我们希望模型预测的 token"(也就是目标)差得很远——这很正常,模型还没训练。

要训练它,先得知道它离正确答案有多远。关键一步:取出模型给"正确 token"分配的概率。

我们的目标是让这些概率尽量逼近 1。在数学优化里,最大化"概率的对数"比直接最大化概率本身更好算(细节见作者的一节课 L8.2 Logistic Regression Loss Function)。于是我们把这些正确 token 的概率都取对数,再求平均,得到一个"平均对数概率"。

我们想通过优化权重,让这个平均值尽量大。因为取了对数,它的最大值是 0,而现在我们离 0 还很远。

在深度学习里,习惯上不"最大化平均对数概率",而是"最小化它的相反数"。换句话说,我们不是去把 -10.7722 抬到 0,而是把 10.7722 压到 0。这个 -10.7722 取反得到的 10.7722,就是交叉熵损失(cross-entropy loss)。

好消息是:PyTorch 已经把这个流程封装成了一个函数 cross_entropy,不用我们手算。

用之前先注意形状:logits 是 (batch_size, num_tokens, vocab_size),targets 是 (batch_size, num_tokens),而 PyTorch 的 cross_entropy 要求把 batch 维度合并展平。所以实际使用时,我们会把 logits 展平成 (batch_size × num_tokens, vocab_size),把 targets 展平成一维。

注意,targets 本身就是 token ID,它们正好对应 logits 里"我们要最大化的那个索引位置"。cross_entropy 会自己在这内部完成 softmax 和对数概率计算,一步到位——把展平后的 logits 和 targets 丢进去,直接得到损失。

与交叉熵紧密相关的概念是困惑度(perplexity)——它只是交叉熵损失的指数,也就是对损失取 exp。

困惑度常被认为更直观,因为它能读作"模型每一步不确定时的有效词汇表大小"(上面例子里是约 48,725)。换个说法:困惑度衡量模型的预测分布和数据集里词的真实分布匹配得有多好。和损失一样,困惑度越低,预测越贴近真实分布。

5.1.3 计算训练和验证集损失

我们用一篇短文本来训练 LLM,原因有三:

  • 没有好显卡也能在笔记本上几分钟跑完。
  • 训练几分钟就结束(而不是几周),对教学友好。
  • 用的是公有领域文本,可以合法地放进 GitHub 仓库、不会撑大仓库。

对比一下前面提过的 Llama 2 7B:它要在 2 万亿 token 上训 184,320 个 A100 GPU 小时,粗算约 69 万美元。

下面加载第 2 章用过的同一个数据集:一段公有领域的短篇小说《The Verdict》。加载脚本会先检查本地有没有 the-verdict.txt,没有才用 requests 从仓库下载下来,有就直接读取。

加载后顺手确认一下规模:它的字符数在一万上下,编码成 token 后总共只有 5,145 个 token,对训练 LLM 来说短得可怜,但重申一次:这是教学用途(后面我们会加载预训练权重)。

接下来把数据切成训练集和验证集:按 9:1 的比例切开,前 90% 做训练、后 10% 做验证。再用第 2 章的 create_dataloader_v1 把它们包装成数据加载器,max_length 和 stride 都设为 LLM 支持的上下文长度(也就是 256)。因为我们训练模型预测下一个词,所以目标看起来和输入一样,只是整体向右移了一位。

这里用很小的批量大小(batch_size=2),一是省算力,二是数据集本身也就这么点。(对比:Llama 2 7B 训练用的批量大小是 1024。)数据加载器准备过程中还会顺手做两件小事:一是确认切分出的 token 数足够填满一个上下文窗口,二是统计训练/验证加载器里各自的 token 总数,保证没有漏数据。

接下来实现两个工具函数:一个算单批的交叉熵损失,一个算数据加载器里若干批的平均损失。

def calc_loss_batch(input_batch, target_batch, model, device):
    input_batch, target_batch = input_batch.to(device), target_batch.to(device)
    logits = model(input_batch)
    loss = torch.nn.functional.cross_entropy(logits.flatten(0, 1), target_batch.flatten())
    return loss


def calc_loss_loader(data_loader, model, device, num_batches=None):
    total_loss = 0.
    if len(data_loader) == 0:
        return float("nan")
    elif num_batches is None:
        num_batches = len(data_loader)
    else:
        # 如果 num_batches 超过数据加载器的批次数,就缩减到实际批次数
        num_batches = min(num_batches, len(data_loader))
    for i, (input_batch, target_batch) in enumerate(data_loader):
        if i < num_batches:
            loss = calc_loss_batch(input_batch, target_batch, model, device)
            total_loss += loss.item()
        else:
            break
    return total_loss / num_batches

如果你的机器有支持 CUDA 的 GPU,LLM 会自动在 GPU 上训练,代码一行都不用改。我们用 device 变量来确保数据被送到和模型相同的设备上:有 CUDA 就用 CUDA,苹果芯片可用 MPS,否则回退到 CPU;随后调用 model.to(device) 把模型也搬过去。

接着把上面两个数据加载器直接喂给这两个函数,就能算出训练集和验证集的初始损失。注意此时模型参数还是随机的,损失很大,基本等于"瞎猜"。训练要做的事,就是让训练损失和验证损失这两个数字降下去。

5.2 训练一个 LLM

终于到了重头戏。我们实现一个简单版训练函数(想加上学习率预热、余弦退火、梯度裁剪等进阶技巧,见附录 D)。

def train_model_simple(model, train_loader, val_loader, optimizer, device, num_epochs,
                       eval_freq, eval_iter, start_context, tokenizer):
    # 初始化用于记录损失和已见 token 数的列表
    train_losses, val_losses, track_tokens_seen = [], [], []
    tokens_seen, global_step = 0, -1

    # 主训练循环
    for epoch in range(num_epochs):
        model.train()  # 把模型切换到训练模式

        for input_batch, target_batch in train_loader:
            optimizer.zero_grad() # 清空上一批迭代残留的梯度
            loss = calc_loss_batch(input_batch, target_batch, model, device)
            loss.backward() # 计算损失梯度
            optimizer.step() # 用梯度更新模型权重
            tokens_seen += input_batch.numel()
            global_step += 1

            # 可选的评估步骤
            if global_step % eval_freq == 0:
                train_loss, val_loss = evaluate_model(
                    model, train_loader, val_loader, device, eval_iter)
                train_losses.append(train_loss)
                val_losses.append(val_loss)
                track_tokens_seen.append(tokens_seen)
                print(f"Ep {epoch+1} (Step {global_step:06d}): "
                      f"Train loss {train_loss:.3f}, Val loss {val_loss:.3f}")

        # 每个 epoch 结束后打印一段生成样本
        generate_and_print_sample(
            model, tokenizer, device, start_context
        )

    return train_losses, val_losses, track_tokens_seen


def evaluate_model(model, train_loader, val_loader, device, eval_iter):
    model.eval()
    with torch.no_grad():
        train_loss = calc_loss_loader(train_loader, model, device, num_batches=eval_iter)
        val_loss = calc_loss_loader(val_loader, model, device, num_batches=eval_iter)
    model.train()
    return train_loss, val_loss


def generate_and_print_sample(model, tokenizer, device, start_context):
    model.eval()
    context_size = model.pos_emb.weight.shape[0]
    encoded = text_to_token_ids(start_context, tokenizer).to(device)
    with torch.no_grad():
        token_ids = generate_text_simple(
            model=model, idx=encoded,
            max_new_tokens=50, context_size=context_size
        )
    decoded_text = token_ids_to_text(token_ids, tokenizer)
    print(decoded_text.replace("\n", " "))  # 紧凑的打印格式
    model.train()

对照前面说的"四步"看这段:zero_grad → 前向 calc_loss_batch → backward → step,正好一一对应。另外它还在每隔 eval_freq 步时评估一次、每个 epoch 结束生成一小段文本,方便你肉眼看到进步。

现在用这个函数正式训练。流程很简单:固定随机种子、新建一个 GPTModel 并搬到 device 上,用 AdamW 优化器(学习率 0.0004、weight_decay=0.1,正好用上前面说的权重衰减),然后调用 train_model_simple 跑 10 个 epoch,每隔 5 步评估一次(eval_iter=5),起始提示就用 "Every effort moves you"。函数会把每步的训练/验证损失以及已见 token 数记录下来,供后面观察和画图。

注意,你的损失值可能和书上略有不同。只要大致接近(训练损失低于 1、验证损失低于 7),就不用担心。小差异通常来自 GPU 硬件、CUDA 版本,或更新版 PyTorch 的小改动。即使在 CPU 上跑也可能有细微差别——一个可能原因是 nn.Dropout 在不同操作系统上、取决于 PyTorch 编译方式而行为不同(见 PyTorch issue tracker)。

把训练过程画出来会更直观:横轴标 epoch、验证曲线上方再叠一条"已见 token 数"的轴,把训练损失和验证损失各画一条曲线,就能一眼看出走势。

看结果:模型最开始吐的是乱码词串,训练到快结束时已经能写出语法大致正确的句子了。但注意——看训练和验证损失,模型开始过拟合了。如果你翻它后面写的一些段落,会发现它们逐字出现在训练集里,说明它是在背课文,而不是真正学会写作。稍后我们会用解码策略来缓解这种"背书"。

这个过拟合的原因很简单:训练集实在太小,而我们把它的每一段都反复看了太多遍。 这里的训练纯粹是为了教学——重点是让你看到模型学会产出连贯文本。与其在昂贵硬件上训几周几个月,我们后面直接加载预训练权重。

想给训练函数加上学习率预热、余弦退火、梯度裁剪?见附录 D。

想用更大的数据集、更长的训练?见 ../03_bonus_pretraining_on_gutenberg。

5.3 控制随机性的解码策略

像我们训练的这个小 LLM,推理很便宜,所以即使你之前用 GPU 训练,推理阶段也没必要用 GPU——我们直接把模型搬回 CPU、切回 eval 模式,再取一次 GPT-2 分词器备用。用第 4 章的 generate_text_simple,我们可以一次一个 token 地生成新文本。如 5.1.2 节所说,下一个 token 就是词汇表里概率最高的那个。

问题来了:这种"贪婪地挑最高概率"的做法毫无随机性——不管跑多少遍,LLM 每次都吐一模一样的输出。

接下来引入两个概念——也就是解码策略(decoding strategies):**温度缩放(temperature scaling)**和 top-k 采样。它们能让模型控制生成文本的随机性和多样性。

5.3.1 温度缩放

之前我们总是用 torch.argmax 挑概率最高的 token。要增加多样性,可以改用 torch.multinomial(probs, num_samples=1) 按概率分布抽签——每个索引被选中的机会等于它在输入张量里的概率。

为了把"生成过程"讲透,我们借一个超小的玩具词汇表来走一遍。假设要接在 "every effort moves you" 后面的候选词只有 9 个(closer、every、effort、forward、inches、moves、pizza、toward、you),模型给出的 logits 经过 softmax 后变成一个 9 维概率分布。用 torch.argmax 取最大概率,会稳定地选中同一个词;而改用 torch.multinomial 从同一分布里抽签(每个词被选中的机会正比于它的概率),选出的结果就会随随机种子变化。

为了看清区别,我们干脆拿这个概率分布采样 1,000 次,数一数每个词各被抽中多少次——这也是理解后面"温度""top-k"如何改变输出的直观办法。

我们可以用一个叫温度缩放的概念来控制这个分布和选择过程。"温度缩放"听起来玄乎,其实就是把 logits 除以一个大于 0 的数再套 softmax:温度大于 1,分布更均匀;温度小于 1,分布更自信(更尖锐、更集中在少数几个峰上)。把温度取 1(原始)、0.1(更自信)、5(更均匀)三种值画成柱状图对比,一眼就能看出区别。

可以看到,温度 0.1 把分布压得非常尖锐,几乎等同于 argmax,所以最可能的词几乎总被选中;而温度 5 让分布更均匀,冷门词也有了可观的出场机会——把两种温度下的分布各采样 1,000 次统计词频,就能直接印证这一点。

但代价是:假设输入 "every effort moves you",用上面的方法有时会生成无意义的文本,比如 "every effort moves you pizza",有 3.2% 的概率(1000 次里 32 次)。这就引出了下一节的 top-k。

5.3.2 Top-k 采样

为了能用高温提高多样性、又不至于胡说八道,我们可以把采样范围限制在概率最高的 top-k 个 token 内。做法是:先用 torch.topk 找出 logits 里最大的 k 个值(连同它们的位置),再把所有小于"第 k 名那个值"的 logits 统统改写成负无穷——相当于把落选词直接判死刑。(书里用 torch.where 来做这个判断替换。)

注意:

这种 top-k 过滤还有一种替代、略更高效的写法:

new_logits = torch.full_like( # 创建全为 -inf 的张量
   next_token_logits, -torch.inf
)   
new_logits[top_pos] = next_token_logits[top_pos] # 把 top k 的值拷进这个 -inf 张量

更多细节见 https://github.com/rasbt/LLMs-from-scratch/discussions/326

把落选词的 logit 压成 −∞-\infty 后再套 softmax,就得到只保留 top-k 候选的概率分布:被丢掉的词概率全为 0,抽签时永远轮不到它们。

5.3.3 修改文本生成函数

前面两小节分别讲了温度采样和 top-k 采样。现在把它们合到一起,改写第 4 章的 generate_text_simple,得到新的 generate 函数:

def generate(model, idx, max_new_tokens, context_size, temperature=0.0, top_k=None, eos_id=None):

    # for 循环和之前一样:取 logits,只看最后一个时间步
    for _ in range(max_new_tokens):
        idx_cond = idx[:, -context_size:]
        with torch.no_grad():
            logits = model(idx_cond)
        logits = logits[:, -1, :]

        # 新增:用 top_k 采样过滤 logits
        if top_k is not None:
            # 只保留 top_k 个值
            top_logits, _ = torch.topk(logits, top_k)
            min_val = top_logits[:, -1]
            logits = torch.where(logits < min_val, torch.tensor(float("-inf")).to(logits.device), logits)

        # 新增:应用温度缩放
        if temperature > 0.0:
            logits = logits / temperature

            # 新增(书中没有):数值稳定性小技巧,让结果在 mps 设备上也一致
            # 在 softmax 前减去每行的最大值
            logits = logits - logits.max(dim=-1, keepdim=True).values
            
            # 套 softmax 得到概率
            probs = torch.softmax(logits, dim=-1)  # (batch_size, context_len)

            # 从分布中采样
            idx_next = torch.multinomial(probs, num_samples=1)  # (batch_size, 1)

        # 否则和之前一样:取 logits 最大的词汇表索引
        else:
            idx_next = torch.argmax(logits, dim=-1, keepdim=True)  # (batch_size, 1)

        if idx_next == eos_id:  # 如果指定了 eos_id 且遇到序列结束 token,就提前停止生成
            break

        # 和之前一样:把采样到的索引拼到当前序列上
        idx = torch.cat((idx, idx_next), dim=1)  # (batch_size, num_tokens+1)

    return idx

用起来也简单:把起始提示编码后交给 generate,指定最多生成 15 个新 token,top_k=25、temperature=1.4,就能得到比贪婪解码更有变化、却又不至于离谱的输出。

温控逻辑一句话总结:temperature=0 时退化成贪婪解码(走 else 分支);temperature>0 时按温度缩放后采样,再用 top_k 把候选池收窄。

5.4 在 PyTorch 里保存和加载模型权重

训练 LLM 又贵又慢,所以能保存和加载权重是刚需。PyTorch 推荐的做法是保存模型的 state_dict(本质是"参数名 → 张量"的字典):用 torch.save(model.state_dict(), "model.pth") 把它写进磁盘;之后新建一个同样配置的 GPTModel,用 load_state_dict(torch.load(..., map_location=device, weights_only=True)) 把权重读回来,再切到 eval 模式即可。

训练 LLM 常用 AdamW 这类自适应优化器(adaptive optimizer)而不是普通 SGD。它们会为每个权重额外存一些状态(比如动量)。如果你打算以后接着训练,光存模型权重不够,得把优化器状态也一起存下来——也就是用一个字典同时打包 model_state_dict 和 optimizer_state_dict,再交给 torch.save。恢复时反过来:把这两部分分别 load_state_dict 回新造好的模型和优化器,最后 model.train() 就能接着往下训。

5.5 从 OpenAI 加载预训练权重

前面我们只用一篇短篇小说训了个迷你 GPT-2,纯教学用。想看更认真的训练(在完整 Project Gutenberg 图书语料上跑很久),见 ../03_bonus_pretraining_on_gutenberg。

好消息:我们不必花几万到几十万美元从头预训练,直接加载 OpenAI 公开的预训练权重就行。


⚠️ 注意:有些用户可能在本节遇到 TensorFlow 兼容性问题,尤其是在某些 Windows 系统上。这里需要 TensorFlow 只是为了加载原始的 OpenAI GPT-2 权重文件,然后把它转成 PyTorch。如果你遇到 TensorFlow 相关问题,可以改用预先转换好的 PyTorch 权重来加载——它由前面描述的相同转换过程生成,能绕开 TensorFlow。详情见 notebook:../02_alternative_weight_loading/weight-loading-pytorch.ipynb。


首先是样板代码:从 OpenAI 下载权重文件并加载进 Python。因为 OpenAI 用的是 TensorFlow,我们不得不装 TensorFlow 来读权重(pip install tensorflow tqdm)——tqdm 只是个进度条库。随后从本文件夹的 gpt_download.py 相对导入 download_and_load_gpt2 函数(也可以写成 from llms_from_scratch.ch05 import download_and_load_gpt2)。


注意

  • 极少数情况下,安装 TensorFlow 时可能报 zsh: illegal hardware instruction python 错误,这通常是因为你机器上的 TensorFlow 安装出了问题。
  • 一位读者发现在这种情况下通过 conda 安装 TensorFlow 解决了问题,见这里。
  • 更多说明见这份补充的 Python 安装教程。

然后调用 download_and_load_gpt2(model_size="124M", models_dir="gpt2"),下载 1.24 亿参数模型的权重。它返回两个对象:一份 settings 记录了模型的各项超参数(词汇表大小、上下文长度、嵌入维度、层数、头数等),一份 params 参数字典则装着各层的权重张量,键名对应 GPT-2 的原始命名(例如 wte 就是 token 嵌入权重)。

另外,"355M"、"774M"、"1558M" 也是受支持的 model_size。不同尺寸的区别总结在图中。

现在,权重已经加载进 Python 了,但还得把它们搬进我们的 GPTModel 实例。先初始化一个新的 GPTModel。做法是在 GPT_CONFIG_124M 的基础上复制一份 NEW_CONFIG,按当前模型(这里用 "gpt2-small (124M)",另有 355M/774M/1558M,区别在于嵌入维度、层数、头数)覆盖相应字段,再补上两个关键设置——把 qkv_bias 设为 True:原始 GPT 模型的注意力查询、键、值线性层带了偏置向量,这既不必要也不推荐,但为了能正确加载权重,我们不得不启用它;同时把上下文长度改回原始 GPT-2 的 1024。用这份配置实例化出的 gpt,就准备好接收权重了。

下一步,把 OpenAI 权重赋给我们 GPTModel 实例里对应的权重张量。注意 OpenAI 的权重很多是转置存储的(w.T),而且 Q/K/V 是合在一起的 c_attn、需要拆成三份——这些"零件名对照"就是搬运的核心难点:

import numpy as np


def assign(left, right):
    if left.shape != right.shape:
        raise ValueError(f"Shape mismatch. Left: {left.shape}, Right: {right.shape}")
    return torch.nn.Parameter(torch.tensor(right))


def load_weights_into_gpt(gpt, params):
    gpt.pos_emb.weight = assign(gpt.pos_emb.weight, params['wpe'])
    gpt.tok_emb.weight = assign(gpt.tok_emb.weight, params['wte'])
    
    for b in range(len(params["blocks"])):
        q_w, k_w, v_w = np.split(
            (params["blocks"][b]["attn"]["c_attn"])["w"], 3, axis=-1)
        gpt.trf_blocks[b].att.W_query.weight = assign(
            gpt.trf_blocks[b].att.W_query.weight, q_w.T)
        gpt.trf_blocks[b].att.W_key.weight = assign(
            gpt.trf_blocks[b].att.W_key.weight, k_w.T)
        gpt.trf_blocks[b].att.W_value.weight = assign(
            gpt.trf_blocks[b].att.W_value.weight, v_w.T)

        q_b, k_b, v_b = np.split(
            (params["blocks"][b]["attn"]["c_attn"])["b"], 3, axis=-1)
        gpt.trf_blocks[b].att.W_query.bias = assign(
            gpt.trf_blocks[b].att.W_query.bias, q_b)
        gpt.trf_blocks[b].att.W_key.bias = assign(
            gpt.trf_blocks[b].att.W_key.bias, k_b)
        gpt.trf_blocks[b].att.W_value.bias = assign(
            gpt.trf_blocks[b].att.W_value.bias, v_b)

        gpt.trf_blocks[b].att.out_proj.weight = assign(
            gpt.trf_blocks[b].att.out_proj.weight, 
            params["blocks"][b]["attn"]["c_proj"]["w"].T)
        gpt.trf_blocks[b].att.out_proj.bias = assign(
            gpt.trf_blocks[b].att.out_proj.bias, 
            params["blocks"][b]["attn"]["c_proj"]["b"])

        gpt.trf_blocks[b].ff.layers[0].weight = assign(
            gpt.trf_blocks[b].ff.layers[0].weight, 
            params["blocks"][b]["mlp"]["c_fc"]["w"].T)
        gpt.trf_blocks[b].ff.layers[0].bias = assign(
            gpt.trf_blocks[b].ff.layers[0].bias, 
            params["blocks"][b]["mlp"]["c_fc"]["b"])
        gpt.trf_blocks[b].ff.layers[2].weight = assign(
            gpt.trf_blocks[b].ff.layers[2].weight, 
            params["blocks"][b]["mlp"]["c_proj"]["w"].T)
        gpt.trf_blocks[b].ff.layers[2].bias = assign(
            gpt.trf_blocks[b].ff.layers[2].bias, 
            params["blocks"][b]["mlp"]["c_proj"]["b"])

        gpt.trf_blocks[b].norm1.scale = assign(
            gpt.trf_blocks[b].norm1.scale, 
            params["blocks"][b]["ln_1"]["g"])
        gpt.trf_blocks[b].norm1.shift = assign(
            gpt.trf_blocks[b].norm1.shift, 
            params["blocks"][b]["ln_1"]["b"])
        gpt.trf_blocks[b].norm2.scale = assign(
            gpt.trf_blocks[b].norm2.scale, 
            params["blocks"][b]["ln_2"]["g"])
        gpt.trf_blocks[b].norm2.shift = assign(
            gpt.trf_blocks[b].norm2.shift, 
            params["blocks"][b]["ln_2"]["b"])

    gpt.final_norm.scale = assign(gpt.final_norm.scale, params["g"])
    gpt.final_norm.shift = assign(gpt.final_norm.shift, params["b"])
    gpt.out_head.weight = assign(gpt.out_head.weight, params["wte"])
    
    
load_weights_into_gpt(gpt, params)
gpt.to(device);

如果加载正确,就能用之前的 generate 生成新文本了:把起始提示 "Every effort moves you" 编码后交给 gpt,设置 top_k=50、temperature=1.5,一次生成 25 个新 token,再解码回文本就能看到结果。

怎么知道权重加载对了?看输出就行——模型能生成连贯的文本,就说明对了;哪怕我们犯一个小错(比如某个张量忘了转置),模型都写不出通顺的句子。

关键概念

  • 交叉熵损失(cross-entropy loss):负的平均对数概率,L=−1N∑ilog⁡p(ti)\mathcal{L} = -\frac{1}{N}\sum_{i}\log p(t_i),衡量预测分布和真实分布的距离。越小越好。
  • 困惑度(perplexity):交叉熵损失的指数,exp⁡(L)\exp(\mathcal{L}),可理解为"模型每步拿不准时的有效候选词数量",越低说明越笃定。
  • 训练循环(training loop):zero_grad → 前向 → backward → step 四步循环,是本章 train_model_simple 的骨架。
  • 过拟合(overfitting):模型死记训练数据,训练损失下降但验证损失上升;本文小数据集下尤其明显。
  • 学习率预热 / 余弦退火 / 梯度裁剪:进阶训练技巧(附录 D),分别是"起步别太猛"、"临近终点放慢"、"别让某步迈太大"。
  • 贪婪解码 vs 采样:argmax 永远选最高概率(稳定但呆板);multinomial 按分布抽签(有多样性)。
  • 温度缩放(temperature scaling):logits 除以温度 TT;T>1T>1 分布更均匀、更有创意,T<1T<1 更尖锐、更保守,T=0T=0 退化为贪婪。
  • top-k 采样:只在概率最高的 k 个 token 里采,踢掉离谱候选,兼顾多样性又不胡说。
  • state_dict:PyTorch 保存/加载模型权重的方式("参数名 → 张量"字典),可连优化器状态一起存以便续训。
  • 预训练权重(pretrained weights):直接加载 OpenAI 的 GPT-2 权重(load_weights_into_gpt),省去昂贵的预训练。

动手练习

  1. 换一个起始提示:把 start_context 改成别的短语(比如 "The meaning of life is"),重新用 generate 生成文本,观察温度设为 0、0.5、1.5 时风格有何不同。
  2. 自己实现 cross_entropy:不调用 torch.nn.functional.cross_entropy,手动用 softmax → log → 取目标位置 → 求负均值 复现它,并验证结果一致。
  3. 理解困惑度:把训练损失从 1.0 降到 0.5,困惑度分别约是多少?算一算,体会"损失降一点点、困惑度降一半"的关系。
  4. 观察过拟合:把 num_epochs 调大(比如 30),观察训练/验证损失曲线何时开始分叉,并把模型生成的文本和训练集原文对比。
  5. 加载更大的模型:把 model_size 换成 "355M" 或 "774M",看生成质量如何变化(注意显存/内存占用)。
  6. 温控与 top-k 消融:固定提示,组合不同 temperature 与 top_k,记录哪种组合最"稳"、哪种最"疯"。

练习解答见仓库的 ch05/01_main-chapter-code/exercise-solutions.ipynb。