大模型预训练学习笔记

一、Decoder-only 的因果语言模型

1.1 预训练目标

1.1.1 数学形式

给定一个由 Token 组成的本文序列 $x=(x_1,x_2,\cdots ,x_T)$，其中 $x_i\in V$（$V$ 为词表），Decoder-Only 模型通过链式法则将联合概率分解为条件概率的乘积：

$$p_{\theta }(x_{1:T})=\prod _{t=1}^T{p}_{\theta }(x_t\mid x_{<t}).$$

其中 $\theta$ 为模型全部可学习参数。这是自回归语言模型的核心数学假设：每个位置仅依赖于其左侧的所有历史 token。

训练目标通常是最大化训练语料的似然：

$$\underset{\theta }{max}\sum _{i=1}^N\sum _{t=1}^{T_i}\log p_{\theta }(x_t^{(i)}\mid x_{<t}^{(i)})$$

等价于最小化负对数似然：

$$\mathcal{L}(\theta )=-\sum _{i=1}^N\sum _{t=1}^{T_i}\log p_{\theta }(x_t^{(i)}\mid x_{<t}^{(i)})$$

在深度学习实现中，这通常就是 cross entropy loss。

推理时，Decoder-only 则把“指令、上下文、回答”全部串成一个 token 序列：

$$s=[x_1,\dots ,x_m,y_1,\dots ,y_n],p_{\theta }(s)=\prod _{t=1}^{m+n}{p}_{\theta }(s_t\mid s_{<t}).$$

1.1.2 从统计的角度看

对 token 序列 $x_{1:T}$：

$$p_{\theta }(x_{1:T})=\prod _{t=1}^T{p}_{\theta }(x_t\mid x_{<t}).$$

最大化训练数据的对数似然等价于最小化 next-token 交叉熵：

$$\mathcal{L}(\theta )=-\frac{1}{N_{\text{tok}}}\sum _{i=1}^n\sum _{t=1}^{T_i}\log p_{\theta }(x_t^{(i)}\mid x_{<t}^{(i)}).$$

从统计角度看，这是对真实条件分布 $p^{\ast }(x_t\mid x_{<t})$ 的经验风险最小化。其总体风险满足

$${\mathbb{E}}_{p^{\ast }}[-\log p_{\theta }]=H(p^{\ast })+D_{\mathrm{KL}}(p^{\ast }\Vert p_{\theta }),$$

证明：

$$\begin{array}{rl}{\mathbb{E}}_{p^{\ast }}[-\log p_{\theta }]& =-\sum _{i=1}^n\sum _{t=1}^{T_i}{p}^{\ast }(x_t^{(i)}\mid x_{<t}^{(i)})\log p_{\theta }(x_t^{(i)}\mid x_{<t}^{(i)})\text{记为}-\sum p^{\ast }\log p_{\theta }\\ & =-\sum p^{\ast }\log \frac{p_{\theta }}{p^{\ast }}{p}^{\ast }\\ & =\sum p^{\ast }\log \frac{p^{\ast }}{p_{\theta }}-\sum p^{\ast }\log p^{\ast }\end{array}$$

其中：

$$H(p^{\ast })=-\sum p^{\ast }\log p^{\ast },D_{\mathrm{KL}}(p^{\ast }\Vert p_{\theta })=\sum p^{\ast }\log \frac{p^{\ast }}{p_{\theta }}$$

所以理想情况下，最小化交叉熵就是缩小模型条件分布与真实条件分布之间的 KL 散度。

1.2 Decoder-only 的整体架构

Decoder-only Transformer 的主体结构并没有脱离原始 Transformer：

$$\text{Embedding}\to {\text{Decoder Block}}_1\to \cdots \to {\text{Decoder Block}}_L\to \text{LM Head}$$

每个 Decoder Block 通常包含：

$$\text{Masked Self-Attention}+\text{Feed-Forward Network}+\text{Residual Connection}+\text{Normalization}$$

相对于原始 Transformer Decoder，Decoder-only 的架构：

• 去掉 Encoder；
• 去掉 Encoder–Decoder Cross-Attention；
• 保留带 causal mask 的 Self-Attention；
• 保留逐位置 FFN、残差连接、归一化；
• 最后用 LM Head 把隐藏向量映射成词表上的概率分布。

现代模型通常也不再原样使用 2017 Transformer 的配置，而常采用以下组合：

$$\text{Pre-Norm}+\text{RMSNorm}+\text{RoPE}+\text{SwiGLU}+\text{GQA/MQA/MLA}.$$

这些是常见设计，不是 Decoder-only 的数学定义；不同模型会选择不同变体。

1.2.1 一个 Decoder block 的计算

设第 $\ell$ 层输入为 $H^{(\ell )}\in {\mathbb{R}}^{T\times d}$。以常见的 Pre-Norm 结构为例：

$$\begin{array}{rl}{\tilde{H}}^{(\ell )}& =H^{(\ell )}+\mathrm{Attn}(\mathrm{Norm}(H^{(\ell )})),\text{(Attn是Causal Attn)}\\ H^{(\ell +1)}& ={\tilde{H}}^{(\ell )}+\mathrm{FFN}(\mathrm{Norm}({\tilde{H}}^{(\ell )})).\end{array}$$

Pre-Norm 中存在接近恒等映射的残差通路，梯度更容易穿过深层网络，通常比 Post-Norm 更适合大规模训练。

1.2.2 输入和输出流程

$$\text{token ids}\stackrel{\text{Embedding}}{\to }{H}^{(0)}\stackrel{L\text{ 个 Decoder blocks}}{\to }{H}^{(L)}\stackrel{\text{Norm}}{\to }Z\stackrel{W_{\text{vocab}}}{\to }\text{logits}.$$

对位置 $t$：

$$z_t=W_{\text{vocab}}{h}_t+b,p_{\theta }(x_{t+1}=v\mid x_{\le t})=\frac{e^{z_{t,v}}}{\sum _{u=1}^V{e}^{z_{t,u}}}.$$

常见的 weight tying 令输出矩阵与输入词嵌入共享参数：

$$W_{\text{vocab}}=E^{\mathrm{\top }}.$$

1.3 关键组件演进

在大模型预训练中，为了提升训练稳定性、收敛速度、数值效率和参数利用率，许多细节组件发生了系统性演进。这些变化看似是“工程细节”，但实际上直接影响大模型能否稳定扩展到几十亿、几百亿甚至更大规模。

1.3.1 归一化位置

1. Post-Norm：原始 Transformer 的结构

Post-Norm 结构，即先经过子层和残差连接，再做 LayerNorm：

$$x_{l+1}=\mathrm{LN}(x_l+F(x_l))$$

具体到 Decoder Block 中，可以写成：

$$\begin{gathered} {\tilde{x}}_l=\mathrm{LN}(x_l+\mathrm{Attn}(x_l)) \\ {x}_{l+1}=\mathrm{LN}({\tilde{x}}_l+\mathrm{FFN}({\tilde{x}}_l)) \end{gathered}$$

Post-Norm 的优点是每一层输出都经过归一化，因此表面上看数值范围较稳定。

但问题是：当模型很深时，梯度需要反向穿过多个 LayerNorm 和非线性模块，容易出现训练不稳定：

$$\frac{\partial \mathcal{L}}{\partial x_l}=\frac{\partial \mathcal{L}}{\partial x_{l+1}}\cdot \frac{\partial \mathrm{LN}(x_l+F(x_l))}{\partial x_l}$$

由于 LayerNorm 位于残差连接之后，残差路径也要经过 LayerNorm 的变换。这意味着原本应该提供稳定梯度通道的残差连接被 LayerNorm 限制住了。

2. Pre-Norm：现代大模型更常用的结构

Pre-Norm 把归一化放到子层之前：

$$x_{l+1}=x_l+F(\mathrm{LN}(x_l))$$

具体到 Decoder Block：

$$\begin{gathered} {\tilde{x}}_l=x_l+\mathrm{Attn}(\mathrm{LN}(x_l)) \\ {x}_{l+1}={\tilde{x}}_l+\mathrm{FFN}(\mathrm{LN}({\tilde{x}}_l)) \end{gathered}$$

这个结构中，残差主路径是：

$$x_l\to x_l+F(\mathrm{LN}(x_l))$$

因此至少有一部分梯度可以沿着近似恒等映射传播：

$$\frac{\partial x_{l+1}}{\partial x_l}\approx I+\text{other terms}$$

这使得深层网络更容易训练。

Pre-Norm 更稳定，但它也可能带来一个问题：由于每一层都是在残差主干上增加一个较小更新，模型深层部分的表示更新可能偏保守。

所以，从训练角度看，Pre-Norm 的本质作用是：

$$\boxed{{\displaystyle \text{让残差路径更顺畅，从而改善深层 Transformer 的梯度传播}}}$$

---

1.3.2 归一化方法

1. LayerNorm

给定某一层某个 token 的隐藏向量 $x\in {\mathbb{R}}^d$，LayerNorm 对这个向量的特征维度做归一化：

$$\mathrm{LN}(x)=\gamma \odot \frac{x-\mu }{\sqrt{{\sigma }^2+ϵ}}+\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$ 是可学习参数。

它的作用是稳定不同层、不同 token 的激活分布。

2. RMSNorm：去掉均值中心化，只保留尺度归一化

RMSNorm 的核心思想是：

不减均值，只根据向量的均方根大小进行缩放。

给定 $x\in {\mathbb{R}}^d$，定义均方根：

$$\mathrm{RMS}(x)=\sqrt{\frac{1}{d}\sum _{i=1}^d{x}_i^2+ϵ}$$

RMSNorm 写作：

$$\mathrm{RMSNorm}(x)=\gamma \odot \frac{x}{\mathrm{RMS}(x)}$$

RMSNorm 论文的核心假设是：LayerNorm 中的 re-centering invariance 不是必须的，因此可以只保留 re-scaling invariance，从而减少计算量。

---

1.3.3 激活函数

1. GELU

GELU，即 Gaussian Error Linear Unit，定义为：

$$\mathrm{GELU}(x)=x\mathrm{\Phi }(x)$$

其中 $\mathrm{\Phi }(x)$ 是标准正态分布的累积分布函数。GELU 最早作为一种高性能神经网络激活函数被提出，后来被 BERT、GPT 等 Transformer 模型广泛使用。

输入 $x$ 是否被保留，不是由 $x>0$ 这个硬阈值决定，而是由一个连续概率权重决定

2. SiLU

定义为：

$$\mathrm{SiLU}(x)=x\sigma (x),\sigma (x)=\frac{1}{1+e^{-x}}$$

它与 GELU 类似，也是一种“输入乘以门控函数”的形式。

从表达能力角度看：

$$\boxed{{\displaystyle \text{GELU / SiLU 比 ReLU 更适合大规模 Transformer 的连续表示学习}}}$$

---

1.3.4 前馈网络

1. 标准 FFN

Transformer 中的 FFN 是逐 token 作用的多层感知机。

给定隐藏向量 $x\in {\mathbb{R}}^{1\times d_{\text{model}}}$，标准 FFN 通常写作：

$$\mathrm{FFN}(x)=\varphi (x{W}_1+b_1)W_2+b_2$$

其中：$W_1\in {\mathbb{R}}^{d_{\text{model}}\times d_{\text{ff}}},W_2\in {\mathbb{R}}^{d_{\text{ff}}\times d_{\text{model}}}$，通常 $d_{\text{ff}}\approx 4d_{\text{model}}$

所以它先升维 $d_{\text{model}}\to d_{\text{ff}}$，再降维 $d_{\text{ff}}\to d_{\text{model}}$。

直观上，Attention 负责 token 之间的信息交互，而 FFN 负责对每个 token 的表示进行非线性变换

2. GLU：引入门控机制

GLU，即 Gated Linear Unit，基本形式是：

$$\mathrm{GLU}(x)=(x{W}_1)\odot \sigma (x{W}_2)$$

其中：

• $x{W}_1$：内容分支；
• $\sigma (x{W}_2)$：门控分支；
• $\odot$：逐元素乘法。

从统计建模角度看，可以理解为输入相关的特征选择：

$$z_j={\text{content}}_j(x)\cdot {\text{gate}}_j(x)$$

其中每个通道 $j$ 的保留程度由输入 $x$ 自适应决定。

3. SwiGLU：现代 LLM 中常见的 FFN 结构

SwiGLU 是 GLU 的一种变体，把 sigmoid gate 换成 SiLU / Swish 型门控：

$$\mathrm{SwiGLU}(x)=(W_{a}x)\odot \mathrm{SiLU}(W_{b}x)$$

然后再接输出投影：

$${\mathrm{FFN}}_{\text{SwiGLU}}(x)=W_2[(W_{a}x)\odot \mathrm{SiLU}(W_{b}x)]$$

GLU 变体研究表明，在 Transformer 中使用 GEGLU、SwiGLU 等门控 FFN 变体通常可以改善模型效果；这些变体后来也成为许多大模型的常见组件

4. 标准 FFN 与 SwiGLU 的结构对比

标准 FFN：

$$x\to W_{1}x\to \varphi (W_{1}x)\to W_2\varphi (W_{1}x)$$

SwiGLU FFN：

$$x\to \{\begin{array}{l}{W}_{\text{up}}x\\ W_{\text{gate}}x\end{array}\to \mathrm{SiLU}(W_{\text{gate}}x)\odot W_{\text{up}}x\to W_{\text{down}}$$

核心区别是：

$$\boxed{{\displaystyle \text{SwiGLU 多了一条与输入 x 相关的门控路径}}}$$

• 增强通道选择能力
• 提高非线性表达能力

---

1.3.5 注意力头

$$\text{MHA → MQA / GQA}$$

1. MHA

给定输入隐藏状态 $X\in {\mathbb{R}}^{T\times d}$，对每个注意力头 $h=1,\dots ,H$，分别计算：

$$\begin{gathered} Q_h=X{W}_h^Q,K_h=X{W}_h^K,V_h=X{W}_h^V, \\ {Q}_h,K_h,V_h\in {\mathbb{R}}^{d\times d_{\text{head}}} \end{gathered}$$

每个头的注意力输出为：

$${\mathrm{Attn}}_h(Q_h,K_h,V_h)=\mathrm{softmax}(\frac{Q_h{K}_h^{\mathrm{\top }}}{\sqrt{d_{\text{head}}}}+M)V_h\in {\mathbb{R}}^{T\times d_{\text{head}}}$$

最后把所有头拼接：

$$\mathrm{MHA}(X)=\mathrm{Concat}({\mathrm{head}}_1,\dots ,{\mathrm{head}}_H)W^O\in {\mathbb{R}}^{T\times d}$$

MHA 的优点是：每个头有独立的 $Q,K,V$，可以学习不同的关系模式。

但是在大模型推理阶段，MHA 有一个明显问题：KV Cache 很大

Decoder-only 模型是自回归生成 $p_{\theta }(x_t\mid x_{<t})$，生成第 $t$ 个 token 时，需要使用之前所有 token 的 Key 和 Value。

为了避免每一步都重新计算历史 token 的 $K,V$，推理时会缓存它们：

$$\text{KV Cache}=\{K_1,V_1,\dots ,K_{t-1},V_{t-1}\}$$

对于 MHA，每一层、每个注意力头都要保存自己的 (K,V)。

如果模型有：

• 层数：$L$
• 注意力头数：$H$
• 序列长度：$T$
• 每个头维度：$d_{\text{head}}$

那么 KV Cache 的规模大致是：

$$\mathcal{O}(2LHT{d}_{\text{head}})=\mathcal{O}(2LTd)$$

当 batch size、上下文长度和层数都较大时，KV Cache 会成为推理显存和带宽瓶颈。

---

2. MQA

MQA, Multi-Query Attention 的核心思想是：

Query 仍然保留多个头，但所有 Query heads 共享同一组 Key 和 Value。

标准 MHA 是：

$$Q_h=X{W}_h^Q,K_h=X{W}_h^K,V_h=X{W}_h^V$$

MQA 则在其基础上，

$$W_1^K=W_2^K=\cdots =W_h^K,W_1^V=W_2^V=\cdots =W_h^V$$

即：

$$Q_h=X{W}_h^Q,K=X{W}^K,V=X{W}^V$$

也就是说：

$$\boxed{{\displaystyle \text{多个 Query heads}+\text{一组共享 KV heads}}}$$

KV Cache 规模变化：

$$\mathcal{O}(2LHT{d}_{\text{head}})⟶\mathcal{O}(2LT{d}_{\text{head}})$$

当然，因为所有头共享 $KV$，模型的表达能力可能下降。

---

3. GQA

GQA, Grouped-Query Attention 是 MHA 和 MQA 之间的折中方案。

它的思想是：

Query heads 仍然有很多个，但 Key/Value heads 不是 1 个，而是分成若干组，每组 Query heads 共享一组 Key/Value。

例如：

$$H_q=32,H_{kv}=8$$

则每 4 个 Query heads 共享一组 Key/Value。

QA 是当前很多 Decoder-only LLM 的常见选择，因为它在效果和推理效率之间取得平衡。

方法	表达能力	KV Cache	推理效率
MHA	强	大	慢
MQA	较弱	最小	快
GQA	接近 MHA	明显降低	较快

可以理解为：

$$\boxed{{\displaystyle \text{GQA 是 MHA 与 MQA 的折中：比 MQA 表达力更强，比 MHA 推理更省}}}$$

GQA 论文也强调，它可以在接近 MHA 质量的同时达到接近 MQA 的推理速度

---

1.3.6 参数初始化方式

参数初始化的核心目标是让前向传播和反向传播的尺度保持稳定。

理想情况下，希望：

$$\begin{gathered} \mathrm{Var}(x_l)\approx \mathrm{Var}(x_{l+1}) \\ \mathrm{Var}\left(\frac{\partial \mathcal{L}}{\partial x_l}\right)\approx \mathrm{Var}\left(\frac{\partial \mathcal{L}}{\partial x_{l+1}}\right) \end{gathered}$$

如果初始化过大：

$$\parallel F_l(x_l)\parallel$$

会很大，残差更新过强，训练初期容易不稳定。

如果初始化过小：

$$F_l(x_l)\approx 0$$

模型训练初期接近恒等映射，虽然稳定，但学习可能较慢。

所以初始化本质是在平衡：

$$\boxed{{\displaystyle \text{稳定性}\text{与}\text{有效更新幅度}}}$$

---

1. 标准正态初始化

早期 GPT 类模型常使用类似正态初始化：

$$W\sim \mathcal{N}(0,{\sigma }^2)$$

2. Xavier / Glorot 初始化

若输入维度为 $d_{\text{in}}$，输出维度为 $d_{\text{out}}$，Xavier 初始化目标是。

前向传播方差分析

设 $x\in {\mathbb{R}}^{d_{\text{in}}},W\in {\mathbb{R}}^{d_{\text{out}}\times d_{\text{in}}}$，前向传播为：

$$y=Wx\in {\mathbb{R}}^{d_{\text{out}}}$$

• $x$ 的各分量独立，$\mathbb{E}[x]=0$，协方差矩阵 ${\mathrm{\Sigma }}_x={\sigma }_x^2{I}_{d_{\text{in}}}$
• $W$ 的各元素独立，$\mathbb{E}[W_{ij}]=0$，$\mathrm{Var}(W_{ij})={\sigma }_W^2{I}_{\text{out}}$
• $W$ 与 $x$ 相互独立

$$\begin{array}{rl}{\mathrm{\Sigma }}_y& =\mathbb{E}[y{y}^{\mathrm{\top }}]=\mathbb{E}[Wx{x}^{\mathrm{\top }}{W}^{\mathrm{\top }}]\\ & ={\mathbb{E}}_W(E_x(Wx{x}^T{W}^T|x))={\mathbb{E}}_W(W{\mathrm{\Sigma }}_x{W}^T)\\ & ={\sigma }_x^2{\mathbb{E}}_W(W{W}^T)\end{array}$$

计算 $\mathbb{E}(W{W}^T)$：

$$\begin{gathered} \mathbb{E}[(W{W}^T{)}_{ij}]=\{\begin{array}{ll}{d}_{\text{in}}\cdot {\sigma }_W^2& \text{if }i=k\\ 0& \text{if }i\ne k\end{array} \\ \boxed{{\displaystyle \mathbb{E}[W{W}^{\mathrm{\top }}]=d_{\text{in}}{\sigma }_W^2{I}_{d_{\text{out}}}}} \end{gathered}$$

代回得到：

$${\mathrm{\Sigma }}_y={\sigma }_x^2{d}_{\text{in}}{\sigma }_W^2{I}_{d_{\text{out}}}$$

希望逐层传播后方差不变，即前向传播方差稳定条件 $\mathrm{Var}(y_j)=\mathrm{Var}(x_i)$：

$$d_{\text{in}}\cdot {\sigma }_W^2\cdot {\sigma }_x^2={\sigma }_x^2⟶\boxed{{\displaystyle {\sigma }_W^2=\frac{1}{d_{\text{in}}}}}$$

同样的方法，可以得到反向传播方差稳定条件：

$$\boxed{{\displaystyle {\sigma }_W^2=\frac{1}{d_{\text{out}}}}}$$

想要同时保持前向和反向方差稳定，Xavier 的做法是取两者的调和平均：

$$\frac{1}{\mathrm{Var}(W)}=\frac{1}{2}(\frac{1}{1/d_{\text{in}}}+\frac{1}{1/d_{\text{out}}})=\frac{d_{\text{in}}+d_{\text{out}}}{2}$$$$\boxed{{\displaystyle \mathrm{Var}(W)=\frac{2}{d_{\text{in}}+d_{\text{out}}}}}$$

常见形式：

$$W_{ij}\sim \mathcal{U}(-\sqrt{\frac{6}{d_{\text{in}}+d_{\text{out}}}},\sqrt{\frac{6}{d_{\text{in}}+d_{\text{out}}}})$$

或：

$$W_{ij}\sim \mathcal{N}(0,\frac{2}{d_{\text{in}}+d_{\text{out}}})$$

3. 残差分支缩放初始化

首先，我们看残差叠加带来的尺度问题。如果每一层都执行：

$$x_{l+1}=x_l+F_l(x_l)⟶x_L=x_0+\sum _{l=0}^{L-1}{F}_l(x_l)$$

如果每个 $F_l(x_l)$ 的方差大致相同，假设：

$$\mathrm{Var}(F_l(x_l))\approx {\sigma }^2$$

如果有 $L$ 层，并且各层更新近似独立，则有：

$$\mathrm{Var}(x_L)\approx \mathrm{Var}(x_0)+L{\sigma }^2$$

这说明层数越深，残差累积可能导致激活尺度增大。

为了控制残差分支的输出尺度，可以让某些输出投影权重初始化更小，例如：

$$W_{\text{out}}\sim \mathcal{N}(0,\frac{{\sigma }^2}{2L})$$

总结

模块	早期形式	现代常见形式	主要目的
归一化位置	Post-Norm	Pre-Norm	深层训练稳定
归一化方法	LayerNorm	RMSNorm	降低计算量，稳定尺度
激活函数	ReLU	GELU / SiLU	更平滑的非线性表达
前馈网络	标准 FFN	GLU / SwiGLU	增强门控与通道选择
注意力头	MHA	MQA / GQA	降低 KV Cache，提高推理效率
残差路径	普通残差	更重视残差尺度控制	防止深层累积失控
参数初始化	普通初始化	深度相关初始化 / 残差缩放	控制前向与反向方差
训练配置	Bias + Dropout 常用	减少 Bias / 减少 Dropout	简化结构，提高大规模训练效率

1.4 MoE稀疏专家模型

MoE，全称 Mixture of Experts，即专家混合模型。在大语言模型中，它通常指：

$$\boxed{{\displaystyle \text{用多个专家网络共同组成模型，但每个 token 只激活其中少数几个专家}}}$$

所以 MoE 的核心不是“把模型变小”，而是：

$$\boxed{{\displaystyle \text{增加总参数量，但保持每次计算只使用一小部分参数}}}$$

在标准稠密 Transformer 中，每个 token 必须经过全部参数的计算。模型性能随参数量增长而提升（Scaling Laws），但推理 FLOPs、显存、延迟也线性增长。

MoE 的核心目标是解耦两件事：

• 总参数量（模型容量/知识储备）→ 可以非常大

• 每个 token 的激活参数量（实际计算量）→ 保持很小

1.4.1 核心架构

在标准 Decoder-only Transformer 中，每一层通常有一个 FFN：

$$\mathrm{FFN}(x)=\varphi (x{W}_1)W_2$$

所有 token 都经过同一个 FFN。

而 MoE 的思想是把一个 FFN 替换成多个专家，即 $N$ 个结构相同的 FFN 子网络，各自拥有独立参数：

$$\begin{gathered} E_1,E_2,\dots ,E_N \\ {E}_i(x)=\varphi (x{W}_i^{\text{in}})W_i^{\text{out}},i=1,2,\cdots ,N \end{gathered}$$

然后，对于每个 token 表示 $x$，模型通过一个门控网络判断应该交给哪些专家处理：

给定 token 表示 $x\in {\mathbb{R}}^{1\times d}$，计算所有专家的打分：

$$s(x)=x{W}_g\in {\mathbb{R}}^{1\times N},W_g\in {\mathbb{R}}^{d\times N}$$

然后通过一些方法将得分转化为概率权重：

$$p(x)=\text{gate}(s(x))$$

其中 $p_i(x)$ 表示 token $x$ 被分配给专家 $i$ 的权重或概率。

最后计算 MoE FFN：

$$y=\sum _{i=1}^N{p}_i(x)E_i(x)$$

其中：

• $E_i(x)$：第 $i$ 个专家网络；
• $p_i(x)$：第 $i$ 个专家的权重；
• $N$：专家总数。

如果所有专家都参与计算，这就是 dense MoE。

但大语言模型中常用的是 sparse MoE，即只激活少数专家，这是由 $\text{gate}$ 的方式决定的。

1.4.2 Top-k 稀疏激活

Top-k 稀疏激活：不是所有专家都参与计算，而是只选择得分最高的 $k$ 个专家

定义：

$${\mathcal{T}}_k(x)=\mathrm{TopK}(p(x))$$

其中：

$${\mathcal{T}}_k(x)\subset \{1,2,\dots ,N\}$$

表示 token $x$ 选中的 $k$ 个专家。

于是 Sparse MoE 的输出为：

$$\mathrm{MoE}(x)=\sum _{i\in {\mathcal{T}}_k(x)}{\tilde{p}}_i(x)E_i(x)$$

其中：

$${\tilde{p}}_i(x)=\frac{p_i(x)}{\sum _{j\in {\mathcal{T}}_k(x)}{p}_j(x)}$$

表示在选中的 Top-k 专家内部重新归一化后的权重。

所以完整形式是：

$$\boxed{{\displaystyle \mathrm{MoE}(x)=\sum _{i\in \mathrm{TopK}(\mathrm{softmax}(x{W}_g))}{\tilde{p}}_i(x)E_i(x)}}$$

总结：

$$\boxed{{\displaystyle \text{MoE = 大容量参数空间 + 稀疏激活计算}}}$$

1.4.3 专家容量与 Token 分配

1.4.4 负载均衡与辅助损失

1.4.5 Expert Parallelism 与 All-to-All 通信

1.4.6 MoE 的收益、代价与适用场景

二、Scaling Law

Scaling Law 可以理解为规模定律。在大语言模型预训练中，它关心的是：

$$\boxed{{\displaystyle \text{模型规模、数据规模、计算量与模型损失之间的经验规律}}}$$

更具体地说，它试图回答三个问题：

1. 模型参数 $N$ 增大，模型效果会怎么变？
2. 训练 token 数 $D$ 增大，模型效果会怎么变？
3. 计算预算 $C$ 固定时，应该把预算分给更大的模型，还是更多的数据？

通常记：

符号	含义
$N$	模型参数量，number of parameters
$D$	训练 token 数，dataset size
$C$	训练计算量，compute，常用 FLOPs 表示
$L$	语言模型的预测损失，通常是 cross entropy loss

2.1 核心幂律关系

2.1.1 Scaling Law 的基本形式

Scaling Law 的核心观察是：

$$\boxed{{\displaystyle \text{语言模型的 loss 会随模型规模、数据规模、计算量呈幂律下降}}}$$

Kaplan et al. 的 Scaling Laws for Neural Language Models 系统研究了模型大小、数据集大小和训练计算量与语言模型交叉熵损失之间的幂律关系，并指出这些趋势可跨越多个数量级。OpenAI

一个常见的通用形式是：

$$L(x)=L_{\mathrm{\infty }}+A{x}^{-\alpha }$$

其中：

• $L(x)$：给定规模 $x$ 下的 loss；
• $L_{\mathrm{\infty }}$：不可约损失，表示即使规模无限增大也难以消除的部分；
• $A$：常数系数；
• $\alpha >0$：幂律指数；
• $x$：可以是模型参数量 $N$、数据量 $D$、计算量 $C$。

也就是说，loss 的下降不是线性的，而是：

$$\boxed{{\displaystyle L-L_{\mathrm{\infty }}\propto x^{-\alpha }}}$$

2.1.2 三种幂律

通用形式具体表现为三种幂律：

• 模型规模幂律：当数据充足、训练充分时，增大参数量可降低 loss：

$$L(N)=L_{\mathrm{\infty }}+A_N{N}^{-{\alpha }_N}$$

• 数据规模幂律：当模型足够大时，增加训练 token 数可降低 loss：

$$L(D)=L_{\mathrm{\infty }}+A_D{D}^{-{\alpha }_D}$$

• 计算量幂律：训练计算量 $C\approx 6ND$，$N$ 为非 embedding 参数量，系数 6 来自前向+反向传播的 FLOPs 估算），loss 随计算预算呈幂律下降：

$$L(C)=L_{\mathrm{\infty }}+A_C{C}^{-{\alpha }_C}$$

所以 Scaling Law 告诉我们：

$$\boxed{{\displaystyle \text{扩大模型有效，但收益递减}}}$$

---

2.1.3 三种瓶颈

实际预训练时，模型效果可能被不同因素限制。

• 模型瓶颈：$N$ 太小，模型容量不足以吸收数据中的信息。此时继续增加数据收益有限，应优先扩大模型。
• 数据瓶颈：$D$ 不足，模型反复看相同数据，容易过拟合。此时继续增大模型不划算，应优先增加高质量 token。
• 计算瓶颈：$C$ 不足，训练步数不够，模型未充分收敛。此时无论模型还是数据多好，都无法达到预期 loss。

2.2 计算最优分配原则

2.2.1 问题：固定计算预算下，模型和数据怎么分配？

Scaling Law 最重要的实际问题是：

$$\boxed{{\displaystyle \text{给定计算预算 }C,\text{ 如何选择模型参数量 }N\text{ 和训练 token 数 }D？}}$$

因为计算量近似满足：

$$C\approx 6ND$$

所以当 (C) 固定时，预训练规划的核心矛盾是：

$$\boxed{{\displaystyle \text{是训练更大的模型，还是让较小模型看更多数据？}}}$$

2.2.2 Kaplan Scaling Law：更重视增大模型

Kaplan et al. 的早期 Scaling Law 研究认为，在计算最优条件下，模型参数量应随计算预算增长得更快，而数据规模增长相对较慢。这个结论影响了早期大模型扩展路径，即更倾向于训练更大的模型。OpenAI

可以粗略理解为：

$$C\uparrow \Rightarrow N\text{ 增长较快},D\text{ 增长较慢}$$

这条路线对应早期很多超大参数模型，例如 GPT-3 这类模型体现了“扩大参数规模带来 few-shot 能力提升”的思路；OpenAI 对 GPT-3 的介绍也强调，扩大语言模型显著提升了任务无关的 few-shot 性能

2.2.3 Chinchilla Scaling Law：模型和数据应近似等比例增长

后来的 Chinchilla 工作重新研究了计算最优训练问题，结论发生了重要变化：

$$\boxed{{\displaystyle \text{在计算最优条件下，模型规模和训练 token 数应近似等比例增长}}}$$

Hoffmann et al. 在 Training Compute-Optimal Large Language Models 中指出，对于 compute-optimal training，模型大小和训练 token 数应当同时扩展；他们训练的 Chinchilla 使用与 Gopher 相同的计算预算，但参数量更小、训练数据约多 4 倍，并取得更好的效果。arXiv

形式上可以写成：

$$\begin{gathered} N_{\text{opt}}\propto C^a \\ {D}_{\text{opt}}\propto C^b \end{gathered}$$

Chinchilla 结论中：

$$a\approx b\approx \frac{1}{2}$$

这意味着：

$$\boxed{{\displaystyle C\text{ 增加 }k\text{ 倍时，}N\text{ 和 }D\text{ 都大约增加 }\sqrt{k}\text{ 倍}}}$$

2.2.4 Chinchilla 的直观含义：很多大模型其实 under-trained

Chinchilla 结论的一个重要启发是：

$$\boxed{{\displaystyle \text{许多早期大模型参数很多，但训练 token 不够}}}$$

也就是说，它们不是模型太小，而是数据看得不够多。

如果一个模型参数量非常大，但训练 token 数不足，那么它可能处于 under-trained large model状态。

此时，与其继续增加参数量，不如在相同计算预算下训练一个较小模型，但给它更多 token：

$$\text{smaller model}+\text{more tokens}$$

这可能获得更好的 loss 和下游表现。

2.2.5 计算最优的数学直觉

假设 loss 可以近似分解为：

$$L(N,D)=L_{\mathrm{\infty }}+\frac{A}{N^{\alpha }}+\frac{B}{D^{\beta }}$$

其中：

• $\frac{A}{N^{\alpha }}$：模型容量不足带来的误差；

• $\frac{B}{D^{\beta }}$：数据不足带来的误差。

代入计算约束 $C=6ND$：

$$L(N,D)=L_{\mathrm{\infty }}+\frac{A}{N^{\alpha }}+B(\frac{6N}{C}{)}^{\beta }$$

所以存在一个优化方式：

$$N_{\text{opt}}=\arg \underset{N}{min}L(N,D)$$

这就是计算最优分配的本质。

2.3 对预训练规划的指导

在预训练规划中，最重要的不是单纯追求更大的参数量，而是求解：

$$\boxed{{\displaystyle (N^{\ast },D^{\ast })=\arg \underset{6ND\le C}{min}L(N,D)}}$$

也就是在固定计算预算下，找到模型规模 (N) 和训练 token 数 (D) 的最优匹配。

2.3.1 从硬件预算估计总计算量

2.3.2 选择模型参数规模和训练 Token 总量

2.3.3 由全局 Batch Size 推算训练步数

2.3.4 规划上下文长度与样本数量

2.3.5 通过小模型试验拟合 Scaling 曲线

在真正训练大模型之前，可以先训练一系列小模型，并使用不同 token 数：

$$\begin{array}{r}{N}_1<N_2<\cdots <N_m\\ D_1<D_2<\cdots <D_k\end{array}$$

得到实验点：

$$(N_i,D_j,L_{ij})$$

然后拟合：

$$L(N,D)=L_{\mathrm{\infty }}+A{N}^{-\alpha }+B{D}^{-\beta }$$

如果拟合稳定，就可以外推到更大规模

2.3.6 为消融实验、评估与故障预留预算

小结：预训练规划的完整推导链条

Scaling Law 对预训练规划的指导可以整理成一条完整链路：

$$\begin{array}{rl}\text{硬件数量、算力、训练时间}& \to C_{\text{total}}\\ C_{\text{total}}& \to C_{\text{main}}\\ C_{\text{main}}\approx 6ND& \to (N,D)\text{ 的匹配关系}\\ D,B_{\text{tokens}}& \to T_{\text{steps}}=\frac{D}{B_{\text{tokens}}}\\ D,S& \to M=\frac{D}{S}\\ (N_i,D_j,L_{ij})& \to \text{拟合 Scaling Curve}\to (N^{\text{*}},D^{\text{*}})\end{array}$$

最终，预训练规划不是简单地决定一个模型大小，而是在求解：

$$\boxed{{\displaystyle \begin{array}{rl}(N^{\ast },D^{\ast },B^{\ast },S^{\ast })& =\arg minL(N,D,B,S)\\ \text{s.t.}6ND& \le C_{\text{main}},\\ \text{memory}(N,B,S)& \le \text{GPU memory},\\ \text{time}(N,D,B,S)& \le \text{training time}.\end{array}}}$$

其中：

• $N$：模型参数量；
• $D$：训练 token 总量；
• $B$：全局 batch token 数；
• $S$：上下文长度；
• $C_{\text{main}}$：主训练计算预算。

三、数据工程

3.1 数据在预训练中的核心地位

3.2 数据来源与类型

3.3 数据规模规划

3.4 数据清洗流水线

3.5 数据配比与混合策略

3.6 Tokenizer

四、完整训练流程

4.1 训练循环基础

可以把一次训练迭代理解为：

$$\text{读取文本 batch}\to \text{构造输入与标签}\to \text{模型前向传播}\to \text{计算 token-level loss}\to \text{反向传播}\to \text{参数更新}$$

对于 Decoder-only 语言模型，训练目标通常是 next-token prediction：

$$p_{\theta }(x_{t+1}\mid x_1,x_2,\dots ,x_t)$$

也就是说，模型看到前面的 token，预测下一个 token。

4.1.1 Batch 读取与样本构造

文本数据首先被 tokenization

对于一段文本，tokenization 就是通过查对应的词表 $V$（词表是提前构造好的），对每个词找到对应的词表中的位置 $x_i$，从而将整段文本转换成一个整数序列：

$$x_i\in \{0,1,\dots ,V-1\}$$

Batch 构造

大模型训练时，不一定按照“句子”或“文章”作为基本单位，而是把大量语料拼接成一个很长的 token 序列。

例如我们将一个完整的训练语料拼接成一个长度 $N$ 的 token 序列：

$$[x_1,x_2,x_3,\dots ,x_N]$$

我们通常不会一次性将整个 token 序列全部输入到模型中训练，首先这对显存的要求很高，另外模型的长下文长度不支持。

大多时候，我们是将 token 序列切片为一个个固定长度的片段，记长度为 $T$，那么就总共有 $\frac{N}{T}$ 条长度为 $T$ 的序列。

由于 $\frac{N}{T}$ 通常也很多，需要分批次将这些序列输入到模型中，每个批次的大小就是 batch size，记为 $B$，那么一个 batch 的输入形状就是：

$$X\in {\mathbb{R}}^{B\times T}$$

标签右移：构造标签 $Y\in {\mathbb{R}}^{B\times T}$ ，通常是 $X$ 向右偏移一位（即预测下一个 token）

4.1.2 前向传播与 Logits

将 token ID embedding：

$$X\in {\mathbb{R}}^{B\times T}\stackrel{\text{Embedding()}}{\to }{H}^{(0)}\in {\mathbb{R}}^{B\times T\times d}$$

经过模型主体：

$$H^{(0)}\stackrel{L\text{ 个 Decoder blocks}}{\to }{H}^{(L)}\stackrel{\text{Norm}}{\to }Z\stackrel{W_{\text{vocab}}}{\to }\text{logits}\in {\mathbb{R}}^{B\times T\times V}.$$

这里不展开 Decoder-only 内部结构，比如 self-attention、causal mask、MLP、残差连接等，因为这些属于架构部分。

4.1.3 Token-level Loss

单个 token 的交叉熵损失

如果第 $b$ 条样本第 $t$ 个位置的真实下一个 token 是 $y_t^b$，那么该位置的 loss 为：

$${\ell }_t^b=-\log p_{t,y_t^b}^b$$

其中：

$$p_t^b=[p_{t,1}^b,p_{t,2}^b,\dots ,p_{t,V}^b]$$

表示模型给第 $b$ 条样本第 $t$ 个位置预测的概率分布，$p_{t,y_t^b}^b$ 就表示表示模型给真实 token 分配的概率。

单个 token 的交叉熵损失

一个 batch 中有 $B\times T$ 个预测位置，因此总 loss 通常取平均：

$$\mathcal{L}(\theta )=\frac{1}{BT}\sum _{b=1}^B\sum _{t=1}^T{\ell }_{b,t}$$

代入交叉熵形式：

$$\mathcal{L}(\theta )=-\frac{1}{BT}\sum _{b=1}^B\sum _{t=1}^T\log p_{\theta }(y_{b,t}\mid x_{b,\le t})$$

Padding token 的处理

有时候，batch 中不同文本长度不同，可能需要 padding，而 padding 位置不应该参与 loss

因此通常会引入 mask：

$$m_{b,t}=\{\begin{array}{ll}1,& \text{该位置是真实 token}\\ 0,& \text{该位置是 padding}\end{array}$$

loss 改为：

$$\mathcal{L}(\theta )=-\frac{\sum _{b=1}^B\sum _{t=1}^T{m}_{b,t}\log p_{\theta }(y_{b,t}\mid x_{b,\le t})}{\sum _{b=1}^B\sum _{t=1}^T{m}_{b,t}}$$

也就是说，只对真实 token 求平均，不让 padding 影响训练。

在很多大规模预训练场景中，数据会被拼接和截断成固定长度，所以 padding 可能较少；但在微调、对话数据训练或变长样本训练中，padding mask 很常见。

4.1.4 反向传播与梯度

最基础的梯度下降更新为：

$${\theta }_{k+1}={\theta }_k-\eta {\mathrm{\nabla }}_{\theta }\mathcal{L}({\theta }_k)$$

其中：

• $k$：第 $k$ 次参数更新；
• $\eta$：学习率；
• ${\mathrm{\nabla }}_{\theta }\mathcal{L}({\theta }_k)$：当前 batch 上计算得到的梯度。

梯度指向 loss 上升最快的方向，所以要沿着负梯度方向更新。

一次前向传播可以抽象为：

$$X\to H\to O\to \mathcal{L}$$

其中：

• $X$：输入 token；
• $H$：hidden states；
• $O$：logits；
• $\mathcal{L}$：loss。

反向传播使用链式法则：

$$\frac{\partial \mathcal{L}}{\partial \theta }=\frac{\partial \mathcal{L}}{\partial O}\frac{\partial O}{\partial H}\frac{\partial H}{\partial \theta }$$

现代深度学习框架会自动构建计算图，框架会自动沿着计算图从 loss 反向传播到每一层参数。

4.1.5 梯度累积与梯度裁剪

1. 梯度累积

为什么需要梯度累积？

大模型训练中，为了训练稳定，我们往往需要较大的 Global Batch Size（如 256、512 甚至更大）。但受限于 GPU 显存，单卡一次能塞进去的 Micro Batch Size 可能只有 4 或 8。

梯度累积的核心思想是：用多次小 batch 的前向/反向传播，模拟一次大 batch 的效果。

原理

假设 Global Batch Size = 32，单卡最多放 Micro Batch Size = 8，那么累积步数 $k=32/8=4$。

具体流程：

• 取第 1 个 micro batch，前向传播，计算 loss，反向传播得到梯度 ${\mathrm{\nabla }}_1$
• 取第 2 个 micro batch，前向传播，计算 loss，反向传播得到梯度 ${\mathrm{\nabla }}_2$
• 取第 3 个 micro batch，前向传播，计算 loss，反向传播得到梯度 ${\mathrm{\nabla }}_3$
• 取第 4 个 micro batch，前向传播，计算 loss，反向传播得到梯度 ${\mathrm{\nabla }}_4$
• 将 4 次梯度求平均：

$$\overline{\mathrm{\nabla }}=\frac{1}{4}({\mathrm{\nabla }}_1+{\mathrm{\nabla }}_2+{\mathrm{\nabla }}_3+{\mathrm{\nabla }}_4)$$

• 用 $\overline{\mathrm{\nabla }}$ 更新参数

1. PyTorch 中 loss.backward() 默认将梯度累加到 param.grad 上而非覆盖。
2. 标准训练中，我们在每次 backward() 前调用 optimizer.zero_grad() 清零梯度，因此每次 param.grad 只保留当前 batch 的梯度。
3. 而梯度累积正是利用这一累加机制，故意在 k*k* 次 backward() 之间不调用 zero_grad()，使多次梯度在 param.grad 上叠加，最后统一更新参数。

2. 梯度裁剪

大模型训练中可能出现梯度过大，导致参数更新不稳定。

常见做法是梯度裁剪，有两种主流方法：

方法一：按范数裁剪（Gradient Clipping by Norm）

计算所有参数的梯度范数（ $g={\mathrm{\nabla }}_{\theta }\mathcal{L}$），如果超过阈值 $C$，就按比例缩小：

$$\text{if}\parallel g{\parallel }_2>C:g\leftarrow g\cdot \frac{C}{\parallel g{\parallel }_2}$$

PyTorch 中常见写法：

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

方法二：按值裁剪（Gradient Clipping by Value）

直接将每个梯度元素截断到 $[-\tau ,\tau ]$ 范围内：

$$g_i\leftarrow \text{clip}(g_i,-\tau ,\tau )=max(-\tau ,min(\tau ,g_i))$$

直觉理解：对梯度的每个分量独立地"削峰"，可能会改变梯度方向。

torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=1.0)

主流大模型（GPT、LLaMA 等）的预训练中，几乎都使用按范数裁剪，典型配置：

• 阈值 $\tau =1.0$
• 在每个 micro batch 的 backward() 之后、optimizer.step() 之前执行
• 配合梯度累积时，通常在最后一次 backward 之后统一裁剪

在 PyTorch 风格的训练循环中，一步训练通常是：

optimizer.zero_grad()

logits = model(input_ids)

loss = cross_entropy(
    logits.view(-1, vocab_size),
    labels.view(-1)
)

loss.backward()

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

optimizer.step()

4.2 优化器

4.2.1 SGD

最基础的优化器是随机梯度下降，简称 SGD。

假设第 $t$ 步参数为 ${\theta }_t$，当前 batch 上的梯度为：

$$g_t={\mathrm{\nabla }}_{\theta }\mathcal{L}({\theta }_t)$$

SGD 的更新规则是：

$${\theta }_{t+1}={\theta }_t-\eta g_t$$

为什么叫随机梯度下降？

理论上的总体目标函数是：

$$\mathcal{L}(\theta )={\mathbb{E}}_{(X,Y)\sim \mathcal{D}}[\ell (f_{\theta }(X),Y)]$$

也就是对整个数据分布求期望。

但实际训练时，我们不会每一步都用完整数据集计算梯度，因为其计算量很大，解决方法是从数据集中采样一个 mini-batch：

$${\mathcal{B}}_t=\{(X_i,Y_i){\}}_{i=1}^B\subseteq \mathcal{D}$$

然后用 mini-batch loss 近似总体 loss：

$${\hat{\mathcal{L}}}_t(\theta )=\frac{1}{B}\sum _{i=1}^B\ell (f_{\theta }(X_i),Y_i)$$

对应的梯度：

$$g_t={\mathrm{\nabla }}_{\theta }{\hat{\mathcal{L}}}_t({\theta }_t),\mathbb{E}(g_t)={\mathrm{\nabla }}_{\theta }{\mathcal{L}}_t({\theta }_t)$$

是总体梯度无偏估计。"无偏"意味着平均来看方向是对的，但每一次具体采样都会有随机波动——这就是"随机"二字的来源

SGD 的问题

SGD 简单，但在大模型训练中通常不够稳定。

主要问题有三个：

问题	含义
梯度噪声大	每个 batch 只是总体梯度的近似
不同参数尺度不同	有些参数梯度大，有些参数梯度小
收敛路径震荡	在高曲率方向容易来回摆动

所以现代大模型训练通常不直接使用普通 SGD，而是使用带动量或自适应学习率的优化器。

4.2.2 Momentum

Momentum 的思想是：

不要只看当前 batch 的梯度，还要参考过去若干步的平均方向。

定义速度变量 $v_t$：

$$v_t=\beta v_{t-1}+(1-\beta )g_t$$

其中：

• $g_t$：当前梯度；
• $v_t$：梯度的指数滑动平均；
• $\beta \in [0,1)$：动量系数，常见取值如 $0.9$。

参数更新为：

$${\theta }_{t+1}={\theta }_t-\eta v_t$$

可以把 Momentum 理解为：

$$\text{当前更新方向}=\text{当前梯度}+\text{历史梯度惯性}$$

$v_t$ 展开后为：

$$v_t=(1-\beta )g_t+(1-\beta )\beta g_{t-1}+(1-\beta ){\beta }^2{g}_{t-2}+\cdots$$

也就是历史梯度的加权平均，越近的梯度权重越大。

SGD 的问题	Momentum 的改善
batch 梯度噪声大	历史平均可以降低噪声
路径震荡	高频震荡方向会被抵消
有效方向前进慢	一致方向会被加速

4.2.3 Adam

Adam（Adaptive Moment Estimation） 可以看作结合了两类信息：

1. 一阶矩估计：梯度的滑动平均，类似 Momentum；
2. 二阶矩估计：梯度平方的滑动平均，用来调整每个参数的步长。

设当前梯度为：

$$g_t={\mathrm{\nabla }}_{\theta }\mathcal{L}({\theta }_t)$$

Adam 维护一阶矩（梯度方向的平均）：

$$m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$$

其中：

• $m_t$：梯度的一阶指数滑动平均；
• ${\beta }_1$：一阶矩衰减系数，常见取值 (0.9)。

Adam 还维护二阶矩：梯度平方的平均：

$$v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$$

其中：

• $v_t$：梯度平方的指数滑动平均；
• ${\beta }_2$：二阶矩衰减系数，常见取值 $0.999$；
• $g_t^2$ 是逐元素平方

如果某个参数长期梯度很大，那么对应的 $v_{t,i}$ 会变大。

Adam 更新时会用 $\sqrt{v_{t,i}}$ 去缩放梯度：

$$\frac{m_{t,i}}{\sqrt{v_{t,i}}+ϵ}$$

误差修正

由于 Adam 初始化时，$m_0=0,v_0=0$，因此在训练初期，$m_t$ 和 $v_t$ 会被系统性低估：

$$\begin{array}{rl}{m}_t& ={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t\\ & =\sum _{i=1}^{t-1}{\beta }_1^{t-i}(1-{\beta }_1)g_i+(1-{\beta }_1)g_t\\ & =\sum _{i=1}^t{\beta }_1^{t-i}(1-{\beta }_1)g_i\end{array}$$

假设各步梯度 $g_i$ 独立同分布，且 $\mathbb{E}[g_i]=\mathbb{E}[g]$ （即真实梯度）：

$$\begin{array}{rl}\mathbb{E}[m_t]& =\mathbb{E}[g](1-{\beta }_1)\sum _{i=1}^t{\beta }_1^{t-i}=\mathbb{E}[g](\sum _{i=1}^t{\beta }_1^{t-i}-\sum _{i=1}^t{\beta }_1^{t+1-i})\\ & =\mathbb{E}[g](\sum _{i=0}^t{\beta }_1^{t-i}-\sum _{i=0}^{t-1}{\beta }_1^{t-i})=(1-{\beta }_1^t)\mathbb{E}[g]\end{array}$$

同理：

$$\mathbb{E}[v_t]=(1-{\beta }_2^t)\mathbb{E}[g^2]$$

为了修正这种偏差，Adam 使用：

$${\hat{m}}_t=\frac{m_t}{1-{\beta }_1^t},{\hat{v}}_t=\frac{v_t}{1-{\beta }_2^t}$$

这其实是一个无偏化操作：

$$\mathbb{E}[\widehat{m_t}]=\mathbb{E}[g],\mathbb{E}[\widehat{v_t}]=\mathbb{E}[g^2]$$

参数更新为：

$${\theta }_{t+1}={\theta }_t-\eta \frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}$$

Adam 的一轮完整更新可以写成：

$$\boxed{{\displaystyle \begin{array}{rl}{g}_t& ={\mathrm{\nabla }}_{\theta }\mathcal{L}({\theta }_t)\\ m_t& ={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t\\ v_t& ={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2\\ {\hat{m}}_t& =\frac{m_t}{1-{\beta }_1^t}\\ {\hat{v}}_t& =\frac{v_t}{1-{\beta }_2^t}\\ {\theta }_{t+1}& ={\theta }_t-\eta \frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}\end{array}}}$$

Adam 的直观解释：

$$\text{更新方向}=\frac{\text{梯度的一阶滑动平均}}{\text{梯度尺度的滑动估计}}$$$$\text{方向由 }{m}_t\text{ 决定，尺度由 }{v}_t\text{ 调整}$$

4.2.4 AdamW

现代大语言模型训练中，更常用的是 AdamW，而不是原始 Adam。

AdamW 的关键改动是：

把 weight decay 从梯度更新中解耦出来。

权重衰减

权重衰减的目标是限制参数规模，防止参数无限变大。

常见形式是在目标函数中加入 $L_2$ 正则项：

$${\mathcal{L}}_{\text{reg}}(\theta )=\mathcal{L}(\theta )+\frac{\lambda }{2}\parallel \theta {\parallel }_2^2$$

对它求梯度：

$${\mathrm{\nabla }}_{\theta }{\mathcal{L}}_{\text{reg}}(\theta )={\mathrm{\nabla }}_{\theta }\mathcal{L}(\theta )+\lambda \theta \to g_t^{\text{reg}}=g_t+\lambda {\theta }_t$$

在 SGD 中，加入 $L_2$ 正则后：

$${\theta }_{t+1}={\theta }_t-\eta (g_t+\lambda {\theta }_t)=(1-\eta \lambda ){\theta }_t-\eta g_t$$

可以看到，参数被乘上了一个衰减因子：$1-\eta \lambda$。

但是在 Adam 中，更新是：

$${\theta }_{t+1}={\theta }_t-\eta \frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}$$

如果把 $\lambda {\theta }_t$ 加进梯度里，由于 $m_t$ 和 $v_t$ 是依赖梯度的，它也会进入 $m_t$ 和 $v_t$，然后被自适应缩放。这会导致 $\lambda {\theta }_t$ 不再是一个单纯的参数衰减项，而是被 Adam 的二阶矩调整过。

AdamW 的更新方式

AdamW 将梯度更新和权重衰减分开。

先做 Adam 更新：

$${\theta }_t\to m_t,v_t$$

同时单独加入权重衰减：

$${\theta }_{t+1}={\theta }_t-\eta \frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}-\eta \lambda {\theta }_t$$

其中：

• $\lambda$：weight decay 系数；
• $(1-\eta \lambda ){\theta }_t$：直接对参数做衰减；
• Adam 部分只处理数据 loss 的梯度。

	Adam + L2	AdamW（解耦权重衰减）
正则项是否进入 $ m_t, v_t $	✅ 是	❌ 否
衰减是否被自适应学习率缩放	✅ 是（不均匀）	❌ 否（等比例）
大参数的衰减效果	偏弱	正常
小参数的衰减效果	偏强	正常

在大语言模型预训练中，常见优化器配置格式大致如下：

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=learning_rate,
    betas=(0.9, 0.95),
    eps=1e-8,
    weight_decay=0.1
)

---

4.2.5 不参与权重衰减的参数

在 AdamW 中，权重衰减表示在每次参数更新时，AdamW 会额外把参数往 0 的方向拉一小步：

$${\theta }_t\mapsto (1-{\eta }_t\lambda ){\theta }_t$$

这对很多权重矩阵是有益的，但并不是所有参数都应该参与 weight decay。

weight decay 的本质是限制参数规模：

$$\parallel \theta {\parallel }_2$$

它适合用于普通权重矩阵，例如：

$$W_Q,W_K,W_V,W_O,W_{\text{MLP}}$$

这些参数通常具有较高维度，并且控制模型的主要表示能力。适当约束它们的范数，可以起到正则化作用。

但是某些参数的功能不是“学习复杂映射”，而是控制尺度、平移或特殊结构。对这些参数做 weight decay，可能会破坏它们的作用。

通常不参与 weight decay 的参数：

参数类型	是否 weight decay	原因
bias 参数	否	偏置项只负责平移，不适合用范数约束
LayerNorm / RMSNorm 权重	否	归一化层参数控制尺度，衰减会干扰归一化效果
BatchNorm 参数	否	类似归一化尺度参数，通常不衰减
embedding 特殊参数	视情况	有些实现会衰减，有些不会
普通 Linear 权重矩阵	是	主要学习映射关系，适合正则化

在大语言模型中，最常见的规则是：

$$\begin{gathered} \text{decay: Linear weights} \\ \text{no decay: bias + norm weights} \end{gathered}$$

---

4.2.6 优化器状态的显存开销

在大模型训练中，显存不只被模型参数占用。

训练时显存主要来自：

$$\text{参数}+\text{梯度}+\text{优化器状态}+\text{激活值}+\text{临时计算缓存}$$

其中，AdamW 的优化器状态非常占显存。

现代大模型训练通常使用 FP16 或 BF16 做前向和反向。FP16/BF16 每个数占 $2\text{ bytes}$，但为了训练稳定，优化器状态通常仍然用 FP32 保存。

一种常见估算是：

对象	精度	显存
模型参数	BF16 / FP16	(2N) bytes
梯度	BF16 / FP16	(2N) bytes
FP32 master weights	FP32	(4N) bytes
Adam 一阶矩 (m)	FP32	(4N) bytes
Adam 二阶矩 (v)	FP32	(4N) bytes

合计 $16N\text{ bytes}$。这说明在不包括激活值和临时计算缓存的情况下，优化器状态（含 master weights）占总量的 75%（$\frac{12N}{16N}$）。

为降低 AdamW 的优化器状态显存，常见方法包括：

方法	核心思想
ZeRO Stage 1	切分 optimizer states
ZeRO Stage 2	进一步切分 gradients
ZeRO Stage 3	切分 parameters、gradients、optimizer states
optimizer offload	把优化器状态放到 CPU 或 NVMe
8-bit optimizer	用低精度保存优化器状态
Adafactor	减少二阶矩存储

具体方法后面再研究。

4.3 学习率调度

在训练语言模型时，学习率 learning rate, LR 通常不是固定不变的，而是会随着训练步数动态调整。

学习率调度，就是设计一个函数：

$${\eta }_t=f(t)$$

使得学习率随着训练过程合理变化。

• 训练初期：学习率太大容易不稳定

• 训练后期：学习率太大不利于收敛

---

4.3.1 Learning Rate Warmup

1. Warmup 是什么？

Learning Rate Warmup 指的是：在训练初期，不直接使用较大的学习率，而是让学习率从一个很小的值逐步增加到目标最大值。

设 warmup 步数为 $T_{\text{warmup}}$，最大学习率为 ${\eta }_{max}$，则线性 warmup 可以写成：

$${\eta }_t={\eta }_{max}\cdot \frac{t}{T_{\text{warmup}}},0\le t\le T_{\text{warmup}}$$

2. 为什么需要 Warmup？

训练刚开始时，模型参数通常是随机初始化的。此时：

$${\theta }_0\sim \text{Random Initialization}$$

模型输出非常不稳定，loss 也通常较大。对应的梯度可能存在较强波动：

$$\parallel {\mathrm{\nabla }}_{\theta }\mathcal{L}({\theta }_0)\parallel$$

如果一开始就使用较大的学习率，参数更新可能过大，从而引起训练不稳定。Warmup 的作用是让模型在训练初期先进行较温和的更新。

---

4.3.2 Constant、Linear 与 Cosine Decay

Warmup 结束后，学习率通常进入 decay 阶段。常见策略包括：

1. Constant Learning Rate
2. Linear Decay
3. Cosine Decay

1. Constant Learning Rate

Constant 学习率指训练过程中学习率保持不变：

$${\eta }_t=\eta$$

如果带 warmup，则通常是：

$${\eta }_t=\{\begin{array}{ll}{\eta }_{max}\cdot \frac{t}{T_{\text{warmup}}},& t\le T_{\text{warmup}}\\ {\eta }_{max},& t>T_{\text{warmup}}\end{array}$$

2. Linear Decay

Linear Decay 指学习率在 warmup 后从最大值线性下降到最小值。

设总训练步数为 $T$，warmup 步数为 $T_{\text{warmup}}$，最小学习率为 ${\eta }_{min}$，则整体形式为：

$${\eta }_t=\{\begin{array}{ll}{\eta }_{max}\cdot \frac{t}{T_{\text{warmup}}},& 0\le t\le T_{\text{warmup}}\\ {\eta }_{max}-({\eta }_{max}-{\eta }_{min})\cdot \frac{t-T_{\text{warmup}}}{T-T_{\text{warmup}}},& T_{\text{warmup}}<t\le T\end{array}$$

先大步搜索，再小步收敛

3. Cosine Decay

Cosine Decay 指 warmup 后学习率按照余弦曲线下降：

$${\eta }_t={\eta }_{max}-\frac{1}{2}({\eta }_{max}-{\eta }_{min})[1+\cos (\pi \cdot \frac{t-T_{\text{warmup}}}{T-T_{\text{warmup}}})]$$

整体形式为：

$${\eta }_t=\{\begin{array}{ll}{\eta }_{max}\cdot \frac{t}{T_{\text{warmup}}},& 0\le t\le T_{\text{warmup}}\\ {\eta }_t={\eta }_{max}-\frac{1}{2}({\eta }_{max}-{\eta }_{min})[1+\cos (\pi \cdot \frac{t-T_{\text{warmup}}}{T-T_{\text{warmup}}})],& T_{\text{warmup}}<t\le T\end{array}$$

4. Constant、Linear、Cosine 对比

策略	公式特点	优点	缺点	适用场景
Constant	${\eta }_t=\eta$	简单，调试方便	后期可能震荡	小实验、调试
Linear Decay	线性下降	稳定、简单	后期可能过早变小	BERT 类训练、常规微调
Cosine Decay	余弦下降	平滑、常用、后期稳定	多一个调度超参数	大模型预训练、视觉模型训练

---

代码理解：

from transformers import get_scheduler

scheduler = get_scheduler(
    optimizer = optimizer,
    name = 'cosine',
    num_warmup_steps = 1000,
    num_training_steps = 10000,
    lr_min_ratio = 1e-2
)

for step, batch in enumerate(dataloader):
    loss = model(batch).loss
    loss.backward()
    optimizer.step()
    scheduler.step()
    optimizer.zero_grad()

4.3.3 Peak Learning Rate 与 Minimum Learning Rate

Peak LR：最大学习率 ${\eta }_{max}$；

Minimum LR：最小学习率 ${\eta }_{min}$。

Peak LR 与 Batch Size 的关系

一般来说，batch size 越大，可以使用的 peak LR 往往越大。

因为大 batch 下梯度估计更稳定，当 batch size $B$ 增大时，梯度方差减小：

$$\begin{array}{rl}{g}_t& =\frac{1}{B}\sum _{i=1}^B{\mathrm{\nabla }}_{\theta }{\ell }_i({\theta }_t)\\ \mathrm{Var}(g_t)& =\frac{1}{B^2}\mathrm{Var}(\sum _{i=1}^B{\mathrm{\nabla }}_{\theta }{\ell }_i({\theta }_t))=\frac{1}{B}\mathrm{Var}({\mathrm{\nabla }}_{\theta }{\ell }_i({\theta }_t))\end{array}$$

因此可以承受更大的学习率。但这不是无限成立。过大的 batch 和学习率仍可能损害泛化或导致训练不稳定。

Peak LR 与 Minimum LR 的整体关系

在大模型训练中，minimum LR 常常设置为 peak LR 的一个比例，例如：

$${\eta }_{min}=0.1{\eta }_{max}$$

也有些训练直接让学习率衰减到 0。

---

4.3.4 大模型实践中的经验设置

预训练：linear warmup + cosine decay（$0\to {\eta }_{max}\to {\eta }_{min}$）

• 初期稳定，中期强学习，后期收敛

微调：linear warmup + linear decay，或 constant with warmup

• 步数少，peak LR 远小于预训练（${\eta }_{max}^{\text{ft}}\ll {\eta }_{max}^{\text{pt}}$），防止破坏已有表示

---

4.4 Batch

4.4.1 Micro Batch、Global Batch 与梯度累积

在大模型训练中，Batch Size 不是一个单一概念。实际训练时至少要区分三个量：

$$B_{\text{micro}},B_{\text{global}},A$$

其中：

名称	含义
Micro Batch Size	单张 GPU 一次前向/反向真正处理的样本数
Gradient Accumulation Steps	梯度累积步数
Global Batch Size	一次参数更新实际等价使用的总样本数

1. Micro Batch Size

Micro Batch Size 是指每张 GPU 在一次 forward/backward 中处理的样本数。

假设一张 GPU 一次只能放下：

$$B_{\text{micro}}=4$$

那么每次前向传播时，这张 GPU 只处理 4 条样本。

2. Gradient Accumulation

显存有限时，不能直接把很大的 Batch 放进 GPU，于是可以用 梯度累积 模拟大 Batch。

普通训练是：

$${\theta }_{t+1}={\theta }_t-\eta {\mathrm{\nabla }}_{\theta }{\mathcal{L}}_B({\theta }_t)$$

其中一次 forward/backward 后立刻更新参数。

梯度累积的做法是：将一个大 Batch 分小批次，连续做多次 forward/backward，但暂时不更新参数，而是把梯度加起来。

假设累积 $A$ 次，每个 micro batch 的 loss 为：

$${\mathcal{L}}^{(a)}(\theta )\to g^{(a)}={\mathrm{\nabla }}_{\theta }{\mathcal{L}}^{(a)}(\theta ),a=1,\dots ,A$$

累积后的梯度为：

$$g=\frac{1}{A}\sum _{a=1}^A{g}^{(a)}$$

然后再进行参数更新：

$${\theta }_{t+1}={\theta }_t-\eta g$$

梯度累积的伪代码可以理解为：

optimizer.zero_grad()

for step, batch in enumerate(dataloader):
    loss = model(batch)
    loss = loss / accumulation_steps
    loss.backward()

    if (step + 1) % accumulation_steps == 0:
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad()

3. Global Batch Size

Global Batch Size 是指一次 optimizer step 实际使用的总 batch size。

$$B_{\text{global}}=B_{\text{micro}}\times N_{\text{gpu}}\times A$$

• GPU 数量为 $N_{\text{gpu}}$；
• 每张 GPU 的 micro batch size 为 $B_{\text{micro}}$；
• 梯度累积步数为 $A$。

---

4.4.2 Batch Size 与梯度噪声

假设 N 是全量训练数据总量，在大模型训练中这个数据量一般很大，实际训练不会每一步都用全部数据，而是采样一个 mini-batch（其实就是上面介绍的 Global Batch Size：$B=B_{\text{micro}}\times N_{\text{gpu}}\times A$）:

$$\mathcal{B}=\{i_1,i_2,\dots ,i_B\}$$

于是 mini-batch 梯度为：

$$g_B(\theta )=\frac{1}{B}\sum _{i\in \mathcal{B}}\mathrm{\nabla }{\ell }_i(\theta )$$

它是完整梯度的随机无偏估计 $\mathbb{E}[g_B(\theta )]=\mathrm{\nabla }\mathcal{L}(\theta )$

如果假设单样本梯度的方差为：

$$\mathrm{Var}(\mathrm{\nabla }{\ell }_i(\theta ))={\sigma }^2$$

那么 mini-batch 平均梯度的方差近似为：

$$\mathrm{Var}(g_B)=\frac{{\sigma }^2}{B}$$

即，Batch Size 越大，梯度噪声越小。大 batch 看似梯度更平稳，但有一个隐含代价：

$$\text{steps per epoch}=\frac{N}{B}\downarrow$$

同样遍历一遍数据，参数更新次数变少了。相当于模型"看"了同样多的数据，但"学"的次数变少了。

• 小 Batch 靠噪声探索，但梯度不稳定且并行效率低；

• 大 Batch 靠稳定加速，但参数更新次数少可能导致收敛变慢，因此常配合更大的学习率。

---

4.4.3 Critical Batch Size

当 batch size 小于某个范围时，增大 batch size 可以明显提升吞吐和稳定性。

但超过某个临界值后，继续增大 batch size 的收益下降：

$$B>B_{\text{critical}}$$

此时：

• 梯度噪声已经很小，现有的梯度已经在很大程度上代表真实的优化方向，如果再增加每个 Batch 的样本，只是重复已有的信息；
• 相应的需要调大学习率，过大的 LR scaling 可能导致训练不稳定；
• 现在的大模型预训练通常是大规模的分布式训练，增大 Batch 会提高显存的需求，分布式训练的通信开销随规模非线性增长，代价很大。

---

4.5 训练的监控与 Checkpoint 管理

大模型预训练通常持续数天甚至数周，训练成本很高，因此不能只关注最终 loss。完整训练系统还需要解决两个问题：

1. 如何判断训练是否正常；
2. 如何在训练中断后准确恢复训练状态。

4.5.1 监控指标

一个典型训练监控面板可能包含：

指标	主要作用
Train Loss	判断模型是否持续学习
Validation Loss	判断泛化性能
Learning Rate	检查学习率调度
Gradient Norm	检测梯度爆炸/异常
Tokens/s	衡量训练吞吐
Step Time	检测训练速度异常
GPU Utilization	判断计算资源利用率
GPU Memory	监测 OOM 风险
NaN/Inf	检测数值稳定性问题

现代大模型训练非常关注 $\text{tokens/sec}$：

$$\text{Throughput}=\frac{B_{\mathrm{global}}\times L}{T_{\mathrm{step}}}$$

• $B_{\mathrm{global}}$：global batch size；

• $L$：sequence length；

• $T_{\mathrm{step}}$：一个 optimizer step 的耗时

如果 loss 正常，但 throughput 突然下降，则可能不是模型问题，而是：

• DataLoader 速度下降；
• 网络通信瓶颈；
• GPU 等待数据；
• Checkpoint 保存阻塞；
• 集群节点异常；
• 数据 Shuffle 或 I/O 出现瓶颈。

---

4.5.2 Checkpoint 管理

若在模型训练的过程中，我们通过监控指标发现有训练不稳定的情况，如果问题严重，我们就需要暂停训练，排查问题并及时修改。完成之后我们要如何恢复训练呢？这时就需要 Checkpoint。

Checkpoint 可以理解为：

训练过程在某一个时间点的完整快照。

最简单的 checkpoint 只有模型参数 ${\theta }_t$，但这通常不足以真正恢复训练。

一个完整 checkpoint 通常至少包含：

$$C_t=\{{\theta }_t,O_t,S_t,t,R_t,M_t\}.$$

• ${\theta }_t$：模型参数；
• $O_t$：optimizer state；
• $S_t$：scheduler state；
• $t$：当前 global step；
• $R_t$：随机数状态；
• $M_t$：其他训练元数据。

$$\boxed{{\displaystyle \text{Model}+\text{Optimizer}+\text{Scheduler}+\text{Step}+\text{RNG}+\text{Data State}}}$$

五、分布式训练与工程优化

5.1 分布式训练的核心动因

5.2 基础并行策略

5.3 混合精度训练

5.4 显存优化

5.5 主流训练框架

5.6 大规模训练工程实践

六、评估（验证与反馈闭环）

6.1预训练阶段在线评估

6.2 基准测试

6.3 生成质量评估

6.4 评估的反馈作用