第 4 章 LLMGPT深度学习

第 4 章 从零实现一个 GPT 模型来生成文本

第 4 章 从零实现一个 GPT 模型来生成文本

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

这章要解决什么问题

前三章我们一直在造零件:第 2 章把文本变成 token 和嵌入向量,第 3 章手写了注意力机制。但零件再多,摆在桌上也不会自己说话。

这一章的任务,就是把这些零件组装成一台能跑起来的 GPT。

打个比方:前面几章你造好了齿轮、活塞、发动机,这一章把它们塞进车架、接上油路,让整台车第一次"嗡嗡"转起来。至于它跑得好不好——那是下一章(训练)要调的事。

具体来说,本章要做六件事:

  • 定义一套和 GPT-2 小号模型(124M 参数)一样的配置;
  • 实现层归一化(LayerNorm),让数据在层与层之间保持稳定;
  • 用 GELU 激活实现前馈网络(FeedForward);
  • 加上捷径连接,也就是残差连接(residual connections),防止梯度消失;
  • 把注意力和前馈网络拼成 transformer 块(TransformerBlock);
  • 用 transformer 块堆出完整的 GPTModel,并写出文本生成函数 generate_text_simple。

先说清楚:本章搭出的模型参数是随机的,它生成的文字还是乱码。训练从下一章才开始,这里我们只是在"造壳子"。

用大白话讲原理

在动手前,先花两分钟把整台机器的样子记住。GPT 说穿了就一句话:

一堆长得一模一样的积木(transformer 块),首尾相接叠了十几层。

每个积木内部做两件事,轮流来:先让所有词互相"聊天"(注意力),再让每个词"自己消化"(前馈网络)。聊完消化、消化完再聊,叠得越深,模型对上下文的理解就越细。

现在讲讲这台机器里几块关键零件,为什么非它们不可:

层归一化(LayerNorm):数据一层层往下传,数值容易越滚越大或越缩越小,训练就飘了。LayerNorm 就像一个"校准器",每个向量都强制拉回到均值 0、方差 1 的基准线上,让后面的层好处理。不用它,深层网络几乎训不稳。

GELU:这是前馈网络里的激活函数。你可以把它理解成一个"平滑开关"——ReLU 是硬开关,输入小于 0 直接切断(归零);GELU 是平滑旋钮,负值附近还留一点点信号,曲线圆润,梯度更好。GPT-2 用的就是它。

前馈网络(FeedForward):注意力负责让词之间交换信息,前馈网络负责让每个词"单独思考一下"。它的做法是先把向量"撑大"到原来的 4 倍(腾出空间做非线性变换),再压回原尺寸。注意力和前馈,一个是"交流",一个是"消化"。

捷径连接(残差连接):想象一队人传话,传到最后一句全变味了。梯度反向传播也一样,层数一多,信号传到前面就衰减没了。捷径连接就是给信号修一条"高速公路"——把某一层的输入直接接到后面某一层的输出上,让梯度绕过中间那些复杂计算。这是深层网络能训起来的关键。

把这些零件拼在一起,就得到 transformer 块;把 transformer 块叠 12 次,前面接嵌入、后面接输出层,就得到 GPT 模型。

补充一个名词:GPT 这类模型只用了原始 transformer 架构的解码器部分(encoder-decoder 里的 decoder),顺序地一个一个生成词,所以常被称为"解码器类"(decoder-like)LLM。

还有一个反直觉的点:LLM 之所以"大",是因为参数量大,不是代码量大。它的代码往往很短,因为大部分结构都是重复的——你会看到很多 for 循环和同一个模块的反复堆叠。

4.1 先搭个"空壳"GPT,确认形状对得上

动手写真正复杂的模块之前,作者先用一个取巧的办法:搭一个骨架,把还没写的零件先用"空实现"占位,先跑通数据流、确认各层张量的形状正确。这就像装修前先用纸箱摆出家具位置,看动线顺不顺。

接下来是本章最重要的一个常数表——GPT-2 小模型的配置 GPT_CONFIG_124M。它决定了模型每层的尺寸,后面几乎所有模块都从这里取参数:

GPT_CONFIG_124M = {
    "vocab_size": 50257,    # 词表大小
    "context_length": 1024, # 上下文长度(最多能看多少个 token)
    "emb_dim": 768,         # 嵌入维度
    "n_heads": 12,          # 注意力头数量
    "n_layers": 12,         # transformer 块的层数
    "drop_rate": 0.1,       # dropout 丢弃率
    "qkv_bias": False       # 查询/键/值是否带偏置
}

(书里还先打印了 matplotlib / torch / tiktoken 的版本号方便复现,这里略去。)用短键名是为了后面避免代码行过长。逐项解释:

  • "vocab_size":词表大小 50,257,由第 2 章的 BPE 分词器决定;
  • "context_length":模型最多能接收的 token 数(1024),对应第 2 章讲的位置嵌入;
  • "emb_dim":嵌入维度 768,每个 token 会被表示成一个 768 维向量;
  • "n_heads":多头注意力里的头数,第 3 章实现过;
  • "n_layers":transformer 块叠多少层,稍后实现;
  • "drop_rate":dropout 强度(0.1 表示训练时随机丢弃 10% 的隐藏单元,用来缓解过拟合);
  • "qkv_bias":注意力的 Linear 层算 Q、K、V 时要不要偏置。我们设 False,这是现代 LLM 的标准做法;第 5 章加载 OpenAI 的 GPT-2 权重时还会回头处理它。

现在搭空壳。书里写了一个 DummyGPTModel:它的结构和真 GPT 一模一样——token 嵌入、位置嵌入、dropout、若干 transformer 块、最后归一化、输出层——但 transformer 块和 LayerNorm 都先用 Dummy(占位)版本,也就是 forward 里什么都不做、原样返回输入。这样就能先跑通数据流、确认各层张量的形状对得上,而不必等真正的模块写完。

关键在输出层 out_head:它把 768 维的向量投影回 50,257 维——每一维对应词表里一个词的"打分"(logit)。分数最高的那个词,就是模型认为最可能的下一个词。这一步是 GPT 从"向量"变回"文字"的桥。

书里用 BPE 分词器把 "Every effort moves you" 和 "Every day holds a" 两句话编成 token ID、叠成一个 2×4 的批次,喂给空壳模型,得到的输出形状是 torch.Size([2, 4, 50257]):2 个样本、每个 4 个 token、每个 token 给出 50,257 个词表打分。形状对上了,说明数据流没问题。

小提示:如果你在 Windows 或 Linux 上运行,得到的数值可能和书上不一样。不用担心——这些只是随机数,不影响后续章节。差异可能来自 nn.Dropout 在不同操作系统上(取决于 PyTorch 的编译方式)行为略有不同,参见 PyTorch issue tracker。

4.2 层归一化:把数据"拉回正轨"

层归一化(layer normalization,简称 LayerNorm)做的事很朴素:把每个输入向量的激活值围绕均值 0 居中,并把方差归一化到 1。 这一步让训练更稳定、更快收敛到有效的权重。

它在 transformer 块里的多头注意力前后各用一次,最后在输出层之前再用一次——一共三处。

书里先用一个简单小网络直观演示:造 5 维输入、过一层 Linear + ReLU 的 2 条样本,算出每条样本的均值和方差,再手动做「减均值、除标准差」。跑完你会看到每行都乖乖变成均值 0、方差 1。

注意计算均值方差时用的都是 dim=-1:归一化是对每条样本独立做的,沿着特征维度计算,而不是跨样本。换句话说,每条样本自己校准自己。书里计算方差时还用了 unbiased=False,即分母取 n 而不是 n-1,理由稍后解释。

把刚才手动做的事封装成一个 LayerNorm 类:

class LayerNorm(nn.Module):
    def __init__(self, emb_dim):
        super().__init__()
        self.eps = 1e-5
        self.scale = nn.Parameter(torch.ones(emb_dim))   # 可训练的缩放
        self.shift = nn.Parameter(torch.zeros(emb_dim))  # 可训练的偏移

    def forward(self, x):
        mean = x.mean(dim=-1, keepdim=True)
        var = x.var(dim=-1, keepdim=True, unbiased=False)
        norm_x = (x - mean) / torch.sqrt(var + self.eps)
        return self.scale * norm_x + self.shift

代码里有两个坑值得解释,它们正是原书特别强调的地方:

缩放和偏移(scale and shift):除了归一化,我们还加了两个可训练参数 scale(初值 1)和 shift(初值 0)。初值下它们不起作用,但训练中可以自动调整——如果模型发现"把这条起跑线挪一挪,效果更好",它就自己学。这给了模型灵活度,去适配它实际处理的数据分布。

为什么要加 eps:在开方之前加了一个极小的值 eps(1e-5),是为了防止方差恰为 0 时出现除零错误。

有偏方差(biased variance):var(..., unbiased=False) 表示用公式 ∑i(xi−xˉ)2n\frac{\sum_i (x_i - \bar{x})^2}{n} 计算方差,分母是 n 而不是 n-1(不带贝塞尔校正),因此是对方差的"有偏"估计。对 LLM 来说嵌入维度 n 很大,n 和 n-1 的差别可以忽略;而 GPT-2 训练时用的就是有偏方差,我们也跟着用,这样第 5 章加载预训练权重时才兼容。

试一下:把刚才那个小网络的输出喂进 LayerNorm、再统计一次均值方差,你会发现方差不会精确等于 1,因为我们加了 eps,这是正常的。

4.3 GELU 与前馈网络:给模型留出"思考"的空间

先讲激活函数。深度学习中 ReLU(修正线性单元)因为简单有效而被广泛使用。但 LLM 里除了 ReLU,还常用几个更复杂的平滑激活函数,最典型的是 GELU(高斯误差线性单元) 和 SwiGLU(Swish 门控线性单元)。

它们和 ReLU 的区别,用大白话说:ReLU 是分段线性的硬开关,输入为正就原样输出,为负就归零;GELU 和 SwiGLU 是平滑的曲线,分别融入了高斯和 sigmoid 的门控特性,在负值附近不那么"一刀切",梯度更细腻,能带来更好的效果。

GELU 的精确定义是 GELU(x)=x⋅Φ(x)\text{GELU}(x) = x \cdot \Phi(x),其中 Φ(x)\Phi(x) 是标准高斯分布的累积分布函数。实际实现时通常用更省算力的近似(GPT-2 就是用它训练的):

GELU(x)≈0.5⋅x⋅(1+tanh⁡[2π⋅(x+0.044715⋅x3)])\text{GELU}(x) \approx 0.5 \cdot x \cdot \left(1 + \tanh\left[\sqrt{\frac{2}{\pi}} \cdot \left(x + 0.044715 \cdot x^3\right)\right]\right)

书里用一个 GELU 类把这个近似式包起来,就是照上面的公式写一遍,没什么额外魔法。把 GELU 和 ReLU 画在同一张图里对比,你会看到:ReLU 是折线,负半轴直接压平为 0;GELU 是平滑曲线,除了大约 x ≈ -0.75 处,负值区域也保留了非零梯度。

有了激活函数,就能搭前馈网络 FeedForward 了。它的结构是"撑大再压回":先用一个 Linear 把嵌入维度撑大到 4 倍,过一层 GELU 激活,再用一个 Linear 压回原来的嵌入维度。中间维度是嵌入维度的 4 倍,这是 transformer 里的标准做法(GPT-2 的 768 维,中间就是 3072 维)。先升维、做非线性变换、再降维——相当于给模型一块更大的"草稿纸"来加工信息。

拿输入 2 个样本、每个 3 个 token、每个 token 768 维试一下,输出形状不变,还是 [2, 3, 768]——前馈网络只是"加工内容",不改形状。

4.4 捷径连接:给梯度修一条高速公路

接下来是捷径连接(shortcut connections),也叫跳跃连接(skip)或残差连接(residual connections)。

这个想法最早出现在计算机视觉的深度网络(残差网络 ResNet)里,用来缓解梯度消失问题。做法很简单:把某一层的输入直接加到后面某一层的输出上,跳过中间的一层或多层。 这样梯度反向传播时就有了一条更短、更通畅的路径,不会在层层衰减中消失殆尽。

书里先用一个小网络直观演示。这个网络有 5 层、可以开关捷径连接:每一层的做法是「线性层 + GELU」,再判断——如果开了捷径且输入输出形状一致,就把当前输入加回这一层的输出上,否则原样往下传。

要看清捷径的作用,书里还写了一个 print_gradients 小工具:对一个随机输入做前向、拿一个目标值算均方误差损失、反向传播,然后把各层权重梯度的平均绝对值打印出来——梯度越小,说明这层学得越"费劲"。

先用同一组输入、同一个随机种子,分别跑一次「无捷径」和「有捷径」的版本,再对比两份梯度报告,你会发现:

没加捷径时,越靠前的层(layers.0 附近)梯度越小,几乎消失;加了捷径后,早期层的梯度明显变大、更健康。

一句话记住:捷径连接让梯度"抄近路"回到前面的层,是深层网络能训得动的关键。 我们马上要在 transformer 块里用它。

4.5 Transformer 块:把注意力和前馈拼起来

现在把前面所有零件组装成 transformer 块。一个 transformer 块 = 因果多头注意力 + 前馈网络,外面各套一层 LayerNorm、一层 dropout,再加捷径连接。

它内含两个"子块",结构完全对称,可以理解为:先交流(注意力),再消化(前馈),每一步都保留原始输入(捷径连接)。

# MultiHeadAttention 来自第 3 章实现的 previous_chapters.py
from previous_chapters import MultiHeadAttention


class TransformerBlock(nn.Module):
    def __init__(self, cfg):
        super().__init__()
        self.att = MultiHeadAttention(  # 第 3 章的因果多头注意力
            d_in=cfg["emb_dim"],
            d_out=cfg["emb_dim"],
            context_length=cfg["context_length"],
            num_heads=cfg["n_heads"],
            dropout=cfg["drop_rate"],
            qkv_bias=cfg["qkv_bias"])
        self.ff = FeedForward(cfg)  # 前馈网络
        self.norm1 = LayerNorm(cfg["emb_dim"])
        self.norm2 = LayerNorm(cfg["emb_dim"])
        self.drop_shortcut = nn.Dropout(cfg["drop_rate"])

    def forward(self, x):
        # 注意力子块的捷径连接
        shortcut = x          # 先存下原始输入
        x = self.norm1(x)
        x = self.att(x)       # 形状 [batch_size, num_tokens, emb_size]
        x = self.drop_shortcut(x)
        x = x + shortcut      # 把原始输入加回来

        # 前馈子块的捷径连接
        shortcut = x
        x = self.norm2(x)
        x = self.ff(x)
        x = self.drop_shortcut(x)
        x = x + shortcut      # 把原始输入加回来

        return x

注意 norm1/norm2 都放在子模块之前(这叫 Pre-LN,是现代 LLM 的常见做法),以及两次 x = x + shortcut——这正是残差连接的实现。

拿 2 个样本、各 4 个 token、每个 768 维的输入试一下,输入输出形状完全一致。你可以把输出理解为:每个词的上下文向量被"增强"后的版本——它既融合了跟其他词的关系(注意力),又经过了自己的深加工(前馈)。

4.6 组装完整的 GPT 模型

万事俱备。现在把 transformer 块塞进 4.1 节那个空壳里,把 Dummy 占位换成真货,就得到能用的 GPT 架构。124M 的 GPT-2 里,transformer 块重复 12 次(cfg["n_layers"] = 12):

class GPTModel(nn.Module):
    def __init__(self, cfg):
        super().__init__()
        self.tok_emb = nn.Embedding(cfg["vocab_size"], cfg["emb_dim"])
        self.pos_emb = nn.Embedding(cfg["context_length"], cfg["emb_dim"])
        self.drop_emb = nn.Dropout(cfg["drop_rate"])

        # 堆 12 个 transformer 块
        self.trf_blocks = nn.Sequential(
            *[TransformerBlock(cfg) for _ in range(cfg["n_layers"])])

        self.final_norm = LayerNorm(cfg["emb_dim"])  # 输出前最后归一化
        self.out_head = nn.Linear(
            cfg["emb_dim"], cfg["vocab_size"], bias=False
        )

    def forward(self, in_idx):
        batch_size, seq_len = in_idx.shape
        tok_embeds = self.tok_emb(in_idx)
        pos_embeds = self.pos_emb(torch.arange(seq_len, device=in_idx.device))
        x = tok_embeds + pos_embeds  # 形状 [batch_size, num_tokens, emb_size]
        x = self.drop_emb(x)
        x = self.trf_blocks(x)
        x = self.final_norm(x)
        logits = self.out_head(x)
        return logits

和空壳的唯一区别,就是 DummyTransformerBlock、DummyLayerNorm 换成了真的 TransformerBlock、LayerNorm。

用随机初始权重实例化它、跑一遍之前那个 2×4 的批次,输出形状同样是 [2, 4, 50257]——每个 token 都给出对全词表的打分。

参数到底有多少?124M 是怎么来的

把所有参数加起来数一数,总量约 163M,而不是名字里的 124M。为什么差了这么多?

原因在原始 GPT-2 论文里用了一个叫**权重绑定(weight tying)**的技巧:复用 token 嵌入层(tok_emb)当作输出层,也就是令 self.out_head.weight = self.tok_emb.weight。

道理是这样的:嵌入层把 50,257 维的输入投影成 768 维,输出层把 768 维投影回 50,257 维——两张矩阵的形状完全一样,参数量也相同,所以完全可以共用一份。既然 GPT-2 论文里复用了 token 嵌入矩阵作输出矩阵,减去输出层的这部分参数,就得到 124M。

不过作者在实践中发现,不做权重重绑反而更容易训练,所以本章我们不复用。等到第 5 章加载预训练权重时,再回来看并应用权重重绑。

最后估算一下模型的显存占用(按 float32、每个参数 4 字节算),结果大约 621 MB。这也解释了为什么大模型这么吃显存——参数量直接决定内存,训练时还要额外存梯度、优化器状态,会再翻好几倍。

4.7 生成文本:一步一个字地接龙

回到开头那句话:LLM 一次只生成一个词。有了完整的 GPT 模型,我们能写出最简单的生成函数 generate_text_simple。它用的是贪婪解码(greedy decoding):每一步都选概率最高的那个 token 作为下一个输出。

技术小细节:因为概率最高等价于 logit 最大,理论上我们甚至不需要真的算 softmax,直接取 argmax 即可。这里保留 softmax 是为了让流程直观。

def generate_text_simple(model, idx, max_new_tokens, context_size):
    # idx 是当前上下文里的 token 索引,形状 (batch, n_tokens)
    for _ in range(max_new_tokens):

        # 如果上下文超出了模型支持的长度,就只保留最后 context_size 个
        # 例如模型只看 5 个 token,而上下文有 10 个,就只取最后 5 个
        idx_cond = idx[:, -context_size:]

        # 前向推理拿预测
        with torch.no_grad():
            logits = model(idx_cond)

        # 只关心最后一个时间步
        # (batch, n_tokens, vocab_size) -> (batch, vocab_size)
        logits = logits[:, -1, :]

        # softmax 得到概率
        probas = torch.softmax(logits, dim=-1)  # (batch, vocab_size)

        # 取概率最大的那个词表索引
        idx_next = torch.argmax(probas, dim=-1, keepdim=True)  # (batch, 1)

        # 把新 token 拼到序列末尾
        idx = torch.cat((idx, idx_next), dim=1)  # (batch, n_tokens+1)

    return idx

逻辑很直白:截断上下文 → 前向 → 取最后一步 → softmax → 取最大 → 拼回去,循环 max_new_tokens 次。每转一圈就吐出一个新 token。

书里准备了一个输入 "Hello, I am",用分词器把它编成 token ID、再加上一个批次维度,然后调用 generate_text_simple 让它往下接 6 个 token,最后把生成的 token ID 解码回文字。

你会发现输出是一通乱码。这很正常——模型还没训练,权重是随机的,它只是在随机接龙。让它说出人话,是下一章(训练)的任务。

关键概念

  • 解码器类 LLM(decoder-like LLM):只使用 transformer 解码器部分的模型,顺序地一个一个生成词;GPT 属于这一类。
  • LayerNorm(层归一化):把激活归一化到均值 0、方差 1,稳定训练;带可训练的 scale 和 shift,并加 eps 防除零。
  • GELU(高斯误差线性单元):比 ReLU 更平滑的激活函数,GPT-2 用的是带 tanh 的近似版本。
  • FeedForward(前馈网络):两层线性层夹一个 GELU,中间维度是嵌入维度的 4 倍(先撑大再压回)。
  • 捷径连接(shortcut / residual connections):把某层输入直接加到后面某层的输出上,为梯度修一条短路径,防止梯度消失。
  • TransformerBlock(transformer 块):因果多头注意力 + 前馈网络,各配 LayerNorm、dropout 和捷径连接;是 GPT 重复堆叠的基本积木。
  • GPTModel:token 嵌入 + 位置嵌入 + 12 个 transformer 块 + 最终 LayerNorm + 输出层,输出对词表中每个词的打分(logits)。
  • 权重重绑(weight tying):把 token 嵌入矩阵复用为输出层矩阵;原始 GPT-2 用它,所以参数是 124M 而非 163M。
  • 贪婪解码(greedy decoding):每一步都选概率最高的 token,简单快速但未必最优。

动手练习

  1. 换配置练手:把 GPT_CONFIG_124M 改成 GPT-2 论文里其它几档尺寸,看看参数量和模型大小怎么变。它们同样出自 GPT-2 论文:

    • GPT2-small(就是本章已实现的 124M 配置):emb_dim = 768、n_layers = 12、n_heads = 12
    • GPT2-medium:emb_dim = 1024、n_layers = 24、n_heads = 16
    • GPT2-large:emb_dim = 1280、n_layers = 36、n_heads = 20
    • GPT2-XL:emb_dim = 1600、n_layers = 48、n_heads = 25
  2. 读完整脚本:./gpt.py 是一个自包含脚本,包含本章实现的所有 GPT 代码,可以对照阅读。

  3. 做练习并核对答案:练习解答见仓库的 ch04/01_main-chapter-code/exercise-solutions.ipynb。