第一章 Transformer基础与变体

"Attention is All You Need." —— Vaswani et al., NeurIPS 2017

1.1 引言：从序列到序列的革命

在深度学习的历史长河中，少数几篇论文真正改变了领域的发展方向。Vaswani等人于2017年发表的《Attention Is All You Need》无疑是其中之一。这篇论文提出的Transformer架构，不仅彻底改变了自然语言处理（NLP）的研究范式，更成为后续大语言模型（LLM）爆发的技术基石。从BERT到GPT系列，从T5到LLaMA，几乎所有现代大模型都可以追溯到这一统一架构。

1.1.1 序列建模的历史演进

在Transformer出现之前，序列建模领域主要被两类架构主导：

循环神经网络（Recurrent Neural Networks, RNN） 及其变体LSTM和GRU，通过隐状态传递信息，天然适合处理序列数据。然而，RNN的串行计算特性导致其无法充分利用现代硬件的并行计算能力，且长距离依赖信息的传递需要经过 $O(n)$ 个时间步，极易出现梯度消失问题。

卷积神经网络（Convolutional Neural Networks, CNN） 也被用于序列建模，通过堆叠卷积层扩大感受野。空洞卷积（Dilated Convolution）可以将依赖路径长度缩短至 $O(\log n)$，但终究无法实现任意两个位置之间的直接交互。

Transformer通过自注意力机制（Self-Attention） 实现了任意两个位置之间的直接交互，将依赖路径长度缩短至 $O(1)$，同时保持了完全并行化的计算能力。这一设计使得Transformer在理论上可以高效地建模任意长度的依赖关系。

1.1.2 Transformer的核心设计哲学

Transformer的设计蕴含了若干深刻的设计哲学：

1. 完全依赖注意力机制：不再使用任何循环或卷积结构，仅用注意力机制和前馈网络就构建了整个模型。这一极简主义设计证明了注意力机制的充分表达能力。

2. 残差连接与层归一化：通过残差连接（Residual Connection）解决深层网络的梯度消失问题，通过层归一化（Layer Normalization）稳定训练过程，使得模型可以堆叠到数十甚至上百层。

3. 编码器-解码器分离：编码器负责将输入序列映射为连续的上下文表示，解码器负责自回归地生成输出序列。这种分离使得架构具有极大的灵活性——后续的BERT仅使用编码器，GPT仅使用解码器，T5保留完整的编码器-解码器结构。

1.1.3 从大模型视角重新审视Transformer

本章将从大模型研究和工程实践的角度，深入剖析Transformer的每一个细节。我们不仅关注"是什么"和"怎么做"，更关注"为什么"——每个设计决策背后的数学原理、物理直觉和工程权衡。掌握这些原理，是理解后续章节（预训练、对齐、推理优化）的必要基础。

本章的组织如下：第1.2节详细剖析自注意力机制的数学原理；第1.3节讨论位置编码的设计与演进；第1.4节呈现完整的Transformer架构；第1.5节分析BERT、GPT、T5三大关键变体；第1.6节探讨高效Transformer变体；第1.7节提供图解说明；第1.8节总结本章要点。

1.2 自注意力机制：核心创新

自注意力机制（Self-Attention Mechanism），又称内部注意力（Intra-Attention），是Transformer架构最核心的创新。它使得序列中的每个位置都可以直接"关注"所有其他位置，从而实现了全局依赖的高效建模。

1.2.1 缩放点积注意力的数学原理

核心问题设定

给定输入序列的表示矩阵 $X \in \mathbb{R}^{n \times d_{model}}$，其中 $n$ 为序列长度，$d_{model}$ 为模型维度。自注意力机制通过三个可学习的线性投影，将 $X$ 映射为Query、Key和Value三个矩阵：

$$Q = XW^Q, \quad K = XW^K, \quad V = XW^V$$

其中 $W^Q, W^K \in \mathbb{R}^{d_{model} \times d_k}$，$W^V \in \mathbb{R}^{d_{model} \times d_v}$ 为可学习的投影矩阵。在原始Transformer中，通常设置 $d_k = d_v = d_{model} / h$，其中 $h$ 为注意力头的数量。

缩放点积注意力的完整定义

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

逐元素展开形式：对于第 $i$ 个位置的输出：

$$\text{Attention}(Q, K, V)i = \sum{j=1}^{n} \underbrace{\frac{\exp\left(\frac{q_i \cdot k_j}{\sqrt{d_k}}\right)}{\sum_{l=1}^{n}\exp\left(\frac{q_i \cdot k_l}{\sqrt{d_k}}\right)}}{\alpha{ij}} v_j$$

其中 $\alpha_{ij}$ 是第 $i$ 个token对第 $j$ 个token的注意力权重，满足 $\sum_{j=1}^{n} \alpha_{ij} = 1$。

维度分析：

• $Q \in \mathbb{R}^{n \times d_k}$，$K^T \in \mathbb{R}^{d_k \times n}$
• $QK^T \in \mathbb{R}^{n \times n}$（注意力分数矩阵，每行是一个query对所有key的分数）
• 除以 $\sqrt{d_k}$ 进行缩放
• 经过softmax后得到注意力权重矩阵 $A \in \mathbb{R}^{n \times n}$
• $V \in \mathbb{R}^{n \times d_v}$
• 最终输出：$AV \in \mathbb{R}^{n \times d_v}$

为什么要除以 $\sqrt{d_k}$？

这是缩放点积注意力中最关键的设计决策之一。假设 $q_i$ 和 $k_j$ 的每个分量是独立随机变量，均值为0，方差为1。则它们的点积：

$$q_i \cdot k_j = \sum_{m=1}^{d_k} q_{i,m} \cdot k_{j,m}$$

由中心极限定理：
- $\mathbb{E}[q_i \cdot k_j] = 0$
- $\text{Var}(q_i \cdot k_j) = d_k$

因此，当 $d_k$ 较大时（如64、128），点积的绝对值会变得很大（标准差为 $\sqrt{d_k}$），导致两个严重问题：

1. Softmax饱和：输入到softmax的值很大时，输出趋近于one-hot分布，即注意力全部集中在一个位置
2. 梯度消失：softmax在极端值附近的梯度几乎为0，阻碍梯度传播

缩放后的效果：

$$\text{Var}\left(\frac{q_i \cdot k_j}{\sqrt{d_k}}\right) = \frac{d_k}{d_k} = 1$$

缩放后点积的方差恒为1，与维度无关，保证了softmax输入的数值稳定性。值得注意的是，这里的 $\frac{1}{\sqrt{d_k}}$ 也可以从温度缩放（Temperature Scaling）的角度理解——它相当于一个温度参数 $T = \sqrt{d_k}$，控制了注意力分布的尖锐程度。

与传统注意力的本质区别

传统注意力机制（如Bahdanau注意力）中，Query来自解码器的隐状态，Key和Value来自编码器的隐状态，用于建立源序列和目标序列之间的对齐关系。而自注意力机制中，Q、K、V全部来自同一个序列，用于计算序列内部每个token与其他所有token之间的依赖关系。这一设计使得：

1. 全局依赖建模：任意两个token之间的依赖路径长度为 $O(1)$，与距离无关
2. 完全并行化：所有位置的计算可以同时进行
3. 可解释性强：注意力权重直接反映了token之间的重要性关系

排列等变性（Permutation Equivariance）

Self-Attention具有一个重要的数学性质——排列等变性。对于任意排列矩阵 $P$：

$$\text{SelfAttn}(PX) = P \cdot \text{SelfAttn}(X)$$

证明：令 $X' = PX$，则：

$$Q' = PXW^Q = PQ, \quad K' = PK, \quad V' = PV$$

$$Q'(K')^T = PQ(PK)^T = P(QK^T)P^T$$

$$\text{softmax}(Q'(K')^T)V' = P \cdot \text{softmax}(QK^T)P^T \cdot PV = P \cdot \text{SelfAttn}(X)$$

这一性质既是自注意力的优点（对输入排列的响应是确定性的），也是其根本缺陷——如果不加入位置信息，模型完全无法区分序列顺序，"我爱你"和"你爱我"将被编码为完全相同的表示。这正是位置编码存在的根本原因。

1.2.2 多头注意力的并行计算

动机与直觉

单一的注意力机制可能只关注到一种类型的依赖关系。类比卷积神经网络中的多个滤波器，多头注意力（Multi-Head Attention）通过多组独立的Q/K/V投影，在不同的表示子空间中并行计算注意力，从而捕捉不同类型的依赖关系（如句法关系、语义关系、共指关系等）。

完整数学定义

$$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h)W^O$$

其中每个注意力头：

$$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$$

参数维度：
- $W_i^Q, W_i^K \in \mathbb{R}^{d_{model} \times d_k}$
- $W_i^V \in \mathbb{R}^{d_{model} \times d_v}$
- $W^O \in \mathbb{R}^{hd_v \times d_{model}}$

通常设置 $d_k = d_v = d_{model}/h$。例如 $d_{model}=512, h=8$ 时，$d_k = d_v = 64$。

多头注意力的表达能力分析

一个常见的问题是：多头注意力是否可以等效为一个单头的更大注意力？答案是否定的。多头注意力本质上是子空间学习，不是简单的矩阵分解。原因如下：

1. 每个头有独立的Q/K/V投影矩阵，分别将输入投影到不同的低维子空间
2. 每个头经过独立的softmax归一化，softmax的非线性特性使得多头的表达能力强于单头
3. 拼接操作（Concat）保留了每个子空间的独立信息，再通过输出投影矩阵 $W^O$ 进行融合

从信息论的角度看，多头注意力类似于集成学习——多个弱注意力函数的输出被聚合为一个更强的表示。

计算流程的维度追踪

以 $d_{model}=512, h=8, d_k=d_v=64$ 为例：

1. 输入 $X \in \mathbb{R}^{n \times 512}$
2. 线性投影：$Q = XW^Q \in \mathbb{R}^{n \times 512}$，再reshape为 $Q \in \mathbb{R}^{n \times 8 \times 64}$
3. 转置为 $Q \in \mathbb{R}^{8 \times n \times 64}$（8个头并行）
4. 每个头计算：$\text{head}_i = \text{softmax}\left(\frac{Q_i K_i^T}{\sqrt{64}}\right)V_i \in \mathbb{R}^{n \times 64}$
5. 拼接：$\text{Concat} \in \mathbb{R}^{n \times 512}$
6. 输出投影：$\text{Output} = \text{Concat} \cdot W^O \in \mathbb{R}^{n \times 512}$

1.2.3 复杂度分析与效率讨论

自注意力机制的时间复杂度和空间复杂度是理解和优化Transformer的关键。

自注意力复杂度分解

$O(n^2)$ 复杂度的来源在于注意力分数矩阵 $QK^T \in \mathbb{R}^{n \times n}$ 的计算和存储。当序列长度增加时，这一开销呈二次增长：

这一 $O(n^2)$ 复杂度是Transformer处理长序列时的核心瓶颈，也是第1.6节将要讨论的高效Transformer变体的主要优化目标。

与RNN、CNN的复杂度对比

关键观察：
- RNN：每步计算简单但串行，长距离依赖需要 $O(n)$ 步传播，容易出现梯度消失
- CNN：通过空洞卷积可以增加感受野，但依赖路径仍需 $O(\log n)$ 层
- Self-Attention：任意两个位置直接交互，依赖路径长度为 $O(1)$，但代价是 $O(n^2)$ 的复杂度

Mask操作的必要性

在实际应用中，自注意力需要两种Mask机制：

Padding Mask（填充掩码）：处理变长序列中的<PAD>标记，使模型不关注填充位置。在softmax前，将填充位置对应的分数置为 $-\infty$：

$$\text{scores}{masked} = \text{scores} + \text{mask}, \quad \text{其中 } \text{mask}{ij} = \begin{cases} 0 & \text{if } j \text{ is valid} \ -\infty & \text{if } j \text{ is padding} \end{cases}$$

Look-Ahead Mask / Causal Mask（因果掩码）：在Decoder的自回归生成中，防止当前位置看到未来的token：

$$\text{mask}_{ij} = \begin{cases} 0 & \text{if } i \geq j \ -\infty & \text{if } i < j \end{cases}$$

Decoder需要Causal Mask的根本原因是：训练时所有位置同时计算，但推理时只能看到已生成的token。Causal Mask确保训练和推理的一致性。

1.3 位置编码：赋予序列顺序信息

自注意力机制的排列等变性意味着，如果不显式注入位置信息，Transformer将完全无法区分序列顺序。位置编码（Positional Encoding, PE）正是为了解决这一问题而设计的。本节将详细讨论正弦位置编码的数学原理、绝对位置编码与相对位置编码的对比，以及旋转位置编码（RoPE）这一现代大模型中的关键变体。

1.3.1 正弦位置编码的数学推导

原始Transformer使用固定的正弦/余弦函数作为位置编码。对于位置 $pos$（从0开始）和模型维度索引 $i$（从0到 $d_{model}-1$）：

$$PE(pos, 2i) = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$

$$PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$

参数解释：
- $pos$：token在序列中的位置索引（$0, 1, 2, \ldots, n-1$）
- $i$：维度索引，$i \in [0, d_{model}/2 - 1]$
- $d_{model}$：模型维度（如512、768、1024）
- $10000$：预定义的基数（base），控制频率范围
- $10000^{2i/d_{model}}$：分母项，决定不同维度的波长

等效写法（更便于分析的形式）：

$$PE(pos, 2i) = \sin(pos \cdot \omega_i), \quad \omega_i = 10000^{-2i/d_{model}}$$

$$PE(pos, 2i+1) = \cos(pos \cdot \omega_i)$$

波长特性分析

对于第 $i$ 组维度（即第 $2i$ 和 $2i+1$ 维），波长 $\lambda_i$ 满足：

$$\lambda_i = 2\pi \cdot 10000^{2i/d_{model}}$$

• 当 $i=0$ 时：$\lambda_0 = 2\pi \approx 6.28$（最小波长，最高频率）
• 当 $i=d_{model}/2-1$ 时：$\lambda_{max} = 2\pi \cdot 10000 \approx 62832$（最大波长，最低频率）

这一设计使得不同维度以不同频率编码位置信息：

低频维度（$i$ 较大，$\omega_i$ 较小）：波长很长，值随位置变化缓慢，编码长程位置变化。例如，对于 $d_{model}=512$，最后几维的波长约62832，远大于常见序列长度，因此在序列范围内几乎线性变化。

高频维度（$i$ 较小，$\omega_i$ 较大）：波长很短，值随位置快速振荡，编码精细位置差异。前几维的波长仅约6.28，可以在很小的位置范围内产生丰富的变化。

正弦/余弦成对使用的核心原因——相对位置编码

使用sin/cos成对使用的关键数学性质是：对于固定偏移量 $k$，$PE(pos+k)$ 可以表示为 $PE(pos)$ 的线性函数。

由三角函数的加法公式：

$$\sin(\omega_i(pos+k)) = \sin(\omega_i pos)\cos(\omega_i k) + \cos(\omega_i pos)\sin(\omega_i k)$$

$$\cos(\omega_i(pos+k)) = \cos(\omega_i pos)\cos(\omega_i k) - \sin(\omega_i pos)\sin(\omega_i k)$$

写成矩阵形式：

$$\begin{bmatrix} PE(pos+k, 2i) \ PE(pos+k, 2i+1) \end{bmatrix} = \begin{bmatrix} \cos(\omega_i k) & \sin(\omega_i k) \ -\sin(\omega_i k) & \cos(\omega_i k) \end{bmatrix} \begin{bmatrix} PE(pos, 2i) \ PE(pos, 2i+1) \end{bmatrix}$$

这是一个旋转矩阵！它将位置 $pos$ 的编码向量旋转了一个角度 $\omega_i k$，得到位置 $pos+k$ 的编码。

这一性质的深刻含义是：模型可以通过注意力机制轻松学习相对位置信息。对于任意偏移 $k$，注意力分数 $q_i \cdot k_j$ 中涉及的 $PE(i)$ 和 $PE(j)$ 之间的关系仅依赖于它们的相对距离 $|i-j|$，而非绝对位置。模型只需学习关注 $\sin(\omega_i k)$ 和 $\cos(\omega_i k)$ 的特定组合，就可以推断任意偏移对应的位置关系。

外推性（Extrapolation）

正弦位置编码是连续函数，对于训练时未见过的更长序列，编码仍然有效（函数值有定义）。这是相比可学习位置编码的一大优势——可学习位置编码在超过训练长度的位置上从未见过对应的嵌入向量，表现会严重下降。

然而，正弦编码的外推性也并非完美。当序列长度远超训练长度时，注意力机制可能无法正确适应更大范围的相对位置。后续工作如Position Interpolation（PI）和NTK-aware扩展正是为了解决这一问题。

位置编码与词嵌入的融合

位置编码通过逐元素相加的方式与词嵌入融合：

$$X = \text{Embedding}(tokens) + PE(positions)$$

这一简单操作的有效性基于以下几点：

1. 数值范围匹配：位置编码的值域为 $[-1, 1]$，与经过初始化的词嵌入（通常均值为0，标准差较小）量级相当。原始Transformer还在词嵌入上乘以 $\sqrt{d_{model}}$（约22.6），使两者量级更匹配，避免位置编码淹没词嵌入的信息。

2. 模型可以学习区分：Transformer后续的线性层和非线性激活可以将相加后的信号分离，分别提取语义信息和位置信息。

3. 类比信号处理：类似于在信号上叠加一个载波，后续处理可以从中提取出有效信息。

实验上，BERT等模型使用可学习的位置编码（直接作为参数与词嵌入相加），同样取得了很好的效果，证明了这种简单相加方式的有效性。

1.3.2 绝对位置编码 vs 相对位置编码

位置编码的设计可以分为两大类：绝对位置编码和相对位置编码。理解它们的区别对于把握现代大模型的设计选择至关重要。

绝对位置编码（Absolute Positional Encoding）

为每个绝对位置 $pos$ 分配一个唯一的编码向量，编码仅依赖位置本身。

相对位置编码（Relative Positional Encoding）

编码token之间的相对距离 $pos_i - pos_j$，而非绝对位置。核心直觉是：在自然语言中，两个词之间的关系更多地取决于它们的相对距离，而非绝对位置。

T5相对位置偏置

T5在注意力分数中引入可学习的相对位置偏置矩阵 $B$：

$$\text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} + B\right)V$$

其中 $B_{ij} = b(i-j)$，$b$ 为针对每个相对距离的可学习标量。T5将相对距离裁剪到某个最大范围（如128），超出该范围的共享同一个偏置值。

RoPE（Rotary Position Embedding，旋转位置编码）

RoPE是现代大模型（LLaMA、ChatGLM等）广泛采用的位置编码方案。其核心思想是通过旋转矩阵将位置信息融入Q和K向量中，使得内积 $q_m^T k_n$ 仅依赖于相对距离 $m-n$。

完整推导过程：

Step 1 - 将 $d$ 维向量分为 $d/2$ 个二维复数对：

$$\bar{q}_n^{(l)} = q_n^{(2l)} + i \cdot q_n^{(2l+1)}, \quad l = 0, 1, \ldots, d/2-1$$

Step 2 - 对每个复数对施加旋转：

$$\tilde{q}_n^{(l)} = \bar{q}_n^{(l)} \cdot e^{in\theta_l}$$

其中 $\theta_l = 10000^{-2l/d}$ 为预定义频率。

Step 3 - 旋转矩阵的实数形式：

对于第 $l$ 对维度 $[2l, 2l+1]$，旋转矩阵为：

$$R_{\Theta,n}^{(l)} = \begin{bmatrix} \cos(n\theta_l) & -\sin(n\theta_l) \ \sin(n\theta_l) & \cos(n\theta_l) \end{bmatrix}$$

完整的旋转矩阵 $R_{\Theta,n} \in \mathbb{R}^{d \times d}$ 是块对角矩阵：

$$R_{\Theta,n} = \begin{bmatrix} R_{\Theta,n}^{(0)} & 0 & \cdots \ 0 & R_{\Theta,n}^{(1)} & \cdots \ \vdots & \vdots & \ddots \end{bmatrix}$$

Step 4 - RoPE编码后的Q、K：

$$\tilde{q}n = R{\Theta,n} \cdot q_n, \quad \tilde{k}m = R{\Theta,m} \cdot k_m$$

Step 5 - 关键性质：内积仅依赖相对位置

$$\tilde{q}n^T \tilde{k}_m = q_n^T R{\Theta,n}^T R_{\Theta,m} \, k_m = q_n^T R_{\Theta,m-n} \, k_m$$

这一等式成立的关键是旋转矩阵的正交性：$R_{\Theta,n}^T R_{\Theta,m} = R_{\Theta,m-n}$。因此内积结果仅依赖于相对距离 $m-n$，实现了相对位置编码。

RoPE的优秀外推能力来源于：对于训练时未见过的更大距离，旋转角度 $e^{i(m-n)\theta_l}$ 仍然有明确定义，模型只需要学习适应更大的角度范围即可。

ALiBi（Attention with Linear Biases）

ALiBi是一种极简的相对位置编码方案，被BLOOM、MPT等模型采用。其核心思想是不给token添加任何位置嵌入向量，而是直接在注意力分数上添加与距离成线性负相关的偏置：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} - b \cdot |i-j|\right)V$$

其中 $b$ 为负斜率参数，通常每个头设置不同的值：$b_h = 2^{-\frac{8}{h}}$（$h$ 为头编号）。

ALiBi的特点：
1. 无需额外参数：偏置是预定义的，不需要学习
2. 训练更稳定：相比可学习位置编码，ALiBi收敛更快更稳定
3. 外推能力强：线性偏置对训练时未见过的更长序列泛化良好
4. 实现简单：仅需在注意力分数矩阵上减去一个偏置矩阵

三种主要位置编码的对比总结

1.4 Transformer架构全貌

本节将完整呈现Transformer的架构细节，包括Encoder-Decoder结构、Layer Normalization与残差连接的设计原理、Feed-Forward Network的作用，以及现代大模型中广泛采用的Pre-LN与Post-LN的讨论。

1.4.1 Encoder-Decoder结构详解

Transformer的整体架构由两部分组成：Encoder（编码器）负责将输入序列映射为连续的上下文表示，Decoder（解码器）负责自回归地生成输出序列。原始Transformer设置 $N=6$ 层编码器和 $N=6$ 层解码器。

整体数据流

text Input Tokens → [Embedding + Positional Encoding] → Encoder × N → Decoder × N → Linear + Softmax → Output Probabilitiestext

Encoder层（每层包含两个子层）

1. Multi-Head Self-Attention：处理输入序列，每个位置关注所有位置（双向注意力）。这里的Self-Attention是"双向"的，因为每个token都可以同时看到其左侧和右侧的所有token。

2. Feed-Forward Network（FFN）：对每个位置独立进行非线性变换。注意FFN是"逐位置"的，不同位置之间不共享信息。

每个子层后都有：残差连接 + Layer Normalization

$$\text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) \quad \text{(Post-LN)}$$

Decoder层（每层包含三个子层）

1. Masked Multi-Head Self-Attention：自回归地关注已生成的位置（单向注意力）。通过Causal Mask确保每个位置只能看到自己和之前的位置。

2. Multi-Head Cross-Attention：Q（Query）来自Decoder前一层的输出，K（Key）和V（Value）来自Encoder的最终输出。这一层建立了源序列和目标序列之间的对齐关系。

3. Feed-Forward Network：对Decoder输出进行非线性变换。

每个子层后同样有残差连接 + Layer Normalization。

输出层

最后的Decoder输出经过Linear层映射到词表维度，再经过Softmax得到下一个token的概率分布：

$$P(x_t | x_{<t}) = \text{Softmax}(W_O \cdot \text{DecoderOutput}_t)$$

Cross-Attention的工作原理

Cross-Attention（编码器-解码器注意力）是连接Encoder和Decoder的桥梁：

$$\text{CrossAttn}(Q_{dec}, K_{enc}, V_{enc}) = \text{softmax}\left(\frac{Q_{dec}K_{enc}^T}{\sqrt{d_k}}\right)V_{enc}$$

维度分析：
- $Q_{dec} \in \mathbb{R}^{m \times d}$（$m$ 为目标序列长度）
- $K_{enc}, V_{enc} \in \mathbb{R}^{n \times d}$（$n$ 为源序列长度）
- 注意力分数矩阵：$\mathbb{R}^{m \times n}$
- 输出：$\mathbb{R}^{m \times d}$

Cross-Attention的核心作用是：
1. 源-目标对齐：每个目标位置的query去匹配所有源位置key，建立翻译/生成中的词语对应关系
2. 信息桥接：将Encoder编码的源语言信息引入Decoder的生成过程
3. 复制机制：Decoder可以通过Cross-Attention直接从源序列中"复制"信息

三种架构变体的对比

1.4.2 Layer Normalization与残差连接

Layer Normalization的数学定义

$$\text{LayerNorm}(x) = \gamma \odot \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta$$

其中：
- $\mu = \frac{1}{d}\sum_{i=1}^{d} x_i$（单样本均值）
- $\sigma^2 = \frac{1}{d}\sum_{i=1}^{d}(x_i - \mu)^2$（单样本方差）
- $\gamma, \beta \in \mathbb{R}^d$ 为可学习的缩放和平移参数
- $\epsilon$ 为数值稳定性常数（通常 $10^{-5}$）

为什么Transformer选择LayerNorm而非BatchNorm？

Transformer选择LayerNorm的原因：

1. 序列长度变化：NLP中序列长度不一，BatchNorm难以稳定计算
2. 小batch场景：NLP训练常用小batch（如8、16），BatchNorm统计量不稳定
3. 独立性要求：Transformer中每个位置的计算应保持一定的独立性
4. 训练推理一致性：LayerNorm训练和推理行为完全一致，简化部署

残差连接（Residual Connection）的数学原理

残差连接是Transformer能够训练深层网络的关键：

$$y = x + \text{Module}(x)$$

梯度分析：

$$\frac{\partial y}{\partial x} = I + \frac{\partial \text{Module}(x)}{\partial x}$$

在反向传播时，梯度会通过两条路径传播：
1. 跳跃连接（$I$）：恒等映射，梯度不衰减
2. 模块路径：正常反向传播

假设网络有 $L$ 层，在没有残差连接时，梯度是 $L$ 个Jacobian矩阵的乘积：

$$\frac{\partial y_L}{\partial x} = \prod_{l=1}^{L} J_l$$

每个 $J_l$ 的范数如果小于1，多次乘积后梯度会指数级衰减。有了残差连接后：

$$x_{l+1} = x_l + f(x_l) \approx x_l$$

当 $f$ 较小时，网络近似于恒等映射，梯度传播类似于：

$$\frac{\partial y_L}{\partial x} \approx I + \text{(small terms)}$$

即使某些层的梯度很小，跳跃连接也能保证梯度有效传播。

Pre-LN vs Post-LN

这是Transformer架构设计中的一个关键选择，直接影响深层模型的训练稳定性。

Post-LN（原始Transformer）：

$$y_l = \text{LayerNorm}(x_l + \text{Module}(x_l))$$

Pre-LN（现代LLM如GPT、LLaMA）：

$$y_l = x_l + \text{Module}(\text{LayerNorm}(x_l))$$

现代模型选择Pre-LN的主要原因：

1. 梯度稳定性：Pre-LN在每个子层模块之前进行归一化，使得残差连接可以直接传播梯度，避免了深层网络中的梯度消失问题
2. 训练效率：Pre-LN可以使用更大的学习率，不需要漫长的warmup阶段
3. 深层模型适配：随着模型层数增加到几十甚至上百层，Post-LN的梯度消失问题越来越严重

Pre-LN的潜在问题：

• "Massive Activations"现象：由于残差连接绕过了LayerNorm，隐状态的方差可以随深度指数增长，可能导致数值不稳定
• 一些研究提出Peri-LN（同时归一化输入和输出）来缓解这个问题

RMSNorm

RMSNorm（Root Mean Square Layer Normalization）是LayerNorm的变体，被LLaMA等模型采用：

$$\text{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_{i=1}^{d}x_i^2 + \epsilon}} \cdot \gamma$$

RMSNorm去掉了LayerNorm中的均值中心化步骤，只保留均方根归一化。实验表明RMSNorm在LLM中略优于标准LayerNorm，且计算更简单。

1.4.3 Feed-Forward Network的设计原理

结构定义

$$\text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2$$

或等价写作：

$$\text{FFN}(x) = W_2 \cdot \text{ReLU}(W_1 x + b_1) + b_2$$

维度变化：
- 第一层：$d_{model} \rightarrow d_{ff}$（升维，通常 $d_{ff} = 4d_{model} = 2048$）
- ReLU激活
- 第二层：$d_{ff} \rightarrow d_{model}$（降维）

为什么这样设计？

1. 增加非线性表达能力：ReLU引入非线性，使模型能学习更复杂的特征变换
2. 升维再降维的"信息瓶颈"效应：中间维度更大，允许模型在高维空间中做更丰富的特征映射，类似于AutoEncoder的结构
3. 位置级独立处理：FFN对每个位置独立应用，增加了模型的逐位置变换能力，补充了Attention的跨位置交互

值得注意的是，FFN占据了Transformer约2/3的参数量：

现代改进——GELU和SwiGLU

现代大模型普遍使用更先进的激活函数替代ReLU：

GELU（BERT、T5使用）：

$$\text{GELU}(x) = x \cdot \Phi(x) = x \cdot \frac{1}{2}\left[1 + \text{erf}\left(\frac{x}{\sqrt{2}}\right)\right]$$

近似形式：

$$\text{GELU}(x) \approx 0.5x\left(1 + \tanh\left[\sqrt{\frac{2}{\pi}}\left(x + 0.044715x^3\right)\right]\right)$$

GELU相比ReLU的优势在于它是平滑的激活函数，在0附近连续可微，有利于梯度传播。

SwiGLU（LLaMA、PaLM使用）：

$$\text{SwiGLU}(x) = (\text{SiLU}(xW_{gate}) \odot xW_{up})W_{down}$$

其中 $\text{SiLU}(x) = x \cdot \sigma(x)$（也称为Swish激活函数），$\sigma$ 为sigmoid，$\odot$ 为逐元素乘法。

SwiGLU引入了门控机制，可以自适应地控制信息流。Google的PaLM、Meta的LLaMA等模型都使用SwiGLU作为FFN的激活函数，实验表明其性能优于GELU。

LLaMA中SwiGLU的实现细节：

$$\text{FFN}_{SwiGLU}(x) = (\text{SiLU}(xW_1) \odot (xW_2))W_3$$

注意：SwiGLU有三组权重矩阵（$W_1$为gate，$W_2$为up，$W_3$为down），为了维持参数量不变，中间维度 $d_{ff}$ 通常调整为 $\frac{2}{3} \times 4d_{model} = \frac{8}{3}d_{model}$。

1.5 关键变体：BERT、GPT与T5

Transformer架构的灵活性催生了三大主要变体，各自对应不同的任务范式和预训练策略。理解这些变体的设计选择，是理解现代大模型发展的关键。

1.5.1 BERT：双向编码器表征

BERT（Bidirectional Encoder Representations from Transformers）于2018年由Google提出，标志着预训练-微调范式的成熟。

架构设计

BERT仅使用Transformer的Encoder部分（双向注意力），丢弃了Decoder。这一设计使得BERT天然适合"理解"类任务——每个token都可以同时看到其左侧和右侧的所有上下文信息。

典型规模：
- BERT-Base：12层，110M参数（$d_{model}=768, h=12$）
- BERT-Large：24层，340M参数（$d_{model}=1024, h=16$）

预训练任务1：MLM（Masked Language Model，掩码语言模型）

MLM的核心思想是：随机mask输入序列中15%的token，让模型预测这些被mask的token。

具体实现：
- 80%的概率用[MASK]替换
- 10%的概率用随机token替换
- 10%的概率保持原token不变

为什么要这样设计？ 防止预训练和微调之间的mismatch。微调时输入中没有[MASK]token，如果不做这种混合策略，模型在微调时无法适应正常文本。

数学形式：

$$\mathcal{L}{MLM} = -\mathbb{E}{x \sim \mathcal{D}} \sum_{i \in \mathcal{M}} \log P(x_i | x_{\backslash \mathcal{M}})$$

其中 $\mathcal{M}$ 是被mask的位置集合。注意 $x_{\backslash \mathcal{M}}$ 表示模型可以看到mask位置两侧的所有上下文。

预训练任务2：NSP（Next Sentence Prediction，下一句预测）

NSP的目标是预测句子B是否是句子A的下一句：
- 正样本（50%）：实际相邻的两个句子
- 负样本（50%）：随机配对的两个句子

输入格式：[CLS] A [SEP] B [SEP]

NSP旨在让模型学习句子间的关系，但后续研究（如RoBERTa）发现NSP对大多数下游任务几乎没有贡献，可能是因为任务太简单或目标不明确，因此被废弃。

BERT的输入表示

BERT的每个输入token的表示由三部分相加：

$$E_{input} = E_{token} + E_{segment} + E_{position}$$

• $E_{token}$：词嵌入
• $E_{segment}$：句子A/B的段落嵌入（用于区分两个句子）
• $E_{position}$：可学习的位置嵌入（注意不是正弦编码）

[CLS]和[SEP]特殊token的作用

• [CLS]（Classification）：放在序列开头，其最终隐状态用于分类任务
• [SEP]（Separator）：用于分隔句子（NSP任务中）和标记序列结束

为什么BERT不适合文本生成？

这是理解BERT设计局限性的关键问题。BERT在预训练时看到的是双向上下文（被mask的词两边都能看到），而生成任务只能看到左边的已生成文本。这种训练和推理的不一致导致BERT无法直接自回归生成。换言之，BERT从未学习过"给定前缀，预测下一个token"的能力。

1.5.2 GPT：自回归语言建模

GPT（Generative Pre-trained Transformer）系列由OpenAI开发，代表了自回归语言模型的演进路径，也是当代大语言模型（GPT-4、Claude、LLaMA等）的直接前身。

架构设计

GPT仅使用Transformer的Decoder部分，采用因果注意力（Causal Attention）：每个token只能看到它自己和之前的token。这种单向结构天然适合自回归生成任务。

GPT系列演进

训练目标（自回归语言模型）

$$\mathcal{L}{LM} = -\sum{t=1}^{T} \log P(x_t | x_1, x_2, \ldots, x_{t-1})$$

核心直觉：模型学习根据已生成的token序列，预测下一个token的概率分布。

GPT的设计哲学与BERT的对比

为什么Decoder-only架构成为大模型主流？

1. 统一性：所有任务都可以统一为"给定前缀，生成后续"
2. 可扩展性：Decoder-only架构在参数量扩大时表现最好（scaling law）
3. 训练简单：不需要像Encoder-Decoder那样处理两种注意力的复杂性
4. 推理友好：自回归生成是自然的文本生成方式

1.5.3 T5：Text-to-Text统一框架

T5（Text-to-Text Transfer Transformer）由Google于2019年提出，其核心思想是将所有NLP任务统一为文本到文本的生成问题。

核心思想

T5认为，无论任务的原始形式是什么（分类、翻译、问答、摘要），都可以将其编码为文本输入，输出也是文本形式。这种统一框架的优雅之处在于：所有任务共享同一套模型架构、预训练目标和训练流程。

具体做法：
- 每个任务编码为带有前缀提示（prefix）的文本输入
- 输出也是文本形式

示例：

架构

T5保留了完整的Encoder-Decoder结构：
- Encoder使用双向注意力
- Decoder使用因果注意力 + Cross-Attention
- 层数：T5-Base（12层）、T5-Large（24层）等

预训练任务：Span Corruption（span损坏）

T5的预训练任务比BERT的MLM更具挑战性：
- 随机采样并mask输入中的连续span（平均长度3）
- 用唯一的<extra_id_0>等哨兵token替换
- 目标输出是被mask的span序列

示例：
- 输入：Thank you <extra_id_0> me to your party <extra_id_1> week
- 输出：<extra_id_0> for inviting <extra_id_1> last

相比BERT只预测单个token，T5需要预测完整的span，这要求模型学习更长的依赖关系和更复杂的推理。

T5统一框架的优势与局限

优势：
1. 框架统一，所有任务共享同一套模型和训练流程
2. 通过prefix可以灵活适配不同任务
3. 生成式框架天然适合需要输出的任务

局限：
1. 某些任务可能不适合生成式建模（如需要精确数值输出的回归任务）
2. 生成式推理比分类慢（需要自回归生成）
3. Encoder-Decoder架构参数量更大

三大变体的架构对比总结

text BERT（Encoder-only）: 输入 → [Encoder × N] → [MLM Head] → 预测Mask Token GPT（Decoder-only）: 输入 → [Decoder × N] → [LM Head] → 预测下一个Token T5（Encoder-Decoder）: 输入 → [Encoder × N] → [Decoder × N] → Text-to-Text Outputtext

从现代大模型的视角看，GPT系列的Decoder-only架构最终成为了主流。这并非偶然——Decoder-only架构在参数量扩大时展现出最好的scaling特性，且自回归生成是语言模型的最自然形式。BERT的双向Encoder结构虽然在理解任务上表现出色，但由于无法直接生成文本，在通用AI的方向上受到了限制。T5的统一框架虽然优雅，但Encoder-Decoder的复杂性使其在超大规模上难以与Decoder-only架构竞争。

1.6 高效Transformer变体

自注意力的 $O(n^2)$ 复杂度是Transformer处理长序列时的核心瓶颈。本节将讨论两类主要的优化方向：通过近似降低复杂度的线性/稀疏注意力，以及通过优化内存访问模式提升效率的Flash Attention。

1.6.1 线性注意力与稀疏注意力

线性注意力（Linear Attention）

线性注意力的核心思想是用核函数（Kernel Feature Map）替代Softmax，将注意力复杂度从 $O(n^2)$ 降到 $O(n)$。

标准注意力回顾：

$$\text{Attn}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

线性注意力的推导：

Step 1 - 将softmax表示为特征映射的内积：

$$\text{sim}(q_i, k_j) = \exp\left(\frac{q_i \cdot k_j}{\sqrt{d_k}}\right) = \phi(q_i)^T \phi(k_j)$$

其中 $\phi$ 是特征映射函数，将原始向量映射到更高维的特征空间。

Step 2 - 注意力输出变为：

$$o_i = \frac{\sum_j \phi(q_i)^T \phi(k_j) v_j}{\sum_j \phi(q_i)^T \phi(k_j)}$$

Step 3 - 关键分解——利用矩阵乘法的结合律：

$$o_i = \frac{\phi(q_i)^T \sum_j \phi(k_j) v_j^T}{\phi(q_i)^T \sum_j \phi(k_j)} = \frac{\phi(q_i)^T \cdot S}{\phi(q_i)^T \cdot z}$$

其中 $S = \sum_j \phi(k_j) v_j^T \in \mathbb{R}^{d' \times d}$，$z = \sum_j \phi(k_j) \in \mathbb{R}^{d'}$。

复杂度分析：
- 计算 $S$ 和 $z$：$O(n \cdot d' \cdot d)$
- 对每个query计算输出：$O(d' \cdot d)$
- 总计：$O(n \cdot d' \cdot d)$，与序列长度线性相关

核心技巧在于：标准注意力先算 $QK^T$（$O(n^2d)$），再乘 $V$；线性注意力通过特征映射改变了计算顺序，先算 $K$ 和 $V$ 的聚合（$O(n)$），再与每个 $Q$ 交互。

常用核函数：
- Performer：使用正交随机特征（ORF）近似RBF核
- Linear Transformer：$\phi(x) = \text{elu}(x) + 1$
- cosFormer：基于余弦重加权

线性注意力的局限：
1. 表达能力弱于softmax注意力——softmax的非线性聚焦能力难以被简单核函数完全替代
2. 在需要精确检索的任务上表现较差
3. 因果（decoder-only）场景下难以实现高效并行训练

稀疏注意力（Sparse Attention）

稀疏注意力的核心思想是：让注意力矩阵变为稀疏矩阵，只计算重要的注意力对。

Longformer 结合三种注意力模式：

1. Sliding Window Attention（滑动窗口注意力）：每个token只关注其左右各 $w$ 个邻居，复杂度 $O(n \cdot w)$
2. Dilated Sliding Attention（空洞滑动注意力）：在滑动窗口中每隔 $d$ 个token才计算注意力，进一步减少计算
3. Global Attention（全局注意力）：在特定位置（如[CLS]）设置全局注意力，可以连接到所有位置

BigBird 是Longformer的扩展，结合了三种模式并证明了其是Universal Approximator：

1. Random Attention（随机注意力）：每个token随机关注 $r$ 个其他token
2. Window Attention（窗口注意力）：局部滑动窗口
3. Global Attention（全局注意力）：部分token关注所有位置，所有位置也关注这些全局token

BigBird的核心理论贡献是证明了这种稀疏注意力模式保持了对连续函数的Universal Approximation能力。

复杂度对比：

线性注意力和稀疏注意力的权衡

线性注意力和稀疏注意力代表了两种不同的优化哲学：

• 线性注意力：保持全局注意力，但通过数学近似降低复杂度。优点是理论上每个位置仍然可以影响所有其他位置；缺点是近似引入的精度损失。
• 稀疏注意力：显式地限制注意力模式，只计算部分注意力对。优点是不改变注意力的数学形式；缺点是表达能力受限于注意力模式的先验设计。

在实际应用中，这两种方法的选择取决于具体任务对全局依赖的需求程度。

1.6.2 Flash Attention：IO感知的精确注意力

Flash Attention代表了第三类优化方向——不改变注意力的数学计算（exact attention），而是通过优化内存访问模式来提升实际运行效率。这一方法已成为现代大模型训练的事实标准。

核心思想：IO-Aware Exact Attention

Flash Attention的洞察是：对于大规模注意力计算，内存访问（而非浮点运算）才是主要瓶颈。GPU的内存层次结构中：
- HBM（High Bandwidth Memory）：容量大（几十GB）但访问速度慢
- SRAM（Static Random Access Memory）：容量小（如A100每SM为164KB）但访问速度快

标准注意力的内存瓶颈分析

标准注意力的执行流程：
1. 从HBM加载Q, K → 计算 $S = QK^T$ → 写回HBM（$O(n^2)$读写）
2. 从HBM加载S → 计算 $P = \text{softmax}(S)$ → 写回HBM（$O(n^2)$读写）
3. 从HBM加载P, V → 计算 $O = PV$ → 写回HBM

重复读写 $O(n^2)$ 的中间矩阵是主要瓶颈。当 $n$ 较大时，这些中间矩阵在HBM和计算单元之间的往返传输消耗了大量时间。

Flash Attention的解决方案

Flash Attention通过两个核心技术的结合解决了上述问题：

技术一：Tiling（分块）

将Q、K、V矩阵分块处理：
- Q分块为 $B_r$ 行（如64行一块）
- K、V分块为 $B_c$ 列（如64列一块）

每块的大小被精心选择，使得可以放入GPU的SRAM中完成计算。

技术二：Online Softmax（在线Softmax）

标准softmax需要全局信息（所有位置的最大值和指数和），这在分块计算时似乎难以实现。Flash Attention的关键洞察是：可以通过维护running statistics来分块计算softmax。

对于每个block，维护：
- $m$：当前见过的行最大值
- $l$：当前行的指数和

当处理新的block时，更新统计量：

$$\tilde{m}{new} = \max(m{old}, m_{new})$$

$$\tilde{l}{new} = l{old} \cdot e^{m_{old} - \tilde{m}{new}} + l{new} \cdot e^{m_{new} - \tilde{m}_{new}}$$

同时，之前的输出也需要根据新的最大值进行调整：

$$\text{output}{new} = \text{output}{old} \cdot e^{m_{old} - \tilde{m}{new}} + P{new} \cdot V_{new}$$

Flash Attention的完整算法流程

text 对于每个Q的block (Q_block): 初始化 output = 0, m = -inf, l = 0 对于每个K,V的block (K_block, V_block): 加载K_block, V_block到SRAM S = Q_block @ K_block^T m_new = max(m, rowmax(S)) 调整output和S的缩放（基于m和m_new的差值） P = exp(S - m_new) l = l * exp(m - m_new) + rowsum(P) output = output * exp(m - m_new) + P @ V_block m = m_new output = output / l （归一化） 写回HBMtext

复杂度对比

Flash Attention的计算量与标准注意力完全相同——它是一个exact attention算法，不改变数学结果。它的速度提升完全来自减少HBM访问。

Flash Attention 2的改进

Flash Attention 2在原始版本的基础上进一步优化：
1. 更高效的线程块划分，减少warps间的同步开销
2. 减少非矩阵乘法（non-matmul）FLOPs
3. 在更多序列长度下达到接近理论的峰值利用率

Flash Attention的意义

Flash Attention的成功揭示了一个重要的系统设计原则：算法优化不仅要考虑计算复杂度，还要考虑硬件的内存层次结构。在现代的计算架构中，内存访问往往比计算本身更加昂贵。Flash Attention通过IO-aware的设计，在不牺牲任何精度的情况下实现了2-8倍的实际加速，使得更长序列的训练成为可能，已成为PyTorch等框架的标准组件。

1.7 图解说明

本节通过Mermaid.js图表直观展示Transformer的核心组件和工作流程。每个图表标注了数据流向、维度变化和关键操作。

图1-1：完整Transformer架构图（数据流+维度标注）

graph TB
    subgraph Input["输入处理"]
        A["输入Token序列<br/>[n]"] --> B["Token Embedding<br/>Vocab × d"]
        C["位置索引<br/>[n]"] --> D["Positional Encoding<br/>n × d"]
        B --> E["X = Embedding + PE<br/>[batch, n, d]"]
        D --> E
    end

    subgraph Encoder["Encoder × N"]
        E --> F["Multi-Head Self-Attention<br/>[batch, n, d] → [batch, n, d]"]
        F --> G["Add & Norm<br/>LayerNorm(x + Sublayer(x))"]
        E -.->|残差连接| G
        G --> H["Feed Forward Network<br/>d → 4d → d"]
        H --> I["Add & Norm<br/>LayerNorm(x + Sublayer(x))"]
        G -.->|残差连接| I
        I -->|"N-1层重复"| F
    end

    subgraph Decoder["Decoder × N"]
        J["输出Token序列<br/>[m]"] --> K["Token Embedding + PE<br/>[batch, m, d]"]
        K --> L["Masked Multi-Head Self-Attention<br/>[batch, m, d]"]
        L --> M["Add & Norm"]
        K -.->|残差连接| M
        M --> N["Multi-Head Cross-Attention<br/>Q:[m,d] K,V:[n,d]"]
        I -.->|Encoder输出| N
        N --> O["Add & Norm"]
        M -.->|残差连接| O
        O --> P["Feed Forward Network<br/>d → 4d → d"]
        P --> Q["Add & Norm"]
        O -.->|残差连接| Q
        Q -->|"N-1层重复"| L
    end

    subgraph Output["输出层"]
        Q --> R["Linear Projection<br/>d → Vocab"]
        R --> S["Softmax"]
        S --> T["输出概率分布<br/>[batch, m, vocab]"]
    end

    style Input fill:#e1f5fe
    style Encoder fill:#fff3e0
    style Decoder fill:#f3e5f5
    style Output fill:#e8f5e9

图1-2：Self-Attention计算流程图

graph LR
    A["Input X<br/>[n × d_model]"] --> B["WQ投影<br/>d_model × d_k"]
    A --> C["WK投影<br/>d_model × d_k"]
    A --> D["WV投影<br/>d_model × d_v"]
    B --> Q["Q矩阵<br/>[n × d_k]"]
    C --> K["K矩阵<br/>[n × d_k]"]
    D --> V["V矩阵<br/>[n × d_v]"]

    Q --> E["Q × K^T<br/>[n × n]"]
    K --> E
    E --> F["÷ √d_k<br/>缩放"]
    F --> G["Softmax<br/>行归一化"]
    G --> H["× V<br/>加权求和"]
    V --> H
    H --> I["Output<br/>[n × d_v]"]

    style A fill:#e1f5fe
    style I fill:#e8f5e9
    style E fill:#fff3e0
    style G fill:#fff3e0

图1-3：Multi-Head Attention分解图

graph TB
    A["Input X<br/>[batch, n, d_model]"] --> B1["Head 1<br/>W1_Q, W1_K, W1_V<br/>d_model → d_k"]
    A --> B2["Head 2<br/>W2_Q, W2_K, W2_V<br/>d_model → d_k"]
    A --> B3["Head 3<br/>W3_Q, W3_K, W3_V<br/>d_model → d_k"]
    A --> Bn["..."]

    B1 --> C1["Attention_1<br/>softmax(Q1K1^T/√d_k)V1<br/>[batch, n, d_v]"]
    B2 --> C2["Attention_2<br/>[batch, n, d_v]"]
    B3 --> C3["Attention_3<br/>[batch, n, d_v]"]
    Bn --> Cn["Attention_h<br/>[batch, n, d_v]"]

    C1 --> D["Concat<br/>[batch, n, h×d_v]"]
    C2 --> D
    C3 --> D
    Cn --> D

    D --> E["WO投影<br/>h×d_v × d_model"]
    E --> F["Final Output<br/>[batch, n, d_model]"]

    style D fill:#fff3e0
    style F fill:#e8f5e9

图1-4：正弦位置编码频率分布图

graph TB
    subgraph Dimension["维度索引 i → 频率分布"]
        direction LR
        D0["i=0<br/>最高频<br/>ω = 1<br/>λ ≈ 6.28"] 
        D1["i=1<br/>高频"]
        D2["i=2<br/>中高频"]
        D3["..."]
        D4["i=d/4<br/>中频"]
        D5["..."]
        D6["i=d/2-2<br/>低频"]
        D7["i=d/2-1<br/>最低频<br/>ω ≈ 0.0001<br/>λ ≈ 62832"]

        D0 --> D1 --> D2 --> D3 --> D4 --> D5 --> D6 --> D7
    end

    subgraph Function["频率函数"]
        F1["ω_i = 10000^(-2i/d_model)"]
    end

    subgraph Property["编码特性"]
        P1["高频维度：编码精细位置差异<br/>（相邻位置的区分）"]
        P2["低频维度：编码长程位置变化<br/>（远距离位置的区分）"]
    end

    Function --> Dimension
    D0 --> P1
    D7 --> P2

    style D0 fill:#ffebee
    style D7 fill:#e8f5e9
    style P1 fill:#ffebee
    style P2 fill:#e8f5e9

图1-5：Pre-LN vs Post-LN对比图

graph LR
    subgraph PostLN["Post-LN（原始Transformer）<br/>y = LayerNorm(x + Sublayer(x))"]
        direction LR
        A1["x"] --> B1["Sublayer<br/>(Attn/FFN)"]
        A1 -.-> C1["x + Sublayer(x)"]
        B1 --> C1
        C1 --> D1["LayerNorm"]
        D1 --> E1["Output<br/>方差稳定<br/>梯度可能消失"]
    end

    subgraph PreLN["Pre-LN（GPT/BERT/LLaMA）<br/>y = x + Sublayer(LayerNorm(x))"]
        direction LR
        A2["x"] --> B2["LayerNorm"]
        B2 --> C2["Sublayer<br/>(Attn/FFN)"]
        A2 -.-> D2["x + Sublayer(LN(x))"]
        C2 --> D2
        D2 --> E2["Output<br/>梯度传播稳定<br/>隐状态方差可能增长"]
    end

    style PostLN fill:#ffebee
    style PreLN fill:#e8f5e9

图1-6：Flash Attention Tiling策略图

graph TB
    subgraph HBM["HBM（大容量，慢访问）"]
        Q["Q矩阵<br/>N × d"]
        K["K矩阵<br/>N × d"]
        V["V矩阵<br/>N × d"]
        O["Output<br/>N × d"]
    end

    subgraph SRAM["SRAM（小容量，快访问）<br/>分块计算，避免存储完整注意力矩阵"]
        Qb["Q_block<br/>B_r × d"]
        Kb["K_block<br/>B_c × d"]
        Vb["V_block<br/>B_c × d"]
        Ob["O_block<br/>B_r × d"]
        S["Running Stats<br/>m（行最大值）<br/>l（指数和）"]
    end

    Q -->|"加载block"| Qb
    K -->|"加载block"| Kb
    V -->|"加载block"| Vb

    Qb --> C["Q_block × K_block^T<br/>S_block = [B_r × B_c]"]
    Kb --> C
    C --> S
    S --> M["Online Softmax<br/>+ P × V<br/>增量更新output"]
    Vb --> M
    M --> Ob
    Ob -->|"写回"| O

    style HBM fill:#ffebee
    style SRAM fill:#e8f5e9
    style S fill:#fff3e0

1.8 本章小结

本章从数学原理到工程实践，全面深入地剖析了Transformer架构及其核心变体。

核心要点回顾：

1. 自注意力机制：通过缩放点积实现了任意两个位置之间的直接交互，将依赖路径缩短至 $O(1)$。除以 $\sqrt{d_k}$ 的缩放操作是保证数值稳定性的关键设计。多头注意力通过多子空间并行计算，增强了模型的表达能力。

2. 位置编码：由于自注意力的排列等变性，位置编码是赋予序列顺序信息的必要组件。从正弦编码到RoPE再到ALiBi，位置编码的设计经历了从绝对到相对、从固定到自适应的演进。RoPE通过旋转矩阵实现了内积仅依赖相对距离的优雅性质。

3. 架构设计：Transformer的Encoder-Decoder结构具有极大的灵活性——仅Encoder（BERT）、仅Decoder（GPT）、完整Encoder-Decoder（T5）分别对应不同的任务范式。Pre-LN相比Post-LN在深层模型的训练稳定性上具有明显优势，成为现代大模型的标准选择。

4. 关键变体：BERT的双向Encoder在理解任务上表现出色，GPT的Decoder-only架构成为大模型的主流选择，T5的统一框架虽然优雅但在scaling上难以竞争。

5. 高效变体：线性注意力和稀疏注意力通过不同的近似策略降低了 $O(n^2)$ 复杂度，但牺牲了一定的表达能力。Flash Attention通过IO-aware的tiling策略，在不改变数学结果的情况下实现了显著的效率提升，成为现代大模型训练的事实标准。

从Transformer到大模型的演进脉络：

Transformer（2017）→ BERT/GPT-1（2018）→ GPT-2/3（2019-2020）→ GPT-4/LLaMA/Claude（2023-2024）

这条演进路径的核心线索是：
- 规模扩大：参数量从百万级增长到万亿级
- 架构简化：从Encoder-Decoder简化为Decoder-only
- 预训练统一：所有任务统一为自回归语言建模
- 推理优化：Flash Attention、MQA/GQA、KV-Cache等技术使得大模型推理更高效

掌握本章的原理，将为后续章节（预训练策略、模型对齐、推理优化）的学习奠定坚实的基础。

参考文献

[1] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L., & Polosukhin, I. (2017). Attention Is All You Need. Advances in Neural Information Processing Systems (NeurIPS), 30, 5998-6008.

[2] Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. Proceedings of NAACL-HLT, 4171-4186.

[3] Radford, A., Narasimhan, K., Salimans, T., & Sutskever, I. (2018). Improving Language Understanding by Generative Pre-Training. OpenAI Technical Report.

[4] Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., & Sutskever, I. (2019). Language Models are Unsupervised Multitask Learners. OpenAI Blog, 1(8), 9.

[5] Brown, T. B., Mann, B., Ryder, N., et al. (2020). Language Models are Few-Shot Learners. Advances in Neural Information Processing Systems (NeurIPS), 33, 1877-1901.

[6] Raffel, C., Shazeer, N., Roberts, A., et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer. Journal of Machine Learning Research, 21(140), 1-67.

[7] Liu, Y., Ott, M., Goyal, N., et al. (2019). RoBERTa: A Robustly Optimized BERT Pretraining Approach. arXiv preprint arXiv:1907.11692.

[8] Lan, Z., Chen, M., Goodman, S., Gimpel, K., Sharma, P., & Soricut, R. (2019). ALBERT: A Lite BERT for Self-supervised Learning of Language Representations. International Conference on Learning Representations (ICLR).

[9] He, P., Liu, X., Gao, J., & Chen, W. (2020). DeBERTa: Decoding-enhanced BERT with Disentangled Attention. International Conference on Learning Representations (ICLR).

[10] Clark, K., Luong, M. T., Le, Q. V., & Manning, C. D. (2020). ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators. International Conference on Learning Representations (ICLR).

[11] Su, J., Lu, Y., Pan, S., Murtadha, A., Wen, B., & Liu, Y. (2024). RoFormer: Enhanced Transformer with Rotary Position Embedding. Neurocomputing, 568, 127063.

[12] Press, O., Smith, N. A., & Lewis, M. (2022). Train Short, Test Long: Attention with Linear Biases Enables Input Length Extrapolation. International Conference on Learning Representations (ICLR).

[13] Dao, T., Fu, D. Y., Ermon, S., Rudra, A., & Re, C. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. Advances in Neural Information Processing Systems (NeurIPS), 35, 16344-16359.

[14] Dao, T. (2023). FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning. International Conference on Learning Representations (ICLR).

[15] Katharopoulos, A., Vyas, A., Pappas, N., & Fleuret, F. (2020). Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention. International Conference on Machine Learning (ICML), 5156-5165.

[16] Beltagy, I., Peters, M. E., & Cohan, A. (2020). Longformer: The Long-Document Transformer. arXiv preprint arXiv:2004.05150.

[17] Zaheer, M., Guruganesh, G., Dubey, K. A., et al. (2020). Big Bird: Transformers for Longer Sequences. Advances in Neural Information Processing Systems (NeurIPS), 33, 17283-17297.

[18] Shazeer, N. (2020). GLU Variants Improve Transformer. arXiv preprint arXiv:2002.05202.

[19] Ba, J. L., Kiros, J. R., & Hinton, G. E. (2016). Layer Normalization. arXiv preprint arXiv:1607.06450.

[20] Xiong, R., Yang, Y., He, D., et al. (2020). On Layer Normalization in the Transformer Architecture. International Conference on Machine Learning (ICML), 10524-10533.

[21] Zhang, B., & Sennrich, R. (2019). Root Mean Square Layer Normalization. Advances in Neural Information Processing Systems (NeurIPS), 32.

[22] He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep Residual Learning for Image Recognition. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 770-778.

[23] Tolstikhin, I., Houlsby, N., Kolesnikov, A., et al. (2021). MLP-Mixer: An all-MLP Architecture for Vision. Advances in Neural Information Processing Systems (NeurIPS), 34, 24261-24272.

[24] Tay, Y., Dehghani, M., Bahri, D., & Metzler, D. (2022). Efficient Transformers: A Survey. ACM Computing Surveys, 55(6), 1-28.

[25] Kaplan, J., McCandlish, S., Henighan, T., et al. (2020). Scaling Laws for Neural Language Models. arXiv preprint arXiv:2001.08361.

附录：关键组件PyTorch实现

本节提供Transformer核心组件的完整PyTorch实现，包括Self-Attention、Multi-Head Attention、位置编码、FFN以及完整的Transformer层。这些实现遵循现代工程实践（Pre-LN、GELU等），可直接用于实验或作为理解原理的参考。

A.1 缩放点积注意力

```python
import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class ScaledDotProductAttention(nn.Module):
"""
缩放点积注意力（Self-Attention核心）

数学公式: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V
"""
def __init__(self, dropout=0.1):
    super().__init__()
    self.dropout = nn.Dropout(dropout)

def forward(self, Q, K, V, mask=None):
    """
    参数:
        Q: [batch_size, n_heads, seq_len_q, d_k]
        K: [batch_size, n_heads, seq_len_k, d_k]
        V: [batch_size, n_heads, seq_len_v, d_v]
        mask: [batch_size, 1, seq_len_q, seq_len_k] (可选)
    返回:
        output: [batch_size, n_heads, seq_len_q, d_v]
        attn_weights: [batch_size, n_heads, seq_len_q, seq_len_k]
    """
    d_k = Q.size(-1)

    # Step 1: 计算 QK^T / sqrt(d_k)
    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
    # scores: [batch, n_heads, seq_q, seq_k]

    # Step 2: 应用mask（padding mask或causal mask）
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9)

    # Step 3: Softmax + Dropout
    attn_weights = F.softmax(scores, dim=-1)
    attn_weights = self.dropout(attn_weights)

    # Step 4: 加权求和V
    output = torch.matmul(attn_weights, V)
    # output: [batch, n_heads, seq_q, d_v]

    return output, attn_weights

```text

A.2 多头注意力

```python
class MultiHeadAttention(nn.Module):
"""
多头注意力模块

数学公式: 
    MultiHead(Q, K, V) = Concat(head_1, ..., head_h) W^O
    head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)
"""
def __init__(self, d_model=512, n_heads=8, dropout=0.1):
    super().__init__()
    assert d_model % n_heads == 0, "d_model必须能被n_heads整除"

    self.d_model = d_model
    self.n_heads = n_heads
    self.d_k = d_model // n_heads  # 每个头的维度

    # Q, K, V的线性投影
    self.W_Q = nn.Linear(d_model, d_model)
    self.W_K = nn.Linear(d_model, d_model)
    self.W_V = nn.Linear(d_model, d_model)

    # 输出投影
    self.W_O = nn.Linear(d_model, d_model)

    self.attention = ScaledDotProductAttention(dropout)
    self.dropout = nn.Dropout(dropout)

def split_heads(self, x):
    """
    将tensor分多头: [batch, seq, d_model] -> [batch, n_heads, seq, d_k]
    """
    batch_size, seq_len, d_model = x.size()
    x = x.view(batch_size, seq_len, self.n_heads, self.d_k)
    return x.transpose(1, 2)

def combine_heads(self, x):
    """
    合并多头: [batch, n_heads, seq, d_k] -> [batch, seq, d_model]
    """
    batch_size, n_heads, seq_len, d_k = x.size()
    x = x.transpose(1, 2).contiguous()
    return x.view(batch_size, seq_len, self.d_model)

def forward(self, query, key, value, mask=None):
    batch_size = query.size(0)

    # Step 1: 线性投影并分多头
    Q = self.split_heads(self.W_Q(query))   # [B, H, L_q, D_k]
    K = self.split_heads(self.W_K(key))     # [B, H, L_k, D_k]
    V = self.split_heads(self.W_V(value))   # [B, H, L_v, D_v]

    # Step 2: 计算缩放点积注意力
    attn_output, attn_weights = self.attention(Q, K, V, mask)

    # Step 3: 合并多头并线性投影
    output = self.W_O(self.combine_heads(attn_output))

    return output, attn_weights

```text

A.3 正弦位置编码

```python
class SinusoidalPositionalEncoding(nn.Module):
"""
原始Transformer的正弦位置编码

数学公式:
    PE(pos, 2i) = sin(pos / 10000^(2i/d_model))
    PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
"""
def __init__(self, d_model, max_len=5000, dropout=0.1):
    super().__init__()
    self.dropout = nn.Dropout(dropout)
    self.d_model = d_model

    # 预计算位置编码矩阵 [max_len, d_model]
    pe = torch.zeros(max_len, d_model)
    position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
    # position: [max_len, 1]

    # 计算分母项: 10000^(-2i/d_model)
    div_term = torch.exp(
        torch.arange(0, d_model, 2).float() * 
        (-math.log(10000.0) / d_model)
    )
    # div_term: [d_model/2]

    # 偶数维度用sin，奇数维度用cos
    pe[:, 0::2] = torch.sin(position * div_term)
    pe[:, 1::2] = torch.cos(position * div_term)

    # 注册为buffer（不参与梯度更新）
    pe = pe.unsqueeze(0)  # [1, max_len, d_model]
    self.register_buffer('pe', pe)

def forward(self, x):
    """
    x: [batch_size, seq_len, d_model]
    """
    x = x + self.pe[:, :x.size(1), :]
    return self.dropout(x)

```text

A.4 旋转位置编码（RoPE）

```python
class RoPE(nn.Module):
"""
旋转位置编码 (Rotary Position Embedding)

核心思想: 通过旋转矩阵将位置信息融入Q、K向量

数学公式:
    R^(l) = [[cos(n*theta_l), -sin(n*theta_l)],
             [sin(n*theta_l),  cos(n*theta_l)]]
    tilde_q_n = R * q_n
"""
def __init__(self, d_model, max_len=2048, base=10000):
    super().__init__()
    self.d_model = d_model

    # 预计算旋转角度: theta_l = base^(-2l/d)
    inv_freq = 1.0 / (base ** (torch.arange(0, d_model, 2).float() / d_model))

    # 计算位置与频率的乘积
    t = torch.arange(max_len, dtype=torch.float)
    freqs = torch.einsum('i,j->ij', t, inv_freq)
    # freqs: [max_len, d_model/2]

    # 注册为buffer
    self.register_buffer('cos_cached', freqs.cos())
    self.register_buffer('sin_cached', freqs.sin())

def rotate_half(self, x):
    """将x的后半部分取反并交换"""
    x1, x2 = x.chunk(2, dim=-1)
    return torch.cat([-x2, x1], dim=-1)

def forward(self, x, seq_len):
    """
    x: [batch, n_heads, seq_len, d_model]
    """
    cos = self.cos_cached[:seq_len].unsqueeze(0).unsqueeze(0)
    sin = self.sin_cached[:seq_len].unsqueeze(0).unsqueeze(0)

    # 将cos和sin扩展到完整维度
    cos = torch.cat([cos, cos], dim=-1)
    sin = torch.cat([sin, sin], dim=-1)

    return x * cos + self.rotate_half(x) * sin

```text

A.5 前馈网络（FFN + SwiGLU）

```python
class FeedForwardNetwork(nn.Module):
"""
标准FFN: 两层线性 + GELU/ReLU

数学公式: FFN(x) = activation(xW_1 + b_1)W_2 + b_2
"""
def __init__(self, d_model, d_ff=None, dropout=0.1, activation='gelu'):
    super().__init__()
    d_ff = d_ff or 4 * d_model

    self.fc1 = nn.Linear(d_model, d_ff)
    self.fc2 = nn.Linear(d_ff, d_model)
    self.dropout = nn.Dropout(dropout)

    if activation == 'gelu':
        self.activation = nn.GELU()
    elif activation == 'relu':
        self.activation = nn.ReLU()
    elif activation == 'swish':
        self.activation = nn.SiLU()
    else:
        raise ValueError(f"Unknown activation: {activation}")

def forward(self, x):
    return self.fc2(self.dropout(self.activation(self.fc1(x))))

class SwiGLU(nn.Module):
"""
SwiGLU激活: LLaMA等现代大模型使用

数学公式: SwiGLU(x) = (SiLU(xW_gate) * xW_up) W_down

注意: SwiGLU有三组权重，为了维持参数量不变，
      d_ff通常设为 (2/3) * 4 * d_model = 8/3 * d_model
"""
def __init__(self, d_model, d_ff=None, dropout=0.1):
    super().__init__()
    d_ff = d_ff or int(8/3 * d_model)

    self.W_gate = nn.Linear(d_model, d_ff, bias=False)
    self.W_up = nn.Linear(d_model, d_ff, bias=False)
    self.W_down = nn.Linear(d_ff, d_model, bias=False)
    self.dropout = nn.Dropout(dropout)

def forward(self, x):
    gate = F.silu(self.W_gate(x))  # SiLU激活（Swish）
    up = self.W_up(x)
    return self.W_down(self.dropout(gate * up))

```text

A.6 Transformer Encoder层（Pre-LN版本）

```python
class TransformerEncoderLayer(nn.Module):
"""
Transformer Encoder层 (Pre-LN版本)

架构:
    x = x + Dropout(Attn(LayerNorm(x)))
    x = x + Dropout(FFN(LayerNorm(x)))
"""
def __init__(self, d_model=512, n_heads=8, d_ff=2048, dropout=0.1):
    super().__init__()
    self.self_attn = MultiHeadAttention(d_model, n_heads, dropout)
    self.ffn = FeedForwardNetwork(d_model, d_ff, dropout, activation='gelu')

    self.norm1 = nn.LayerNorm(d_model)
    self.norm2 = nn.LayerNorm(d_model)
    self.dropout1 = nn.Dropout(dropout)
    self.dropout2 = nn.Dropout(dropout)

def forward(self, x, mask=None):
    # Pre-LN: 先归一化，再计算子层
    # 子层1: Self-Attention + 残差
    x_norm = self.norm1(x)
    attn_out, _ = self.self_attn(x_norm, x_norm, x_norm, mask)
    x = x + self.dropout1(attn_out)

    # 子层2: FFN + 残差
    x_norm = self.norm2(x)
    ffn_out = self.ffn(x_norm)
    x = x + self.dropout2(ffn_out)

    return x

```text

A.7 Transformer Decoder层（Pre-LN版本）

```python
class TransformerDecoderLayer(nn.Module):
"""
Transformer Decoder层 (Pre-LN版本)

架构:
    x = x + Dropout(MaskedAttn(LayerNorm(x)))
    x = x + Dropout(CrossAttn(LayerNorm(x), enc_output))
    x = x + Dropout(FFN(LayerNorm(x)))
"""
def __init__(self, d_model=512, n_heads=8, d_ff=2048, dropout=0.1):
    super().__init__()
    self.masked_self_attn = MultiHeadAttention(d_model, n_heads, dropout)
    self.cross_attn = MultiHeadAttention(d_model, n_heads, dropout)
    self.ffn = FeedForwardNetwork(d_model, d_ff, dropout, activation='gelu')

    self.norm1 = nn.LayerNorm(d_model)
    self.norm2 = nn.LayerNorm(d_model)
    self.norm3 = nn.LayerNorm(d_model)
    self.dropout1 = nn.Dropout(dropout)
    self.dropout2 = nn.Dropout(dropout)
    self.dropout3 = nn.Dropout(dropout)

def forward(self, x, enc_output, src_mask=None, tgt_mask=None):
    # 子层1: Masked Self-Attention
    x_norm = self.norm1(x)
    attn1_out, _ = self.masked_self_attn(x_norm, x_norm, x_norm, tgt_mask)
    x = x + self.dropout1(attn1_out)

    # 子层2: Cross-Attention (Q来自Decoder, K/V来自Encoder)
    x_norm = self.norm2(x)
    attn2_out, _ = self.cross_attn(x_norm, enc_output, enc_output, src_mask)
    x = x + self.dropout2(attn2_out)

    # 子层3: FFN
    x_norm = self.norm3(x)
    ffn_out = self.ffn(x_norm)
    x = x + self.dropout3(ffn_out)

    return x

```text

A.8 完整Transformer模型

```python
class Transformer(nn.Module):
"""
完整Transformer模型 (Encoder-Decoder)

参数:
    src_vocab_size: 源语言词表大小
    tgt_vocab_size: 目标语言词表大小
    d_model: 模型维度
    n_heads: 注意力头数
    n_encoder_layers: Encoder层数
    n_decoder_layers: Decoder层数
    d_ff: FFN中间维度
    max_len: 最大序列长度
    dropout: Dropout概率
    pad_idx: padding token的索引
"""
def __init__(
    self,
    src_vocab_size,
    tgt_vocab_size,
    d_model=512,
    n_heads=8,
    n_encoder_layers=6,
    n_decoder_layers=6,
    d_ff=2048,
    max_len=512,
    dropout=0.1,
    pad_idx=0
):
    super().__init__()
    self.d_model = d_model
    self.pad_idx = pad_idx

    # 嵌入层
    self.src_embedding = nn.Embedding(src_vocab_size, d_model)
    self.tgt_embedding = nn.Embedding(tgt_vocab_size, d_model)
    self.pos_encoding = SinusoidalPositionalEncoding(d_model, max_len, dropout)

    # Encoder
    self.encoder_layers = nn.ModuleList([
        TransformerEncoderLayer(d_model, n_heads, d_ff, dropout)
        for _ in range(n_encoder_layers)
    ])

    # Decoder
    self.decoder_layers = nn.ModuleList([
        TransformerDecoderLayer(d_model, n_heads, d_ff, dropout)
        for _ in range(n_decoder_layers)
    ])

    # 输出层
    self.output_layer = nn.Linear(d_model, tgt_vocab_size)

    # 参数初始化
    self._init_parameters()

def _init_parameters(self):
    for p in self.parameters():
        if p.dim() > 1:
            nn.init.xavier_uniform_(p)

def make_src_mask(self, src):
    """Padding mask for source sequence"""
    return (src != self.pad_idx).unsqueeze(1).unsqueeze(2)

def make_tgt_mask(self, tgt):
    """Combined padding mask + causal mask for target sequence"""
    tgt_pad_mask = (tgt != self.pad_idx).unsqueeze(1).unsqueeze(3)
    seq_len = tgt.size(1)
    causal_mask = torch.tril(
        torch.ones(seq_len, seq_len, device=tgt.device)
    ).bool().unsqueeze(0).unsqueeze(0)
    return tgt_pad_mask & causal_mask

def encode(self, src, src_mask=None):
    x = self.pos_encoding(self.src_embedding(src) * math.sqrt(self.d_model))
    for layer in self.encoder_layers:
        x = layer(x, src_mask)
    return x

def decode(self, tgt, enc_output, src_mask=None, tgt_mask=None):
    x = self.pos_encoding(self.tgt_embedding(tgt) * math.sqrt(self.d_model))
    for layer in self.decoder_layers:
        x = layer(x, enc_output, src_mask, tgt_mask)
    return x

def forward(self, src, tgt):
    src_mask = self.make_src_mask(src)
    tgt_mask = self.make_tgt_mask(tgt)

    enc_output = self.encode(src, src_mask)
    dec_output = self.decode(tgt, enc_output, src_mask, tgt_mask)

    return self.output_layer(dec_output)

```text

本章撰写说明：本章基于Vaswani et al. (2017)的原始Transformer论文，以及后续BERT、GPT、T5等关键变体的研究成果，从数学推导、架构设计、工程实现三个维度进行了系统性梳理。所有公式使用标准LaTeX格式，代码示例使用PyTorch框架，图表使用Mermaid.js语法。

第二章 预训练与微调技术

2.1 引言：预训练-微调范式

大语言模型（Large Language Model, LLM）的成功并非一蹴而就，其背后贯穿了一条从"通用学习"到"专用适配"的技术主线——预训练-微调范式（Pre-training and Fine-tuning Paradigm）。这一范式自2018年BERT与GPT的诞生起便深刻影响了自然语言处理乃至整个机器学习领域的研究路线，并在2022年至2025年的大模型爆发期中持续演进，成为支撑GPT-4、LLaMA、Qwen等超大规模模型落地应用的核心方法论。

预训练阶段的目标是在海量无标注文本上学习通用的语言表示与世界知识。通过自监督学习（Self-Supervised Learning），模型从数万亿token的语料中自动提取语法规则、语义关联、逻辑推理模式以及跨领域的常识知识。这一阶段需要大规模计算集群（数百至数千张GPU/TPU）和数天至数周的训练时间，其产出是一个具备强通用能力的"基础模型"（Base Model）。然而，基础模型本身并非直接面向终端用户——它擅长文本续写，却不善于遵循指令、保持对话连贯性或执行特定领域的专业任务。

微调阶段则承担着"能力定向"的角色。通过在中等规模的任务相关数据上继续训练，模型将预训练获得的通用知识迁移到特定下游任务中。早期的微调实践以全量微调（Full Fine-tuning）为主，即更新模型的全部参数。然而，随着模型规模从数亿增长至数千亿甚至万亿参数，全量微调的计算与存储成本变得不可承受。这一瓶颈催生了参数高效微调（Parameter-Efficient Fine-Tuning, PEFT）技术的蓬勃发展——LoRA、QLoRA、Adapter、Prefix Tuning等方法通过仅训练极少量的新增参数（通常不到总参数的1%），即可达到接近全量微调的任务性能。

与此同时，指令微调（Supervised Fine-Tuning, SFT）作为连接基础模型与对话模型（如ChatGPT、Claude）的关键桥梁，使模型学会了理解并遵循自然语言指令的"元能力"。通过在海量多样化的"指令-输入-输出"三元组上进行训练，模型获得了零样本泛化到新指令类型的能力，这构成了大模型应用化的核心技术路径。

本章将从预训练的基础理论出发，系统性地覆盖以下核心内容：

1. 预训练基础理论：自监督学习目标函数（CLM/MLM/Span Corruption）、训练稳定性保障机制、大规模分布式训练系统（DeepSpeed ZeRO、混合精度训练）。
2. 全量微调与灾难性遗忘：微调的理论本质、灾难性遗忘问题的成因与缓解策略。
3. 参数高效微调（PEFT）：以LoRA为核心的低秩适配理论（含完整数学推导）、QLoRA量化训练技术、Adapter与软提示方法（Prefix Tuning / Prompt Tuning / P-Tuning v2）。
4. 指令微调（SFT）：指令数据构建策略、训练流程与超参数配置、多任务指令微调方法。
5. PEFT方法综合对比：从参数量、显存占用、推理延迟、适用场景等维度进行系统比较。

通过本章的学习，读者将能够全面理解预训练与微调的完整技术链路，掌握从理论推导到工程实践的每一个细节，并具备根据具体场景选择最优微调策略的决策能力。

2.2 预训练基础理论

2.2.1 自监督学习目标函数（CLM/MLM/Span Corruption）

大语言模型的预训练本质上是一个自监督学习过程——模型利用文本数据自身的结构来构建监督信号，无需人工标注。根据模型架构和预测目标的不同，预训练目标函数主要分为三种：因果语言建模（Causal Language Modeling, CLM）、掩码语言建模（Masked Language Modeling, MLM）和跨度损坏（Span Corruption）。这三种目标函数分别对应Decoder-only、Encoder-only和Encoder-Decoder三种架构范式。

1. 因果语言建模（CLM / 自回归语言模型）

CLM是自回归（Autoregressive）建模的核心形式，目标是从左到右逐token预测序列中的下一个词。对于输入序列 $\mathbf{x} = (x_1, x_2, ..., x_T)$，CLM最大化以下条件似然：

$$
\mathcal{L}{\text{CLM}} = \sum{t=1}^{T} \log P(x_t \mid x_1, x_2, ..., x_{t-1}; \theta)
$$

在实现层面，CLM通过因果掩码（Causal Mask）确保每个位置 $t$ 只能关注到位置 $t$ 之前的token。具体而言，注意力矩阵被约束为一个下三角矩阵：

$$
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} + M\right)V, \quad M_{ij} = \begin{cases} 0 & i \geq j \ -\infty & i < j \end{cases}
$$

其中 $M$ 是因果掩码矩阵，确保位置 $i$ 不能"看到"未来的位置 $j > i$。这种单向注意力机制使CLM天然适合文本生成任务，模型在训练时即学会了按序生成连贯文本的能力。

代表模型：GPT系列（GPT-3/4）、LLaMA系列、ChatGLM、百川（Baichuan）等。这些模型均采用Decoder-only架构，以CLM为目标函数进行预训练。

2. 掩码语言建模（MLM / 双向编码器）

MLM由Devlin等人于2019年在BERT中提出，其核心思想是随机遮蔽输入序列中一定比例的token（通常为15%），让模型根据双向上下文预测被遮蔽的token。与CLM不同，MLM允许模型同时利用被遮蔽位置左右两侧的上下文信息进行预测。

给定输入序列 $\mathbf{x}$ 和遮蔽位置集合 $\mathcal{M}$，MLM的目标函数为：

$$
\mathcal{L}{\text{MLM}} = \mathbb{E}{\mathbf{x} \sim D} \left[ \sum_{m \in \mathcal{M}} \log P(x_m \mid \mathbf{x}_{\setminus \mathcal{M}}; \theta) \right]
$$

其中 $\mathbf{x}_{\setminus \mathcal{M}}$ 表示未被遮蔽的token集合。在BERT的原始实现中，15%的被选中token中有80%替换为 [MASK] 特殊token，10%替换为随机token，10%保持不变，这一策略迫使模型不依赖于特定的掩码标记，增强了表示的鲁棒性。

MLM的优势在于双向上下文的充分利用，使其在文本理解任务（如文本分类、命名实体识别、问答）上表现出色。然而，由于预训练时存在 [MASK] 标记而微调/推理时不存在，导致预训练与下游任务之间存在轻微的"不一致性"。此外，MLM一次只预测15%的token，预训练效率低于CLM。

代表模型：BERT、RoBERTa、ALBERT、DeBERTa等。

3. 跨度损坏（Span Corruption / Prefix LM）

Span Corruption是T5（Text-to-Text Transfer Transformer）和UL2等模型采用的预训练目标，它将输入序列中的连续片段（span）替换为单个哨兵token（sentinel），然后在解码器中自回归地重建这些被替换的片段。

具体而言，设输入序列中的跨度集合为 ${(s_1, e_1), (s_2, e_2), ...}$，其中 $(s_i, e_i)$ 表示第 $i$ 个跨度的起始和结束位置。这些跨度被替换为哨兵token <extra_id_0>、<extra_id_1> 等，形成损坏的输入文本。目标序列则按顺序排列被替换的跨度内容，同样在前后添加对应的哨兵token。

Span Corruption的目标函数为：

$$
\mathcal{L}{\text{Span}} = \sum{t=1}^{T_{\text{target}}} \log P(y_t \mid y_{<t}, \text{Encoder}(\mathbf{x}_{\text{corrupted}}); \theta)
$$

其中 $\text{Encoder}(\mathbf{x}_{\text{corrupted}})$ 对损坏的输入进行双向编码，解码器则自回归地生成目标跨度内容。这种"编码器双向理解 + 解码器自回归生成"的架构使Span Corruption兼具理解与生成的能力。

Span Corruption的一个重要变体是通用语言模型（Unified Language Learning, UL2）提出的混合去噪目标（Mixture of Denoisers），它同时包含三种去噪模式：
- S-denoiser（短跨度）：类似Span Corruption，跨度长度较短
- R-denoiser（长跨度/极端掩码）：类似CLM，保留前缀、遮蔽后缀
- X-denoiser（极端长跨度）：类似MLM，遮蔽极长跨度

通过混合这三种去噪模式，UL2使单一模型同时具备双向理解和单向生成能力，为后续的Flan-T5等模型奠定了架构基础。

代表模型：T5、FLAN-T5、UL2等。

三种目标函数的系统对比

实践启示：当前大模型时代的主流选择是CLM，原因在于（1）Decoder-only架构的预训练效率最高，所有输入位置都参与损失计算；（2）单向注意力机制天然适配自回归生成，与后续的对话/推理场景无缝衔接；（3）GPT系列的成功验证了这一路线的可扩展性。然而，Span Corruption的变体（如GLM的自回归空白填充）在部分中文模型（如ChatGLM）中仍有应用，其优势在于同时具备理解和生成的灵活性。

2.2.2 训练稳定性与优化策略

大模型预训练是一个高度不稳定的数值优化过程。数十亿至数千亿参数在深层层叠的网络结构中传播梯度，任何微小的数值异常都可能导致训练崩溃（Loss发散为NaN或Inf）。保障训练稳定性需要从梯度控制、数值精度、优化器状态管理等多个维度进行综合设计。

1. 梯度裁剪（Gradient Clipping）

梯度裁剪是防止梯度爆炸的第一道防线。当梯度的 $L_2$ 范数超过预设阈值 $\gamma$ 时，将梯度按比例缩放回阈值范围内：

$$
\hat{\mathbf{g}} = \min\left(1, \frac{\gamma}{|\mathbf{g}|_2}\right) \cdot \mathbf{g}
$$

其中 $\gamma$ 通常设为 1.0。PyTorch中的实现为：

```python
import torch.nn as nn

梯度裁剪（在loss.backward()之后，optimizer.step()之前执行）

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
```text

梯度裁剪的本质是对优化步长进行上限约束。当某个批次数据引入异常大的梯度时，裁剪操作确保参数更新不会偏离稳定区域过远。值得注意的是，梯度裁剪操作应在梯度累积完成之后执行（如果使用了梯度累积），因为累积过程中部分batch的梯度异常可能被其他batch抵消。

2. 混合精度训练（Mixed Precision Training）

混合精度训练是大模型训练的标配技术，其核心思想是使用低精度（FP16或BF16）进行前向传播和反向传播以加速计算并减少显存占用，同时保持FP32精度进行参数更新以保障数值稳定性。

FP16（IEEE 754 half-precision）的格式为1位符号 + 5位指数 + 10位尾数，其可表示范围约为 $[6.1 \times 10^{-5}, 6.5 \times 10^4]$。BF16（BFloat16）由Google Brain提出，格式为1位符号 + 8位指数 + 7位尾数，动态范围与FP32相同（约 $[1.2 \times 10^{-38}, 3.4 \times 10^{38}]$）。

大模型训练更倾向于使用BF16的原因有三：
- 动态范围充足：BF16的动态范围与FP32完全一致，训练过程中不易出现梯度下溢（underflow）或上溢（overflow），无需复杂的梯度缩放管理。
- 数值稳定性：FP16的梯度值若小于 $2^{-24} \approx 5.96 \times 10^{-8}$ 将直接下溢为0，在深层层叠的Transformer中这一问题尤为严重。
- 硬件加速：NVIDIA Ampere架构（A100及以上）原生支持BF16 Tensor Core加速，无需额外计算开销。

PyTorch中的混合精度训练实现：

```python
from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler() # 仅FP16需要，BF16通常不需要

for batch in dataloader:
optimizer.zero_grad()

with autocast(dtype=torch.bfloat16):  # 使用BF16
    outputs = model(**batch)
    loss = outputs.loss

# BF16可以直接反向传播
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()

```text

3. 学习率预热（Warmup）与衰减

大模型的训练通常采用分段学习率调度策略，包括线性预热阶段和余弦衰减阶段：

$$
\eta(t) = \begin{cases} \eta_{\max} \cdot \frac{t}{t_{\text{warmup}}} & 0 \leq t < t_{\text{warmup}} \quad \text{（线性预热）} \ \eta_{\min} + \frac{1}{2}(\eta_{\max} - \eta_{\min})\left(1 + \cos\left(\frac{t - t_{\text{warmup}}}{T - t_{\text{warmup}}}\pi\right)\right) & t \geq t_{\text{warmup}} \quad \text{（余弦衰减）} \end{cases}
$$

Warmup的作用机理：
- 防止早期训练不稳定：训练初始阶段，模型参数随机初始化，各层激活的统计特性尚未稳定。此时若使用大学习率，深层梯度可能迅速放大导致训练崩溃。Warmup通过在前 $t_{\text{warmup}}$ 步线性递增学习率，使优化过程从"保守探索"逐步过渡到"积极学习"。
- Adam优化器的偏差修正：Adam优化器依赖于一阶矩（动量）和二阶矩（自适应学习率）的指数移动平均估计。训练初期这些估计存在较大偏差（偏向0），Warmup阶段的小学习率配合偏差修正（bias correction）有助于稳定早期的参数更新方向。
- 逐步激活深层网络：从优化的动力学角度，Warmup允许浅层先稳定收敛到合理的表示空间，深层网络逐步参与训练，避免了所有层同时大幅更新导致的内部协变量偏移（Internal Covariate Shift）累积。

典型超参数配置：
- Warmup比例：总步数的 1% ~ 10%（如LLaMA-2使用2000步warmup / 总计约100万步 ≈ 0.2%）
- 最大学习率 $\eta_{\max}$：预训练通常 $1 \times 10^{-4}$ ~ $3 \times 10^{-4}$
- 最小学习率 $\eta_{\min}$：通常为 $\eta_{\max}$ 的 10%

4. 权重衰减（Weight Decay）与AdamW

权重衰减是一种L2正则化技术，通过对参数施加衰减惩罚防止过拟合。AdamW（Loshchilov & Hutter, 2019）将权重衰减从梯度更新中解耦，使其不依赖于自适应学习率的缩放：

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

其中 $\lambda$ 是权重衰减系数，通常设为0.01。AdamW相比原始Adam的关键改进在于权重衰减项直接作用于参数本身，而非通过梯度间接施加，这使得正则化效果更加稳定可控。

5. 激活检查点（Activation Checkpointing）

激活检查点是一种"以时间换空间"的技术。在标准的前向传播中，每一层的激活值都需要保存以用于反向传播的梯度计算。对于深层大模型，这些激活值占用的显存远超参数本身。激活检查点的策略是：

• 前向传播时只保存部分关键层的激活值
• 反向传播到某层时，如果需要该层的激活值但已被丢弃，则重新执行该层的前向计算
• 用约 20%~30% 的额外计算时间换取约 50%~70% 的显存节省

PyTorch实现：torch.utils.checkpoint.checkpoint(function, *args)

2.2.3 大规模训练系统（DeepSpeed ZeRO、混合精度）

当模型规模超过单卡显存容量时，分布式训练系统成为必需。DeepSpeed的ZeRO（Zero Redundancy Optimizer）系列技术通过消除数据并行中的冗余状态，实现了超大规模模型的高效训练。

ZeRO的核心思想

在标准的数据并行（Data Parallelism, DP）中，每个GPU都保存一份完整的模型参数、梯度和优化器状态。对于Adam优化器，每个参数的优化器状态包括动量（momentum，4字节）和方差（variance，4字节），即每个参数需要8字节的额外存储。对于10B参数的模型，仅优化器状态就需要约80GB显存——这已超出绝大多数单卡容量。

ZeRO的核心洞察是：数据并行中的每个GPU实际上并不需要同时维护完整的优化器状态。由于每个GPU只处理部分数据，优化器状态可以按数据并行维度分区，只在需要时通过集合通信（All-Gather）获取。

ZeRO的三个阶段

ZeRO-Stage 1：优化器状态分区（Optimizer State Partitioning）

将Adam的优化器状态按数据并行rank进行分区。每个rank只存储自己负责的那部分参数的优化器状态（momentum和variance）。在进行参数更新时，每个rank只需要获取对应分区的梯度即可执行优化步骤。显存节省约4倍（Adam优化器状态占总状态的约3/4）。

ZeRO-Stage 2：优化器状态 + 梯度分区（Optimizer State + Gradient Partitioning）

在Stage 1基础上进一步分区梯度。反向传播完成后，梯度通过Reduce-Scatter操作聚合到对应的rank上，每个rank只保留自己负责分区的梯度。显存节省约8倍。

ZeRO-Stage 3：完全分区（Optimizer State + Gradient + Parameter Partitioning）

在Stage 2基础上进一步分区参数本身。每个rank只存储部分参数，在前向传播时通过All-Gather按需获取完整参数，计算完成后立即释放。Stage 3可以配合CPU/NVMe Offloading，将参数和优化器状态卸载到CPU内存甚至NVMe SSD上，使得单卡即可微调数百亿参数的模型。

ZeRO的显存计算公式

对于参数量为 $\Psi$ 的模型，使用Adam优化器（混合精度训练），各阶段的显存占用为：

• 无ZeRO：$12\Psi$（参数2$\Psi$ + 梯度2$\Psi$ + 优化器状态8$\Psi$）
• ZeRO-1：$4\Psi + \frac{8\Psi}{N_d}$
• ZeRO-2：$2\Psi + \frac{10\Psi}{N_d}$
• ZeRO-3：$\frac{2\Psi}{N_d} + \frac{10\Psi}{N_d} = \frac{12\Psi}{N_d}$（配合Offload可进一步降低）

其中 $N_d$ 是数据并行的GPU数量。

选型建议

DeepSpeed配置示例（ZeRO-3 + Offload）：

json { "bf16": {"enabled": true}, "zero_optimization": { "stage": 3, "offload_optimizer": { "device": "cpu", "pin_memory": true }, "offload_param": { "device": "cpu", "pin_memory": true }, "overlap_comm": true, "contiguous_gradients": true, "reduce_bucket_size": 1e9, "stage3_prefetch_bucket_size": 1e9, "stage3_param_persistence_threshold": 1e6 }, "gradient_accumulation_steps": 4, "gradient_clipping": 1.0, "train_batch_size": "auto", "train_micro_batch_size_per_gpu": "auto" }text

Flash Attention：内存高效的注意力实现

除了分布式优化， attention 机制的内存优化也至关重要。Flash Attention（Dao et al., 2022）通过IO感知的精确注意力算法，将标准注意力的 $O(N^2)$ 显存复杂度降低到 $O(N)$（其中 $N$ 是序列长度），同时保持计算结果的数值精确性（非近似算法）。其核心思想是：

1. 分块计算（Tiling）：将输入序列分块处理，避免一次性存储完整的 $N \times N$ 注意力矩阵
2. 在线softmax（Online Softmax）：在分块计算的同时动态更新softmax的归一化因子
3. 重计算（Recomputation）：反向传播时重新计算前向的注意力权重，而非存储它们

Flash Attention的IO复杂度分析：标准注意力需要 $O(N^2)$ 的HBM（高带宽内存）读写，而Flash Attention仅需 $O(N)$ 级别的HBM访问，将大部分计算保持在高速的SRAM中。对于长序列（如8K、32K、128K），Flash Attention可带来2~10倍的训练加速。

2.3 全量微调与灾难性遗忘

2.3.1 微调的理论基础

微调（Fine-tuning）是将在大规模通用语料上预训练得到的模型参数作为初始化，在特定下游任务的标注数据上继续进行监督训练的过程。从优化的视角来看，微调本质上是在预训练参数 $\theta_{\text{pretrain}}$ 附近寻找一个更适合下游任务的局部最优解 $\theta_{\text{finetune}}$。

微调与预训练的核心区别

微调使用较小学习率的关键原因在于：预训练模型已经处于一个"良好的参数区域"，在通用语言理解上表现优异。过大的学习率可能导致参数跳离这个区域，破坏预训练获得的通用知识。从损失地貌（Loss Landscape）的角度，预训练找到一个宽阔且通用的低谷，微调则是在这个低谷内部寻找更适合特定任务的次优解。

任务适配层（Task-specific Head）设计

微调时通常需要在预训练模型的输出层之上添加任务特定的预测头（Head）：

1. 文本分类：在最后一个token（或 [CLS] 位置）的隐藏状态后接线性分类层 $W_{\text{cls}} \in \mathbb{R}^{d_{\text{hidden}} \times N_{\text{classes}}}$，输出多类分类概率：
   $$P(y \mid \mathbf{x}) = \text{softmax}(W_{\text{cls}} \cdot h_{\text{last}})$$

2. 序列标注（NER）：在每个token位置的隐藏状态上独立接分类头，可选CRF层建模标签间的依赖关系：
   $$\hat{y}_t = \arg\max_y P(y \mid h_t), \quad \forall t \in [1, T]$$

3. 文本生成：直接使用语言模型的LM Head进行自回归生成，微调时只需调整输入格式（如添加指令模板），无需额外的任务头。

全量微调的适用场景

全量微调在以下场景中仍是首选方案：
- 数据量充足：拥有超过1万条高质量标注样本
- 任务分布差异大：下游任务与预训练数据的分布差异显著（如从通用文本到生物医学领域）
- 性能要求极致：可以承受计算成本，追求最佳任务性能
- 硬件资源充裕：拥有足够的GPU显存和计算时间

然而，全量微调的局限性同样明显：需要为每个任务保存完整模型副本（例如7B参数的FP16模型约需14GB存储），且面临严重的灾难性遗忘问题。

2.3.2 灾难性遗忘问题与缓解策略

灾难性遗忘（Catastrophic Forgetting）是神经网络在持续学习（Continual Learning）中面临的核心挑战之一。其表现为：模型在学习新任务后，之前在旧任务上学到的知识被严重干扰甚至完全遗忘。对于大语言模型的微调而言，这一问题尤为突出——经过领域数据微调后，模型在通用能力评测（如MMLU、HellaSwag）上的得分可能下降15%~40%。

灾难性遗忘的成因分析

灾难性遗忘的根本原因在于参数共享机制。神经网络的所有任务共享同一套参数，当使用新任务的梯度更新参数时，这些更新方向不可避免地会干扰预训练阶段已经收敛的参数配置。

从损失地貌的角度分析，预训练在参数空间中找到一个对通用任务"宽广且深"的最优区域，而微调过程则被新任务的梯度引导向一个新的局部最优。由于这个大模型参数空间的高维性和损失地貌的复杂性，从旧最优区域向新最优区域的移动路径几乎必然经过"通用性能下降"的中间区域。

形式化地，设预训练任务的最优参数为 $\theta^$，新任务的目标函数为 $\mathcal{L}{\text{new}}(\theta)$。微调过程最小化 $\mathcal{L}{\text{new}}(\theta)$，但希望同时保持预训练任务的低损失 $\mathcal{L}{\text{old}}(\theta) \approx \mathcal{L}{\text{old}}(\theta^)$。然而，除非两个任务的最优区域高度重叠（这在大模型中几乎不可能），否则单纯最小化 $\mathcal{L}{\text{new}}$ 必然导致 $\mathcal{L}{\text{old}}$ 上升。

缓解策略

1. 降低学习率与限制训练步数

最直接的方法是使用极小的学习率（$10^{-5}$ ~ $5 \times 10^{-5}$，约为预训练的1/10至1/100）和较少的训练轮数（1~3个epoch）。这种方法的直觉是：参数更新幅度越小，对预训练知识结构的破坏就越有限。然而，这种保守策略的效果有限——即使很小的学习率在数万次更新累积后，仍可能导致显著的知识偏移。

2. 数据混合（Data Mixing / Replay）

在微调数据中混入10%~20%的通用预训练数据（或来自原始预训练分布的样本），迫使优化器在更新参数时兼顾新旧任务，寻找对两类数据都"相对友好"的参数更新方向。

设微调数据集为 $D_{\text{new}}$，通用数据为 $D_{\text{general}}$，混合后的训练目标为：

$$
\mathcal{L}{\text{mixed}} = \mathcal{L}(D{\text{new}}; \theta) + \lambda \cdot \mathcal{L}(D_{\text{general}}; \theta)
$$

其中 $\lambda$ 是混合权重，通常取 0.1~0.2。数据混合是实践中最有效的全量微调遗忘缓解手段之一。Amazon Nova Forge的自动化数据混合方案就是这一思路的工程化典范，通过算法自动确定最优的数据混合比例。

3. 参数高效微调（PEFT）—— 最根本的解决方案

PEFT方法（如LoRA、Adapter）通过冻结预训练参数、仅训练少量新增参数，从根本上限制了对预训练知识的干扰范围。由于 $\theta_{\text{pretrain}}$ 保持不变，预训练知识被"锁定"，新增参数仅通过残差连接或并行路径引入任务特定的调整。这是目前实践中缓解灾难性遗忘最有效的方法，将在2.4至2.6节中详细展开。

4. 正则化方法

• EWC（Elastic Weight Consolidation）：基于Fisher信息矩阵度量每个参数对预训练任务的重要性，对重要参数的更新施加二次惩罚：

$$
\mathcal{L}{\text{EWC}} = \mathcal{L}{\text{new}}(\theta) + \lambda \sum_{i} F_i (\theta_i - \theta_i^*)^2
$$

其中 $F_i = \mathbb{E}_{p(x \mid \theta^)}\left[\left(\frac{\partial \log p(x \mid \theta^)}{\partial \theta_i}\right)^2\right]$ 是Fisher信息矩阵的第 $i$ 个对角元素，度量参数 $\theta_i$ 对预训练任务的重要性。

• L2-SPAR（L2正则化）：限制微调参数与预训练参数的距离：

$$
\mathcal{L}{\text{L2}} = \mathcal{L}{\text{new}}(\theta) + \lambda |\theta - \theta^*|_2^2
$$

正则化方法在大模型微调中的实际效果通常不如PEFT方法直接有效，但在某些需要全量微调的场景中仍可作为辅助手段。

5. 渐进式学习（Progressive Learning）

从易到难逐步增加任务难度，让模型先适应与预训练分布接近的简单任务，再逐步过渡到复杂的领域任务。这种渐进式微调策略模拟了人类学习的过程，有助于参数空间中平滑的知识迁移路径。

2.4 参数高效微调：LoRA

2.4.1 低秩适配的数学原理（完整推导）

LoRA（Low-Rank Adaptation）由Hu等人于2022年在ICLR上发表，是当前最流行、生态最成熟的参数高效微调方法。LoRA的核心思想源于一个关键假设：微调过程中的权重更新具有低本征秩（low intrinsic rank），即有效的参数更新主要发生在低维子空间中。

核心假设与理论动机

Aghajanyan等人（2020）在"Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning"一文中证明了预训练语言模型的微调具有极低的本征维度——即使将模型投影到一个远小于原始参数空间的低维子空间中（维度 $d \ll D$，其中 $D$ 是模型总参数），仍可达到接近全量微调的性能。这一发现为LoRA的低秩假设提供了坚实的理论基础。

从奇异值分解（SVD）的视角理解，对预训练权重矩阵 $W_0 \in \mathbb{R}^{d \times k}$ 进行SVD分解：

$$
W_0 = U \Sigma V^T = \sum_{i=1}^{\min(d,k)} \sigma_i u_i v_i^T
$$

其中 $\sigma_1 \geq \sigma_2 \geq ... \geq \sigma_{\min(d,k)} \geq 0$ 是奇异值。研究表明，预训练模型的奇异值谱通常呈快速衰减分布——前几个奇异值占据了绝大部分"能量"。这意味着权重矩阵的有效信息集中在少数几个主方向上，而低秩更新恰好捕捉这些最重要的方向。

LoRA的前向传播公式

对于预训练权重矩阵 $W_0 \in \mathbb{R}^{d \times k}$，标准的前向传播为 $h = W_0 x$。LoRA在保持 $W_0$ 冻结的前提下，引入一个低秩的增量矩阵 $\Delta W$：

$$
h = W_0 x + \Delta W x = W_0 x + BA x
$$

其中：
- $W_0 \in \mathbb{R}^{d \times k}$：预训练权重矩阵（训练时冻结，不计算梯度）
- $B \in \mathbb{R}^{d \times r}$：可训练的低秩矩阵
- $A \in \mathbb{R}^{r \times k}$：可训练的低秩矩阵
- $r \ll \min(d, k)$：LoRA的秩（rank），典型值 8~64
- $\alpha$：缩放因子（scaling factor），实际控制更新幅度的超参数

完整的前向传播公式（含缩放因子）：

$$
h = W_0 x + \frac{\alpha}{r} BA x
$$

缩放因子 $\frac{\alpha}{r}$ 的作用是控制LoRA更新相对于预训练输出的幅度。当 $r$ 变化时，通过固定 $\alpha$ 可以保持更新幅度的相对稳定。

初始化策略的设计原理

LoRA采用特定的初始化策略以确保训练初期的行为一致性：

• 矩阵 $A$：使用Kaiming Uniform初始化（或标准正态分布 $\mathcal{N}(0, \sigma^2)$）
• 矩阵 $B$：初始化为全零矩阵

这种设计的精妙之处在于：

$$
\Delta W = B A = \mathbf{0} \cdot A = \mathbf{0} \quad \text{（初始时）}
$$

因此，训练开始时 $h = W_0 x + \frac{\alpha}{r} \cdot \mathbf{0} \cdot x = W_0 x$，输出与预训练模型完全一致。随着训练进行，梯度逐步更新 $A$ 和 $B$，低秩更新 $\Delta W = BA$ 逐渐非零，模型在保持预训练能力的基础上学习任务特定的知识。这种"从零开始"的渐进式学习有效避免了初始化时对预训练知识的突然干扰。

可训练参数量分析

对于原始权重矩阵 $W_0 \in \mathbb{R}^{d \times k}$：

• 原始参数量：$d \times k$
• LoRA参数量：$d \times r + r \times k = r(d + k)$
• 参数节省比例：

$$
\rho = \frac{r(d + k)}{dk} = \frac{r}{k} + \frac{r}{d}
$$

当 $d \approx k$（Transformer中通常成立）时：

$$
\rho \approx \frac{2r}{d}
$$

以一个典型的7B参数模型为例，假设隐藏维度 $d = 4096$，LoRA秩 $r = 8$：

$$
\rho \approx \frac{2 \times 8}{4096} = \frac{16}{4096} \approx 0.39\%
$$

即仅需约0.39%的参数即可表达有效的任务适配。

完整梯度推导

LoRA的前向传播可写为：

$$
h = W_0 x + s \cdot x A^T B^T
$$

其中 $s = \frac{\alpha}{r}$ 是缩放因子。设上游梯度为 $\frac{\partial \mathcal{L}}{\partial h} = g \in \mathbb{R}^{1 \times d}$，则对各参数的梯度为：

1. 对 $B$ 的梯度：

令 $h_{\text{LoRA}} = s \cdot x A^T B^T$，则：

$$
\frac{\partial \mathcal{L}}{\partial B} = s \cdot (x A^T)^T g = s \cdot A x^T g \quad \in \mathbb{R}^{r \times d}
$$

更精确地，使用矩阵微积分：

$$
\frac{\partial \mathcal{L}}{\partial B} = s \cdot A x^T \cdot g = s \cdot A (g^T x)^T
$$

在PyTorch中（batch形式），设 $X \in \mathbb{R}^{b \times k}$ 为输入batch：

$$
\frac{\partial \mathcal{L}}{\partial B} = \frac{s}{b} \sum_{i=1}^{b} A x_i^T g_i = \frac{s}{b} A X^T G
$$

其中 $G \in \mathbb{R}^{b \times d}$ 是batch中每个样本的上游梯度。

2. 对 $A$ 的梯度：

$$
\frac{\partial \mathcal{L}}{\partial A} = s \cdot x^T (g B) \quad \in \mathbb{R}^{k \times r}
$$

Batch形式：

$$
\frac{\partial \mathcal{L}}{\partial A} = \frac{s}{b} X^T (G B)
$$

3. 对输入 $x$ 的梯度（传递给上层）：

$$
\frac{\partial \mathcal{L}}{\partial x} = g W_0 + s \cdot (g B) A \quad \in \mathbb{R}^{1 \times k}
$$

第一项 $g W_0$ 是预训练路径的梯度，第二项 $s \cdot (g B) A$ 是LoRA路径的梯度。注意预训练权重 $W_0$ 不参与反向传播，$\frac{\partial \mathcal{L}}{\partial W_0} = 0$。

复杂度分析

• 前向传播额外计算：$O(k \cdot r + r \cdot d) = O(r(k + d))$
• 原始前向传播计算：$O(k \cdot d)$
• 计算开销比例：$\frac{r(k+d)}{kd} \approx \frac{2r}{d}$（与参数比例相同）

当 $r \ll d$ 时，LoRA引入的计算和存储开销都可忽略不计。

为什么低秩更新有效？——多视角解释

1. 内在低维度假说：预训练模型在高度过参数化的空间中学习，微调所需的有效参数更新仅发生在一个低维子空间中。LoRA通过显式地将更新限制在低秩空间中，恰好契合了这一结构特性。

2. 主成分分析（PCA）视角：将微调所需的完整权重更新 $\Delta W_{\text{full}}$ 视为一个矩阵，其SVD分解的前 $r$ 个主成分包含了最重要的更新方向。LoRA的可训练矩阵 $B$ 和 $A$ 恰好学习这前 $r$ 个主成分所张成的子空间。

3. 信息瓶颈（Information Bottleneck）理论：低秩约束充当了信息瓶颈，迫使模型只学习对下游任务最重要的信息，过滤掉噪声和不相关的参数变化，这反而提升了泛化能力。

2.4.2 LoRA的实现与优化

PyTorch完整实现

以下给出LoRA的完整PyTorch实现，包括核心LoRA层、应用到现有线性层的包装器、以及权重合并功能：

```python
import torch
import torch.nn as nn
import math

class LoRALayer(nn.Module):
"""
LoRA核心层实现。

对输入进行低秩变换: output = dropout(x) @ A @ B * scaling
其中 A.shape = (in_features, rank), B.shape = (rank, out_features)
"""
def __init__(self, in_features: int, out_features: int, 
             rank: int = 8, lora_alpha: int = 16, dropout: float = 0.0):
    super().__init__()
    self.rank = rank
    self.lora_alpha = lora_alpha
    self.scaling = lora_alpha / rank

    # 可训练的低秩矩阵
    self.lora_A = nn.Parameter(torch.zeros(in_features, rank))
    self.lora_B = nn.Parameter(torch.zeros(rank, out_features))
    self.dropout = nn.Dropout(dropout) if dropout > 0 else nn.Identity()

    # 初始化：A用Kaiming初始化，B用零初始化
    # 保证训练开始时 LoRA 输出为0
    nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
    nn.init.zeros_(self.lora_B)

def forward(self, x: torch.Tensor) -> torch.Tensor:
    # x @ A @ B * scaling
    # 输入x: (batch, seq_len, in_features)
    return self.dropout(x) @ self.lora_A @ self.lora_B * self.scaling

class LinearWithLoRA(nn.Module):
"""
将LoRA应用到现有线性层的包装器。
前向传播: output = base_layer(x) + lora(x)
"""
def init(self, linear_layer: nn.Linear, rank: int = 8,
lora_alpha: int = 16, dropout: float = 0.0):
super().init()
self.base_layer = linear_layer
self.lora = LoRALayer(
linear_layer.in_features,
linear_layer.out_features,
rank=rank,
lora_alpha=lora_alpha,
dropout=dropout
)
# 冻结基础权重（关键！）
for param in self.base_layer.parameters():
param.requires_grad = False

def forward(self, x: torch.Tensor) -> torch.Tensor:
    # 原始输出 + LoRA增量
    return self.base_layer(x) + self.lora(x)

def merge_weights(self) -> nn.Linear:
    """
    训练完成后将LoRA权重合并到基础权重中。
    合并后推理无额外开销。

    W_merged = W_0 + (B @ A)^T * scaling
    """
    # 计算增量权重: (A @ B)^T * scaling
    delta_W = (self.lora.lora_A @ self.lora.lora_B).T * self.lora.scaling
    # 合并到基础权重
    self.base_layer.weight.data += delta_W.T
    return self.base_layer

def apply_lora_to_model(model, target_modules=["q_proj", "v_proj"],
rank=8, lora_alpha=16, dropout=0.05):
"""
为模型中指定的模块应用LoRA。

Args:
    model: 预训练模型
    target_modules: 要应用LoRA的模块名称列表
    rank: LoRA秩
    lora_alpha: 缩放因子
    dropout: LoRA dropout率
"""
lora_config = {
    "q_proj": ["q_proj"],
    "k_proj": ["k_proj"],
    "v_proj": ["v_proj"],
    "o_proj": ["o_proj"],
    "gate_proj": ["gate_proj"],
    "up_proj": ["up_proj"],
    "down_proj": ["down_proj"],
}

for name, module in model.named_modules():
    if isinstance(module, nn.Linear) and any(
        target in name for target in target_modules
    ):
        # 获取父模块和当前模块名
        parent_name = ".".join(name.split(".")[:-1])
        child_name = name.split(".")[-1]
        parent = model.get_submodule(parent_name) if parent_name else model

        # 替换为LoRA包装层
        lora_layer = LinearWithLoRA(module, rank=rank, 
                                     lora_alpha=lora_alpha, dropout=dropout)
        setattr(parent, child_name, lora_layer)

return model

def print_trainable_parameters(model):
"""打印可训练参数统计信息"""
trainable_params = 0
all_params = 0
for _, param in model.named_parameters():
all_params += param.numel()
if param.requires_grad:
trainable_params += param.numel()
print(f"可训练参数: {trainable_params:,} || "
f"总参数: {all_params:,} || "
f"可训练比例: {100 * trainable_params / all_params:.4f}%")
```text

LoRA应用位置的选择策略

LoRA可以应用于Transformer中的任意线性层。实践中最常见的应用位置是Attention层的投影矩阵：

为什么通常只对 $W_Q$ 和 $W_V$ 添加LoRA？

Hu等人（2022）在原始论文中的实验表明，仅对 $W_Q$（Query投影）和 $W_V$（Value投影）应用LoRA即可达到接近对所有矩阵应用LoRA的效果。这一发现的深层原因在于Attention机制的功能分工：

• Query矩阵 $W_Q$：决定"查询什么信息"——任务适配需要调整关注的目标
• Value矩阵 $W_V$：决定"返回什么信息"——任务适配需要调整输出的语义内容
• Key矩阵 $W_K$：主要负责相似度计算的参考标准，任务间差异较小
• Output矩阵 $W_O$：聚合注意力头的输出，其更新收益递减

因此，$W_Q$ 和 $W_V$ 是任务适配中最具信息量的参数矩阵，低秩更新在这两个矩阵上获得了最高的"投入产出比"。

Hugging Face PEFT库的使用

在实践中，推荐使用Hugging Face的PEFT库来简化LoRA的应用：

```python
from transformers import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model, TaskType

加载预训练模型

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")

LoRA配置

lora_config = LoraConfig(
r=16, # LoRA秩
lora_alpha=32, # 缩放因子
target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
lora_dropout=0.05, # Dropout率
bias="none", # 不训练bias
task_type=TaskType.CAUSAL_LM, # 任务类型
)

应用LoRA

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

输出: trainable params: 33,554,432 || all params: 6,771,970,048

|| trainable%: 0.4955

```text

2.4.3 秩的选择策略与理论分析

秩 $r$ 的选择

秩 $r$ 是LoRA中最重要的超参数，它决定了低秩更新的表达能力。从理论上看，$r$ 的选择涉及一个权衡：

• 较小的 $r$：参数效率高，但可能表达能力不足，无法捕捉复杂的任务适配
• 较大的 $r$：表达能力强，接近全量微调，但可能引入过拟合风险

秩选择的实践策略：

1. 从 $r=8$ 开始：这是社区验证的通用初始值，在大多数任务上表现良好
2. 逐步增大：若验证集性能明显不足，逐步增大到16、32
3. 监控过拟合：增大 $r$ 后若验证集性能下降而训练集继续提升，说明过拟合，应配合增大dropout或增加数据
4. 任务复杂度匹配：需要学习大量新知识的任务（如领域迁移）需要更大的 $r$

缩放因子 $\alpha$ 的选择

缩放因子 $\alpha$ 与秩 $r$ 的比值 $\frac{\alpha}{r}$ 实际控制LoRA更新的幅度：

LoRA原始论文的推荐策略是固定 $\alpha$（如 $\alpha=16$），通过调整 $r$ 来控制模型复杂度。社区实践经验则倾向于固定 $\alpha/r = 2$ 的比例，这样在增大 $r$ 时更新幅度保持稳定。

超参数搜索空间

LoRA与SVD的理论联系

将训练完成的LoRA更新矩阵 $\Delta W = BA$ 进行SVD分解：

$$
\Delta W = U' \Sigma' V'^T
$$

实验观察发现（Hu et al., 2022），$\Delta W$ 的奇异值谱与完整权重更新 $\Delta W_{\text{full}}$ 的奇异值谱在前 $r$ 个分量上高度吻合，但在后续分量上 $\Delta W$ 自然衰减为零（因为秩最多为 $r$）。这说明LoRA成功地学习了完整权重更新中最重要的方向，同时自动丢弃了噪声方向。

此外，$\Delta W$ 与预训练权重 $W_0$ 的 top-$r$ 奇异向量通常只有较小的重叠（重叠度约10%~30%），这意味着LoRA学习到的更新方向主要位于预训练权重主方向的正交补空间中。这一发现解释了为什么LoRA能有效引入新任务知识而不破坏预训练知识——它在预训练知识"覆盖不足"的子空间中进行补充学习。

前沿改进：AdaLoRA与DoRA

AdaLoRA（Zhang et al., 2023）提出自适应秩分配策略，将增量矩阵直接参数化为SVD形式 $\Delta W = P \Lambda Q$，并通过重要性评分动态剪枝不重要的奇异值组件，在固定参数预算下将更多参数分配给重要的层。

DoRA（Liu et al., 2024）将权重显式分解为幅度（magnitude）和方向（direction）两个组件：

$$
W' = m \cdot \frac{W_0 + BA}{|W_0 + BA|_c}
$$

其中 $m$ 是可训练的幅度向量，$BA$ 控制方向更新。DoRA在学习模式上更接近全量微调，通常一致性地优于标准LoRA。

2.5 QLoRA：量化+低秩适配

2.5.1 4-bit量化原理（NF4、双重量化）

QLoRA（Quantized LoRA）由Dettmers等人于2023年在NeurIPS上发表，它在LoRA的基础上引入了一系列内存优化技术，使得在单张消费级GPU（如24GB显存的RTX 3090/4090）上即可微调数十亿参数的大模型。QLoRA的三大核心技术突破是：4-bit NormalFloat量化（NF4）、双重量化（Double Quantization）和分页优化器（Paged Optimizer）。

量化基础概念

量化（Quantization）是将模型权重从高精度浮点数（通常是FP16或FP32）转换为低精度表示的过程。设原始权重为 $w \in \mathbb{R}$，量化后的值为 $\hat{w}$，量化过程一般包括三个步骤：

1. 确定缩放范围：$[w_{\min}, w_{\max}]$
2. 计算缩放因子：$s = \frac{w_{\max} - w_{\min}}{2^b - 1}$，其中 $b$ 是目标比特数
3. 量化：$\hat{w} = \text{round}\left(\frac{w - z}{s}\right)$，其中 $z$ 是零点（zero-point）

反量化（Dequantization）过程为：$w_{\text{dequant}} = \hat{w} \cdot s + z$

分块量化（Block-wise Quantization）

直接将整个权重矩阵一次性量化会产生较大的精度损失，因为不同区域的权重分布可能差异很大。QLoRA采用分块量化策略：将权重矩阵划分为大小为64的块（block），每个块独立进行量化，拥有自己的缩放因子和零点。

对于第 $i$ 个块 $W_{\text{block}}^{(i)}$：

$$
s^{(i)} = \frac{\max(W_{\text{block}}^{(i)}) - \min(W_{\text{block}}^{(i)})}{2^b - 1}, \quad z^{(i)} = \min(W_{\text{block}}^{(i)})
$$

分块量化虽然增加了存储缩放因子的开销（每64个参数需要一个FP32缩放因子），但显著提高了量化精度，因为每个块可以根据自身的局部分布进行自适应量化。

4-bit NormalFloat（NF4）—— 针对正态分布的最优量化

NF4是QLoRA的核心创新之一。其设计基于一个关键观察：神经网络预训练后的权重通常近似服从零均值正态分布 $W \sim \mathcal{N}(0, \sigma^2)$。

传统均匀量化（如INT4）将量化级别均匀分布在表示范围内。然而，对于正态分布，大部分概率质量集中在均值附近，均匀量化会浪费大量量化级别在概率极低的尾部区域，而中心区域（概率最高）的量化精度却不足。

NF4的解决方案是将量化级别放置在正态分布的等分位数点（quantiles）上：

$$
q_i = F^{-1}_W\left(\frac{2i + 1}{2^{b+1}}\right), \quad i = 0, 1, ..., 2^b - 1
$$

其中 $F^{-1}_W$ 是标准正态分布的逆累积分布函数（inverse CDF），$b=4$ 是位数（共 $2^4 = 16$ 个量化级别）。这样设计的直觉是：每个量化区间包含的概率质量相等，因此在期望意义下量化误差最小。

NF4量化级别的具体数值（标准化后的正态分布）为：

$$
\text{NF4} = {-1.0, -0.696, -0.525, -0.394, -0.284, -0.184, -0.091, 0.0, 0.079, 0.160, 0.246, 0.338, 0.440, 0.562, 0.723, 1.0}
$$

实际量化时，NF4的值按以下流程确定：

1. 估计权重的标准差 $\hat{\sigma}$
2. 将NF4的标准化值乘以 $\hat{\sigma}$ 得到实际量化级别：$q_i^{\text{actual}} = q_i \cdot \hat{\sigma}$
3. 对每个权重找到最近的量化级别进行映射

NF4 vs INT4 / FP4 的对比

实验表明，在相同的4-bit存储下，NF4的量化误差（以均方误差衡量）比INT4低约30%~50%，这使得QLoRA在极低比特率下仍能保持较高的模型质量。

双重量化（Double Quantization）

分块量化引入了一个隐形成本：每个块需要存储一个FP32的缩放因子 $s^{(i)}$。对于64参数的块，这意味着每64个权重需要一个32位的缩放因子，额外开销为 $32/64 = 0.5$ bits/参数——将有效比特率从4-bit提高到4.5-bit。

双重量化通过对缩放因子进行二次量化来消除这一开销：

• 第一层量化：FP32权重 $\rightarrow$ NF4（每64参数一个FP32缩放因子 $s^{(i)}$）
• 第二层量化：FP32缩放因子 $s^{(i)}$ $\rightarrow$ 8-bit（每256个缩放因子一个FP32全局缩放因子 $s_{\text{global}}$）

双重量化的额外开销计算：

• 无双重化的开销：$0.5$ bits/参数
• 双重化后的开销：$\frac{8 \text{ bits}}{64 \text{ params}} + \frac{32 \text{ bits}}{64 \times 256 \text{ params}} = 0.125 + 0.002 = 0.127$ bits/参数

通过双重量化，缩放因子的存储开销从0.5 bits/参数降至约0.127 bits/参数，QLoRA的总有效比特率约为4.13 bits/参数（vs FP16的16 bits）。

QLoRA显存节省分析

显存节省的比例随模型规模增大而提升，这是因为QLoRA的固定开销（优化器状态、激活值、LoRA参数）在总显存中的占比随模型增大而降低。

2.5.2 分页优化器与训练稳定性

分页优化器（Paged Optimizer）

分页优化器是QLoRA的第三项关键技术，它利用NVIDIA统一内存（Unified Memory）自动在GPU显存和CPU主存之间进行页面交换，防止训练过程中因显存不足（OOM）而崩溃。

其工作原理类似于操作系统的虚拟内存机制：

1. 正常状态：优化器状态（Adam的momentum和variance）存储在GPU显存中
2. 显存压力增大：当GPU显存接近上限时，系统将不活跃的优化器状态"页"自动换出（offload）到CPU内存
3. 需要时换入：当对应参数需要更新时，优化器状态页被重新加载回GPU显存
4. 自动管理：整个过程由CUDA统一内存自动管理，无需手动干预

分页优化器使得QLoRA可以在GPU显存远低于模型参数所需空间的情况下稳定训练。例如，使用24GB显存的消费级GPU即可微调70B参数的模型，其中大部分优化器状态被透明地存储在CPU内存中。

QLoRA的完整训练流程

QLoRA训练的完整流程如下：

1. 加载预训练模型：将FP16/BF16精度的预训练权重量化为4-bit NF4格式
2. 冻结量化权重：量化后的权重完全冻结，不计算梯度
3. 添加LoRA适配器：在目标层上添加FP16精度的LoRA适配器（$A$ 和 $B$ 矩阵）
4. 前向传播：
5. 从4-bit权重反量化为FP16/BF16进行计算
6. 通过冻结的量化权重和可训练的LoRA适配器计算输出
7. 反向传播：
8. 量化权重不计算梯度（requires_grad=False）
9. 仅LoRA适配器的参数接收梯度并更新
10. 优化器状态管理：分页优化器自动处理优化器状态的GPU/CPU交换

```python
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import torch

Step 1: 4-bit量化配置

bnb_config = BitsAndBytesConfig(
load_in_4bit=True, # 启用4-bit加载
bnb_4bit_quant_type="nf4", # NF4量化
bnb_4bit_compute_dtype=torch.bfloat16, # 计算用BF16
bnb_4bit_use_double_quant=True, # 启用双重量化
)

Step 2: 加载量化模型

model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-7b-hf",
quantization_config=bnb_config,
device_map="auto", # 自动分配层到GPU/CPU
torch_dtype=torch.bfloat16,
)

Step 3: 准备模型用于训练

梯度检查点、输入梯度启用、归一化层32位精度

model = prepare_model_for_kbit_training(model)

Step 4: LoRA配置

lora_config = LoraConfig(
r=64, # QLoRA推荐更大的秩
lora_alpha=16,
target_modules=["q_proj", "v_proj", "k_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_dropout=0.1,
bias="none",
task_type="CAUSAL_LM",
)

Step 5: 应用LoRA

model = get_peft_model(model, lora_config)

Step 6: 训练参数

from transformers import TrainingArguments

training_args = TrainingArguments(
output_dir="./qlora_output",
per_device_train_batch_size=1,
gradient_accumulation_steps=4,
num_train_epochs=3,
learning_rate=2e-4, # QLoRA推荐学习率
warmup_ratio=0.03,
lr_scheduler_type="cosine",
logging_steps=10,
save_strategy="epoch",
fp16=False, # QLoRA用BF16计算
bf16=True,
optim="paged_adamw_8bit", # 分页优化器！
gradient_checkpointing=True, # 激活检查点
group_by_length=True, # 相似长度样本分组，提升效率
)
```text

QLoRA的关键训练超参数

QLoRA的推理与权重合并

训练完成后，LoRA适配器可以与反量化后的模型权重合并，合并后的模型恢复为FP16精度，推理时无任何额外开销：

$$
W_{\text{merged}} = \text{dequantize}(W_{\text{NF4}}) + \frac{\alpha}{r} BA
$$

QLoRA训练出的LoRA适配器也可以在不合并的情况下用于4-bit推理（通过bitsandbytes库），但推理速度会慢于FP16。在大多数部署场景中，推荐将适配器合并到反量化后的模型中进行推理。

```python
from peft import PeftModel

加载基础模型（4-bit量化）

base_model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-7b-hf",
quantization_config=bnb_config,
device_map="auto"
)

加载训练好的LoRA适配器

model = PeftModel.from_pretrained(base_model, "./qlora_output/checkpoint-final")

合并权重并卸载量化

model = model.merge_and_unload() # 合并后模型为FP16
```text

2.6 其他PEFT方法

除了LoRA及其量化变体QLoRA之外，参数高效微调领域还发展出了多种具有不同设计理念的方法。本节介绍三种具有代表性的PEFT方法：Adapter（瓶颈层适配）、Prefix Tuning / Prompt Tuning（软提示方法）以及P-Tuning v2（深层提示调优）。

2.6.1 Adapter：瓶颈层适配

Adapter的结构与公式

Adapter由Houlsby等人于2019年在ICML上提出，是一种在Transformer层间插入小型神经网络模块（瓶颈层）的方法。其核心结构为：

$$
h' = h + W_{\text{up}} \cdot \sigma(W_{\text{down}} \cdot h)
$$

其中：
- $h \in \mathbb{R}^d$：输入隐藏状态
- $W_{\text{down}} \in \mathbb{R}^{d \times m}$：下投影矩阵（$m \ll d$，通常 $m = d/4$ 或 $d/8$）
- $\sigma$：非线性激活函数（通常为GELU或ReLU）
- $W_{\text{up}} \in \mathbb{R}^{m \times d}$：上投影矩阵
- 残差连接 $h + \cdot$ 确保初始化时Adapter的输出接近 $h$，不破坏预训练行为

插入位置：Houlsby Adapter在每个Transformer块的两个子层后各插入一个Adapter（一个在多头注意力后，一个在FFN后）。Pfeiffer变体则只在FFN后插入一个Adapter，进一步减少参数量。

可训练参数量：每个Adapter的可训练参数为 $2 \times m \times d$（下投影 + 上投影，忽略bias）。对于Houlsby配置（每层两个Adapter），总可训练参数约为 $4 \times L \times m \times d$，其中 $L$ 是层数。

Adapter的核心特性

1. 模块化设计：每个任务训练独立的Adapter模块，推理时只需切换不同的Adapter即可适配不同任务，无需修改基础模型
2. 顺序计算开销：Adapter增加了网络的深度（额外的前向传播层），引入不可避免的推理延迟
3. 近零初始化：由于残差连接的存在，初始化时 Adapter 的输出接近于零，训练初期的模型行为与预训练模型一致

```python
class AdapterLayer(nn.Module):
"""Adapter瓶颈层实现"""
def init(self, hidden_dim: int, bottleneck_dim: int):
super().init()
self.down_proj = nn.Linear(hidden_dim, bottleneck_dim)
self.activation = nn.GELU()
self.up_proj = nn.Linear(bottleneck_dim, hidden_dim)

    # 初始化：接近零输出
    nn.init.xavier_uniform_(self.down_proj.weight)
    nn.init.zeros_(self.up_proj.weight)
    nn.init.zeros_(self.up_proj.bias)

def forward(self, x: torch.Tensor) -> torch.Tensor:
    # h' = h + W_up * GELU(W_down * h)
    return x + self.up_proj(self.activation(self.down_proj(x)))

```text

Adapter vs LoRA 的系统对比

Adapter在多任务部署场景中具有独特优势——不同任务的Adapter模块可以独立存储和动态切换，而LoRA需要在推理前合并权重或使用支持多LoRA的推理框架。

2.6.2 Prefix Tuning / Prompt Tuning

Prefix Tuning和Prompt Tuning属于软提示（Soft Prompt）方法家族，其核心思想是：不修改模型的任何内部参数，而是在输入序列中注入可学习的连续向量（"软提示"），引导模型生成期望的输出。

Prefix Tuning（Li & Liang, 2021）

Prefix Tuning在Transformer的每一层的Key和Value序列前添加可学习的前缀向量：

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

其中：

$$
K' = [P_k; X W_k], \quad V' = [P_v; X W_v]
$$

• $P_k, P_v \in \mathbb{R}^{l_p \times d}$ 是可学习的前缀向量
• $[;]$ 表示序列拼接操作
• $l_p$ 是前缀长度，通常为10~100

Prefix Tuning的关键设计是在每一层（而非仅在输入层）都添加前缀，这使得软提示可以直接影响深层的注意力模式。此外，原始论文使用了一个MLP重参数化技巧：训练时用一个小型MLP将低维向量映射为前缀，推理时缓存MLP的输出以避免推理延迟。

Prompt Tuning（Lester et al., 2021）

Prompt Tuning是Prefix Tuning的简化版本，只在输入嵌入层添加可学习的提示向量：

$$
h = M([p_1; p_2; ...; p_{l_p}; e(x_1); e(x_2); ...; e(x_n)])
$$

其中 $p_1, ..., p_{l_p} \in \mathbb{R}^d$ 是可学习的提示嵌入，$e(x_i)$ 是输入token的嵌入向量，$M$ 是预训练模型。

Prompt Tuning的可训练参数极少——例如100个提示token $\times$ 768维 ≈ 76,800参数，仅占T5-XXL模型（110亿参数）的约0.0007%。Prompt Tuning的核心发现是：随着模型规模增大，Prompt Tuning的效果迅速接近全量微调。在T5-XXL（11B）上，Prompt Tuning已达到与全量微调相当的性能。但在较小模型上，Prompt Tuning的效果明显较差——这是因为小模型的表示空间不够丰富，难以从少量软提示向量中学习到有效的任务表示。

```python
class PromptTuning(nn.Module):
"""Prompt Tuning实现"""
def init(self, num_tokens: int, token_dim: int):
super().init()
self.soft_prompt = nn.Parameter(torch.randn(num_tokens, token_dim))

def forward(self, input_embeds: torch.Tensor) -> torch.Tensor:
    # 在输入嵌入前拼接软提示
    batch_size = input_embeds.shape[0]
    soft_prompt_embeds = self.soft_prompt.unsqueeze(0).expand(
        batch_size, -1, -1
    )
    return torch.cat([soft_prompt_embeds, input_embeds], dim=1)

```text

2.6.3 P-Tuning v2与Deep Prompt Tuning

P-Tuning v2（Liu et al., 2022）

P-Tuning v2针对P-Tuning v1和Prompt Tuning的不足进行了系统性改进，核心创新包括：

1. 深层提示调优（Deep Prompt Tuning）：与Prefix Tuning类似，在每一层的输入都插入可学习的提示向量。这一设计使得提示信息可以直接影响深层的Transformer表示，而非仅通过层层传播间接影响。

2. 去除重参数化：P-Tuning v1使用LSTM/MLP编码器生成提示向量，P-Tuning v2发现直接优化提示向量（去除重参数化）效果更好且更简单。

3. 使用分类头：不再使用P-Tuning v1中的verbalizer（将标签映射为词汇表中单词的设计），改用随机初始化的分类头（与标准微调一致），这提升了方法的通用性。

4. 多任务学习支持：提示向量可以在多任务数据上预训练，然后迁移到下游任务。

P-Tuning v2的前向传播公式（第 $l$ 层）：

$$
h^{(l)} = \text{TransformerLayer}^{(l)}([P^{(l)}; h^{(l-1)}])
$$

其中 $P^{(l)} \in \mathbb{R}^{l_p \times d}$ 是第 $l$ 层的可学习提示向量，$[;]$ 表示序列拼接。

三种软提示方法的系统对比

软提示方法的局限

1. 模型规模依赖：Prompt Tuning在小型模型上效果不佳，严重依赖大模型的丰富表示空间
2. 推理延迟：Prefix Tuning和P-Tuning v2在每一层都增加了序列长度，略微增加了注意力计算的复杂度
3. 长度限制：前缀长度是固定超参数，可能需要针对不同任务进行调优
4. 与生成任务的兼容性：软提示方法最初为分类/理解任务设计，在纯生成任务上的效果不如LoRA稳定

DoRA：权重分解低秩适配（前沿方法）

DoRA（Liu et al., 2024）虽然属于LoRA家族的改进，但其核心思想与上述方法有本质不同，值得单独介绍。DoRA发现LoRA和全量微调（FT）在学习模式上存在差异——FT倾向于同时独立地更新权重的幅度（magnitude）和方向（direction），而LoRA的方向更新会间接影响幅度，导致学习动态不够灵活。

DoRA将权重显式分解为幅度和方向两个组件：

$$
W = \mathbf{m} \cdot \frac{V}{|V|_c}
$$

其中 $\mathbf{m} \in \mathbb{R}^{1 \times k}$ 是列-wise幅度向量，$V$ 是方向矩阵，$|\cdot|_c$ 表示列向范数。

DoRA的微分公式为：

$$
W' = \mathbf{m} \cdot \frac{W_0 + BA}{|W_0 + BA|_c}
$$

• $\mathbf{m}$：可训练的幅度向量（新增少量参数）
• $BA$：LoRA式的低秩方向更新
• 方向分量被归一化，幅度分量独立学习

DoRA的优势在于：（1）学习模式更接近全量微调，幅度和方向独立控制；（2）训练更稳定；（3）在多项任务上 consistently 优于标准LoRA。训练完成后，DoRA的更新同样可以合并回原权重，推理无额外开销。

2.7 指令微调（SFT）

2.7.1 指令数据的构建与组织

指令微调（Instruction Tuning / Supervised Fine-Tuning, SFT）是将预训练基础模型转化为能够遵循自然语言指令、进行有用且安全对话的AI助手的关键步骤。与针对单一任务的普通微调不同，指令微调的核心目标是让模型学会"如何遵循指令"这一元能力，从而能够泛化到训练时未见过的指令类型。

指令数据的标准格式

指令数据的基本单元是一个三元组 ${\text{instruction}, \text{input}, \text{output}}$：

json { "instruction": "请将以下英文翻译成中文", "input": "The rapid advancement of artificial intelligence is transforming every aspect of our society.", "output": "人工智能的快速发展正在改变我们社会的方方面面。" }text

其中：
- instruction：描述要执行的任务（自然语言指令）
- input：任务的输入内容（可选，部分任务如开放式生成可能为空）
- output：期望的模型输出（即标注的参考答案）

SFT数据的构建流程

1. 数据收集：
2. 现成数据集：FLAN Collection（整合了1800+ NLP任务）、Alpaca（52K指令数据，由Self-Instruct方法生成）、ShareGPT（真实用户与ChatGPT的对话数据）、Dolly（人工编写的15K指令数据）
3. 自我指令（Self-Instruct）：使用GPT-4等强模型自动生成指令数据。具体流程为：（a）用种子人工编写的指令作为示例；（b）让模型生成新的指令-输入-输出三元组；（c）过滤低质量样本。这种方法可以低成本地大规模扩展指令数据集。
4. 人工标注：雇佣专业标注员编写高质量指令-回复对，确保数据的准确性和安全性

5. 领域特定数据：从行业文档、FAQ、专业论坛中提取领域问答对

6. 数据清洗与过滤：

7. 去重：精确去重（完全相同的样本）+ 语义去重（MinHash/LSH，相似度阈值通常设为0.95）
8. 质量过滤：
   • 规则过滤：移除过长/过短、格式错误、包含敏感信息的样本
   • 模型评分：使用奖励模型或更强的模型对回复质量打分，仅保留高分样本

9. 安全过滤：移除有害、偏见、隐私泄露的内容

10. 数据格式化：

11. 统一为对话模板格式（如ChatML、Llama-2-chat、Qwen-chat等）
12. 添加特殊token标记角色（system/user/assistant）

多轮对话数据的组织

多轮对话数据采用消息列表格式：

json { "messages": [ {"role": "system", "content": "你是一个 helpful 的AI助手。"}, {"role": "user", "content": "你好"}, {"role": "assistant", "content": "你好！很高兴为你服务。"}, {"role": "user", "content": "帮我总结一下机器学习的概念"}, {"role": "assistant", "content": "机器学习是人工智能的一个分支..."} ] }text

以ChatML模板格式化为模型输入：

text <|im_start|>system 你是一个 helpful 的AI助手。<|im_end|> <|im_start|>user 你好<|im_end|> <|im_start|>assistant 你好！很高兴为你服务。<|im_end|> <|im_start|>user 帮我总结一下机器学习的概念<|im_end|> <|im_start|>assistant 机器学习是人工智能的一个分支...<|im_end|>text

高质量指令数据的七个关键特征

1. 指令多样性：覆盖广泛的任务类型（问答、摘要、翻译、推理、代码、创作等）
2. 指令明确性：指令清晰无歧义，目标明确，避免模糊的表达
3. 输入-输出相关性：输入与输出强相关，输出直接回应指令和输入
4. 回复质量：准确、完整、有帮助、无害，避免虚假信息和偏见
5. 难度梯度：简单任务到复杂任务均衡分布，避免全为简单或全为复杂
6. 语言多样性：覆盖目标语言的各种变体和风格
7. 长度适中：指令和回复不过长不过短，信息密度高

数据质量与数量的权衡

研究表明，在指令微调中数据质量远比数量重要。低质量数据会引入噪声和错误模式，模型可能学会错误的回答风格或传播错误知识。实践中的经验法则是：1000条高质量指令数据的效果通常优于100,000条低质量数据。这一发现推动了"质量优先"的数据构建策略，即通过严格的人工审核和模型过滤确保每条数据的高质量。

训练时的损失计算策略

SFT训练的一个关键细节是只在assistant的回复部分计算损失，user输入和system prompt部分被mask掉（标记为-100，在PyTorch的CrossEntropyLoss中会被忽略）：

$$
\mathcal{L}{\text{SFT}} = -\sum{t \in \text{assistant tokens}} \log P(x_t \mid x_{<t}; \theta)
$$

这种设计的直觉是：模型只需要学习"如何回复"，而不需要重新学习"理解用户输入"（这一能力已在预训练中获得）。如果对所有token都计算损失，会浪费计算资源，且可能干扰模型对用户输入的理解方式。

```python
def compute_sft_loss(model, input_ids, attention_mask, labels):
"""
SFT损失计算：只在assistant回复上计算loss

labels中，非assistant部分的token设为-100（忽略）
"""
outputs = model(input_ids=input_ids, attention_mask=attention_mask)
logits = outputs.logits

# Shift for next-token prediction
shift_logits = logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()

# 只计算labels != -100的位置
loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), 
                shift_labels.view(-1))
return loss

```text

2.7.2 SFT的训练策略与超参数

SFT与预训练的核心差异

关键训练原则

1. 学习率必须远小于预训练：SFT的学习率通常为预训练的1/10至1/100。过大的学习率会导致模型快速偏离预训练的知识区域，造成灾难性遗忘。

2. 通常只需1~3个epoch：SFT的数据量远小于预训练（通常千至十万级别），过多的训练轮数会导致严重的过拟合。实践中通常从1个epoch开始，根据验证集表现决定是否增加到2~3个epoch。

3. Warmup比例较小：SFT的总步数通常只有数千步，warmup占总步数的3%~10%即可。

超参数配置示例

以下是一个典型的7B模型SFT训练配置：

```python
from transformers import TrainingArguments

training_args = TrainingArguments(
output_dir="./sft_output",

# Batch配置
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
gradient_accumulation_steps=2,
num_train_epochs=3,

# 优化器配置
learning_rate=2e-5,                    # SFT学习率：较小
warmup_ratio=0.03,                     # Warmup比例
lr_scheduler_type="cosine",            # 余弦衰减
weight_decay=0.0,                      # SFT通常不使用weight decay

# 训练控制
logging_steps=10,
save_strategy="steps",
save_steps=500,
eval_strategy="steps",
eval_steps=500,
load_best_model_at_end=True,

# 精度与优化
bf16=True,                             # BF16混合精度
gradient_checkpointing=True,           # 激活检查点

# 其他
remove_unused_columns=False,
report_to="wandb",

)
```text

训练不稳定的排查策略

SFT训练中常见的问题及解决方案：

早停策略（Early Stopping）

SFT训练中强烈建议使用早停来防止过拟合：

```python
from transformers import EarlyStoppingCallback

early_stopping = EarlyStoppingCallback(
early_stopping_patience=3, # 容忍3个eval不改善
early_stopping_threshold=0.001 # 改善阈值
)

trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
callbacks=[early_stopping], # 添加早停回调
)
```text

2.7.3 多任务指令微调

多任务指令微调（Multi-task Instruction Tuning）是指在多个不同类型的任务上同时进行SFT训练，使模型获得处理多样化任务的能力。这是构建通用对话助手（如ChatGPT、Claude）的关键步骤。

多任务SFT的核心优势

1. 指令泛化：模型学习的是"遵循指令"的元能力，能泛化到训练时未见过的指令类型（zero-shot instruction following）
2. 任务间知识迁移：不同任务间的共享知识相互促进学习
3. 减少遗忘：多样化的训练数据使模型不偏向单一任务模式

数据混合策略

多任务SFT的核心挑战是如何平衡不同任务类型的数据比例。常见策略包括：

1. 均匀采样：每种任务类型采样相同数量的样本。适合任务数量相近的场景。

2. 温度采样：根据任务样本数量进行温度调整采样：

$$
p_i \propto n_i^{1/T}
$$

其中 $n_i$ 是第 $i$ 类任务的样本数，$T$ 是温度参数：
- $T = 1$：按原始比例采样
- $T \rightarrow \infty$：完全均匀采样
- $T \rightarrow 0$：按原始比例（不调整）

1. 目标比例采样：根据业务目标手动设定各任务类型的采样比例，如：
2. 通用问答：30%
3. 代码生成：20%
4. 摘要提取：15%
5. 翻译任务：15%
6. 推理任务：10%
7. 创意写作：10%

缓解指令覆盖（Instruction Override）

指令覆盖是多任务SFT中的一个常见问题：当某些指令类型在训练数据中占比过高时，模型会过度偏向这些指令类型的回答模式，导致对其他指令的遵循能力下降。例如，安全对齐数据过多可能导致模型过度拒绝合理请求（over-refusal）。

缓解策略包括：

1. 数据重采样：确保每种任务类型至少占5%~10%的训练数据
2. 指令模板多样化：同一指令用多种不同表述方式（如"翻译"可用"Translate"、"把...翻译成"、"请翻译以下内容"等）
3. 拒绝感知训练：加入模型应当明确拒绝回答的样本类型
4. 多样性评估：定期在未见过的指令类型上评估模型性能

SFT完整训练代码示例

```python
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
Trainer,
DataCollatorForSeq2Seq,
EarlyStoppingCallback,
)
from datasets import load_dataset
import torch

def format_instruction(sample):
"""格式化单条指令数据为对话格式"""
if "messages" in sample:
# 多轮对话格式
formatted = ""
for msg in sample["messages"]:
role = msg["role"]
content = msg["content"]
formatted += f"<|im_start|>{role}\n{content}<|im_end|>\n"
return formatted
else:
# 单轮指令格式
instruction = sample.get("instruction", "")
input_text = sample.get("input", "")
output_text = sample.get("output", "")

    prompt = f"<|im_start|>user\n{instruction}\n{input_text}<|im_end|>\n"
    response = f"<|im_start|>assistant\n{output_text}<|im_end|>"
    return prompt + response

def tokenize_function(examples, tokenizer, max_length=2048):
"""Tokenize并创建labels（mask非assistant部分）"""
texts = [format_instruction(ex) for ex in examples]

model_inputs = tokenizer(
    texts,
    max_length=max_length,
    truncation=True,
    padding=False,  # 动态padding
)

# 创建labels：默认复制input_ids
model_inputs["labels"] = [
    ids.copy() for ids in model_inputs["input_ids"]
]

# 对每条样本，找到assistant回复的起始位置
# 将非assistant部分标记为-100（不计算loss）
for i, text in enumerate(texts):
    assistant_token = "<|im_start|>assistant"
    assistant_ids = tokenizer.encode(
        assistant_token, add_special_tokens=False
    )
    input_ids = model_inputs["input_ids"][i]
    labels = model_inputs["labels"][i]

    # 标记所有位置为忽略
    for j in range(len(labels)):
        labels[j] = -100

    # 找到所有assistant标记，将其后的内容设为实际label
    for j in range(len(input_ids) - len(assistant_ids)):
        if input_ids[j:j+len(assistant_ids)] == assistant_ids:
            # 从assistant标签后开始设置label
            start = j + len(assistant_ids)
            # 找到该assistant回复的结束位置
            for k in range(start, len(input_ids)):
                if input_ids[k] == tokenizer.encode(
                    "<|im_end|>", add_special_tokens=False
                )[0]:
                    break
                labels[k] = input_ids[k]

return model_inputs

==================== 主流程 ====================

1. 加载模型和tokenizer

model_name = "Qwen/Qwen2-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.bfloat16,
device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

2. 加载和预处理数据集

dataset = load_dataset("json", data_files={
"train": "instruction_train.json",
"validation": "instruction_val.json"
})

tokenized_dataset = dataset.map(
lambda x: tokenize_function(x, tokenizer),
batched=True,
remove_columns=dataset["train"].column_names,
)

3. 训练参数

training_args = TrainingArguments(
output_dir="./sft_output",
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
gradient_accumulation_steps=2,
num_train_epochs=3,
learning_rate=2e-5,
warmup_ratio=0.03,
lr_scheduler_type="cosine",
logging_steps=10,
save_strategy="steps",
save_steps=500,
eval_strategy="steps",
eval_steps=500,
load_best_model_at_end=True,
bf16=True,
gradient_checkpointing=True,
remove_unused_columns=False,
)

4. 数据整理器

data_collator = DataCollatorForSeq2Seq(
tokenizer=tokenizer,
model=model,
padding=True,
return_tensors="pt",
)

5. 创建Trainer

trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset["train"],
eval_dataset=tokenized_dataset["validation"],
data_collator=data_collator,
callbacks=[EarlyStoppingCallback(early_stopping_patience=3)],
)

6. 训练

trainer.train()

7. 保存模型

trainer.save_model("./sft_final_model")
```text

2.8 PEFT方法综合对比

本节从参数量、显存占用、推理延迟、训练速度、适用场景等多个维度，对已介绍的所有PEFT方法进行系统性对比。

PEFT方法核心指标对比

选型决策树

text 是否有足够显存（>模型参数×2）？ ├── 是 → 数据量 > 10K？ │ ├── 是 → 追求极致性能？ │ │ ├── 是 → Full Fine-tuning（数据混合缓解遗忘） │ │ └── 否 → LoRA（标准配置：r=8/16, 关注Q/V矩阵） │ └── 否 → LoRA（r=8, 关注Q/V矩阵） └── 否 → 单卡显存 < 16GB？ ├── 是 → QLoRA（NF4 + 分页优化器） └── 否 → LoRA + DeepSpeed ZeRO-2/3 + Offloadtext

各方法的核心优劣势总结

LoRA（最推荐）
- 优势：可训练参数极少、训练后可合并权重（推理零开销）、社区生态最完善（Hugging Face PEFT原生支持）、超参数调优相对简单
- 劣势：在某些极端分布差异的任务上可能略逊于全量微调
- 适用：绝大多数微调场景的首选方案

QLoRA（显存受限场景）
- 优势：极致显存节省（单卡24GB可调70B模型）、NF4量化误差小、训练稳定
- 劣势：训练速度慢于标准LoRA（反量化开销）、量化有微小精度损失
- 适用：消费级GPU大模型微调、快速原型验证

Adapter（多任务场景）
- 优势：天然模块化、任务切换零成本（只需切换Adapter模块）、适合大规模多任务部署
- 劣势：推理延迟增加（串行计算）、不能合并权重、社区支持不如LoRA
- 适用：需要同时服务多个任务（如多领域客服）的生产环境

Prompt Tuning（极简场景）
- 优势：可训练参数最少、实现最简单、完全不改变模型结构
- 劣势：严重依赖大模型（>10B）、小模型效果差、长任务上效果有限
- 适用：超大模型（10B+）的简单分类/理解任务

P-Tuning v2（NLU任务）
- 优势：深层提示调优效果稳定、序列标注任务友好、比Prompt Tuning通用性强
- 劣势：推理延迟增加、超参数（前缀长度）需要调优
- 适用：命名实体识别、文本分类、阅读理解等NLU任务

DoRA（前沿改进）
- 优势：学习模式更接近全量微调、幅度-方向解耦带来更好的稳定性和效果
- 劣势：训练计算略增（需计算列范数）、社区支持仍在发展中
- 适用：当标准LoRA效果不满意时，作为LoRA的直接替代

PEFT方法的共性问题与改进方向

尽管PEFT方法已取得巨大成功，仍存在一些共性的局限：

1. 性能天花板：多数情况下仍略低于全量微调，尤其在任务与预训练分布差异较大的场景
2. 超参数敏感：秩、缩放因子、学习率等需要仔细调优，缺乏通用的"万能配置"
3. 灾难性遗忘未完全解决：PEFT缓解了但无法完全消除遗忘，尤其在深层知识上
4. 长上下文挑战：PEFT方法在超长上下文（32K+）场景下的效果仍需更多验证
5. 多任务组合：不同任务适配器的有效组合、切换机制还不够成熟

2024-2025年的前沿改进方向包括：
- 初始化改进：PiSSA（Principal Singular Component Adaptation）、LoRA-GA从预训练权重的主奇异值方向初始化低秩矩阵
- 优化策略：LoRA+为A和B矩阵分配差异化学习率，LoRA-RITE改进学习率调度
- 秩自适应：AdaLoRA、SoRA根据参数重要性动态调整各层的秩
- 混合方法：DoRA的幅度-方向分解、PiSSA的主成分初始化
- 持续学习：ReLoRA、CURLoRA支持多次低秩更新的累积，缓解持续学习中的遗忘

2.9 图解说明

本节通过Mermaid.js图表对预训练与微调的核心概念进行可视化说明。

图2-1：LoRA低秩分解架构图

graph TD
    subgraph "LoRA层前向传播"
        X["输入 x<br/>shape: (batch, seq, k)"] --> W0["W₀<br/>预训练权重<br/>(d × k)<br/>冻结 ❄"]
        X --> Drop["Dropout"]
        Drop --> A["A<br/>可训练<br/>(k × r)"]
        A --> B["B<br/>可训练<br/>(r × d)"]
        B --> Scale["× α/r<br/>缩放因子"]
        W0 --> Sum["⊕ 求和"]
        Scale --> Sum
        Sum --> H["输出 h<br/>shape: (batch, seq, d)"]
    end

    subgraph "维度变化"
        D1["x: (k)"] --> D2["x·A: (r)"]
        D2 --> D3["x·A·B: (d)"]
        D3 --> D4["s·x·A·B: (d)"]
    end

    style W0 fill:#ffcccc,stroke:#cc0000,stroke-width:2px
    style A fill:#ccffcc,stroke:#009900,stroke-width:2px
    style B fill:#ccffcc,stroke:#009900,stroke-width:2px
    style Drop fill:#ffffcc,stroke:#999900
    style Scale fill:#e6e6fa,stroke:#6600cc

图2-1说明：LoRA在原始线性层 $W_0$ 旁边并行添加低秩路径 $B \cdot A$。输入 $x$ 同时通过冻结的 $W_0$ 和可训练的 $A \rightarrow B$ 路径，输出相加。其中 $r \ll \min(d, k)$，可训练参数量仅为 $r(d + k)$，相比原始的 $d \times k$ 大幅缩减。矩阵 $B$ 初始化为零，确保训练开始时LoRA输出为零，不破坏预训练行为。

图2-2：QLoRA量化+适配训练流程图

graph TD
    subgraph "QLoRA训练架构"
        FP16["预训练权重<br/>FP16精度"] --> NF4["NF4 4-bit量化<br/>分块量化(64)"]
        NF4 --> Freeze["冻结量化权重 ❄"]

        Freeze --> Dequant["反量化<br/>(FP16计算)"]
        Input["输入 x"] --> Dequant
        Dequant --> Matmul1["W₀ × x"]

        LoRA_A["LoRA A (FP16)<br/>可训练 ✓"] --> LoRA_B["LoRA B (FP16)<br/>可训练 ✓"]
        Input --> LoRA_A
        LoRA_B --> Scale["× α/r"]
        Scale --> Matmul2["ΔW × x"]

        Matmul1 --> Output["输出 = W₀x + ΔWx"]
        Matmul2 --> Output
    end

    subgraph "内存管理"
        Optim["优化器状态<br/>AdamW 8-bit"] --> Page["分页优化器<br/>Unified Memory"]
        Page --> GPU["GPU显存"]
        Page --> CPU["CPU内存<br/>自动交换"]
    end

    subgraph "双重量化"
        W["FP32权重"] --> Q1["第一层: FP32 → NF4<br/>每64参数一个FP32缩放因子"]
        Q1 --> Q2["第二层: FP32缩放因子 → 8-bit<br/>每256缩放因子一个FP32全局因子"]
        Q2 --> Effective["有效比特率: ~4.13 bits/参数"]
    end

    style FP16 fill:#ffcccc,stroke:#cc0000
    style NF4 fill:#ff9966,stroke:#cc6600
    style Freeze fill:#ccccff,stroke:#0000cc
    style LoRA_A fill:#ccffcc,stroke:#009900
    style LoRA_B fill:#ccffcc,stroke:#009900
    style Optim fill:#ffffcc,stroke:#999900
    style Page fill:#e6e6fa,stroke:#6600cc

图2-2说明：QLoRA将预训练权重量化为4-bit NF4格式并冻结。前向传播时反量化到FP16进行计算。LoRA适配器保持FP16全精度训练。分页优化器利用NVIDIA统一内存在GPU和CPU间自动交换优化器状态，避免OOM。双重量化将缩放因子的存储开销从0.5 bits/参数降至约0.127 bits/参数，总有效比特率约4.13 bits/参数。

图2-3：PEFT方法分类树状图

graph TD
    PEFT["参数高效微调 PEFT"] --> Additive["添加式方法<br/>新增可训练模块"]
    PEFT --> Selective["选择性方法<br/>选择部分参数训练"]
    PEFT --> Reparam["重参数化方法<br/>低秩分解更新"]
    PEFT --> SoftPrompt["软提示方法<br/>学习输入提示"]

    Additive --> Adapter["Adapter<br/>瓶颈层适配<br/>Houlsby et al. 2019"]

    Reparam --> LoRA["LoRA<br/>低秩适配<br/>Hu et al. 2022"]
    Reparam --> DoRA["DoRA<br/>权重分解LoRA<br/>Liu et al. 2024"]
    Reparam --> AdaLoRA["AdaLoRA<br/>自适应秩分配<br/>Zhang et al. 2023"]

    SoftPrompt --> Prefix["Prefix Tuning<br/>每层KV前缀<br/>Li & Liang 2021"]
    SoftPrompt --> Prompt["Prompt Tuning<br/>输入层软提示<br/>Lester et al. 2021"]
    SoftPrompt --> PTv2["P-Tuning v2<br/>深层提示调优<br/>Liu et al. 2022"]

    LoRA --> QLoRA["QLoRA<br/>量化+LoRA<br/>Dettmers et al. 2023"]

    style PEFT fill:#99ccff,stroke:#0066cc,stroke-width:3px
    style LoRA fill:#ccffcc,stroke:#009900,stroke-width:2px
    style QLoRA fill:#ccffcc,stroke:#009900,stroke-width:2px
    style Adapter fill:#ffffcc,stroke:#999900,stroke-width:2px
    style Prefix fill:#ffcccc,stroke:#cc0000,stroke-width:2px
    style Prompt fill:#ffcccc,stroke:#cc0000,stroke-width:2px
    style PTv2 fill:#ffcccc,stroke:#cc0000,stroke-width:2px
    style DoRA fill:#e6e6fa,stroke:#6600cc,stroke-width:2px
    style AdaLoRA fill:#e6e6fa,stroke:#6600cc,stroke-width:2px

图2-3说明：PEFT方法按照技术路线可分为四大类：（1）添加式方法（Adapter）在层间插入小型模块；（2）重参数化方法（LoRA/DoRA/AdaLoRA）通过低秩分解更新现有权重，是当前最主流的路线；（3）软提示方法（Prefix/Prompt/P-Tuning v2）在输入或注意力中注入可学习向量；（4）QLoRA在LoRA基础上叠加量化技术实现极致内存效率。各方法在参数效率、推理延迟、多任务支持等方面各有侧重。

图2-4：SFT训练流程图

graph LR
    subgraph "数据准备阶段"
        A["原始数据<br/>FLAN/Alpaca/ShareGPT"] --> B["数据清洗<br/>去重+质量过滤"]
        B --> C["数据格式化<br/>统一对话模板"]
        C --> D["数据划分<br/>Train/Val/Test"]
    end

    subgraph "训练阶段"
        D --> E["加载预训练模型<br/>(FP16/BF16)"]
        E --> F["应用LoRA/QLoRA<br/>(可选)"]
        F --> G["前向传播<br/>计算 logits"]
        G --> H["Loss计算<br/>只算assistant部分"]
        H --> I["反向传播<br/>更新LoRA/全量参数"]
        I --> J{"验证集评估"}
        J -->|性能提升| K["继续训练"]
        J -->|性能饱和| L["早停/保存最佳模型"]
        K --> G
    end

    subgraph "部署阶段"
        L --> M["合并LoRA权重<br/>(可选)"]
        M --> N["模型评估<br/>通用能力+任务能力"]
        N --> O["部署上线"]
    end

    style A fill:#99ccff,stroke:#0066cc
    style B fill:#ffffcc,stroke:#999900
    style C fill:#ffffcc,stroke:#999900
    style E fill:#ffcccc,stroke:#cc0000
    style F fill:#ccffcc,stroke:#009900
    style H fill:#e6e6fa,stroke:#6600cc
    style L fill:#ccffcc,stroke:#009900,stroke-width:2px
    style O fill:#99ff99,stroke:#009900,stroke-width:2px

图2-4说明：SFT训练流程分为三个阶段：数据准备（收集、清洗、格式化、划分）、训练（加载模型→可选LoRA→前向传播→损失计算→反向传播→验证评估→早停）、部署（合并权重、全面评估、上线）。关键设计包括：只在assistant回复上计算损失、使用远小于预训练的学习率、配合早停防止过拟合。

图2-5：各PEFT方法参数量与性能对比图

xychart-beta
    title "PEFT方法：可训练参数比例 vs 相对性能"
    x-axis "可训练参数比例 (%)" [0.001, 0.01, 0.1, 0.5, 1, 2, 5, 100]
    y-axis "相对性能 (% of Full FT)" 0.6 --> 1.05

    %% Prompt Tuning: ~0.001% params, ~70-95% performance (model size dependent)
    %% LoRA: ~0.1-2% params, ~95-99% performance
    %% Adapter: ~0.5-5% params, ~96-99% performance
    %% Prefix Tuning: ~0.1-1% params, ~93-98% performance
    %% P-Tuning v2: ~0.1-1% params, ~95-99% performance
    %% Full FT: 100% params, 100% performance
    %% QLoRA: same as LoRA in params
    %% DoRA: same range as LoRA, slightly better

    line [0.001, 0.01, 0.1, 0.5, 1, 2, 5, 100] [0.70, 0.85, 0.97, 0.985, 0.99, 0.995, 0.998, 1.0]

    annotation "Prompt Tuning<br/>(大模型)" [0.001, 0.92]
    annotation "LoRA / QLoRA" [0.5, 0.97]
    annotation "DoRA" [0.5, 0.99]
    annotation "Adapter" [2, 0.98]
    annotation "Full FT<br/>(100%)" [100, 1.0]

图2-5说明：上图展示了各PEFT方法的可训练参数比例与相对性能的关系。横轴为可训练参数占模型总参数的比例（对数刻度），纵轴为相对于全量微调（Full FT）的性能百分比。关键观察：（1）LoRA/QLoRA在仅训练约0.1%~2%参数的情况下即可达到全量微调95%~99%的性能，是最优的参数效率点；（2）Prompt Tuning在极大数据量下性能高度依赖模型规模，小模型上性能显著下降；（3）DoRA在相同参数量下通常略优于标准LoRA；（4）全量微调虽然达到100%性能，但需要100%参数参与训练，计算和存储成本极高。

2.10 本章小结

本章系统性地介绍了大模型预训练与微调的完整技术链路，从预训练的基础理论到各类微调方法的数学原理与工程实践，覆盖了当前工业界和学术界的主流方案。

核心要点回顾：

1. 预训练目标函数决定了模型的基础架构和能力倾向。CLM（因果语言建模）是当前大模型的主流选择，对应Decoder-only架构；MLM（掩码语言建模）适用于文本理解任务；Span Corruption则兼具理解与生成能力。

2. 训练稳定性保障是大模型预训练成功的基石。梯度裁剪、混合精度训练（BF16优先于FP16）、学习率预热与余弦衰减、DeepSpeed ZeRO系列优化器以及Flash Attention内存优化，共同构成了大规模训练的技术栈。

3. 灾难性遗忘是微调中必须面对的核心挑战。最有效 mitigation 手段是PEFT方法（冻结预训练参数 + 训练少量新增参数），辅以数据混合、低学习率等策略。

4. LoRA是参数高效微调的标杆方法。其核心假设——权重更新具有低本征秩——得到了理论和实验的双重验证。通过 $h = W_0 x + \frac{\alpha}{r}BAx$ 的简洁形式，LoRA以不到1%的参数达到了接近全量微调的性能。

5. QLoRA通过NF4量化（针对正态分布优化的4-bit量化）、双重量化和分页优化器三项技术，将LoRA的显存效率推向了极致，使得消费级GPU微调70B参数模型成为可能。

6. 其他PEFT方法各有特色：Adapter天然适合多任务模块化部署；Prompt Tuning是最简单的PEFT方案但依赖大模型规模；P-Tuning v2在NLU任务上表现优异；DoRA通过幅度-方向分解进一步提升了LoRA的效果。

7. 指令微调（SFT）是连接基础模型与对话助手的桥梁。高质量指令数据的构建、只在assistant回复上计算损失、多任务数据混合策略以及合理的超参数配置（小学习率、少epoch、早停），是成功SFT的关键要素。

选型建议总结：

展望：PEFT领域仍在快速发展中。2024-2025年的前沿方向包括自适应秩分配（AdaLoRA）、权重分解（DoRA）、数据感知初始化（PiSSA）、差异化学习率（LoRA+）以及支持持续学习的累积更新方法（ReLoRA/CURLoRA）。随着模型规模继续增长和应用场景的不断扩展，参数高效微调技术将在大模型落地中扮演越来越重要的角色。

参考文献

1. Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. NAACL 2019.

2. Radford, A., Narasimhan, K., Salimans, T., & Sutskever, I. (2018). Improving Language Understanding by Generative Pre-Training. OpenAI Technical Report.

3. Raffel, C., et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer. JMLR 2020.

4. Hu, E. J., et al. (2022). LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022.

5. Dettmers, T., et al. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. NeurIPS 2023.

6. Houlsby, N., et al. (2019). Parameter-Efficient Transfer Learning for NLP. ICML 2019.

7. Li, X. L., & Liang, P. (2021). Prefix-Tuning: Optimizing Continuous Prompts for Generation. ACL 2021.

8. Lester, B., Al-Rfou, R., & Constant, N. (2021). The Power of Scale for Parameter-Efficient Prompt Tuning. EMNLP 2021.

9. Liu, X., et al. (2022). P-Tuning v2: Prompt Tuning Can Be Comparable to Fine-tuning Universally Across Scales and Tasks. ACL 2022.

10. Liu, S., et al. (2024). DoRA: Weight-Decomposed Low-Rank Adaptation. ICLR 2024.

11. Zhang, Q., et al. (2023). AdaLoRA: Adaptive Budget Allocation for Parameter-Efficient Fine-Tuning. ICLR 2023.

12. Aghajanyan, A., et al. (2021). Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning. ACL 2021.

13. Rajbhandari, S., et al. (2020). ZeRO: Memory Optimizations Toward Training Trillion Parameter Models. SC 2020.

14. Micikevicius, P., et al. (2018). Mixed Precision Training. ICLR 2018.

15. Dao, T., et al. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022.

16. Ouyang, L., et al. (2022). Training Language Models to Follow Instructions with Human Feedback. NeurIPS 2022.

17. Wei, J., et al. (2022). Finetuned Language Models Are Zero-Shot Learners. ICLR 2022 (FLAN).

18. Taori, R., et al. (2023). Stanford Alpaca: An Instruction-following LLaMA Model. Stanford Technical Report.

19. Kirkpatrick, J., et al. (2017). Overcoming Catastrophic Forgetting in Neural Networks. PNAS 2017.

20. Loshchilov, I., & Hutter, F. (2019). Decoupled Weight Decay Regularization. ICLR 2019.

21. Lialin, V., et al. (2023). Scaling Down to Scale Up: A Guide to Parameter-Efficient Fine-Tuning. arXiv:2303.15647.

22. Pfeiffer, J., et al. (2021). AdapterFusion: Non-Destructive Task Composition for Transfer Learning. EACL 2021.

23. Su, H., et al. (2024). PiSSA: Principal Singular values and Singular vectors Adaptation of Large Language Models. arXiv:2404.02948.

24. Hayou, S., et al. (2024). LoRA+: Efficient Low Rank Adaptation of Large Models. ICML 2024.

25. Kalajdzievski, D. (2023). A Rank Stabilization Scaling Factor for Fine-Tuning with LoRA. arXiv:2312.03732.

26. Sheng, Y., et al. (2023). S-LoRA: Serving Thousands of Concurrent LoRA Adapters. arXiv:2311.03285.

27. Biderman, D., et al. (2024). LoRA Learns Less and Forgets Less. arXiv:2405.09673.

28. Meng, F., et al. (2024). ReLoRA: High-Rank Training Through Low-Rank Updates. ICLR 2024 Workshop.

本章完。读者在掌握本章内容后，应能够：（1）理解预训练的三种目标函数及其适用场景；（2）配置和优化大规模训练系统；（3）为具体任务选择合适的微调策略；（4）熟练使用LoRA/QLoRA进行参数高效微调；（5）构建高质量的指令数据并完成SFT训练；（6）系统性地对比和评估不同PEFT方法的优劣。

第三章 人类对齐与强化学习

章节定位：本章是全书的重点章节，系统讲解大模型人类对齐的核心技术——从RLHF三阶段框架出发，深入推导策略梯度定理、TRPO/PPO的数学原理，剖析DPO的直接优化思想，重点专题解析GRPO（组相对策略优化）的架构创新与工程实践。读者将通过完整的数学推导、详细的架构图解与可运行的代码实现，全面掌握大模型对齐的理论体系与技术演进脉络。

3.1 引言：从能力到对齐

3.1.1 预训练的能力边界

在大语言模型（LLM）的训练 pipeline 中，预训练阶段赋予了模型强大的语言理解与生成能力——通过在海量无标注文本上进行自监督学习，模型掌握了语法结构、世界知识和推理模式。然而，预训练模型本质上是一个"文本补全器"，其优化目标是最大化训练数据的似然概率，而非遵循人类的意图和价值观。

这一差距具体表现在以下几个方面：

（1）指令遵循能力的缺失。预训练模型仅根据上文预测下一个token，不理解"回答问题""总结要点""翻译句子"等指令性表达。当用户输入"请用简洁的语言解释量子力学"时，预训练模型可能继续生成与"量子力学"相关的百科内容，而非针对性地进行解释。

（2）价值对齐的缺位。预训练数据来源于互联网，不可避免地包含有害、偏见和错误信息。如果不加以引导，模型可能生成歧视性内容、危险建议或不实信息。

（3）输出质量的不可控性。预训练模型缺乏对"好回答"与"差回答"的判别能力，生成内容的风格、长度和深度难以预测和控制。

3.1.2 对齐：让模型"有用且无害"

人类对齐（Human Alignment）的核心目标是使大语言模型的行为与人类的意图、偏好和价值观保持一致。这一领域的研究受启发于一个被称为对齐问题（Alignment Problem）的基本命题：如何确保一个能力强大的智能系统按照人类的真正意图行事，而非仅仅优化某个可度量的目标函数？

在大模型的语境下，对齐问题具体化为以下优化目标：

$$
\max_{\pi_\theta} \; \underbrace{\mathbb{E}{x \sim \mathcal{D}, y \sim \pi\theta(\cdot|x)}[r(x, y)]}{\text{人类偏好奖励}} \; - \; \underbrace{\beta \cdot \mathbb{D}{KL}[\pi_\theta(y|x) \parallel \pi_{\text{ref}}(y|x)]}_{\text{KL约束：防止策略漂移}}
$$

其中 $r(x, y)$ 是奖励函数，量化人类对回答 $y$ 的偏好程度；$\pi_{\text{ref}}$ 是参考模型（通常是SFT模型），KL散度项确保训练后的策略不会偏离参考模型太远。

对齐的三重维度：

3.1.3 从监督微调到强化学习的技术演进

大模型对齐技术的发展经历了三个关键阶段：

阶段一：监督微调（SFT）。通过收集高质量的人工标注指令-回答对，以监督学习的方式微调预训练模型。SFT赋予模型基本的指令遵循能力，但其上限受限于标注数据的质量和规模——模型只能学习到标注者"示范"的回答模式，难以超越。

阶段二：奖励模型（Reward Model）与偏好学习。人类更擅长做相对比较（"回答A比回答B好"）而非绝对评分（"给回答A打8分"）。基于这一洞察，研究者采用成对比较的方式收集偏好数据，训练奖励模型来预测人类的偏好。

阶段三：强化学习优化。以奖励模型的打分作为奖励信号，使用强化学习算法（如PPO）进一步优化策略模型。强化学习赋予了模型"自我改进"的能力——通过不断尝试和探索，发现人类偏好的回答模式。

graph LR
    subgraph "对齐技术演进路线"
        direction LR
        PT["预训练<br/>Pre-training"] --> SFT["监督微调<br/>SFT<br/>(模仿学习)"]
        SFT --> RM["奖励模型<br/>Reward Model<br/>(偏好建模)"]
        RM --> RL["强化学习<br/>PPO/DPO/GRPO<br/>(自主优化)"]

        style PT fill:#e1f5fe
        style SFT fill:#fff3e0
        style RM fill:#f3e5f5
        style RL fill:#e8f5e9
    end

3.1.4 对齐的评估与挑战

对齐评估的维度：

评估一个对齐后的大模型是否成功，通常需要从多个维度进行综合考察：

对齐面临的核心挑战：

1. 对齐税（Alignment Tax）：模型经过RLHF对齐后，在某些通用能力（如知识问答、阅读理解）上的表现可能下降。这是因为对齐改变了模型的输出分布，可能"挤占"了其他能力。减少对齐税的方法包括：保持KL约束、混合原始训练数据、冻结底层参数等。

2. Reward Hacking：策略可能找到非预期的方式最大化奖励模型的分数，而不是真正学习人类偏好。这是强化学习中的经典问题，在LLM场景中表现为重复高分模式、长度填充、格式欺骗等。

3. 人类偏好的不一致性：不同标注者的偏好可能不同甚至矛盾，如何处理这种不一致性是一个开放问题。

4. 分布外泛化：对齐训练只能覆盖有限的偏好数据分布，模型在分布外的问题上的行为难以预测。

3.1.5 本章内容概览

本章将沿着以下逻辑主线展开：

• 3.2节：介绍RLHF的三阶段框架（SFT→RM→PPO），建立整体认知
• 3.3节：从基础出发，完整推导策略梯度定理——所有策略优化算法的理论基石
• 3.4节：从TRPO到PPO的演进，推导PPO-Clip目标函数与GAE
• 3.5节：将PPO应用于RLHF场景，详解四模型交互架构
• 3.6节：推导DPO——将RL问题转化为分类问题的优雅方法
• 3.7节：重点专题GRPO，详解其去Critic架构设计与在DeepSeek-R1中的应用
• 3.8节：介绍SLiC、IPO、KTO、Constitutional AI等其他对齐方法
• 3.9节：图解说明核心架构的对比
• 3.10节：本章小结

3.2 RLHF全流程概述

RLHF（Reinforcement Learning from Human Feedback，人类反馈强化学习）是当前最主流的大模型对齐方法。它通过将人类的偏好反馈转化为奖励信号，驱动强化学习算法优化语言模型的生成策略。本节首先概述RLHF的三阶段框架，然后深入其核心组件——偏好数据建模与Bradley-Terry模型。

3.2.1 SFT → Reward Model → PPO的三阶段框架

RLHF的完整流程包含三个紧密衔接的阶段，每个阶段都在前一阶段的基础上构建，形成从"模仿"到"偏好建模"再到"自主优化"的能力递进。

graph TD
    subgraph "RLHF三阶段框架"
        direction LR

        subgraph "阶段1：SFT"
            S1_D["高质量指令数据<br/>(x, y)"] --> S1_M["预训练模型<br/>(Pre-trained)"]
            S1_M --> S1_Out["SFT模型<br/>(π_SFT)"]
        end

        subgraph "阶段2：RM训练"
            S2_D["偏好数据<br/>(x, y_w, y_l)"] --> S2_M["SFT模型 + 线性头<br/>(r_φ)"]
            S2_M --> S2_Out["奖励模型<br/>(r_φ)"]
        end

        subgraph "阶段3：PPO优化"
            S3_Prompt["提示 x"] --> S3_Actor["Actor<br/>(π_θ, 可训练)"]
            S3_Actor --> S3_Resp["生成回答 y"]
            S3_Resp --> S3_RM["Reward Model<br/>(r_φ, 冻结)"]
            S3_RM --> S3_R["奖励 r(x,y)"]
            S3_Resp --> S3_Ref["Reference<br/>(π_ref, 冻结)"]
            S3_Ref --> S3_KL["KL散度"]
            S3_R --> S3_PPO["PPO算法"]
            S3_KL --> S3_PPO
            S3_PPO --> S3_Update["更新Actor"]
            S3_Out["优化后策略<br/>(π*)"]
        end

        S1_Out --> S2_M
        S1_Out --> S3_Actor
        S1_Out --> S3_Ref
        S2_Out --> S3_RM
        S3_Update --> S3_Out
    end

数据流向说明：

阶段一：监督微调（SFT）

SFT阶段的目标是让预训练模型获得基本的指令遵循能力。

数据构建：收集高质量的人工标注指令-回答对 $\mathcal{D}{\text{SFT}} = {(x_i, y_i)}{i=1}^{N}$。这些数据通常由专业标注团队撰写，涵盖问答、对话、摘要、翻译、代码生成等多种任务类型。

训练目标：最大化回答的条件似然：

$$
\mathcal{L}{\text{SFT}}(\theta) = -\mathbb{E}{(x,y) \sim \mathcal{D}{\text{SFT}}}\left[\sum{t=1}^{|y|} \log \pi_\theta(y_t | x, y_{<t})\right]
$$

关键要点：
- SFT模型 $\pi_{\text{SFT}}$ 是后续阶段的"基石"：作为PPO阶段的Actor初始化、作为KL约束的参考模型
- SFT数据的质量比数量更重要——少量高质量数据胜过大量低质量数据
- SFT阶段通常只需要1-3个epoch，避免过拟合

阶段二：奖励模型（RM）训练

奖励模型的任务是为给定的"提示-回答"对预测一个标量奖励值，反映人类对该回答的偏好程度。

为什么不用绝对评分？ 人类标注者在给出绝对分数（如1-10分）时，标准往往不一致：同一个人在不同时间的评分可能波动，不同人之间的评分尺度也不同。相比之下，人类做相对比较（"A比B好"）时一致性更高、噪声更小。

成对比较数据：对于同一提示 $x$，收集两个不同回答 $y_w$（winning，偏好）和 $y_l$（losing，非偏好），构成三元组 $(x, y_w, y_l)$。

Bradley-Terry模型：假设存在一个底层真实奖励函数 $r^*(x, y)$，人类偏好的概率由奖励差值的sigmoid函数决定：

$$
P(y_w \succ y_l \mid x) = \sigma(r^(x, y_w) - r^(x, y_l)) = \frac{1}{1 + \exp(-(r^(x, y_w) - r^(x, y_l)))}
$$

奖励模型 $r_\phi(x, y)$ 的训练目标是最大化偏好数据的似然：

$$
\mathcal{L}{\text{RM}}(r\phi) = -\mathbb{E}{(x, y_w, y_l) \sim \mathcal{D}}\left[\log \sigma(r\phi(x, y_w) - r_\phi(x, y_l))\right]
$$

阶段三：PPO强化学习优化

以SFT模型初始化策略（Actor），在奖励模型的指导下，使用PPO算法优化策略，最大化期望奖励同时约束KL散度：

$$
\max_{\pi_\theta} \; \mathbb{E}{x \sim \mathcal{D}, y \sim \pi\theta(\cdot|x)}[r_\phi(x, y)] \; - \; \beta \cdot \mathbb{D}{KL}[\pi\theta(y|x) \parallel \pi_{\text{ref}}(y|x)]
$$

其中 $\pi_{\text{ref}} = \pi_{\text{SFT}}$（SFT模型，冻结参数），$\beta$ 是KL系数。

3.2.2 偏好数据与Bradley-Terry模型

Bradley-Terry模型是RLHF偏好建模的理论基石。本节深入剖析其数学原理、训练目标推导及关键性质。

BT模型的数学基础

假设：存在底层真实奖励函数 $r^*: \mathcal{X} \times \mathcal{Y} \rightarrow \mathbb{R}$，对于提示 $x$ 和两个候选回答 $y_1, y_2$，人类偏好 $y_1$ 胜过 $y_2$ 的概率为：

$$
p^(y_1 \succ y_2 \mid x) = \frac{\exp(r^(x, y_1))}{\exp(r^(x, y_1)) + \exp(r^(x, y_2))}
$$

通过简单的代数变换，可以重写为sigmoid形式：

$$
p^(y_1 \succ y_2 \mid x) = \sigma(r^(x, y_1) - r^*(x, y_2))
$$

训练目标推导

1. 参数化奖励模型：使用Transformer模型（通常是SFT模型加一层线性头）参数化奖励函数 $r_\phi(x, y)$，输入提示和回答，输出标量奖励值。

2. 构建似然函数：给定偏好数据集 $\mathcal{D} = {(x_i, y_w^{(i)}, y_l^{(i)})}_{i=1}^{N}$，假设各标注独立，似然函数为：

$$
\mathcal{L}(\phi) = \prod_{i=1}^{N} p(y_w^{(i)} \succ y_l^{(i)} \mid x_i) = \prod_{i=1}^{N} \sigma(r_\phi(x_i, y_w^{(i)}) - r_\phi(x_i, y_l^{(i)}))
$$

1. 取负对数得到损失函数：

$$
\boxed{\mathcal{L}{\text{RM}}(\phi) = -\sum{i=1}^{N} \log \sigma(r_\phi(x_i, y_w^{(i)}) - r_\phi(x_i, y_l^{(i)}))}
$$

BT模型的关键性质

性质1：尺度不变性。BT模型只关心奖励的相对差值。如果对所有回答加上常数 $c$，即 $r'\phi(x, y) = r\phi(x, y) + c$，偏好概率不变。这意味奖励模型的输出没有绝对意义，只有相对比较才有意义。

性质2：不可识别性。由于尺度不变性，$r_\phi$ 的整体偏移不影响训练损失。实践中需要添加L2正则化防止奖励值发散：

$$
\mathcal{L}{\text{RM}}^{\text{regularized}} = \mathcal{L}{\text{RM}} + \lambda \cdot \mathbb{E}[r_\phi(x, y)^2]
$$

性质3：与最大似然估计的联系。BT模型的训练等价于一个二分类问题——判断"$(x, y_w)$ 是否优于 $(x, y_l)$"，这正是逻辑回归的形式。

偏好数据的收集方法

BT模型的扩展：Plackett-Luce模型

当需要比较多个（超过两个）候选回答时，Bradley-Terry模型可以推广为Plackett-Luce模型。对于同一提示 $x$ 的 $K$ 个回答 ${y_1, y_2, \ldots, y_K}$，其排名 $\tau$（从最好到最差）的概率为：

$$
P(\tau | x) = \prod_{k=1}^{K-1} \frac{\exp(r^(x, y_{\tau(k)}))}{\sum_{j=k}^{K} \exp(r^(x, y_{\tau(j)}))}
$$

其中 $\tau(k)$ 表示排名第 $k$ 的回答。

Plackett-Luce模型在Best-of-N排序场景中特别有用——当标注者对N个回答进行全排序时，可以比成对比较提取更多的偏好信息。

Plackett-Luce vs Bradley-Terry：

偏好数据的质量控制

偏好数据的质量直接决定了奖励模型乃至最终对齐效果的上限。以下是关键的质量控制策略：

1. 标注者一致性评估

使用Cohen's Kappa系数衡量标注者之间的一致性：

$$
\kappa = \frac{p_o - p_e}{1 - p_e}
$$

其中 $p_o$ 是观测一致率，$p_e$ 是期望一致率（随机标注的一致率）。

实践中，偏好标注的Kappa系数应至少达到0.6才能保证数据质量。

2. 噪声数据处理

即使经过一致性评估，偏好数据中仍不可避免地存在噪声。处理方法：

• 软标签训练：使用标注者投票比例作为软标签，而非硬标签（0或1）
• 样本重加权：根据标注置信度对样本加权
• 噪声过滤：剔除多次标注分歧严重的样本
• 偏好模型：建模每个标注者的可靠性差异

3. 数据规模与质量权衡

在偏好数据收集中，质量和数量的权衡至关重要：

3.3 策略梯度定理（完整推导）

策略梯度定理（Policy Gradient Theorem）是强化学习中所有策略优化算法的理论基石。从REINFORCE到TRPO、PPO、GRPO，都建立在策略梯度定理的基础之上。本节将从强化学习基础出发，完整推导策略梯度定理的每一步，并在此基础上引出REINFORCE算法与基线缩减技术。

3.3.1 强化学习基础回顾

马尔可夫决策过程（MDP）

强化学习的标准建模框架是马尔可夫决策过程，定义为五元组 $\mathcal{M} = (\mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{R}, \gamma)$：

策略（Policy） $\pi_\theta(a|s)$：参数为 $\theta$ 的神经网络，输入状态 $s$，输出动作 $a$ 的概率分布。在LLM中，策略就是语言模型本身——给定上文，输出下一个token的分布。

轨迹（Trajectory）：$\tau = (s_0, a_0, r_0, s_1, a_1, r_1, \ldots, s_T)$，表示一次完整的交互过程。

关键函数定义

累积回报（Return）：从时刻 $t$ 开始的折扣累积奖励：

$$
G_t = \sum_{k=0}^{T-t-1} \gamma^k r_{t+k}
$$

状态价值函数（State Value Function）：从状态 $s$ 出发，遵循策略 $\pi$ 的期望累积回报：

$$
V^{\pi}(s) = \mathbb{E}_{\pi}\left[G_t \mid s_t = s\right]
$$

动作价值函数（Action Value Function）：从状态 $s$ 出发，执行动作 $a$ 后再遵循策略 $\pi$ 的期望累积回报：

$$
Q^{\pi}(s, a) = \mathbb{E}_{\pi}\left[G_t \mid s_t = s, a_t = a\right]
$$

优势函数（Advantage Function）：动作 $a$ 相对于状态 $s$ 下"平均水平"的优势：

$$
A^{\pi}(s, a) = Q^{\pi}(s, a) - V^{\pi}(s)
$$

优势函数是策略梯度定理的核心——它告诉策略"这个动作比平均好多少"（正优势意味着应该增加该动作的概率，负优势则应该减少）。

graph TD
    subgraph "强化学习核心概念关系图"
        direction TB
        Pi["策略 π(a|s)"] --> Q["Q^π(s,a)<br/>动作价值"]
        Q --> A["A^π(s,a) = Q^π(s,a) - V^π(s)<br/>优势函数"]
        Pi --> V["V^π(s)<br/>状态价值"]
        V --> A
        A --> PG["∇J = E[∇log π · A]<br/>策略梯度"]
    style Pi fill:#e3f2fd
    style A fill:#ffebee
    style PG fill:#e8f5e9
end

3.3.2 策略梯度定理的数学推导（不跳步）

目标函数

强化学习的目标是最大化策略 $\pi_\theta$ 下的期望累积回报：

$$
J(\theta) = \mathbb{E}{\tau \sim \pi\theta}\left[R(\tau)\right] = \int p_\theta(\tau) R(\tau) d\tau
$$

其中轨迹概率 $p_\theta(\tau)$ 由策略 $\pi_\theta$ 和环境动力学 $P$ 共同决定，$R(\tau) = \sum_{t=0}^{T-1} \gamma^t r_t$ 是累积回报。

Step 1：对数导数技巧（Log-Derivative Trick）

策略梯度的核心挑战在于：梯度算子无法直接穿过期望算子。解决这一问题的关键技术是对数导数技巧：

对于任意可微的正函数 $p_\theta(\tau)$：

$$
\nabla_\theta p_\theta(\tau) = p_\theta(\tau) \cdot \nabla_\theta \log p_\theta(\tau)
$$

证明：

$$
\nabla_\theta \log p_\theta(\tau) = \frac{\nabla_\theta p_\theta(\tau)}{p_\theta(\tau)} \quad \Rightarrow \quad \nabla_\theta p_\theta(\tau) = p_\theta(\tau) \cdot \nabla_\theta \log p_\theta(\tau)
$$

这一技巧的关键价值在于：将 $\nabla_\theta p_\theta(\tau)$ 转化为 $p_\theta(\tau) \cdot \nabla_\theta \log p_\theta(\tau)$ 后，可以利用 $p_\theta(\tau)$ 作为采样分布进行蒙特卡洛估计。

Step 2：轨迹概率分解

在MDP中，一条轨迹 $\tau = (s_0, a_0, s_1, a_1, \ldots, s_{T-1}, a_{T-1}, s_T)$ 的概率为：

$$
p_\theta(\tau) = p(s_0) \prod_{t=0}^{T-1} \pi_\theta(a_t | s_t) \cdot P(s_{t+1} | s_t, a_t)
$$

其中：
- $p(s_0)$：初始状态分布（与 $\theta$ 无关）
- $\pi_\theta(a_t | s_t)$：策略决定的动作概率（与 $\theta$ 有关）
- $P(s_{t+1} | s_t, a_t)$：环境转移概率（与 $\theta$ 无关）

取对数：

$$
\log p_\theta(\tau) = \log p(s_0) + \sum_{t=0}^{T-1} \left[\log \pi_\theta(a_t | s_t) + \log P(s_{t+1} | s_t, a_t)\right]
$$

Step 3：梯度简化

对 $\log p_\theta(\tau)$ 关于 $\theta$ 求梯度：

$$
\nabla_\theta \log p_\theta(\tau) = \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t | s_t)
$$

注意 $p(s_0)$ 和 $P(s_{t+1}|s_t, a_t)$ 均与 $\theta$ 无关，因此它们的梯度为零。这是一个极为重要的简化——策略梯度只依赖于策略的对数概率梯度，与环境动力学完全无关。

Step 4：策略梯度定理的初等形式

现在对目标函数求梯度：

$$
\nabla_\theta J(\theta) = \nabla_\theta \int p_\theta(\tau) R(\tau) d\tau
$$

在温和条件下（$p_\theta(\tau)$ 足够光滑），梯度与积分可交换：

$$
= \int \nabla_\theta p_\theta(\tau) R(\tau) d\tau
$$

应用对数导数技巧：

$$
= \int p_\theta(\tau) \nabla_\theta \log p_\theta(\tau) R(\tau) d\tau
$$

代入Step 3的结果：

$$
= \int p_\theta(\tau) \left[\sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t | s_t)\right] R(\tau) d\tau
$$

重写为期望形式：

$$
\boxed{\nabla_\theta J(\theta) = \mathbb{E}{\tau \sim \pi\theta}\left[\sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t | s_t) \cdot R(\tau)\right]}
$$

这就是策略梯度定理的初等形式。

Step 5：引入因果性约束（Causality）

策略梯度定理的初等形式有一个明显的问题：$R(\tau) = \sum_{k=0}^{T-1} \gamma^k r_k$ 是整个轨迹的累积回报，但动作 $a_t$ 只能影响从 $t$ 时刻开始的奖励，不能影响 $t$ 时刻之前的奖励。这一观察可以显著降低梯度估计的方差。

因果性原理：在时刻 $t$ 采取的动作 $a_t$ 只能影响 $r_t, r_{t+1}, r_{t+2}, \ldots$，不能影响 $r_0, r_1, \ldots, r_{t-1}$。

因此，用从 $t$ 时刻开始的累积回报替代 $R(\tau)$：

$$
G_t = \sum_{k=0}^{T-t-1} \gamma^k r_{t+k}
$$

得到因果形式的策略梯度：

$$
\nabla_\theta J(\theta) = \mathbb{E}{\pi\theta}\left[\sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t | s_t) \cdot G_t\right]
$$

为什么这不会引入偏差？

因为在Step 4的展开式中，$\nabla_\theta \log \pi_\theta(a_t|s_t)$ 与 $t$ 时刻之前的奖励无关（它们是由 $s_0, a_0, \ldots, s_{t-1}, a_{t-1}$ 决定的，不包含 $a_t$），所以 $\mathbb{E}[\nabla_\theta \log \pi_\theta(a_t|s_t) \cdot r_k] = 0$（对于 $k < t$）。

Step 6：引入基线（Baseline）减少方差

策略梯度的一个核心问题是方差过大。即使策略保持不变，由于采样的随机性，$G_t$ 的波动会导致梯度估计剧烈震荡。

关键洞察：减去与动作无关的基线 $b(s_t)$ 不影响梯度的期望值，但可以显著减少方差。

引理（基线不变性）：对于任意仅依赖于状态的函数 $b(s)$：

$$
\mathbb{E}{\pi\theta}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot b(s)\right] = 0
$$

证明：

$$
\mathbb{E}{\pi\theta}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot b(s) \mid s\right] = b(s) \cdot \sum_a \pi_\theta(a|s) \nabla_\theta \log \pi_\theta(a|s)
$$

$$
= b(s) \cdot \sum_a \pi_\theta(a|s) \frac{\nabla_\theta \pi_\theta(a|s)}{\pi_\theta(a|s)} = b(s) \cdot \sum_a \nabla_\theta \pi_\theta(a|s)
$$

$$
= b(s) \cdot \nabla_\theta \sum_a \pi_\theta(a|s) = b(s) \cdot \nabla_\theta 1 = 0
$$

因此，我们可以减去 $b(s_t)$ 而不影响梯度的期望：

$$
\nabla_\theta J(\theta) = \mathbb{E}{\pi\theta}\left[\sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t | s_t) \cdot (G_t - b(s_t))\right]
$$

最优基线选择：理论上，最优的基线是状态价值函数 $b^*(s_t) = V^{\pi_\theta}(s_t)$。此时 $G_t - V^{\pi_\theta}(s_t)$ 恰好是优势函数的蒙特卡洛估计。

Step 7：策略梯度定理的标准形式

定义优势函数 $A^{\pi_\theta}(s, a) = Q^{\pi_\theta}(s, a) - V^{\pi_\theta}(s)$，策略梯度定理的标准形式为：

$$
\boxed{\nabla_\theta J(\theta) = \mathbb{E}{(s,a) \sim \pi\theta}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot A^{\pi_\theta}(s, a)\right]}
$$

物理意义解读：
- $\nabla_\theta \log \pi_\theta(a|s)$ 指向增加动作 $a$ 在状态 $s$ 下概率的方向
- $A^{\pi_\theta}(s, a) > 0$：动作 $a$ 优于平均水平，应增加其概率
- $A^{\pi_\theta}(s, a) < 0$：动作 $a$ 差于平均水平，应减少其概率
- $|A^{\pi_\theta}(s, a)|$ 越大，更新幅度越大

直观类比：想象策略梯度定理就像一个"教练"在指导运动员（策略）：
- 如果某个动作带来了比预期更好的结果（$A > 0$），教练会让运动员以后多尝试这个动作（增加概率）
- 如果结果比预期差（$A < 0$），教练会让运动员少做这个动作（减少概率）
- 效果好多少/差多少（$|A|$ 的大小），决定了调整的幅度

策略梯度定理的等价形式

策略梯度定理有几种等价表达形式，在不同场景下各有优势：

形式1：状态-动作期望形式（最常用）

$$
\nabla_\theta J(\theta) = \mathbb{E}{s \sim d^\pi, a \sim \pi\theta}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot A^{\pi_\theta}(s, a)\right]
$$

其中 $d^\pi(s)$ 是策略 $\pi$ 下的状态访问分布。

形式2：$Q$函数形式

$$
\nabla_\theta J(\theta) = \mathbb{E}{s \sim d^\pi, a \sim \pi\theta}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot Q^{\pi_\theta}(s, a)\right]
$$

由于减去基线不影响期望，用 $Q(s,a)$ 替代 $A(s,a)$ 也是有效的（只是方差更大）。

形式3：逐token形式（LLM场景）

在LLM中，策略是序列生成模型，策略梯度可以写成逐token的形式：

$$
\nabla_\theta J(\theta) = \mathbb{E}{x \sim \mathcal{D}, y \sim \pi\theta}\left[\sum_{t=1}^{|y|} \nabla_\theta \log \pi_\theta(y_t | x, y_{<t}) \cdot \hat{A}_t\right]
$$

其中 $\hat{A}_t$ 是第 $t$ 个token的优势估计。这种形式直接对应了代码实现中的循环结构。

graph TD
    subgraph "策略梯度定理推导流程"
        direction TB
    Start["目标函数<br/>J(θ) = E[R(τ)]"] --> Log["Step 1: 对数导数技巧<br/>∇p = p·∇log p"]
    Log --> Decompose["Step 2: 轨迹概率分解<br/>p(τ) = p(s₀)∏π·P"]
    Decompose --> Simplify["Step 3: 梯度简化<br/>∇log p(τ) = Σ∇log π(aₜ|sₜ)"]
    Simplify --> Initial["Step 4: 初等形式<br/>∇J = E[Σ∇log π·R(τ)]"]
    Initial --> Causal["Step 5: 因果性约束<br/>R(τ) → Gₜ"]
    Causal --> Baseline["Step 6: 基线缩减<br/>Gₜ → Gₜ - b(sₜ)"]
    Baseline --> Final["Step 7: 标准形式<br/>∇J = E[∇log π·A(s,a)]"]

    style Start fill:#e3f2fd
    style Final fill:#e8f5e9
end

3.3.3 REINFORCE算法与基线缩减

REINFORCE算法

REINFORCE（Williams, 1992）是策略梯度定理最直接的算法实现。它使用累积回报 $G_t$ 作为优势函数的估计，并通过蒙特卡洛采样来近似期望。

算法流程：

1. 采样：从当前策略 $\pi_\theta$ 生成轨迹 $\tau = (s_0, a_0, r_0, \ldots, s_T)$
2. 计算回报：对于每个 $t$，计算 $G_t = \sum_{k=0}^{T-t-1} \gamma^k r_{t+k}$
3. 梯度估计：$\hat{g} = \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot G_t$
4. 参数更新：$\theta \leftarrow \theta + \alpha \cdot \hat{g}$

REINFORCE的局限性：
- 方差大：$G_t$ 是累积多个随机奖励的和，方差随轨迹长度线性增长
- 收敛慢：高方差导致需要大量样本才能稳定估计梯度
- 只能用于回合制（episode-based）任务

REINFORCE with Baseline

通过引入基线 $b(s_t)$，可以显著降低梯度估计的方差。

简单的基线选择：使用状态价值的滑动平均：

$$
b(s_t) = \frac{1}{N} \sum_{i=1}^{N} G_t^{(i)}
$$

其中 $G_t^{(i)}$ 是第 $i$ 条轨迹在时刻 $t$ 的累积回报。

更优的基线选择：训练一个Critic网络 $V_\phi(s)$ 来估计状态价值函数，这就是 Actor-Critic 方法的核心思想。Actor-Critic将策略梯度的基线从一个简单的统计量提升为一个可学习的函数逼近器，从而能够更精确地估计优势函数，大幅降低梯度方差。

3.4 TRPO与PPO

从策略梯度定理出发，研究者发展了一系列实用的策略优化算法。本章将沿着 TRPO $\rightarrow$ PPO 的演进路线，深入理解其背后的数学原理和工程洞察。

3.4.1 TRPO的约束优化问题

从策略梯度到重要性采样

策略梯度定理要求梯度从当前策略 $\pi_\theta$ 中采样。但在实际训练中，我们希望复用旧策略采样的数据——这就是重要性采样（Importance Sampling）的思想。

重要性采样恒等式：

$$
\mathbb{E}{x \sim p}[f(x)] = \mathbb{E}{x \sim q}\left[\frac{p(x)}{q(x)} f(x)\right]
$$

应用到策略梯度中，令 $r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)}$ 为概率比（probability ratio），则：

$$
\nabla_\theta J(\theta) = \mathbb{E}{s,a \sim \pi{\theta_{\text{old}}}}\left[r_t(\theta) \cdot \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot A^{\pi_{\theta_{\text{old}}}}(s_t, a_t)\right]
$$

TRPO的核心约束

TRPO（Trust Region Policy Optimization, Schulman et al., ICML 2015）的核心思想是：策略更新不应该太大，否则新策略可能表现很差。为此，TRPO引入KL散度约束，限制新旧策略之间的差异。

TRPO优化问题：

$$
\max_{\theta} \; \mathbb{E}{s,a \sim \pi{\theta_{\text{old}}}}\left[\frac{\pi_\theta(a|s)}{\pi_{\theta_{\text{old}}}(a|s)} \cdot A^{\pi_{\theta_{\text{old}}}}(s, a)\right]
$$

$$
\text{s.t.} \quad \mathbb{E}s\left[\mathbb{D}{KL}\left[\pi_{\theta_{\text{old}}} (\cdot|s) \parallel \pi_\theta(\cdot|s)\right]\right] \leq \delta
$$

TRPO约束的含义：
- 信任区域：在每个优化步骤中，新策略必须位于旧策略的"信任区域"内（KL距离不超过 $\delta$）
- 理论保证：在信任区域内，用重要性采样近似的目标函数与实际目标函数之间的误差有界
- 步长自适应：信任区域的大小 $\delta$ 自动调节有效步长——在平坦区域允许大步长，在陡峭区域限制小步长

TRPO的求解方法

TRPO的求解需要处理约束优化问题，其标准方法是：

1. 线性化目标函数：对目标函数做一阶泰勒展开
2. 二次近似约束：对KL散度做二阶近似

KL散度的二次近似：

$$
\mathbb{D}{KL}[\pi{\theta_{\text{old}}} \parallel \pi_{\theta_{\text{old}} + \Delta\theta}] \approx \frac{1}{2} \Delta\theta^T \mathbf{F} \Delta\theta
$$

其中 $\mathbf{F}$ 是Fisher信息矩阵（FIM）：

$$
\mathbf{F} = \mathbb{E}{s,a \sim \pi{\theta_{\text{old}}}}\left[\nabla_\theta \log \pi_\theta(a|s) \nabla_\theta \log \pi_\theta(a|s)^T\right]
$$

FIM刻画了策略参数空间中的"局部几何结构"——在FIM诱导的度量下，KL散度近似等于欧氏距离的平方。

自然梯度：TRPO的解等价于自然梯度下降：

$$
\Delta\theta = \sqrt{\frac{2\delta}{\nabla_\theta J^T \mathbf{F}^{-1} \nabla_\theta J}} \cdot \mathbf{F}^{-1} \nabla_\theta J
$$

TRPO的计算瓶颈：
- 需要计算Fisher信息矩阵 $\mathbf{F}$（$O(n^2)$ 存储，$n$ 为参数数量）
- 需要求解 $\mathbf{F}^{-1} \nabla_\theta J$（通常使用共轭梯度法，$O(kn^2)$，$k$ 为迭代次数）
- 对于大模型（如7B参数），FIM根本无法存储（需要 $7\text{B} \times 7\text{B} \times 4\text{B} = 196$ EB）

这一计算瓶颈促使了PPO的诞生。

自然梯度与Fisher信息矩阵的深入理解

为了更深入地理解TRPO为何计算代价高昂，我们需要理解Fisher信息矩阵的几何意义。

Fisher信息矩阵作为黎曼度量：

在策略空间（参数空间）中，标准的欧氏距离 $||\theta_1 - \theta_2||^2$ 并不是衡量两个策略差异的"正确"方式——因为参数空间的不同方向的单位变化对策略分布的影响差异巨大。

Fisher信息矩阵定义了参数空间中的自然度量：

$$
d_{\text{natural}}(\theta, \theta + d\theta)^2 = d\theta^T \mathbf{F} d\theta = \mathbb{E}\left[(d\theta^T \nabla_\theta \log \pi_\theta(a|s))^2\right]
$$

这个度量反映了参数变化对策略分布的"实际影响"——沿着FIM特征值大的方向改变参数，策略分布变化大；沿着特征值小的方向改变参数，策略分布变化小。

TRPO的几何解释：

TRPO的约束优化问题等价于：

$$
\max_{\Delta\theta} \nabla_\theta J^T \Delta\theta \quad \text{s.t.} \quad \frac{1}{2}\Delta\theta^T \mathbf{F} \Delta\theta \leq \delta
$$

这是在一个椭球（由FIM定义）内沿梯度方向寻找最优步长。椭球的形状由各方向的FIM特征值决定——在"平坦"方向可以走更远，在"陡峭"方向需要更谨慎。

为什么这对大模型不可行：

对于7B参数的模型：
- FIM存储：$7\text{B} \times 7\text{B} \times 4\text{ bytes} \approx 196 \times 10^{18} \text{ bytes} = 196 \text{ EB}$
- 即使使用近似方法（如共轭梯度），每次迭代也需要 $O(n)$ 的矩阵-向量乘法
- 对于深层Transformer，Hessian近似误差累积严重

这一计算瓶颈促使了PPO的诞生。

3.4.2 PPO-Clip的近似推导

PPO（Proximal Policy Optimization, Schulman et al., 2017）的核心洞察是：与其精确求解带约束的优化问题（TRPO），不如在目标函数中直接"裁剪"概率比，使其不会偏离太远。

从TRPO到PPO-Clip的直觉

TRPO的目标函数中的概率比 $r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)}$ 是关键量：
- $r_t(\theta) = 1$：新策略和旧策略在该动作上的概率相同
- $r_t(\theta) > 1$：新策略增加了该动作的概率
- $r_t(\theta) < 1$：新策略减少了该动作的概率

TRPO通过KL约束间接限制 $r_t(\theta)$ 的范围。PPO则直接裁剪 $r_t(\theta)$：

$$
\text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) = \begin{cases} 1-\epsilon & \text{if } r_t(\theta) < 1-\epsilon \ r_t(\theta) & \text{if } 1-\epsilon \leq r_t(\theta) \leq 1+\epsilon \ 1+\epsilon & \text{if } r_t(\theta) > 1+\epsilon \end{cases}
$$

其中 $\epsilon$ 是一个小的超参数（通常0.1或0.2）。

PPO-Clip目标函数

PPO-Clip的目标函数定义如下：

$$
\boxed{L^{CLIP}(\theta) = \mathbb{E}_t\left[\min\left(r_t(\theta) \hat{A}_t, \; \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \cdot \hat{A}_t\right)\right]}
$$

其中：
- $r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)}$：概率比
- $\hat{A}_t$：时刻 $t$ 的优势估计（通常使用GAE）
- $\epsilon$：裁剪超参数（典型值0.2）

PPO-Clip的Case分析

PPO-Clip目标函数的设计非常精巧。让我们分情况讨论 $\min$ 和 $\text{clip}$ 的作用：

graph TD
    subgraph "PPO-Clip目标函数工作原理"
        direction TB

        Start["PPO-Clip<br/>min(r·A, clip(r)·A)"] --> A_pos["Âₜ > 0<br/>(动作好于平均)"]
        Start --> A_neg["Âₜ < 0<br/>(动作差于平均)"]

        A_pos --> P1["r < 1+ε:<br/>min取 r·A<br/>→ 正常增加概率 ✓"]
        A_pos --> P2["r ≥ 1+ε:<br/>min取 (1+ε)·A<br/>→ 梯度为0，截断 ✗"]

        A_neg --> N1["r > 1-ε:<br/>min取 clip·A<br/>→ 正常减少概率 ✓"]
        N2["r ≤ 1-ε:<br/>由于A<0, clip·A > r·A<br/>min取 r·A<br/>→ 继续减少概率 ✓"]
        A_neg --> N2

        style P1 fill:#e8f5e9
        style P2 fill:#ffebee
        style N1 fill:#e8f5e9
        style N2 fill:#e8f5e9
    end

Case 1：$\hat{A}_t > 0$（动作好于平均水平，应该增加概率）

Case 2：$\hat{A}_t < 0$（动作差于平均水平，应该减少概率）

总结：
- $\hat{A}_t > 0$：限制概率增加不超过 $1+\epsilon$ 倍
- $\hat{A}_t < 0$：不限制概率减少（可以继续减到0）
- $\min$ 操作：总是取更保守的估计，防止策略更新过大

3.4.3 PPO-Clip目标函数的完整形式

在实际应用中，PPO-Clip的目标函数包含三个部分：

$$
\boxed{\mathcal{L}^{PPO}(\theta) = \mathbb{E}t\left[L_t^{CLIP}(\theta) - c_1 \cdot L_t^{VF}(\theta) + c_2 \cdot H(\pi\theta(\cdot|s_t))\right]}
$$

（1）策略损失（Clip损失）：

$$
L_t^{CLIP}(\theta) = \min\left(r_t(\theta)\hat{A}_t, \; \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \cdot \hat{A}_t\right)
$$

这是PPO的核心，通过裁剪概率比限制策略更新幅度。

（2）价值损失（Critic损失）：

$$
L_t^{VF}(\theta) = (V_\phi(s_t) - V_t^{target})^2
$$

其中 $V_t^{target} = \hat{A}t + V{\phi_{\text{old}}}(s_t)$ 是回报目标，$c_1$ 是价值损失系数（通常0.5）。

（3）熵奖励（Entropy Bonus）：

$$
H(\pi_\theta(\cdot|s_t)) = -\sum_a \pi_\theta(a|s_t) \log \pi_\theta(a|s_t)
$$

熵奖励鼓励策略保持随机性，防止过早收敛到局部最优。$c_2$ 是熵系数（通常0.01）。

PPO训练流程概览：

```python

PPO训练伪代码（完整版）

for iteration in range(num_iterations):
# 1. 收集数据
trajectories = collect_trajectories(env, actor, num_steps)

# 2. 计算优势（GAE）
advantages = compute_gae(trajectories.rewards, trajectories.values, gamma, lam)

# 3. 多epoch更新
for epoch in range(num_epochs):
    for batch in trajectories.batches(batch_size):
        # 重新计算动作概率
        new_log_probs = actor(batch.states, batch.actions)
        ratio = torch.exp(new_log_probs - batch.old_log_probs)

        # Clip损失
        surr1 = ratio * batch.advantages
        surr2 = torch.clamp(ratio, 1-eps, 1+eps) * batch.advantages
        clip_loss = -torch.min(surr1, surr2).mean()

        # 价值损失
        values = critic(batch.states)
        value_loss = F.mse_loss(values, batch.returns)

        # 熵奖励
        entropy = actor.entropy(batch.states).mean()

        # 总损失
        loss = clip_loss + c1 * value_loss - c2 * entropy

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

```text

3.4.4 GAE：广义优势估计的推导

偏差-方差权衡问题

策略梯度的质量直接取决于优势估计 $\hat{A}_t$ 的质量。理想的优势估计应该：
- 无偏：期望等于真实优势 $\mathbb{E}[\hat{A}_t] = A^{\pi}(s_t, a_t)$
- 低方差：不同样本之间的波动小

但实际中这两个目标往往矛盾。考虑两种极端方法：

方法1：单步TD残差（$\hat{A}_t^{(1)}$）——低方差、高偏差

$$
\hat{A}t^{(1)} = r_t + \gamma V(s{t+1}) - V(s_t)
$$

只使用一步的奖励和价值估计，偏差大（依赖价值函数 $V$ 的准确性），但方差低。

方法2：蒙特卡洛（$\hat{A}_t^{(\infty)}$）——无偏、高方差

$$
\hat{A}t^{(\infty)} = \sum{l=0}^{T-t-1} \gamma^l r_{t+l} - V(s_t) = G_t - V(s_t)
$$

使用完整的累积回报，无偏，但方差随轨迹长度线性增长。

能否在两者之间找到一个平衡点？ GAE正是为此而生。

n步优势估计

定义n步优势估计为：

$$
\hat{A}t^{(n)} = \sum{l=0}^{n-1} \gamma^l r_{t+l} + \gamma^n V(s_{t+n}) - V(s_t)
$$

展开前几项：

• 1步优势（TD残差）：

$$
\hat{A}t^{(1)} = r_t + \gamma V(s{t+1}) - V(s_t) = \delta_t
$$

• 2步优势：

$$
\hat{A}t^{(2)} = r_t + \gamma r{t+1} + \gamma^2 V(s_{t+2}) - V(s_t) = \delta_t + \gamma \delta_{t+1}
$$

• n步优势：

$$
\hat{A}t^{(n)} = \sum{l=0}^{n-1} \gamma^l \delta_{t+l}
$$

其中 $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$ 是TD残差。

GAE的指数加权平均

GAE($\gamma, \lambda$) 的核心思想：将所有n步优势进行指数加权平均，通过参数 $\lambda$ 控制偏差-方差权衡。

$$
\hat{A}t^{GAE(\gamma, \lambda)} = (1-\lambda) \sum{n=1}^{\infty} \lambda^{n-1} \hat{A}_t^{(n)}
$$

展开：

$$
= (1-\lambda)\left[\hat{A}_t^{(1)} + \lambda \hat{A}_t^{(2)} + \lambda^2 \hat{A}_t^{(3)} + \cdots\right]
$$

递推形式推导

将 $\hat{A}t^{(n)} = \sum{l=0}^{n-1} \gamma^l \delta_{t+l}$ 代入：

$$
\hat{A}t^{GAE} = (1-\lambda) \sum{n=1}^{\infty} \lambda^{n-1} \sum_{l=0}^{n-1} \gamma^l \delta_{t+l}
$$

交换求和顺序（先对 $l$ 求和，再对 $n$ 求和）：

$$
= (1-\lambda) \sum_{l=0}^{\infty} \gamma^l \delta_{t+l} \sum_{n=l+1}^{\infty} \lambda^{n-1}
$$

内层求和是等比数列：

$$
\sum_{n=l+1}^{\infty} \lambda^{n-1} = \lambda^l + \lambda^{l+1} + \cdots = \frac{\lambda^l}{1-\lambda}
$$

代入：

$$
\hat{A}t^{GAE} = (1-\lambda) \sum{l=0}^{\infty} \gamma^l \delta_{t+l} \cdot \frac{\lambda^l}{1-\lambda} = \sum_{l=0}^{\infty} (\gamma\lambda)^l \delta_{t+l}
$$

得到闭式表达式：

$$
\boxed{\hat{A}t^{GAE(\gamma, \lambda)} = \sum{l=0}^{T-t-1} (\gamma\lambda)^l \delta_{t+l}}
$$

递推计算公式

GAE还可以写成高效的递推形式：

$$
\boxed{\hat{A}t = \delta_t + \gamma\lambda \cdot \hat{A}{t+1}}
$$

边界条件：$\hat{A}_T = 0$（终止状态的优势为0）

算法流程（从后向前递推）：

```python
def compute_gae(rewards, values, gamma=1.0, lam=1.0):
"""
计算Generalized Advantage Estimation

Args:
    rewards: [T] 即时奖励序列
    values: [T+1] 价值估计（包含最后一个状态的V(s_T)）
    gamma: 折扣因子
    lam: GAE参数

Returns:
    advantages: [T] 优势估计
    returns: [T] 回报目标（用于Critic训练）
"""
T = len(rewards)
advantages = torch.zeros(T)
gae = 0

# 逆序计算
for t in reversed(range(T)):
    if t == T - 1:
        next_value = values[t + 1] if len(values) > T else 0
    else:
        next_value = values[t + 1]

    # TD残差: δ_t = r_t + γV(s_{t+1}) - V(s_t)
    delta = rewards[t] + gamma * next_value - values[t]

    # GAE递推: Â_t = δ_t + γλÂ_{t+1}
    gae = delta + gamma * lam * gae
    advantages[t] = gae

# 回报 = 优势 + 价值
returns = advantages + values[:T]

return advantages, returns

```text

GAE参数的意义

graph TD
    subgraph "GAE计算流程图"
        direction TB

        Input["输入：<br/>rewards [T]<br/>values [T+1]"] --> Init["初始化：<br/>gae = 0<br/>Â_T = 0"]
        Init --> Loop["for t = T-1, T-2, ..., 0"]
        Loop --> Delta["计算TD残差：<br/>δₜ = rₜ + γV(sₜ₊₁) - V(sₜ)"]
        Delta --> Recur["递推：<br/>Âₜ = δₜ + γλÂₜ₊₁"]
        Recur --> Check{"t == 0?"}
        Check -->|否| Loop
        Check -->|是| Output["输出：<br/>advantages [T]<br/>returns = A + V"]

        style Input fill:#e3f2fd
        style Output fill:#e8f5e9
    end

LLM场景中的特殊设置：

在RLHF场景中，特别是对于推理任务（如数学/代码），奖励通常是稀疏的——只在序列末端给出（如答案正确/错误），中间token的奖励为0。此时：

• $\gamma = 1.0$：不设折扣，因为所有奖励集中在末尾
• $\lambda = 1.0$：纯蒙特卡洛估计，因为中间步骤的TD残差为0（$r_t = 0$ 对于 $t < T$），GAE退化为 $\hat{A}_t = G_t - V(s_t)$

这与OpenAI的InstructGPT、DeepSeek-R1等工作的超参数设置一致。

3.5 RLHF中的PPO训练

将PPO算法应用于大语言模型的对齐训练（即RLHF的第三阶段），是InstructGPT、ChatGPT等模型成功的核心技术。本节详解RLHF-PPO的四模型交互架构、KL散度约束机制以及完整的训练流程。

3.5.1 四模型交互架构（Actor/Critic/Reward/Reference）

RLHF-PPO训练同时涉及四个不同的模型，每个模型扮演不同的角色，构成一个复杂的交互系统。

graph TD
    subgraph "RLHF-PPO 四模型交互架构"
        X["Prompt x<br/>(batch_size, seq_len)"]

        ACTOR["Actor Model (π_θ)<br/>可训练<br/>SFT模型初始化<br/>生成回答 y"]
        REF["Reference Model (π_ref)<br/>冻结<br/>SFT模型副本<br/>KL散度锚点"]
        RM["Reward Model (r_φ)<br/>冻结<br/>阶段2训练<br/>打分 r(x,y)"]
        CRITIC["Critic Model (V_φ)<br/>可训练<br/>估计状态价值<br/>提供优势基线"]

        X --> ACTOR
        ACTOR --> Y["Generated Response y<br/>(batch_size, gen_len)"]

        Y --> RM
        RM --> R["Reward<br/>r(x,y) ∈ ℝ<br/>(batch_size,)"]

        Y --> REF
        REF --> KL["KL Divergence<br/>D_KL[π_θ‖π_ref]<br/>逐token累加"]

        X --> CRITIC
        CRITIC --> V["Value Estimate<br/>V(s_t) ∈ ℝ<br/>(batch_size, seq_len)"]

        R --> ADV["Advantage Â<br/>Â = R - KL - V(s)<br/>经GAE处理"]
        V --> ADV
        KL --> ADV

        ADV --> PPO["PPO Optimizer<br/>Clip损失 + 价值损失"]
        ACTOR --> PPO
        CRITIC --> PPO

        PPO -->|梯度更新| ACTOR
        PPO -->|梯度更新| CRITIC
    end

四个模型的职责详解

显存占用分析：在标准PPO训练设置中，四个模型同时驻留GPU显存。对于7B参数的模型（FP32精度），总显存占用约为 $28 \times 4 = 112$ GB，加上优化器状态、梯度和激活值，总需求可达 200-300 GB。这正是PPO训练的主要瓶颈之一。

Actor与Critic的关系

联合训练的必要性：

1. Critic提供准确的优势估计 $\hat{A}_t$，直接影响Actor的梯度质量
2. Actor的策略分布影响Critic的估计目标——策略变化后，状态分布变化，价值函数也需要更新
3. 共生关系：Critic越准确 → Actor梯度方差越小 → 训练越稳定；Actor策略越好 → Critic的估计目标越稳定 → Critic训练越容易

3.5.2 KL散度约束与训练稳定性

KL散度约束是RLHF-PPO训练中不可或缺的组件。没有KL约束，策略可能"欺骗"奖励模型（reward hacking），找到非预期的方式最大化奖励分数。

为什么必须加KL约束？

（1）防止Reward Hacking。奖励模型 $r_\phi$ 只是人类偏好的近似——它是一个有容量限制的神经网络，不可能完美建模人类的所有偏好维度。没有KL约束时，策略可能找到让 $r_\phi$ 打高分但人类实际不喜欢的"捷径"：
- 重复高分模式（如"the the the..."但恰好击中RM的偏好模式）
- 利用RM的长度偏见（生成冗长内容）
- 发现RM的特定漏洞（如在回答末尾添加特定标记）

（2）保持语言能力。SFT模型已经具备了较好的语言能力。KL约束确保优化后的策略不会偏离太远，保留基础的语言生成能力。

（3）训练稳定性。KL约束相当于一个"信任区域"，防止单步策略更新过大导致训练崩溃。

（4）保证可逆性。如果RL训练出现问题，KL约束保证模型不会偏离参考模型太远，可以从参考模型重新初始化。

KL散度的计算方式

在RLHF中，KL散度有以下几种计算方式：

方式1：逐token KL累加（最常用）

对于生成的序列 $y = (y_1, y_2, \ldots, y_T)$：

$$
\text{KL}(\pi_\theta \parallel \pi_{\text{ref}}) = \sum_{t=1}^{T} \log \frac{\pi_\theta(y_t | x, y_{<t})}{\pi_{\text{ref}}(y_t | x, y_{<t})}
$$

方式2：KL作为奖励惩罚

总奖励信号中减去KL惩罚：

$$
r_{\text{total}}(x, y) = r_\phi(x, y) - \beta \cdot \text{KL}(\pi_\theta(\cdot|x) \parallel \pi_{\text{ref}}(\cdot|x))
$$

方式3：自适应KL控制

动态调整 $\beta$ 使得KL散度维持在目标值 $d_{\text{target}}$：

$$
\beta_{t+1} = \beta_t \cdot \left(1 + \eta \cdot (\text{KL}{\text{current}} - d{\text{target}})\right)
$$

当当前KL大于目标值时，增大 $\beta$（加强约束）；反之则减小 $\beta$。

KL散度的方向问题

KL散度不是对称的，需要注意方向选择：

• $\text{KL}(\pi_\theta \parallel \pi_{\text{ref}})$（期望在 $\pi_\theta$ 下计算）：惩罚 $\pi_\theta$ 探索 $\pi_{\text{ref}}$ 不覆盖的区域（mode-seeking）。这是RLHF中的标准选择。
• $\text{KL}(\pi_{\text{ref}} \parallel \pi_\theta)$（期望在 $\pi_{\text{ref}}$ 下计算）：惩罚 $\pi_\theta$ 忽略 $\pi_{\text{ref}}$ 覆盖的区域（mode-covering）。

$\beta$ 参数的调节：

实践中 $\beta \in [0.01, 0.5]$，需要根据具体任务和奖励模型调整。

3.5.3 PPO训练流程详解

完整训练循环

graph TD
    subgraph "RLHF-PPO 完整训练循环"
        direction TB
    Init["初始化：<br/>Actor/Critic = SFT<br/>RM/Ref = 冻结"] --> Loop["训练循环"]

    Loop --> Step1["Step 1: 数据收集<br/>Actor生成回答<br/>存储经验到Buffer"]

    Step1 --> Step2["Step 2: 奖励计算<br/>RM打分 r(x,y)<br/>Ref计算逐token KL"]

    Step2 --> Step3["Step 3: 优势估计<br/>Critic计算V(s)<br/>GAE计算Â_t"]

    Step3 --> Step4["Step 4: 多epoch更新<br/>对经验Buffer<br/>进行4-8个epoch训练"]

    Step4 --> Step5["Step 5: 监控指标<br/>Reward/KL/Entropy<br/>检查收敛/异常"]

    Step5 --> Check{"继续训练?"}
    Check -->|是| Loop
    Check -->|否| End["输出优化后模型 π*"]

    style Step1 fill:#e3f2fd
    style Step2 fill:#fff3e0
    style Step3 fill:#f3e5f5
    style Step4 fill:#e8f5e9
    style End fill:#ffebee
end

PPO Trainer核心实现

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class PPOTrainer:
def init(self, actor, critic, reward_model, ref_model,
epsilon=0.2, beta=0.01, gamma=1.0, lam=1.0,
actor_lr=1e-5, critic_lr=1e-5, epochs=4):
self.actor = actor # 策略模型（可训练）
self.critic = critic # 价值模型（可训练）
self.reward_model = reward_model # 奖励模型（冻结）
self.ref_model = ref_model # 参考模型（冻结）

    # PPO超参数
    self.epsilon = epsilon          # Clip裁剪范围（0.1或0.2）
    self.beta = beta                # KL散度系数
    self.gamma = gamma              # 折扣因子（LLM通常1.0）
    self.lam = lam                  # GAE参数（通常0.95-1.0）
    self.epochs = epochs            # 每个batch的更新轮数

    # 优化器
    self.actor_opt = torch.optim.Adam(actor.parameters(), lr=actor_lr)
    self.critic_opt = torch.optim.Adam(critic.parameters(), lr=critic_lr)

    # 冻结RM和Ref
    for param in self.reward_model.parameters():
        param.requires_grad = False
    for param in self.ref_model.parameters():
        param.requires_grad = False

def compute_gae(self, rewards, values, action_mask):
    """
    计算GAE优势估计

    Args:
        rewards: [batch_size, seq_len] 逐token奖励（稀疏时大部分为0）
        values: [batch_size, seq_len] Critic估计的V(s_t)
        action_mask: [batch_size, seq_len] 实际生成token的mask

    Returns:
        advantages: [batch_size, seq_len] GAE优势
        returns: [batch_size, seq_len] 回报目标
    """
    batch_size, seq_len = rewards.shape
    advantages = torch.zeros_like(rewards)
    gae = 0

    # 逆序计算GAE
    for t in reversed(range(seq_len)):
        if t == seq_len - 1:
            next_value = torch.zeros(batch_size, device=rewards.device)
        else:
            next_value = values[:, t + 1]

        # TD残差: δ_t = r_t + γV(s_{t+1}) - V(s_t)
        delta = rewards[:, t] + self.gamma * next_value - values[:, t]

        # GAE递推: Â_t = δ_t + γλÂ_{t+1}
        gae = delta + self.gamma * self.lam * gae
        advantages[:, t] = gae

    # 只在实际生成的token上计算优势
    advantages = advantages * action_mask

    # 回报 = 优势 + 价值
    returns = advantages + values

    return advantages, returns

def compute_kl_penalty(self, actor_logits, ref_logits, action_mask):
    """
    计算逐token KL散度: KL(π_θ || π_ref)

    Args:
        actor_logits: [batch_size, seq_len, vocab_size]
        ref_logits: [batch_size, seq_len, vocab_size]
        action_mask: [batch_size, seq_len]

    Returns:
        kl: [batch_size, seq_len] 逐token KL
    """
    actor_log_probs = F.log_softmax(actor_logits, dim=-1)
    ref_log_probs = F.log_softmax(ref_logits, dim=-1)

    # KL = π_θ · (log π_θ - log π_ref) = E_π_θ[log π_θ - log π_ref]
    # 对于实际采样的动作，简化为逐token的差值
    kl_per_token = torch.sum(
        torch.exp(actor_log_probs) * (actor_log_probs - ref_log_probs),
        dim=-1
    )
    kl_per_token = kl_per_token * action_mask

    return kl_per_token

def ppo_update(self, experiences):
    """
    PPO核心更新循环

    Args:
        experiences: 包含以下字段的对象
            - states: [batch, seq_len] 输入token ids
            - actions: [batch, seq_len] 生成的token ids
            - old_action_log_probs: [batch, seq_len] π_old的log prob
            - rewards: [batch, seq_len] 逐token奖励
            - values: [batch, seq_len] Critic估计的V(s)
            - ref_logits: [batch, seq_len, vocab] 参考模型的logits
            - action_mask: [batch, seq_len] 生成token的mask
    """
    # 1. 计算KL散度惩罚
    kl_per_token = self.compute_kl_penalty(
        experiences.actor_logits, experiences.ref_logits, experiences.action_mask
    )

    # 2. 计算调整后的奖励（减去KL惩罚）
    adjusted_rewards = experiences.rewards - self.beta * kl_per_token

    # 3. 使用GAE计算优势
    advantages, returns = self.compute_gae(
        adjusted_rewards, experiences.values, experiences.action_mask
    )

    # 对优势进行标准化（有助于训练稳定性）
    advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)

    for epoch in range(self.epochs):
        for batch in experiences.batches():
            # 4. 重新计算当前策略的动作概率
            new_logits = self.actor(batch.states, attention_mask=batch.attn_mask)
            new_log_probs = F.log_softmax(new_logits, dim=-1)

            # 收集实际采取动作的log prob
            new_action_log_probs = torch.gather(
                new_log_probs, dim=-1, index=batch.actions.unsqueeze(-1)
            ).squeeze(-1) * batch.action_mask

            # 5. 计算概率比
            ratio = torch.exp(new_action_log_probs - batch.old_action_log_probs)

            # 6. PPO-Clip策略损失
            surr1 = ratio * batch.advantages
            surr2 = torch.clamp(ratio, 1 - self.epsilon, 1 + self.epsilon) * batch.advantages
            actor_loss = -torch.min(surr1, surr2).mean()

            # 7. Critic价值损失
            new_values = self.critic(batch.states, attention_mask=batch.attn_mask)
            critic_loss = F.mse_loss(
                new_values * batch.action_mask,
                batch.returns * batch.action_mask
            )

            # 8. 熵奖励（鼓励探索）
            entropy = -(torch.exp(new_log_probs) * new_log_probs).sum(dim=-1)
            entropy_loss = -(entropy * batch.action_mask).mean()

            # 9. 总损失
            total_loss = actor_loss + 0.5 * critic_loss + 0.01 * entropy_loss

            # 10. 反向传播
            self.actor_opt.zero_grad()
            self.critic_opt.zero_grad()
            total_loss.backward()

            # 梯度裁剪
            torch.nn.utils.clip_grad_norm_(self.actor.parameters(), 1.0)
            torch.nn.utils.clip_grad_norm_(self.critic.parameters(), 1.0)

            self.actor_opt.step()
            self.critic_opt.step()

    return {
        'actor_loss': actor_loss.item(),
        'critic_loss': critic_loss.item(),
        'mean_reward': experiences.rewards.sum(dim=1).mean().item(),
        'mean_kl': kl_per_token.sum(dim=1).mean().item()
    }

```text

训练监控与异常检测

Reward Model训练实现

在RLHF的第二阶段，需要训练一个奖励模型（Reward Model）来预测人类对回答的偏好。以下是完整的Reward Model训练代码：

```python
import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import AutoModel, AutoTokenizer

class RewardModel(nn.Module):
"""
奖励模型：基于预训练语言模型，增加线性头来输出标量奖励值
"""
def init(self, base_model_name, device='cuda'):
super().init()
self.base = AutoModel.from_pretrained(base_model_name)
self.score_head = nn.Linear(self.base.config.hidden_size, 1)
self.device = device
self.to(device)

def forward(self, input_ids, attention_mask=None):
    """
    前向传播

    Args:
        input_ids: [batch, seq_len] prompt + response的token ids
        attention_mask: [batch, seq_len] 注意力mask

    Returns:
        scores: [batch] 标量奖励值
    """
    outputs = self.base(input_ids=input_ids, attention_mask=attention_mask)
    hidden = outputs.last_hidden_state  # [batch, seq_len, hidden_size]

    # 使用最后一个非pad token的hidden state
    if attention_mask is not None:
        # 找到每个序列最后一个有效token的位置
        last_valid_idx = attention_mask.sum(dim=1) - 1  # [batch]
        pooled = hidden[torch.arange(hidden.size(0)), last_valid_idx]
    else:
        pooled = hidden[:, -1]  # 取最后一个token

    score = self.score_head(pooled).squeeze(-1)  # [batch]
    return score

class RewardModelTrainer:
"""
奖励模型训练器：使用Bradley-Terry模型训练
"""
def init(self, model, lr=1e-5, weight_decay=0.01):
self.model = model
self.optimizer = torch.optim.AdamW(
model.parameters(), lr=lr, weight_decay=weight_decay
)

def bt_loss(self, chosen_scores, rejected_scores):
    """
    Bradley-Terry损失函数

    Args:
        chosen_scores: [batch] 偏好回答的奖励值 r(x, y_w)
        rejected_scores: [batch] 非偏好回答的奖励值 r(x, y_l)

    Returns:
        loss: 标量损失
        metrics: 监控指标
    """
    # P(y_w > y_l) = σ(r(x, y_w) - r(x, y_l))
    # 损失 = -log σ(r_chosen - r_rejected) = -log P(y_w > y_l)
    logits = chosen_scores - rejected_scores
    loss = -F.logsigmoid(logits).mean()

    # 监控指标
    accuracy = (logits > 0).float().mean()
    margin = logits.mean()

    metrics = {
        'loss': loss.item(),
        'accuracy': accuracy.item(),
        'margin': margin.item(),
        'chosen_mean': chosen_scores.mean().item(),
        'rejected_mean': rejected_scores.mean().item()
    }

    return loss, metrics

def train_step(self, batch):
    """
    单步训练

    Args:
        batch: 包含以下字段
            - chosen_input_ids: [batch, seq_len] 偏好回答
            - chosen_attention_mask: [batch, seq_len]
            - rejected_input_ids: [batch, seq_len] 非偏好回答
            - rejected_attention_mask: [batch, seq_len]
    """
    # 1. 计算偏好回答的奖励
    chosen_scores = self.model(
        batch.chosen_input_ids,
        attention_mask=batch.chosen_attention_mask
    )

    # 2. 计算非偏好回答的奖励
    rejected_scores = self.model(
        batch.rejected_input_ids,
        attention_mask=batch.rejected_attention_mask
    )

    # 3. 计算BT损失
    loss, metrics = self.bt_loss(chosen_scores, rejected_scores)

    # 4. 反向传播
    self.optimizer.zero_grad()
    loss.backward()

    # 梯度裁剪
    torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)

    self.optimizer.step()

    return metrics

def prepare_preference_data(prompts, chosen_responses, rejected_responses, tokenizer, max_length=512):
"""
准备偏好数据

Args:
    prompts: 提示列表
    chosen_responses: 偏好回答列表
    rejected_responses: 非偏好回答列表
    tokenizer: 分词器
    max_length: 最大长度

Returns:
    batch: 准备好的batch数据
"""
chosen_inputs = []
rejected_inputs = []

for prompt, chosen, rejected in zip(prompts, chosen_responses, rejected_responses):
    # 编码prompt + response
    chosen_text = prompt + chosen
    rejected_text = prompt + rejected

    chosen_encoded = tokenizer(
        chosen_text, max_length=max_length, truncation=True,
        padding='max_length', return_tensors='pt'
    )
    rejected_encoded = tokenizer(
        rejected_text, max_length=max_length, truncation=True,
        padding='max_length', return_tensors='pt'
    )

    chosen_inputs.append(chosen_encoded)
    rejected_inputs.append(rejected_encoded)

# 合并batch
batch = {
    'chosen_input_ids': torch.cat([x['input_ids'] for x in chosen_inputs]),
    'chosen_attention_mask': torch.cat([x['attention_mask'] for x in chosen_inputs]),
    'rejected_input_ids': torch.cat([x['input_ids'] for x in rejected_inputs]),
    'rejected_attention_mask': torch.cat([x['attention_mask'] for x in rejected_inputs])
}

return batch

Reward Model训练流程示例

"""

1. 加载基础模型

model = RewardModel('meta-llama/Llama-2-7b-hf')

2. 创建训练器

trainer = RewardModelTrainer(model, lr=1e-5)

3. 训练循环

for epoch in range(3):
for batch in dataloader:
metrics = trainer.train_step(batch)
print(f"Loss: {metrics['loss']:.4f}, Accuracy: {metrics['accuracy']:.4f}")

# 保存检查点
torch.save(model.state_dict(), f'reward_model_epoch_{epoch}.pt')

"""
```text

Reward Model训练的关键技巧

1. 数据质量重于数量

奖励模型的性能高度依赖偏好数据的质量。低质量的偏好数据（标注不一致、噪声大）会导致奖励模型学到错误的偏好模式，进而误导PPO训练。

• 标注一致性过滤：计算标注者之间的一致性（如Cohen's Kappa），剔除低一致性的数据
• 多轮标注：对关键数据进行多轮标注，取多数投票
• 困难样本挖掘：关注模型"不确定"的偏好对（奖励差值接近0），这些样本包含更多信息

2. 防止奖励值发散

由于BT模型的尺度不变性，奖励值可能无限增长。正则化技巧：

$$
\mathcal{L}{RM}^{total} = \mathcal{L}{RM} + \lambda \cdot \mathbb{E}[r_\phi(x, y)^2]
$$

其中 $\lambda$ 是正则化系数（通常 $10^{-3}$ 到 $10^{-4}$）。

3. 奖励模型的泛化能力

奖励模型需要在PPO训练过程中评估策略生成的、训练时未见过的回答（分布外泛化）。提升泛化能力的方法：

• 数据多样性：覆盖广泛的主题、风格和难度
• 对抗训练：用当前策略生成的"对抗性"回答作为负例
• Dropout和权重衰减：防止过拟合

3.6 DPO：直接偏好优化

PPO-RLHF虽然在实践中取得了巨大成功，但其训练流程复杂——需要维护四个模型、调优大量超参数（clip范围、GAE参数、KL系数、学习率等），且训练不稳定。DPO（Direct Preference Optimization, Rafailov et al., NeurIPS 2023）通过一项优雅的数学发现，将复杂的强化学习问题转化为简单的分类问题，大幅简化了对齐训练。

3.6.1 从奖励模型到DPO目标的推导

核心发现：最优策略的闭式解

DPO的出发点是以下KL约束下的RL优化问题（与PPO-RLHF的目标相同）：

$$
\max_{\pi} \; \mathbb{E}{x \sim \mathcal{D}, y \sim \pi(\cdot|x)}[r(x, y)] \; - \; \beta \cdot \mathbb{D}{KL}[\pi(y|x) \parallel \pi_{\text{ref}}(y|x)]
$$

DPO的关键洞察：这个带KL约束的优化问题有一个闭式解！

推导过程：

对于固定的提示 $x$，我们需要优化：

$$
\max_{\pi(\cdot|x)} \; \sum_y \pi(y|x) r(x,y) \; - \; \beta \sum_y \pi(y|x) \log \frac{\pi(y|x)}{\pi_{\text{ref}}(y|x)}
$$

$$
\text{s.t.} \quad \sum_y \pi(y|x) = 1
$$

构造拉格朗日函数：

$$
\mathcal{L}(\pi) = \sum_y \pi(y|x) r(x,y) - \beta \sum_y \pi(y|x) \log \frac{\pi(y|x)}{\pi_{\text{ref}}(y|x)} + \lambda(x)\left(\sum_y \pi(y|x) - 1\right)
$$

对 $\pi(y|x)$ 求导并令为0：

$$
\frac{\partial \mathcal{L}}{\partial \pi(y|x)} = r(x,y) - \beta \left(\log \frac{\pi(y|x)}{\pi_{\text{ref}}(y|x)} + 1\right) + \lambda(x) = 0
$$

解得：

$$
\log \frac{\pi(y|x)}{\pi_{\text{ref}}(y|x)} = \frac{r(x,y)}{\beta} - 1 + \frac{\lambda(x)}{\beta}
$$

$$
\pi^*(y|x) = \pi_{\text{ref}}(y|x) \cdot \exp\left(\frac{r(x,y)}{\beta} - 1 + \frac{\lambda(x)}{\beta}\right)
$$

令 $Z(x) = \exp\left(1 - \frac{\lambda(x)}{\beta}\right)$，则：

$$
\boxed{\pi^*(y|x) = \frac{1}{Z(x)} \pi_{\text{ref}}(y|x) \exp\left(\frac{r(x,y)}{\beta}\right)}
$$

其中归一化常数 $Z(x) = \sum_y \pi_{\text{ref}}(y|x) \exp\left(\frac{r(x,y)}{\beta}\right)$ 是配分函数。

逆向表达奖励函数

从最优策略的闭式解中，我们可以逆向表达奖励函数：

$$
r(x, y) = \beta \log \frac{\pi^*(y|x)}{\pi_{\text{ref}}(y|x)} + \beta \log Z(x)
$$

关键观察：$\beta \log Z(x)$ 只依赖于 $x$，不依赖于 $y$。由于Bradley-Terry模型只关心奖励的相对差值，这一项在偏好建模中会被消去！

这意味着：如果我们用参数化策略 $\pi_\theta$ 替代 $\pi^$，就可以隐式*地定义奖励函数：

$$
r_\theta(x, y) = \beta \log \frac{\pi_\theta(y|x)}{\pi_{\text{ref}}(y|x)}
$$

这是DPO的核心创新——不需要显式训练奖励模型，策略模型本身就编码了隐式奖励函数。

3.6.2 DPO损失函数的完整形式

推导DPO损失

1. 将隐式奖励代入BT模型：

偏好概率为：

$$
p_\theta(y_w \succ y_l | x) = \sigma(r_\theta(x, y_w) - r_\theta(x, y_l))
$$

1. 展开奖励差值：

$$
r_\theta(x, y_w) - r_\theta(x, y_l) = \beta \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}
$$

定义对数概率差：

$$
\Delta(x, y_w, y_l) = \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}
$$

1. 构建最大似然损失：

对偏好数据集最大化对数似然：

$$
\boxed{\mathcal{L}{DPO}(\pi\theta; \pi_{\text{ref}}) = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}}\left[\log \sigma\left(\beta \cdot \Delta(x, y_w, y_l)\right)\right]}
$$

展开：

$$
\mathcal{L}{DPO} = -\mathbb{E}{(x, y_w, y_l) \sim \mathcal{D}}\left[\log \sigma\left(\beta \left(\log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\right)\right)\right]
$$

DPO的梯度分析

DPO损失函数的梯度揭示了其学习机制：

$$
\nabla_\theta \mathcal{L}{DPO} = -\mathbb{E}{(x, y_w, y_l)}\left[\nabla_\theta \log \sigma(\beta \Delta)\right]
$$

链式法则展开：

$$
= -\mathbb{E}{(x, y_w, y_l)}\left[\frac{1}{\sigma(\beta\Delta)} \cdot \sigma(\beta\Delta)(1-\sigma(\beta\Delta)) \cdot \beta \nabla\theta \Delta\right]
$$

$$
= -\mathbb{E}{(x, y_w, y_l)}\left[(1-\sigma(\beta\Delta)) \cdot \beta \nabla\theta \Delta\right]
$$

展开 $\nabla_\theta \Delta$：

$$
\nabla_\theta \Delta = \nabla_\theta \log \pi_\theta(y_w|x) - \nabla_\theta \log \pi_\theta(y_l|x)
$$

最终梯度公式：

$$
\boxed{\nabla_\theta \mathcal{L}{DPO} = -\beta \cdot \mathbb{E}{(x,y_w,y_l)}\left[\underbrace{\sigma(\hat{r}\theta(x,y_l) - \hat{r}\theta(x,y_w))}{\text{权重}} \cdot \underbrace{(\nabla\theta \log \pi_\theta(y_w|x) - \nabla_\theta \log \pi_\theta(y_l|x))}_{\text{方向}}\right]}
$$

梯度解读：
- 权重 $\sigma(\hat{r}\theta(x,y_l) - \hat{r}\theta(x,y_w))$：模型对偏好的"不确定度"
- 当 $\hat{r}\theta(x,y_w) \gg \hat{r}\theta(x,y_l)$（已正确排序）：权重 $\approx 0$，梯度很小
- 当 $\hat{r}\theta(x,y_w) \approx \hat{r}\theta(x,y_l)$（不确定）：权重 $\approx 0.5$，梯度最大
- 方向：增加偏好回答的概率，减少非偏好回答的概率

为什么DPO能自动衰减：当模型已经正确排序所有偏好对时，梯度自然趋于零，训练自动停止——这相当于一种隐式的早停机制。

DPO Trainer实现

```python
import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import AutoModelForCausalLM

class DPOTrainer:
def init(self, model, ref_model, beta=0.1, lr=5e-7):
"""
DPO训练器

    Args:
        model: 训练模型（π_θ），可训练
        ref_model: 参考模型（π_ref），冻结
        beta: 温度参数（通常0.1-0.5）
        lr: 学习率
    """
    self.model = model
    self.ref_model = ref_model
    self.beta = beta
    self.optimizer = torch.optim.AdamW(model.parameters(), lr=lr)

    # 冻结参考模型
    for param in self.ref_model.parameters():
        param.requires_grad = False

def compute_log_probs(self, model, input_ids, attention_mask, labels):
    """
    计算序列的条件对数概率

    Args:
        model: 语言模型
        input_ids: [batch, seq_len] 输入token ids（prompt + response）
        attention_mask: [batch, seq_len] 注意力mask
        labels: [batch, seq_len] 标签（-100表示不参与计算的位置）

    Returns:
        sequence_log_probs: [batch] 每个序列的总对数概率
    """
    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
    logits = outputs.logits  # [batch, seq_len, vocab_size]

    # 计算log probs
    log_probs = F.log_softmax(logits, dim=-1)  # [batch, seq_len, vocab_size]

    # 收集目标token的log prob
    per_token_logps = torch.gather(
        log_probs, dim=2, index=labels.unsqueeze(2)
    ).squeeze(2)  # [batch, seq_len]

    # 只计算实际生成token的位置（labels != -100）
    valid_mask = labels.ne(-100).float()
    per_token_logps = per_token_logps * valid_mask

    # 序列总对数概率
    sequence_log_probs = per_token_logps.sum(dim=1)  # [batch]

    return sequence_log_probs

def dpo_loss(self, batch):
    """
    DPO损失函数

    Args:
        batch: 包含以下字段
            - chosen_input_ids: [batch, seq_len] 偏好回答的完整输入
            - chosen_attention_mask: [batch, seq_len]
            - chosen_labels: [batch, seq_len]
            - rejected_input_ids: [batch, seq_len] 非偏好回答的完整输入
            - rejected_attention_mask: [batch, seq_len]
            - rejected_labels: [batch, seq_len]

    Returns:
        loss: 标量损失
        metrics: 监控指标字典
    """
    # 1. 计算π_θ对偏好/非偏好回答的对数概率
    policy_chosen_logps = self.compute_log_probs(
        self.model,
        batch.chosen_input_ids,
        batch.chosen_attention_mask,
        batch.chosen_labels
    )
    policy_rejected_logps = self.compute_log_probs(
        self.model,
        batch.rejected_input_ids,
        batch.rejected_attention_mask,
        batch.rejected_labels
    )

    # 2. 计算π_ref对偏好/非偏好回答的对数概率（不计算梯度）
    with torch.no_grad():
        ref_chosen_logps = self.compute_log_probs(
            self.ref_model,
            batch.chosen_input_ids,
            batch.chosen_attention_mask,
            batch.chosen_labels
        )
        ref_rejected_logps = self.compute_log_probs(
            self.ref_model,
            batch.rejected_input_ids,
            batch.rejected_attention_mask,
            batch.rejected_labels
        )

    # 3. 计算隐式奖励
    policy_ratio = policy_chosen_logps - policy_rejected_logps
    ref_ratio = ref_chosen_logps - ref_rejected_logps

    # 4. DPO损失: -log σ(β * (policy_ratio - ref_ratio))
    logits = self.beta * (policy_ratio - ref_ratio)
    loss = -F.logsigmoid(logits).mean()

    # 5. 监控指标
    chosen_rewards = self.beta * (policy_chosen_logps - ref_chosen_logps)
    rejected_rewards = self.beta * (policy_rejected_logps - ref_rejected_logps)

    metrics = {
        'loss': loss.item(),
        'reward_margin': (chosen_rewards - rejected_rewards).mean().item(),
        'accuracy': (chosen_rewards > rejected_rewards).float().mean().item(),
        'chosen_reward': chosen_rewards.mean().item(),
        'rejected_reward': rejected_rewards.mean().item()
    }

    return loss, metrics

def train_step(self, batch):
    """单步训练"""
    self.optimizer.zero_grad()
    loss, metrics = self.dpo_loss(batch)
    loss.backward()

    # 梯度裁剪
    torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)

    self.optimizer.step()
    return metrics

```text

3.6.3 DPO vs PPO的深入对比

graph LR
    subgraph "DPO vs PPO 路径对比图"
        direction TB

        subgraph "PPO路径（RLHF）"
            P1["偏好数据<br/>(x, y_w, y_l)"] --> P2["训练Reward Model<br/>BT损失"]
            P2 --> P3["Reward Model<br/>r_φ(x,y)"]
            P4["Prompt x"] --> P5["Actor π_θ<br/>生成回答"]
            P5 --> P3
            P3 --> P6["奖励信号 r(x,y)"]
            P5 --> P7["Reference π_ref"]
            P7 --> P8["KL散度"]
            P6 --> P9["PPO优化<br/>在线采样"]
            P8 --> P9
            P10["Critic V_φ"] --> P9
        end

        subgraph "DPO路径（直接优化）"
            D1["偏好数据<br/>(x, y_w, y_l)"] --> D2["DPO损失<br/>分类问题"]
            D2 --> D3["直接优化<br/>π_θ"]
            D4["π_ref（冻结）"] --> D2
        end

        style P9 fill:#fff3e0
        style D2 fill:#e8f5e9
    end

全面对比

DPO的核心优势

1. 简单高效：将RL问题转化为监督学习，工程实现极其简洁
2. 训练稳定：无需调PPO的超参数，没有在线采样的方差问题
3. 资源友好：只需维护两个模型（$\pi_\theta$ 和 $\pi_{\text{ref}}$），显存需求约为PPO的40-50%
4. 理论优雅：从KL约束RL的闭式解出发，推导严谨

DPO的局限性

1. 分布外（OOD）问题：DPO是离线方法，无法探索训练数据分布外的回答。如果偏好数据不够多样化，模型性能可能受限于数据覆盖范围。

2. 长度偏见：DPO损失中的 $\log \pi_\theta(y|x)$ 是序列的累积对数概率。对于更长的序列，即使每个token的平均概率相同，总对数概率的绝对值也更大。这导致DPO倾向于偏好更长的回答。

3. 过拟合风险：当偏好数据有噪声时，DPO容易过拟合——它会为 $y_w$ 赋予极高概率、为 $y_l$ 赋予极低概率，导致隐式奖励发散。

4. 对参考模型依赖：DPO的性能高度依赖参考模型的质量。如果 $\pi_{\text{ref}}$ 本身不够好，DPO的优化空间受限。

长度偏见的缓解方法：

3.7 GRPO：组相对策略优化（重点专题）

GRPO（Group Relative Policy Optimization）是DeepSeek-AI在训练DeepSeekMath和DeepSeek-R1系列模型时提出的强化学习算法。它在PPO的基础上做出了一个革命性的简化——完全去掉Critic网络，用组内采样的相对评估替代价值函数估计。这一设计不仅大幅降低了显存占用，还天然适配了LLM推理任务（数学/代码）的奖励稀疏特点。

3.7.1 GRPO的核心思想：去掉Critic网络

PPO的Critic困境

在传统PPO中，Critic网络 $V_\phi(s)$ 承担着估计状态价值的重任，为优势函数 $A(s,a) = Q(s,a) - V(s)$ 提供基线。然而在LLM场景中，Critic面临几个根本性挑战：

（1）状态空间巨大。LLM的状态 $s_t$ 是已生成的token序列 $(x, y_{<t})$，其空间是组合爆炸的。训练一个准确的Critic需要覆盖极其广泛的状态分布。

（2）价值估计困难。在推理任务中（如数学题求解），一个部分正确的推理步骤到底"值多少分"是一个极其困难的判断。即使是人类专家也难以准确评估一条未完成推理链的期望最终成功率。

（3）显存消耗高。Critic通常与Actor同规模， doubling显存需求。对于7B参数的模型，这意味着额外28GB的显存占用。

GRPO的洞察：用组内相对评估替代Critic

GRPO的核心洞察来自于一个简单的事实：对于同一个问题，生成多个回答后，我们不需要一个绝对的价值估计——只需要知道"哪个回答比平均好"就够了。

具体而言：
- 对于问题 $q$，从旧策略 $\pi_{\theta_{\text{old}}}$ 采样 $G$ 个回答 ${o_1, o_2, \ldots, o_G}$
- 计算每个回答的奖励 ${r_1, r_2, \ldots, r_G}$
- 用组内奖励的均值 $\mu = \frac{1}{G}\sum_{i=1}^G r_i$ 替代Critic的价值估计
- 每个回答的优势就是其奖励与均值的偏差（标准化后）

这就是GRPO的核心——用统计替代学习，用相对比较替代绝对估计。

3.7.2 组内采样与相对奖励计算

组内采样策略

对于每个问题（提示）$q$，GRPO执行以下采样过程：

1. 从旧策略 $\pi_{\theta_{\text{old}}}$ 独立采样 $G$ 个回答：

$$
o_i \sim \pi_{\theta_{\text{old}}}(\cdot | q), \quad i = 1, 2, \ldots, G
$$

1. 对每个回答计算奖励（通常使用规则奖励函数或奖励模型）：

$$
r_i = \text{Reward}(q, o_i), \quad i = 1, 2, \ldots, G
$$

在DeepSeek-R1的训练中，Reward通常是确定性规则：
- 数学问题：答案正确 → $r = 1$，错误 → $r = 0$
- 代码问题：测试用例通过 → $r = 1$，否则 → $r = 0$

组内归一化计算优势

Step 1：计算组内统计量

$$
\mu = \frac{1}{G}\sum_{i=1}^G r_i, \quad \sigma = \sqrt{\frac{1}{G}\sum_{i=1}^G (r_i - \mu)^2 + \epsilon}
$$

其中 $\epsilon$ 是一个小常数（如 $10^{-8}$），防止除以零。

Step 2：计算标准化优势

$$
\boxed{\hat{A}_i = \frac{r_i - \mu}{\sigma}}
$$

关键设计：同一回答的所有token共享相同的优势值 $\hat{A}_i$。这种outcome-level reward assignment意味着：如果最终答案正确，推理过程中每个token都获得正优势；如果最终答案错误，所有token都获得负优势。

为什么相对评估有效？

1. 消除绝对尺度依赖。不同问题的绝对奖励差异很大（简单数学题全对vs困难题全错），但相对排序比绝对分数更稳定。

2. 自归一化。$\hat{A}_i = \frac{r_i - \mu}{\sigma}$ 天然标准化到零均值、单位方差，不需要额外的缩放。

3. 问题难度无关。简单问题（全对）和难问题（全错）都被归一化处理——组内比较消除了问题难度的影响。

4. 符合推理任务特点。推理任务的奖励通常只在序列末端给出（正确/错误），中间步骤无即时奖励。在这种情况下，Critic根本无法从中间步骤学到有用的价值信号。

3.7.3 GRPO损失函数的完整推导

从策略梯度到GRPO

Step 1：从策略梯度定理出发

策略梯度定理的标准形式：

$$
\nabla_\theta J(\theta) = \mathbb{E}{(s,a) \sim \pi\theta}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot A^{\pi_\theta}(s, a)\right]
$$

Step 2：PPO的优势估计

PPO使用Critic估计的基线：

$$
\hat{A}^{PPO}(s, a) = R(s, a) - V_\phi(s)
$$

Step 3：GRPO的核心替换——用组内均值替代Critic

对于问题 $q$ 和回答 $o_i$，定义其优势为组内归一化奖励：

$$
\hat{A}^{GRPO}(q, o_i) = \frac{r_i - \mu}{\sigma}
$$

其中 $\mu = \frac{1}{G}\sum_{j=1}^G r_j$，$\sigma = \sqrt{\frac{1}{G}\sum_{j=1}^G (r_j - \mu)^2 + \epsilon}$。

Step 4：构建GRPO-PClip目标

将GRPO的优势代入PPO-Clip框架。对于回答 $o_i$ 中的第 $t$ 个token：

$$
\rho_{i,t}(\theta) = \frac{\pi_\theta(o_{i,t} | q, o_{i,<t})}{\pi_{\theta_{\text{old}}}(o_{i,t} | q, o_{i,<t})}
$$

GRPO的目标函数为：

$$
\boxed{\mathcal{L}{GRPO}(\theta) = -\frac{1}{G}\sum{i=1}^G \frac{1}{|o_i|}\sum_{t=1}^{|o_i|} \min\left(\rho_{i,t}(\theta) \hat{A}i, \; \text{clip}(\rho{i,t}(\theta), 1-\epsilon, 1+\epsilon) \cdot \hat{A}_i\right)}
$$

Step 5：加入KL散度正则化

为了防止策略从参考模型漂移太远，加入KL散度项：

$$
\mathcal{L}{GRPO}^{total}(\theta) = \mathcal{L}{GRPO}(\theta) - \beta \cdot \frac{1}{G}\sum_{i=1}^G \text{KL}(\pi_\theta(\cdot | q, o_{i,<t}) \parallel \pi_{\text{ref}}(\cdot | q, o_{i,<t}))
$$

完整形式：

$$
\boxed{\mathcal{L}{GRPO}^{total}(\theta) = -\frac{1}{G}\sum{i=1}^G \left[\frac{1}{|o_i|}\sum_{t=1}^{|o_i|} \min\left(\rho_{i,t} \hat{A}i, \text{clip}(\rho{i,t}, 1-\epsilon, 1+\epsilon) \hat{A}i\right) - \beta \cdot \text{KL}{i,t}\right]}
$$

各项含义解读

3.7.4 GRPO与PPO的架构对比分析

graph TD
    subgraph "PPO vs GRPO 架构对比"
        direction LR
    subgraph "PPO架构（4模型）"
        direction TB
        P_Q["Prompt q"]
        P_Actor["Actor π_θ<br/>可训练<br/>生成回答"]
        P_Critic["Critic V_φ<br/>可训练<br/>估计V(s)<br/>❌ 需要大量显存"]
        P_RM["Reward Model<br/>r_φ<br/>冻结"]
        P_Ref["Reference π_ref<br/>冻结"]

        P_Q --> P_Actor
        P_Actor --> P_y["回答 y"]
        P_y --> P_RM
        P_RM --> P_r["奖励 r"]
        P_y --> P_Ref
        P_Ref --> P_KL["KL散度"]
        P_Critic --> P_V["V(s)"]

        P_r --> P_Adv["A = r - KL - V(s)"]
        P_V --> P_Adv
        P_KL --> P_Adv

        P_Adv --> P_Clip["PPO-Clip<br/>更新Actor + Critic"]
        P_Clip --> P_A_Update["更新 Actor"]
        P_Clip --> P_C_Update["更新 Critic"]

        style P_Critic fill:#ffebee
        style P_C_Update fill:#ffebee
    end

    subgraph "GRPO架构（2-3模型）"
        direction TB
        G_Q["Prompt q"]
        G_Actor["Actor π_θ<br/>可训练<br/>生成G个回答"]
        G_Reward["Reward Function<br/>规则/可验证<br/>无需学习"]
        G_Ref["Reference π_ref<br/>冻结"]

        G_Q --> G_Actor
        G_Actor --> G_G["{o₁, o₂, ..., o_G}<br/>组采样"]
        G_G --> G_Reward
        G_Reward --> G_R["{r₁, r₂, ..., r_G}"]

        G_R --> G_Adv["A_i = (r_i - μ) / σ<br/>组内归一化<br/>✅ 无需学习"]

        G_G --> G_Ref
        G_Ref --> G_KL["KL散度"]

        G_Adv --> G_Clip["PPO-Clip<br/>仅更新Actor"]
        G_KL --> G_Clip
        G_Clip --> G_Update["更新 Actor"]

        G_NoCritic["❌ Critic<br/>不需要<br/>节省显存"]
        style G_NoCritic fill:#e8f5e9
        style G_Adv fill:#e8f5e9
        style G_Update fill:#e8f5e9
    end
end

架构核心差异：

从策略梯度视角的统一理解

GRPO可以视为PPO在特定约束下的自然推广：

关系：当 $G \rightarrow \infty$ 且策略分布不变时，$\mu \rightarrow \mathbb{E}[r] \approx V^*(s)$。因此GRPO的基线可以看作是对最优价值函数的"蒙特卡洛估计"——用有限样本的均值替代了学习得到的近似值。

3.7.5 显存节省的量化计算

标准PPO的显存占用

假设使用FP32精度（4 bytes/参数）：

实际场景：通常使用FP16/BF16混合精度，可将显存减半至约140 GB。即便如此，训练7B模型的PPO仍需要4-8张A100（80GB）。

GRPO的显存占用

GRPO去掉Critic直接节省约112 GB显存（从280GB降到约168GB在混合精度下），占总训练显存的 40%。

更深层的节省：
- 不需要存储Critic的前向传播激活值（激活检查点的节省）
- 不需要在每次PPO更新时计算Critic的前向/反向传播
- 训练循环更简单，减少框架开销

实际训练中的显存优化技巧

```python

1. 使用梯度检查点（Gradient Checkpointing）

model.gradient_checkpointing_enable()

用时间换空间：重新计算前向传播而非存储激活值

2. 混合精度训练

from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()
with autocast(dtype=torch.bfloat16):
loss = grpo_loss(...)
scaler.scale(loss).backward()

3. 参考模型CPU卸载

只在需要KL散度时将ref_model加载到GPU

class CPUOffloadRefModel:
def forward(self, args, kwargs):
self.ref_model.to('cuda')
output = self.ref_model(args, **kwargs)
self.ref_model.to('cpu')
return output

4. 批量KL计算

不存储整个生成序列的KL，而是逐chunk计算

```text

3.7.6 DeepSeek-R1中的应用

GRPO在DeepSeek-R1的训练中发挥了核心作用。本节分析DeepSeek-R1的奖励设计、超参数选择和训练策略。

奖励函数设计

DeepSeek-R1-Zero采用纯规则的奖励系统，避免使用学习的奖励模型，从根本上消除了reward hacking的可能。

1. 准确性奖励（Accuracy Reward）

$$
r_{accuracy} = \begin{cases} 1 & \text{if answer is correct} \ 0 & \text{otherwise} \end{cases}
$$

• 数学问题：通过规则提取最终答案（LaTeX解析或数值比较），判断是否正确
• 代码问题：编译+执行，检查测试用例是否全部通过

2. 格式奖励（Format Reward）

$$
r_{format} = \begin{cases} 1 & \text{if } \langle think \rangle \text{ and } \langle answer \rangle \text{ tags present} \ 0 & \text{otherwise} \end{cases}
$$

• 强制模型将推理过程放在 <think>...</think> 标签内
• 强制最终答案放在 <answer>...</answer> 标签内
• 正确格式化给予正奖励，否则惩罚

3. 语言一致性奖励（Language Consistency Reward）

$$
r_{language} = \begin{cases} 1 & \text{if response language matches query} \ 0 & \text{otherwise} \end{cases}
$$

• 惩罚在中英文之间随意切换
• 鼓励使用与问题相同的语言回答

总奖励：

$$
r = r_{accuracy} + \lambda_{format} \cdot r_{format} + \lambda_{lang} \cdot r_{language}
$$

设计原则：
- 奖励函数必须是确定性的、可验证的（verifiable rewards）
- 规则简单明确，不给模型留下"钻空子"的空间
- 避免使用学习的奖励模型（learning-based RM），防止reward hacking

DeepSeek-R1的典型超参数

为什么 $\gamma = \lambda = 1.0$？

推理任务的奖励具有高度稀疏性——只在序列末端给出（答案正确/错误），中间推理步骤无即时奖励。在这种设定下：

• TD残差 $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t) = 0$（对于 $t < T$，因为 $r_t = 0$）
• 最后的TD残差 $\delta_T = r_T + 0 - V(s_T)$
• GAE退化为：$\hat{A}t = \delta_t + \gamma\lambda \hat{A}{t+1} = 0 + 1 \cdot \hat{A}{t+1} = \hat{A}{t+1}$
• 因此 $\hat{A}_t = r_T - V(s_T)$ 对所有 $t$ 相同

这等价于蒙特卡洛估计——每个token共享序列末端的奖励信号。

优势崩溃问题与解决方案

问题描述：当组内所有回答的奖励相同时（如全对或全错）：
- $\sigma = 0$（标准差为零）
- 所有 $\hat{A}_i = \frac{r_i - \mu}{\sigma + \epsilon} \approx 0$
- 梯度 $\approx 0$，训练停滞

这被称为优势崩溃（Advantage Collapse），在实践中非常常见：
- 问题太简单 → 所有回答都正确 → 奖励全同
- 问题太难 → 所有回答都错误 → 奖励全同

监控指标——ACR（Advantage Collapse Rate）：

$$
ACR = \frac{\text{组内标准差} < \epsilon \text{ 的组数}}{\text{总组数}}
$$

解决方案：

GRPO Trainer实现

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class GRPOTrainer:
def init(self, model, ref_model, reward_fn,
group_size=8, epsilon=0.2, beta=0.04, lr=1e-6):
"""
GRPO训练器

    Args:
        model: Actor策略模型（π_θ），可训练
        ref_model: 参考模型（π_ref），冻结
        reward_fn: 奖励函数（规则或可学习的）
        group_size: 组大小G（每个问题采样的回答数）
        epsilon: PPO裁剪参数
        beta: KL散度系数
        lr: 学习率
    """
    self.model = model
    self.ref_model = ref_model
    self.reward_fn = reward_fn
    self.G = group_size
    self.epsilon = epsilon
    self.beta = beta
    self.optimizer = torch.optim.AdamW(model.parameters(), lr=lr)

    # 冻结参考模型
    for param in self.ref_model.parameters():
        param.requires_grad = False

def generate_group_responses(self, prompts, max_length=512):
    """
    为每个prompt生成G个回答

    Args:
        prompts: [batch_size, prompt_len] 提示token ids
        max_length: 最大生成长度

    Returns:
        responses: list of G tensors [batch_size, gen_len]
        old_log_probs: list of G tensors [batch_size, gen_len]
    """
    all_responses = []
    all_log_probs = []

    for _ in range(self.G):
        # 从当前策略采样生成
        with torch.no_grad():
            outputs = self.model.generate(
                prompts,
                max_length=max_length,
                do_sample=True,
                temperature=0.9,
                return_dict_in_generate=True,
                output_scores=True,
                pad_token_id=self.model.config.pad_token_id
            )

        responses = outputs.sequences  # [batch, prompt_len + gen_len]

        # 计算每个token的log prob（在旧策略下）
        with torch.no_grad():
            log_probs = self.compute_token_log_probs(responses)

        all_responses.append(responses)
        all_log_probs.append(log_probs)

    return all_responses, all_log_probs

def compute_token_log_probs(self, sequences):
    """
    计算序列中每个token的log prob

    Args:
        sequences: [batch_size, seq_len] token ids

    Returns:
        log_probs: [batch_size, seq_len] 每个token的log prob
    """
    outputs = self.model(input_ids=sequences)
    logits = outputs.logits[:, :-1, :]  # [batch, seq_len-1, vocab]

    # 收集实际token的log prob
    target_ids = sequences[:, 1:]  # 预测的下一个token
    log_probs = F.log_softmax(logits, dim=-1)
    token_log_probs = torch.gather(
        log_probs, dim=-1, index=target_ids.unsqueeze(-1)
    ).squeeze(-1)

    # padding
    result = torch.zeros_like(sequences, dtype=torch.float)
    result[:, 1:token_log_probs.size(1)+1] = token_log_probs

    return result

def compute_advantages(self, rewards):
    """
    组内归一化计算优势

    Args:
        rewards: [batch_size, G] 每个prompt的G个回答的奖励

    Returns:
        advantages: [batch_size, G] 归一化优势
    """
    # 组内均值和标准差
    mean = rewards.mean(dim=1, keepdim=True)  # [batch, 1]
    std = rewards.std(dim=1, keepdim=True) + 1e-8  # [batch, 1]

    # 标准化
    advantages = (rewards - mean) / std  # [batch, G]

    return advantages

def compute_kl_penalty(self, sequences):
    """
    计算逐token KL散度: KL(π_θ || π_ref)

    Args:
        sequences: [batch_size, seq_len]

    Returns:
        kl: [batch_size, seq_len] 逐token KL
    """
    with torch.no_grad():
        ref_outputs = self.ref_model(input_ids=sequences)
        ref_logits = ref_outputs.logits[:, :-1, :]
        ref_log_probs = F.log_softmax(ref_logits, dim=-1)

    outputs = self.model(input_ids=sequences)
    logits = outputs.logits[:, :-1, :]
    log_probs = F.log_softmax(logits, dim=-1)

    # KL(π_θ || π_ref) = E_π_θ[log π_θ - log π_ref]
    target_ids = sequences[:, 1:]

    # 收集目标token的log probs
    model_target_logps = torch.gather(
        log_probs, dim=-1, index=target_ids.unsqueeze(-1)
    ).squeeze(-1)

    ref_target_logps = torch.gather(
        ref_log_probs, dim=-1, index=target_ids.unsqueeze(-1)
    ).squeeze(-1)

    kl = model_target_logps - ref_target_logps  # [batch, seq_len-1]

    # padding
    result = torch.zeros(sequences.size(0), sequences.size(1),
                       device=sequences.device)
    result[:, 1:kl.size(1)+1] = kl

    return result

def grpo_loss(self, prompts, old_responses, old_log_probs, rewards):
    """
    GRPO损失函数

    Args:
        prompts: [batch_size, prompt_len]
        old_responses: list of G tensors [batch_size, seq_len]
        old_log_probs: list of G tensors [batch_size, seq_len]
        rewards: [batch_size, G] 奖励值

    Returns:
        loss: 标量损失
        metrics: 监控指标
    """
    batch_size = prompts.size(0)

    # 1. 计算组内归一化优势
    advantages = self.compute_advantages(rewards)  # [batch, G]

    # 2. 计算KL散度
    kl_losses = []
    for i in range(self.G):
        kl = self.compute_kl_penalty(old_responses[i])  # [batch, seq_len]
        kl_losses.append(kl)

    # 3. 计算策略损失
    total_policy_loss = 0
    total_kl_loss = 0

    for i in range(self.G):
        # 重新计算当前策略的log probs
        new_log_probs = self.compute_token_log_probs(old_responses[i])

        # 计算概率比
        ratio = torch.exp(new_log_probs - old_log_probs[i])  # [batch, seq_len]

        # PPO-Clip
        # advantages[:, i] shape: [batch] -> [batch, 1] for broadcasting
        adv = advantages[:, i:i+1]  # [batch, 1]

        surr1 = ratio * adv  # [batch, seq_len]
        surr2 = torch.clamp(ratio, 1 - self.epsilon, 1 + self.epsilon) * adv

        policy_loss = -torch.min(surr1, surr2).mean()
        kl_loss = kl_losses[i].mean()

        total_policy_loss += policy_loss
        total_kl_loss += kl_loss

    # 4. 平均
    avg_policy_loss = total_policy_loss / self.G
    avg_kl_loss = total_kl_loss / self.G

    # 5. 总损失
    total_loss = avg_policy_loss + self.beta * avg_kl_loss

    # 6. 监控指标
    metrics = {
        'loss': total_loss.item(),
        'policy_loss': avg_policy_loss.item(),
        'kl_loss': avg_kl_loss.item(),
        'mean_reward': rewards.mean().item(),
        'reward_std': rewards.std().item(),
        'advantage_mean': advantages.mean().item(),
        'advantage_std': advantages.std().item()
    }

    return total_loss, metrics

def train_step(self, prompts):
    """
    GRPO单步训练

    Args:
        prompts: [batch_size, prompt_len] 提示

    Returns:
        metrics: 监控指标
    """
    # 1. 为每个prompt生成G个回答
    responses, old_log_probs = self.generate_group_responses(prompts)

    # 2. 计算奖励 [batch_size, G]
    rewards_list = []
    for i in range(self.G):
        # 从responses中提取生成部分（去掉prompt）
        batch_rewards = []
        for j in range(prompts.size(0)):
            prompt_len = prompts.size(1)
            gen_text = responses[i][j, prompt_len:]
            r = self.reward_fn(prompts[j], gen_text)
            batch_rewards.append(r)
        rewards_list.append(torch.tensor(batch_rewards, device=prompts.device))

    rewards = torch.stack(rewards_list, dim=1)  # [batch, G]

    # 3. 计算损失并更新
    self.optimizer.zero_grad()
    loss, metrics = self.grpo_loss(prompts, responses, old_log_probs, rewards)
    loss.backward()

    # 梯度裁剪
    torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)

    self.optimizer.step()

    return metrics

```text

3.7.7 GRPO的变体与前沿进展

DAPO（Dynamic Attention-based Policy Optimization）

DAPO解决GRPO训练中的梯度方差问题：

• 动态batch大小：根据训练状态动态调整batch大小
• 自适应采样策略：根据ACR指标调整采样temperature
• 目标：缓解梯度方差，提高训练稳定性

AVSPO（Adaptive Virtual Sample Policy Optimization）

AVSPO专门针对优势崩溃问题：

• ACR诊断指标：实时监控优势崩溃率
• 虚拟样本注入：当ACR过高时，注入人工创造的虚拟奖励样本
• 效果：在同质组中创造差异，打破优势崩溃

LamPO（Lambda-style Policy Optimization）

LamPO改进GRPO的组内统计丢失细粒度信息的问题：

• Pairwise Decomposed Advantage：用两两比较替代标量组统计
• ROUGE-L辅助奖励：减少奖励稀疏性
• 保留更多比较信息：在排序中保留差异的幅度信息

3.7.8 GRPO的理论分析

GRPO作为PPO的特例

从理论上严格分析，GRPO可以被视为PPO在特定约束下的特例。我们从策略梯度定理的统一视角来理解这一关系。

命题：GRPO的优势估计 $\hat{A}_i^{GRPO} = \frac{r_i - \mu}{\sigma}$ 等价于PPO的蒙特卡洛优势估计 $\hat{A}_t^{MC} = G_t - b(s_t)$，其中基线 $b(s_t) = \mu$ 是组内均值而非学习得到的价值函数。

证明：

在PPO中，优势估计的一般形式为：

$$
\hat{A}t^{PPO} = R(\tau) - V\phi(s_t)
$$

在GRPO中，对于问题 $q$ 和回答 $o_i$：

$$
\hat{A}_i^{GRPO} = \frac{r_i - \mu}{\sigma}
$$

令 $b(q) = \mu = \frac{1}{G}\sum_{j=1}^G r_j$，则：

$$
\hat{A}_i^{GRPO} = \frac{r_i - b(q)}{\sigma}
$$

除以 $\sigma$ 是对优势的标准化处理（控制方差），不改变策略优化的方向（因为 $\sigma > 0$ 对于所有组都是相同的标量）。

因此，GRPO的核心操作与PPO完全一致——都是从累积奖励中减去基线来估计优势。区别在于：

当GRPO收敛到PPO：

当组大小 $G \rightarrow \infty$ 时（假设回答质量服从某个分布），由大数定律：

$$
\mu = \frac{1}{G}\sum_{j=1}^G r_j \rightarrow \mathbb{E}{o \sim \pi{\theta_{old}}}[r(q, o)] = V^{\pi_{\theta_{old}}}(q)
$$

即组内均值收敛到真实的状态价值函数！此时GRPO的优势估计收敛到PPO的最优蒙特卡洛估计：

$$
\hat{A}_i^{GRPO} \rightarrow \frac{r_i - V^{\pi}(q)}{\sigma}
$$

（差一个 $\sigma$ 的标准化因子，这相当于一个自适应的学习率调整。）

GRPO的方差分析

引理：设组内奖励 ${r_1, r_2, \ldots, r_G}$ 是独立同分布采样，方差为 $\sigma_r^2$。则GRPO标准化优势 $\hat{A}_i$ 的方差为：

$$
\text{Var}(\hat{A}_i) = \text{Var}\left(\frac{r_i - \mu}{\sigma}\right) = \frac{G-1}{G} \approx 1 \quad (\text{for large } G)
$$

这意味着GRPO天然将优势标准化到单位方差，不需要额外的梯度缩放——这是GRPO训练稳定性的理论保障。

与PPO的方差对比：

在PPO中，优势的方差取决于Critic的质量和GAE参数：

$$
\text{Var}(\hat{A}t^{PPO}) = \text{Var}(R_t) + \text{Var}(V\phi(s_t)) - 2\text{Cov}(R_t, V_\phi(s_t))
$$

如果Critic估计有偏或方差大，PPO的优势估计方差也随之增大。而GRPO的方差仅取决于组大小 $G$，与学习无关——这消除了Critic训练引入的不稳定性。

GRPO的偏差分析

GRPO的基线 $\mu = \frac{1}{G}\sum_j r_j$ 是真实价值 $V^*(q)$ 的无偏估计（假设回答从同一策略独立采样）：

$$
\mathbb{E}[\mu] = \mathbb{E}\left[\frac{1}{G}\sum_{j=1}^G r_j\right] = V^*(q)
$$

但由于组大小有限，$\mu$ 的估计有采样误差，其方差为 $\sigma_r^2/G$。这意味着：

• G越大：基线估计越准确，优势估计偏差越小
• G越小：基线估计噪声大，优势估计偏差大

实践中 $G=8$ 到 $16$ 提供了良好的偏差-方差权衡。

3.7.9 GRPO的工程实践指南

超参数调优建议

训练诊断检查清单

• [ ] ACR监控：优势崩溃率应低于20%，否则增大G或调整难度分布
• [ ] KL散度：应缓慢上升后平稳，不应激增
• [ ] 奖励均值：应稳步上升，反映策略改进
• [ ] Entropy：应缓慢下降但不过快（防止mode collapse）
• [ ] 回答长度：应合理增长，不应无限增长
• [ ] 梯度范数：应在合理范围内（如1e-3到1），不应爆炸或消失

GRPO的常见问题与解决方案

问题1：训练初期奖励不增长

可能原因：
- 学习率太小 → 增大学习率
- Group Size太小 → 增大G
- 奖励函数设计不合理 → 检查奖励信号

问题2：策略坍缩到单一模式

可能原因：
- Entropy下降过快 → 增大temperature或添加entropy bonus
- KL系数太大 → 适当减小$\beta$
- 优势崩溃 → 增大G或引入多样性奖励

问题3：KL散度过大

可能原因：
- KL系数太小 → 增大$\beta$
- Clip范围太大 → 减小$\epsilon$
- 学习率太大 → 降低学习率

3.8 其他对齐方法

除了RLHF（PPO）、DPO和GRPO这三大主流方法外，对齐领域还涌现出许多有价值的替代方案。本节介绍SLiC、IPO、KTO等改进算法，以及Constitutional AI和RLAIF等可扩展对齐框架。

3.8.1 SLiC、IPO、KTO

IPO（Identity Preference Optimization）

IPO（Azar et al., 2024）针对DPO的过拟合问题提出了改进。DPO的核心问题是：一旦偏好对被正确排序，梯度就趋于零——但此时模型的奖励值可能已经"挤压"在一起（reward collapse），模型虽然排序正确，但置信度不够高。

IPO的核心思想：不仅要求正确排序，还要求偏好对之间的奖励间隔锚定到固定值。

IPO损失函数：

$$
\boxed{\mathcal{L}{IPO}(\pi\theta, \pi_{\text{ref}}) = \mathbb{E}{(x, y_w, y_l) \sim \mathcal{D}}\left[\left(\log \frac{\pi\theta(y_w|x)\pi_{\text{ref}}(y_l|x)}{\pi_{\text{ref}}(y_w|x)\pi_\theta(y_l|x)} - \frac{1}{2\beta}\right)^2\right]}
$$

用隐式奖励 $r_\theta(x,y) = \beta \log \frac{\pi_\theta(y|x)}{\pi_{\text{ref}}(y|x)}$ 重写：

$$
\mathcal{L}{IPO} = \mathbb{E}\left[\left(r\theta(x, y_w) - r_\theta(x, y_l) - \frac{1}{2\beta}\right)^2\right]
$$

IPO vs DPO：

IPO的直观理解：DPO的目标是"排好序"，一旦排好序梯度就消失了；IPO的目标是"不仅排好序，还要保持固定的奖励间隔 $\frac{1}{2\beta}$"，这防止了模型把所有奖励值挤在一起。

KTO（Kahneman-Tversky Optimization）

KTO（Ethayarajh et al., 2024）基于行为经济学中的前景理论（Prospect Theory），提出了一个只需要二元反馈的对齐方法。

核心洞察：人类对收益和损失的感知是非对称的——损失厌恶（loss aversion）意味着人类对负面结果的敏感度高于正面结果。

KTO的另一个关键优势：不需要成对偏好数据，只需要知道一个输出对于给定输入是"好的"还是"坏的"（二元反馈）。这大大降低了数据收集成本。

KTO损失函数：

$$
\boxed{\mathcal{L}{KTO}(\pi\theta, \pi_{\text{ref}}) = \mathbb{E}{x,y \sim \mathcal{D}}\left[w(y)(1 - v{KTO}(x, y; \beta))\right]}
$$

其中：

$$
r_{KTO}(x, y) = \beta \log \frac{\pi_\theta(y|x)}{\pi_{\text{ref}}(y|x)}
$$

$$
z_{\text{ref}} = \mathbb{E}{x' \sim \mathcal{D}}\left[\beta \cdot \mathbb{D}{KL}(\pi_\theta(y'|x') \parallel \pi_{\text{ref}}(y'|x'))\right]
$$

$$
v_{KTO}(x, y; \beta) = \begin{cases} \sigma(r_{KTO}(x,y) - z_{\text{ref}}) & \text{if } y \sim y_{\text{desirable}}|x \ \sigma(z_{\text{ref}} - r_{KTO}(x,y)) & \text{if } y \sim y_{\text{undesirable}}|x \end{cases}
$$

$$
w(y) = \begin{cases} \lambda_D & \text{if desirable} \ \lambda_U & \text{if undesirable} \end{cases}
$$

KTO vs DPO：

SLiC（Sequence Likelihood Calibration）

SLiC（Zhao et al., 2023）结合校准损失（calibration loss）和正则化微调，使用hinge损失替代DPO的sigmoid损失。

SLiC-HF损失函数：

$$
\mathcal{L}{SLiC} = \mathbb{E}{(x, y_w, y_l)}\left[\max(0, \delta - \log \pi_\theta(y_w|x) + \log \pi_\theta(y_l|x))\right]
$$

其中 $\delta$ 是边际（margin）超参数。

SLiC与DPO的区别：
- SLiC使用hinge损失（类似SVM），DPO使用log-sigmoid损失
- SLiC的梯度在margin区域内是恒定的，DPO的梯度随置信度衰减
- SLiC对过拟合有一定鲁棒性

SimPO（Simple Preference Optimization）

SimPO（Meng et al., 2024）进一步简化了DPO——去掉参考模型，直接使用长度归一化的对数概率作为隐式奖励。

SimPO损失函数：

$$
\mathcal{L}{SimPO} = -\mathbb{E}{(x,y_w,y_l)}\left[\log \sigma\left(\frac{1}{|y_w|}\log \pi_\theta(y_w|x) - \frac{1}{|y_l|}\log \pi_\theta(y_l|x) - \gamma\right)\right]
$$

SimPO的改进：
- 去掉参考模型：不需要维护冻结的 $\pi_{\text{ref}}$，节省显存
- 长度归一化：显式处理长度偏见
- 引入边际：要求偏好间隔超过阈值 $\gamma$

3.8.2 Constitutional AI / RLAIF

Constitutional AI的原理

Constitutional AI（Bai et al., 2022）是Anthropic提出的对齐框架，其核心思想是：让AI模型根据一组预设的自然语言原则（称为"宪法"）来自我批评和自我修正，从而在没有人类直接标注的情况下实现对齐。

"宪法"（Constitution）是一组自然语言原则，例如：
- "选择最诚实和有帮助的回答"
- "避免种族歧视或性别歧视内容"
- "如果不知道答案，承认不知道"
- "不要协助非法或不道德的行为"

graph TD
    subgraph "Constitutional AI 两阶段流程"
        direction LR

        subgraph "阶段1：自批评与修正（SL）"
            S1_Q["Prompt x"]
            S1_Model["SFT Model"]
            S1_Resp["初始回答 y"]
            S1_Principle["采样宪法原则 c"]
            S1_Critique["自批评：<br/>'根据原则c，<br/>这个回答有什么问题？'"]
            S1_Revise["自修正：<br/>生成改进版 y'"]

            S1_Q --> S1_Model --> S1_Resp --> S1_Critique --> S1_Revise
            S1_Principle --> S1_Critique
        end

        subgraph "阶段2：RLAIF（AI反馈强化学习）"
            S2_Q["Prompt x"]
            S2_Model["当前策略 π_θ"]
            S2_Pair["生成成对回答<br/>(y₁, y₂)"]
            S2_AI_Judge["AI裁判<br/>根据宪法选择更好的"]
            S2_RM["训练偏好模型"]
            S2_RL["RL训练<br/>(PPO)"]

            S2_Q --> S2_Model --> S2_Pair --> S2_AI_Judge --> S2_RM --> S2_RL --> S2_Model
        end

        style S1_Q fill:#e3f2fd
        style S2_Q fill:#fff3e0
    end

Constitutional AI的核心步骤：

阶段1：监督学习（Self-Critique & Revision）

1. 模型对提示 $x$ 生成初始回答 $y$
2. 从"宪法"中随机采样一条原则 $c$
3. 模型根据 $c$ 批评自己的回答，生成批评文本
4. 模型根据批评修订回答，生成改进版 $y'$
5. 用修订后的 $(x, y')$ 对微调模型

这一阶段产生的数据称为"自批评数据"，用于监督微调。

阶段2：RLAIF（Reinforcement Learning from AI Feedback）

1. 模型对同一问题生成两个回答 $y_1, y_2$
2. AI裁判根据宪法原则选择更好的回答
3. 用AI标注的偏好数据训练奖励模型
4. 使用标准RL（如PPO）优化策略

RLAIF vs RLHF

RLAIF的核心优势：
- 可扩展性：不需要人类标注，可以无限扩展
- 一致性：AI裁判在所有数据上应用相同的标准，不存在人类标注者之间的不一致
- 可解释性：AI裁判的选择基于明确的原则，可以追溯和调试

RLAIF的局限性：
- 质量上限：AI裁判的质量受限于基础模型，可能不如高质量的人类标注
- 偏见传播：如果基础模型有偏见，RLAIF可能放大这些偏见
- 复杂偏好：对于微妙的主观偏好（如"有趣"vs"严肃"），AI裁判可能不如人类

多维度偏好处理

在实际应用中，人类对齐涉及多个维度（有帮助性、无害性、诚实性、简洁性等）。处理多维度偏好的方法包括：

1. 标量奖励加权：

$$
r_{total}(x, y) = w_1 \cdot r_{helpful}(x, y) + w_2 \cdot r_{harmless}(x, y) + w_3 \cdot r_{honest}(x, y)
$$

2. 多目标PPO：每个维度独立训练一个Critic，使用多目标优化算法。

3. 约束优化：主要优化帮助性，将无害性作为硬约束。

4. 条件偏好：在提示中指定优化目标。

在线DPO与迭代对齐

传统的DPO是一种离线方法——使用固定的偏好数据集训练后不再与环境交互。但在实践中，模型可以通过在线采样持续改进，这就是在线DPO（Online DPO）或迭代DPO的核心思想。

在线DPO的训练循环：

```text
初始化: π_θ = SFT模型, π_ref = SFT模型

for iteration = 1, 2, ..., N:
1. 用当前策略 π_θ 生成新的回答
2. 用RM或人类对新生成的回答进行偏好标注
3. 将新偏好数据加入训练集
4. 在更新的数据集上进行DPO训练
5. 可选: 更新 π_ref = π_θ（渐进式参考）
```text

代表方法：

在线DPO的优势：
- 持续探索和改进，不受初始数据分布限制
- 模型可以学习到自己的错误并纠正（类似自我对弈）
- 在实践中通常比单次DPO效果更好

在线DPO的挑战：
- 需要在线的RM或人类标注，增加了系统复杂度
- 训练稳定性可能不如离线DPO
- 如果生成质量差，新标注的数据可能噪声大

NLHF：纳什学习从人类反馈

传统RLHF将偏好优化建模为一个单人优化问题——最大化固定奖励函数的期望。但这种方法忽略了人类偏好本身的复杂性和不一致性。

NLHF（Nash Learning from Human Feedback, Munos et al., ICML 2023）提出了一个全新视角：将偏好优化建模为两个策略之间的纳什均衡问题。

核心思想：

两个策略 $\pi_1$ 和 $\pi_2$ 相互竞争：
- $\pi_1$ 试图生成更好的回答
- $\pi_2$ 试图生成 $\pi_1$ 难以击败的回答

纳什均衡条件：

$$
\pi_1^ \in \arg\max_{\pi_1} \mathbb{E}_{y_1 \sim \pi_1, y_2 \sim \pi_2^}[p(y_1 \succ y_2)]
$$

$$
\pi_2^ \in \arg\max_{\pi_2} \mathbb{E}_{y_1 \sim \pi_1^, y_2 \sim \pi_2}[p(y_2 \succ y_1)]
$$

在对称设定下，$\pi_1^ = \pi_2^ = \pi^*$，即策略达到自我一致——无法通过与自身比较来进一步改进。

NLHF的优势：
1. 自动课程学习：对手（自身旧版本）越来越强，驱动策略持续进化
2. 解决偏好不一致性：纳什均衡天然处理不一致的偏好
3. 理论保证：收敛到纳什均衡有理论保证

NLHF vs 传统RLHF：

对齐方法的演化趋势

从方法演化的角度，我们可以观察到几个重要趋势：

趋势1：从在线到离线再到混合
- PPO（在线采样）→ DPO（离线优化）→ 在线DPO（混合）
- 离线方法简单高效但探索受限，在线方法探索能力强但复杂
- 未来可能是两者的有机结合

趋势2：从四模型到两模型再到单模型
- PPO（4模型）→ DPO（2模型）→ SimPO（1模型，无参考模型）
- 不断简化的趋势反映了工程实践的需求
- 但简化不等于性能下降——关键在于找到正确的理论简化

趋势3：从学习奖励到规则奖励
- 传统RLHF：学习奖励模型（需要大量偏好数据）
- GRPO/DeepSeek-R1：规则奖励（正确/错误可验证）
- 这一趋势与推理任务的兴起密切相关

趋势4：从人类反馈到AI反馈
- RLHF：人类标注（高质量、高成本）
- RLAIF：AI标注（可扩展、低成本）
- 未来可能是人机协作的混合反馈

3.9 图解说明

本节汇总本章的核心架构图与流程图，提供全局视角的对比分析。

3.9.1 对齐方法全景对比

graph TD
    subgraph "大模型对齐方法全景图"
        direction TB

        Input["偏好数据<br/>(x, y_w, y_l) 或 (x, y, label)"]

        Input --> Online["在线方法<br/>(Online)"]
        Input --> Offline["离线方法<br/>(Offline)"]

        Online --> PPO["PPO-RLHF<br/>4个模型<br/>强探索"]
        Online --> GRPO["GRPO<br/>2-3个模型<br/>推理任务专用"]
        Online --> OnlineDPO["在线DPO<br/>迭代生成+偏好标注"]

        Offline --> DPO["DPO<br/>2个模型<br/>简单高效"]
        Offline --> IPO["IPO<br/>平方损失<br/>防过拟合"]
        Offline --> KTO["KTO<br/>二元反馈<br/>低成本"]
        Offline --> SimPO["SimPO<br/>无参考模型<br/>极简"]

        PPO --> PPO_Pros["✅ 探索能力强<br/>✅ 适用通用任务<br/>❌ 训练复杂<br/>❌ 显存需求高"]
        GRPO --> GRPO_Pros["✅ 显存节省<br/>✅ 推理任务专用<br/>✅ 训练稳定<br/>❌ 通用任务挑战"]
        DPO --> DPO_Pros["✅ 简单高效<br/>✅ 训练稳定<br/>✅ 资源友好<br/>❌ 分布外探索弱<br/>❌ 长度偏见"]
        IPO --> IPO_Pros["✅ 防过拟合<br/>✅ 始终有梯度<br/>❌ 计算稍复杂"]
        KTO --> KTO_Pros["✅ 二元反馈足够<br/>✅ 数据成本低<br/>❌ 理论较复杂"]
        SimPO --> SimPO_Pros["✅ 无参考模型<br/>✅ 显存最低<br/>❌ 缺少正则化"]

        style PPO fill:#fff3e0
        style GRPO fill:#e8f5e9
        style DPO fill:#e3f2fd
        style IPO fill:#f3e5f5
        style KTO fill:#fce4ec
        style SimPO fill:#e0f2f1
    end

3.9.2 PPO-Clip工作原理详解

graph LR
    subgraph "PPO-Clip目标函数工作原理"
        direction TB

        Start["概率比 r = π_θ / π_old"] --> CheckA["优势 Â > 0<br/>(动作好于平均)"]
        Start --> CheckB["优势 Â < 0<br/>(动作差于平均)"]

        CheckA --> CaseA1["r < 1+ε:<br/>min取 r·A<br/>→ 增加概率 ✓"]
        CheckA --> CaseA2["r ≥ 1+ε:<br/>min取 (1+ε)·A<br/>→ 梯度为0，截断 ✗"]

        CheckB --> CaseB1["r > 1-ε:<br/>min取 clip·A<br/>→ 减少概率 ✓"]
        CheckB --> CaseB2["r ≤ 1-ε:<br/>由于A<0,<br/>r·A < clip·A,<br/>min取 r·A<br/>→ 继续减少 ✓"]

        style CaseA1 fill:#c8e6c9
        style CaseA2 fill:#ffcdd2
        style CaseB1 fill:#c8e6c9
        style CaseB2 fill:#c8e6c9
    end

3.9.3 方法选型决策树

text 是否有高质量成对偏好数据? ├── 否 → 是否有二元反馈（好/坏）? │ ├── 是 → KTO │ └── 否 → 需要先收集偏好数据 └── 是 → 任务类型? ├── 推理任务（数学/代码）+ 可验证奖励 │ ├── 显存紧张 → GRPO │ └── 显存充足 → PPO 或 GRPO ├── 通用对话/对齐 │ ├── 计算资源有限 → DPO │ ├── 需要强探索能力 → PPO │ └── 防止过拟合 → IPO └── 需要最高效率 └── SimPO（无参考模型）text

3.9.4 RLHF数据流全景图

graph TD
    subgraph "RLHF完整数据流"
        direction TB

        subgraph "数据层"
            PT_Data["预训练数据<br/>（网页、书籍、代码）"]
            SFT_Data["SFT数据<br/>（人工撰写指令-回答）"]
            Pref_Data["偏好数据<br/>（成对比较标注）"]
        end

        subgraph "模型层"
            PT_Model["预训练模型<br/>GPT/LLaMA/Qwen"]
            SFT_Model["SFT模型<br/>π_SFT"]
            RM_Model["奖励模型<br/>r_φ"]
            Final_Model["对齐后模型<br/>π*"]
        end

        subgraph "训练阶段"
            Stage1["阶段1: 预训练<br/>自回归语言建模<br/>L = -Σ log p(x_t|x_<t)"]
            Stage2["阶段2: SFT<br/>监督微调<br/>L = -Σ log p(y_t|x,y_<t)"]
            Stage3["阶段3: RM训练<br/>BT损失<br/>L = -log σ(r_φ(y_w) - r_φ(y_l))"]
            Stage4["阶段4: RL优化<br/>PPO/DPO/GRPO<br/>max E[r] - β·KL"]
        end

        PT_Data --> Stage1
        Stage1 --> PT_Model
        PT_Model --> Stage2
        SFT_Data --> Stage2
        Stage2 --> SFT_Model
        SFT_Model --> Stage3
        Pref_Data --> Stage3
        Stage3 --> RM_Model
        SFT_Model --> Stage4
        RM_Model --> Stage4
        Stage4 --> Final_Model
    end

3.9.5 PPO vs GRPO 详细架构对比

graph TD
    subgraph "PPO vs GRPO 详细对比"
        direction LR

        subgraph "PPO Pipeline"
            P_Step1["1. Prompt Batch<br/>(x_1, x_2, ..., x_B)"] --> P_Step2
            P_Step2["2. Actor采样<br/>y_i ~ π_θ(·|x_i)"] --> P_Step3
            P_Step3["3. RM打分<br/>r_i = r_φ(x_i, y_i)"] --> P_Step4
            P_Step4["4. Critic估计<br/>V_i = V_φ(x_i)"] --> P_Step5
            P_Step5["5. KL计算<br/>KL_i = Σ log π_θ/π_ref"] --> P_Step6
            P_Step6["6. 优势计算<br/>Â_i = r_i - KL_i - V_i"] --> P_Step7
            P_Step7["7. PPO-Clip更新<br/>Actor + Critic"] --> P_Step8
            P_Step8["8. 下一批Prompt<br/>重复1-7"]
        end

        subgraph "GRPO Pipeline"
            G_Step1["1. Prompt<br/>x"] --> G_Step2
            G_Step2["2. 组采样<br/>{o_1, ..., o_G} ~ π_θ(·|x)"] --> G_Step3
            G_Step3["3. 规则奖励<br/>{r_1, ..., r_G}"] --> G_Step4
            G_Step4["4. 组内归一化<br/>μ = mean(r), σ = std(r)<br/>Â_i = (r_i - μ)/σ"] --> G_Step5
            G_Step5["5. KL计算<br/>KL_i = Σ log π_θ/π_ref"] --> G_Step6
            G_Step6["6. PPO-Clip更新<br/>仅更新Actor"] --> G_Step7
            G_Step7["7. 下一个Prompt<br/>重复1-6"]

            style G_Step4 fill:#e8f5e9
        end

        style P_Step4 fill:#ffebee
        style P_Step7 fill:#ffebee
    end

3.10 本章小结

核心知识脉络

本章系统讲解了大模型人类对齐与强化学习的完整理论体系，从基础到前沿的递进关系如下：

第一层：理论基础
- 策略梯度定理（3.3节）：所有策略优化算法的理论基石。通过数学推导，我们得到了 $ \nabla_\theta J(\theta) = \mathbb{E}[\nabla_\theta \log \pi_\theta(a|s) \cdot A(s,a)] $ 的标准形式，为后续的PPO、GRPO奠定了数学基础。

第二层：算法演进
- TRPO（3.4.1节）：通过KL散度约束引入"信任区域"思想，但计算代价高昂（需要FIM和共轭梯度）
- PPO-Clip（3.4.2-3.4.3节）：用裁剪机制替代精确约束，以 $O(n)$ 的计算复杂度达到了与TRPO相当的效果，成为深度学习时代RL的事实标准
- GAE（3.4.4节）：通过指数加权平均平衡偏差与方差，为PPO提供高质量的优势估计

第三层：LLM对齐应用
- RLHF-PPO（3.5节）：将PPO应用于LLM对齐，详解四模型（Actor/Critic/RM/Ref）交互架构、KL散度约束和完整训练流程
- DPO（3.6节）：从KL约束RL的闭式解出发，将强化学习问题优雅地转化为分类问题，大幅简化了对齐训练
- GRPO（3.7节）：去掉Critic网络，用组内相对评估替代价值函数估计，在推理任务上实现了显存节省和训练稳定的双重突破

第四层：前沿方法
- IPO/KTO/SimPO（3.8.1节）：DPO的改进变体，分别解决过拟合、数据效率和参考模型依赖问题
- Constitutional AI/RLAIF（3.8.2节）：用AI反馈替代人类反馈，实现了对齐训练的可扩展性

关键对比总结

工程实践要点

1. PPO训练稳定性：KL散度约束是必需的，$\beta$ 参数需要仔细调优。监控KL、Entropy和Reward三个指标是诊断训练健康度的关键。

2. DPO数据质量：DPO对偏好数据的质量高度敏感。长度匹配的偏好对可以有效缓解长度偏见。

3. GRPO的奖励设计：GRPO的成功高度依赖奖励函数的设计。确定性、可验证的奖励函数（如正确/错误规则）是关键。

4. 显存优化：混合精度训练（BF16）、梯度检查点和参考模型CPU卸载是降低显存需求的有效手段。

5. 方法选择：有高质量偏好数据+计算资源有限→DPO；推理任务+可验证奖励→GRPO；通用对齐+资源充足→PPO。

核心公式速查表

关键技术对比总结

工程实践常见问题FAQ

Q1: PPO训练中KL散度突然增大怎么办？

A: 首先检查$\beta$参数是否设置合理（通常0.01-0.2）。如果KL持续增大，可以：
- 增大$\beta$系数
- 减小学习率
- 检查是否有reward hacking现象
- 减小PPO的$\epsilon$参数

Q2: DPO训练后模型输出过长怎么办？

A: 这是DPO的常见长度偏见问题。解决方案：
- 使用长度归一化（SimPO方式）
- 在偏好数据构建时匹配长度
- 在损失中加入长度惩罚项
- 考虑直接使用SimPO

Q3: GRPO训练中遇到优势崩溃（所有回答奖励相同）怎么办？

A: 这是GRPO的已知问题。解决方案：
- 增大Group Size（从8增到16或32）
- 引入部分奖励（如ROUGE-L）
- 使用课程学习，避免同时全对/全错
- 考虑使用AVSPO注入虚拟样本

Q4: 应该选PPO还是DPO还是GRPO？

A: 选择取决于具体场景：
- 有高质量偏好数据+计算资源有限 → DPO
- 推理任务（数学/代码）+可验证奖励 → GRPO
- 通用对齐+需要强探索+资源充足 → PPO
- 只有二元反馈（好/坏） → KTO
- 防止DPO过拟合 → IPO

Q5: 奖励模型训练不收敛怎么办？

A: 可能的原因和解决方案：
- 数据质量差 → 过滤低一致性数据
- 标注噪声大 → 多轮标注取投票
- 奖励值发散 → 添加L2正则化
- 学习率不合适 → 尝试1e-6到1e-5之间

从理论到实践的建议学习路径

text Step 1: 理解策略梯度定理（3.3节）——理论基础 ↓ Step 2: 掌握PPO-Clip和GAE（3.4节）——核心算法 ↓ Step 3: 理解RLHF四模型架构（3.5节）——LLM应用 ↓ Step 4: 学习DPO的推导（3.6节）——简化方法 ↓ Step 5: 深入GRPO（3.7节）——前沿专题 ↓ Step 6: 了解其他方法（3.8节）——拓展视野text

参考文献

1. Schulman, J., Levine, S., Moritz, P., Jordan, M. I., & Abbeel, P. (2015). Trust Region Policy Optimization. International Conference on Machine Learning (ICML).

2. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., & Klimov, O. (2017). Proximal Policy Optimization Algorithms. arXiv:1707.06347.

3. Schulman, J., Moritz, P., Levine, S., Jordan, M., & Abbeel, P. (2015). High-Dimensional Continuous Control Using Generalized Advantage Estimation. arXiv:1506.02438.

4. Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D., & Finn, C. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Advances in Neural Information Processing Systems (NeurIPS).

5. Shao, Z., Wang, P., Zhu, Q., Xu, R., Song, J., Bi, X., Zhang, H., Zhang, M., Li, Y., Wu, Y., & Guo, D. (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv:2402.03300.

6. Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., Xu, R., Zhu, Q., Ma, S., Wang, P., Bi, X., et al. (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948.

7. Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., Zhang, C., Agarwal, S., Slama, K., Ray, A., et al. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems (NeurIPS), 35, 27730-27744.

8. Azar, M. G., Guo, Z. D., Piot, B., Munos, R., Rowland, M., Valko, M., & Calandriello, D. (2024). A General Theoretical Paradigm for Learning from Preferences. arXiv:2310.19828.

9. Ethayarajh, K., Xu, W., Muennighoff, N., Jurafsky, D., & Kiela, D. (2024). KTO: Model Alignment as Prospect Theoretic Optimization. arXiv:2402.01306.

10. Bai, Y., Kadavath, S., Kundu, S., Askell, A., Kernion, J., Jones, A., Chen, A., Goldie, A., Mirhoseini, A., McKinnon, C., et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.

11. Williams, R. J. (1992). Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning. Machine Learning, 8(3), 229-256.

12. Bradley, R. A., & Terry, M. E. (1952). Rank Analysis of Incomplete Block Designs: I. The Method of Paired Comparisons. Biometrika, 39(3/4), 324-345.

13. Munos, R., Perolat, J., Liu, B., Bobu, A., Gheshlaghi Azar, M., Lespiau, J. B., & Valko, M. (2023). Nash Learning from Human Feedback. International Conference on Machine Learning (ICML).

14. Meng, Y., Xia, M., & Chen, D. (2024). SimPO: Simple Preference Optimization with a Reference-Free Reward. arXiv:2405.14734.

15. Zhao, Y., Joshi, R., Liu, T., Khalman, M., Saleh, M., & Liu, P. J. (2023). SLiC-HF: Sequence Likelihood Calibration with Human Feedback. arXiv:2305.10425.

16. He, J., et al. (2025). AVSPO: Adaptive Virtual Sample Policy Optimization for Advantage Collapse in GRPO. arXiv preprint.

17. Yuan, Z., et al. (2025). LamPO: A Lambda Style Policy Optimization for Reasoning Language Models. arXiv preprint.

18. Sutton, R. S., & Barto, A. G. (2018). Reinforcement Learning: An Introduction (2nd ed.). MIT Press.

本章结束。通过本章的学习，读者应已掌握：策略梯度定理的完整推导、PPO-Clip的数学原理与工程实现、RLHF四模型架构的运作机制、DPO的闭式解推导、GRPO的去Critic架构设计与在DeepSeek-R1中的应用实践。这些知识构成了大模型对齐领域的核心理论体系，是理解和实现大模型人类对齐的必备基础。

第四章 混合专家模型（MoE）

"The capacity of a neural network can be increased without proportionally increasing its computation through conditional computation." — Yoshua Bengio, 2013

4.1 引言：从密集到稀疏的范式转变

4.1.1 密集模型的 Scaling Law 困境

自 Transformer 架构问世以来，大语言模型（LLM）的 Scaling Law 揭示了模型性能与参数量、数据量、计算量之间的幂律关系。然而，密集（Dense）模型遵循着一条残酷的等式：

$$\text{计算成本} \propto \text{参数总量} \propto \text{模型容量}$$

这意味着，若要将模型容量提升 $10$ 倍，训练与推理的计算成本也将同步增长 $10$ 倍。当模型规模迈向千亿乃至万亿参数级别时，这种"参数-计算"的刚性绑定使得训练成本变得难以承受。以 GPT-4（rumored 约 $1.8$ 万亿参数）为例，若采用密集架构，单次前向传播就需要约 $3.6 \times 10^{12}$ 次浮点运算——这在工程实践中已接近当前硬件集群的极限。

这一困境的根本矛盾在于：密集模型中所有参数对所有输入都"同等重要"。无论输入是关于法国大革命的历史问题，还是关于 Python 函数的编程问题，模型中的每一层、每一个参数都参与计算。这种"一刀切"的计算模式在大规模参数下产生了巨大的浪费。

4.1.2 条件计算：解耦参数与计算

条件计算（Conditional Computation）的核心思想最早由 Bengio 等人在 2013 年提出：模型根据输入动态决定激活网络的哪一部分，而非对所有输入执行相同的计算图。这一思想为"参数-计算解耦"提供了理论可能性：

$$\text{总参数量} \gg \text{每步激活参数量} \approx \text{实际计算量}$$

混合专家模型（Mixture of Experts, MoE）正是条件计算最成功的工程实现。MoE 的基本范式是：模型拥有大量参数（总参数量极大），但每个输入 token 只激活其中一小部分专家网络。以 DeepSeek-V3 为例，总参数量达 $671$B，但每个 token 仅激活 $37$B 参数，稀疏度低至约 $5.5\%$。这意味着模型在保持巨大知识容量的同时，实际计算开销仅相当于一个 $37$B 规模的密集模型。

条件计算的理论基础可以追溯到 Jacobs 和 Jordan 在 1990 年代早期的工作。他们将混合专家模型形式化为一个分层的概率系统，其中门控网络决定输入由哪个专家处理。然而，在深度学习时代之前，MoE 的应用受限于计算能力和数据规模。直到 2017 年 Shazeer 等人的突破性工作，MoE 才成功适配到深度神经网络中。

4.1.3 MoE 的发展脉络

MoE 的思想源远流长，其演进可划分为三个关键阶段：

第一阶段：理论奠基（1990s-2014）

1991 年，Jacobs、Jordan、Nowlan 和 Hinton 发表了《Adaptive mixtures of local experts》，首次提出了混合专家模型的基本框架。该工作的核心思想是：多个"专家"网络分别学习处理输入空间的不同区域，而一个"门控网络"决定每个输入由哪个专家处理。1994 年，Jordan 和 Jacobs 进一步提出了层次化混合专家模型（Hierarchical Mixture of Experts, HME），将 MoE 的思想扩展到树状结构中。

2013 年，Bengio 等人在《Estimating or propagating gradients through stochastic neurons for conditional computation》中，首次将条件计算的概念引入深度学习领域。这篇论文系统论述了通过随机神经元实现条件计算的可能性，为后来的大规模稀疏模型奠定了理论基础。

第二阶段：深度学习适配（2016-2020）

2017 年是 MoE 进入深度学习时代的关键年份。Shazeer、Mirhoseini、Maziarz 等人在 ICLR 上发表了里程碑式的论文《Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer》。这篇论文首次成功将 MoE 应用于深度神经网络（LSTM），提出了带噪声的 Top-k 门控机制，并在语言模型和机器翻译任务上验证了 MoE 的有效性。Shazeer 等人的工作证明了一个惊人的事实：使用 MoE 可以将 LSTM 的参数规模扩展到 $137$B，同时保持与 $10$B 密集模型相当的计算成本。

2020 年，Google 的 Lepikhin 等人在 ICLR 上发表了 GShard，将 MoE 推向千亿参数规模。GShard 不仅是一个模型，更是一个完整的分布式训练系统。它提出了 Expert Parallelism 范式，成功在 $2048$ 个 TPU v3 上训练了 $600$B 参数的 Transformer 模型。GShard 的成功证明了"条件计算 + 分布式训练"范式的工程可行性，开创了现代大规模 MoE 的先河。

第三阶段：成熟与普及（2021-至今）

2021 年，Google 的 Fedus、Zoph 和 Shazeer 发表了 Switch Transformer，将路由从 Top-2 大胆简化为 Top-1，并取得了更好的效果。这一"反直觉"的简化深刻影响了后续 MoE 的设计哲学：不再盲目追求复杂的路由机制，而是寻求工程简单性与模型质量的平衡。Switch Transformer 成功训练了 $1.6$T 参数的模型，比同等 FLOP 的密集模型快 $7$ 倍达到相同质量。

2023 年底，Mistral AI 发布了 Mixtral 8x7B，成为首个获得广泛关注和采用的开源 MoE 大模型。Mixtral 以仅 $12.9$B 的激活参数，在多数基准测试上超越了 LLaMA 2 70B 密集模型，以令人信服的方式证明了 MoE 的"性价比"优势。Mixtral 的成功极大地推动了 MoE 在开源社区的普及。

2024 年，DeepSeek-AI 先后发布了 DeepSeek-MoE、DeepSeek-V2 和 DeepSeek-V3，带来了细粒度专家分割、共享专家隔离、Loss-Free Balancing 和 FP8 训练等一系列重大创新。DeepSeek-V3 以 $671$B 总参数、$37$B 激活参数的规模，代表了当前公开可用的最先进 MoE 模型。

4.1.4 本章结构与学习目标

本章将系统深入地解析 MoE 的核心原理，从基础架构到前沿进展，层层递进。具体结构安排如下：

• 4.2 节：建立 MoE 的数学框架，详解门控网络、专家网络与 Top-k 路由机制，推导线性和条件计算的本质
• 4.3 节：剖析负载均衡问题，从数学定义出发完整推导辅助损失、Router Z-Loss，并深入介绍 Loss-Free Balancing 前沿方案
• 4.4 节：以重点专题形式深入分析专家坍缩的成因（正反馈循环数学模型）、检测指标与阈值设计、多层预防方案与分级恢复策略
• 4.5 节：讨论 MoE 的分布式训练与推理优化，包括 Expert Parallelism、All-to-All 通信分析与优化、推理调度策略
• 4.6 节：对比分析 GShard、Switch Transformer、Mixtral、DeepSeek-MoE、Qwen-MoE 等代表性模型
• 4.7 节：图解说明，以可视化形式汇总 MoE 的核心机制
• 4.8 节：本章小结，提供关键设计决策清单和核心公式速查

学习目标：阅读完本章后，读者应能：
1. 独立推导 MoE 的前向传播与损失函数
2. 理解负载均衡的数学本质，设计负载均衡方案
3. 设计专家坍缩的监控指标体系与恢复策略
4. 具备部署分布式 MoE 训练的工程判断力
5. 根据具体场景选择合适的 MoE 架构和超参数

4.2 MoE架构基础

4.2.1 稀疏MoE的设计哲学

4.2.1.1 从通用逼近到条件激活

密集模型的基本假设是：所有参数对所有输入都"同等重要"。这一假设在大规模模型中产生了巨大的计算浪费——对于一个关于"法国大革命"的问题，模型处理"代码语法"相关的参数同样被激活并参与计算。统计上，密集模型中相当一部分参数对任意特定输入都是"冗余"的。

MoE 的设计哲学则截然不同：将知识分片存储，按需激活。每个专家网络被期望学习特定类型的知识或处理特定类型的输入模式。门控网络作为"调度器"，根据输入的语义特征，将 token 路由到最合适的专家子集。这种设计暗含一个关键假设：

数据的异质性假设：自然语言数据具有内在的结构性差异（如代码 vs. 诗歌、数学 vs. 叙事、中文 vs. 英文），不同的子空间应该由不同的专家子网络处理。

这一假设在实践中得到了充分验证。DeepSeek 的分析表明，经过充分训练的 MoE 模型中，路由专家确实表现出明显的专业化倾向：某些专家主要处理代码 token，某些专家专注于数学符号，还有些专家负责处理特定语言的词汇。这种自然涌现的专业化是 MoE 有效性的核心来源。

4.2.1.2 稀疏性的两层含义

在 MoE 语境中，"稀疏性"具有精确的两层技术含义：

第一层：参数稀疏（Parameter Sparsity）
模型拥有大量参数，但每个 token 只使用一小部分。参数稀疏度定义为：

$$\text{稀疏度} = \frac{\text{激活参数量}}{\text{总参数量}}$$

各代表性模型的稀疏度对比如下表所示：

一个清晰的趋势浮现：越新的模型稀疏度越低（激活比例越小），追求更高的参数-计算比。DeepSeek-V3 以仅 $5.5\%$ 的激活比例，在 $37$B 激活参数的规模上达到了与数倍密集模型相当的性能。这种"极致稀疏"的趋势预示着 MoE 未来可能向更低的激活比例演进。

第二层：计算稀疏（Computation Sparsity）
每个 token 的前向传播只经过 $k$ 个专家而非全部 $N$ 个，计算图的绝大部分路径未被激活。这种计算稀疏性使得 MoE 能够在保持巨大参数量的同时，控制实际浮点运算量。

计算稀疏性的量化指标是激活计算比例：

$$\text{激活计算比例} = \frac{K}{N}$$

对于 Mixtral 8x7B（$K=2, N=8$），激活计算比例为 $25\%$；对于 DeepSeek-V3（$K=8, N=256$），激活计算比例仅为 $3.1\%$。

4.2.1.3 MoE层在Transformer中的位置

MoE 层并不替换 Transformer 的全部组件，而是精准地替代前馈网络（FFN）子层。标准 Sparse Transformer 的层结构如下：

text Input → LayerNorm → Multi-Head Attention → Residual Add → LayerNorm → MoE Layer (替代 FFN) → Residual Add → Outputtext

这一设计选择并非偶然，而是经过深思熟虑的工程决策。以下是几个关键原因：

1. 计算量集中
FFN 层占 Transformer 总计算量的约 $2/3$。Attention 的计算复杂度为 $O(S^2 \cdot d)$，FFN 的计算复杂度为 $O(S \cdot d_{ff} \cdot d)$。对于长序列，FFN 的计算占比更高。因此，将 FFN 替换为 MoE 能获得最大的计算节省。

2. 结构特性适配
FFN 对每个 token 独立处理（无 token 间交互），天然适合并行分割。每个 token 可以被独立路由到不同的专家。相比之下，Attention 需要全局信息交互，不适合条件计算——如果将 Attention 改为 MoE，每个 token 需要与不同子集的 token 做注意力，通信模式将变得极其复杂。

3. 工程可行性
FFN MoE 的 All-to-All 通信模式简单（按 token 分发）。Attention MoE 的通信模式复杂（涉及序列间的注意力图），实现难度极大。大量实验也表明 FFN MoE 已能获得显著提升，而 Attention MoE 的研究尚处于早期阶段。

4. 硬件友好
FFN 的核心运算是矩阵乘法，可充分利用 GPU/TPU 的张量核心。MoE 的稀疏激活模式与硬件的批处理能力相匹配。

因此，MoE 仅替换 FFN 层已成为业界标准实践。所有主流的 MoE 模型（GShard、Switch Transformer、Mixtral、DeepSeek 系列）都遵循这一设计。

4.2.2 门控网络与专家网络的结构

4.2.2.1 专家网络（Expert Networks）

MoE 中的专家通常为标准的前馈网络（FFN），采用 SwiGLU 激活变体：

$$\text{FFN}(\mathbf{x}) = W_2 \cdot \left(\sigma(W_1 \cdot \mathbf{x}) \odot (W_3 \cdot \mathbf{x})\right)$$

其中：
- $W_1, W_3 \in \mathbb{R}^{d \times d_{ff}}$：门控投影和上投影矩阵
- $W_2 \in \mathbb{R}^{d_{ff} \times d}$：下投影矩阵
- $\sigma$：激活函数（通常为 Swish/SiLU）
- $\odot$：逐元素乘法

SwiGLU 通过门控机制增强了表达能力：$W_1$ 的输出经过激活函数后与 $W_3$ 的输出相乘，形成一个"门控"效果。这种设计允许网络选择性地传递信息，已成为大模型 FFN 的事实标准。

每个专家独立拥有完整的参数集。专家数量 $N$ 的典型取值为 $8$、$64$、$128$ 或 $256$，甚至可达 $2048$（如 GShard）。专家设计的关键超参数包括：

专家可以用更复杂的结构吗？

理论上，专家可以是任意子网络：Conv1D、RNN、甚至嵌套 MoE（hierarchical MoE，每个专家本身是一个小 MoE）。但实践中 FFN 是性价比最高的选择，原因包括：

1. 计算效率：FFN 结构简单（两个矩阵乘 + 激活函数），易于并行
2. 参数量可控：FFN 的中间维度 $d_{ff}$ 决定了专家大小
3. Transformer 兼容：最小化架构改动
4. 硬件友好：矩阵乘法可充分利用 GPU/TPU 的张量核心

DeepSeek-MoE 采用了细粒度分割策略，将标准 FFN 切分为多个小专家，是一种折中方案。

4.2.2.2 门控网络/路由器（Gating Network / Router）

门控网络是 MoE 的核心决策组件，其结构极简：

$$\mathbf{z} = W_g \cdot \mathbf{x}, \quad W_g \in \mathbb{R}^{N \times d}$$

其中 $\mathbf{x} \in \mathbb{R}^d$ 是输入 token 的隐藏表示，$W_g$ 是路由投影矩阵。门控网络的参数量仅约 $N \times d$（如 $256 \times 4096 \approx 1$M），相比于数亿甚至数十亿的专家参数，几乎可以忽略。然而，正是这个轻量级组件决定了整个 MoE 系统的效率与稳定性——路由器的小小偏差可能导致整个训练崩溃。

门控网络的输出经过 softmax 转换为概率分布：

$$p_i = \frac{\exp(z_i)}{\sum_{j=1}^{N} \exp(z_j)}, \quad i = 1, 2, \ldots, N$$

该概率分布具有两个关键特性：

1. 归一性：$\sum_{i=1}^{N} p_i = 1$，确保所有专家的路由概率之和为 1
2. 可微分性：Softmax 全程可微，允许梯度反向传播到门控网络，即使某个专家在当前 step 未被选中

为什么使用 Softmax？

路由分数使用 Softmax 而非其他归一化方式的原因有三：

1. 概率分布性：Softmax 输出可解释为"选择概率"，具有自然的概率含义
2. 竞争性：Softmax 天然引入专家间的竞争，高概率意味着其他专家的概率被压低
3. 梯度流动：即使未选中，softmax 前的 logit 仍有梯度（通过未选中专家的反向传播）

注意点：负载均衡损失使用的是全概率分布（所有 $N$ 个专家的 softmax 概率），而非仅 Top-k 的归一化概率。实际聚合输出使用的是 Top-k 局部归一化权重。

4.2.2.3 MoE层的完整前向传播

综合以上组件，MoE 层的完整前向传播公式如下：

$$\mathbf{h}t = \mathbf{u}_t + \sum{i=1}^{N} g_{i,t} \cdot \text{FFN}_i(\mathbf{u}_t)$$

$$g_{i,t} = \begin{cases} \dfrac{\exp(s_{i,t})}{\sum_{j \in \mathcal{T}t} \exp(s{j,t})}, & i \in \mathcal{T}_t \ 0, & \text{otherwise} \end{cases}$$

$$s_{i,t} = (W_g \cdot \mathbf{u}_t)_i$$

$$\mathcal{T}t = \text{TopK}({s{1,t}, s_{2,t}, \ldots, s_{N,t}}, K)$$

其中 $\mathbf{u}t$ 是第 $t$ 个 token 经过 Attention 层后的隐藏状态，$\mathcal{T}_t$ 是选中的 $K$ 个专家的索引集合，$g{i,t}$ 是局部重新归一化后的路由权重。

4.2.3 Top-k路由机制的数学定义

4.2.3.1 完整路由流程的数学描述

Top-k 路由机制是稀疏 MoE 的核心算法，其完整流程可分解为五个严格定义的步骤：

Step 1：计算路由分数（Router Logits）

给定输入 $\mathbf{x} \in \mathbb{R}^{B \times S \times d}$（$B$ 为 batch size，$S$ 为序列长度，$d$ 为隐藏维度），首先展平 token 维度：

$$\mathbf{X} = \text{reshape}(\mathbf{x}) \in \mathbb{R}^{(B \cdot S) \times d}$$

门控网络计算路由 logits：

$$\mathbf{Z} = \mathbf{X} \cdot W_g^T \in \mathbb{R}^{(B \cdot S) \times N}$$

其中 $Z_{t,i}$ 表示第 $t$ 个 token 对第 $i$ 个专家的路由分数。这一步的计算量为 $O(T \cdot d \cdot N)$，其中 $T = B \cdot S$。由于 $N$ 通常远小于 $d$，门控网络的计算开销相对于专家 FFN 计算可以忽略。

Step 2：全局 Softmax 归一化

$$p_{t,i} = \frac{\exp(Z_{t,i})}{\sum_{j=1}^{N} \exp(Z_{t,j})}, \quad \forall t \in [T], i \in [N]$$

此步骤产生的全概率分布 $\mathbf{P} \in \mathbb{R}^{T \times N}$ 将用于负载均衡损失的计算。需要特别注意的是：所有 $N$ 个专家的 logits 都需要计算 softmax，即使最终只有 $K$ 个专家被激活。这是因为在负载均衡损失中需要用到所有专家的 softmax 概率。

Step 3：Top-k 选择

$$\mathcal{T}t = \text{TopK}({p{t,1}, p_{t,2}, \ldots, p_{t,N}}, K)$$

选择概率最高的 $K$ 个专家的索引集合 $\mathcal{T}_t$，$|\mathcal{T}_t| = K$。Top-k 操作的时间复杂度为 $O(N)$（使用快速选择算法），空间复杂度为 $O(K)$。

Step 4：局部重新归一化

$$w_{t,i} = \frac{p_{t,i}}{\sum_{j \in \mathcal{T}t} p{t,j}}, \quad i \in \mathcal{T}_t$$

仅对选中的 $K$ 个专家重新做 softmax 归一化，使权重之和为 1。这一步确保输出是选中专家结果的凸组合：

$$\sum_{i \in \mathcal{T}t} w{t,i} = 1$$

为什么需要重新归一化？ 如果不重新归一化，直接使用全局 softmax 概率作为权重，则未被选中的 $N-K$ 个专家的概率"丢失"了，权重之和将小于 1。重新归一化确保输出是选中专家输出的凸组合，保留了输出的幅度。

Step 5：加权聚合输出

$$\mathbf{y}t = \sum{i \in \mathcal{T}t} w{t,i} \cdot \text{FFN}_i(\mathbf{x}_t)$$

最终输出通过残差连接：

$$\mathbf{h}_t = \mathbf{x}_t + \mathbf{y}_t$$

残差连接的设计至关重要：它确保即使某个 token 未被任何专家处理（如超出容量被丢弃），其原始表示仍能通过残差连接传递，梯度也能通过残差路径反向传播。

4.2.3.2 Top-1 vs. Top-k 的权衡

Top-1 路由（$K=1$）和 Top-2 路由（$K=2$）代表了两种截然不同的设计哲学：

Top-1 路由（Switch Transformer）：

每个 token 仅被发送给一个专家。其优势在于通信量最小、实现最简单、计算无冗余。但其致命弱点是路由决策"非黑即白"，缺乏灵活性，单个专家故障影响大，且专家坍缩风险最高。

Switch Transformer 选择 Top-1 的核心考量是工程简化：
1. 通信效率：All-to-All 通信量减半，在 TPU 集群上优势显著
2. TPU 友好：TPU/XLA 编译器对静态形状更友好，Top-1 更容易优化
3. 简即是美：单专家路由极大简化了系统设计和分布式训练
4. 质量不差：实验证明在足够大的模型上能达到与 Top-2 相当的性能

Top-2 路由（GShard / Mixtral）：

每个 token 被发送给两个专家，提供更好的梯度信号（两个专家都获得梯度）、路由更鲁棒、专家 specialization 更明显。但代价是 $2$ 倍通信量、$2$ 倍专家计算、实现更复杂。Mixtral 8x7B 的成功验证了 Top-2 在开源模型中的优越性。

Top-k（$K \geq 6$，DeepSeek 系列）：

随着专家数量的增加（如 DeepSeek-V3 的 $256$ 个路由专家），激活数 $K$ 也相应增加（$K=8$）。这种设计使得细粒度专家分割成为可能——每个专家处理更专门化的知识子领域。$K=8$ 的设计意味着每个 token 可以从 $256$ 个专家中选择 $8$ 个，组合空间极为丰富。

4.2.3.3 噪声门控：探索-利用的平衡

噪声门控（Noisy Gating）由 Shazeer 等人在 2017 年提出，在路由分数计算前添加高斯噪声：

$$\text{NoisyTopKGate}(\mathbf{x}) = \text{TopK}\left(\text{softmax}(\mathbf{z} + \epsilon \cdot \mathcal{N}(0, \mathbf{I}))\right)$$

其中 $\epsilon$ 是噪声尺度参数。噪声门控的作用机制包含四个层面：

1. 探索-利用平衡：噪声强制路由器在训练初期探索更多专家，避免过早固化到少数专家。这类似于强化学习中的 epsilon-greedy 策略
2. 防止专家坍缩：打破正反馈循环的初始触发条件——即使某个专家偶然表现稍好，噪声也可能导致其他专家被选中
3. 负载均衡辅助：噪声自然促使 token 分散到不同专家，减轻了负载均衡损失的压力
4. 正则化效果：相当于对路由器的一种随机正则化，提高了路由策略的鲁棒性

现代 MoE 中，噪声门控已演变为多种形式：

• Input Jitter（Switch Transformer）：对输入乘以均匀分布噪声
  $$\mathbf{x}_{\text{jittered}} = \mathbf{x} \cdot \mathcal{U}(1-\epsilon, 1+\epsilon)$$
  这种乘性噪声的直觉是：如果输入的微小变化会导致路由决策改变，说明该 token 处于多个专家的决策边界附近，应该允许这种不确定性。

• Router Jitter Noise（Phi-3.5 MoE 等）：直接在路由 logits 上加噪声
  $$Z_{t,i}^{\text{noisy}} = Z_{t,i} + \epsilon \cdot \mathcal{N}(0, 1)$$

训练策略：噪声的尺度应在训练过程中退火：
- 训练初期使用较大噪声（探索阶段，如 $\epsilon = 0.1$）
- 训练后期逐渐减小噪声（利用阶段，如 $\epsilon = 0.001$）
- 最终阶段可以完全移除噪声

4.2.3.4 条件计算的数学本质

MoE 被称为条件计算的典型实现，其数学本质在于：输出是输入的函数，而参与计算的专家集合也是输入的函数。形式化地：

$$\mathbf{y} = \sum_{i=1}^{N} G(\mathbf{x})_i \cdot E_i(\mathbf{x})$$

其中 $G(\mathbf{x})_i \in {0, 1}$（硬选择）或 $[0, 1]$（软选择），且 $|G(\mathbf{x})|_0 = K \ll N$。

这种输入依赖的计算图结构使得 MoE 与以下架构形成鲜明对比：

MoE 的独特优势在于其条件化粒度——在单层内部进行细粒度的子网络选择，既保持了 Transformer 的层级结构，又实现了参数的按需激活。这种"条件计算 + 层级结构"的组合，使得 MoE 成为当前扩展模型规模最有效的技术路径之一。

4.2.4 共享参数与参数统计

4.2.4.1 MoE 模型中的共享参数

在标准 Sparse Transformer 中，以下参数在所有专家间共享：

DeepSeek-MoE 引入了共享专家的概念：
- 共享专家：对所有 token 始终激活，存储通用知识
- 路由专家：通过 Top-k 动态选择，存储领域专用知识

4.2.4.2 参数量估算公式

MoE 模型参数量估算公式：

$$\text{Total Params} = P_{\text{shared}} + N_{\text{experts}} \times P_{\text{expert}}$$

其中：
- $P_{\text{shared}}$ = Attention + Embedding + Norm 等共享参数
- $N_{\text{experts}}$ = 专家数量
- $P_{\text{expert}}$ = 每个专家的参数量

Mixtral 8x7B 的参数量验证（详见 4.6.2.1 节）：
- 总参数量：$\approx 47.4$B（与公布的 $46.7$B 基本一致）
- 激活参数量：$\approx 13.6$B（与公布的 $12.9$B 接近）

4.2.5 Expert Choice Routing

除了传统的 Token Choice Routing（每个 token 选择 $k$ 个专家），Zhou 等人（2022）提出了 Expert Choice Routing（EC Routing）——翻转视角，让每个专家选择 top-k 个 token。

$$\text{对于每个专家 } j: \quad \mathcal{T}j = \text{TopK}{\text{tokens}}({s_{1,j}, s_{2,j}, \ldots, s_{T,j}}, C)$$

其中 $C$ 是每个专家处理的固定 token 数（容量），$s_{t,j}$ 是 token $t$ 对专家 $j$ 的 affinity score。

优缺点对比：

EC Routing 在自回归生成中面临特殊挑战：由于需要完整序列信息才能确定每个专家选哪些 token，与自回归的逐 token 生成存在矛盾。这限制了 EC Routing 在标准 LLM 中的应用，但在输出长度固定的场景（如扩散语言模型）中更有价值。

4.3 负载均衡问题

负载均衡是 MoE 训练中最为核心也最为棘手的问题。没有有效的负载均衡机制，MoE 将不可避免地陷入专家坍缩——门控网络将所有 token 路由到少数"受欢迎"的专家，而其他专家完全不被使用。本节将从数学定义出发，系统推导负载均衡损失、容量限制、Router Z-Loss，并深入介绍 Loss-Free Balancing 这一前沿方案。

4.3.1 辅助负载均衡损失的数学定义

4.3.1.1 GShard / Switch Transformer 的负载均衡损失

负载均衡损失（Load Balancing Loss）最早由 GShard 系统性地引入 MoE 训练，其数学定义为：

$$\mathcal{L}{\text{load}} = \alpha \cdot N \cdot \sum{i=1}^{N} f_i \cdot P_i$$

其中：
- $\alpha$：损失权重系数（通常为 $0.01 \sim 0.1$）
- $N$：专家总数
- $f_i$：第 $i$ 个专家被分配到的 token 硬分派比例（hard dispatch fraction）
- $P_i$：第 $i$ 个专家的平均路由软概率（soft probability）

具体计算如下：

$$f_i = \frac{1}{T} \sum_{t=1}^{T} \mathbb{1}[\text{token } t \text{ dispatched to expert } i]$$

$$P_i = \frac{1}{T} \sum_{t=1}^{T} p_{t,i} = \frac{1}{T} \sum_{t=1}^{T} \text{softmax}(\mathbf{z}_t)_i$$

其中 $p_{t,i}$ 是 token $t$ 被路由到专家 $i$ 的 softmax 概率，$\mathbb{1}[\cdot]$ 是指示函数。

辅助损失的直观理解：

负载均衡损失的设计精妙之处在于 $f_i$ 和 $P_i$ 的乘积。$f_i$ 反映了专家 $i$ 的实际工作量（不可微分），$P_i$ 反映了门控网络"喜欢"专家 $i$ 的程度（可微分）。两者的乘积将"实际负载"与"路由偏好"耦合：

• 当专家 $i$ 负载很高（$f_i$ 大）且路由器也很喜欢它（$P_i$ 大）时，$f_i \cdot P_i$ 的乘积大，产生大损失，从而惩罚这种不均衡
• 当专家 $i$ 负载适中时，$f_i \approx P_i \approx K/N$，$f_i \cdot P_i \approx K^2/N^2$，损失较小

4.3.1.2 期望值推导

在完美均衡的情况下，每个专家处理的 token 数为 $T \cdot K / N$（总 token 数乘以每 token 激活的专家数，除以专家总数），因此 $f_i = K/N$。同时每个专家的平均路由概率也为 $P_i = K/N$（因为 softmax 概率之和为 $K$ 每 token，平均到 $N$ 个专家）。代入负载均衡损失：

$$\mathbb{E}[\mathcal{L}{\text{load}}] = \alpha \cdot N \cdot \sum{i=1}^{N} \frac{K}{N} \cdot \frac{K}{N} = \alpha \cdot N \cdot N \cdot \frac{K^2}{N^2} = \alpha \cdot K^2$$

乘以 $N$ 的设计目的是使损失值与专家数量无关，保持期望值稳定。当负载不均衡时，$f_i$ 和 $P_i$ 的偏离会产生较大的损失值，从而驱动门控网络调整路由策略。

验证：假设 $N = 8$，$K = 2$，$\alpha = 0.01$，则均衡时：

$$\mathbb{E}[\mathcal{L}_{\text{load}}] = 0.01 \times 2^2 = 0.04$$

这个值足够小，不会干扰主任务的训练，但又能有效地约束路由分布。

4.3.1.3 $f_i$ 与 $P_i$ 的区别与联系

理解 $f_i$ 和 $P_i$ 的本质区别，是深入理解负载均衡损失的关键：

$f_i$ 和 $P_i$ 的乘积 $f_i \cdot P_i$ 巧妙地耦合了"实际负载"与"路由偏好"：

• 当专家 $i$ 负载很高且路由器也很喜欢它时：$f_i$ 大且 $P_i$ 大 → 乘积大 → 损失大 → 被惩罚
• 当专家 $i$ 负载很低且路由器不喜欢它时：$f_i$ 小且 $P_i$ 小 → 乘积小 → 损失小 → 不受惩罚
• 当专家 $i$ 负载很高但路由器不喜欢它时：$f_i$ 大但 $P_i$ 小 → 乘积中等 → 损失适中
• 当专家 $i$ 负载很低但路由器喜欢它时：$f_i$ 小但 $P_i$ 大 → 乘积中等 → 损失适中

这种不对称设计意味着负载均衡损失鼓励的是：高负载专家获得低路由概率，低负载专家获得高路由概率，从而自然趋向均衡。

为什么 $f_i$ 不能单独使用？

如果仅使用 $f_i$ 作为损失（如 $\sum_i f_i^2$），由于 $f_i$ 不可微分，梯度无法流回门控网络，路由器无法从负载均衡损失中学习。

为什么 $P_i$ 不能单独使用？

如果仅使用 $P_i$（如 $\sum_i P_i^2$），可能导致"概率均匀但实际分配不均"的情况。门控网络可以输出均匀的概率分布，但由于 Top-k 选择的离散性，实际分配可能高度不均衡。

等价理解：

$$\mathcal{L}{\text{load}} = \alpha \cdot N \cdot \sum{i} f_i \cdot P_i = \alpha \cdot N \cdot \mathbb{E}_{i}[f_i \cdot P_i]$$

这鼓励了"高负载专家获得低路由概率"和"低负载专家获得高路由概率"的动态平衡。

4.3.1.4 完整梯度推导

负载均衡损失对路由分数 $Z_{t,m}$ 的梯度推导是理解其工作机制的关键。

从定义出发：

$$\mathcal{L}{\text{load}} = \alpha \cdot N \cdot \sum{i=1}^{N} f_i \cdot P_i$$

其中 $P_i = \frac{1}{T} \sum_{t=1}^{T} p_{t,i} = \frac{1}{T} \sum_{t=1}^{T} \text{softmax}(\mathbf{z}_t)_i$

$$\frac{\partial \mathcal{L}{\text{load}}}{\partial Z{t,m}} = \alpha \cdot N \cdot \sum_{i=1}^{N} f_i \cdot \frac{\partial P_i}{\partial Z_{t,m}}$$

由于 $P_i$ 通过 softmax 依赖所有 $Z_{t,*}$：

$$\frac{\partial p_{t,i}}{\partial Z_{t,m}} = p_{t,i} \cdot (\mathbb{1}[i=m] - p_{t,m})$$

这是 softmax 的标准导数：当 $i = m$ 时，$\frac{\partial p_{t,m}}{\partial Z_{t,m}} = p_{t,m}(1 - p_{t,m})$；当 $i \neq m$ 时，$\frac{\partial p_{t,i}}{\partial Z_{t,m}} = -p_{t,i} p_{t,m}$。

因此：

$$\frac{\partial P_i}{\partial Z_{t,m}} = \frac{1}{T} \cdot p_{t,i} \cdot (\mathbb{1}[i=m] - p_{t,m})$$

代入并化简：

$$\frac{\partial \mathcal{L}{\text{load}}}{\partial Z{t,m}} = \frac{\alpha \cdot N}{T} \sum_{i=1}^{N} f_i \cdot p_{t,i} \cdot (\mathbb{1}[i=m] - p_{t,m})$$

$$= \frac{\alpha \cdot N}{T} \left(f_m \cdot p_{t,m} - p_{t,m} \sum_{i=1}^{N} f_i \cdot p_{t,i}\right)$$

$$= \frac{\alpha \cdot N}{T} \cdot p_{t,m} \left(f_m - \sum_{i=1}^{N} f_i \cdot p_{t,i}\right)$$

令 $\bar{f}t = \sum_i f_i \cdot p{t,i}$（期望负载，即按路由概率加权的平均负载），则：

$$\boxed{\frac{\partial \mathcal{L}{\text{load}}}{\partial Z{t,m}} = \frac{\alpha \cdot N}{T} \cdot p_{t,m} \cdot (f_m - \bar{f}_t)}$$

梯度含义的深度解读：

• 当 $f_m > \bar{f}t$ 时，梯度为正 → $Z{t,m}$ 减小 → 降低专家 $m$ 的路由概率 → 减轻其负载
• 当 $f_m < \bar{f}t$ 时，梯度为负 → $Z{t,m}$ 增大 → 提高专家 $m$ 的路由概率 → 增加其负载

本质上：高负载专家的 logit 被抑制，低负载专家的 logit 被提升。这是一个自适应的负反馈机制，趋向于使所有专家的负载趋于均衡。

注意：$\bar{f}t = \sum_i f_i \cdot p{t,i}$ 是每 token 的动态阈值，与 token 对各个专家的路由概率有关。不同 token 的梯度方向和幅度不同，这允许模型根据输入特征学习不同的路由策略，同时保持全局负载均衡。

4.3.1.5 负载均衡损失的局限性与权衡

尽管负载均衡损失是防止专家坍缩的标准方案，但它存在一个根本性的矛盾：负载均衡要求均匀分布，但最优的路由可能本身就是非均匀的。

具体来说，辅助损失的引入带来了以下问题：

1. 目标冲突：负载均衡损失要求所有专家获得相等的负载，但数据的天然分布可能是非均匀的。某些 token 类型（如标点、停用词、常见英文单词）出现频率更高，强迫均匀分配可能将这些高频 token 分配给不合适的专家。

2. 梯度干扰：辅助损失的梯度与主任务梯度方向可能不一致。门控网络在"让路由器输出均匀分布"和"让路由器输出正确分布"之间被迫做出妥协。Anthropic 的实验表明，在 $70$B 参数的 MoE 模型上，添加负载均衡损失导致约 $0.5\%$ 的 perplexity 退化。

3. 超参数敏感：$\alpha$ 的调优是一个困难的多目标优化问题：

4. $\alpha$ 太小 → 负载约束不足 → 专家坍缩
5. $\alpha$ 太大 → 强迫均匀路由 → 损害模型性能
6. 不同训练阶段需要不同的 $\alpha$ 值

这些局限性催生了后续更为精细的负载均衡方案，包括 Router Z-Loss、动态调整 $\alpha$、Loss-Free Balancing 等。

为什么说 Perfect Load Balance 不一定最优？

这是一个需要深入理解的观点：

1. 数据分布天然不均匀：某些类型的 token（如标点、停用词）出现频率更高，强迫均匀分配可能将这些 token 分配给不合适的专家
2. 专家特化的价值：最优的 MoE 应该让某些专家专精于特定领域（代码、数学等），完美均衡可能破坏这种特化
3. 辅助损失的权衡：辅助损失强迫均匀分布 → 损失函数中增加了非任务相关的目标。极端情况下，所有专家处理完全相同的 token 混合 → 退化为 Dense 模型
4. 实践观察：即使有很大的负载均衡损失，训练后的 MoE 仍有明显的专家特化模式。负载均衡只需要"足够好"而非"完美"

4.3.2 容量因子与专家容量限制

4.3.2.1 专家容量的定义

容量因子（Capacity Factor, CF）是控制 MoE 层计算-质量权衡的关键超参数。专家容量的定义为：

$$\text{Expert Capacity} = \text{CF} \times \left\lfloor \frac{T \times K}{N} \right\rfloor$$

其中：
- $\text{CF}$ = 容量因子（通常 $1.0 \sim 2.0$）
- $T$ = batch 中 token 总数
- $K$ = 每个 token 激活的专家数
- $N$ = 专家总数

$\frac{T \times K}{N}$ 表示理想均衡情况下每个专家应处理的 token 数。容量因子的作用是为实际分配提供缓冲空间——由于路由决策不可能完美均衡，某些专家收到的 token 数会超过平均值。

示例计算（DeepSeek-V3 配置）：
- $T = 4096$（序列长度），$K = 8$，$N_r = 256$（路由专家）
- CF = $1.0$：Capacity = $1.0 \times 4096 \times 8 / 256 = 128$
- CF = $1.25$：Capacity = $1.25 \times 128 = 160$
- CF = $2.0$：Capacity = $2.0 \times 128 = 256$

4.3.2.2 Token Dropping 机制

当路由到某专家的 token 数超过其容量时，超出的 token 将被丢弃（dropped）。丢弃的 token 不经过任何专家计算，直接通过残差连接传递：

$$\mathbf{y}{\text{dropped}} = \mathbf{x}{\text{dropped}} + \mathbf{0} = \mathbf{x}_{\text{dropped}}$$

Token 丢弃策略通常有两种：

• 按概率丢弃（probs）：优先丢弃路由概率最低的 token。直觉是：如果一个 token 被路由到某专家的概率很低，说明该 token 与该专家的"匹配度"不高，丢弃的代价较小
• 按位置丢弃（position）：按 token 在序列中的位置丢弃，实现更简单但可能损害质量

不同容量因子的影响：

容量因子的选择是一个精妙的权衡：高 CF 意味着更少的 token 被丢弃，但会带来更多的 padding 和计算浪费；低 CF 计算效率高，但可能导致大量 token 被丢弃，影响模型质量。实践中，CF = $1.25$ 是预训练阶段的常用默认值。

经验法则：
- 预训练阶段：CF = $1.0 \sim 1.25$，少量丢弃是可接受的
- 微调阶段：CF = $1.25 \sim 1.5$，质量要求更高
- 评估/推理阶段：CF = $1.0$ 或 dropless（无丢弃），确保所有 token 都被处理

4.3.2.3 容量因子的动态调整

更高级的策略是在训练过程中动态调整容量因子：

• 训练初期：CF 较大（如 $2.0$），确保所有 token 都能获得充分的训练信号，避免早期丢弃导致某些 token 学习不足
• 训练中后期：逐渐降低 CF（如降至 $1.25$ 或 $1.0$），因为此时路由器已经学习到了稳定的路由模式，丢弃率自然降低

这种动态调整策略在 GShard 和后续的大规模 MoE 训练中被广泛采用。

4.3.3 Router Z-Loss及其作用

4..3.3.1 问题背景：路由数值不稳定性

在 MoE 训练的实践中，研究者发现即使没有专家坍缩，训练过程也可能出现损失尖峰（loss spike）和数值不稳定性。根本原因在于：路由器可能为某些专家输出极端的 logit 值（如 $Z_{t,i} = 100$ 或 $Z_{t,i} = -100$），导致 softmax 概率趋于 $0$ 或 $1$。

当 softmax 概率过于尖锐时：
- 梯度消失：对于概率接近 $0$ 的专家，其梯度接近于 $0$，无法学习
- 梯度爆炸：对于概率接近 $1$ 的专家，微小的 logit 变化可能导致巨大的梯度
- 训练不稳定：loss spike 频繁出现，模型难以收敛

4.3.3.2 Router Z-Loss 的数学定义

Router Z-Loss 由 ST-MoE（Zoph et al., 2022）提出，用于解决训练数值不稳定性。其定义为：

$$\mathcal{L}{z} = \frac{1}{T} \sum{t=1}^{T} \left(\log \sum_{i=1}^{N} \exp(Z_{t,i})\right)^2$$

等价地：

$$\mathcal{L}{z} = \frac{1}{T} \sum{t=1}^{T} \text{LSE}(\mathbf{Z}_t)^2$$

其中 $\text{LSE}(\mathbf{Z}) = \log \sum_{i} \exp(Z_i)$ 是 Log-Sum-Exp 操作。

Log-Sum-Exp 的数值稳定实现：

$$\text{LSE}(\mathbf{Z}) = Z_{\max} + \log \sum_{i=1}^{N} \exp(Z_i - Z_{\max})$$

其中 $Z_{\max} = \max_i Z_i$，这种实现避免了指数爆炸。

LSE 的数学性质：

$$\max_i Z_i \leq \text{LSE}(\mathbf{Z}) \leq \max_i Z_i + \log N$$

这意味着 LSE 是最大 logit 的"软化"版本，上界为 $\max_i Z_i + \log N$。

4.3.3.3 Router Z-Loss 的作用机制

Router Z-Loss 通过惩罚过大的 logits，实现了三个层面的稳定性保障：

1. 有界 logit 增长：当任何 $Z_{t,i}$ 过大时，$\text{LSE}(\mathbf{Z}_t)$ 随之增大，Z-Loss 产生强梯度将其拉回。由于 LSE 的下界是 $\max_i Z_i$，Z-Loss 实际上是在约束最大 logit 的大小

2. 防止 softmax 坍塌：避免路由器对某个专家输出极端置信度（如 $p_i \approx 0.999$），保持概率分布的"柔和度"。Softmax 概率的熵因此保持在合理范围内

3. 梯度稳定性：有界的 logits 意味着稳定的梯度流。Softmax 导数 $p_i(1-p_i)$ 在 $p_i \approx 0.5$ 时最大，在 $p_i \approx 0$ 或 $1$ 时接近 $0$。Z-Loss 通过保持概率分布的"柔和度"，确保梯度信号不至于消失

Z-Loss 的梯度：

$$\frac{\partial \mathcal{L}z}{\partial Z{t,m}} = \frac{2}{T} \cdot \text{LSE}(\mathbf{Z}t) \cdot p{t,m}$$

这意味着 Z-Loss 对所有 logits 都施加正梯度，但 LSE 值较大时对最大 logit 的抑制更强。

4.3.3.4 Z-Loss 与负载均衡损失的对比

两者是互补关系：Load Balancing Loss 解决"负载不均"问题，Z-Loss 解决"数值不稳"问题。现代 MoE 训练通常同时使用两者。

4.3.3.5 联合训练目标

综合任务损失、负载均衡损失和 Router Z-Loss，MoE 的完整训练目标为：

$$\mathcal{L}{\text{total}} = \mathcal{L}{\text{task}} + \alpha_{\text{aux}} \cdot \mathcal{L}_{\text{load}} + \alpha_z \cdot \mathcal{L}_z$$

其中 $\mathcal{L}{\text{task}}$ 是主任务损失（如语言模型的交叉熵损失）。三个损失项的系数通常按 $\alpha{\text{aux}} \gg \alpha_z$ 的关系设置，确保负载均衡是主要约束，数值稳定是辅助约束。

4.3.4 Loss-Free Balancing的前沿进展

4.3.4.1 核心思想：跳出损失函数的框架

辅助负载均衡损失的根本困境在于：它是一个与主任务无关的优化目标，其引入不可避免地干扰了模型对主任务的学习。Loss-Free Balancing 的核心思想是——不通过损失函数来惩罚不均衡，而是通过动态调整路由偏置来实现负载均衡。

这一方案由 DeepSeek-V2/V3 系统性地提出和完善，代表了 MoE 负载均衡技术的重大进步。其 insight 在于：负载均衡是一个约束条件而非优化目标，应该通过控制机制而非梯度惩罚来实现。

4.3.4.2 DeepSeek-V3 的实现机制

Step 1：引入专家偏置项

对每个专家 $i$ 维护一个偏置 $b_i$，将其加到路由分数上：

$$\hat{s}{t,i} = s{t,i} + b_i$$

Top-k 选择基于偏置后的分数 $\hat{s}{t,i}$，但输出权重使用原始分数 $s{t,i}$。这一分离至关重要——偏置只影响"选哪个专家"，不影响"选中后的权重计算"。

这种分离的设计理念是：
- 偏置是"修正项"，用于纠正不均衡的路由行为
- 权重是"质量信号"，反映专家与输入的真实匹配度
- 两者不应混淆，否则会影响聚合输出的质量

Step 2：动态更新偏置

在每个训练步骤结束后，根据专家负载更新偏置：

$$b_i^{(t+1)} = \begin{cases} b_i^{(t)} - \gamma, & \text{if expert } i \text{ is overloaded} \ b_i^{(t)} + \gamma, & \text{if expert } i \text{ is underloaded} \end{cases}$$

其中 $\gamma$ 是偏置更新速度（如 $\gamma = 0.001$）。

更精确的更新公式为：

$$b_i^{(t+1)} = b_i^{(t)} + \gamma \cdot \text{sign}(\bar{c} - c_i)$$

其中 $\bar{c} = K \cdot T / N$ 是目标负载，$c_i$ 是专家 $i$ 的实际负载。

更新逻辑的直觉：
- 若专家 $i$ 过载（$c_i > \bar{c}$）：减小 $b_i$，使得专家 $i$ 的路由分数降低，被选中概率下降
- 若专家 $i$ 欠载（$c_i < \bar{c}$）：增大 $b_i$，使得专家 $i$ 的路由分数提升，被选中概率上升
- 偏置调整的速度 $\gamma$ 控制收敛速度：$\gamma$ 太小则调整缓慢，$\gamma$ 太大则振荡

Step 3：偏置不参与梯度传播

• $b_i$ 的更新是纯启发式的，不通过反向传播
• 梯度只流经原始分数 $s_{t,i}$
• 这避免了辅助损失对主任务的任何梯度干扰

4.3.4.3 Loss-Free Balancing 的优势

1. 无性能损失：不牺牲模型性能来换取负载均衡。DeepSeek-V3 的实验表明，Loss-Free 方案在多个基准测试上优于同等规模的辅助损失方案。这是因为主任务的梯度完全不受负载均衡机制的干扰

2. 超参数简化：不再需要精心调优 $\alpha_{\text{aux}}$。仅需设置偏置更新速度 $\gamma$，且 $\gamma$ 的鲁棒性比 $\alpha_{\text{aux}}$ 好得多

3. 负载更稳定：实验表明 MaxVio（最大违规率，即最大负载偏差与目标负载的比值）降低 $10 \sim 20$ 倍

4. 可组合性：可与极小的序列级辅助损失结合，作为安全网防止极端不均衡

5. 动态响应：偏置调整在每步训练后立即生效，响应速度远快于梯度更新

4.3.4.4 互补的序列级辅助损失

DeepSeek-V3 仍保留一个极小的序列级平衡损失（$\alpha = 0.0001$），仅用于防止单个序列内的极端不均衡：

$$\mathcal{L}{\text{Bal}} = \alpha \sum{i=1}^{N_r} f_i \cdot P_i$$

这个损失的系数极小（比传统方案小 $100 \sim 1000$ 倍），其梯度对主任务的影响可以忽略不计，但能在极端情况下提供额外的安全保障。保留这一极小损失的原因在于：

1. 单序列极端情况：Loss-Free 的全局调整可能无法捕捉到单个序列内的局部不均衡
2. 安全网作用：在训练初期，偏置尚未充分调整时，提供基本的均衡约束
3. 监控作用：序列级损失的数值变化可以作为训练稳定性的监控指标

4.3.4.5 设备受限路由（Device-Limited Routing）

与 Loss-Free Balancing 配套使用的重要技术是设备受限路由（Device-Limited Routing），它解决了大规模 EP 的通信瓶颈。

问题背景：MoE 的 All-to-All 通信量与 token 需要发送到的 GPU 数量成正比。在 $256$ 个专家分布在 $64$ 个 GPU 的场景中，每个 token 可能需要与所有 $64$ 个 GPU 通信。

解决方案：限制每个 token 最多发送到 $M$ 个节点（node），而非所有节点。

DeepSeek-V3 的配置：
- 每层路由专家分布在 $8$ 个节点的 $64$ 个 GPU 上
- 每个 token 最多发送到 $M = 4$ 个节点
- 通过预先分组专家，每个节点包含一组专家
- 路由器首先选择节点，再选择节点内的专家

效果：All-to-All 通信量减少为原来的 $M/8 = 50\%$。

4.3.4.6 负载均衡策略演进总览

负载均衡技术经历了从简单到精巧的演进过程：

这一演进趋势清晰地指向一个目标：在确保负载均衡的同时，最小化对主任务学习的干扰。Loss-Free Balancing 是当前这一方向的最优解，但研究者仍在探索更为精细的方案。

4.4 专家坍缩问题（重点专题）

专家坍缩（Expert Collapse）是 MoE 训练中最具破坏性的失效模式。一旦坍缩发生，拥有数十亿甚至万亿参数的 MoE 模型将退化为一个小规模的密集模型——绝大多数专家不被使用，模型容量被严重浪费。本节将从正反馈循环的数学模型出发，系统分析坍缩的成因、检测指标、多层预防方案与分级恢复策略。

4.4.1 专家坍缩的成因分析

4.4.1.1 正反馈循环模型

专家坍缩的根本成因是一个正反馈循环（Positive Feedback Loop），也称为"富者愈富"效应。以下是对这一循环的详细拆解：

text 专家 A 偶然表现稍好（初始化随机性或早期训练噪声） ↓ 路由器倾向发送更多 token 给 A（softmax 的锐化效应） ↓ A 获得更多训练信号，权重更新更多，变得"更优" ↓ 路由器更加倾向于选择 A（概率进一步集中） ↓ ...（恶性循环加剧，反馈增益 > 1） ↓ 其他专家几乎收不到 token，无法学习和更新 ↓ 模型退化为一个以 A 为核心的小 Dense 模型text

这一正反馈循环与经济学中的"马太效应"、社会学中的"富者愈富"现象具有相同的数学结构。理解这一循环的关键在于认识到：MoE 系统中存在内生的不稳定性，需要外部控制机制来维持均衡。

4.4.1.2 数学模型

设专家 $i$ 在时间步 $t$ 的质量（performance）为 $q_i(t)$，路由概率为 $p_i(t)$。简化模型如下：

$$p_i(t) = \frac{\exp(\beta \cdot q_i(t))}{\sum_{j=1}^{N} \exp(\beta \cdot q_j(t))}$$

$$q_i(t+1) = q_i(t) + \eta \cdot p_i(t) \cdot g_i(t) - \delta \cdot (q_i(t) - \bar{q}(t))$$

其中：
- $\beta$：softmax 的"锐度"参数（温度倒数），$\beta$ 越大，概率分布越尖锐
- $\eta$：学习率
- $g_i(t)$：专家 $i$ 收到的训练信号（梯度强度），假设为正值
- $\delta$：衰减/正则化项，防止质量无限增长
- $\bar{q}(t)$：所有专家的平均质量

正反馈分析：

假设在初始时刻，专家 $1$ 略优于专家 $2$：$q_1(0) = q_2(0) + \epsilon$，其中 $\epsilon > 0$ 是一个很小的正数（如 $0.01$）。则：

$$\frac{p_1(0)}{p_2(0)} = \frac{\exp(\beta \cdot q_1(0))}{\exp(\beta \cdot q_2(0))} = \exp(\beta \cdot \epsilon)$$

当 $\beta = 1$ 且 $\epsilon = 0.01$ 时，$p_1/p_2 = e^{0.01} \approx 1.01$，仅 $1\%$ 的优势。但当 $\beta = 10$ 时，$p_1/p_2 = e^{0.1} \approx 1.105$，优势扩大到 $10.5\%$。

更一般地，定义路由概率的比率：

$$r_{ij}(t) = \frac{p_i(t)}{p_j(t)} = \exp(\beta \cdot (q_i(t) - q_j(t)))$$

若专家 $i$ 的质量优势持续扩大（$q_i(t) - q_j(t)$ 单调递增），则 $r_{ij}(t) \to \infty$，即专家 $j$ 完全被"挤出"。

简化情形下的解析解：

考虑两个专家的情形（$N = 2$），忽略衰减项（$\delta = 0$），假设 $g_1(t) = g_2(t) = g$ 为常数。则：

$$q_1(t+1) - q_2(t+1) = q_1(t) - q_2(t) + \eta g (p_1(t) - p_2(t))$$

$$= q_1(t) - q_2(t) + \eta g \cdot \tanh\left(\frac{\beta(q_1(t) - q_2(t))}{2}\right)$$

令 $\Delta q(t) = q_1(t) - q_2(t)$，则：

$$\Delta q(t+1) = \Delta q(t) + \eta g \cdot \tanh\left(\frac{\beta \cdot \Delta q(t)}{2}\right)$$

由于 $\tanh(x) > 0$ 当 $x > 0$，且 $\tanh(x)$ 在 $x$ 较大时趋近于 $1$，差值 $\Delta q(t)$ 会单调递增，趋近于无穷大。这意味着：

$$\lim_{t \to \infty} \Delta q(t) = \infty \Rightarrow \lim_{t \to \infty} p_1(t) = 1, \lim_{t \to \infty} p_2(t) = 0$$

结论：在没有负载均衡机制的情况下，即使初始差异无限小，正反馈循环也必然导致坍缩。

4.4.1.3 临界点分析

系统存在一个临界值 $\beta_c$，决定了均衡的稳定性。当 $\beta < \beta_c$ 时，噪声或其他随机因素可以维持均衡；当 $\beta > \beta_c$ 时，正反馈占主导，系统必然坍缩。

临界值的近似表达式为：

$$\beta_c \approx \frac{2}{\eta g} \cdot \frac{1}{N}$$

这表明：
- $\beta_c$ 与 $N$ 成反比：专家越多，越容易发生坍缩
- $\beta_c$ 与 $\eta$ 成反比：学习率越高，越容易发生坍缩
- $\beta_c$ 与 $g$ 成反比：训练信号越强，越容易发生坍缩

辅助负载均衡损失的作用本质上就是降低有效 $\beta$——通过惩罚不均衡的路由分布，使得概率分布无法过度尖锐化。

4.4.1.4 触发因素汇总

专家坍缩的触发通常是多种因素共同作用的结果：

1. 初始化随机性：某些专家由于随机初始化获得了更有利的初始权重。在标准 Xavier/Glorot 初始化下，专家权重的初始分布相同，但随机采样导致了微小的差异，这些差异在正反馈循环中被放大

2. 早期训练噪声：某专家偶然处理到"容易"的 batch（如简单的高频词汇），产生了虚假的性能优势。这种偶然优势通过正反馈循环被不断放大

3. 缺少负载均衡机制：无辅助损失时，正反馈几乎必然导致坍缩。即使是微小的初始差异，也会在数百至数千步内被放大到不可忽略的程度

4. 学习率过高：加速了正反馈循环的迭代。高学习率意味着每次更新的幅度更大，专家质量的差异被更快地放大

5. Top-1 路由：比 Top-k（$k > 1$）更容易坍缩。Top-1 时，每个 token 只发送给一个专家，一旦路由决策偏向某专家，该专家获得的训练信号是 Top-2 时的约 2 倍

6. 数据分布偏斜：某些类型的 token 出现频率更高，自然流向特定专家。例如，代码数据集中缩进和括号的出现频率远高于普通文本

7. Batch 大小不足：小 batch 的统计噪声更大，更容易产生"虚假"的专家性能差异

4.4.2 检测指标与阈值设计

及时检测专家坍缩的早期信号，是防止训练灾难的关键。本节介绍一套完整的指标体系。

4.4.2.1 核心指标

指标 1：最大负载比 $\max_i f_i$

$$f_i = \frac{N}{K \cdot T} \sum_{t=1}^{T} \mathbb{1}[\text{expert } i \text{ selected for token } t]$$

在完美均衡时，$f_i = 1/N$ 对所有 $i$。若 $\max_i f_i \gg 1/N$，则表明存在超级专家。

指标 2：最小负载比 $\min_i f_i$

若 $\min_i f_i \approx 0$，表明存在死专家（Dead Expert）——长期不被任何 token 选中。

指标 3：负载熵 $H$

$$H = -\sum_{i=1}^{N} f_i \log f_i$$

负载熵衡量负载分布的不确定性。在完美均衡时：

$$H_{\max} = \log N$$

低熵表示不均衡（负载集中在少数专家）。

指标 4：Gini 系数

Gini 系数是衡量不平等的通用指标，取值范围为 $[0, 1]$：

$$G = \frac{\sum_{i=1}^{N} \sum_{j=1}^{N} |f_i - f_j|}{2N \sum_{i=1}^{N} f_i}$$

4.4.2.2 综合评估矩阵

以下矩阵提供了多指标联合判定的标准：

4.4.2.3 实时监控方案

在实际训练中，建议使用 TensorBoard 或类似工具实时监控以下曲线：

1. 每个专家的 $f_i$ 直方图：直观展示负载分布。理想情况下应该是一个近似均匀分布
2. 负载熵 $H$ 随训练步数的变化：熵值下降趋势是坍缩的预警信号。若 $H$ 连续 $1000$ 步下降，应提高警惕
3. Gini 系数曲线：Gini 系数快速上升（斜率 $> 0.001$/step）表明正反馈循环正在加速
4. Router Z-Loss 的 LSE 值：LSE 值过高（$> 10$）表明 logits 正在失控
5. 专家利用率热力图：可视化每个专家在每步的负载，形成 $N \times T$ 的热力图

实践经验：在 TensorBoard 中，若部分专家的 load 长期 $< 1/(4N)$，即应发出警告信号。训练初期（前 $10\%$ 的步数）负载波动是正常的，但如果持续 $> 5\%$ 的训练步数都处于不均衡状态，则需要干预。

4.4.3 预防方案

4.4.3.1 方案一：辅助负载均衡损失

辅助负载均衡损失是防止专家坍缩的标准防线（详见 4.3.1 节）。关键参数设置：

• $\alpha = 0.01 \sim 0.1$（需根据监控指标调优）
• 训练初期 $\alpha$ 可较大（如 $0.1$），后期逐渐减小（如 $0.01$）
• 结合 Z-Loss 使用（$\alpha_z = 10^{-4} \sim 10^{-2}$）

调优策略：
1. 初始设置 $\alpha = 0.01$
2. 监控 $H/H_{\max}$，若 $< 0.5$ 则增大 $\alpha$ $50\%$
3. 监控主任务 loss，若明显退化则减小 $\alpha$ $50\%$
4. 重复步骤 2-3 直到找到平衡点

4.4.3.2 方案二：Loss-Free Balancing

Loss-Free Balancing 是当前最先进的防坍缩方案（详见 4.3.4 节）。其优势在于：

• 无梯度干扰，不损害主任务性能
• 偏置更新速度与专家数量无关，超参数更鲁棒
• MaxVio（最大违规率）降低 $10 \sim 20$ 倍

最佳实践：
- $\gamma = 0.001$ 作为默认值
- 偏置 $b_i$ 使用 register_buffer 存储，不参与梯度
- 每训练 step 后调用 update_bias()

4.4.3.3 方案三：噪声路由（Noisy Gating / Jitter）

在路由分数计算前添加随机噪声，打破正反馈循环的确定性：

$$\hat{Z}{t,i} = Z{t,i} + \epsilon \cdot \mathcal{N}(0, 1)$$

或通过输入抖动：

$$\mathbf{x}_{\text{jittered}} = \mathbf{x} \cdot \mathcal{U}(1-\epsilon, 1+\epsilon)$$

训练策略：
- 训练初期（前 $20\%$ 步数）使用较大噪声（探索阶段，如 $\epsilon = 0.1$）
- 训练中期（$20\% \sim 80\%$）逐渐减小噪声（如 $\epsilon = 0.01$）
- 训练后期（最后 $20\%$）最小噪声（利用阶段，如 $\epsilon = 0.001$）
- Switch Transformer 发现乘性 jitter（multiplying jitter）效果好于加性 jitter

噪声退火 schedule：

$$\epsilon(t) = \epsilon_{\max} \cdot \left(1 - \frac{t}{T_{\text{total}}}\right)^2$$

这种二次退火 schedule 在训练初期提供大量噪声促进探索，在后期几乎无噪声保证利用。

4.4.3.4 方案四：Expert Dropout

Expert Dropout 以一定概率随机屏蔽专家，强制路由器不能过度依赖任何单个专家：

$$\text{ExpertDropout}(E_i) = \begin{cases} \mathbf{0}, & \text{with probability } p_{\text{drop}} \ E_i(\mathbf{x}), & \text{with probability } 1 - p_{\text{drop}} \end{cases}$$

Switch Transformer 在微调阶段使用 $p_{\text{drop}} = 0.4$ 的 Expert Dropout 来防止过拟合。在预训练阶段，较低的 dropout 率（如 $p_{\text{drop}} = 0.1$）也能有效防止坍缩。

Expert Dropout 的作用机制：
1. 防止过度依赖：即使某专家质量很高，dropout 也迫使路由器准备备选方案
2. 增加鲁棒性：训练时所有专家都可能被屏蔽，模型必须学习多样化的路由策略
3. 正则化效果：类似于标准 dropout，Expert Dropout 防止了专家之间的"共适应"

4.4.3.5 方案五：Top-k 路由（$k > 1$）

选择多个专家而非单一专家，提供天然的冗余：

• Top-2：每个 token 发送给两个专家，即使一个专家坍缩，另一个仍能接收梯度
• Top-k（$k \geq 6$）：如 DeepSeek-V3 的 $K=8$，在 $256$ 个专家中激活 $8$ 个。即使 $200$ 个专家坍缩，剩余 $56$ 个仍能维持训练。这种冗余设计使得大规模专家系统天然具有容错能力

$K$ 值的选择建议：
- 小规模模型（$N \leq 16$）：$K = 2$
- 中规模模型（$16 < N \leq 64$）：$K = 4 \sim 6$
- 大规模模型（$N > 64$）：$K = 6 \sim 8$

4.4.3.6 方案六：容量限制与 Token 重路由

设置专家容量上限，溢出的 token 被重新分配给其他专家：

$$\text{if } |{t: \text{expert}_i \text{ selected}}| > \text{Capacity}_i:$$
$$\quad \text{reroute overflow tokens to expert } \arg\min_j f_j$$

ST-MoE 采用了这种重路由策略，确保没有 token 被丢弃，同时将溢出负载导向最空闲的专家。

4.4.3.7 方案七：正交约束

强制专家权重矩阵相互正交，防止它们学习相似的功能：

$$\mathcal{L}{\text{orth}} = \lambda \sum{i \neq j} \frac{|W_i^T W_j|_F^2}{|W_i|_F^2 |W_j|_F^2}$$

正交约束鼓励专家差异化，降低它们之间的竞争替代性。当专家权重相互正交时，一个专家的"优势"不容易直接替代另一个专家的功能，从而减缓正反馈循环。

不过这一方案在最新的大规模 MoE 中使用较少，因为正交性可能过于严格，限制了专家的学习能力。

4.4.3.8 综合预防策略

现代大规模 MoE 训练通常采用多层防御策略：

text 第 1 层：Loss-Free Balancing（主防线，始终启用） ↓ 若仍不均衡 第 2 层：极小的序列级辅助损失（α = 0.0001，安全网） ↓ 若早期训练仍不稳定 第 3 层：Input Jitter（训练初期 ε = 0.01~0.1，逐步退火） ↓ 若出现极端情况 第 4 层：Expert Dropout（p_drop = 0.1，随机屏蔽） ↓ 若某专家完全死亡 第 5 层：权重重新初始化（最后手段，重置死专家）text

这种分层防御的理念类似于信息安全中的"纵深防御"——不依赖单一防线，而是通过多层措施确保系统的鲁棒性。

4.4.4 恢复策略

即使采取了预防措施，专家坍缩仍可能在训练过程中发生。以下是针对不同严重程度的恢复策略。

4.4.4.1 轻度坍缩（Gini < 0.5）

症状：部分专家负载偏低，但仍有少量训练信号。$\min f_i > 0.01/N$。

恢复方案：
1. 增大辅助损失系数：从 $\alpha = 0.01$ 提升到 $0.05$ 或 $0.1$
2. 增大 jitter 噪声：将 $\epsilon$ 从 $0.01$ 提升到 $0.05$
3. 降低学习率：减小 $50\%$，减缓正反馈循环的速度

预期恢复时间：通常在 $1000 \sim 5000$ 步内恢复均衡。

4.4.4.2 中度坍缩（Gini 0.5~0.8）

症状：存在明显的死专家和超级专家，但部分专家仍在正常工作。$\min f_i < 0.01/N$，$\max f_i > 5/N$。

恢复方案：
1. 大幅增大 jitter 噪声：$\epsilon = 0.1$，强制路由器大规模探索
2. Loss-Free 偏置快速调整：将 $\gamma$ 增大 $5 \sim 10$ 倍，快速纠正过载/欠载
3. 冻结超级专家：临时冻结负载最高的 $1 \sim 2$ 个专家的权重，强制路由器寻找替代专家

预期恢复时间：$5000 \sim 20000$ 步。

4.4.4.3 重度坍缩（Gini > 0.8）

症状：几乎所有 token 路由到 $1 \sim 2$ 个专家，模型已严重退化。$\max f_i > 20/N$，$> 50\%$ 的专家 $f_i = 0$。

恢复方案：
1. 重新初始化坍缩专家：将死专家的权重重新随机初始化，给它们"第二次机会"。注意：仅重置 FFN 权重，保留路由器参数
2. 完全重启路由器训练：将路由器的 $W_g$ 重新初始化，保持专家权重不变。这相当于让路由器"重新学习"如何路由
3. 检查点回退：回退到上一个稳定检查点，调整超参数后重新训练

预期恢复时间：$10000 \sim 50000$ 步，或可能需要从头训练。

4.4.4.4 恢复策略的自动化

在大规模分布式训练中，手动监控和恢复是不现实的。建议实现自动化恢复流程：

```python
def auto_recover(expert_loads, router_logits, step):
"""自动专家坍缩检测与恢复"""
N = len(expert_loads)
f = expert_loads / expert_loads.sum()
gini = compute_gini(f)

if gini > 0.8:
    # 重度坍缩：重新初始化死专家
    dead_experts = f < 0.001 / N
    for i in range(N):
        if dead_experts[i]:
            reinitialize_expert(i)
    return "severe_recovery_applied"
elif gini > 0.5:
    # 中度坍缩：增大 jitter
    set_jitter_scale(0.1)
    return "moderate_recovery_applied"
elif max(f) > 3 / N:
    # 轻度不均衡：微调 alpha
    increase_aux_loss_alpha(1.5)
    return "mild_adjustment_applied"
else:
    return "normal"

```text

4.5 分布式训练与推理

MoE 的分布式训练是工程实现的难点所在。当专家数量达到数百甚至上千，单个 GPU 的显存远不足以容纳全部参数时，专家并行（Expert Parallelism, EP）成为必然选择。本节将深入剖析 EP 的通信模式、All-to-All 通信优化，以及推理阶段的 MoE 调度策略。

4.5.1 专家并行（Expert Parallelism）

4.5.1.1 EP 的基本概念

专家并行（Expert Parallelism, EP）是 MoE 特有的并行维度，其核心思想是将不同的专家网络分配到不同的 GPU 上：

$$\text{GPU } g \text{ 持有} {E_i : i \in \text{Assigned}(g)}$$

其中 $\text{Assigned}(g)$ 是分配给 GPU $g$ 的专家索引集合。假设有 $N$ 个专家和 $E$ 个 GPU（EP size = $E$），每个 GPU 持有约 $N/E$ 个专家。

为什么需要 EP？

以 DeepSeek-V3 为例，总参数量 $671$B，其中专家参数约占 $660$B。假设每个专家 $2.6$B 参数（BF16 占 $5.2$ GB），$256$ 个专家共需 $1331$ GB 显存——远超单卡 A100 的 $80$ GB。即使使用 $8$ 卡，每卡仍需约 $166$ GB，仍然不够。因此，专家必须分布在多个 GPU 上。

4.5.1.2 EP 的数据流

EP 的前向传播包含两个阶段：

Dispatch 阶段：每个 GPU 的路由器根据路由结果，将 token 发送到持有目标专家的 GPU。

$$\text{Send}(\text{GPU}g, \text{GPU}{g'}) = {(t, i) : \text{token } t \text{ 需要专家 } i, \text{ expert } i \in \text{GPU}_{g'}, \text{ token } t \in \text{GPU}_g}$$

Combine 阶段：专家计算完成后，结果发送回原始 GPU。

$$\text{Receive}(\text{GPU}g, \text{GPU}{g'}) = {(t, \mathbf{o}) : \text{token } t \text{ 原属 GPU}g, \text{expert output } \mathbf{o} \text{ from GPU}{g'}}$$

为什么需要 Combine？

因为每个 token 可能路由到多个专家（Top-k），这些专家可能分布在不同 GPU 上。每个 GPU 只计算其持有的专家的输出，然后将结果送回原始 GPU 进行加权聚合。

4.5.1.3 EP 与其他并行维度的关系

MoE 的训练通常涉及四种并行维度的组合：

典型配置策略：

1. MoE 层使用 EP：专家分布在不同 GPU，计算效率高。EP 使得每个 GPU 只需计算其持有的专家，矩阵乘法的 shape 更大，GPU 利用率更高
2. Attention 层使用 TP/SP：Attention 不适合 EP（需要全局 token 交互），使用张量并行或序列并行更合适
3. 混合策略示例：
4. DeepSeek-V3：PP + EP($64$) + 无 TP
5. 典型配置：EP = $8$ 时不再使用 TP

DeepSeek-V2 的配置详解：
- $236$B 参数，$21$B 激活
- $8$ EP + $16$ PP (ZeroBubble) + Zero-1
- 不使用 TP（因为 EP 已足够提供并行度）
- 总 GPU 数 = $8$ EP $\times$ $16$ PP = $128$

4.5.1.4 EP 的显存分析

EP 改变了显存需求的计算方式：

$$\text{VRAM}{\text{per-GPU}} = \frac{P{\text{shared}}}{\text{DP} \cdot \text{TP}} + \frac{P_{\text{experts}}}{\text{EP}} + \text{Optimizer States} + \text{Activations}$$

其中 $P_{\text{shared}}$ 是共享参数（Attention、Embedding 等），$P_{\text{experts}}$ 是所有专家参数总和。EP 使得每个 GPU 只需存储 $1/\text{EP}$ 的专家参数。

示例计算（DeepSeek-V2, $236$B 参数）：
- 共享参数：$\sim 20$B
- 专家参数：$\sim 216$B（$64$ 个专家 $\times$ $3.4$B 每专家）
- EP = $8$：每 GPU 专家参数 = $216$B / $8$ = $27$B
- 共享参数每 GPU = $20$B（不分 EP）
- BF16 模型权重：$(27 + 20) \times 2$ = $94$ GB
- Optimizer States（Adam, FP32）：$2 \times 94$ = $188$ GB（使用 ZeRO-1 后降至 $188$ / DP）
- 激活内存：$\sim 10$ GB
- 总计：$\sim 110$ GB / GPU（使用 ZeRO-1 + EP8 后）

4.5.2 All-to-All通信优化

4.5.2.1 All-to-All 通信量分析

All-to-All 通信是 EP 的核心开销，其通信量可精确计算：

$$\text{All-to-All}_{\text{dispatch}} = B \times S \times K \times H \times \text{sizeof(dtype)}$$

$$\text{All-to-All}_{\text{combine}} = B \times S \times K \times H \times \text{sizeof(dtype)}$$

$$\text{总通信量} = 2 \times B \times S \times K \times H \times \text{sizeof(dtype)}$$

其中：
- $B$ = batch size
- $S$ = 序列长度
- $K$ = Top-k 值
- $H$ = hidden size
- $\text{sizeof(dtype)}$ = $2$ bytes（BF16/FP16）或 $1$ byte（FP8）

通信量与哪些因素成正比？
- 与 batch size 成正比：更大的 batch 意味着更多的 token 需要通信
- 与序列长度成正比：更长的序列意味着更多的 token
- 与 Top-k 成正比：每个 token 路由到更多专家，通信量线性增长
- 与 hidden size 成正比：每个 token 的表示更大
- 与专家数量无关（只要 EP size 不变）：这是 EP 的重要特性

为什么 All-to-All 成为瓶颈：

1. 同步通信：所有 GPU 必须等待 All-to-All 完成才能继续，形成同步屏障。任何一个 GPU 慢了，所有 GPU 都要等
2. 跨节点带宽低：节点内 NVLink 带宽可达 $900$ GB/s，但节点间 InfiniBand 带宽通常只有 $200$ GB/s 甚至更低
3. 负载不均衡加剧等待："热门"专家成为短板，持有该专家的 GPU 处理时间过长，其他 GPU 空闲等待

EP vs TP 的通信对比：

• EP：$4 \times B \times S \times K \times H$ bytes（dispatch + combine，BF16）
• TP：$8 \times B \times S \times H$ bytes（每层的两次 All-Reduce）
• 当 $K=2$ 时，EP 通信量约等于 TP；$K$ 越大 EP 通信量越高

4.5.2.2 优化策略一：计算-通信重叠

在 All-to-All 进行的同时执行其他计算，是最直接的优化手段：

text 时间线: ├─ All-to-All Dispatch 开始 │ └─ 重叠: 计算已到达 token 的 Expert FFN ├─ All-to-All Dispatch 完成 │ └─ 所有 token 已到达目标 GPU ├─ Expert 计算（大矩阵乘法，GPU 满负荷） ├─ All-to-All Combine 开始 │ └─ 重叠: 准备下一层的计算 ├─ All-to-All Combine 完成text

DeepEP（DeepSeek 的 Expert Parallelism 内核库）通过精细的流水线调度，实现了高达 $70\%$ 的计算-通信重叠率。

实现技巧：
1. 使用多个 CUDA stream：一个用于通信，一个用于计算
2. 分块处理：将大 batch 分成多个小块，块间流水线化
3. 预取：在计算当前块的同时，预取下一块需要的专家参数

4.5.2.3 优化策略二：节点受限路由

节点受限路由（Device-Limited Routing）限制每个 token 最多发送到 $M$ 个节点，而非所有节点。

DeepSeek-V3 的配置：
- 每层路由专家分布在 $8$ 个节点的 $64$ 个 GPU 上
- 每个 token 最多发送到 $M = 4$ 个节点
- 通过预先分组专家，每个节点包含一组专家
- 路由器首先选择节点，再选择节点内的专家

路由流程：

text Token → 选择 M=4 个节点 → 在每个节点内选择 K/M 个专家 → 只与这 4 个节点做 All-to-Alltext

效果：All-to-All 通信量减少为原来的 $M/8 = 50\%$。

负载均衡的考量：

节点受限路由可能与负载均衡产生冲突——如果某个节点包含的所有专家都过载，限制 token 发送到该节点会加剧不均衡。DeepSeek-V3 的解决方案是：
1. Loss-Free Balancing 在每个节点内部独立调整偏置
2. 节点间的负载通过全局偏置协调
3. 允许 token 在必要时发送到非首选节点（软限制而非硬限制）

4.5.2.4 优化策略三：FP8 量化通信

将 All-to-All 通信的数据类型从 BF16 降至 FP8，直接减半通信量：

$$\text{通信量}{\text{FP8}} = \frac{1}{2} \times \text{通信量}{\text{BF16}}$$

DeepSeek-V3 是首个大规模验证 FP8 训练与通信的 MoE 模型。FP8 的挑战在于：

1. 量化范围：FP8（E4M3）的动态范围约为 $[-448, 448]$，对于某些激活值可能不够
2. 精度损失：FP8 只有 $4$ 位指数和 $3$ 位尾数，精度远低于 BF16
3. 混合精度：DeepSeek-V3 采用混合精度策略：矩阵乘法使用 FP8，累加使用 FP32，权重更新使用 BF16

DeepSeek-V3 的 FP8 策略：
- 路由计算（softmax）使用 FP32
- 只有专家 FFN 的 GEMM 使用 FP8
- All-to-All 通信使用 FP8
- 累加使用 FP32 防止精度累积误差

4.5.2.5 优化策略四：多流并行

使用多个 CUDA 流并行执行通信和计算：

```python

伪代码：多流并行

stream_comm = torch.cuda.Stream() # 通信流
stream_compute = torch.cuda.Stream() # 计算流

with torch.cuda.stream(stream_comm):
# All-to-All dispatch
dispatched_tokens = all_to_all(tokens, routing_info)

with torch.cuda.stream(stream_compute):
# 同时计算已到达的 token
for expert_id in local_experts:
if tokens_arrived[expert_id]:
outputs[expert_id] = expertexpert_id
```text

多流并行允许 GPU 在执行计算的同时发起通信请求，最大化硬件利用率。

4.5.3 推理时的MoE调度

4.5.3.1 MoE 推理的显存挑战

MoE 推理面临的最大挑战是：虽然激活参数少，但需要加载全部参数到显存（无法预知道路选择）。

显存需求：

$$\text{Total VRAM} = \text{Model Weights} + \text{KV Cache} + \text{Activations}$$

以具体模型为例：

Mixtral 8x7B 的 $97$ GB 总显存已超过单卡 A100（80 GB），需要多卡或量化方案。

优化方案：
- 4-bit 量化（GPTQ/AWQ）：$47$B $\rightarrow$ 约 $27$ GB，可放入 $48$ GB GPU
- 专家卸载（Offloading）：不活跃专家放在 CPU 内存
- 专家缓存（Caching）：保持常用专家在 GPU，按需加载其他专家

4.5.3.2 Expert Offloading 策略

对于无法完全放入显存的超大 MoE 模型，Expert Offloading 是一种有效的调度策略：

策略 1：LRU/LFU 缓存
- Mixtral-Offloading/AdapMoE：Least Recently/Frequently Used 专家淘汰
- 保持热专家常驻 GPU，冷专家在 CPU 内存
- 实现简单，效果取决于访问模式的局部性

策略 2：语义缓存
- fMoE：基于输入语义的专家预测缓存
- 利用历史 prompt 与当前输入的匹配度决定缓存
- 需要维护一个语义索引结构

策略 3：预测性加载
- 基于前层路由结果预测下层的专家需求
- 提前异步加载可能需要的专家，隐藏 I/O 延迟
- 实现复杂度高，但在特定场景下效果显著

4.5.3.3 Sparsity Erosion 问题

Sparsity Erosion（稀疏性侵蚀）是 MoE 推理中特有的效率问题：由于 batch size 小（如 decode 阶段每次只生成 $1$ 个 token）或 chunked prefill 导致专家激活覆盖率降低，MoE 的稀疏优势被削弱。

量化数据（Qwen3-30B-A3B 在 ShareGPT 数据集）：

小 batch 时，每个专家只处理少量 token，矩阵乘法 shape 小，GPU 利用率低，MoE 的优势几乎丧失殆尽。

Chunked Prefill 的冲突：

Prefill 阶段分块处理 → batch size 受限 → MoE 专家覆盖率低。这种现象称为"稀疏性侵蚀"（Sparsity Erosion）—— chunk 越小，专家激活的覆盖率越低。

4.5.3.4 推理优化策略

策略 1：Continuous Batching
将多个请求动态组合成一个 batch，增大等效 batch size：

$$\text{Effective Batch} = \sum_{r \in \text{active requests}} \text{tokens per request}$$

这是解决 Sparsity Erosion 的最有效手段。通过动态批处理，可以将来自不同请求的 token 组合在一起，提高每个专家的处理 batch size。

策略 2：专家批处理（Expert Batching）
将激活相同专家的请求分组处理，最大化每个专家的处理 batch size：

$$\text{Group requests by expert affinity} \rightarrow \text{Process each expert with larger batch}$$

策略 3：投机解码（Speculative Decoding）
使用 MTP（Multi-Token Prediction）预测多个 token，增大等效 batch：

$$\text{Speedup} \approx \frac{\text{Accepted Tokens}}{\text{Draft Steps}}$$

DeepSeek-V3 的 MTP 模块可以在一次前向传播中预测多个后续 token，这天然增加了等效 batch size。

策略 4：预取专家
根据历史模式预加载高频专家：

$$\text{Prefetch}(E_i \text{ at layer } l+1) = f(\text{routing result at layer } l)$$

4.5.3.5 MoE 推理的性能权衡

MoE 推理与 Dense 推理的性能对比是一个复杂的多维权衡：

工程建议：
- 大 batch 推理（如服务场景）：MoE 优势明显，推荐部署
- 小 batch 推理（如交互场景）：需配合 Expert Offloading 和 Continuous Batching
- 极低延迟场景（如实时对话）：考虑 Dense 模型或高度优化的 MoE 部署

4.6 代表性MoE模型

本节将系统对比分析 MoE 发展史上的里程碑模型：GShard、Switch Transformer、Mixtral 系列、DeepSeek-MoE 系列以及 Qwen-MoE。通过这些模型的演进脉络，读者可以深刻理解 MoE 架构的设计理念变迁与技术进步。

4.6.1 GShard与Switch Transformer

4.6.1.1 GShard：大规模分布式MoE的奠基之作

GShard（Lepikhin et al., Google, 2020）是 MoE 发展史上的里程碑式工作，它首次将千亿参数规模的 MoE 模型在分布式系统上成功训练，开创了现代 MoE 的工程范式。

核心贡献：

1. 首个大规模分布式 MoE：训练了 $600$B 参数的 MoE Transformer，证明了分布式训练的可行性。在此之前，最大的 MoE 模型仅有数十亿参数
2. Expert Parallelism 范式：提出了专家并行的系统架构，将不同专家分布在不同 TPU 上。这一范式至今仍是所有大规模 MoE 的基础
3. Top-2 路由 + 随机 2nd：主专家通过 Top-1 选择，第 2 个专家随机选择。这种设计在提供冗余的同时促进了探索
4. 自动分片（Auto Sharding）：利用 XLA 编译器自动将计算图分布到数千设备，极大地简化了分布式编程

架构参数：

Top-2 + 随机 2nd 的设计动机：

$$\mathcal{T}t^{(1)} = \arg\max_i p{t,i}$$