Transformer on 方糖猫Blog

大模型是怎么炼成的？LLM 训练全流程数学拆解（公式 + 演算 + 避坑）

Sat, 08 Aug 2026 11:16:00 +0800

大模型是怎么炼成的？LLM 训练全流程数学拆解

目标读者：学过函数、导数、向量/矩阵基础，想搞清楚 LLM 训练本质的同学。
本文目标：把“炼丹”过程拆成可计算的公式和可复现的例子。

写在前面：LLM 训练其实就是“猜下一个词”

大语言模型（Large Language Model，LLM）看起来很神秘，但核心任务可以概括为一句话：

给定前面的词，预测下一个词。

整个训练流程可以拆成 5 大块：

数据预处理：把互联网上的文本变成模型能吃的“数字串”。
Tokenization：把句子切分成 token，再映射成向量。
Transformer 前向传播：用 Attention 机制捕捉上下文关系。
计算损失：模型猜的下一个词和真实下一个词差多少。
反向传播 + 优化器：用梯度调整权重，让模型越猜越准。

下面每一节都会先讲直觉，再给公式、例子、图解和踩坑经验。

一、训练全景图：从原始文本到可用模型

1.1 一句话理解

LLM 的训练就像教一个小孩学说话：先给他看大量书（预训练），再教他怎么礼貌回答（SFT），最后告诉他哪些回答更好（RLHF）。

1.2 三阶段训练流程

flowchart LR
    subgraph 数据
        D1["原始文本（网页、书籍、代码）"]
        D2["清洗 / 去重 / 过滤"]
        D3["Token 序列"]
    end

    subgraph 训练阶段
        P["① 预训练 Pre-training"]
        S["② 监督微调 SFT"]
        R["③ 强化学习 RLHF / DPO"]
    end

    subgraph 输出
        M["基础大模型"]
        C["对话模型"]
        A["对齐模型"]
    end

    D1 --> D2 --> D3 --> P --> M
    M --> S --> C
    C --> R --> A

1.3 每个阶段在优化什么？

阶段	输入	目标	损失函数
预训练	海量无标注文本	学会语言结构和知识	下一个 token 的交叉熵
SFT	（ prompt, answer ）配对	学会按人类习惯回答问题	监督式交叉熵
RLHF	prompt + 多条回答 + 人类排序	学会生成更受欢迎的回答	PPO / DPO 奖励模型

二、数据预处理与 Tokenization

2.1 一句话理解

模型看不懂汉字或英文，只能看数字。Tokenization 就是把文本切成最小单元，再查表换成整数 ID。

2.2 BPE 编码例子

BPE（Byte Pair Encoding）是 LLM 最常用的分词方法，核心思想：把出现频率高的子词合并成一个 token。

假设语料里经常出现：

low, lower, lowest, high, higher, highest

初始把每个字符当做一个 token：

l, o, w, e, r, h, i, g

发现 er 出现很多次，合并成新 token er；发现 est 出现很多次，合并成 est。最后得到词表：

low, lower, lowest, high, higher, highest, er, est

2.3 从文本到 ID 的例子

假设词表（vocabulary）有 10000 个 token，其中：

文本	Token ID
北京	1024
是	7
中国	2048
的	3
首都	4096

句子：

北京 是 中国 的 首都

变成 token ID 序列：

$$ \mathbf{x} = [1024,\ 7,\ 2048,\ 3,\ 4096] $$

2.4 Embedding：把 ID 变成向量

每个 token ID 会查一张 Embedding 表，得到长度为 $d$ 的向量。假设 $d=4$，词表大小 $V=10000$：

$$ \mathbf{E} \in \mathbb{R}^{10000 \times 4} $$

对 token ID $1024$，取第 $1024$ 行：

$$ \mathbf{e}_{1024} = \mathbf{E}[1024] \in \mathbb{R}^4 $$

整个句子就变成矩阵：

$$ \mathbf{X} = \begin{bmatrix} \mathbf{e}_{1024}^\top \\ \mathbf{e}_{7}^\top \\ \mathbf{e}_{2048}^\top \\ \mathbf{e}_{3}^\top \\ \mathbf{e}_{4096}^\top \end{bmatrix} \in \mathbb{R}^{5 \times 4} $$

实际 LLM 中 $d$ 通常是 768、1024、4096、8192 等。

2.5 流程图

flowchart LR
    T["原始文本"] --> B["BPE / SentencePiece 分词"]
    B --> I["Token ID 序列"]
    I --> E["Embedding 查表"]
    E --> X["输入向量矩阵 X ∈ R^(T×d)"]

2.6 使用注意点 / 避坑

坑	现象	处理
词表太小	很多词被切成很多 token，序列变长、效率低	词表一般设 32k-200k
词表太大	稀疏 token 训练不充分，Embedding 质量差	平衡词表大小和数据量
中英文混合	中文常按字切，导致同样内容 token 数比英文多	训练中文专用 BPE
特殊符号处理	数字、代码、表情被切得很碎	预处理时统一格式，保留代码结构

2.7 异常场景处理

OOV（Out of Vocabulary）：现代 BPE 会把未知字符拆成 <unk> 或字节级子词，基本不会出现完全无法表示的情况。出现 <unk> 过多时，检查清洗流程。
序列超长： truncation 截断或滑动窗口切分，不要硬塞。
标签泄漏：预训练数据里混入了测试集内容，会导致评估指标虚高。要严格去重、划分数据。

三、Transformer 架构：Attention + FFN

3.1 一句话理解

Transformer 就像一个“全连接阅读器”：每个词都能直接看到其他所有词，并通过 Attention 机制决定该关注谁。

3.2 结构图

flowchart TD
    subgraph TransformerBlock["Transformer Block"]
        X["输入 X"] --> LN1["LayerNorm"]
        LN1 --> A["Multi-Head Self-Attention"]
        A --> Add1["X + Attention(X)"]
        Add1 --> LN2["LayerNorm"]
        LN2 --> F["Feed Forward Network"]
        F --> Add2["+ 残差连接"]
    end
    Add2 --> OUT["输出"]

堆叠很多个这样的 Block，再接一个输出层，就是 GPT 系列的结构。

3.3 Attention 的数学公式

对于某个输入序列，先通过三个权重矩阵算出 Query、Key、Value：

$$ \begin{aligned} \mathbf{Q} &= \mathbf{X} \mathbf{W}^Q \\ \mathbf{K} &= \mathbf{X} \mathbf{W}^K \\ \mathbf{V} &= \mathbf{X} \mathbf{W}^V \end{aligned} $$

然后计算 Scaled Dot-Product Attention：

$$ \text{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{softmax}\left( \frac{\mathbf{Q}\mathbf{K}^\top}{\sqrt{d_k}} \right) \mathbf{V} $$

其中：

$d_k$：每个 head 的 Key/Query 维度。
除以 $\sqrt{d_k}$ 是为了防止点积结果太大，导致 softmax 梯度消失。
softmax 把分数变成概率分布（每行之和为 1）。

3.4 计算例子：Attention 到底在算什么？

假设输入序列有 3 个 token，每个 token 的向量维度 $d=4$。为了演示，简化为 $d_k = 2$。

输入矩阵：

$$ \mathbf{X} = \begin{bmatrix} 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \\ 1 & 1 & 0 & 0 \end{bmatrix} $$

假设已经学过权重（实际训练中得到）：

$$ \mathbf{W}^Q = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 0 & 0 \\ 0 & 0 \end{bmatrix}, \quad \mathbf{W}^K = \begin{bmatrix} 0 & 1 \\ 1 & 0 \\ 0 & 0 \\ 0 & 0 \end{bmatrix} $$

计算 Q 和 K：

$$ \mathbf{Q} = \mathbf{X}\mathbf{W}^Q = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix}, \quad \mathbf{K} = \mathbf{X}\mathbf{W}^K = \begin{bmatrix} 0 & 1 \\ 1 & 0 \\ 1 & 1 \end{bmatrix} $$

计算 $\mathbf{Q}\mathbf{K}^\top$：

$$ \begin{aligned} \mathbf{Q}\mathbf{K}^\top &= \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \begin{bmatrix} 0 & 1 & 1 \\ 1 & 0 & 1 \end{bmatrix} \\ &= \begin{bmatrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 2 \end{bmatrix} \end{aligned} $$

除以 $\sqrt{d_k} = \sqrt{2} \approx 1.414$：

$$ \frac{\mathbf{Q}\mathbf{K}^\top}{\sqrt{2}} \approx \begin{bmatrix} 0 & 0.707 & 0.707 \\ 0.707 & 0 & 0.707 \\ 0.707 & 0.707 & 1.414 \end{bmatrix} $$

对每一行做 softmax（以第一行为例）：

$$ \text{softmax}([0,\ 0.707,\ 0.707]) = \left[ \frac{e^0}{Z},\ \frac{e^{0.707}}{Z},\ \frac{e^{0.707}}{Z} \right] $$

其中 $Z = e^0 + e^{0.707} + e^{0.707} \approx 1 + 2.028 + 2.028 = 5.056$。

所以第一行：

$$ [0.198,\ 0.401,\ 0.401] $$

含义：第一个 token 更关注第二个和第三个 token。

3.5 为什么需要 Masked Attention？

训练语言模型时，模型只能看到当前位置及之前的 token，不能偷看答案。所以要用一个上三角为 $-\infty$ 的 Mask：

0   -∞  -∞
0    0  -∞
0    0   0

这样 softmax 之后，当前位置看不到后面的词。

3.6 使用注意点 / 避坑

坑	现象	处理
$d_k$ 算错	Attention 分数尺度异常，训练不稳定	检查 head 维度 = 总维度 / head 数
忘记 Mask	模型作弊，直接看到未来 token，loss 特别低但推理崩溃	训练时加 causal mask
Softmax 数值溢出	$e^{1000}$ 变成 Inf	实现时先做 `x - max(x)` 再 exp
注意力权重全一样	Q/K 初始化或学习率问题	检查初始化、LayerNorm 位置

3.7 异常场景处理

Attention 权重集中在某一个位置：可能是某个 token 的 Key 向量特别大，检查是否没做 scale，或 LayerNorm 失效。
Loss 很低但生成质量差：可能是 mask 写错，训练时模型偷看了未来词，推理时却没有未来词可用。
Multi-Head Attention 输出震荡：不同 head 学到的模式冲突，适当增加 warmup 轮数。

四、前向传播：从输入到预测概率

4.1 一句话理解

前向传播就是数据从输入层一直流到输出层，最后得到“下一个词是词表里每个词的概率”。

4.2 计算图

flowchart LR
    X["输入 Token IDs"] --> E["Embedding"]
    E --> PE["+ 位置编码 Positional Encoding"]
    PE --> TB["Transformer Blocks × N"]
    TB --> LN["Final LayerNorm"]
    LN --> LM["线性层 Linear"]
    LM --> Soft["Softmax"]
    Soft --> P["概率分布 P(next token | previous)"]

4.3 输出层公式

Transformer 最后一层的输出 $\mathbf{H} \in \mathbb{R}^{T \times d}$，乘以输出权重矩阵 $\mathbf{W}_{\text{out}} \in \mathbb{R}^{d \times V}$，得到 logits：

$$ \mathbf{Z} = \mathbf{H} \mathbf{W}_{\text{out}} + \mathbf{b}_{\text{out}} \in \mathbb{R}^{T \times V} $$

对 logits 做 softmax，得到概率：

$$ P(w_t = j \mid w_{<t}) = \frac{e^{z_{t,j}}}{\sum_{k=1}^{V} e^{z_{t,k}}} $$

4.4 计算例子

假设词表大小 $V=5$，某一步的 logits：

$$ \mathbf{z} = [2.0,\ 1.0,\ 0.5,\ 0.1,\ -1.0] $$

先求 $e^{z_i}$：

$$ e^{2.0} \approx 7.389,\ e^{1.0} \approx 2.718,\ e^{0.5} \approx 1.649,\ e^{0.1} \approx 1.105,\ e^{-1.0} \approx 0.368 $$

求和：

$$ Z = 7.389 + 2.718 + 1.649 + 1.105 + 0.368 = 13.229 $$

概率分布：

$$ \mathbf{p} = [0.558,\ 0.205,\ 0.125,\ 0.084,\ 0.028] $$

模型认为第一个词概率最大，为 55.8%。

4.5 使用注意点 / 避坑

logits 尺度影响 softmax：如果 logits 都很大，softmax 会接近 one-hot，梯度变小；温度参数 $T$ 可以调整：

$$ P_i = \frac{e^{z_i / T}}{\sum_j e^{z_j / T}} $$

输出层权重共享（Weight Tying）：很多 LLM 把 Embedding 矩阵和输出层矩阵共享，减少参数并提升效果。
推理时不要复用训练时的 dropout：切换到 eval 模式，否则结果不稳定。

4.6 异常场景处理

Softmax 输出全 0 或 NaN：检查 logits 是否 overflow，实现时减去最大值。
生成结果重复同一个 token：可能是温度太低、top-k/top-p 设置不当，或训练数据里该模式重复过多。
概率分布太平：模型不自信，增加训练或检查标签是否正确。

五、损失函数：Cross Entropy Loss

5.1 一句话理解

Cross Entropy 衡量“模型预测的分布”和“真实分布”之间的距离。预测越准，loss 越小。

5.2 数学公式

对于下一个 token 的真实标签是第 $c$ 个词（one-hot 向量 $\mathbf{y}$），模型预测概率为 $\mathbf{p}$：

$$ \mathcal{L} = -\sum_{j=1}^{V} y_j \log(p_j) = -\log(p_c) $$

因为只有真实位置 $c$ 的 $y_c=1$，其他为 0，所以 loss 简化为 负对数似然。

5.3 计算例子

真实下一个词是第 1 个（从 0 开始数也是第 1 个），模型预测概率：

$$ \mathbf{p} = [0.558,\ 0.205,\ 0.125,\ 0.084,\ 0.028] $$

真实标签 $c=1$，所以 $p_c = 0.205$：

$$ \mathcal{L} = -\log(0.205) \approx 1.585 $$

如果模型完全猜对，$p_c = 0.999$：

$$ \mathcal{L} = -\log(0.999) \approx 0.001 $$

如果完全猜错，$p_c = 0.001$：

$$ \mathcal{L} = -\log(0.001) \approx 6.908 $$

loss 越小，模型对真实下一个词的预测概率越高。

5.4 一个 batch 的平均 loss

训练时一个 batch 有 $B$ 个样本，每个样本有 $T$ 个 token 位置参与预测，平均 loss：

$$ \mathcal{L}_{\text{batch}} = -\frac{1}{B \cdot T} \sum_{b=1}^{B} \sum_{t=1}^{T} \log p\left(w_t^{(b)} \mid w_{<t}^{(b)}\right) $$

5.5 使用注意点 / 避坑

坑	现象	处理
标签 smoothing 过度	模型变得不自信，输出模糊	label smoothing 一般 0.1 左右
忽略 padding	padding 位置也参与 loss 计算，污染梯度	用 mask 屏蔽 padding
loss 为负	对数定义域问题或实现 bug	检查 softmax 前是否减了最大值
z-loss 没加	MoE 模型路由不稳定	加 auxiliary loss 约束专家负载

5.6 异常场景处理

Loss 一开始很大然后骤降：正常现象，说明模型快速学习简单模式。
Loss 一直不下降：检查学习率、数据质量、标签是否正确。
Loss 变成 NaN：通常是学习率过大、梯度爆炸或出现了 $\log(0)$，加 epsilon 或做梯度裁剪。

六、反向传播：从损失回到每个权重

6.1 一句话理解

反向传播就是用链式法则，从输出层的 loss 倒推，算出每个权重对 loss 的贡献。

6.2 链式法则回顾

复合函数求导：

$$ \frac{\partial \mathcal{L}}{\partial w} = \frac{\partial \mathcal{L}}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} $$

神经网络就是很多层复合函数套在一起，反向传播只是系统化地算一遍。

6.3 计算例子：一个简单的输出层权重

假设模型最后一层只有一个神经元，简化为：

$$ \begin{aligned} z &= w \cdot h + b \\ p &= \sigma(z) \\ \mathcal{L} &= -y \log(p) - (1-y)\log(1-p) \end{aligned} $$

其中 $h$ 是 Transformer 最后一层的某个隐藏状态，$y$ 是真实标签（0 或 1）。

已知：$h=2.0$，$w=0.5$，$b=-1.0$，$y=1$。

前向：

$$ \begin{aligned} z &= 0.5 \times 2.0 + (-1.0) = 0 \\ p &= \sigma(0) = 0.5 \\ \mathcal{L} &= -\log(0.5) \approx 0.693 \end{aligned} $$

反向：

$$ \frac{\partial \mathcal{L}}{\partial z} = p - y = 0.5 - 1 = -0.5 $$

然后：

$$ \begin{aligned} \frac{\partial \mathcal{L}}{\partial w} &= \frac{\partial \mathcal{L}}{\partial z} \cdot \frac{\partial z}{\partial w} = -0.5 \times 2.0 = -1.0 \\ \frac{\partial \mathcal{L}}{\partial b} &= \frac{\partial \mathcal{L}}{\partial z} \cdot \frac{\partial z}{\partial b} = -0.5 \times 1 = -0.5 \end{aligned} $$

更新（学习率 $\eta = 0.1$）：

$$ \begin{aligned} w_{\text{new}} &= 0.5 - 0.1 \times (-1.0) = 0.6 \\ b_{\text{new}} &= -1.0 - 0.1 \times (-0.5) = -0.95 \end{aligned} $$

再算一次前向，$z = 0.6 \times 2.0 - 0.95 = 0.25$，$p = \sigma(0.25) \approx 0.562$，loss 变小。

6.4 Transformer 里的反向传播

flowchart TD
    L["Loss"] --> O["输出层梯度"]
    O --> TB["Transformer Block N"]
    TB --> TB2["Transformer Block N-1"]
    TB2 --> DOTS["..."]
    DOTS --> E["Embedding 层"]
    E --> G["所有权重梯度"]

6.5 使用注意点 / 避坑

坑	现象	处理
梯度消失	深层网络前面层梯度接近 0，学不动	残差连接、LayerNorm、更好的初始化
梯度爆炸	loss 突然变成 NaN，权重更新巨大	梯度裁剪、减小学习率、混合精度检查
激活函数死区	ReLU 神经元永久输出 0	用 GeLU/SiLU，或用 SwiGLU
checkpoint 丢失梯度	梯度检查点实现错误	验证 checkpoint 前后梯度一致

6.6 异常场景处理

某些层梯度全 0：检查激活函数是否全部死亡，或该层是否被 freeze。
不同层梯度差 1000 倍：深层网络不稳定，加梯度裁剪或 LayerNorm。
Loss 反升：学习率过大或数据里有异常样本，先降学习率再查数据。

七、优化器：AdamW + 学习率调度

7.1 一句话理解

AdamW 是 Adam 的改进版，它在更新权重的同时做真正的权重衰减（Weight Decay），让模型参数不要太大，防止过拟合。

7.2 Adam 更新公式

对于参数 $\theta$ 和梯度 $g_t$：

$$ \begin{aligned} m_t &= \beta_1 m_{t-1} + (1 - \beta_1) g_t \\ v_t &= \beta_2 v_{t-1} + (1 - \beta_2) g_t^2 \\ \hat{m}_t &= \frac{m_t}{1 - \beta_1^t} \\ \hat{v}_t &= \frac{v_t}{1 - \beta_2^t} \\ \theta_t &= \theta_{t-1} - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} \end{aligned} $$

$m_t$：一阶动量（梯度的指数移动平均）。
$v_t$：二阶动量（梯度平方的指数移动平均）。
$\beta_1=0.9$，$\beta_2=0.999$，$\epsilon=10^{-8}$ 是常用默认值。

7.3 AdamW 的权重衰减

AdamW 把权重衰减放在梯度更新之外：

$$ \theta_t = \theta_{t-1} - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} - \eta \lambda \theta_{t-1} $$

其中 $\lambda$ 是 weight decay 系数，常见值 $0.01$。

7.4 计算例子

假设参数 $\theta_{t-1} = 1.0$，梯度 $g_t = -2.0$，学习率 $\eta = 0.1$，$\lambda = 0.01$。

为了简化，假设 $m_t \approx g_t = -2.0$，$v_t \approx g_t^2 = 4.0$（已经稳定）。

Adam 部分：

$$ \Delta \theta_{\text{Adam}} = -\eta \cdot \frac{g_t}{\sqrt{g_t^2} + \epsilon} = -0.1 \cdot \frac{-2.0}{2.0 + 10^{-8}} \approx 0.1 $$

Weight Decay 部分：

$$ \Delta \theta_{\text{WD}} = -\eta \lambda \theta_{t-1} = -0.1 \times 0.01 \times 1.0 = -0.001 $$

最终更新：

$$ \theta_t = 1.0 + 0.1 - 0.001 = 1.099 $$

没有 weight decay 时 $\theta_t = 1.1$，AdamW 让它稍微小一点。

7.5 学习率调度

LLM 训练通常用 warmup + cosine decay：

flowchart LR
    A["lr = 0"] --> B["Warmup 线性上升"]
    B --> C["Cosine Decay 下降"]
    C --> D["最小学习率保持"]

公式：

$$ \eta_t = \begin{cases} \eta_{\max} \cdot \frac{t}{t_{\text{warmup}}}, & t < t_{\text{warmup}} \\ \eta_{\min} + \frac{1}{2}(\eta_{\max} - \eta_{\min}) \left(1 + \cos\left(\frac{t - t_{\text{warmup}}}{t_{\max} - t_{\text{warmup}}} \pi\right)\right), & t \ge t_{\text{warmup}} \end{cases} $$

7.6 使用注意点 / 避坑

坑	现象	处理
Weight decay 太大	参数被压得太小，欠拟合	常见 0.01，小模型可 0.1
Warmup 太短	早期梯度爆炸，loss 变成 NaN	warmup 步数设总步数的 1%-3%
学习率衰减太快	还没收敛就降到 0	调整 cosine 周期或最小学习率
AdamW β 参数写错	训练异常	β1=0.9，β2=0.999，不要混淆

7.7 异常场景处理

Loss 在 warmup 阶段就 NaN：说明峰值学习率太高，或 warmup 太短，降低 $\eta_{\max}$。
Loss 降到一定程度后停滞：可能是学习率太小，检查 cosine 是否已经进入尾部。
验证 loss 比训练 loss 高很多：过拟合，增大 weight decay 或加 dropout。

八、从预训练到 RLHF：三阶段训练

8.1 预训练：让模型“博览群书”

目标函数：

$$ \mathcal{L}_{\text{PT}} = -\mathbb{E}_{x \sim D_{\text{pretrain}}} \left[ \sum_t \log P(x_t \mid x_{<t}; \theta) \right] $$

数据量通常是万亿级 token，算力消耗最大。

8.2 SFT：监督微调

用人工标注的（prompt, answer）对训练：

$$ \mathcal{L}_{\text{SFT}} = -\mathbb{E}_{(x,y) \sim D_{\text{sft}}} \left[ \sum_t \log P(y_t \mid x, y_{<t}; \theta) \right] $$

注意：通常只计算 answer 部分的 loss，prompt 部分用 mask 屏蔽。

8.3 RLHF：人类反馈强化学习

flowchart TD
    P["Prompt"] --> RM["奖励模型 Reward Model"]
    RM --> R["奖励分数 r"]
    R --> PPO["PPO 优化策略模型"]
    PPO --> M["更新后的模型"]

奖励模型给回答打分，PPO 用策略梯度优化：

$$ \nabla_\theta J = \mathbb{E}_{x,y} \left[ r(x,y) \cdot \nabla_\theta \log P(y \mid x; \theta) \right] - \beta \cdot \text{KL}(P_\theta | P_{\text{ref}}) $$

第二项是 KL 散度约束，防止模型跑得太偏。

8.4 DPO：更简单的对齐方法

DPO（Direct Preference Optimization）不用训练奖励模型，直接用偏好数据优化：

$$ \mathcal{L}_{\text{DPO}} = -\mathbb{E}_{(x, y_w, y_l)} \left[ \log \sigma\left( \beta \log \frac{P(y_w \mid x)}{P_{\text{ref}}(y_w \mid x)} - \beta \log \frac{P(y_l \mid x)}{P_{\text{ref}}(y_l \mid x)} \right) \right] $$

其中 $y_w$ 是人类更喜欢的回答，$y_l$ 是较差的回答。

8.5 使用注意点 / 避坑

坑	现象	处理
SFT 数据太少	模型学会模板但泛化差	SFT 数据通常 10k-1M 条
SFT 只训 answer	prompt 也参与 loss 会干扰	用 label mask 只保留 answer
RLHF 奖励黑客	模型钻奖励模型漏洞，生成无意义高分回答	加 KL 约束、人工抽检
DPO 偏好数据噪声	模型对齐方向乱	严格清洗偏好对

8.6 异常场景处理

SFT 后模型不会遵循指令：检查 prompt 格式是否和预训练一致，增加多轮对话样本。
RLHF 后模型过度讨好：奖励模型可能偏向“长回答”或“道歉”，调整奖励函数。
对齐后模型能力下降：KL 系数太大，模型被锁死；太小，模型跑偏。需要调 $\beta$。

九、PyTorch 实战：一个可运行的 MiniGPT Demo

9.1 一句话理解

前面几节的公式，在 PyTorch 里其实只有几行代码：前向传播是 model(x)，交叉熵是 F.cross_entropy，反向传播是 loss.backward()，AdamW 更新是 optimizer.step()。下面这个约 70 行的脚本可以在 CPU 上直接跑通完整训练流程。

9.2 完整代码（CPU 可运行）

"""MiniGPT：用 PyTorch 跑通 LLM 训练全流程"""
import math
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(42)

# ===== 0. 复现 3.4 节的 Attention 手算例子 =====
X = torch.tensor([[1, 0, 1, 0], [0, 1, 0, 1], [1, 1, 0, 0]], dtype=torch.float32)
WQ = torch.tensor([[1, 0], [0, 1], [0, 0], [0, 0]], dtype=torch.float32)
WK = torch.tensor([[0, 1], [1, 0], [0, 0], [0, 0]], dtype=torch.float32)
Q, K = X @ WQ, X @ WK
attn = torch.softmax(Q @ K.T / math.sqrt(2), dim=-1)
print("Attention 第一行:", attn[0].tolist())  # ≈ [0.198, 0.401, 0.401]，与手算一致

# ===== 1. 数据预处理与 Tokenization（对应第二节）=====
# 玩具语料：字符级分词，真实 LLM 用的是 BPE
corpus = "北京是中国的首都。北京有天安门。中国的首都是北京。" * 20
chars = sorted(set(corpus))
stoi = {ch: i for i, ch in enumerate(chars)}
itos = {i: ch for ch, i in stoi.items()}
V = len(chars)
data = torch.tensor([stoi[ch] for ch in corpus], dtype=torch.long)

# ===== 2. 模型：Embedding + Transformer Block + 输出层（第三、四节）=====
class MiniGPT(nn.Module):
    def __init__(self, vocab_size, d_model=64, n_head=4, n_layer=2, max_len=32):
        super().__init__()
        self.max_len = max_len
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(max_len, d_model)
        layer = nn.TransformerEncoderLayer(d_model, n_head, dim_feedforward=4 * d_model,
                                           batch_first=True, norm_first=True)
        self.blocks = nn.TransformerEncoder(layer, num_layers=n_layer)
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size, bias=False)
        self.head.weight = self.tok_emb.weight  # Weight Tying（4.5 节）

    def forward(self, idx):
        T = idx.size(1)
        x = self.tok_emb(idx) + self.pos_emb(torch.arange(T, device=idx.device))
        # causal mask：上三角为 -inf，防止偷看未来 token（3.5 节）
        mask = torch.triu(torch.full((T, T), float("-inf"), device=idx.device), diagonal=1)
        h = self.ln_f(self.blocks(x, mask=mask))
        return self.head(h)  # logits: (B, T, V)

model = MiniGPT(V)

# ===== 3. 取 batch：输入和标签错开一位（预测下一个 token）=====
B, T = 16, 32
def get_batch():
    ix = torch.randint(0, len(data) - T - 1, (B,))
    x = torch.stack([data[i:i + T] for i in ix])
    y = torch.stack([data[i + 1:i + T + 1] for i in ix])  # 标签 = 输入右移一位
    return x, y

# ===== 4. 优化器与学习率调度：AdamW + warmup + cosine（第七节）=====
max_steps, warmup_steps, lr_max, lr_min = 300, 10, 3e-3, 3e-4
optimizer = torch.optim.AdamW(model.parameters(), lr=lr_max, weight_decay=0.01)

def lr_lambda(step):
    if step < warmup_steps:                      # warmup 线性上升
        return step / warmup_steps
    p = (step - warmup_steps) / (max_steps - warmup_steps)
    return lr_min / lr_max + 0.5 * (1 - lr_min / lr_max) * (1 + math.cos(math.pi * p))

scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

# ===== 5. 训练循环：前向 → CE loss → 反向传播 → 更新（第四、五、六节）=====
for step in range(max_steps):
    x, y = get_batch()
    logits = model(x)                                        # 前向传播
    loss = F.cross_entropy(logits.view(-1, V), y.view(-1))   # 交叉熵（5.2 节）
    optimizer.zero_grad()
    loss.backward()                                          # 反向传播（链式法则）
    grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # 梯度裁剪（6.5 节）
    optimizer.step()                                         # AdamW 更新权重
    scheduler.step()
    if step % 30 == 0 or step == max_steps - 1:
        lr = scheduler.get_last_lr()[0]
        ppl = math.exp(loss.item())                          # perplexity（第十节第 5 条）
        print(f"step {step:4d} | loss {loss.item():.4f} | ppl {ppl:7.2f} | lr {lr:.5f} | grad {grad_norm:.2f}")

# ===== 6. 生成：贪心解码 =====
model.eval()
idx = torch.tensor([[stoi["北"]]], dtype=torch.long)
for _ in range(15):
    logits = model(idx[:, -model.max_len:])
    nxt = logits[0, -1].argmax()                             # 贪心：取概率最大的 token
    idx = torch.cat([idx, nxt.view(1, 1)], dim=1)
print("生成:", "".join(itos[i] for i in idx[0].tolist()))

运行方式：

pip install torch   # CPU 版即可
python demo.py

9.3 实际运行输出

在 CPU（torch 2.5.1）上跑一遍，输出如下：

Attention 第一行: [0.1978, 0.4011, 0.4011]
词表大小 V=13, 总 token 数=500
参数量: 102976
step    0 | loss 41.3162 | ppl 8.8e+17 | lr 0.00030 | grad 14.51
step   30 | loss 0.6630  | ppl    1.94 | lr 0.00297 | grad 1.07
step   60 | loss 0.2738  | ppl    1.32 | lr 0.00280 | grad 1.08
step   90 | loss 0.0683  | ppl    1.07 | lr 0.00251 | grad 0.28
step  120 | loss 0.0576  | ppl    1.06 | lr 0.00214 | grad 0.24
step  150 | loss 0.0315  | ppl    1.03 | lr 0.00171 | grad 0.20
step  180 | loss 0.0456  | ppl    1.05 | lr 0.00127 | grad 0.21
step  210 | loss 0.0325  | ppl    1.03 | lr 0.00088 | grad 0.18
step  240 | loss 0.0330  | ppl    1.03 | lr 0.00057 | grad 0.20
step  270 | loss 0.0369  | ppl    1.04 | lr 0.00037 | grad 0.11
step  299 | loss 0.0458  | ppl    1.05 | lr 0.00030 | grad 0.20
生成: 北京有天安门。中国的首都是北京。

几个值得注意的点：

Attention 第一行 [0.198, 0.401, 0.401] 和 3.4 节手算结果完全一致。
step 0 的 loss 高达 41，远高于随机猜测的理论值 $\ln 13 \approx 2.56$——这是 Weight Tying 下随机初始化的 Embedding 同时当输出层，产生了极端 logits。30 步内就降到 2.56 以下，说明 AdamW + warmup 很快把它拉回正常区间。
最终 loss 降到 0.03 左右（PPL ≈ 1.03），模型基本“背”下了玩具语料，所以贪心生成能接出通顺的句子。

9.4 代码与前文章节的对应关系

代码片段	对应章节	关键点
`stoi` / `itos` 字符级分词	第二节	真实场景换成 BPE（如 `tiktoken`）
`nn.Embedding`	2.4 节	就是查表 $\mathbf{E}[id]$
`Q @ K.T / math.sqrt(2)`	3.3 节	Scaled Dot-Product Attention
`torch.triu(..., "-inf", diagonal=1)`	3.5 节	Causal mask，忘了它模型就作弊
`self.head.weight = self.tok_emb.weight`	4.5 节	Weight Tying
`F.cross_entropy(logits, y)`	第五节	内部已做 softmax + 负对数似然，数值稳定
`loss.backward()`	第六节	自动完成整条链式法则
`clip_grad_norm_(..., 1.0)`	6.5 节	梯度裁剪防 NaN
`torch.optim.AdamW`	7.2、7.3 节	$\beta_1=0.9, \beta_2=0.999$ 是默认值
`LambdaLR` + `lr_lambda`	7.5 节	warmup + cosine decay
`math.exp(loss.item())`	第十节第 5 条	PPL $= e^{\mathcal{L}}$

9.5 使用注意点 / 避坑

坑	现象	处理
忘记 `optimizer.zero_grad()`	梯度跨 step 累积，loss 曲线异常	每个 step 先清零梯度
训练/推理忘了切模式	dropout 在推理时还生效，结果不稳定	训练 `model.train()`，生成 `model.eval()`
`cross_entropy` 前手动 softmax	数值溢出、loss 变 NaN	直接传 logits，PyTorch 内部已做稳定化
标签没右移	模型在学“复制当前 token”，loss 极低但没学会预测	`y = x` 右移一位
mask 写成下三角 -inf	每个 token 只能看自己，模型学不到上下文	上三角才是屏蔽未来
玩具语料 loss 降不到 0 就慌	属正常，随机性 + 容量限制	先固定种子，确认能过拟合单 batch

9.6 动手练习建议

把 lr_max 从 3e-3 改成 3e-2，观察 loss 是否 NaN（体会 warmup 和梯度裁剪的作用）。
注释掉 causal mask，看 loss 是不是“假低”——训练 loss 很低，但生成崩了。
把 n_layer 从 2 加到 6，观察梯度范数变化和训练速度。
把玩具语料换成一段真实文本（如《论语》），词表改为字级，看 PPL 能降到多少。
用 torch.autograd.grad 手动验证 6.3 节手算的梯度 $\partial \mathcal{L} / \partial w = -1.0$。

十、通用训练避坑指南

下面这 12 条适用于 LLM 全阶段：

数据质量 > 数据数量：脏数据会让模型学会错误模式，先清洗再训练。
固定随机种子：方便复现和对比实验。
从小规模开始验证：先用 1B 参数或少量数据跑通 pipeline。
监控 loss 曲线：训练 loss、验证 loss、perplexity 一起画。
perplexity 是核心指标：

$$ \text{PPL} = e^{\mathcal{L}} $$

PPL 越低越好，一般预训练 PPL 在 2-10 之间。

检查梯度范数：突然变大说明要梯度裁剪。
学习率是最重要的超参数：先按论文默认值，再按 10 倍上下调。
Batch size 影响稳定性：大 batch 需要更大学习率，小 batch 噪声大但泛化好。
不要用测试集调参：会过拟合测试集。
注意数据泄漏：训练集和测试集要去重。
混合比例要平衡：代码、中文、英文、数学数据比例影响模型能力。
保存多个 checkpoint：不要只存最后一个，中间可能有更好的模型。

十一、异常场景与业务异常处理

11.1 训练阶段异常

异常	可能原因	处理
Loss = NaN / Inf	学习率过大、梯度爆炸、log(0)	降学习率、梯度裁剪、检查 softmax 实现
Loss 完全不降	学习率太小、数据损坏、标签错误	调大 lr、抽查数据、检查 mask
训练 loss 降，验证 loss 升	过拟合	早停、加 dropout、增数据、加正则
训练/验证 loss 都高	欠拟合	加模型容量、训练更久、减正则
显存 OOM	batch 太大、序列太长、模型太大	降 batch、用 gradient accumulation、激活检查点
分布式训练卡住	通信问题、某些 GPU 慢	检查 NCCL、负载均衡、all-reduce 同步
某些 token 生成重复	训练数据偏差或解码参数问题	调 temperature、top-p、加重复惩罚

11.2 部署/业务阶段异常

业务异常	表现	处理
概念漂移	线上数据分布变了，效果下降	监控输入分布、定期重训、在线学习
输入越界	用户输入超长、乱码、恶意 prompt	长度截断、输入校验、内容安全过滤
模型幻觉	生成看似合理但错误的内容	RAG 检索增强、增加事实性数据、后验校验
输出有害内容	生成歧视、违法、不当内容	安全对齐、输出拦截、人工审核
推理成本过高	模型太大，延迟/费用超标	量化、蒸馏、剪枝、换小模型
长尾问题答不好	冷门领域准确率低	领域 SFT、RAG、专家模型路由

11.3 一个实用的排查 checklist

□ 输入 token 范围对吗？（padding 是否被 mask？）
□ 标签 mask 对吗？（SFT 是否只算 answer loss？）
□ 损失函数和输出层匹配吗？（CE for classification）
□ 学习率调度正常吗？（warmup + decay）
□ 权重还有在更新吗？（打印梯度范数）
□ 单条数据能过拟合吗？（Sanity Check）
□ 分布式通信正常吗？（loss 同步一致）
□ 显存占用符合预期吗？（避免 OOM）

十二、总结

环节	核心作用	一句话口诀
Tokenization	文本 → 数字	高频子词合并，查表得向量
Embedding	ID → 向量	每个 token 对应一行稠密向量
Transformer	提取上下文关系	QK 点积算 attention，再乘 V
输出层 + Softmax	生成概率分布	猜下一个词是哪个
Cross Entropy	衡量预测好坏	真实词概率越大，loss 越小
反向传播	计算每个权重梯度	链式法则从后往前传
AdamW	更新权重	动量 + 二阶矩 + 真正 weight decay
LR 调度	控制学习节奏	先 warmup，再 cosine 下降
SFT / RLHF	对齐人类偏好	先模仿人类回答，再优化偏好

如果你是第一次接触 LLM 训练，建议按这个顺序动手：

先用一个小型 Transformer（如 nanoGPT）跑通“下一个 token 预测”。
改改学习率、batch size、warmup，观察 loss 曲线变化。
打印 attention 权重，看看模型在关注哪些 token。
用少量 SFT 数据微调，体会 mask answer 的重要性。
最后尝试 DPO，理解偏好对齐的数学本质。

本文档持续维护中。如果有哪一步的公式或例子让你卡住，欢迎在评论区指出，我会继续用更直观的方式补充图解和代码。

生成式AI原理与实战（Part 1）学习笔记：给初级开发者的 LLM 入门图解

Fri, 07 Nov 2025 15:18:31 +0800

生成式AI原理与实战（Part 1）学习笔记：给初级开发者的 LLM 入门图解

读完《生成式AI原理与实战 —— Part 1》后，我把 58 个问题整理成这篇文章。目标读者是刚接触 AI 的初中级开发者：你不用会推反向传播，但读完后应该能清楚地说出大模型是怎么“看”文本、怎么生成文本、以及怎么在实际任务里用它。

写在前面：为什么开发者要懂这些？

如果你只是调用 API，可能会觉得大模型就像一个“黑盒 HTTP 服务”。但真到做项目时，很多问题都和底层机制有关：

为什么同样的中文输入，不同模型算出来的 Token 数差很多？
为什么上下文不能无限长？
为什么模型做数学题会错？
RAG、Agent、微调这些词到底在解决什么问题？

这篇文章会用“概念 + 图 + 生活化类比”来回答。每张图都是帮助你建立直觉，而不是背公式。

一、大模型不是单一结构：三种 Transformer 架构

大模型基本都基于 Transformer。Transformer 最初有编码器 + 解码器，但后来发展出三种形态。

graph LR
    subgraph 仅编码器模型
        A1[输入文本] --> E1[Encoder<br/>双向 Self-Attention]
        E1 --> O1[理解结果/分类]
    end

    subgraph 仅解码器模型
        A2[前缀文本] --> D2[Decoder<br/>Masked Self-Attention]
        D2 --> O2[逐字生成<br/>自回归]
    end

    subgraph 编码器-解码器模型
        A3[输入文本] --> E3[Encoder]
        E3 --> D3[Decoder<br/>Cross-Attention]
        D3 --> O3[翻译/摘要]
    end

类型	代表	看上下文的方式	典型用途
仅编码器	BERT、RoBERTa	双向（整句一起看）	分类、检索、文本匹配
仅解码器	GPT、LLaMA、Mistral	单向（只能看左边）	续写、对话、代码生成
编码器-解码器	T5、BART	编码器双向 + 解码器单向	翻译、摘要、复杂生成

GPT 和原始 Transformer 的最大区别：GPT 把解码器单独拿出来，训练目标是“给定前文，预测下一个 token”，也就是自回归语言建模。这让 GPT 系列天然适合生成任务。

1.1 为什么 Transformer 比 RNN+Attention 强？

早期 LSTM/GRU 需要一步一步处理序列，计算是串行的。Transformer 的自注意力可以一次性看到整句话，所有位置并行计算。

并行：训练速度大幅提升。
长距离依赖：RNN 对很远距离的信息容易“遗忘”，自注意力让任意两个 token 直接建立联系。
结构统一：没有复杂的循环状态，更容易扩展成超大模型。

代价是计算复杂度为 O(n²)，n 是序列长度。这也是上下文窗口不能无限长的根本原因。

二、从文本到向量：Token 与 Embedding

大模型看不懂“字”，它只能处理数字。所以第一步是分词（Tokenization）。

flowchart LR
    T[原始文本] --> Token[Tokenizer 切分]
    Token --> ID[Token ID]
    ID --> Emb[Embedding 向量]
    Emb --> PE[加位置编码]
    PE --> In[输入 Transformer]

2.1 大模型分词器 vs 传统中文分词

对比	大模型 Tokenizer	传统中文分词
目标	给神经网络高效编码	切出符合语言学的“词”
粒度	子词、字符、字节，视词表而定	一般是词
OOV 处理	拆成子词/字节，几乎不会失败	拆成单字或按规则处理
例子	“hello” → [“hell”, “o”]	“人工智能” → [“人工”, “智能”]

给定一个词表，分词结果通常是唯一的。因为现代 Tokenizer 大多采用贪心最长匹配（BPE、WordPiece、Unigram 等），优先匹配最长的子词。

2.2 字节级 BPE 为什么更通用？

GPT-4、Llama 等模型使用 byte-level BPE：先把文本转成 UTF-8 字节序列，再在字节上做 BPE。

好处：

任何语言、Emoji、乱码、代码都能被编码，没有 OOV。
不需要为每种语言设计特殊预处理。
不同平台对 UTF-8 字节表示一致，迁移更稳定。

2.3 大模型怎么区分“用户说的”和“AI 说的”？

靠特殊 Token 和固定格式。训练时，对话会被包装成类似下面的结构：

<|user|> 今天天气怎么样？ <|assistant|> 今天天气很好，晴朗温暖。 <|end|>

模型在训练过程中学会了：看到 <|assistant|> 就知道要切换成回答模式。实际调用 ChatGPT、Claude 的 API 时，role: user/assistant/system 也是同样的道理。

2.4 工具调用时，输出怎么和文本回复区分？

模型通过输出格式约定区分：

普通回复：生成自然语言文本。
工具调用：生成结构化的 JSON / Function Call Schema。

服务端拿到输出后，检查结构：如果是 JSON，就执行工具；如果是文本，就直接返回给用户。训练阶段会通过 RLHF 告诉模型“该调用工具时不要废话，直接输出 JSON”。

三、静态 vs 上下文相关 Embedding

3.1 word2vec 的负例有什么用？

word2vec 有两种训练方式：CBOW 和 Skip-gram。Skip-gram + Negative Sampling 中，负例让训练从“对整个词表做 softmax”变成“对少量正例 + 负例做二分类”。

作用：

减少计算量：每次只更新少量向量。
学到区分性表示：正确搭配拉近，错误搭配推远。

3.2 静态 Embedding 和上下文相关 Embedding

特性	静态词嵌入（word2vec/GloVe）	上下文相关嵌入（BERT/GPT）
向量	每个词一个固定向量	每个词每次出现都不同
例子	“bank” 永远是一个向量	在 “river bank” 和 “investment bank” 中向量不同
结构	浅层神经网络	深层 Transformer
能力	捕捉共现关系	理解语义、消歧、语法

静态 Embedding 仍然有价值：轻量、快速、可解释、适合小数据和边缘设备。很多推荐系统、搜索召回场景仍然用 Embedding 模型。

flowchart LR
    subgraph 静态词嵌入
        W1[bank] --> V1[固定向量]
    end
    subgraph 上下文相关嵌入
        S1["river bank"] --> C1[向量A]
        S2["investment bank"] --> C2[向量B]
    end

四、LLM 的内部机制

4.1 模型怎么知道该停下来了？

训练数据每段文本末尾都有一个特殊 token，通常叫 <eos>（End of Sequence）。模型的训练目标是预测下一个 token，所以它会自然学会：当回答完整时，输出 <eos>。

推理时还有辅助规则：

达到最大生成长度。
输出 <eos> 立即停止。
检测到重复循环时停止。

4.2 训练时怎么防止偷看未来？

用 Causal Mask（因果掩码）。它是一个上三角矩阵，遮住当前位置右边的 token，让模型只能看到“过去”的信息。

graph TD
    subgraph 序列
        T1[token1]
        T2[token2]
        T3[token3]
        T4[token4]
    end
    T1 --> T1
    T2 --> T1
    T2 --> T2
    T3 --> T1
    T3 --> T2
    T3 --> T3
    T4 --> T1
    T4 --> T2
    T4 --> T3
    T4 --> T4

箭头表示“能看到”。token3 看不到 token4，这就是自回归的核心。

4.3 Self-Attention 到底在算什么？

每个 token 都有三个向量：

Q（Query）：我想找什么信息？
K（Key）：我是什么信息？
V（Value）：我的实际内容是什么？

计算步骤：

Q 和 K 做点积，得到注意力分数。
除以 √d_k，防止数值过大导致 softmax 太尖锐。
softmax 得到权重。
用权重对 V 做加权求和。

flowchart LR
    X[输入 X] --> Q[Query]
    X --> K[Key]
    X --> V[Value]
    Q --> DOT[Q × K^T]
    K --> DOT
    DOT --> SCALE[÷ √d]
    SCALE --> SOFT[softmax]
    SOFT --> MUL[× V]
    V --> MUL
    MUL --> OUT[输出]

为什么要除以 √d_k？ 因为维度越高，点积值越容易变大，softmax 会趋向“只有一个位置是 1，其他都是 0”的极端分布，梯度变小，训练不稳定。

4.4 为什么需要多头注意力？

多个头相当于多个“观察角度”：

有的头关注语法结构。
有的头关注相邻词。
有的头关注长距离依赖。

如果只用一个头，模型只能学一种注意模式，表达能力受限。

4.5 KV Cache：让生成变快的关键

生成文本时，模型是逐 token 生成的。如果没有 KV Cache，每生成一个新 token，都要重新计算前面所有 token 的 Attention，复杂度是 O(L²)。

有了 KV Cache：

已经生成过的 token 的 K 和 V 被缓存下来。
每次只需要计算新 token 的 Q，再和缓存中的 K、V 做 Attention。
复杂度变成 O(L)。

flowchart TB
    subgraph 无 KV Cache
        A1[生成 token1] --> A2[生成 token2<br/>重算 token1]
        A2 --> A3[生成 token3<br/>重算 token1, token2]
    end

    subgraph 有 KV Cache
        B1[生成 token1<br/>缓存 K1,V1] --> B2[生成 token2<br/>只算 Q2 + 读取 K1,V1]
        B2 --> B3[生成 token3<br/>只算 Q3 + 读取 K1~V2]
    end

为什么只缓存 K 和 V，不缓存 Q？ 因为 K、V 来自“已经生成的历史”，是固定的；Q 来自“当前要生成的这个新 token”，每次都要重新算。

4.6 残差连接、LayerNorm、FFN 各有什么用？

残差连接（Residual Connection）：把子层输入直接加回输出，缓解深层网络梯度消失，让训练更稳定。
LayerNorm：对每个样本内部做归一化，不依赖 batch 大小，适合 NLP。
RMSNorm：Llama-3 使用，去掉减均值步骤，计算更快更稳定。
FFN（前馈神经网络）：Attention 负责“看哪里”，FFN 负责“怎么理解”。两者缺一不可。

4.7 为什么大模型做数学题经常不准？

大模型本质是概率模式匹配器，不是计算器：

优化目标是“下一个 token 看起来合理”，不是“答案精确”。
训练数据里的数学推导质量参差不齐。
多步推理会累积误差。
没有内建算术引擎。

改善方法：提示工程、CoT（Chain-of-Thought）链式推理、调用外部计算器工具。但无法根治。

4.8 扩展上下文长度会带来的问题

把 8K 模型扩展到 32K，KV Cache 大小会变成 4 倍。同时 Attention 计算量和内存带宽需求也同步增加。

常用做法：

位置编码外推：RoPE 可以通过插值扩展范围。
继续训练：在长文本上继续训练一段时间，让模型适应新的长度分布。
打包训练 + Attention Mask：把多个短样本拼成一条长序列，用块对角掩码阻止它们互相看到。

4.9 Flash Attention 为什么能加速？

Flash Attention 没有减少总计算量，但大幅减少了对 HBM（GPU 显存）的访问。

把 Attention 拆成小块，在片上 SRAM 完成计算。
融合多个 kernel，减少数据搬运。
用 online softmax 增量维护最大值和归一化因子。

4.10 RoPE 比绝对位置编码强在哪？

原始 Transformer 把位置编码加到 Embedding 上，是加法的。RoPE（旋转位置编码）通过旋转 Q、K 向量把位置信息乘进去。

优势：

天然编码相对位置信息。
具备一定的长度外推能力。

挑战：超长上下文下，旋转角度增长过快，可能出现周期折叠和数值精度问题。

4.11 推测解码：用小模型加速大模型

思路：让小模型快速猜一串 token，大模型一次性批量验证。如果猜对了，直接接受；如果错了，从错的地方用大模型重新生成。

sequenceDiagram
    participant User
    participant Small as 小模型
    participant Large as 大模型

    User->>Small: 请生成候选 token
    Small->>Large: 提交候选序列
    Large->>Large: 一次性验证多个 token
    alt 全部正确
        Large-->>User: 直接返回候选结果
    else 第 k 个错误
        Large-->>User: 前 k-1 个接受，从 k 开始重新生成
    end

推测解码没有减少总计算量，但减少了“慢的大模型”的运行次数，从而降低延迟。

五、预训练 + 微调：两步范式

大模型不是一开始就会聊天、会做题的。它通常经历两个阶段：

flowchart LR
    PT[预训练<br/>海量无标注文本] -->|获得通用能力| FT[微调<br/>指令/人类偏好数据]
    FT -->|对齐人类价值观| Model[可用模型]

5.1 预训练让模型获得什么？

语言理解与生成能力。
世界知识和常识。
基本的推理和归纳能力。
跨任务泛化能力。

5.2 微调做什么？

指令遵循：学会按照用户要求组织答案。
问答能力：更准确、简洁、相关地回答问题。
对齐人类价值观：减少有害、偏见、违法内容。

这也是 Llama-3 8B 能比 Llama-1 70B 更强的关键原因之一：更好的数据、更优的训练方法、更系统的微调和对齐。

六、文本分类：Embedding 还是生成？

6.1 Embedding + 分类头

流程：

flowchart LR
    T[文本] --> M[Embedding 模型]
    M --> V[向量]
    V --> C[分类头<br/>Linear/MLP]
    C --> L[标签]

优点：推理快、成本低、类别可以很多、精度通常稳定。

6.2 生成模型直接分类

把分类任务写成 prompt，让模型直接输出类别文本。例如：

你是情感分析专家。请判断下面电影评论是 positive 还是 negative，只返回标签：
评论：这部电影太精彩了！

优点：零样本、少样本能力强，加新类别不用重新训练。缺点：推理慢、对 prompt 敏感、类别多时容易出错。

6.3 没有标注数据怎么办？

可以把分类变成文本相似度检索：

给每个类别写一段自然语言描述。
用 Embedding 模型把描述和待分类文本都变成向量。
计算余弦相似度，选最相似的类别。

标签描述的技巧：

用具体场景描述，而不是抽象词。
写成完整短句。
包含领域关键词。
长度适中（10-20 字左右）。
类别之间要有区分度。

6.4 Transformer 为什么比朴素贝叶斯强？

朴素贝叶斯假设：给定类别后，每个词都是条件独立的。这忽略了：

词语之间的相关性（如“银行”和“贷款”）。
语序信息（“这部电影不好看” vs “这部电影好看”）。
否定词、修饰语的语义反转。

Transformer 通过自注意力建模上下文关系，没有强独立性假设，因此表现更好。

七、文本聚类与主题建模

7.1 为什么有了生成式大模型，还需要 Embedding 模型？

生成模型擅长理解和生成，但不擅长：

对海量候选做快速相似度检索。
低延迟推荐。
大规模向量化索引。

推荐系统就是典型例子：先把商品/用户变成向量，再用向量数据库做近邻搜索，效率高、成本低。

7.2 从文档到主题的流程

flowchart LR
    Docs[大量文档] --> Prep[预处理]
    Prep --> Vec[向量化<br/>TF-IDF 或 Embedding]
    Vec --> Cluster[聚类<br/>KMeans / HDBSCAN]
    Cluster --> Topic[主题提取<br/>TF-IDF / c-TF-IDF / LLM]
    Topic --> Label[人工命名/标签]

7.3 词袋法 vs 文档嵌入

特性	词袋法 / TF-IDF	文档嵌入（BERT/SBERT）
表示	稀疏向量	稠密向量
上下文	不考虑	考虑
一词多义	不能处理	能处理
资源	快速轻量	需要模型和算力
可解释性	强	弱

词袋法在很多简单任务上仍是有效的基线，别急着上深度学习。

7.4 c-TF-IDF 改进在哪？

BERTopic 里的 c-TF-IDF 把统计单位从“文档”改成“主题（簇）”。

TF：某个词在主题内所有文档合并后的频率。
IDF：log(K / df)，K 是主题总数，df 是包含该词的主题数。

这样提取出来的关键词更能代表整个主题的共性，而不是单篇文档的特例。

7.5 聚类算法怎么选？

算法	优点	缺点	适合
K-Means	快、可扩展	需指定 K、对噪声敏感、只能找球形簇	大规模、簇形状规则
DBSCAN/HDBSCAN	自动识别噪声、任意形状	高维稀疏空间效果差、HDBSCAN 较慢	中小规模、噪声多

7.6 为什么把聚类和主题表示分开更好？

灵活性：聚类方法可以换，主题提取方法也可以换。
解释性：先聚类再从每簇提关键词，比联合模型更直观。
降噪：聚类只关心语义相似度，主题提取专注于代表性关键词。

7.7 主题关键词重叠怎么办？

可以尝试：

用 c-TF-IDF 提升每个主题的代表词独特性。
去掉停用词和高频无意义词。
合并过细的小簇后重新提取关键词。
用 MMR（Maximal Marginal Relevance）兼顾相关性和多样性。
换更好的语义嵌入模型。

7.8 BERTopic 离群点太多怎么办？

可能原因：

嵌入模型和领域不匹配。
文本太短，语义信息不足。
min_cluster_size 设置过大。
语料本身主题分散。

调整方法：减小 min_cluster_size、换 cluster_selection_method='leaf'、使用更适合短文本的嵌入模型（如 SimCSE、MiniLM）。

7.9 检测新兴主题

滑动窗口 + 动态聚类：按时间切分数据，追踪主题演化。
频率突变监测：统计词频增长率，发现突然火起来的词。
Embedding 演化分析：新聚类中心远离旧中心，说明出现新主题。

7.10 推荐系统冷启动怎么做？

阶段	推荐方式	方法
冷启动	内容理解	TF-IDF + KMeans / BERTopic
初始推荐	主题/相似内容	用户兴趣引导 + 主题中心匹配
有行为数据	协同过滤 + 内容	ItemCF / UserCF + 向量相似度
数据丰富	CTR 预估	FM / DNN / DSSM

八、写在最后

这篇笔记覆盖了《生成式AI原理与实战 —— Part 1》的 5 个章节。对初级开发者来说，最重要的不是记住每个公式，而是建立下面几个直觉：

大模型 = 分词 + 向量 + Transformer + 生成概率。
Transformer 的核心是 Attention：看哪里（QK）和拿什么信息（V）。
生成模型靠自回归逐 token 预测，每次只能看过去，靠 KV Cache 加速。
预训练给通识，微调给方向，对齐给安全。
Embedding 模型在检索、推荐、聚类场景仍然不可替代。

如果你能把这些讲给一位没做过 AI 的后端同事听明白，说明这篇文章的目的就达到了。

参考资料：《生成式AI原理与实战 —— Part 1》

Transformer 不完全图解：一个 AI 工程师需要理解到多深？

Thu, 06 Nov 2025 21:00:00 +0800

Transformer 不完全图解：一个 AI 工程师需要理解到多深？

做 AI 应用开发，不一定要会手推反向传播，但理解 Transformer 的基本工作原理非常有价值。这篇文章结合经典文章《The Illustrated Transformer》与《LLM 安全 | 大语言模型应用安全入门》中的图解，从零梳理我最常被人问到的几个核心问题。

一、为什么 AI 工程师需要懂 Transformer？

我自己是从 Java 后端转型到 AI 工程的，最初有个困惑：

「我只是调用 LLM API，为什么要懂 Transformer？」

后来在实际项目中发现，不懂底层会导致很多问题：

不知道 Token 是怎么切分的，导致成本估算偏差
不理解上下文窗口限制的本质，导致长文本处理方案选错
不明白 Attention 机制，做不好 RAG 和 Prompt 设计
不清楚自回归生成，理解不了为什么 LLM 会"胡编"

你不需要成为算法研究员，但需要知道模型在做什么、能力边界在哪里。

二、一句话理解 LLM：词语接龙预测器

如果你之前对 LLM 略有耳闻，很可能听过这个说法：

LLM 本质上是一个 Next Token Predictor（下一个 Token 预测器），也就是"词语接龙"。

但大多数解释到此为止。真正的问题是：它怎么知道下一个词该接什么？

答案可以简化成三步：

把文字变成数字：用 Embedding 把每个 Token 表示成向量
层层加工语义：用 Transformer 不断提炼上下文信息
输出概率分布：预测词表里每个 Token 出现的可能性，选最可能的那个

flowchart LR
    A["输入文本"] --> B["变成向量"]
    B --> C["多层 Transformer 加工"]
    C --> D["输出概率分布"]
    D --> E["选出下一个 Token"]

    style E fill:#fff4e1

三、从单词到向量：Embedding 是什么？

人类用字母表示单词，比如 C-A-T 表示"猫"。但神经网络只认识数字，所以我们需要把单词映射成词向量（word vector）。

例如，“cat” 可能被表示成这样一个向量：

[0.0074, 0.0030, -0.0105, 0.0742, …, 0.0002]

这个向量的维度通常是 300、1000、1536，甚至像 GPT-3 那样达到 12,288 维。

3.1 词向量的神奇性质

在训练好的词向量空间里，含义相近的词会离得很近。比如 “cat” 附近会有 dog、kitten、pet。

更神奇的是，词向量还能做"语义计算"：

biggest - big + small ≈ smallest
Paris - France + Germany ≈ Berlin
Swiss - Switzerland + Cambodia ≈ Cambodian

这种能力让模型不仅能"认识"词，还能在一定程度上"理解"词之间的关系。

3.2 词向量是怎么得到的？

早期的 word2vec 通过分析大量文本，让模型预测"一个词旁边常出现哪些词"，从而把语义相近的词放到相近的位置。

现代 LLM 不再单独训练词向量，而是把 Embedding 层作为模型的一部分，端到端地训练。但核心思想没变：把离散的符号映射成连续的、有意义的向量。

四、Transformer 总览：数据是怎么流动的？

2017 年，Google 发表论文《Attention Is All You Need》，提出了 Transformer 架构。它彻底改变了 NLP，也是 GPT、Claude、DeepSeek 等模型的基础。

下面这张图是原始 Transformer 的完整结构（包含 Encoder 和 Decoder）：

图片来源：《LLM 安全 | 大语言模型应用安全入门》

4.1 图中这些英文标签是什么意思？

第一次看到这张图，很多人会被里面的英文缩写吓到。其实它们都是高中数学/线性代数里很基础的操作：

标签	全称/含义	简单解释
MatMul	Matrix Multiplication	矩阵乘法。把两个矩阵按规则相乘，是神经网络里最常用的计算。
Dot-Product	点积	两个向量对应位置相乘再相加，结果越大表示两个向量越"像"。Attention 里用 Q 和 K 的点积来衡量"相关性"。
Scale	缩放	把点积结果除以 `√d_k`，防止数值太大导致 Softmax 梯度消失。
Mask	掩码	在 Decoder 里把"未来的 Token"遮起来（变成 -∞），让模型不能偷看答案。Encoder 不需要，所以是 opt.（可选）。
Softmax	归一化指数函数	把任意一组分数变成"概率分布"：都是正数，且加起来等于 1。
Linear	线性层	简单的 `y = xW + b`，也就是对向量做一次线性变换。

对应的标准 Attention 公式也要贴出来：

Attention(Q, K, V) = softmax(QK^T / √d_k) × V

一句话串起来：

Q 和 K 做 MatMul（这一步本质上在计算 Dot-Product）→ Scale → Mask（可选）→ Softmax 得到权重 → 权重再和 V 做 MatMul → 最后过 Linear 层。

对 AI 应用开发者来说，不需要记住每一个方块，但要理解整体数据流：

flowchart TD
    A[输入文本] --> B[Tokenizer<br/>切分成 Token]
    B --> C[Embedding 层<br/>Token → 向量]
    C --> D[位置编码<br/>加入位置信息]
    D --> E[多层 Transformer Block]
    subgraph "一个 Transformer Block 重复 N 次"
        E --> F[Masked Self-Attention<br/>带因果掩码的自注意力]
        F --> G[Add & Norm<br/>残差连接 + 层归一化]
        G --> H[Feed Forward Network<br/>前馈神经网络]
        H --> I[Add & Norm<br/>残差连接 + 层归一化]
    end
    I --> J[线性层 + Softmax]
    J --> K[词表上的概率分布]
    K --> L[采样/取最大概率<br/>得到下一个 Token]
    L --> M[拼回已生成序列<br/>继续预测]
    M --> E

一句话总结：文本先变成向量，再经过多层"Attention + FFN"的处理，最后预测下一个 Token。

五、Transformer 的每一层在做什么？

想象你读一句话：“John wants his bank to cash the “。

第一层 Transformer 可能会发现：wants 和 cash 在这里是动词；第二层会进一步澄清：his 指的是 John，bank 指的是金融机构而不是河岸。

每一层都在前一个层的基础上，给词向量"写注释”，帮助模型理解上下文。

图片来源：《LLM 安全 | 大语言模型应用安全入门》

这些"注释"人类无法直接解读，但它们以数字的形式存储在词向量中，并随着层数增加逐渐丰富。最终，最后一层输出的向量包含了预测下一个 Token 所需的全部信息。

六、从 Token 到向量：输入表示

6.1 Token 与 Embedding

用户输入一句话，比如「你好世界」，模型并不会直接理解汉字。首先要经过 Tokenizer 切分成 Token：

"你好世界" → ["你", "好", "世", "界"]
或
"你好世界" → ["你好", "世界"]

不同模型的 Tokenizer 不同，这也是为什么同样的中文文本，在不同模型里 Token 数可能差很多。

每个 Token 会被映射成一个向量，叫做 Embedding：

"你" → x₁ (一个 d 维向量)
"好" → x₂
"世" → x₃
"界" → x₄

用流程图表示：

flowchart LR
    A["原始文本：<br/>你好世界"] --> B["Tokenizer<br/>分词器"]
    B --> C["Token 序列：<br/>['你', '好', '世', '界']"]
    C --> D["Embedding 层<br/>查表/投影"]
    D --> E["向量序列：<br/>x₁, x₂, x₃, x₄"]

    style A fill:#e1f5e1
    style E fill:#fff4e1

6.2 位置编码

Transformer 本身没有顺序概念（它一次看到所有 Token），所以需要加入位置信息。原始 Transformer 用正弦/余弦函数生成位置编码：

PE(pos, 2i)   = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

直观理解：位置编码向量的左半部分变化平缓（正弦），右半部分变化较快（余弦），中间会有明显的分隔。

最终输入向量是：

x_i = Embedding(token_i) + PE(pos_i)

flowchart LR
    A["Token Embedding<br/>你 → x₁"] --> C["相加"]
    B["位置编码<br/>pos=1 → PE₁"] --> C
    C --> D["最终输入向量<br/>x₁ + PE₁"]

    style D fill:#fff4e1

为什么需要位置编码？ 因为 Attention 机制本质上是对所有 Token 做"加权平均”，如果不告诉模型"谁在哪个位置"，“我爱你"和"你爱我"对它来说就完全没有区别。

七、Self-Attention：核心计算

7.1 Q、K、V 是怎么来的？

对于每个输入向量 x_i，分别乘以三个权重矩阵，得到：

q_i = x_i × W_q
k_i = x_i × W_k
v_i = x_i × W_v

Q（Query）：当前 Token 在问什么
K（Key）：每个 Token 能提供什么信息
V（Value）：每个 Token 的实际内容

W_q、W_k、W_v 是训练出来的，通过反向传播和梯度下降不断优化。

flowchart TD
    A["输入向量 x_i"] --> B["× W_q"]
    A --> C["× W_k"]
    A --> D["× W_v"]
    B --> E["q_i<br/>查询向量"]
    C --> F["k_i<br/>键向量"]
    D --> G["v_i<br/>值向量"]

    style E fill:#e1f5fe
    style F fill:#e1f5fe
    style G fill:#e1f5fe

7.2 Attention 分数计算：一步一步看

计算每个 Token 对其他 Token 的关注程度：

Attention(Q, K, V) = softmax(Q × K^T / √d_k) × V

以 “q₁”（对应 Token “你”）为例，整个过程可以拆成 4 步：

flowchart TD
    A["步骤 1：算相似度<br/>q₁ × k₁, q₁ × k₂,<br/>q₁ × k₃, q₁ × k₄"] --> B["步骤 2：缩放<br/>每个分数 ÷ √d_k"]
    B --> C["步骤 3：Softmax<br/>变成概率分布<br/>和为 1"]
    C --> D["步骤 4：加权求和<br/>概率 × [v₁, v₂, v₃, v₄]<br/>得到 z₁"]

    style D fill:#fff4e1

更具体地，对于序列中的每个位置：

flowchart LR
    Q1["q₁"] --> S["点积<br/>q₁·k₁, q₁·k₂, q₁·k₃, q₁·k₄"]
    K1["k₁, k₂, k₃, k₄"] --> S
    S --> D["÷ √d_k"]
    D --> SM["Softmax"]
    SM --> W["权重：<br/>0.5, 0.3, 0.1, 0.1"]
    V1["v₁, v₂, v₃, v₄"] --> SUM["加权求和"]
    W --> SUM
    SUM --> Z["z₁ = 0.5v₁ + 0.3v₂ + 0.1v₃ + 0.1v₄"]

    style Z fill:#fff4e1

z₁ 就是 “你” 这个 Token 经过 Self-Attention 后的新表示，它融合了整个句子的信息。

注意：上面的例子假设是双向 Self-Attention（Encoder 场景），所以位置 1 能看到所有位置。如果是 GPT 这类 Decoder-only 模型，由于有因果掩码，位置 1 只能看到自己，结果会变成 z₁ = 1.0 × v₁。只有最后一个位置（比如 z₄）才能看到所有 k₁, k₂, k₃, k₄。

7.3 多头 Attention

实际 Transformer 不会只算一组 Q/K/V，而是算多组（Multi-Head）。最后把多组结果拼接，再乘以 W_o：

Z = Concat(z_0, z_1, ..., z_h) × W_o

多头的好处是：不同头可以关注不同类型的信息，比如一个头关注语法，一个头关注语义。

flowchart TD
    A["输入 X"] --> B1["Head 1"]
    A --> B2["Head 2"]
    A --> B3["Head ..."]
    A --> B4["Head h"]

    B1 --> C1["z₁"]
    B2 --> C2["z₂"]
    B3 --> C3["..."]
    B4 --> C4["zₕ"]

    C1 --> D["Concat<br/>拼接"]
    C2 --> D
    C3 --> D
    C4 --> D

    D --> E["× W_o<br/>线性投影"]
    E --> F["最终输出 Z"]

    style F fill:#fff4e1

7.4 一个完整演算：输入 x₁, x₂，怎么预测 x₃？

前面讲了很多公式，现在用一个具体的 Decoder-only 例子把流程走一遍。

场景：用户已经输入了 x₁, x₂（比如「你」「好」），模型要预测下一个 Token x₃（比如「世」）。

第 1 步：生成 Q、K、V

每个输入向量各自乘以三个权重矩阵：

x₁ → q₁, k₁, v₁
x₂ → q₂, k₂, v₂

第 2 步：应用因果掩码

Decoder 不能偷看未来，所以 2×2 的掩码矩阵是：

[[0, -∞],
 [0,  0]]

含义：

位置 1 只能看到位置 1
位置 2 能看到位置 1 和位置 2

flowchart LR
    subgraph "位置 1"
        A1["只能看到 x₁"]
    end
    subgraph "位置 2"
        A2["可以看到 x₁, x₂"]
    end
    A1 --> A2

第 3 步：计算 z₁

位置 1 被掩码挡住了 x₂，所以：

分数 = [q₁·k₁/√d_k,  -∞]
       ↓ Softmax
权重 = [1.0,  0.0]

z₁ = 1.0 × v₁ + 0.0 × v₂ = v₁

flowchart LR
    Q1["q₁"] --> S["点积<br/>q₁·k₁, -∞"]
    K1["k₁, k₂"] --> S
    S --> D["÷ √d_k"]
    D --> SM["Softmax<br/>→ [1.0, 0.0]"]
    SM --> W["权重"]
    V1["v₁, v₂"] --> SUM["加权求和"]
    W --> SUM
    SUM --> Z["z₁ = v₁"]

    style Z fill:#fff4e1

第 4 步：计算 z₂

位置 2 可以看到 x₁ 和 x₂：

分数 = [q₂·k₁/√d_k,  q₂·k₂/√d_k]
       ↓ Softmax
权重 = [0.3,  0.7]   ← 假设的示例值

z₂ = 0.3 × v₁ + 0.7 × v₂

flowchart LR
    Q2["q₂"] --> S["点积<br/>q₂·k₁, q₂·k₂"]
    K2["k₁, k₂"] --> S
    S --> D["÷ √d_k"]
    D --> SM["Softmax<br/>→ [0.3, 0.7]"]
    SM --> W["权重"]
    V2["v₁, v₂"] --> SUM["加权求和"]
    W --> SUM
    SUM --> Z["z₂ = 0.3v₁ + 0.7v₂"]

    style Z fill:#fff4e1

第 5 步：用 z₂ 预测 x₃

只有最后一个位置 z₂ 才包含"已输入全部信息”，所以：

flowchart LR
    Z2["z₂"] --> L["Linear<br/>线性层"]
    L --> SM["Softmax"]
    SM --> P["词表概率分布"]
    P --> X3["选出概率最大的 Token<br/>即 x₃"]

    style X3 fill:#fff4e1

z₁ 有必要算吗？

这个问题要分"概念上"和"工程实现上"两层来理解。

概念上：如果你只想预测 x₃，那确实只需要 z₂。z₁ 对应的是预测 x₂，不是 x₃。

工程实现上：标准 Transformer 在前向传播时会一次性把 z₁, z₂ 都算出来（因为矩阵运算适合并行）。所以 z₁ 通常还是被算了，只是它的输出被丢弃，不参与生成 x₃。

那因果掩码还有必要吗？

有必要，原因有两个：

架构是统一的：Transformer 不知道你这次只想要 z₂，它仍然按同样的规则处理所有位置。既然要算 z₁，就必须对 z₁ 应用掩码，防止它偷看 x₂。
Prompt 阶段需要并行：实际推理时，对于用户输入的整段 Prompt（比如 [x₁, x₂]），模型通常是一次性并行算出所有位置的，而不是一个一个算。这时候如果不加掩码，z₁ 就会看到后面的 x₂，破坏因果性。

KV Cache 优化：在生成后续 Token 时（比如已经生成到 [x₁, x₂, x₃]，要预测 x₄），工程上会把之前算好的 K、V 缓存起来，只计算新位置。这时 z₁、z₂ 确实不会被重复计算，但因果掩码仍然保留在架构中。

八、看看真实模型长什么样：GPT-3 的维度

理论知识看多了，看看真实模型的尺寸会更有体感。下面是一张手绘风格的 GPT-3 结构图：

图片来源：《LLM 安全 | 大语言模型应用安全入门》

从这张图可以看到几个关键数字：

词向量维度：12,288 —— 每个 Token 用 12,288 个数字表示
上下文长度：2,048 —— GPT-3 一次能处理 2,048 个 Token
层数：96 层 —— 同样的 Transformer Block 重复 96 次
参数量：约 1,750 亿 —— 这些参数就是 W_q、W_k、W_v、W_o、W₁、W₂ 等矩阵

你可以把这些高维向量看作"草稿纸"，前面的层写下的注释可以被后面的层读取和修改，模型就这样逐层加深对上下文的理解。

这也解释了为什么**上下文窗口（context window）**不是无限的：每个 Token 都要和上下文里所有 Token 计算 Attention，长度越长，计算和显存开销越大。

九、Add & Norm 与 FFN

9.1 残差连接

Self-Attention 的输出会做一个残差连接：

Output = LayerNorm(Z + X)

也就是把 Attention 前的输入 X 和 Attention 后的输出 Z 相加，再 Layer Normalization。

残差连接的作用：

缓解梯度消失，帮助深层网络训练
保留原始输入信息，避免 Attention 过度改变表示

flowchart TD
    A["输入 X"] --> B["Self-Attention"]
    B --> C["Z"]
    A --> D["相加<br/>X + Z"]
    C --> D
    D --> E["LayerNorm"]
    E --> F["输出"]

    style F fill:#fff4e1

9.2 Feed Forward Network

每个位置独立经过两层全连接：

FFN(x) = max(0, x × W₁ + b₁) × W₂ + b₂

注意：

中间用 ReLU 激活
通常先升维（4 倍），再降维回原维度
每个位置独立计算，不跨位置交互

FFN 的作用是为模型引入非线性变换能力，增强表达能力。

flowchart LR
    A["输入 x"] --> B["线性层 1<br/>x × W₁ + b₁"]
    B --> C["ReLU 激活<br/>max(0, ...)"]
    C --> D["线性层 2<br/>× W₂ + b₂"]
    D --> E["输出"]

    style E fill:#fff4e1

9.3 一个完整的 Transformer Block

把上面的模块拼起来，就是一个标准的 Transformer Block：

flowchart TD
    A["输入 X"] --> B["Masked Self-Attention"]
    B --> C["X + Attention输出"]
    A --> C
    C --> D["LayerNorm"]
    D --> E["FFN"]
    E --> F["D + FFN输出"]
    D --> F
    F --> G["LayerNorm"]
    G --> H["输出"]

    style H fill:#fff4e1

这个 Block 会重复堆叠几十层（比如 GPT-3 有 96 层）。每一层都在前一层的基础上进一步提炼信息。

十、Decoder 与自回归生成

10.1 编码器 vs 解码器

原始 Transformer 有 Encoder 和 Decoder：

Encoder：读取整个输入序列，生成上下文表示
Decoder：根据已生成的 Token，逐个预测下一个 Token

但我们常用的 GPT、DeepSeek、Claude 等都是 Decoder-only 结构，只有解码器。

flowchart TD
    subgraph "原始 Transformer"
        A["输入序列"] --> B["Encoder"]
        B --> C["上下文表示"]
        C --> D["Decoder"]
        D --> E["输出序列"]
    end

    subgraph "GPT / Claude / DeepSeek<br/>Decoder-only"
        F["已生成 Token"] --> G["Decoder"]
        G --> H["预测下一个 Token"]
        H --> I["拼回输入"]
        I --> F
    end

10.2 因果掩码

Decoder 在训练和推理时都不能偷看未来的 Token，所以要用因果掩码（Causal Mask）。它用一个 4×4 的下三角矩阵表示：

[[0, -∞, -∞, -∞],
 [0,  0, -∞, -∞],
 [0,  0,  0, -∞],
 [0,  0,  0,  0]]

上三角为 -∞，经过 softmax 后变成 0，从而实现"不能看未来"的约束。

flowchart LR
    subgraph "位置 1"
        A1["只能看到自己<br/>你"]
    end
    subgraph "位置 2"
        A2["可以看到<br/>你、好"]
    end
    subgraph "位置 3"
        A3["可以看到<br/>你、好、世"]
    end
    subgraph "位置 4"
        A4["可以看到<br/>你、好、世、界"]
    end

    A1 --> A2 --> A3 --> A4

10.3 预测下一个 Token

Decoder 最后一个位置的隐藏状态 h_t，经过线性层和 softmax，得到词表上的概率分布：

logits = W_o × h_t + b_o
probabilities = softmax(logits)

词表通常有几万维，每一维代表一个 Token 的概率。选择概率最高的 Token 作为输出。

flowchart LR
    A["最后一个隐藏状态 h_t"] --> B["线性层<br/>W_o × h_t + b_o"]
    B --> C["Logits<br/>词表大小维度的分数"]
    C --> D["Softmax"]
    D --> E["概率分布"]
    E --> F["取 argmax<br/>或采样"]
    F --> G["下一个 Token"]

    style G fill:#fff4e1

10.4 为什么预测的是 t+1？

训练时，输入序列的每个位置 i 都对应一个标签：下一个位置 i+1 的 Token。

输入：[你， 好， 世， 界]
标签：[好， 世， 界， EOS]

所以位置 i 的隐状态 h_i 被训练来预测位置 i+1。

推理时，模型每次用已生成的所有 Token 预测下一个 Token，然后把它拼回输入，继续预测。

10.5 自回归生成流程

自回归的核心就是"一步一步来"：

flowchart LR
    A["输入：你"] --> B["预测：好"]
    B --> C["输入：你好"]
    C --> D["预测：世"]
    D --> E["输入：你好世"]
    E --> F["预测：界"]
    F --> G["输入：你好世界"]
    G --> H["预测：EOS"]
    H --> I["结束"]

    style I fill:#fff4e1

10.6 训练 vs 推理：有什么不一样？

flowchart TD
    subgraph 训练阶段
        A["输入：你好世界"] --> B["一次前向传播"]
        B --> C["同时计算所有位置"]
        C --> D["位置1 预测 好<br/>位置2 预测 世<br/>位置3 预测 界<br/>位置4 预测 EOS"]
    end

    subgraph 推理阶段
        E["输入：你"] --> F["预测 好"]
        F --> G["输入：你好"]
        G --> H["预测 世"]
        H --> I["..."]
    end

关键区别：训练时和推理时都会用因果掩码，区别在于——训练时可以一次性输入整句话，并行计算所有位置（同时得到所有位置的预测结果）；推理时只能一个一个地生成，每次把已生成的 Token 拼回去再预测下一个。

10.7 生成什么时候结束？

通常有两个停止条件：

生成了结束符 EOS（End of Sequence）
达到了预设的最大生成长度

实际工程中还会加上停止字符串等兜底策略。

flowchart TD
    A["模型预测下一个 Token"] --> B{"是 EOS 吗？"}
    B -->|是| C["结束生成"]
    B -->|否| D{"超过最大长度？"}
    D -->|是| C
    D -->|否| E["拼回输入<br/>继续预测"]
    E --> A

十一、模型是怎么训练出来的？

理解 Transformer 的结构后，再来看模型是怎么"学会"的。整个过程可以分成两个阶段：

预训练（Pre-training）：让模型学会语言的基本规律
微调（Fine-tuning）：让模型学会遵循指令、生成有用回答

图片来源：《LLM 安全 | 大语言模型应用安全入门》

11.1 预训练：词语接龙

预训练阶段，模型会阅读海量文本（网页、书籍、维基百科等），学习目标很简单：给定前 N 个 Token，预测第 N+1 个 Token。

例如：

今天是个好天气，我准备去____

模型会预测"公园"、“超市”、“图书馆"等词的概率。预测错了就调整参数，预测对了也微调，让概率分布更接近真实世界。

GPT-3 的预训练数据构成如下：

图片来源：《LLM 安全 | 大语言模型应用安全入门》

可以看到：

Common Crawl 占大头，但经过了过滤
WebText2 是高质量网页文本
Books1/Books2 是书籍数据
Wikipedia 虽然量少但质量高

Common Crawl 的数据来源非常广泛：

图片来源：《LLM 安全 | 大语言模型应用安全入门》

预训练完成后得到的是基座模型（Base Model）。它很擅长"续写”，但不一定擅长对话或遵循指令。比如你让它"写一首关于月亮的诗"，它可能只会开始写关于月亮的百科介绍。

11.2 微调：让模型变成"助手"

微调阶段，研究人员会准备大量高质量的"指令-回答"数据对，比如 Alpaca 数据集：

图片来源：《LLM 安全 | 大语言模型应用安全入门》

每一行包含：

Instruction：任务指令
Input：可选的输入上下文
Output：期望的回答
Text：拼接后的完整训练样本

通过在这些数据上继续训练，模型学会了理解指令、按格式输出、拒绝有害请求等能力，最终变成我们日常使用的助手模型（Assistant Model）。

11.3 RLHF：人类反馈强化学习

更进一步的训练还会用到 RLHF（Reinforcement Learning from Human Feedback）：

让模型对同一个问题生成多个回答
人类标注员比较哪个回答更好
用这些比较数据训练一个"奖励模型"
用奖励模型指导基座模型生成更人类喜欢的回答

图片来源：《LLM 安全 | 大语言模型应用安全入门》

为什么用"比较"而不是"写答案"？因为对人类来说，判断哪个回答更好往往比自己写回答容易得多。

十二、上下文窗口的限制

前文提到，Transformer 的上下文窗口不是无限的。GPT-3 只有 2,048 个 Token，GPT-4 后来扩展到 128K，但即便如此，长上下文下的信息检索也会下降。

下面这张图是著名的"大海捞针"测试（Needle In A Haystack）：把一条关键信息藏在长文档的不同位置，然后让模型回答相关问题。

图片来源：《LLM 安全 | 大语言模型应用安全入门》

绿色表示模型能准确找到信息，红色/黄色表示失败。可以看到：

当文档较短时，模型几乎全能找到
当文档很长、且关键信息位于中间位置时，准确率明显下降
这就是常说的 “Lost in the Middle” 问题

对 AI 工程师的启示：

不要把整本书直接塞进 Prompt
做 RAG 时，召回的 chunk 要尽量精准
关键信息尽量放在上下文的开头或结尾

十三、这些知识在工程中有什么用？

13.1 理解 Token 消耗

模型的输入和输出都按 Token 计费。理解 Tokenizer 后，你会知道：

为什么中文比英文更"贵"
为什么同样的 Prompt 在不同模型上价格不同
为什么长文本容易超出上下文窗口

13.2 设计更好的 RAG

Attention 机制让模型能关注输入中的相关信息。做 RAG 时：

召回的 chunk 要尽量相关
上下文不能太长，否则注意力会稀释
关键信息要放在 Prompt 的重要位置

13.3 理解 LLM 的局限性

LLM 是自回归生成，每次只预测下一个 Token，所以会出现"说胡话"
没有真正的推理，只是概率模式匹配
上下文窗口有限，不能无限记忆

这些认知会直接影响你的产品设计方案。

十四、延伸：DeepSeek 的 MLA

传统 Transformer 的 Attention 需要保存每个 Token 的 K 和 V，显存开销大。

DeepSeek 的 MLA（Multi-head Latent Attention） 做了压缩：不再直接存储完整的 K/V，而是存储一个低维的潜在向量，推理时动态解压。

这样显著降低了显存占用，让长上下文推理更便宜。

对于应用开发者来说，这意味着：

长上下文能力的成本在下降
未来可以设计更复杂的 Agent 工作流
但仍要关注 Token 成本

flowchart LR
    subgraph "传统 Attention"
        A1["每个 Token 存储完整 K, V"] --> B1["显存占用大"]
    end

    subgraph "MLA"
        A2["每个 Token 存储低维潜在向量"] --> B2["推理时动态解压为 K, V"]
        B2 --> C2["显存占用小"]
    end

十五、总结

Transformer 不需要你推导每个公式，但核心机制要知道：

输入：Token → Embedding + 位置编码
Attention：Q/K/V 计算，softmax 得到关注权重
残差与 FFN：帮助深层网络训练和非线性表达
Decoder：因果掩码 + 自回归生成
输出：线性层 + softmax 预测下一个 Token
训练：预训练学语言规律，微调学指令遵循

作为 AI 工程师，理解这些不是为了造模型，而是为了更好地使用模型、设计产品、控制成本。

flowchart TD
    A["输入文本"] --> B["Token + Embedding"]
    B --> C["位置编码"]
    C --> D["Multi-Head Self-Attention"]
    D --> E["Add & Norm"]
    E --> F["FFN"]
    F --> G["Add & Norm"]
    G --> H["重复 N 层"]
    H --> I["Linear + Softmax"]
    I --> J["预测下一个 Token"]

    style J fill:#fff4e1

你对 Transformer 的哪个部分最困惑？欢迎在评论区讨论。

参考文章：