AI-A0-0186​

优化算法

注意力计算

一种IO感知的精确注意力算法，通过分块和重计算减少内存访问，提高计算效率。

Flash Attention​

1. 目标：​ 计算注意力输出 O=softmax(QKT)V，同时减少高带宽内存（HBM）与片上内存（SRAM）之间的数据传输。
2. 分块：​ 将 Q,K,V分成块，在SRAM中逐块计算，避免将整个 QKT矩阵存入HBM。
3. 在线softmax：​ 使用在线softmax算法，逐块更新softmax分母和分子，无需存储整个注意力矩阵。
4. 重计算：​ 在反向传播时，从存储的 Q,K,V和输出 O重新计算注意力矩阵，而不是存储中间矩阵，以节省内存。

优点：​ 大幅减少内存访问， 加速注意力计算， 支持长序列。
复杂度：​ 计算复杂度仍为 O(L2d)， 但内存访问复杂度从 O(L2)降为 O(L)。

算法优化， 内存层次。 利用GPU内存层次，通过分块和重计算优化注意力计算的内存效率。

场景：​ 训练和推理大模型， 尤其是长序列场景。
特征：​ 分块计算， 在线softmax， 重计算， 内存高效。

Q,K,V：​ 查询、键、值矩阵，形状 (L,d)。
块大小：​ Bc​（键/值块大小），Br​（查询块大小），根据SRAM大小设置。
O：​ 输出矩阵，形状 (L,d)。
l：​ softmax分母向量，形状 (L)。
m：​ 每行的最大值向量，形状 (L)。

分块矩阵乘法：​ QKT分块计算。
在线softmax：​ 逐块更新 m和 l。
重计算：​ 反向传播时重新计算 S=QKT。

描述为“将注意力计算分块进行，在片上内存中逐块计算注意力分数和输出，并使用在线softmax避免存储整个注意力矩阵，从而减少内存访问”。

**1. 初始化输出 O=0，softmax分母 l=0，最大值 m=−∞。
2. 将 K,V分成 Tc​块，每块大小 Bc​；将 Q分成 Tr​块，每块大小 Br​。
3. 对于每个查询块 i：
a. 加载查询块 Qi​到SRAM。
b. 初始化块输出 Oi​=0，块分母 li​=0，块最大值 mi​=−∞。
c. 对于每个键值块 j：
i. 加载键块 Kj​和值块 Vj​到SRAM。
ii. 计算块注意力分数 Sij​=Qi​KjT​。
iii. 更新 mi​=max(mi​,rowmax(Sij​))，li​=li​⋅emiold​−mi​+rowsum(eSij​−mi​)。
iv. 更新 Oi​=Oi​⋅emiold​−mi​+eSij​−mi​Vj​。
d. 将 Oi​写回HBM。
4. 最终输出 O，分母 l用于反向传播。

“分块流”：​ 查询流 Q被分成小块流 Qi​，键值流 K,V被分成小块流 Kj​,Vj​。注意力计算流在SRAM中进行：对于每个 Qi​，依次与所有 Kj​,Vj​块流交互，通过在线softmax流逐步更新输出流 Oi​。这种流避免了将整个 QKT矩阵流经HBM，减少了数据移动。

Flash Attention 利用GPU的共享内存（SRAM）进行块计算，减少全局内存（HBM）访问。在多GPU中，序列可以分区，每个GPU计算本地注意力，但需要全局通信来聚合结果（如模型并行）。Flash Attention 可以结合模型并行使用。

注意力机制， 在线softmax， 内存优化。

AI-A0-0187​

位置编码

序列建模

一种线性偏置方法，在注意力分数中添加一个与相对距离成比例的偏置，无需学习的位置嵌入。

ALiBi (Attention with Linear Biases)​

1. 偏置项：​ 在注意力分数 Sij​=qiT​kj​上添加一个与相对距离 j−i成比例的负偏置：$\tilde{S}{ij} = S{ij} - m \cdot

j-i

，其中m是头特定的斜率。<br>∗∗2.斜率设置：∗∗对于头h（从0开始计数），m_h = 2^{-8h/H}，其中H是总头数。<br>∗∗3.注意力计算：∗∗\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T - m \cdot D}{\sqrt{d_k}}\right) V，其中D_{ij} =

j-i

（对于自回归解码器，j > i时D_{ij} = \infty$ 或大数，以掩码未来位置）。

优点：​ 无需位置嵌入， 外推性好， 在长序列上表现优异。
偏置：​ 线性偏置， 越远的token惩罚越大。

位置编码， 相对位置。 通过添加与相对距离成比例的线性偏置来注入位置信息。

场景：​ 自回归语言模型， 如GPT-like模型， 尤其擅长外推到更长序列。
特征：​ 无位置嵌入， 线性偏置， 头特定斜率。

qi​,kj​：​ 查询和键向量。
m：​ 斜率，头特定，mh​=2−8h/H。
Dij​：​ 相对距离，$

j-i

。<br>∗∗H：∗∗总头数。<br>∗∗h$：**​ 头索引（0-based）。

AI-A0-0188​

归一化技术

层归一化

层归一化的变体，仅对输入进行缩放，不进行平移，且使用RMS（均方根）进行归一化。

RMSNorm (Root Mean Square Layer Normalization)​

1. 计算RMS：​ 对于输入 x∈Rd，RMS(x)=d1​∑i=1d​xi2​​。
2. 归一化：​ x^i​=RMS(x)+ϵxi​​，其中 ϵ是小常数。
3. 缩放：​ yi​=gi​x^i​，其中 g∈Rd是可学习的缩放参数。
4. 整体：​ RMSNorm(x)=RMS(x)x​⊙g。

特点：​ 去除了均值中心化， 仅使用RMS进行缩放， 计算更简单， 在有些模型中表现与LayerNorm相当。
与LayerNorm区别：​ 不减均值， 无偏置参数 β。

归一化， 缩放。 使用均方根进行归一化，仅学习缩放参数，简化计算。

场景：​ LLaMA、T5等模型， 作为LayerNorm的替代。
特征：​ 无均值减法， 可学习缩放， 计算高效。

x：​ 输入向量，维度 d。
RMS(x)：​ 均方根，d1​∑i​xi2​​。
ϵ：​ 小常数，防止除零。
g：​ 可学习的缩放参数，维度 d。

均方根：​ 平方和的平均再开方。
缩放：​ 逐元素乘以 g。

描述为“计算输入向量的均方根，然后用它来缩放输入，最后乘以可学习的缩放参数”。

1. 计算 RMS=d1​∑i=1d​xi2​+ϵ​。
2. 计算 x^=x/RMS。
3. 输出 y=g⊙x^，其中 ⊙是逐元素乘法。​

“RMS缩放”流：​ 输入流 x首先计算其均方根流 RMS(x)，该流衡量了输入的总体幅度。然后，输入流被 RMS(x)缩放，得到一个单位RMS的流 x^。最后，通过可学习的缩放参数流 g对每个维度进行重新缩放，恢复模型的表达能力。与LayerNorm相比，它省略了减去均值的步骤，假设零均值已由前一层的偏置项处理。

RMSNorm计算比LayerNorm少一步均值计算，因此略高效。同样可并行计算。在多GPU中，每个样本独立计算RMS，然后进行缩放。

LayerNorm， 归一化。

AI-A0-0189​

激活函数

激活函数

一种门控激活函数，结合了Swish（SiLU）和GLU（Gated Linear Unit）的思想。

SwiGLU​

1. 定义：​ SwiGLU(x,W,V,b,c)=Swish(xW+b)⊙(xV+c)，其中 Swish(x)=xσ(x)，σ是sigmoid函数，⊙是逐元素乘法。
2. 简化：​ 通常 W和 V是线性变换，将输入 x投影到更高维度。
3. 在FFN中：​ FFNSwiGLU​(x)=(Swish(xW1​)⊙(xV1​))W2​，其中 W1​,V1​将 x投影到 dff​，W2​投影回 dmodel​。

优点：​ 比ReLU或GELU表现更好， 在PaLM等大模型中采用。
参数量：​ 由于有两个投影矩阵 W1​和 V1​，参数量是标准FFN的 2/3倍（如果 W1​和 V1​输出维度相同）。

激活函数， 门控机制。 通过Swish激活的门控线性单元，增强非线性表达能力。

场景：​ Transformer的FFN层， 替代标准ReLU/GELU FFN。
特征：​ 门控， Swish激活， 两个线性变换。

x：​ 输入，形状 (L,dmodel​)。
W1​,V1​：​ 权重矩阵，形状 (dmodel​,dff​)。
b,c：​ 偏置（可选）。
W2​：​ 权重矩阵，形状 (dff​,dmodel​)。
σ：​ sigmoid函数。
⊙：​ 逐元素乘法。

门控：​ 逐元素乘法。
Swish：​ xσ(x)。
线性变换：​ 两个并行投影。

描述为“对输入进行两个不同的线性变换，其中一个变换的结果经过Swish激活，然后与另一个变换的结果逐元素相乘，最后再经过一个线性变换”。

1. 计算 A=Swish(xW1​+b)=(xW1​+b)σ(xW1​+b)。
2. 计算 B=xV1​+c。
3. 计算 H=A⊙B。
4. 计算输出 y=HW2​。​

“双路门控”流：​ 输入流 x被复制为两路。一路流经线性变换 W1​和Swish激活，产生门控信号流 A。另一路流经线性变换 V1​，产生值流 B。两路流通过逐元素乘法融合，其中Swish激活的门控信号 A调制值流 B。融合后的流 H再经过线性变换 W2​输出。这种门控机制允许模型选择性地传递信息。

SwiGLU FFN比标准FFN多一个线性投影（V1​），因此计算量和参数量更大。计算可以并行：xW1​和 xV1​可以同时计算。在多GPU中，线性变换可以按模型并行方式分割。

FFN， GELU， GLU。

AI-A0-0190​

训练技巧

梯度处理

在多个小批量上累积梯度，然后一次性更新参数，模拟大批量训练。

梯度累积 (Gradient Accumulation)​

1. 过程：​ 对于 N个连续的小批量（micro-batch），每次前向传播后计算梯度，但不立即更新参数，而是将梯度累加到累积变量中。
2. 更新：​ 每累积 N个小批量后，用累积梯度除以 N（可选，用于平均）更新参数，然后清零累积梯度。
3. 数学：​ 设第 i个小批量的梯度为 gi​，累积梯度 G=∑i=1N​gi​。更新参数 θ=θ−α⋅NG​（如果取平均）。

目的：​ 在内存有限时模拟大批量训练， 稳定训练， 允许使用更大的有效批量大小。
N：​ 累积步数， 如4、8、16。

优化技巧， 内存效率。 通过多次前向-反向传播累积梯度，实现更大的有效批量大小。

场景：​ 当GPU内存不足以容纳大批量时， 训练大模型。
特征：​ 梯度累加， 延迟更新， 模拟大批量。

gi​：​ 第 i个小批量的梯度。
G：​ 累积梯度。
N：​ 累积步数。
α：​ 学习率。
θ：​ 模型参数。

累加：​ G=∑i=1N​gi​。
平均：​ 可选除以 N。

描述为“在多个小批量上重复前向和反向传播，累积梯度但不更新参数，累积一定步数后，用累积梯度（或平均梯度）更新一次参数”。

1. 初始化累积梯度 G=0，计数器 count=0。
2. 对于每个小批量 xi​：
a. 前向传播计算损失 Li​。
b. 反向传播计算梯度 gi​。
c. 累积梯度 G=G+gi​。
d. count=count+1。
e. 如果 count==N：
i. 更新参数 θ=θ−α⋅(G/N)（或直接使用 G）。
ii. 重置 G=0,count=0。
3. 重复直到训练完成。​

“梯度缓冲”流：​ 在标准训练中，梯度流 gi​产生后立即用于更新参数流 θ。在梯度累积中，梯度流被暂时存储到累积缓冲区 G中。经过 N个小批量，N个梯度流汇合成一个累积梯度流 G。然后这个累积流被用于更新参数流，模拟了一个批量大小为 N×micro-batch size的更新。这允许在有限内存下使用更大的有效批量。

梯度累积在单个GPU或数据并行中均可使用。每个GPU独立计算本地梯度并累积。在数据并行中，如果使用梯度平均，需要在累积 N步后对所有GPU的累积梯度进行AllReduce，然后更新参数。

批量大小， 优化器。

AI-A0-0191​

训练技巧

混合精度

使用半精度（FP16）进行前向和反向传播，同时保留单精度（FP32）主权重副本用于更新，以加速训练并减少内存占用。

混合精度训练 (Mixed Precision Training)​

1. 维护FP32主权重：​ θfp32​。
2. 前向传播：​ 将 θfp32​转换为FP16得到 θfp16​，使用 θfp16​和FP16输入进行计算，得到FP16损失。
3. 反向传播：​ 在FP16下计算梯度 gfp16​。
4. 梯度转换：​ 将 gfp16​转换为FP32得到 gfp32​。
5. 更新主权重：​ 使用 gfp32​和优化器（如Adam）更新 θfp32​：θfp32​=θfp32​−α⋅optimizer_update(gfp32​)。
6. 梯度缩放：​ 为防止梯度下溢，在反向传播前对损失乘以缩放因子 S（如1024），计算梯度后再除以 S。

优点：​ 加速计算， 减少内存占用， 保持数值稳定性。
缩放因子 S：​ 动态或静态， 如 210。

数值计算， 精度。 利用FP16加速计算，用FP32保持数值范围，通过梯度缩放防止下溢。

场景：​ 训练大型神经网络， 如Transformer， 需要加速和节省内存。
特征：​ FP16计算， FP32主权重， 梯度缩放。

θfp32​：​ FP32主权重。
θfp16​：​ FP16副本权重。
gfp16​：​ FP16梯度。
gfp32​：​ FP32梯度。
S：​ 梯度缩放因子。
α：​ 学习率。

精度转换：​ FP32 ↔ FP16。
梯度缩放：​ 损失乘以 S，梯度除以 S。

描述为“使用半精度进行前向和反向传播以加速计算并节省内存，同时保留单精度主权重副本用于更新，并通过梯度缩放防止梯度下溢”。

1. 将FP32主权重 θfp32​复制为FP16权重 θfp16​。
2. 前向传播：使用 θfp16​和FP16输入计算损失 Lfp16​。
3. 梯度缩放：计算缩放损失 Lscaled​=S⋅Lfp16​。
4. 反向传播：计算 Lscaled​对 θfp16​的梯度 gfp16​。
5. 梯度反缩放：gfp16​=gfp16​/S。
6. 将梯度转换为FP32：gfp32​=float32(gfp16​)。
7. 使用 gfp32​更新FP32主权重 θfp32​。
8. 重复。​

“精度混合流”：​ 权重流 θ以FP32格式存储（主权重流）。在前向流中，权重流被转换为FP16流 θfp16​，与FP16输入流进行运算，产生FP16激活流和损失流。损失流被缩放因子 S放大，以保留梯度信息。反向流计算FP16梯度流 gfp16​，然后反缩放并转换为FP32梯度流 gfp32​，最后用于更新FP32主权重流。这种流在计算密集型部分使用FP16加速，在权重更新时使用FP32保持精度。

混合精度训练需要GPU支持FP16计算（如Tensor Cores）。在数据并行中，每个GPU进行本地FP16前向/反向传播，梯度在FP32下进行AllReduce。梯度缩放可以动态调整（如根据梯度范数）。

FP16， 梯度缩放， 数值稳定性。

AI-A0-0192​

训练技巧

内存优化

在训练中只保存部分中间激活值，在反向传播时重新计算其他激活，以节省内存。

激活检查点 (Activation Checkpointing)​

1. 前向传播：​ 将模型分成若干段（checkpoint segments）。在前向传播时，只保存每段的输入和输出（检查点），不保存中间激活值。
2. 反向传播：​ 当计算梯度时，从最近的检查点开始重新运行前向传播以计算该段所需的中间激活值，然后计算梯度并释放这些激活值。
3. 权衡：​ 用计算时间换取内存节省。

节省内存：​ 内存占用从 O(L)降低到 O(L​)或 O(logL)， 其中 L是层数。
计算开销：​ 增加约30%的前向计算。

内存-计算权衡。 通过重计算中间激活来减少内存占用。

场景：​ 训练极深模型， 内存受限时。
特征：​ 分段检查点， 重计算激活， 时间换空间。

模型分段：​ 将模型分为 k段。
检查点：​ 每段的输入和输出。
中间激活：​ 前向传播中的中间结果，通常不保存。

重计算：​ 从检查点重新运行前向传播。
内存节省：​ 与分段数 k有关。

描述为“将模型分成若干段，在前向传播时只保存每段的输入和输出作为检查点，在反向传播时根据需要从检查点重新计算中间激活，从而节省内存”。

1. 将模型划分为 k个段：[segment1​,segment2​,...,segmentk​]。
2. 前向传播：
a. 对于每个段 i，输入 xi​（来自上一段的输出或初始输入）。
b. 计算段输出 yi​=segmenti​(xi​)。
c. 保存检查点 (xi​,yi​)，丢弃段内中间激活。
3. 反向传播（从最后一段开始）：
a. 对于段 i从 k到 1：
i. 从检查点加载 xi​和 yi​。
ii. 重新运行段 i的前向传播，保存中间激活。
iii. 使用中间激活计算段 i的梯度。
iv. 将梯度传播到段 i−1的输入。
v. 丢弃中间激活。​

“检查点-重计算”流：​ 前向流经过模型分段，每段的输入流 xi​和输出流 yi​被保存为检查点流，而段内的中间激活流被丢弃。在反向流中，从最后一段开始，加载检查点流 xi​和 yi​，重新执行该段的前向流以生成中间激活流，然后计算梯度流。梯度流传播后，中间激活流被释放。这种流以额外的计算流为代价，减少了内存中需要同时保存的激活流数量。

激活检查点可以在单个GPU上实施，也可以与数据并行结合。在模型并行中，检查点可以设置在设备边界。重计算会增加计算时间，但允许训练更大的模型或更大的批量。

重计算， 内存优化， 梯度检查点。

AI-A0-0193​

并行策略

模型并行

将模型的不同层放置在不同的设备上，按层顺序执行，每层计算完成后将激活传递给下一层。

流水线并行 (Pipeline Parallelism)​

1. 模型划分：​ 将模型的 L层划分为 p个阶段（stage），每个阶段包含连续的若干层，放置在不同的设备上。
2. 微批量：​ 将每个训练批量划分为 m个微批量（micro-batch）。
3. 流水线调度：​ 使用如GPipe的调度：首先依次向流水线注入所有微批量（前向传播），然后依次进行反向传播。
4. 气泡：​ 流水线中存在设备空闲时间（气泡），通过增加微批量数量减少气泡比例。

目标：​ 将模型分布到多个设备， 解决单个设备内存不足问题。
气泡开销：​ 与阶段数 p和微批量数 m有关， 气泡比例约为 mp−1​。

模型并行， 流水线。 将模型按层划分到多个设备，通过流水线执行提高设备利用率。

场景：​ 模型过大无法放入单个设备内存时。
特征：​ 层划分， 微批量， 流水线调度， 气泡。

p：​ 流水线阶段数。
m：​ 微批量数量。
L：​ 总层数。
阶段划分：​ 每个阶段包含 L/p层。
气泡：​ 设备空闲时间。

流水线：​ 多个微批量重叠执行。
气泡：​ 启动和排空流水线的时间。

描述为“将模型按层划分到多个设备上，将每个批量分成多个微批量，以流水线方式执行微批量的前向和反向传播，从而重叠不同设备上的计算”。

1. 前向传播（以GPipe为例）：
a. 设备1计算微批量1的前向，将激活发送给设备2。
b. 设备1计算微批量2的前向，同时设备2计算微批量1的前向，以此类推。
2. 反向传播：
a. 最后阶段计算微批量1的梯度，将梯度发送给前一阶段。
b. 最后阶段计算微批量2的梯度，同时前一阶段计算微批量1的梯度，以此类推。
3. 参数更新：所有微批量完成后，更新参数。​

“流水线流”：​ 数据流被分割为微批量流。这些微批量流依次进入流水线。每个设备（阶段）处理其对应的层流。当一个微批量流完成一个阶段后，其激活流被发送到下一个阶段，同时该阶段可以处理下一个微批量流。这样，多个微批量流在流水线中重叠流动，提高了设备利用率。然而，在流水线开始和结束时，会有气泡（空闲时间），因为并非所有阶段都同时工作。

流水线并行需要设备间通信传递激活和梯度。通信发生在相邻阶段之间。气泡开销可以通过增加微批量数量来减少。通常与数据并行结合，形成混合并行。

模型并行， 数据并行， 张量并行。

AI-A0-0194​

并行策略

模型并行

将模型的单个层内的参数和计算分割到多个设备上，通常按维度分割矩阵乘法。

张量并行 (Tensor Parallelism)​

1. 列并行：​ 将权重矩阵 W按列分割，W=[W1​,W2​]，输入 x广播，y=xW=x[W1​,W2​]=[xW1​,xW2​]，每个设备计算一部分，结果拼接。
2. 行并行：​ 将权重矩阵 W按行分割，W=[W1​;W2​]，输入 x按列分割 x=[x1​,x2​]，y=xW=[x1​,x2​][W1​;W2​]=x1​W1​+x2​W2​，每个设备计算部分和，然后求和。
3. 组合：​ 如Megatron-LM中，将FFN和注意力层的矩阵乘法按列或行分割。

目标：​ 将单个层的计算分布到多个设备， 减少每个设备的内存和计算负载。
通信：​ 需要设备间通信（如All-Reduce）来聚合结果。

模型并行， 矩阵分割。 将矩阵乘法按行或列分割到多个设备，通过通信组合结果。

场景：​ 单个层过大无法放入单个设备内存时， 如大型FFN层或注意力层。
特征：​ 矩阵分割， 按维度并行， 需要通信。

W：​ 权重矩阵，形状 (m,n)。
x：​ 输入向量或矩阵。
设备数：​ p。
分割维度：​ 按行或按列。

列分割：​ W按列分割，x广播，输出拼接。
行分割：​ W按行分割，x按列分割，输出求和。

描述为“将权重矩阵按行或列分割到多个设备上，每个设备计算部分结果，然后通过通信（如拼接或求和）得到完整输出”。

以列并行为例：
1. 将权重矩阵 W按列分割为 W1​,W2​,...,Wp​，每个设备存储一部分。
2. 输入 x广播到所有设备。
3. 每个设备计算 yi​=xWi​。
4. 通过All-Gather通信将所有 yi​拼接成完整输出 y=[y1​,y2​,...,yp​]。
以行并行为例：
1. 将权重矩阵 W按行分割为 W1​,W2​,...,Wp​，每个设备存储一部分。
2. 将输入 x按列分割为 x1​,x2​,...,xp​，每个设备获得一部分。
3. 每个设备计算 zi​=xi​Wi​。
4. 通过All-Reduce求和得到完整输出 y=∑i​zi​。​

“张量分割流”：​ 权重流 W被分割成多个子流 Wi​分布在不同设备上。输入流 x被广播或分割到各设备。每个设备独立计算局部流 yi​=xWi​或 zi​=xi​Wi​。然后通过通信流（All-Gather或All-Reduce）将局部流聚合成全局流 y。这种流将单个层的计算负载分散到多个设备，但引入了通信开销。

张量并行需要设备间通信，通信量较大。通常用于单个层非常大的情况，如Transformer的FFN层（dff​很大）。在多头注意力中，可以将不同头分布到不同设备上。

模型并行， 流水线并行， Megatron-LM。

AI-A0-0195​

并行策略

模型并行

将模型的不同层放置在不同的设备上，每层计算在单个设备上完成，层间通过设备间通信传递激活和梯度。

模型并行 (Model Parallelism)​

1. 垂直划分：​ 将模型按层划分，不同层放置在不同设备上。
2. 执行：​ 前向传播时，设备 i计算其拥有的层，将输出发送给设备 i+1；反向传播时，设备 i+1将梯度发送给设备 i。
3. 通信：​ 相邻设备间传递激活和梯度。
4. 与流水线并行的区别：​ 纯模型并行通常一次处理一个样本，没有微批量和流水线调度。

目标：​ 将模型分布到多个设备， 解决内存不足问题。
缺点：​ 设备利用率低， 因为大多数时间只有一个设备在计算。

模型并行， 层划分。 将模型的不同层放置在不同设备上，串行执行。

场景：​ 模型过大无法放入单个设备内存， 且层数较多时。
特征：​ 层划分， 串行执行， 设备间传递激活。

L：​ 总层数。
p：​ 设备数。
划分：​ 每台设备分配 L/p层。
激活：​ 层间传递的中间结果。

串行：​ 一次只有一个设备在计算。
通信：​ 相邻设备间点对点通信。

描述为“将模型的不同层放置在不同的设备上，前向传播时数据从一个设备流向下一个设备，每层计算完成后将激活传递给下一层，反向传播时梯度反向传递”。

1. 前向传播：
a. 设备1计算层1，输出激活 a1​，发送给设备2。
b. 设备2接收 a1​，计算层2，输出 a2​，发送给设备3。
c. 如此继续直到最后设备输出损失。
2. 反向传播：
a. 最后设备计算损失梯度，反向传播到其拥有的层，得到梯度并发送给前一设备。
b. 前一设备接收梯度，继续反向传播，如此继续直到设备1。
3. 参数更新：每个设备更新其拥有的参数。​

“层间流”：​ 数据流依次流经每个设备上的层流。每个设备上的层流处理完后，激活流被发送到下一个设备。反向传播时，梯度流反向流动。这种流是纯串行的，因此设备利用率低，大部分设备处于空闲状态。

模型并行（纯层并行）通信量相对较小（仅层间传递激活和梯度），但设备利用率低。通常与数据并行结合，形成混合并行。

流水线并行， 张量并行。

AI-A0-0196​

优化算法

内存优化

一种优化器状态分区技术，将优化器状态、梯度和参数分区到多个设备上，以节省内存。

ZeRO (Zero Redundancy Optimizer)​

1. ZeRO-DP：​ 数据并行，但将优化器状态、梯度和参数分区到多个GPU上，每个GPU只存储一部分。
2. ZeRO-1：​ 仅分区优化器状态，每个GPU存储全部参数和梯度，但只存储一部分优化器状态（如Adam的动量、方差）。
3. ZeRO-2：​ 分区优化器状态和梯度，每个GPU存储全部参数，但只存储一部分梯度和优化器状态。
4. ZeRO-3：​ 分区优化器状态、梯度和参数，每个GPU只存储一部分参数、梯度和优化器状态，需要时从其他GPU获取。

目标：​ 减少数据并行中的内存冗余， 允许训练更大模型。
通信：​ ZeRO-3 需要在前向/反向传播时收集参数， 增加通信开销。

数据并行， 内存优化。 通过分区优化器状态、梯度和参数，消除数据并行中的内存冗余。

场景：​ 训练极大模型， 如万亿参数模型， 内存受限。
特征：​ 状态分区， 通信换内存， 可扩展性。

N：​ GPU数量。
优化器状态：​ 如Adam的 m（一阶矩）和 v（二阶矩）。
分区：​ 将状态、梯度、参数按维度分割到 N个GPU上。

分区：​ 将张量沿某个维度分割。
收集：​ 需要时通过All-Gather收集完整张量。

描述为“在数据并行中，将优化器状态、梯度和参数分区到多个GPU上，每个GPU只负责更新和存储其中一部分，从而大幅减少每个GPU的内存占用”。

以ZeRO-3为例：
1. 参数分区：模型参数 W被分区到 N个GPU上，每个GPU存储 Wi​。
2. 前向传播：需要完整参数时，通过All-Gather从所有GPU收集 W，计算后释放其他GPU的参数。
3. 反向传播：同样通过All-Gather收集参数计算梯度，梯度被分区存储。
4. 优化器更新：每个GPU更新其负责的参数分区 Wi​，以及对应的梯度分区和优化器状态分区。​

“分区流”：​ 参数流 W被分割成多个子流 Wi​分布在不同GPU上。在前向流中，通过All-Gather通信流将 Wi​聚合成完整参数流 W用于计算，然后释放非本地部分。梯度流同样被分区存储。优化器状态流

AI-A0-0198​

优化算法

优化器

一种自适应学习率优化算法，为每个参数维护一个学习率，该学习率与历史梯度平方和的平方根成反比。

Adagrad (Adaptive Gradient Algorithm)​

1. 初始化：​ 累积梯度平方和 G=0。
2. 更新：​ 对于每个参数 θi​，计算梯度 gt,i​=∇θi​​L(θt​)。
3. 累积平方：​ Gt,i​=Gt−1,i​+gt,i2​。
4. 参数更新：​ θt+1,i​=θt,i​−Gt,i​+ϵ​α​⋅gt,i​，其中 α是全局学习率，ϵ是小常数（如1e-8）。

特点：​ 自适应学习率， 稀疏梯度效果好， 但学习率可能单调下降至过小。
适用：​ 稀疏数据， 如自然语言处理。

自适应学习率， 梯度平方累积。 为每个参数自适应调整学习率，梯度大的参数学习率小，梯度小的参数学习率大。

场景：​ 处理稀疏特征的模型， 如词嵌入训练。
特征：​ 参数独立学习率， 累积平方梯度， 学习率递减。

θi​：​ 第 i个参数。
gt,i​：​ 第 t步时参数 θi​的梯度。
Gt,i​：​ 到第 t步为止参数 θi​的梯度平方累积和。
α：​ 全局学习率。
ϵ：​ 小常数，防止除零。

累积和：​ Gt,i​=∑τ=1t​gτ,i2​。
学习率：​ α/Gt,i​+ϵ​。

描述为“为每个参数维护一个梯度平方的累积和，并用其平方根的倒数来缩放学习率”。

1. 初始化参数 θ，初始化累积变量 G=0。
2. 对于每个训练步 t：
a. 计算梯度 gt​=∇θ​L(θt​)。
b. 累积平方梯度 G=G+gt2​（逐元素）。
c. 更新参数 θt+1​=θt​−α⋅gt​/(G​+ϵ)。
3. 重复直到收敛。​

“自适应衰减”流：​ 每个参数 θi​的梯度流 gt,i​被平方后累积到历史流 Gt,i​中。更新流中，学习率 α被 Gt,i​​缩放。梯度大的参数，Gt,i​增长快，学习率迅速下降；梯度小的参数，学习率下降慢。这导致学习率单调递减，可能过早停止学习。

Adagrad需要为每个参数维护累积变量 G，内存开销与参数数量成正比。在数据并行中，每个GPU计算本地梯度，但累积平方梯度需要在所有GPU上同步？实际上，Adagrad的累积是基于每个参数独立的历史，在数据并行中，每个GPU有完整的模型副本和累积变量，梯度聚合后，每个GPU用相同的聚合梯度更新自己的累积变量，因此不需要额外同步累积变量。

RMSProp， Adam， 自适应学习率。

AI-A0-0199​

优化算法

优化器

Adagrad的改进，使用指数移动平均代替累积和，解决学习率递减问题。

RMSProp (Root Mean Square Propagation)​

1. 初始化：​ 移动平均 E[g2]0​=0。
2. 更新：​ 计算梯度 gt​。
3. 更新移动平均：​ E[g2]t​=βE[g2]t−1​+(1−β)gt2​，其中 β是衰减率（如0.9）。
4. 参数更新：​ θt+1​=θt​−E[g2]t​+ϵ​α​⋅gt​。

特点：​ 自适应学习率， 解决Adagrad学习率单调下降问题， 适用于非平稳目标。
衰减率 β：​ 通常0.9。

自适应学习率， 指数移动平均。 使用梯度平方的指数移动平均来调整学习率，避免累积和无限增长。

场景：​ 深度学习， 尤其是循环神经网络。
特征：​ 指数移动平均， 自适应学习率， 非单调。

θ：​ 参数。
gt​：​ 当前梯度。
E[g2]t​：​ 梯度平方的指数移动平均。
β：​ 衰减率。
α：​ 学习率。
ϵ：​ 小常数。

指数移动平均：​ E[g2]t​=βE[g2]t−1​+(1−β)gt2​。
学习率：​ α/E[g2]t​+ϵ​。

描述为“维护梯度平方的指数移动平均，并用其平方根的倒数来缩放学习率”。

1. 初始化参数 θ，初始化 E[g2]=0。
2. 对于每个训练步 t：
a. 计算梯度 gt​=∇θ​L(θt​)。
b. 更新移动平均 E[g2]t​=βE[g2]t−1​+(1−β)gt2​。
c. 更新参数 θt+1​=θt​−α⋅gt​/(E[g2]t​​+ϵ)。
3. 重复直到收敛。​

“指数平滑自适应”流：​ RMSProp引入衰减率 β，使得梯度平方的历史流 E[g2]t​是指数移动平均，而不是累积和。这给旧梯度赋予衰减权重，使得 E[g2]t​不会无限增长，学习率不会单调递减至零，能够适应非平稳的优化环境。

类似Adagrad，需要为每个参数维护移动平均状态 E[g2]。在数据并行中，每个GPU独立更新自己的状态，但梯度聚合后，所有GPU使用相同的梯度更新，因此状态保持一致。

Adagrad， Adam， 自适应学习率。

AI-A0-0200​

优化算法

优化器

结合动量法和RMSProp，同时使用梯度的一阶矩和二阶矩估计。

Adam (Adaptive Moment Estimation)​

1. 初始化：​ 一阶矩 m0​=0，二阶矩 v0​=0，时间步 t=0。
2. 计算梯度：​ gt​=∇θ​L(θt−1​)。
3. 更新一阶矩：​ mt​=β1​mt−1​+(1−β1​)gt​。
4. 更新二阶矩：​ vt​=β2​vt−1​+(1−β2​)gt2​。
5. 偏差校正：​ m^t​=mt​/(1−β1t​), v^t​=vt​/(1−β2t​)。
6. 参数更新：​ θt​=θt−1​−αv^t​​+ϵm^t​​。

优点：​ 自适应学习率， 动量， 偏差校正， 鲁棒性好。
超参数：​ β1​=0.9, β2​=0.999, ϵ=1e−8。

自适应优化， 动量， 二阶矩。 结合动量法和RMSProp，并引入偏差校正。

场景：​ 深度学习广泛使用， 尤其是Transformer。
特征：​ 一阶矩（动量）， 二阶矩（自适应学习率）， 偏差校正。

θ：​ 参数。
gt​：​ 梯度。
mt​,vt​：​ 一阶和二阶矩估计。
β1​,β2​：​ 衰减率。
α：​ 学习率。
ϵ：​ 小常数。
t：​ 时间步。

指数移动平均：​ 一阶和二阶矩。
偏差校正：​ 除以 1−βt。
逐元素更新：​ 每个参数有自己的学习率。

描述为“维护梯度的一阶矩（动量）和二阶矩（梯度平方）的指数移动平均，进行偏差校正后，用校正后的矩更新参数”。

1. 初始化 m=0,v=0,t=0。
2. 对于每个训练步：
a. t=t+1
b. 计算梯度 gt​
c. mt​=β1​mt−1​+(1−β1​)gt​
d. vt​=β2​vt−1​+(1−β2​)gt2​
e. m^t​=mt​/(1−β1t​)
f. v^t​=vt​/(1−β2t​)
g. θt​=θt−1​−αm^t​/(v^t​​+ϵ)
3. 重复直到收敛。​

“自适应动量”流：​ Adam将动量流（一阶矩）和自适应学习率流（二阶矩）结合。动量流 mt​提供平滑的梯度方向，自适应流 vt​根据梯度幅度调整每个参数的学习率。偏差校正流消除初始零偏置。更新流中，m^t​提供方向，v^t​提供缩放，实现高效优化。

Adam需要为每个参数维护两个状态 m和 v。在数据并行中，梯度聚合后，每个GPU用相同的梯度更新本地状态，因此状态保持一致。在模型并行中，参数和状态分布在多个GPU上，更新需要通信或本地进行。

AdamW， RMSProp， 动量法。

AI-A0-0201​

优化算法

优化器

Adam的变体，将权重衰减与参数更新解耦，直接添加到更新步骤中。

AdamW​

1. 计算梯度：​ gt​=∇θ​L(θt−1​)（不包含权重衰减项）。
2. 更新一阶矩和二阶矩：​ 同Adam：mt​=β1​mt−1​+(1−β1​)gt​, vt​=β2​vt−1​+(1−β2​)gt2​。
3. 偏差校正：​ m^t​=mt​/(1−β1t​), v^t​=vt​/(1−β2t​)。
4. 参数更新：​ θt​=θt−1​−α(v^t​​+ϵm^t​​+λθt−1​)，其中 λ是权重衰减系数。

优点：​ 权重衰减与自适应学习率解耦， 通常比Adam泛化更好。
解耦：​ 权重衰减项 λθ直接加到更新中。

自适应优化， 权重衰减。 将权重衰减从损失函数中分离，直接应用于参数更新，避免与自适应学习率耦合。

场景：​ 训练大型模型如Transformer， 需要权重衰减正则化。
特征：​ 解耦权重衰减， 更新公式包含显式权重衰减项。

θ：​ 参数。
λ：​ 权重衰减系数。
其他同Adam。​

加法项：​ 更新中直接加 λθ。
解耦：​ 权重衰减独立于梯度计算。

描述为“在Adam更新公式中，额外添加一个权重衰减项，直接作用于参数，而不是通过损失函数”。

1. 计算梯度 gt​（不包含权重衰减）。
2. 更新一阶矩 mt​和二阶矩 vt​同Adam。
3. 计算校正后矩 m^t​,v^t​。
4. 更新参数：θt​=θt−1​−α(v^t​​+ϵm^t​​+λθt−1​)。​

“解耦正则化”流：​ 在AdamW中，权重衰减流 λθ直接与自适应更新流 αm^t​/(v^t​​+ϵ)相加。这与传统Adam（权重衰减通过损失函数影响梯度）不同，避免了权重衰减与自适应学习率之间的耦合，使得正则化效果更稳定，模型泛化更好。

与Adam类似，但更新步骤中多了一项权重衰减。权重衰减项可以本地计算，无需额外通信。在多GPU数据并行中，每个GPU独立计算权重衰减项并更新本地参数副本。

Adam， 权重衰减， L2正则化。

AI-A0-0202​

优化算法

学习率调度

学习率在训练过程中按余弦函数从初始值衰减到最小值。

余弦退火 (Cosine Annealing)​

1. 学习率公式：​ ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(Tmax​Tcur​​π))，其中 Tcur​是当前步数，Tmax​是总步数（或周期长度）。
2. 变化：​ 学习率从 ηmax​开始，按余弦函数平滑下降到 ηmin​。

特点：​ 平滑下降， 避免学习率突变， 有助于模型收敛到更优解。
超参数：​ ηmax​, ηmin​, Tmax​。

学习率调度， 余弦函数。 使用余弦函数平滑调整学习率。

场景：​ 深度学习训练， 如图像分类、自然语言处理。
特征：​ 余弦曲线， 平滑衰减， 可周期性重启。

ηt​：​ 当前学习率。
ηmax​：​ 最大学习率。
ηmin​：​ 最小学习率。
Tcur​：​ 当前步数。
Tmax​：​ 总步数或周期长度。

余弦函数：​ cos(πTcur​/Tmax​)。
线性变换：​ 映射到 [ηmin​,ηmax​]。

描述为“学习率按余弦函数从最大值平滑衰减到最小值”。

1. 设置最大学习率 ηmax​、最小学习率 ηmin​、总步数 Tmax​。
2. 对于每个训练步 t（Tcur​=t）：
a. 计算学习率 ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(πt/Tmax​))。
b. 使用 ηt​更新参数。
3. 当 t=Tmax​时，可停止或重启（带热重启）。​

“余弦衰减”流：​ 学习率流 ηt​随时间 t按余弦曲线从 ηmax​平滑下降到 ηmin​。这种平滑下降避免了阶梯式下降的突变，允许模型在初期以较大学习率快速收敛，后期以较小学习率精细调整，有助于找到更平坦的最小值。

学习率调度器在训练循环中每一步更新学习率。在多GPU训练中，通常由主进程计算学习率并广播，或每个进程独立计算相同值。

带热重启的余弦退火， 学习率调度。

AI-A0-0203​

优化算法

学习率调度

学习率在指定步数或epoch处乘以一个衰减因子。

步长衰减 (Step Decay)​

1. 定义：​ 学习率在预定义的步数或epoch处衰减。例如，每 s步将学习率乘以 γ（如0.1）。
2. 公式：​ ηt​=η0​⋅γ⌊t/s⌋，其中 η0​是初始学习率，s是步长，γ是衰减因子。
3. 也可基于epoch：​ 每 k个epoch衰减一次。

特点：​ 简单， 常用， 但衰减可能过于激进。
超参数：​ 初始学习率 η0​， 衰减因子 γ， 步长 s。

学习率调度， 指数衰减。 按固定步长降低学习率。

场景：​ 各种深度学习任务， 尤其是训练收敛后期。
特征：​ 阶梯式下降， 预定义衰减点。

ηt​：​ 当前学习率。
η0​：​ 初始学习率。
γ：​ 衰减因子（0<γ<1）。
s：​ 衰减步长（多少步衰减一次）。
t：​ 当前步数。

指数衰减：​ ηt​=η0​γ⌊t/s⌋。
阶梯函数：​ 每隔 s步变化。

描述为“每经过固定的步数，学习率乘以一个小于1的衰减因子，呈阶梯式下降”。

1. 设置初始学习率 η0​，衰减因子 γ，步长 s。
2. 对于每个训练步 t：
a. 计算当前衰减次数 k=⌊t/s⌋。
b. 学习率 ηt​=η0​⋅γk。
c. 使用 ηt​更新参数。
3. 重复直到训练结束。​

“阶梯下降”流：​ 学习率流 ηt​在大多数时间保持恒定，每经过 s步就突然下降为原来的 γ倍。这种离散的下降允许模型在某个学习率下稳定训练一段时间，然后进入更精细的调整阶段。

实现简单，只需在训练循环中检查当前步数是否达到衰减点。在多GPU中，学习率值需要同步。

指数衰减， 学习率调度。

AI-A0-0204​

训练技巧

权重初始化

根据输入维度调整初始化方差，保持前向传播中激活的方差不变。

Xavier初始化 (Glorot初始化)​

1. 均匀分布：​ W∼U[−nin​+nout​​6​​,nin​+nout​​6​​]，其中 nin​和 nout​是输入和输出维度。
2. 正态分布：​ W∼N(0,nin​+nout​2​)。
3. 目标：​ 保持各层激活的方差一致，避免梯度消失或爆炸。

适用：​ 使用sigmoid、tanh等饱和激活函数的网络。
原理：​ 方差守恒。

权重初始化， 方差缩放。 根据输入输出维度调整初始化范围。

场景：​ 全连接层， 卷积层（需调整维度计算）， 使用sigmoid/tanh的网络。
特征：​ 均匀或正态分布， 方差与输入输出维度和相关。

W：​ 权重矩阵，形状 (nout​,nin​)。
nin​：​ 输入维度。
nout​：​ 输出维度。

均匀分布：​ 边界由 6/(nin​+nout​)​决定。
方差：​ Var(W)=2/(nin​+nout​)。

描述为“权重从均匀或正态分布中初始化，其方差与输入和输出维度的和成反比”。

1. 计算缩放因子 scale=6/(nin​+nout​)​（均匀分布）或 std=2/(nin​+nout​)​（正态分布）。
2. 从 U[−scale,scale]或 N(0,std2)采样初始化 W。​

“方差均衡”流：​ Xavier初始化确保权重矩阵 W的初始化方差与输入维度 nin​和输出维度 nout​相关，使得前向传播中激活的方差和反向传播中梯度的方差在各层之间大致保持稳定，避免梯度消失或爆炸。

初始化在训练开始前执行一次。在多GPU上，每个GPU独立初始化相同的权重（如果使用相同随机种子），或按模型并行分区初始化。

Kaiming初始化， 权重初始化。

AI-A0-0205​

训练技巧

权重初始化

针对ReLU及其变体设计，保持前向传播中激活的方差不变。

Kaiming初始化 (He初始化)​

1. 正态分布：​ W∼N(0,nin​2​)，其中 nin​是输入维度。
2. 均匀分布：​ W∼U[−nin​​6​​,nin​​6​​]。
3. 考虑ReLU：​ 由于ReLU将一半激活置零，方差减半，因此需要加倍方差补偿。

适用：​ 使用ReLU、LeakyReLU等非饱和激活函数的网络。
原理：​ 考虑ReLU的激活稀疏性。

权重初始化， 方差缩放。 针对ReLU族激活函数调整初始化方差。

场景：​ 使用ReLU的深度神经网络， 如ResNet、Transformer（FFN中的ReLU/GELU）。
特征：​ 方差与输入维度成反比， 考虑激活函数特性。

W：​ 权重矩阵，形状 (nout​,nin​)。
nin​：​ 输入维度。
a：​ ReLU负斜率（对于LeakyReLU）。

方差：​ Var(W)=(1+a2)nin​2​，对于ReLU a=0，故为 nin​2​。

描述为“针对ReLU激活函数，权重初始化方差与输入维度成反比，并考虑激活函数的稀疏性”。

1. 确定激活函数参数 a（ReLU为0，LeakyReLU为负斜率）。
2. 计算方差 var=(1+a2)nin​2​。
3. 从 N(0,var)或 U[−3var​,3var​]采样初始化 W。​

“ReLU方差校正”流：​ Kaiming初始化考虑了ReLU激活函数会将一半的激活置零，导致方差减半。因此，初始化时将权重方差放大一倍（nin​2​对比 Xavier 的 nin​+nout​2​），以补偿这种稀疏性，确保各层激活方差稳定。

同Xavier初始化，在训练前执行。对于Transformer，FFN层的权重通常使用Kaiming初始化。

Xavier初始化， ReLU， 权重初始化。

AI-A0-0206​

训练技巧

梯度裁剪

限制梯度范数，防止梯度爆炸。

梯度裁剪 (Gradient Clipping)​

1. 计算梯度范数：​ g=∇θ​L，总梯度范数 $

g

_2 = \sqrt{\sum_i g_i^2}。<br>∗∗2.裁剪：∗∗如果

g

_2 > threshold，则g = g \cdot \frac{threshold}{

g

AI-A0-0207​

训练技巧

正则化

在训练过程中，随机将一部分神经元的输出置零，防止过拟合。

Dropout​

1. 训练阶段：​ 对于每一层，每个神经元以概率 p（dropout率）被置零，否则其输出乘以 1/(1−p)（缩放）。
2. 数学描述：​ y=x⊙m/(1−p)，其中 m∼Bernoulli(1−p)是掩码向量，⊙是逐元素乘法。
3. 测试阶段：​ 不使用dropout，所有神经元激活，但权重乘以 (1−p)（或等价地，训练时缩放，测试时不变）。

作用：​ 防止过拟合， 提高模型泛化能力， 相当于模型平均。
典型 p：​ 0.1到0.5， 输入层较低，隐藏层较高。

正则化， 模型平均。 通过随机丢弃神经元，强制网络不依赖特定神经元，提高鲁棒性。

场景：​ 全连接层， 卷积层， 注意力层（如Transformer中的dropout）。
特征：​ 随机丢弃， 训练和测试行为不同。

x：​ 输入向量或矩阵。
p：​ dropout率，神经元被丢弃的概率。
m：​ 掩码向量，元素独立服从 Bernoulli(1−p)。
y：​ 输出。

随机：​ 伯努利分布。
缩放：​ 除以 1−p以保持期望不变。

描述为“在训练时，随机将一部分神经元的输出置零，其余神经元按比例放大，以保持期望不变；测试时直接使用所有神经元”。

训练时：
1. 生成掩码 m∼Bernoulli(1−p)。
2. 计算 y=x⊙m/(1−p)。
测试时：
1. 直接使用 y=x（因为训练时已缩放）。​

“随机子网络”流：​ 在每次前向传播中，Dropout随机选择神经元子集构成一个“子网络”。信息流只能通过未被丢弃的神经元流动。这迫使网络学习冗余表示，不依赖于任何单个神经元。缩放操作确保信息流的总体强度在训练和测试间一致。

Dropout操作是逐元素乘法，可并行。掩码生成是随机的，但可以同步随机种子以确保多GPU一致性。在Transformer中，dropout常用于注意力权重和FFN激活后。

正则化， 模型平均。

AI-A0-0208​

训练技巧

正则化

在标签分布中引入噪声，将硬标签（one-hot）转换为软标签，防止模型过度自信。

标签平滑 (Label Smoothing)​

1. 硬标签：​ 对于真实类别 y，one-hot向量 q满足 qy​=1，其他为0。
2. 平滑：​ q′=(1−ϵ)q+ϵu，其中 ϵ是平滑参数（如0.1），u是均匀分布（ui​=1/K，K是类别数）。
3. 损失：​ 使用 q′作为目标计算交叉熵损失。

效果：​ 防止模型对正确类别过度自信， 提高泛化能力， 减轻过拟合。
参数 ϵ：​ 通常0.05到0.2。

正则化， 校准。 通过软化标签分布，鼓励模型保留不确定性。

场景：​ 分类任务， 尤其是大规模分类（如ImageNet）。
特征：​ 软化标签， 均匀噪声。

q：​ 原始one-hot标签向量。
ϵ：​ 平滑系数。
u：​ 均匀分布向量，ui​=1/K。
K：​ 类别总数。

凸组合：​ (1−ϵ)q+ϵu。
概率分布：​ 仍为概率分布。

描述为“将真实标签的1减去一个小量，并将这个小量均匀分配到其他类别上，得到软标签”。

1. 给定真实类别 y，创建one-hot向量 q。
2. 计算平滑标签 q′=(1−ϵ)q+ϵ⋅K1​。
3. 使用 q′作为目标计算交叉熵损失：L=−∑i​qi′​logpi​，其中 p是模型预测概率。​

“标签软化”流：​ 硬标签流（one-hot）包含绝对确定性，可能促使模型过度拟合。标签平滑将硬标签流与均匀噪声流混合，产生一个较软的标签流。这个软标签流鼓励模型对正确类别的预测概率接近 1−ϵ，同时对其他类别赋予小的概率 ϵ/K，从而保留一定程度的不确定性，提高泛化。

标签平滑在数据加载或损失计算时进行，计算简单。在多GPU数据并行中，每个GPU独立对本地数据的标签进行平滑。

交叉熵损失， 正则化。

AI-A0-0209​

模型架构

注意力机制

通过线性投影将输入序列映射为查询、键、值，然后计算注意力权重和输出。

缩放点积注意力 (Scaled Dot-Product Attention)​

1. 线性投影：​ Q=XWQ, K=XWK, V=XWV，其中 WQ,WK,WV是可学习权重矩阵。
2. 计算注意力分数：​ S=QKT/dk​​，其中 dk​是键维度。
3. 应用softmax：​ A=softmax(S)，按行归一化。
4. 加权求和：​ O=AV。

特点：​ 计算高效， 可并行， 是Transformer的核心组件。
缩放因子：​ 1/dk​​防止点积过大导致softmax梯度消失。

注意力机制， 点积。 通过点积计算相似度，缩放后归一化，加权求和值。

场景：​ Transformer的自注意力和交叉注意力。
特征：​ 点积相似度， 缩放， softmax归一化。

X：​ 输入序列，形状 (L,dmodel​)。
WQ,WK,WV：​ 投影矩阵，形状分别为 (dmodel​,dk​), (dmodel​,dk​), (dmodel​,dv​)。
Q,K,V：​ 查询、键、值矩阵，形状分别为 (L,dk​), (L,dk​), (L,dv​)。
dk​,dv​：​ 键和值维度。
O：​ 输出，形状 (L,dv​)。

点积：​ QKT。
缩放：​ 除以 dk​​。
softmax：​ 行归一化。

描述为“将输入投影为查询、键、值，计算查询和键的点积并缩放，然后通过softmax得到注意力权重，最后对值加权求和”。

1. 计算投影：Q=XWQ, K=XWK, V=XWV。
2. 计算注意力分数：S=QKT/dk​​。
3. 可选应用掩码（如因果掩码）：S=S+M。
4. 计算注意力权重：A=softmax(S)。
5. 计算输出：O=AV。​

“信息检索”流：​ 输入 X通过三个不同的线性变换流生成查询流 Q、键流 K和值流 V。查询流和键流通过点积交互，产生相似度流 S，经缩放和softmax转化为注意力权重流 A。权重流 A对值流 V进行加权求和，生成输出流 O，其中每个位置是值流的加权组合。

注意力计算可以高度并行。矩阵乘法 QKT复杂度 O(L2dk​)。在多GPU上，可以通过张量并行将注意力头分配到不同GPU，或通过序列并行将序列分块。

多头注意力， 自注意力。

AI-A0-0210​

模型架构

注意力机制

将注意力计算拆分为多个头，每个头学习不同的表示子空间，然后拼接结果。

多头注意力 (Multi-Head Attention)​

1. 线性投影到多个头：​ 对于第 i个头，Qi​=XWiQ​, Ki​=XWiK​, Vi​=XWiV​，其中 WiQ​∈Rdmodel​×dk​, WiK​∈Rdmodel​×dk​, WiV​∈Rdmodel​×dv​，且 dk​=dv​=dmodel​/h，h是头数。
2. 每个头独立计算缩放点积注意力：​ headi​=Attention(Qi​,Ki​,Vi​)。
3. 拼接所有头：​ Concat=[head1​;head2​;...;headh​]。
4. 线性投影：​ O=ConcatWO，其中 WO∈Rhdv​×dmodel​。

优点：​ 允许模型共同关注来自不同位置的不同表示子空间的信息， 增强表示能力。
头数 h：​ 通常8或16。

注意力机制， 并行化。 通过多个注意力头并行计算，融合不同子空间信息。

场景：​ Transformer的自注意力和交叉注意力。
特征：​ 多个头， 独立计算， 拼接后投影。

X：​ 输入，形状 (L,dmodel​)。
h：​ 头数。
dk​,dv​：​ 每个头的键/值维度，通常 dk​=dv​=dmodel​/h。
WiQ​,WiK​,WiV​：​ 第 i个头的投影矩阵。
WO：​ 输出投影矩阵。
O：​ 输出，形状 (L,dmodel​)。

并行：​ 多个头独立计算。
拼接：​ 沿特征维度拼接。
线性投影：​ 融合多头信息。

描述为“将输入投影到多个子空间，在每个子空间独立计算注意力，然后将所有结果拼接并投影回原始维度”。

**1. 对于每个头 i=1到 h：
a. 计算 Qi​=XWiQ​, Ki​=XWiK​, Vi​=XWiV​。
b. 计算 headi​=Attention(Qi​,Ki​,Vi​)。
2. 拼接：Concat=[head1​;head2​;...;headh​]。
3. 输出投影：$O =

AI-A0-0211​

模型架构

前馈网络

Transformer中每个位置独立应用的两层全连接网络，带激活函数。

位置式前馈网络 (Position-wise Feed-Forward Network, FFN)​

1. 第一层线性变换：​ F1​=ReLU(XW1​+b1​)，其中 W1​∈Rdmodel​×dff​，b1​∈Rdff​，dff​是中间维度（通常 dff​=4×dmodel​）。
2. 第二层线性变换：​ F2​=F1​W2​+b2​，其中 W2​∈Rdff​×dmodel​，b2​∈Rdmodel​。
3. 整体：​ FFN(X)=ReLU(XW1​+b1​)W2​+b2​。

作用：​ 对每个位置的表示进行非线性变换， 增加模型容量。
激活函数：​ 通常ReLU， 也可用GELU、Swish等。

前馈网络， 非线性变换。 每个位置独立应用相同的两层全连接网络，实现逐位置非线性变换。

场景：​ Transformer编码器和解码器层中， 位于自注意力层之后。
特征：​ 位置独立， 两层， 非线性激活。

X：​ 输入，形状 (L,dmodel​)。
W1​,b1​：​ 第一层权重和偏置。
W2​,b2​：​ 第二层权重和偏置。
dff​：​ 中间维度，通常 dff​=4dmodel​。
ReLU： 激活函数。

线性变换：​ 矩阵乘法加偏置。
非线性：​ ReLU激活。
位置独立：​ 对每个位置独立操作。

描述为“一个两层的全连接网络，对输入序列的每个位置独立进行变换，第一层进行线性变换并应用ReLU激活，第二层进行线性变换”。

1. 输入 X形状 (L,dmodel​)。
2. 计算第一层：H=ReLU(XW1​+b1​)，形状 (L,dff​)。
3. 计算第二层：Y=HW2​+b2​，形状 (L,dmodel​)。
4. 输出 Y。​

“逐位置非线性流”：​ 输入流 X的每个位置向量独立地流经第一层线性变换，被映射到高维空间（dff​），然后经过ReLU激活流引入非线性，再通过第二层线性变换流映射回原始维度 dmodel​。这个流在每个位置上是独立的，但参数共享。

FFN计算可以完全并行于序列长度 L。矩阵乘法 XW1​和 HW2​是密集计算，适合GPU加速。在多GPU数据并行中，FFN层参数在所有GPU上复制，输入 X被分割。在模型并行中，W1​和 W2​可以按行或列分割。

自注意力， 残差连接， 层归一化。

AI-A0-0212​

位置编码

序列建模

通过正弦和余弦函数为序列中每个位置生成固定编码，注入位置信息。

正弦位置编码 (Sinusoidal Positional Encoding)​

1. 定义：​ 对于位置 pos和维度 i（i为偶数或奇数），编码为：
PE(pos,2i)​=sin(pos/100002i/dmodel​)
PE(pos,2i+1)​=cos(pos/100002i/dmodel​)
其中 dmodel​是模型维度。
2. 与输入相加：​ X′=X+PE，其中 X是词嵌入，PE是位置编码矩阵。

特点：​ 固定， 非学习， 可泛化到任意长度， 但无法适应训练数据。
波长：​ 形成几何级数， 不同维度对应不同频率。

位置编码， 三角函数。 使用正弦和余弦函数生成位置编码，使模型能够感知序列中token的顺序。

场景：​ 原始Transformer， 需要位置信息的序列模型。
特征：​ 确定性函数， 可外推， 与输入相加。

pos：​ 位置索引，从0到 L−1。
i：​ 维度索引，从0到 dmodel​/2−1。
dmodel​：​ 模型维度。
PE：​ 位置编码矩阵，形状 (L,dmodel​)。

三角函数：​ sin和 cos。
频率：​ 10000−2i/dmodel​形成几何序列。

描述为“使用正弦和余弦函数为每个位置生成一个固定向量，其频率随维度增加而降低，然后与词嵌入相加”。

1. 对于每个位置 pos=0,1,...,L−1：
a. 对于每个维度 i=0,1,...,dmodel​/2−1：
i. 计算 angle=pos/100002i/dmodel​。
ii. PE(pos,2i)​=sin(angle)。
iii. PE(pos,2i+1)​=cos(angle)。
2. 将位置编码矩阵 PE与词嵌入矩阵 X相加：X′=X+PE。​

“位置信号注入”流：​ 位置编码流 PE是一个固定的、预先计算好的矩阵，其中每个位置对应一个独特的 dmodel​维向量。这个向量通过正弦和余弦函数生成，确保不同位置和不同维度有不同的模式。该流与词嵌入流 X相加，将绝对位置信息注入到输入表示中，使模型能够区分序列顺序。

位置编码可以预先计算并存储，或在前向传播时实时计算。计算涉及三角函数，但可以向量化。在多GPU中，每个GPU获得序列的一部分，需要知道其全局位置以计算或获取对应的位置编码。

学习的位置嵌入， 相对位置编码。

AI-A0-0213​

位置编码

序列建模

将位置编码作为可学习参数，随模型一起训练。

学习的位置嵌入 (Learned Positional Embedding)​

1. 定义：​ 创建一个可学习的嵌入矩阵 P∈RLmax​×dmodel​，其中 Lmax​是预设的最大序列长度。
2. 索引：​ 对于位置 pos，取其对应的行向量 P[pos]∈Rdmodel​。
3. 与输入相加：​ X′=X+P[pos]，其中 X是词嵌入。

特点：​ 可学习， 能适应训练数据， 但无法处理超过 Lmax​的序列。
Lmax​：​ 需预设， 如512、1024、2048等。

位置编码， 可学习参数。 将位置编码视为可训练的参数，通过梯度下降学习。

场景：​ BERT、GPT等模型， 序列长度固定或有限。
特征：​ 可学习， 有限长度， 与词嵌入类似。

P：​ 位置嵌入矩阵，可学习参数，形状 (Lmax​,dmodel​)。
pos：​ 位置索引，0≤pos<Lmax​。
X：​ 词嵌入，形状 (L,dmodel​)。

嵌入查找：​ 根据位置索引查找向量。
加法：​ 与词嵌入相加。

描述为“创建一个可学习的位置嵌入矩阵，每个位置对应一个向量，训练时与词嵌入相加”。

1. 初始化位置嵌入矩阵 P（随机或零）。
2. 对于输入序列长度 L（L≤Lmax​），获取位置嵌入 P[0:L]，形状 (L,dmodel​)。
3. 计算 X′=X+P[0:L]。
4. 在训练中，P通过梯度下降更新。​

“可学习位置流”：​ 位置嵌入流 P是一个可学习的参数流，其每一行对应一个绝对位置。在前向流中，根据token的位置索引，从 P中提取对应的位置向量流，然后与词嵌入流 X相加。这个流通过训练可以学习到数据中位置相关的模式，但仅限于训练中见过的位置（不超过 Lmax​）。

学习的位置嵌入作为模型参数的一部分。在数据并行中，参数 P在所有GPU上复制。在模型并行中，P可以按维度 dmodel​分割。

正弦位置编码， 相对位置编码。

AI-A0-0214​

位置编码

序列建模

通过旋转位置编码，将绝对位置信息融入注意力计算中的查询和键。

旋转位置编码 (Rotary Position Embedding, RoPE)​

1. 将位置信息融入查询和键：​ 对于位置 m的查询向量 qm​和位置 n的键向量 kn​，通过旋转矩阵 RΘ,m​和 RΘ,n​进行变换：q~​m​=RΘ,m​qm​, k~n​=RΘ,n​kn​，其中 RΘ,m​是一个旋转矩阵，Θ是预设的频率参数。
2. 旋转矩阵构造：​ 对于维度 i，旋转角度为 mθi​，其中 θi​=10000−2i/d，d是维度的一半（因为复数表示）。
3. 注意力分数：​ am,n​=Re(q~​mH​k~n​)=Re((RΘ,m​qm​)H(RΘ,n​kn​))，其中 Re表示取实部，H表示共轭转置。

优点：​ 保持相对位置关系， 可外推， 在长序列上表现好。
数学性质：​ am,n​=g(qm​,kn​,m−n)，即注意力分数只依赖于相对位置 m−n。

位置编码， 相对位置， 复数旋转。 通过旋转操作将绝对位置信息注入查询和键，使注意力分数仅依赖于相对位置。

场景：​ LLaMA、GPT-NeoX等现代大语言模型。
特征：​ 相对位置编码， 可外推， 融入注意力计算。

qm​,kn​：​ 位置 m和 n的查询和键向量，维度 d。
RΘ,m​：​ 位置 m的旋转矩阵，维度 d×d。
θi​：​ 频率，θi​=10000−2i/d，i=0,1,...,d/2−1。
d：​ 查询/键向量的维度（通常 d=dmodel​/h，h是头数）。

旋转矩阵：​ 块对角矩阵，每个块是2D旋转矩阵。
复数表示：​ 将向量视为复数，旋转即乘法。
相对性：​ 注意力分数只依赖于 m−n。

描述为“将查询和键向量视为复数，根据其位置进行旋转，使得点积注意力分数仅依赖于相对位置”。

1. 将查询 q和键 k重塑为复数形式：将每两个连续维度视为一个复数（实部和虚部）。
2. 对于每个位置 m，计算旋转角度 θm​=m⋅θi​（对每个维度对 i）。
3. 计算旋转后的查询和键：q~​m​=qm​⊙eimΘ, k~n​=kn​⊙einΘ，其中 ⊙是逐元素乘法，Θ是频率向量。
4. 计算注意力分数：am,n​=Re(q~​m​⋅k~n∗​)，其中 ∗表示共轭。​

“旋转流”：​ 查询流 qm​和键流 kn​根据其绝对位置 m和 n分别进行旋转操作流。旋转角度由预设的频率 θi​和位置决定。旋转后的查询 q~​m​和键 k~n​的点积结果只依赖于相对位置 m−n，因为旋转操作在复数乘法中表现为相位差。这使得模型能够自然地捕捉相对位置信息，并具有良好的外推性。

RoPE在计算注意力之前应用于查询和键。计算可以向量化。在多GPU中，每个GPU持有序列的一部分，需要知道其全局位置以进行旋转。旋转操作是逐元素的，可以并行计算。

相对位置编码， 注意力机制。

AI-A0-0215​

归一化技术

层归一化

层归一化的变体，仅对输入进行缩放，不进行平移，且使用RMS（均方根）进行归一化。

RMSNorm (Root Mean Square Layer Normalization)​

1. 计算RMS：​ 对于输入 x∈Rd，RMS(x)=d1​∑i=1d​xi2​​。
2. 归一化：​ x^i​=RMS(x)+ϵxi​​，其中 ϵ是小常数。
3. 缩放：​ yi​=gi​x^i​，其中 g∈Rd是可学习的缩放参数。
4. 整体：​ RMSNorm(x)=RMS(x)x​⊙g。

特点：​ 去除了均值中心化， 仅使用RMS进行缩放， 计算更简单， 在有些模型中表现与LayerNorm相当。
与LayerNorm区别：​ 不减均值， 无偏置参数 β。

归一化， 缩放。 使用均方根进行归一化，仅学习缩放参数，简化计算。

场景：​ LLaMA、T5等模型， 作为LayerNorm的替代。
特征：​ 无均值减法， 可学习缩放， 计算高效。

x：​ 输入向量，维度 d。
RMS(x)：​ 均方根，d1​∑i​xi2​​。
ϵ：​ 小常数，防止除零。
g：​ 可学习的缩放参数，维度 d。

均方根：​ 平方和的平均再开方。
缩放：​ 逐元素乘以 g。

描述为“计算输入向量的均方根，然后用它来缩放输入，最后乘以可学习的缩放参数”。

1. 计算 RMS=d1​∑i=1d​xi2​+ϵ​。
2. 计算 x^=x/RMS。
3. 输出 y=g⊙x^，其中 ⊙是逐元素乘法。​

“RMS缩放”流：​ 输入流 x首先计算其均方根流 RMS(x)，该流衡量了输入的总体幅度。然后，输入流被 RMS(x)缩放，得到一个单位RMS的流 x^。最后，通过可学习的缩放参数流 g对每个维度进行重新缩放，恢复模型的表达能力。与LayerNorm相比，它省略了减去均值的步骤，假设零均值已由前一层的偏置项处理。

RMSNorm计算比LayerNorm少一步均值计算，因此略高效。同样可并行计算。在多GPU中，每个样本独立计算RMS，然后进行缩放。

LayerNorm， 归一化。

AI-A0-0216​

激活函数

激活函数

一种门控激活函数，结合了Swish（SiLU）和GLU（Gated Linear Unit）的思想。

SwiGLU​

1. 定义：​ SwiGLU(x,W,V,b,c)=Swish(xW+b)⊙(xV+c)，其中 Swish(x)=xσ(x)，σ是sigmoid函数，⊙是逐元素乘法。
2. 简化：​ 通常 W和 V是线性变换，将输入 x投影到更高维度。
3. 在FFN中：​ FFNSwiGLU​(x)=(Swish(xW1​)⊙(xV1​))W2​，其中 W1​,V1​将 x投影到 dff​，W2​投影回 dmodel​。

优点：​ 比ReLU或GELU表现更好， 在PaLM等大模型中采用。
参数量：​ 由于有两个投影矩阵 W1​和 V1​，参数量是标准FFN的 2/3倍（如果 W1​和 V1​输出维度相同）。

激活函数， 门控机制。 通过Swish激活的门控线性单元，增强非线性表达能力。

场景：​ Transformer的FFN层， 替代标准ReLU/GELU FFN。
特征：​ 门控， Swish激活， 两个线性变换。

x：​ 输入，形状 (L,dmodel​)。
W1​,V1​：​ 权重矩阵，形状 (dmodel​,dff​)。
b,c：​ 偏置（可选）。
W2​：​ 权重矩阵，形状 (dff​,dmodel​)。
σ：​ sigmoid函数。
⊙：​ 逐元素乘法。

门控：​ 逐元素乘法。
Swish：​ xσ(x)。
线性变换：​ 两个并行投影。

描述为“对输入进行两个不同的线性变换，其中一个变换的结果经过Swish激活，然后与另一个变换的结果逐元素相乘，最后再经过一个线性变换”。

1. 计算 A=Swish(xW1​+b)=(xW1​+b)σ(xW1​+b)。
2. 计算 B=xV1​+c。
3. 计算 H=A⊙B。
4. 计算输出 y=HW2​。​

“双路门控”流：​ 输入流 x被复制为两路。一路流经线性变换 W1​和Swish激活，产生门控信号流 A。另一路流经线性变换 V1​，产生值流 B。两路流通过逐元素乘法融合，其中Swish激活的门控信号 A调制值流 B。融合后的流 H再经过线性变换 W2​输出。这种门控机制允许模型选择性地传递信息。

SwiGLU FFN比标准FFN多一个线性投影（V1​），因此计算量和参数量更大。计算可以并行：xW1​和 xV1​可以同时计算。在多GPU中，线性变换可以按模型并行方式分割。

FFN， GELU， GLU。

AI-A0-0217​

训练技巧

梯度处理

在多个小批量上累积梯度，然后一次性更新参数，模拟大批量训练。

梯度累积 (Gradient Accumulation)​

1. 过程：​ 对于 N个连续的小批量（micro-batch），每次前向传播后计算梯度，但不立即更新参数，而是将梯度累加到累积变量中。
2. 更新：​ 每累积 N个小批量后，用累积梯度除以 N（可选，用于平均）更新参数，然后清零累积梯度。
3. 数学：​ 设第 i个小批量的梯度为 gi​，累积梯度 G=∑i=1N​gi​。更新参数 θ=θ−α⋅NG​（如果取平均）。

目的：​ 在内存有限时模拟大批量训练， 稳定训练， 允许使用更大的有效批量大小。
N：​ 累积步数， 如4、8、16。

优化技巧， 内存效率。 通过多次前向-反向传播累积梯度，实现更大的有效批量大小。

场景：​ 当GPU内存不足以容纳大批量时， 训练大模型。
特征：​ 梯度累加， 延迟更新， 模拟大批量。

gi​：​ 第 i个小批量的梯度。
G：​ 累积梯度。
N：​ 累积步数。
α：​ 学习率。
θ：​ 模型参数。

累加：​ G=∑i=1N​gi​。
平均：​ 可选除以 N。

描述为“在多个小批量上重复前向和反向传播，累积梯度但不更新参数，累积一定步数后，用累积梯度（或平均梯度）更新一次参数”。

1. 初始化累积梯度 G=0，计数器 count=0。
2. 对于每个小批量 xi​：
a. 前向传播计算损失 Li​。
b. 反向传播计算梯度 gi​。
c. 累积梯度 G=G+gi​。
d. count=count+1。
e. 如果 count==N：
i. 更新参数 θ=θ−α⋅(G/N)（或直接使用 G）。
ii. 重置 G=0,count=0。
3. 重复直到训练完成。​

“梯度缓冲”流：​ 在标准训练中，梯度流 gi​产生后立即用于更新参数流 θ。在梯度累积中，梯度流被暂时存储到累积缓冲区 G中。经过 N个小批量，N个梯度流汇合成一个累积梯度流 G。然后这个累积流被用于更新参数流，模拟了一个批量大小为 N×micro-batch size的更新。这允许在有限内存下使用更大的有效批量。

梯度累积在单个GPU或数据并行中均可使用。每个GPU独立计算本地梯度并累积。在数据并行中，如果使用梯度平均，需要在累积 N步后对所有GPU的累积梯度进行AllReduce，然后更新参数。

批量大小， 优化器。

AI-A0-0218​

训练技巧

混合精度

使用半精度（FP16）进行前向和反向传播，同时保留单精度（FP32）主权重副本用于更新，以加速训练并减少内存占用。

混合精度训练 (Mixed Precision Training)​

1. 维护FP32主权重：​ θfp32​。
2. 前向传播：​ 将 θfp32​转换为FP16得到 θfp16​，使用 θfp16​和FP16输入进行计算，得到FP16损失。
3. 反向传播：​ 在FP16下计算梯度 gfp16​。
4. 梯度转换：​ 将 gfp16​转换为FP32得到 gfp32​。
5. 更新主权重：​ 使用 gfp32​和优化器（如Adam）更新 θfp32​：θfp32​=θfp32​−α⋅optimizer_update(gfp32​)。
6. 梯度缩放：​ 为防止梯度下溢，在反向传播前对损失乘以缩放因子 S（如1024），计算梯度后再除以 S。

优点：​ 加速计算， 减少内存占用， 保持数值稳定性。
缩放因子 S：​ 动态或静态， 如 210。

数值计算， 精度。 利用FP16加速计算，用FP32保持数值范围，通过梯度缩放防止下溢。

场景：​ 训练大型神经网络， 如Transformer， 需要加速和节省内存。
特征：​ FP16计算， FP32主权重， 梯度缩放。

θfp32​：​ FP32主权重。
θfp16​：​ FP16副本权重。
gfp16​：​ FP16梯度。
gfp32​：​ FP32梯度。
S：​ 梯度缩放因子。
α：​ 学习率。

类型转换：​ FP32 ↔FP16。
梯度缩放：​ 损失乘以 S，梯度除以 S。

描述为“使用半精度权重和激活进行前向和反向传播以加速，但保留单精度主权重副本用于更新，并通过梯度缩放防止小梯度下溢”。

1. 初始化FP32主权重 θfp32​。
2. 对于每个训练步：
a. 复制 θfp16​=castfp16​(θfp32​)。
b. 前向传播：使用 θfp16​和FP16输入计算损失 Lfp16​。
c. 梯度缩放：Lscaled​=Lfp16​×S。
d. 反向传播：计算梯度 gfp16​=∇θfp16​​Lscaled​。
e. 取消缩放：gfp16​=gfp16​/S。
f. 转换梯度：gfp32​=castfp32​(gfp16​)。
g. 更新主权重：使用 gfp32​和优化器更新 θfp32​。
3. 重复。​

“精度混合流”：​ 权重流 θfp32​存储在FP32中以保证精度。在前向流中，权重被转换为FP16流 θfp16​，与FP16输入流进行高速计算。损失流 Lfp16​被放大 S倍以防止梯度下溢。反向梯度流 gfp16​计算后，被缩小 S倍并转换为FP32流 gfp32​。最后，优化器使用FP32梯度流更新FP32主权重流。这样既利用了FP16的计算速度，又保持了FP32的数值稳定性。

混合精度训练需要GPU支持FP16计算（如Tensor Cores）。在数据并行中，每个GPU进行本地FP16前向/反向传播，梯度在FP32下进行AllReduce，然后更新本地FP32主权重。

FP16， BF16， 梯度缩放。

AI-A0-0219​

训练技巧

混合精度

一种半精度浮点数格式，比FP16具有更大的动态范围，更适合深度学习训练。

BFloat16 (Brain Floating Point 16)​

1. 格式：​ 1位符号位，8位指数位，7位尾数位（而FP16是1位符号，5位指数，10位尾数）。
2. 动态范围：​ 与FP32（8位指数）相同，但精度（尾数）较低。
3. 使用：​ 直接用于存储权重、激活和梯度，无需复杂的梯度缩放，因为其动态范围大，不易出现下溢/溢出。

优点：​ 动态范围大， 与FP32指数位相同， 训练更稳定， 简化混合精度训练流程。
缺点：​ 精度比FP16低（尾数位少）。

数值格式， 浮点数。 提供与FP32相同的指数范围，但使用16位存储，平衡范围和精度。

场景：​ 训练大型模型， 如Transformer， 在TPU和现代GPU上使用。
特征：​ 8位指数， 7位尾数， 大动态范围。

符号位：​ 1 bit。
指数位：​ 8 bits。
尾数位：​ 7 bits。
总位数：​ 16 bits。

指数范围：​ 与FP32相同（2−126到 2127）。
精度：​ 约2位十进制数字。

描述为“一种16位浮点数格式，具有与32位浮点数相同的指数范围，但尾数精度较低，适用于深度学习训练”。

1. 将权重、激活、梯度存储为BFloat16格式。
2. 前向传播和反向传播使用BFloat16计算。
3. 优化器状态（如动量）可能仍使用FP32，但权重更新可以使用BFloat16梯度。
4. 由于动态范围大，通常不需要梯度缩放。​

“大范围半精度”流：​ BFloat16数据流具有与FP32相同的指数范围，因此可以表示非常小和非常大的数，避免了FP16中容易出现的梯度下溢（值太小变为0）和溢出（值太大变为inf）问题。这使得BFloat16流可以直接用于训练，无需复杂的梯度缩放，简化了混合精度训练流程。计算流在BFloat16下进行，速度与FP16相当，但稳定性更好。

BFloat16得到现代AI加速器（如TPU、NVIDIA Ampere GPU）原生支持。在混合精度训练中，可以使用BFloat16代替FP16，简化流程。在多GPU中，通信可以使用BFloat16减少带宽。

FP16， FP32， 混合精度训练。

AI-A0-0220​

解码策略

文本生成

从模型输出的概率分布中随机采样下一个token，采样概率与softmax后的概率成正比。

随机采样 (Random Sampling)​

1. 模型输出：​ 给定上下文，模型输出下一个token的logits $z \in \mathbb{R}^{

V

}。<br>∗∗2.计算概率：∗∗p = \text{softmax}(z)，得到概率分布。<br>∗∗3.采样：∗∗根据概率分布p随机采样一个tokenw，即w \sim \text{Categorical}(p)。<br>∗∗4.将w$ 作为下一个token，并添加到上下文中，重复过程。

特点：​ 生成结果多样， 但可能不连贯或不合逻辑。
温度参数：​ 常与温度采样结合， 控制分布的平滑度。

采样， 概率分布。 根据模型输出的概率分布随机选择下一个token，引入随机性。

场景：​ 创造性文本生成， 如故事、诗歌， 需要多样性。
特征：​ 随机性， 基于概率。

z：​ logits向量，长度 $

V

（词汇表大小）。<br>∗∗p：∗∗概率分布，p_i = \frac{e^{z_i}}{\sum_j e^{z_j}}。<br>∗∗w$：**​ 采样的token索引。

softmax：​ 将logits转换为概率。
分类分布：​ w∼Categorical(p)。

描述为“将模型输出的logits通过softmax转换为概率分布，然后根据该分布随机采样下一个token”。

AI-A0-0221​

解码策略

文本生成

在采样前，通过温度参数调整概率分布的平滑度，控制生成的随机性。

温度采样 (Temperature Sampling)​

1. 模型输出logits z。
2. 应用温度：​ z′=z/T，其中 T>0是温度参数。
3. 计算概率：​ p=softmax(z′)。
4. 采样：​ 从 p中采样下一个token。
5. 温度的影响：**​ T=1不变；T<1使分布更尖锐（降低随机性）；T>1使分布更平滑（增加随机性）。

作用：​ 控制生成多样性， T越小生成越确定， T越大生成越随机。
典型 T：​ 0.5到1.0。

采样， 温度缩放。 通过温度参数缩放logits，改变softmax输出的概率分布形状。

场景：​ 与随机采样结合， 控制文本生成的创造性和连贯性。
特征：​ 可调温度， 影响概率分布。

z：​ logits向量。
T：​ 温度参数，标量，T>0。
z′：​ 缩放后的logits。
p：​ 温度调整后的概率分布。

缩放：​ z′=z/T。
softmax：​ pi​=ezi′​/∑j​ezj′​。

描述为“将模型输出的logits除以一个温度参数，然后再进行softmax和采样，温度参数控制分布的平滑度”。

1. 给定上下文，模型输出logits z。
2. 计算 z′=z/T。
3. 计算 p=softmax(z′)。
4. 根据 p采样下一个token。
5. 重复。​

“温度调节流”：​ logits流 z经过温度缩放流 T，产生缩放后的logits流 z′=z/T。当 T较小时，z′的数值范围相对扩大，经过softmax后，概率流 p会变得更加尖锐（高概率更高，低概率更低），采样流更倾向于高概率token，生成更确定。当 T较大时，z′数值范围缩小，概率流 p更平滑，采样流更随机，生成更多样。

温度采样在softmax之前进行简单的逐元素除法，计算轻量。在批量生成中，可以对所有样本应用相同温度，或每个样本不同。

随机采样， softmax。

AI-A0-0222​

解码策略

文本生成

从概率最高的k个token中随机采样，限制采样空间，提高生成质量。

Top-k采样​

1. 模型输出logits z，计算概率 p=softmax(z)。
2. 选择top-k：​ 找出概率最高的 k个token，将其概率重新归一化，其他token概率置零。
3. 重新归一化：​ p′={pi​/∑j∈top-k​pj​0​if i∈top-kotherwise​。
4. 采样：**​ 从 p′中采样下一个token。

优点：​ 避免从低概率token中采样， 提高生成连贯性。
超参数 k：​ 通常5到100， 根据任务调整。

采样， 截断。 将采样空间限制在概率最高的k个token内，避免低概率token。

场景：​ 文本生成， 需要平衡多样性和质量。
特征：​ 限制候选集， 重新归一化。

z：​ logits向量。
p：​ 原始概率分布。
k：​ 超参数，保留的token数量。
top-k：​ 概率最高的k个token的索引集合。
p′：​ 重新归一化后的分布。

选择：​ 取top-k个最大概率。
重新归一化：​ 使top-k概率和为1。

描述为“从模型输出的概率分布中选出概率最高的k个token，将其概率重新归一化，然后从这k个token中采样”。

1. 计算 p=softmax(z)。
2. 找到概率最大的 k个token的索引集合 topk​。
3. 将不在 topk​中的token的概率设为0。
4. 重新归一化：p′=p/∑i∈topk​​pi​（仅对 i∈topk​）。
5. 从 p′中采样下一个token。​

“截断采样流”：​ 原始概率流 p包含整个词汇表的概率。Top-k采样流首先过滤掉概率较低的token，只保留概率最高的k个token，形成截断的概率流。然后对这个截断流进行重新归一化，使得剩余token的概率和为1，产生新的分布流 p′。采样流从 p′中抽取，确保不会采样到低概率的无关token，提高了生成质量。

Top-k采样需要找到top-k个最大概率，可以通过快速选择算法或排序部分元素实现。在批量生成中，可以对每个样本独立进行。

Top-p采样， 随机采样。

AI-A0-0223​

解码策略

文本生成

从累积概率超过阈值p的最小token集合中采样，动态调整候选集大小。

Top-p采样 (Nucleus Sampling)​

1. 模型输出logits z，计算概率 p=softmax(z)。
2. 排序：**

AI-A0-0223​

解码策略

文本生成

从累积概率超过阈值p的最小token集合中采样，动态调整候选集大小。

核采样 (Top-p采样, Nucleus Sampling)​

1. 计算概率分布：​ 给定语言模型输出的logits，通过softmax得到概率分布 P(x)。
2. 排序：​ 将概率从大到小排序，得到排序后的概率 p(1)​≥p(2)​≥...≥p(V)​，对应token x(1)​,x(2)​,...,x(V)​。
3. 累积概率：​ 计算累积概率 C(k)=∑i=1k​p(i)​。
4. 选择候选集：​ 找到最小的 k使得 C(k)≥p，其中 p是阈值（如0.9）。候选集为 Vnucleus​={x(1)​,...,x(k)​}。
5. 重新归一化：​ 对候选集内的概率重新归一化：P′(x(i)​)=∑j=1k​p(j)​p(i)​​，i=1,...,k。
6. 采样：​ 从 P′中采样一个token作为输出。

优点：​ 动态调整候选集大小， 避免在概率分布平坦时采样到低概率token， 或在尖锐时过度限制。
阈值 p：​ 通常0.9~0.95。

概率采样， 动态阈值。 通过累积概率阈值动态选择候选集，平衡多样性和质量。

场景：​ 文本生成， 如故事创作、对话生成， 需要多样性和连贯性。
特征：​ 动态候选集， 重新归一化， 避免尾部token。

P(x)：​ 原始概率分布，x∈V（词表）。
p：​ 阈值，0<p≤1。
k：​ 候选集大小，满足 ∑i=1k​p(i)​≥p。
P′(x)：​ 重新归一化的概率分布。

排序：​ 概率降序排列。
累积和：​ C(k)=∑i=1k​p(i)​。
重新归一化：​ P′(x(i)​)=p(i)​/C(k)。

描述为“将概率从大到小排序，选择累积概率达到阈值p的最小token集合，然后在这个集合内重新归一化概率并采样”。

1. 输入：概率分布 P(x)，阈值 p。
2. 将概率降序排序，得到序列 p(1)​,p(2)​,...,p(V)​和对应token。
3. 初始化 C=0, k=0。
4. while C<pand k<V:
a. k=k+1
b. C=C+p(k)​
5. 候选集 S={x(1)​,...,x(k)​}。
6. 重新归一化：对于 i=1到 k，P′(x(i)​)=p(i)​/C。
7. 根据 P′采样一个token输出。​

“概率累积流”：​ 概率流 P(x)被排序为降序流 p(i)​。累积流 C(k)逐步累加，直到达到阈值 p。此时，前 k个token形成核心流（nucleus），其余token被截断。核心流内的概率被重新归一化，形成新的概率流 P′，采样流从 P′中产生输出token。

核采样在单个GPU上执行，涉及排序和累积操作，计算复杂度 O(VlogV)。在分布式生成中，每个GPU可以独立采样，但需要同步随机种子以确保一致性（如果要求）。

Top-k采样， 温度采样， 束搜索。

AI-A0-0224​

解码策略

文本生成

从概率最高的k个token中采样，候选集大小固定。

Top-k采样​

1. 计算概率分布：​ P(x)通过softmax得到。
2. 选择Top-k：​ 选择概率最高的 k个token，构成候选集 Vtop-k​。
3. 重新归一化：​ 对候选集内的概率重新归一化：P′(x)=∑x∈Vtop-k​​P(x)P(x)​，对于 x∈Vtop-k​。
4. 采样：​ 从 P′中采样一个token。

优点：​ 简单， 避免采样到低概率token。
缺点：​ k固定， 可能在某些情况下排除合理token（如果概率分布尖锐）或包含过多噪声（如果分布平坦）。
k：​ 通常5~50。

概率采样， 固定候选集。 通过固定大小的候选集限制采样范围，提高生成质量。

场景：​ 文本生成， 需要限制采样空间时。
特征：​ 固定k， 重新归一化， 简单高效。

P(x)：​ 原始概率分布。
k：​ 候选集大小，正整数。
Vtop-k​：​ 概率最高的k个token集合。
P′(x)：​ 重新归一化的概率分布。

Top-k选择：​ 选择概率最大的k个元素。
重新归一化：​ 在子集上归一化。

描述为“选择概率最高的k个token，然后在这个集合内重新归一化概率并采样”。

**1. 输入：概率分布 P(x)，参数 k。
2. 找到概率最大的k个token：$V{\text{top-k}} = \arg\max{x \in V,

S

=k} \sum{x \in S} P(x)。<br>3.计算候选集总概率：Z = \sum{x \in V{\text{top-k}}} P(x)。<br>4.重新归一化：对于每个x \in V{\text{top-k}}，P'(x) = P(x) / Z。<br>5.根据P'$ 采样一个token输出。**​

“Top-k截断流”：​ 概率流 P(x)经过排序，保留前 k个最大的概率流，其余被截断。然后对保留的概率流进行重新归一化，形成新的概率流 P′，采样流从 P′中产生输出。

AI-A0-0225​

解码策略

文本生成

通过温度参数调整概率分布的平滑度，控制生成多样性。

温度采样 (Temperature Sampling)​

1. 计算logits：​ 语言模型输出logits zi​对于每个token i。
2. 应用温度：​ zi′​=zi​/T，其中 T>0是温度参数。
3. Softmax：​ Pi​=∑j​exp(zj′​)exp(zi′​)​。
4. 采样：​ 从 Pi​中采样一个token。

温度效应：​ T=1保持原分布；T>1平滑分布（增加多样性）；T<1锐化分布（减少多样性，趋向贪婪）。
T：​ 通常0.5~1.0。

概率变换， 平滑控制。 通过温度参数控制概率分布的熵，调节生成多样性。

场景：​ 文本生成， 需要控制生成结果的随机性时。
特征：​ 温度参数， 平滑/锐化分布， 简单。

zi​：​ logits，未归一化的分数。
T：​ 温度参数，正实数。
Pi​：​ 温度调整后的概率。

缩放：​ zi′​=zi​/T。
Softmax：​ Pi​=softmax(zi′​)。

描述为“将logits除以温度参数后再进行softmax，温度越高概率分布越平滑，采样越多样；温度越低分布越尖锐，采样越确定”。

1. 输入：logits向量 z，温度 T。
2. 计算缩放logits：z′=z/T。
3. 计算概率：P=softmax(z′)。
4. 从 P中采样一个token输出。​

“温度调节流”：​ logits流 z被温度参数 T缩放，得到 z′。然后通过softmax流转换为概率流 P。温度 T作为一个控制阀：当 T大时，缩放后的 logits 流 z′差异变小，softmax 流输出更平滑的概率流，采样流更随机；当 T小时，z′差异放大，概率流更尖锐，采样流更确定。

温度采样计算简单，只需除法和softmax。在分布式生成中，每个GPU独立应用温度并采样。

核采样， Top-k采样， 贪婪解码。

AI-A0-0226​

解码策略

文本生成

在每一步选择概率最高的token，确定性解码。

贪婪解码 (Greedy Decoding)​

1. 计算概率分布：​ P(x)通过softmax得到。
2. 选择最大概率token：​ x∗=argmaxx​P(x)。
3. 输出 x∗作为当前步的生成token。​

优点：​ 简单， 快速， 确定性。
缺点：​ 容易陷入重复或局部最优， 缺乏多样性。

确定性解码， 最大似然。 每一步选择当前最可能的token，但不保证全局最优序列。

场景：​ 需要快速、确定性生成的场景， 如机器翻译、摘要。
特征：​ 确定性， 贪婪， 每一步局部最优。

P(x)：​ 概率分布。
x∗：​ 最大概率token。

argmax：​ x∗=argmaxP(x)。

描述为“每一步都选择概率最高的token作为输出”。

1. 输入：概率分布 P(x)。
2. 找到最大概率token：x∗=argmaxx​P(x)。
3. 输出 x∗。​

“贪婪选择流”：​ 概率流 P(x)直接流向argmax操作，输出最大概率token流。没有随机性，每一步都是确定性的选择。

贪婪解码只需argmax操作，计算简单。在分布式生成中，每个GPU可以独立生成，但需要同步以确保一致性（如果使用束搜索则需通信）。

束搜索， 采样方法。

AI-A0-0227​

解码策略

文本生成

维护多个候选序列（束），每一步扩展所有候选序列，保留总体概率最高的k个序列。

束搜索 (Beam Search)​

1. 初始化：​ 包含一个空序列，分数为0。
2. 迭代：​ 对于每一步 t：
a. 对于每个候选序列（束），用语言模型预测下一个token的概率分布。
b. 扩展每个序列：生成所有可能的下一token，计算新序列分数（累积对数概率）。
c. 从所有扩展序列中选择分数最高的 k个作为新的候选集。
3. 终止：​ 当达到最大长度或所有候选序列以结束符结束时，选择分数最高的序列作为输出。

优点：​ 比贪婪解码更可能找到全局最优序列。
缺点：​ 计算开销大， 内存占用高， 可能产生重复或平淡的文本。
束宽 k：​ 通常5~10。

启发式搜索， 广度优先剪枝。 维护固定大小的候选集，近似全局最优序列。

场景：​ 序列生成任务， 如机器翻译、文本摘要， 需要高质量序列。
特征：​ 束宽k， 保留多个候选， 基于累积分数选择。

k：​ 束宽，候选序列数量。
s：​ 序列分数，通常为对数概率之和：s=∑i=1t​logP(xi​∣x<i​)。
T：​ 最大生成长度。
结束符：​ 如 <eos>。

累积对数概率：​ s=∑logP。
Top-k选择：​ 每步保留分数最高的k个序列。

描述为“维护k个最有可能的候选序列，每一步扩展这些序列，然后从所有扩展序列中再选择k个分数最高的，直到生成结束”。

1. 初始化束 B=[(空序列,分数=0)]。
2. for t=1to T:
a. 初始化所有候选序列集合 C=∅。
b. for 每个序列 (seq,score)in B:
i. 如果 seq以结束符结尾，则加入 C并跳过扩展。
ii. 否则，用语言模型预测下一个token概率 P(x∣seq)。
iii. for 每个token xin 词表：
- 新序列 new_seq=seq+[x]。
- 新分数 new_score=score+logP(x∣seq)。
- 将 (new_seq,new_score)加入 C。
c. 从 C中选择分数最高的 k个序列作为新的束 B。
d. 如果 B中所有序列都以结束符结尾，则跳出循环。
3. 从 B中选择分数最高的序列作为输出。​

“束流”：​ 初始时，一个空序列流开始。每一步，每个序列流扩展为多个子流（每个token一个），形成扩展流集合。然后通过排序和选择，保留分数最高的k个流，其余被剪枝。这些流继续迭代，直到结束。束流通过并行探索多条路径，增加了找到高质量序列的可能性。

束搜索需要维护k个候选序列，每个序列需要独立进行前向传播，计算量大。在分布式生成中，每个GPU可以处理部分序列，但需要通信来同步分数和选择全局top-k。

贪婪解码， 长度惩罚， 重复惩罚。

AI-A0-0228​

解码策略

文本生成

在束搜索中引入长度归一化，避免偏向短序列。

长度惩罚 (Length Penalty)​

1. 序列分数：​ 原始分数为对数概率之和 s=∑i=1L​logP(xi​∣x<i​)。
2. 长度归一化：​ snorm​=(L+c)αs​，其中 L是序列长度，c是常数，α是惩罚因子。
3. 在束搜索中，使用 snorm​而不是 s来比较序列。​

目的：​ 纠正束搜索倾向于短序列的偏差（因为对数概率为负，越长分数越低）。
α：​ 通常0.6~1.0，α=0无惩罚，α>0惩罚长序列，α<0奖励长序列。
c：​ 通常5，平滑长度。

分数归一化， 偏差校正。 通过对数概率之和除以长度相关因子，使不同长度序列可比。

场景：​ 束搜索中， 需要公平比较不同长度序列时。
特征：​ 长度归一化， 可调参数 α。

s：​ 原始分数，对数概率之和。
L：​ 序列长度（token数）。
c：​ 常数，通常5。
α：​ 长度惩罚因子，实数。

归一化：​ snorm​=s/(L+c)α。
对数概率和：​ s=∑logP。

描述为“将序列的对数概率之和除以长度的幂次方，以消除长度偏差，使得束搜索能够公平比较不同长度的序列”。

在束搜索的每一步，当计算新序列分数时：
1. 计算原始分数 s=score+logP(x∣seq)。
2. 计算归一化分数 snorm​=s/(L+5)α，其中 L是新序列长度。
3. 使用 snorm​作为序列分数进行排序和选择。​

“长度归一化流”：​ 原始分数流 s与长度流 L结合，通过归一化函数 f(L)=(L+c)α进行缩放，得到归一化分数流 snorm​。这个流使得长序列的分数不会被过度惩罚，从而在束搜索中公平竞争。

长度惩罚在束搜索中简单应用，只需在计算分数时增加归一化步骤。在分布式束搜索中，每个GPU本地计算归一化分数，然后全局排序。

束搜索， 重复惩罚。

AI-A0-0229​

解码策略

文本生成

在生成过程中惩罚重复的n-gram，避免重复文本。

重复惩罚 (Repetition Penalty)​

1. 识别重复：​ 对于已生成的序列，检测出现的n-gram（如unigram, bigram）。
2. 调整概率：​ 对于下一个token候选，如果其与已生成序列形成重复n-gram，则降低其概率：P′(x)=penaltyP(x)​如果 x导致重复，否则 P′(x)=P(x)。或者更一般地：P′(x)=max(1,λ⋅count(gram))P(x)​，其中 λ是惩罚因子，count(gram)是n-gram出现次数。
3. 重新归一化：​ 对调整后的概率重新归一化，然后采样或选择。

目的：​ 减少生成文本中的重复短语。
惩罚因子 λ：​ 通常1.2~1.5。
n-gram大小：​ 通常1~3。

概率调整， 重复抑制。 通过降低重复token的概率来避免生成重复内容。

场景：​ 文本生成， 特别是对话、故事生成， 容易产生重复时。
特征：​ 惩罚重复n-gram， 动态调整概率。

P(x)：​ 原始概率分布。
λ：​ 惩罚因子，λ≥1。
count(gram)：​ n-gram在已生成序列中的出现次数。
n-gram大小：​ n，通常1或2。

概率缩放：​ P′(x)=P(x)/max(1,λ⋅count(gram))。
重新归一化：​ 确保 ∑x​P′(x)=1。

描述为“如果下一个token会导致重复的n-gram，则将其概率除以一个惩罚因子，从而降低重复的可能性”。

1. 输入：已生成序列 seq，当前步的概率分布 P(x)，惩罚因子 λ，n-gram大小 n。
2. 对于每个候选token x：
a. 构建新n-gram：如果 n=1，gram=x；如果 n=2，gram=seq[−1]+x（最后token和x的组合）。
b. 计算gram在 seq中出现的次数 c。
c. 调整概率：P′(x)=P(x)/max(1,λ⋅c)。
3. 重新归一化 P′使其和为1。
4. 根据 P′采样或选择最大概率token。​

“重复抑制流”：​ 原始概率流 P(x)经过重复检测器，对于每个候选token x，检查其与历史流形成的n-gram是否重复。如果重复，则概率流被惩罚因子 λ缩放降低；否则保持不变。调整后的概率流 P′(x)被重新归一化，然后用于生成流。这抑制了重复流，促进多样性流。

重复惩罚需要在生成过程中维护n-gram计数，计算开销较小。在分布式生成中，每个GPU需要知道完整的历史序列，可能需要通信。

束搜索， 长度惩罚。

AI-A0-0230​

解码策略

文本生成

在束搜索中，对已生成的序列进行分组，避免多样性不足。

束搜索分组 (Beam Search with Grouping)​

1. 分组：​ 将束中的序列根据某些特征（如前缀、语义）分成若干组。
2. 每组保留最佳：​ 从每组中选择分数最高的序列代表该组。
3. 平衡选择：​ 在扩展时，确保最终保留的束包含来自不同组的序列，以增加多样性。

目的：​ 增加束搜索的多样性， 避免所有序列都相似。
分组策略：​ 按前缀、 按句子嵌入聚类等。

多样性促进， 分组平衡。 通过分组确保候选集覆盖不同区域，提高多样性。

场景：​ 需要多样生成的束搜索， 如对话生成、 故事生成。
特征：​ 分组， 每组保留最佳， 平衡选择。

k：​ 束宽。
g：​ 组数。
分组函数：​ group(seq)返回序列所属组别。
分数：​ 序列的对数概率分数。

分组：​ 将序列划分为不相交的子集。
每组选择：​ 每组内按分数排序。

描述为“将候选序列分组，从每组中选择最好的序列，确保最终束包含不同组的序列，以增加多样性”。

**1. 初始化束 B包含 k个序列（或空序列）。
2. 每步扩展后，得到候选序列集合 C。
3. 将 C中的序列按分组函数分成 g组。
4. 从每组中选择分数最高的序列，形成新的束 B′，如果 $

B'

< k$，则从剩余序列中补足分数最高的。
5. 重复直到结束。**​

“分组选择流”：​ 候选序列流 C被分组函数分成多个子流。每个子流内，分数最高的序列流被选出，代表该组。这些代表流组成新的束流 B′。这样，束流包含了来自不同组的流，增加了多样性。

AI-A0-0231​

解码策略

文本生成

在生成过程中，同时考虑模型概率和与之前生成的token的相似性，鼓励多样性。

对比搜索 (Contrastive Search)​

1. 候选生成：​ 在每一步，从模型概率分布中选择 top-k 候选token。
2. 评分函数：​ 对每个候选token x，计算分数 s(x)=(1−α)⋅logP(x∣context)−α⋅maxy∈context​sim(f(x),f(y))，其中 sim是相似度（如余弦相似度），f是token的嵌入向量，α是权重。
3. 选择：​ 选择分数最高的token作为输出。

目的：​ 在保持生成质量的同时， 减少重复， 增加多样性。
α：​ 控制多样性权重， 通常0.5~0.8。
相似度：​ 使用token嵌入的余弦相似度。

多样性解码， 对比惩罚。 通过惩罚与上下文相似的token来鼓励多样性。

场景：​ 文本生成， 需要多样且连贯的文本。
特征：​ 结合模型概率和相似度惩罚， 选择多样token。

P(x∣context)：​ 模型给定上下文的概率。
f(x)：​ token x的嵌入向量。
sim(u,v)：​ 余弦相似度 ∥u∥∥v∥u⋅v​。
α：​ 多样性权重，0≤α≤1。
top-k：​ 候选token数。

加权和：​ s(x)=(1−α)⋅logP−α⋅max similarity。
相似度惩罚：​ 惩罚与上下文最相似的token。

描述为“从概率最高的k个候选token中，选择模型概率高且与已生成token相似度低的token，通过加权分数进行平衡”。

1. 输入：上下文 c，模型概率分布 P(x∣c)，嵌入函数 f，参数 α, k。
2. 选择top-k候选token：Vtop-k​=topk​(P)。
3. 对于每个候选 x∈Vtop-k​：
a. 计算模型分数：slm​(x)=logP(x∣c)。
b. 计算相似度惩罚：ssim​(x)=maxy∈c​sim(f(x),f(y))。
c. 总分：s(x)=(1−α)⋅slm​(x)−α⋅ssim​(x)。
4. 选择总分最高的token输出。​

“对比分数流”：​ 模型概率流 logP与相似度惩罚流 max similarity结合。对于每个候选token，其嵌入流 f(x)与历史token的嵌入流计算相似度，取最大值作为惩罚。总分数流 s(x)是概率流与惩罚流的加权差。选择流选取总分最高的token。这鼓励选择概率高但与历史不重复的token。

对比搜索需要计算每个候选token与历史token的相似度，计算开销随历史长度增加。嵌入向量 f(x)可以是预训练的token嵌入。在分布式生成中，每个GPU需要访问完整历史嵌入。

核采样， 重复惩罚。

AI-A0-0232​

解码策略

文本生成

在生成过程中，同时考虑多个候选序列，通过比较选择最佳下一个token。

集束采样 (Beam Sampling)​

1. 维护束：​ 类似束搜索，维护 k个候选序列。
2. 采样扩展：​ 对于每个候选序列，根据模型概率分布采样下一个token（而不是选择最高概率），生成多个扩展序列。
3. 选择：​ 从所有扩展序列中选择 k个分数最高的序列（分数为累积对数概率）。
4. 重复直到结束。​

特点：​ 结合了束搜索的序列维护和采样的随机性， 增加多样性。
束宽 k：​ 通常5~10。

随机束搜索， 采样与选择结合。 通过采样扩展增加探索，通过分数选择保持质量。

场景：​ 文本生成， 需要多样性但又不失连贯性。
特征：​ 采样扩展， 束选择， 随机性。

k：​ 束宽。
采样：​ 从模型概率分布中采样下一个token。
分数：​ 累积对数概率 s=∑logP。

采样：​ 从 P(x)中随机采样。
Top-k选择：​ 选择分数最高的k个序列。

描述为“维护k个候选序列，每一步对每个序列采样下一个token生成多个扩展序列，然后选择分数最高的k个序列继续”。

1. 初始化束 B包含 k个序列（如空序列）。
2. 每步：
a. 初始化候选集 C=∅。
b. 对于每个序列 (seq,score)in B：
i. 如果 seq已结束，加入 C。
ii. 否则，根据 P(x∣seq)采样 m个token（m可固定或动态）。
iii. 对于每个采样token x，新序列 new_seq=seq+[x]，新分数 new_score=score+logP(x∣seq)，加入 C。
c. 从 C中选择分数最高的 k个序列作为新束 B。
3. 达到最大长度或所有序列结束时，从 B中选择分数最高的序列输出。​

“采样-选择流”：​ 每个序列流通过采样产生多个分支流，每个分支流对应一个采样token。然后所有分支流根据分数排序，选择top-k流继续。这结合了随机探索和确定性选择。

集束采样需要为每个序列采样多个token，计算量较大。在分布式生成中，每个GPU可以独立处理部分序列，但需要通信进行全局选择。

束搜索， 核采样。

AI-A0-0233​

解码策略

文本生成

在每一步，从模型概率分布中随机采样一个token，完全随机。

随机采样 (Random Sampling)​

1. 计算概率分布：​ P(x)通过softmax得到。
2. 采样：​ 根据 P(x)随机采样一个token，即 x∼P(x)。

特点：​ 完全随机， 多样性最高， 但可能生成不连贯的文本。
通常与温度采样结合使用。​

概率采样， 完全随机。 根据概率分布随机选择下一个token。

场景：​ 需要高多样性的创意写作， 或与温度采样结合控制随机性。
特征：​ 完全随机， 无偏采样。

P(x)：​ 概率分布。

采样：​ x∼P(x)。

描述为“根据模型输出的概率分布随机选择一个token作为输出”。

1. 输入：概率分布 P(x)。
2. 根据 P(x)随机采样一个token x。
3. 输出 x。​

“随机采样流”：​ 概率流 P(x)直接作为采样分布，随机生成一个token流。没有确定性选择，完全随机。

随机采样只需从分布中采样，计算简单。在分布式生成中，每个GPU独立采样，但需要同步随机种子以确保一致性（如果要求）。

温度采样， 贪婪解码。

AI-A0-0234​

解码策略

文本生成

在每一步，从模型概率分布中采样，但通过调整概率分布避免重复。

重复惩罚采样 (Repetition Penalty Sampling)​

1. 计算原始概率 P(x)。
2. 对于已生成序列中的token，降低其概率：P′(x)=penaltyP(x)​如果 x在历史中出现过，否则 P′(x)=P(x)。惩罚因子 penalty>1。
3. 重新归一化 P′。
4. 从 P′中采样。​

目的：​ 减少重复token的出现。
惩罚因子：​ 通常1.2~2.0。

概率调整， 重复抑制。 通过降低已出现token的概率来避免重复。

场景：​ 文本生成， 容易产生重复token时。
特征：​ 惩罚历史token， 重新归一化， 采样。

P(x)：​ 原始概率分布。
历史集合 H：​ 已生成的token集合。
惩罚因子 λ：​ λ≥1。
P′(x)：​ 调整后的概率。

概率缩放：​ P′(x)=P(x)/λ如果 x∈H。
重新归一化：​ ∑x​P′(x)=1。

描述为“降低已生成token的概率，然后重新归一化并采样，以减少重复”。

1. 输入：原始概率 P(x)，历史token集合 H，惩罚因子 λ。
2. 对于每个token x：
a. 如果 x∈H，则 P′(x)=P(x)/λ。
b. 否则 P′(x)=P(x)。
3. 重新归一化 P′：P′′(x)=P′(x)/∑x′​P′(x′)。
4. 从 P′′中采样一个token输出。​

“重复抑制采样流”：​ 原始概率流 P(x)经过惩罚过滤器，历史token的概率流被缩小 λ倍。然后重新归一化流产生 P′′(x)，采样流从 P′′中产生输出。这降低了重复token被选中的概率。

重复惩罚采样需要维护历史token集合，计算开销小。在分布式生成中，每个GPU需要知道历史token，可能需要通信。

核采样， 对比搜索。

AI-A0-0235​

解码策略

文本生成

在每一步，从模型概率分布中采样，但通过调整概率分布鼓励多样性。

多样性促进采样 (Diversity-Promoting Sampling)​

1. 计算原始概率 P(x)。
2. 调整概率：P′(x)=P(x)α/∑x′​P(x′)α，其中 α<1时平滑分布（增加多样性），α>1时锐化分布（减少多样性）。
3. 从 P′中采样。​

效果：​ α=1为原始分布；α<1增加多样性；α>1减少多样性。
α：​ 通常0.5~0.9 以增加多样性。

概率变换， 熵调整。 通过指数 α调整概率分布的熵，控制多样性。

场景：​ 文本生成， 需要控制多样性时。
特征：​ 指数调整， 重新归一化， 采样。

P(x)：​ 原始概率分布。
α：​ 多样性参数，α>0。
P′(x)：​ 调整后的概率。

指数变换：​ P′(x)∝P(x)α。
归一化：​ P′(x)=P(x)α/∑x′​P(x′)α。

描述为“将原始概率分布进行指数变换，指数小于1时平滑分布增加多样性，大于1时锐化分布减少多样性，然后采样”。

1. 输入：原始概率 P(x)，参数 α。
2. 计算 P′(x)=P(x)α对于所有 x。
3. 归一化：P′′(x)=P′(x)/∑x′​P′(x′)。
4. 从 P′′中采样一个token输出。​

“指数平滑流”：​ 原始概率流 P(x)经过指数变换 (⋅)α。当 α<1时，概率流被平滑，低概率token的相对概率提升，增加多样性流；当 α>1时，概率流被锐化，高概率token更突出，减少多样性流。然后归一化流产生 P′′(x)，采样流从中选择。

多样性促进采样涉及指数运算和归一化，计算开销中等。在分布式生成中，每个GPU独立计算。

温度采样， 核采样。

AI-A0-0236​

解码策略

文本生成

在每一步，从模型概率分布中采样，但通过调整概率分布避免生成特定token（如不良词汇）。

禁止token采样 (Forbidden Token Sampling)​

1. 计算原始概率 P(x)。
2. 将禁止token集合 F的概率设为0：P′(x)=0如果 x∈F，否则 P′(x)=P(x)。
3. 重新归一化 P′。
4. 从 P′中采样。​

目的：​ 避免生成不希望出现的token， 如脏话、 敏感词等。
禁止集合 F：​ 预定义或动态更新。

概率过滤， 内容控制。 通过将禁止token的概率置零来避免生成它们。

场景：​ 内容安全， 避免生成不良内容。
特征：​ 禁止token集合， 概率置零， 重新归一化。

P(x)：​ 原始概率分布。
F：​ 禁止token集合。
P′(x)：​ 调整后的概率。

概率置零：​ P′(x)=0for x∈F。
**重新归一化

AI-A0-0223​

解码策略

Token领域

从累积概率超过阈值p的最小token集合中采样，动态调整候选集大小。

核采样 (Top-p采样, Nucleus Sampling)​

1. 计算概率分布：​ 给定语言模型输出的logits，通过softmax得到概率分布 P(x)。
2. 排序：​ 将概率从大到小排序，得到排序后的概率 p(1)​≥p(2)​≥...≥p(V)​，对应token x(1)​,x(2)​,...,x(V)​。
3. 累积概率：​ 计算累积概率 C(k)=∑i=1k​p(i)​。
4. 选择候选集：​ 找到最小的 k使得 C(k)≥p，其中 p是阈值（如0.9）。候选集为 Vnucleus​={x(1)​,...,x(k)​}。
5. 重新归一化：​ 对候选集内的概率重新归一化：P′(x(i)​)=∑j=1k​p(j)​p(i)​​，i=1,...,k。
6. 采样：​ 从 P′中采样一个token作为输出。

优点：​ 动态调整候选集大小， 避免在概率分布平坦时采样到低概率token， 或在尖锐时过度限制。
阈值 p：​ 通常0.9~0.95。

概率采样， 动态阈值。 通过累积概率阈值动态选择候选集，平衡多样性和质量。

场景：​ 文本生成， 如故事创作、对话生成， 需要多样性和连贯性。
特征：​ 动态候选集， 重新归一化， 避免尾部token。

P(x)：​ 原始概率分布，x∈V（词表）。
p：​ 阈值，0<p≤1。
k：​ 候选集大小，满足 ∑i=1k​p(i)​≥p。
P′(x)：​ 重新归一化的概率分布。

排序：​ 概率降序排列。
累积和：​ C(k)=∑i=1k​p(i)​。
重新归一化：​ P′(x(i)​)=p(i)​/C(k)。

描述为“将概率从大到小排序，选择累积概率达到阈值p的最小token集合，然后在这个集合内重新归一化概率并采样”。

1. 输入：概率分布 P(x)，阈值 p。
2. 将概率降序排序，得到序列 p(1)​,p(2)​,...,p(V)​和对应token。
3. 初始化 C=0, k=0。
4. while C<pand k<V:
a. k=k+1
b. C=C+p(k)​
5. 候选集 S={x(1)​,...,x(k)​}。
6. 重新归一化：对于 i=1到 k，P′(x(i)​)=p(i)​/C。
7. 根据 P′采样一个token输出。​

“概率累积流”：​ 概率流 P(x)被排序为降序流 p(i)​。累积流 C(k)逐步累加，直到达到阈值 p。此时，前 k个token形成核心流（nucleus），其余token被截断。核心流内的概率被重新归一化，形成新的概率流 P′，采样流从 P′中产生输出token。

核采样在单个GPU上执行，涉及排序和累积操作，计算复杂度 O(VlogV)。在分布式生成中，每个GPU可以独立采样，但需要同步随机种子以确保一致性（如果要求）。

Top-k采样， 温度采样， 束搜索。

AI-A0-0224​

解码策略

Token领域

从概率最高的k个token中采样，候选集大小固定。

Top-k采样​

1. 计算概率分布：​ P(x)通过softmax得到。
2. 选择Top-k：​ 选择概率最高的 k个token，构成候选集 Vtop-k​。
3. 重新归一化：​ 对候选集内的概率重新归一化：P′(x)=∑x∈Vtop-k​​P(x)P(x)​，对于 x∈Vtop-k​。
4. 采样：​ 从 P′中采样一个token。

优点：​ 简单， 避免采样到低概率token。
缺点：​ k固定， 可能在某些情况下排除合理token（如果概率分布尖锐）或包含过多噪声（如果分布平坦）。
k：​ 通常5~50。

概率采样， 固定候选集。 通过固定大小的候选集限制采样范围，提高生成质量。

场景：​ 文本生成， 需要限制采样空间时。
特征：​ 固定k， 重新归一化， 简单高效。

P(x)：​ 原始概率分布。
k：​ 候选集大小，正整数。
Vtop-k​：​ 概率最高的k个token集合。
P′(x)：​ 重新归一化的概率分布。

Top-k选择：​ 选择概率最大的k个元素。
重新归一化：​ 在子集上归一化。

描述为“选择概率最高的k个token，然后在这个集合内重新归一化概率并采样”。

**1. 输入：概率分布 P(x)，参数 k。
2. 找到概率最大的k个token：$V{\text{top-k}} = \arg\max{x \in V,

S

=k} \sum{x \in S} P(x)。<br>3.计算候选集总概率：Z = \sum{x \in V{\text{top-k}}} P(x)。<br>4.重新归一化：对于每个x \in V{\text{top-k}}，P'(x) = P(x) / Z。<br>5.根据P'$ 采样一个token输出。**​

“Top-k截断流”：​ 概率流 P(x)经过排序，保留前 k个最大的概率流，其余被截断。然后对保留的概率流进行重新归一化，形成新的概率流 P′，采样流从 P′中产生输出。

AI-A0-0225​

解码策略

Token领域

通过温度参数调整概率分布的平滑度，控制生成多样性。

温度采样 (Temperature Sampling)​

1. 计算logits：​ 语言模型输出logits zi​对于每个token i。
2. 应用温度：​ zi′​=zi​/T，其中 T>0是温度参数。
3. Softmax：​ Pi​=∑j​exp(zj′​)exp(zi′​)​。
4. 采样：​ 从 Pi​中采样一个token。

温度效应：​ T=1保持原分布；T>1平滑分布（增加多样性）；T<1锐化分布（减少多样性，趋向贪婪）。
T：​ 通常0.5~1.0。

概率变换， 平滑控制。 通过温度参数控制概率分布的熵，调节生成多样性。

场景：​ 文本生成， 需要控制生成结果的随机性时。
特征：​ 温度参数， 平滑/锐化分布， 简单。

zi​：​ logits，未归一化的分数。
T：​ 温度参数，正实数。
Pi​：​ 温度调整后的概率。

缩放：​ zi′​=zi​/T。
Softmax：​ Pi​=softmax(zi′​)。

描述为“将logits除以温度参数后再进行softmax，温度越高概率分布越平滑，采样越多样；温度越低分布越尖锐，采样越确定”。

1. 输入：logits向量 z，温度 T。
2. 计算缩放logits：z′=z/T。
3. 计算概率：P=softmax(z′)。
4. 从 P中采样一个token输出。​

“温度调节流”：​ logits流 z被温度参数 T缩放，得到 z′。然后通过softmax流转换为概率流 P。温度 T作为一个控制阀：当 T大时，缩放后的 logits 流 z′差异变小，softmax 流输出更平滑的概率流，采样流更随机；当 T小时，z′差异放大，概率流更尖锐，采样流更确定。

温度采样计算简单，只需除法和softmax。在分布式生成中，每个GPU独立应用温度并采样。

核采样， Top-k采样， 贪婪解码。

AI-A0-0226​

解码策略

Token领域

在每一步选择概率最高的token，确定性解码。

贪婪解码 (Greedy Decoding)​

1. 计算概率分布：​ P(x)通过softmax得到。
2. 选择最大概率token：​ x∗=argmaxx​P(x)。
3. 输出 x∗作为当前步的生成token。​

优点：​ 简单， 快速， 确定性。
缺点：​ 容易陷入重复或局部最优， 缺乏多样性。

确定性解码， 最大似然。 每一步选择当前最可能的token，但不保证全局最优序列。

场景：​ 需要快速、确定性生成的场景， 如机器翻译、摘要。
特征：​ 确定性， 贪婪， 每一步局部最优。

P(x)：​ 概率分布。
x∗：​ 最大概率token。

argmax：​ x∗=argmaxP(x)。

描述为“每一步都选择概率最高的token作为输出”。

1. 输入：概率分布 P(x)。
2. 找到最大概率token：x∗=argmaxx​P(x)。
3. 输出 x∗。​

“贪婪选择流”：​ 概率流 P(x)直接流向argmax操作，输出最大概率token流。没有随机性，每一步都是确定性的选择。

贪婪解码只需argmax操作，计算简单。在分布式生成中，每个GPU可以独立生成，但需要同步以确保一致性（如果使用束搜索则需通信）。

束搜索， 采样方法。

AI-A0-0227​

解码策略

Token领域

维护多个候选序列（束），每一步扩展所有候选序列，保留总体概率最高的k个序列。

束搜索 (Beam Search)​

1. 初始化：​ 包含一个空序列，分数为0。
2. 迭代：​ 对于每一步 t：
a. 对于每个候选序列（束），用语言模型预测下一个token的概率分布。
b. 扩展每个序列：生成所有可能的下一token，计算新序列分数（累积对数概率）。
c. 从所有扩展序列中选择分数最高的 k个作为新的候选集。
3. 终止：​ 当达到最大长度或所有候选序列以结束符结束时，选择分数最高的序列作为输出。

优点：​ 比贪婪解码更可能找到全局最优序列。
缺点：​ 计算开销大， 内存占用高， 可能产生重复或平淡的文本。
束宽 k：​ 通常5~10。

启发式搜索， 广度优先剪枝。 维护固定大小的候选集，近似全局最优序列。

场景：​ 序列生成任务， 如机器翻译、文本摘要， 需要高质量序列。
特征：​ 束宽k， 保留多个候选， 基于累积分数选择。

k：​ 束宽，候选序列数量。
s：​ 序列分数，通常为对数概率之和：s=∑i=1t​logP(xi​∣x<i​)。
T：​ 最大生成长度。
结束符：​ 如 <eos>。

累积对数概率：​ s=∑logP。
Top-k选择：​ 每步保留分数最高的k个序列。

描述为“维护k个最有可能的候选序列，每一步扩展这些序列，然后从所有扩展序列中再选择k个分数最高的，直到生成结束”。

1. 初始化束 B=[(空序列,分数=0)]。
2. for t=1to T:
a. 初始化所有候选序列集合 C=∅。
b. for 每个序列 (seq,score)in B:
i. 如果 seq以结束符结尾，则加入 C并跳过扩展。
ii. 否则，用语言模型预测下一个token概率 P(x∣seq)。
iii. for 每个token xin 词表：
- 新序列 new_seq=seq+[x]。
- 新分数 new_score=score+logP(x∣seq)。
- 将 (new_seq,new_score)加入 C。
c. 从 C中选择分数最高的 k个序列作为新的束 B。
d. 如果 B中所有序列都以结束符结尾，则跳出循环。
3. 从 B中选择分数最高的序列作为输出。​

“束流”：​ 初始时，一个空序列流开始。每一步，每个序列流扩展为多个子流（每个token一个），形成扩展流集合。然后通过排序和选择，保留分数最高的k个流，其余被剪枝。这些流继续迭代，直到结束。束流通过并行探索多条路径，增加了找到高质量序列的可能性。

束搜索需要维护k个候选序列，每个序列需要独立进行前向传播，计算量大。在分布式生成中，每个GPU可以处理部分序列，但需要通信来同步分数和选择全局top-k。

贪婪解码， 长度惩罚， 重复惩罚。

AI-A0-0228​

解码策略

Token领域

在束搜索中引入长度归一化，避免偏向短序列。

长度惩罚 (Length Penalty)​

1. 序列分数：​ 原始分数为对数概率之和 s=∑i=1L​logP(xi​∣x<i​)。
2. 长度归一化：​ snorm​=(L+c)αs​，其中 L是序列长度，c是常数，α是惩罚因子。
3. 在束搜索中，使用 snorm​而不是 s来比较序列。​

目的：​ 纠正束搜索倾向于短序列的偏差（因为对数概率为负，越长分数越低）。
α：​ 通常0.6~1.0，α=0无惩罚，α>0惩罚长序列，α<0奖励长序列。
c：​ 通常5，平滑长度。

分数归一化， 偏差校正。 通过对数概率之和除以长度相关因子，使不同长度序列可比。

场景：​ 束搜索中， 需要公平比较不同长度序列时。
特征：​ 长度归一化， 可调参数 α。

s：​ 原始分数，对数概率之和。
L：​ 序列长度（token数）。
c：​ 常数，通常5。
α：​ 长度惩罚因子，实数。

归一化：​ snorm​=s/(L+c)α。
对数概率和：​ s=∑logP。

描述为“将序列的对数概率之和除以长度的幂次方，以消除长度偏差，使得束搜索能够公平比较不同长度的序列”。

在束搜索的每一步，当计算新序列分数时：
1. 计算原始分数 s=score+logP(x∣seq)。
2. 计算归一化分数 snorm​=s/(L+5)α，其中 L是新序列长度。
3. 使用 snorm​作为序列分数进行排序和选择。​

“长度归一化流”：​ 原始分数流 s与长度流 L结合，通过归一化函数 f(L)=(L+c)α进行缩放，得到归一化分数流 snorm​。这个流使得长序列的分数不会被过度惩罚，从而在束搜索中公平竞争。

长度惩罚在束搜索中简单应用，只需在计算分数时增加归一化步骤。在分布式束搜索中，每个GPU本地计算归一化分数，然后全局排序。

束搜索， 重复惩罚。

AI-A0-0229​

解码策略

Token领域

在生成过程中惩罚重复的n-gram，避免重复文本。

重复惩罚 (Repetition Penalty)​

1. 识别重复：​ 对于已生成的序列，检测出现的n-gram（如unigram, bigram）。
2. 调整概率：​ 对于下一个token候选，如果其与已生成序列形成重复n-gram，则降低其概率：P′(x)=penaltyP(x)​如果 x导致重复，否则 P′(x)=P(x)。或者更一般地：P′(x)=max(1,λ⋅count(gram))P(x)​，其中 λ是惩罚因子，count(gram)是n-gram出现次数。
3. 重新归一化：​ 对调整后的概率重新归一化，然后采样或选择。

目的：​ 减少生成文本中的重复短语。
惩罚因子 λ：​ 通常1.2~1.5。
n-gram大小：​ 通常1~3。

概率调整， 重复抑制。 通过降低重复token的概率来避免生成重复内容。

场景：​ 文本生成， 特别是对话、故事生成， 容易产生重复时。
特征：​ 惩罚重复n-gram， 动态调整概率。

P(x)：​ 原始概率分布。
λ：​ 惩罚因子，λ≥1。
count(gram)：​ n-gram在已生成序列中的出现次数。
n-gram大小：​ n，通常1或2。

概率缩放：​ P′(x)=P(x)/max(1,λ⋅count(gram))。
重新归一化：​ 确保 ∑x​P′(x)=1。

描述为“如果下一个token会导致重复的n-gram，则将其概率除以一个惩罚因子，从而降低重复的可能性”。

1. 输入：已生成序列 seq，当前步的概率分布 P(x)，惩罚因子 λ，n-gram大小 n。
2. 对于每个候选token x：
a. 构建新n-gram：如果 n=1，gram=x；如果 n=2，gram=seq[−1]+x（最后token和x的组合）。
b. 计算gram在 seq中出现的次数 c。
c. 调整概率：P′(x)=P(x)/max(1,λ⋅c)。
3. 重新归一化 P′使其和为1。
4. 根据 P′采样或选择最大概率token。​

“重复抑制流”：​ 原始概率流 P(x)经过重复检测器，对于每个候选token x，检查其与历史流形成的n-gram是否重复。如果重复，则概率流被惩罚因子 λ缩放降低；否则保持不变。调整后的概率流 P′(x)被重新归一化，然后用于生成流。这抑制了重复流，促进多样性流。

重复惩罚需要在生成过程中维护n-gram计数，计算开销较小。在分布式生成中，每个GPU需要知道完整的历史序列，可能需要通信。

束搜索， 长度惩罚。

AI-A0-0230​

解码策略

Token领域

在束搜索中，对已生成的序列进行分组，避免多样性不足。

束搜索分组 (Beam Search with Grouping)​

1. 分组：​ 将束中的序列根据某些特征（如前缀、语义）分成若干组。
2. 每组保留最佳：​ 从每组中选择分数最高的序列代表该组。
3. 平衡选择：​ 在扩展时，确保最终保留的束包含来自不同组的序列，以增加多样性。

目的：​ 增加束搜索的多样性， 避免所有序列都相似。
分组策略：​ 按前缀、 按句子嵌入聚类等。

多样性促进， 分组平衡。 通过分组确保候选集覆盖不同区域，提高多样性。

场景：​ 需要多样生成的束搜索， 如对话生成、 故事生成。
特征：​ 分组， 每组保留最佳， 平衡选择。

k：​ 束宽。
g：​ 组数。
分组函数：​ group(seq)返回序列所属组别。
分数：​ 序列的对数概率分数。

分组：​ 将序列划分为不相交的子集。
每组选择：​ 每组内按分数排序。

描述为“将候选序列分组，从每组中选择最好的序列，确保最终束包含不同组的序列，以增加多样性”。

**1. 初始化束 B包含 k个序列（或空序列）。
2. 每步扩展后，得到候选序列集合 C。
3. 将 C中的序列按分组函数分成 g组。
4. 从每组中选择分数最高的序列，形成新的束 B′，如果 $

B'

< k$，则从剩余序列中补足分数最高的。
5. 重复直到结束。**​

“分组选择流”：​ 候选序列流 C被分组函数分成多个子流。每个子流内，分数最高的序列流被选出，代表该组。这些代表流组成新的束流 B′。这样，束流包含了来自不同组的流，增加了多样性。

AI-A0-0231​

解码策略

Token领域

在生成过程中，同时考虑模型概率和与之前生成的token的相似性，鼓励多样性。

对比搜索 (Contrastive Search)​

1. 候选生成：​ 在每一步，从模型概率分布中选择 top-k 候选token。
2. 评分函数：​ 对每个候选token x，计算分数 s(x)=(1−α)⋅logP(x∣context)−α⋅maxy∈context​sim(f(x),f(y))，其中 sim是相似度（如余弦相似度），f是token的嵌入向量，α是权重。
3. 选择：​ 选择分数最高的token作为输出。

目的：​ 在保持生成质量的同时， 减少重复， 增加多样性。
α：​ 控制多样性权重， 通常0.5~0.8。
相似度：​ 使用token嵌入的余弦相似度。

多样性解码， 对比惩罚。 通过惩罚与上下文相似的token来鼓励多样性。

场景：​ 文本生成， 需要多样且连贯的文本。
特征：​ 结合模型概率和相似度惩罚， 选择多样token。

P(x∣context)：​ 模型给定上下文的概率。
f(x)：​ token x的嵌入向量。
sim(u,v)：​ 余弦相似度 ∥u∥∥v∥u⋅v​。
α：​ 多样性权重，0≤α≤1。
top-k：​ 候选token数。

加权和：​ s(x)=(1−α)⋅logP−α⋅max similarity。
相似度惩罚：​ 惩罚与上下文最相似的token。

描述为“从概率最高的k个候选token中，选择模型概率高且与已生成token相似度低的token，通过加权分数进行平衡”。

1. 输入：上下文 c，模型概率分布 P(x∣c)，嵌入函数 f，参数 α, k。
2. 选择top-k候选token：Vtop-k​=topk​(P)。
3. 对于每个候选 x∈Vtop-k​：
a. 计算模型分数：slm​(x)=logP(x∣c)。
b. 计算相似度惩罚：ssim​(x)=maxy∈c​sim(f(x),f(y))。
c. 总分：s(x)=(1−α)⋅slm​(x)−α⋅ssim​(x)。
4. 选择总分最高的token输出。​

“对比分数流”：​ 模型概率流 logP与相似度惩罚流 max similarity结合。对于每个候选token，其嵌入流 f(x)与历史token的嵌入流计算相似度，取最大值作为惩罚。总分数流 s(x)是概率流与惩罚流的加权差。选择流选取总分最高的token。这鼓励选择概率高但与历史不重复的token。

对比搜索需要计算每个候选token与历史token的相似度，计算开销随历史长度增加。嵌入向量 f(x)可以是预训练的token嵌入。在分布式生成中，每个GPU需要访问完整历史嵌入。

核采样， 重复惩罚。

AI-A0-0232​

解码策略

Token领域

在生成过程中，同时考虑多个候选序列，通过比较选择最佳下一个token。

集束采样 (Beam Sampling)​

1. 维护束：​ 类似束搜索，维护 k个候选序列。
2. 采样扩展：​ 对于每个候选序列，根据模型概率分布采样下一个token（而不是选择最高概率），生成多个扩展序列。
3. 选择：​ 从所有扩展序列中选择 k个分数最高的序列（分数为累积对数概率）。
4. 重复直到结束。​

特点：​ 结合了束搜索的序列维护和采样的随机性， 增加多样性。
束宽 k：​ 通常5~10。

随机束搜索， 采样与选择结合。 通过采样扩展增加探索，通过分数选择保持质量。

场景：​ 文本生成， 需要多样性但又不失连贯性。
特征：​ 采样扩展， 束选择， 随机性。

k：​ 束宽。
采样：​ 从模型概率分布中采样下一个token。
分数：​ 累积对数概率 s=∑logP。

采样：​ 从 P(x)中随机采样。
Top-k选择：​ 选择分数最高的k个序列。

描述为“维护k个候选序列，每一步对每个序列采样下一个token生成多个扩展序列，然后选择分数最高的k个序列继续”。

1. 初始化束 B包含 k个序列（如空序列）。
2. 每步：
a. 初始化候选集 C=∅。
b. 对于每个序列 (seq,score)in B：
i. 如果 seq已结束，加入 C。
ii. 否则，根据 P(x∣seq)采样 m个token（m可固定或动态）。
iii. 对于每个采样token x，新序列 new_seq=seq+[x]，新分数 new_score=score+logP(x∣seq)，加入 C。
c. 从 C中选择分数最高的 k个序列作为新束 B。
3. 达到最大长度或所有序列结束时，从 B中选择分数最高的序列输出。​

“采样-选择流”：​ 每个序列流通过采样产生多个分支流，每个分支流对应一个采样token。然后所有分支流根据分数排序，选择top-k流继续。这结合了随机探索和确定性选择。

集束采样需要为每个序列采样多个token，计算量较大。在分布式生成中，每个GPU可以独立处理部分序列，但需要通信进行全局选择。

束搜索， 核采样。

AI-A0-0233​

解码策略

Token领域

在每一步，从模型概率分布中随机采样一个token，完全随机。

随机采样 (Random Sampling)​

1. 计算概率分布：​ P(x)通过softmax得到。
2. 采样：​ 根据 P(x)随机采样一个token，即 x∼P(x)。

特点：​ 完全随机， 多样性最高， 但可能生成不连贯的文本。
通常与温度采样结合使用。​

概率采样， 完全随机。 根据概率分布随机选择下一个token。

场景：​ 需要高多样性的创意写作， 或与温度采样结合控制随机性。
特征：​ 完全随机， 无偏采样。

P(x)：​ 概率分布。

采样：​ x∼P(x)。

描述为“根据模型输出的概率分布随机选择一个token作为输出”。

1. 输入：概率分布 P(x)。
2. 根据 P(x)随机采样一个token x。
3. 输出 x。​

“随机采样流”：​ 概率流 P(x)直接作为采样分布，随机生成一个token流。没有确定性选择，完全随机。

随机采样只需从分布中采样，计算简单。在分布式生成中，每个GPU独立采样，但需要同步随机种子以确保一致性（如果要求）。

温度采样， 贪婪解码。

AI-A0-0234​

解码策略

Token领域

在每一步，从模型概率分布中采样，但通过调整概率分布避免重复。

重复惩罚采样 (Repetition Penalty Sampling)​

1. 计算原始概率 P(x)。
2. 对于已生成序列中的token，降低其概率：P′(x)=penaltyP(x)​如果 x在历史中出现过，否则 P′(x)=P(x)。惩罚因子 penalty>1。
3. 重新归一化 P′。
4. 从 P′中采样。​

目的：​ 减少重复token的出现。
惩罚因子：​ 通常1.2~2.0。

概率调整， 重复抑制。 通过降低已出现token的概率来避免重复。

场景：​ 文本生成， 容易产生重复token时。
特征：​ 惩罚历史token， 重新归一化， 采样。

P(x)：​ 原始概率分布。
历史集合 H：​ 已生成的token集合。
惩罚因子 λ：​ λ≥1。
P′(x)：​ 调整后的概率。

概率缩放：​ P′(x)=P(x)/λ如果 x∈H。
重新归一化：​ ∑x​P′(x)=1。

描述为“降低已生成token的概率，然后重新归一化并采样，以减少重复”。

1. 输入：原始概率 P(x)，历史token集合 H，惩罚因子 λ。
2. 对于每个token x：
a. 如果 x∈H，则 P′(x)=P(x)/λ。
b. 否则 P′(x)=P(x)。
3. 重新归一化 P′：P′′(x)=P′(x)/∑x′​P′(x′)。
4. 从 P′′中采样一个token输出。​

“重复抑制采样流”：​ 原始概率流 P(x)经过惩罚过滤器，历史token的概率流被缩小 λ倍。然后重新归一化流产生 P′′(x)，采样流从 P′′中产生输出。这降低了重复token被选中的概率。

重复惩罚采样需要维护历史token集合，计算开销小。在分布式生成中，每个GPU需要知道历史token，可能需要通信。

核采样， 对比搜索。

AI-A0-0235​

解码策略

Token领域

在每一步，从模型概率分布中采样，但通过调整概率分布鼓励多样性。

多样性促进采样 (Diversity-Promoting Sampling)​

1. 计算原始概率 P(x)。
2. 调整概率：P′(x)=P(x)α/∑x′​P(x′)α，其中 α<1时平滑分布（增加多样性），α>1时锐化分布（减少多样性）。
3. 从 P′中采样。​

效果：​ α=1为原始分布；α<1增加多样性；α>1减少多样性。
α：​ 通常0.5~0.9 以增加多样性。

概率变换， 熵调整。 通过指数 α调整概率分布的熵，控制多样性。

场景：​ 文本生成， 需要控制多样性时。
特征：​ 指数调整， 重新归一化， 采样。

P(x)：​ 原始概率分布。
α：​ 多样性参数，α>0。
P′(x)：​ 调整后的概率。

指数变换：​ P′(x)∝P(x)α。
归一化：​ P′(x)=P(x)α/∑x′​P(x′)α。

描述为“将原始概率分布进行指数变换，指数小于1时平滑分布增加多样性，大于1时锐化分布减少多样性，然后采样”。

1. 输入：原始概率 P(x)，参数 α。
2. 计算 P′(x)=P(x)α对于所有 x。
3. 归一化：P′′(x)=P′(x)/∑x′​P′(x′)。
4. 从 P′′中采样一个token输出。​

“指数平滑流”：​ 原始概率流 P(x)经过指数变换 (⋅)α。当 α<1时，概率流被平滑，低概率token的相对概率提升，增加多样性流；当 α>1时，概率流被锐化，高概率token更突出，减少多样性流。然后归一化流产生 P′′(x)，采样流从中选择。

多样性促进采样涉及指数运算和归一化，计算开销中等。在分布式生成中，每个GPU独立计算。

温度采样， 核采样。

AI-A0-0236​

解码策略

Token领域

在每一步，从模型概率分布中采样，但通过调整概率分布避免生成特定token（如不良词汇）。

禁止token采样 (Forbidden Token Sampling)​

1. 计算原始概率 P(x)。
2. 将禁止token集合 F的概率设为0：P′(x)=0如果 x∈F，否则 P′(x)=P(x)。
3. 重新归一化 P′。
4. 从 P′中采样。​

目的：​ 避免生成不希望出现的token， 如脏话、 敏感词等。
禁止集合 F：​ 预定义或动态更新。

概率过滤， 内容控制。 通过将禁止token的概率置零来避免生成它们。

场景：​ 内容安全， 避免生成不良内容。
特征：​ 禁止token集合， 概率置零， 重新归一化。

P(x)：​ 原始概率分布。
F：​ 禁止token集合。
P′(x)：​ 调整后的概率。

概率置零：​ P′(x)=0for x∈F。
重新归一化：​ ∑x​P′(x)=1。

描述为“将禁止token的概率设为0，然后重新归一化并采样，以确保不会生成这些token”。

1. 输入：原始概率 P(x)，禁止token集合 F。
2. 对于每个token x：
a. 如果 x∈F，则 P′(x)=0。
b. 否则 P′(x)=P(x)。
3. 重新归一化 P′：P′′(x)=P′(x)/∑x′​P′(x′)。
4. 从 P′′中采样一个token输出。​

“禁止过滤流”：​ 原始概率流 P(x)经过禁止过滤器，属于集合 F的token的概率流被截断为0。然后重新归一化流产生 P′′(x)，采样流从 P′′中产生输出，确保禁止token不会被选中。

禁止token采样需要维护禁止集合，计算开销小。在分布式生成中，禁止集合需要同步到所有GPU。

重复惩罚采样。

AI-A0-0237​

解码策略

Token领域

在生成过程中，根据上下文动态调整温度参数，以控制随机性。

动态温度采样 (Dynamic Temperature Sampling)​

1. 计算上下文的不确定性：​ 例如，使用概率分布的熵 H(P)=−∑x​P(x)logP(x)，或最大概率值 pmax​。
2. 根据不确定性调整温度：​ T=f(H(P))，例如 T=α⋅H(P)+β，或 T=pmax​1​。
3. 应用温度采样：​ zi′​=zi​/T，然后softmax和采样。

目的：​ 在模型不确定时增加多样性（高温）， 在模型确定时减少多样性（低温）。
调整函数 f：​ 线性、 倒数等。

自适应温度， 不确定性感知。 根据模型输出的不确定性动态调整温度参数。

场景：​ 文本生成， 需要自适应控制随机性时。
特征：​ 动态温度， 基于熵或最大概率。

P(x)：​ 原始概率分布。
H(P)：​ 熵。
pmax​：​ 最大概率值。
T：​ 动态温度。
α,β：​ 调整参数。

熵计算：​ H(P)=−∑PlogP。
温度调整：​ T=f(H)。

描述为“根据当前概率分布的熵或最大概率值动态计算温度参数，然后进行温度采样”。

**1. 输入：logits z，调整参数 α,β。
2. 计算原始概率 P=softmax(z)。
3. 计算熵 H=−∑x​P(x)logP(x)。

AI-A0-0237​

解码策略

Token领域

在生成过程中，根据上下文动态调整温度参数，以控制随机性。

动态温度采样 (Dynamic Temperature Sampling)​

1. 计算上下文的不确定性：​ 例如，使用概率分布的熵 H(P)=−∑x​P(x)logP(x)，或最大概率值 pmax​。
2. 根据不确定性调整温度：​ T=f(H(P))，例如 T=α⋅H(P)+β，或 T=pmax​1​。
3. 应用温度采样：​ zi′​=zi​/T，然后softmax和采样。

目的：​ 在模型不确定时增加多样性（高温）， 在模型确定时减少多样性（低温）。
调整函数 f：​ 线性、 倒数等。

自适应温度， 不确定性感知。 根据模型输出的不确定性动态调整温度参数。

场景：​ 文本生成， 需要自适应控制随机性时。
特征：​ 动态温度， 基于熵或最大概率。

P(x)：​ 原始概率分布。
H(P)：​ 熵。
pmax​：​ 最大概率值。
T：​ 动态温度。
α,β：​ 调整参数。

熵计算：​ H(P)=−∑PlogP。
温度调整：​ T=f(H)。

描述为“根据当前概率分布的熵或最大概率值动态计算温度参数，然后进行温度采样”。

1. 输入：logits z，调整参数 α,β。
2. 计算原始概率 P=softmax(z)。
3. 计算熵 H=−∑x​P(x)logP(x)。
4. 计算温度 T=α⋅H+β（或其他函数）。
5. 缩放logits: z′=z/T。
6. 计算新概率 P′=softmax(z′)。
7. 从 P′中采样。​

“自适应温度流”：​ 概率流 P的熵流 H反映了不确定性。不确定性高时，熵流大，温度流 T增大，导致缩放后的logits流 z′差异缩小，概率流 P′更平滑，采样流更随机；反之，不确定性低时，温度流小，概率流更尖锐，采样流更确定。

动态温度采样需要计算熵，增加了一些计算开销。在分布式生成中，每个GPU独立计算熵和温度。

温度采样， 熵。

AI-A0-0238​

解码策略

Token领域

在生成过程中，使用多个采样结果，通过投票或平均选择最终输出。

集束投票采样 (Beam Vote Sampling)​

1. 独立采样：​ 从同一个模型中独立采样 N个序列（使用相同的采样方法，如核采样）。
2. 投票：​ 对于每一步，考虑 N个采样序列在该位置的token，选择出现次数最多的token（多数投票）。
3. 如果有多个token票数相同，则从中随机选择一个。​

目的：​ 通过集成多个采样结果来提高生成质量和稳定性。
N：​ 采样次数， 如3、5。

集成采样， 投票。 通过多个独立采样的结果进行投票，减少随机性的不利影响。

场景：​ 需要更稳定、 更可靠生成的场景。
特征：​ 多次采样， 多数投票， 集成。

N：​ 采样次数。
seqi​：​ 第 i个采样序列。
t：​ 时间步。
投票：​ vote(x)=∑i=1N​I(seqi​[t]=x)。

计数：​ 统计每个token的出现次数。
多数投票：​ 选择计数最大的token。

描述为“独立采样多个序列，然后在每个时间步对token进行投票，选择得票最多的token作为最终输出”。

1. 初始化 N个空序列。
2. 对于每个时间步 t：
a. 对于每个 i=1到 N，如果序列 i未结束，则根据上下文采样下一个token xi​。
b. 统计所有 xi​的票数。
c. 选择票数最高的token x∗（平局时随机选一个）。
d. 将 x∗添加到所有未结束的序列中（强制一致）。
3. 当所有序列结束时停止。​

“投票集成流”：​ 多个独立的采样流并行进行，每个流产生一个token流。在每一步，这些token流进行投票，票数最高的token流被选为最终输出流，并反馈到所有采样流中以确保同步。

集束投票采样需要并行运行多个采样过程，计算开销是单次采样的 N倍。在分布式生成中，可以将不同采样分配到不同GPU上，然后通过AllReduce进行投票。

核采样， 集成方法。

AI-A0-0239​

解码策略

Token领域

在生成过程中，通过调整概率分布，使生成文本的风格或内容符合特定要求。

引导生成 (Guided Generation)​

1. 定义引导函数：​ g(x,c)衡量token x在上下文 c下符合引导目标的程度（如情感、主题）。
2. 调整概率：​ P′(x)∝P(x)⋅exp(λ⋅g(x,c))，其中 λ是引导强度。
3. 重新归一化并采样。​

目的：​ 引导生成文本朝特定方向， 如积极情感、 特定主题等。
引导函数 g：​ 可由分类器、 判别器等提供。

概率调整， 引导控制。 通过外部信号调整概率分布，实现可控生成。

场景：​ 可控文本生成， 如情感控制、 主题控制。
特征：​ 引导函数， 强度参数， 概率缩放。

P(x)：​ 原始概率分布。
g(x,c)：​ 引导分数，标量。
λ：​ 引导强度，λ>0促进，λ<0抑制。
P′(x)：​ 调整后的概率。

指数加权：​ P′(x)∝P(x)⋅exp(λg(x,c))。
重新归一化。​

描述为“将原始概率乘以引导函数的指数权重，然后重新归一化，以引导生成符合特定目标的文本”。

1. 输入：原始概率 P(x)，引导函数 g(x,c)，强度 λ。
2. 对于每个token x，计算 P′(x)=P(x)⋅exp(λ⋅g(x,c))。
3. 归一化：P′′(x)=P′(x)/∑x′​P′(x′)。
4. 从 P′′中采样。​

“引导加权流”：​ 原始概率流 P(x)与引导分数流 exp(λg(x,c))相乘，得到调整后的概率流 P′(x)。引导分数流根据外部信号放大或缩小某些token的概率，从而引导生成流朝向期望的方向。

引导生成需要计算引导函数，可能引入额外模型（如分类器）的开销。在分布式生成中，引导函数可能需要跨GPU计算。

条件生成， 可控生成。

AI-A0-0240​

并行训练

PD分离领域

将数据分片到多个设备，每个设备持有完整的模型，独立计算梯度，然后同步梯度。

数据并行 (Data Parallelism)​

1. 复制模型：​ 每个设备拥有完整的模型副本。
2. 分割数据：​ 将全局批次划分为多个子批次，每个设备处理一个子批次。
3. 前向和反向：​ 每个设备独立计算前向传播和反向传播，得到本地梯度。
4. 梯度同步：​ 使用AllReduce操作（如求和）聚合所有设备的梯度，得到平均梯度。
5. 参数更新：​ 每个设备使用平均梯度更新其模型副本。

优点：​ 简单， 适用于模型能放入单个设备的情况。
通信开销：​ 梯度同步， 与参数量成正比。

分布式训练， 数据分割。 通过数据划分并行计算梯度，同步更新。

场景：​ 模型可放入单设备， 需要加速训练。
特征：​ 模型复制， 数据分割， 梯度同步。

N：​ 设备数。
B：​ 全局批次大小。
Bi​：​ 设备 i的子批次大小，B=∑i​Bi​。
gi​：​ 设备 i的梯度。
gˉ​：​ 平均梯度，gˉ​=N1​∑i​gi​。

划分：​ 数据划分。
平均：​ 梯度平均。

描述为“将模型复制到多个设备，每个设备处理一部分数据，计算梯度后同步平均梯度，然后各自更新参数”。

1. 将模型复制到每个设备。
2. 将当前批次数据划分到各设备。
3. 各设备独立前向-反向传播，计算本地梯度。
4. 使用AllReduce（求和）聚合梯度，然后每个设备除以 N得到平均梯度。
5. 各设备用平均梯度更新本地模型参数。
6. 重复。​

“数据分流，梯度合流”：​ 训练数据流被分割成多个子流，分别流入不同的设备。在每个设备上，完整的模型副本独立处理子流，产生局部梯度流。然后，所有局部梯度流通过通信网络汇合，聚合成全局平均梯度流。这个全局梯度流再分流到每个设备，用于更新本地模型副本，确保所有副本同步演进。

深度学习框架（如PyTorch的DistributedDataParallel）封装了数据并行。前向和反向传播在各设备上并行执行。梯度同步使用高效的All-Reduce原语（如NCCL）。通信开销与模型参数量成正比。

模型并行， 流水线并行， All-Reduce。

AI-A0-0241​

并行训练

PD分离领域

将模型的不同层分配到不同设备上，按层顺序计算，每层计算完成后将激活传递给下一层。

模型并行 (Model Parallelism)​

1. 垂直划分：​ 将模型按层划分，不同层放置在不同设备上。
2. 执行：​ 前向传播时，设备 i计算其拥有的层，将输出发送给设备 i+1；反向传播时，设备 i+1将梯度发送给设备 i。
3. 通信：​ 相邻设备间传递激活和梯度。

目标：​ 将模型分布到多个设备， 解决内存不足问题。
缺点：​ 设备利用率低， 串行执行。

模型并行， 层划分。 将模型的不同层放置在不同设备上，串行执行。

场景：​ 模型过大无法放入单个设备内存， 且层数较多时。
特征：​ 层划分， 串行执行， 设备间传递激活。

L：​ 总层数。
p：​ 设备数。
划分：​ 每台设备分配 L/p层。
激活：​ 层间传递的中间结果。

串行：​ 一次只有一个设备在计算。
通信：​ 相邻设备间点对点通信。

描述为“将模型的不同层放置在不同的设备上，前向传播时数据从一个设备流向下一个设备，每层计算完成后将激活传递给下一层，反向传播时梯度反向传递”。

1. 前向传播：
a. 设备1计算层1，输出激活 a1​，发送给设备2。
b. 设备2接收 a1​，计算层2，输出 a2​，发送给设备3。
c. 如此继续直到最后设备输出损失。
2. 反向传播：
a. 最后设备计算损失梯度，反向传播到其拥有的层，得到梯度并发送给前一设备。
b. 前一设备接收梯度，继续反向传播，如此继续直到设备1。
3. 参数更新：每个设备更新其拥有的参数。​

“层间流”：​ 数据流依次流经每个设备上的层流。每个设备上的层流处理完后，激活流被发送到下一个设备。反向传播时，梯度流反向流动。这种流是纯串行的，因此设备利用率低，大部分设备处于空闲状态。

模型并行（纯层并行）通信量相对较小（仅层间传递激活和梯度），但设备利用率低。通常与数据并行结合，形成混合并行。

流水线并行， 张量并行。

AI-A0-0242​

并行训练

PD分离领域

将模型按层划分到多个设备，并通过微批量和流水线调度提高设备利用率。

流水线并行 (Pipeline Parallelism)​

1. 模型划分：​ 将模型的 L层划分为 p个阶段（stage），每个阶段包含连续的若干层，放置在不同的设备上。
2. 微批量：​ 将每个训练批量划分为 m个微批量（micro-batch）。
3. 流水线调度：​ 使用如GPipe的调度：首先依次向流水线注入所有微批量（前向传播），然后依次进行反向传播。
4. 气泡：​ 流水线中存在设备空闲时间（气泡），通过增加微批量数量减少气泡比例。

目标：​ 将模型分布到多个设备， 解决单个设备内存不足问题， 提高设备利用率。
气泡开销：​ 与阶段数 p和微批量数 m有关， 气泡比例约为 mp−1​。

模型并行， 流水线。 将模型按层划分到多个设备，通过流水线执行提高设备利用率。

场景：​ 模型过大无法放入单个设备内存时。
特征：​ 层划分， 微批量， 流水线调度， 气泡。

p：​ 流水线阶段数。
m：​ 微批量数量。
L：​ 总层数。
阶段划分：​ 每个阶段包含 L/p层。
气泡：​ 设备空闲时间。

流水线：​ 多个微批量重叠执行。
气泡：​ 启动和排空流水线的时间。

描述为“将模型按层划分到多个设备上，将每个批量分成多个微批量，以流水线方式执行微批量的前向和反向传播，从而重叠不同设备上的计算”。

1. 前向传播（以GPipe为例）：
a. 设备1计算微批量1的前向，将激活发送给设备2。
b. 设备1计算微批量2的前向，同时设备2计算微批量1的前向，以此类推。
2. 反向传播：
a. 最后阶段计算微批量1的梯度，将梯度发送给前一阶段。
b. 最后阶段计算微批量2的梯度，同时前一阶段计算微批量1的梯度，以此类推。
3. 参数更新：所有微批量完成后，更新参数。​

“流水线流”：​ 数据流被分割为微批量流。这些微批量流依次进入流水线。每个设备（阶段）处理其对应的层流。当一个微批量流完成一个阶段后，其激活流被发送到下一个阶段，同时该阶段可以处理下一个微批量流。这样，多个微批量流在流水线中重叠流动，提高了设备利用率。然而，在流水线开始和结束时，会有气泡（空闲时间），因为并非所有阶段都同时工作。

流水线并行需要设备间通信传递激活和梯度。通信发生在相邻阶段之间。气泡开销可以通过增加微批量数量来减少。通常与数据并行结合，形成混合并行。

模型并行， 数据并行， 张量并行。

AI-A0-0243​

并行训练

PD分离领域

将模型的单个层内的参数和计算分割到多个设备上，通常按维度分割矩阵乘法。

张量并行 (Tensor Parallelism)​

1. 列并行：​ 将权重矩阵 W按列分割，W=[W1​,W2​]，输入 x广播，y=xW=x[W1​,W2​]=[xW1​,xW2​]，每个设备计算一部分，结果拼接。
2. 行并行：​ 将权重矩阵 W按行分割，W=[W1​;W2​]，输入 x按列分割 x=[x1​,x2​]，y=xW=[x1​,x2​][W1​;W2​]=x1​W1​+x2​W2​，每个设备计算部分和，然后求和。
3. 组合：​ 如Megatron-LM中，将FFN和注意力层的矩阵乘法按列或行分割。

目标：​ 将单个层的计算分布到多个设备， 减少每个设备的内存和计算负载。
通信：​ 需要设备间通信（如All-Reduce）来聚合结果。

模型并行， 矩阵分割。 将矩阵乘法按行或列分割到多个设备，通过通信组合结果。

场景：​ 单个层过大无法放入单个设备内存时， 如大型FFN层或注意力层。
特征：​ 矩阵分割， 按维度并行， 需要通信。

W：​ 权重矩阵，形状 (m,n)。
x：​ 输入向量或矩阵。
设备数：​ p。
分割维度：​ 按行或按列。

列分割：​ W按列分割，x广播，输出拼接。
行分割：​ W按行分割，x按列分割，输出求和。

描述为“将权重矩阵按行或列分割到多个设备上，每个设备计算部分结果，然后通过通信（如拼接或求和）得到完整输出”。

以列并行为例：
1. 将权重矩阵 W按列分割为 W1​,W2​,...,Wp​，每个设备存储一部分。
2. 输入 x广播到所有设备。
3. 每个设备计算 yi​=xWi​。
4. 通过All-Gather通信将所有 yi​拼接成完整输出 y=[y1​,y2​,...,yp​]。
以行并行为例：
1. 将权重矩阵 W按行分割为 W1​,W2​,...,Wp​，每个设备存储一部分。
2. 将输入 x按列分割为 x1​,x2​,...,xp​，每个设备获得一部分。
3. 每个设备计算 zi​=xi​Wi​。
4. 通过All-Reduce求和得到完整输出 y=∑i​zi​。​

“张量分割流”：​ 权重流 W被分割成多个子流 Wi​分布在不同设备上。输入流 x被广播或分割到各设备。每个设备独立计算局部流 yi​=xWi​或 zi​=xi​Wi​。然后通过通信流（All-Gather或All-Reduce）将局部流聚合成全局流 y。这种流将单个层的计算负载分散到多个设备，但引入了通信开销。

张量并行需要设备间通信，通信量较大。通常用于单个层非常大的情况，如Transformer的FFN层（dff​很大）。在多头注意力中，可以将不同头分布到不同设备上。

模型并行， 流水线并行， Megatron-LM。

AI-A0-0244​

并行训练

PD分离领域

一种优化器状态分区技术，将优化器状态、梯度和参数分区到多个设备上，以节省内存。

ZeRO (Zero Redundancy Optimizer)​

1. ZeRO-DP：​ 数据并行，但将优化器状态、梯度和参数分区到多个GPU上，每个GPU只存储一部分。
2. ZeRO-1：​ 仅分区优化器状态，每个GPU存储全部参数和梯度，但只存储一部分优化器状态（如Adam的动量、方差）。
3. ZeRO-2：​ 分区优化器状态和梯度，每个GPU存储全部参数，但只存储一部分梯度和优化器状态。
4. ZeRO-3：​ 分区优化器状态、梯度和参数，每个GPU只存储一部分参数、梯度和优化器状态，需要时从其他GPU获取。

目标：​ 减少数据并行中的内存冗余， 允许训练更大模型。
通信：​ ZeRO-3 需要在前向/反向传播时收集参数， 增加通信开销。

数据并行， 内存优化。 通过分区优化器状态、梯度和参数，消除数据并行中的内存冗余。

场景：​ 训练极大模型， 如万亿参数模型， 内存受限。
特征：​ 状态分区， 通信换内存， 可扩展性。

N：​ GPU数量。
优化器状态：​ 如Adam的 m（一阶矩）和 v（二阶矩）。
分区：​ 将状态、梯度、参数按维度分割到 N个GPU上。

分区：​ 将张量沿某个维度分割。
收集：​ 需要时通过All-Gather收集完整张量。

描述为“在数据并行中，将优化器状态、梯度和参数分区到多个GPU上，每个GPU只负责更新和存储其中一部分，从而大幅减少每个GPU的内存占用”。

以ZeRO-3为例：
1. 参数分区：模型参数 W被分区到 N个GPU上，每个GPU存储 Wi​。
2. 前向传播：需要完整参数时，通过All-Gather从所有GPU收集 W，计算后释放其他GPU的参数。
3. 反向传播：同样通过All-Gather收集参数计算梯度，梯度被分区存储。
4. 优化器更新：每个GPU更新其负责的参数分区 Wi​，以及对应的梯度分区和优化器状态分区。​

“分区流”：​ 参数流 W被分割成多个子流 Wi​分布在不同GPU上。在前向流中，通过All-Gather通信流将 Wi​聚合成完整参数流 W用于计算，然后释放非本地部分。梯度流同样被分区存储。优化器状态流（如动量）也被分区。更新流只在每个GPU本地进行。这大大减少了每个GPU的内存占用，但增加了通信开销。

ZeRO-3 需要在前向和反向传播时进行All-Gather收集参数，通信开销较大。ZeRO-2 只需要在梯度更新时通信。ZeRO-1 通信开销最小。通常与数据并行结合使用。

数据并行， 模型并行， 内存优化。

AI-A0-0245​

并行训练

PD分离领域

一种混合并行策略，结合数据并行、流水线并行和张量并行，以训练极大模型。

3D并行 (3D Parallelism)​

1. 数据并行 (DP)：​ 复制整个模型到多个设备，数据分片。
2. 流水线并行 (PP)：​ 将模型按层划分到多个设备，微批量流水线执行。
3. 张量并行 (TP)：​ 将单个层内的矩阵计算划分到多个设备。
4. 组合：​ 同时使用这三种并行维度，形成三维并行网格。例如，在Megatron-DeepSpeed中，使用TP在节点内，PP跨节点，DP跨流水线组。

目标：​ 最大化模型规模和训练效率， 适应超大规模模型训练。
设计：​ 需要仔细平衡通信和计算。

混合并行， 三维并行。 结合数据、流水线和张量并行，实现极大规模模型训练。

场景：​ 训练千亿、万亿参数模型， 如Megatron-Turing NLG。
特征：​ 三种并行维度组合， 高可扩展性。

DP degree：​ 数据并行度。
PP degree：​ 流水线并行度。
TP degree：​ 张量并行度。
总设备数：​ N=DP×PP×TP。

乘积：​ 总设备数为三个维度的乘积。
组合：​ 不同并行策略协同工作。

描述为“同时使用数据并行、流水线并行和张量并行，将模型分布到大量设备上，以训练超大规模模型”。

1. 将设备组织成三维网格：DP、PP、TP。
2. 张量并行在TP维度的设备组内进行，将单个层拆分。
3. 流水线并行在PP维度的设备组间进行，将模型层按阶段划分。
4. 数据并行在DP维度的设备组间进行，每个组处理不同的数据子集。
5. 训练时，微批量在流水线中流动，每个流水线阶段内使用张量并行计算，多个流水线副本进行数据并行。​

“三维并行流”：​ 数据流在DP维度上被复制多份，每个副本处理不同的数据子流。每个数据副本的模型被切分成多个阶段流（PP维度），每个阶段流在TP维度上进一步切分成多个设备流。计算流在TP组内进行张量并行计算，在PP组间进行流水线传递，在DP组间独立进行。梯度流在DP组内进行All-Reduce，在TP组内进行All-Reduce，在PP组间反向传递。

3D并行需要复杂的通信模式。TP需要组内All-Reduce，PP需要相邻阶段间点对点通信，DP需要跨组All-Reduce。通信优化至关重要。

Megatron-LM， DeepSpeed， ZeRO。

AI-A0-0246​

并行训练

PD分离领域

一种异步数据并行方法，每个设备独立计算梯度并异步更新中央参数服务器，无需等待同步。

异步数据并行 (Asynchronous Data Parallelism)​

1. 参数服务器：​ 维护全局参数 W。
2. 工作者：​ 每个工作者拥有本地模型副本，从参数服务器拉取最新参数，处理一个批次，计算梯度，然后将梯度推送到参数服务器。
3. 异步更新：​ 参数服务器收到梯度后立即更新全局参数，不等待其他工作者。
4. 冲突：​ 由于异步，不同工作者的梯度可能基于不同版本的参数，导致更新冲突。

优点：​ 无需同步等待， 设备利用率高。
缺点：​ 梯度陈旧（stale gradient）， 可能收敛不稳定。

异步并行， 参数服务器。 通过异步更新全局参数，避免同步开销。

场景：​ 大规模分布式训练， 通信带宽受限， 对收敛精度要求不高时。
特征：​ 异步， 参数服务器， 梯度陈旧。

W：​ 全局参数。
Wi​：​ 工作者 i的本地参数。
gi​：​ 工作者 i计算的梯度。
α：​ 学习率。

异步更新：​ W←W−αgi​，当收到梯度时立即更新。

描述为“多个工作者异步地从参数服务器拉取参数，计算梯度后推送更新，参数服务器立即应用更新，不等待其他工作者”。

1. 初始化全局参数 W。
2. 每个工作者循环：
a. 从参数服务器拉取当前参数 Wcurrent​。
b. 用本地数据计算梯度 g。
c. 将梯度 g推送到参数服务器。
3. 参数服务器循环：
a. 收到梯度 g后，更新 W←W−αg。
4. 重复直到收敛。​

“异步流”：​ 参数流 W存储在参数服务器中。工作者流异步地拉取参数流，计算梯度流，然后推送更新流。参数服务器流立即应用更新流，导致参数流被多个工作者流交错更新，可能产生冲突。梯度流可能基于过时的参数流，导致更新方向不一致。

异步数据并行中，每个工作者可以独立运行，无需同步，因此可扩展性好。但梯度陈旧可能影响收敛。需要处理参数版本冲突，如使用延迟更新补偿。

同步数据并行， 参数服务器。

AI-A0-0247​

并行训练

PD分离领域

一种同步数据并行方法，使用All-Reduce同步梯度，所有设备同步更新。

同步数据并行 (Synchronous Data Parallelism)​

1. 复制模型：​ 每个设备拥有完整的模型副本。
2. 数据分割：​ 将批次数据分割到各设备。
3. 同步计算梯度：​ 各设备同时计算本地梯度，然后通过All-Reduce（求和）同步梯度，得到平均梯度。
4. 同步更新：​ 所有设备使用平均梯度同时更新参数。

优点：​ 梯度准确， 收敛稳定。
缺点：​ 需要等待最慢的设备（同步屏障）。

同步并行， All-Reduce。 通过全局同步梯度，确保所有设备使用相同的梯度更新。

场景：​ 大多数数据并行训练， 如使用DistributedDataParallel。
特征：​ 同步， All-Reduce， 梯度平均。

N：​ 设备数。
gi​：​ 设备 i的梯度。
gˉ​：​ 平均梯度，gˉ​=N1​∑i​gi​。

平均：​ 梯度平均。
同步：​ 所有设备同时更新。

描述为“所有设备同步计算梯度，然后通过All-Reduce计算平均梯度，最后所有设备使用平均梯度更新参数”。

1. 将模型复制到每个设备。
2. 将批次数据划分到各设备。
3. 各设备同时前向-反向传播，计算本地梯度。
4. 使用All-Reduce（求和）聚合所有梯度，然后每个设备除以 N得到平均梯度。
5. 所有设备用平均梯度更新本地参数。
6. 重复。​

“同步流”：​ 数据流被分割到多个设备流。每个设备流独立计算梯度流，然后通过All-Reduce通信流聚合成平均梯度流。所有设备流同步等待通信完成，然后使用相同的平均梯度流更新本地参数流。这保证了参数流的一致性，但速度受限于最慢的设备流。

同步数据并行使用All-Reduce进行梯度同步，通信开销与参数量成正比。在GPU集群中，使用NCCL库进行高效的All-Reduce。

异步数据并行， All-Reduce。

AI-A0-0248​

并行训练

PD分离领域

一种梯度压缩方法，在通信前对梯度进行量化，减少通信量。

梯度量化 (Gradient Quantization)​

1. 量化：​ 将梯度从32位浮点数量化为低位表示，如8位整数。例如，对梯度 g，计算最大值 gmax​和最小值 gmin​，然后线性量化：gquant​=round(gmax​−gmin​g−gmin​​⋅(2b−1))，其中 b是量化位数（如8）。
2. 通信：​ 传输量化后的梯度 gquant​以及 gmin​和 gmax​。
3. 反量化：​ 接收方进行反量化：g′=gmin​+2b−1gquant​​⋅(gmax​−gmin​)。
4. 使用反量化后的梯度进行更新。​

目的：​ 减少梯度通信带宽， 加速分布式训练。
量化位数 b：​ 通常8位， 也可1位（符号SGD）。

通信压缩， 量化。 通过降低梯度精度减少通信量。

场景：​ 分布式训练， 通信带宽受限时。
特征：​ 梯度量化， 减少通信量， 可能引入误差。

g：​ 原始梯度，浮点数。
b：​ 量化位数。
gmin​,gmax​：​ 梯度最小最大值。
gquant​：​ 量化后的整数。

线性量化：​ 将浮点数映射到整数区间。
反量化：​ 整数映射回浮点数。

描述为“将梯度量化为低比特整数进行通信，接收方再反量化为浮点数，以减少通信量”。

1. 计算梯度 g。
2. 计算 gmin​和 gmax​（可基于整个梯度张量或每层单独）。
3. 量化：gquant​=round(gmax​−gmin​g−gmin​​⋅(2b−1))。
4. 通信 gquant​、gmin​、gmax​。
5. 接收方反量化得到 g′。
6. 使用 g′进行后续更新。​

“量化压缩流”：​ 梯度流 g被量化为低比特流 gquant​，同时额外传输范围流 gmin​和 gmax​。通信流传输压缩后的数据流。接收方通过反量化流恢复出近似梯度流 g′。量化流引入了误差，但大幅减少了通信流量。

梯度量化可以将通信量减少为原来的 b/32（如8位量化减少4倍）。在All-Reduce中，需要对量化后的梯度进行通信。多GPU中，每个GPU独立量化，然后通信，最后反量化。

梯度稀疏化， 通信压缩。

AI-A0-0249​

并行训练

PD分离领域

一种梯度压缩方法，只通信绝对值大的梯度（超过阈值），减少通信量。

梯度稀疏化 (Gradient Sparsification)​

1. 选择重要梯度：​ 根据梯度绝对值选择前 k% 的梯度（或超过阈值 τ的梯度）进行通信，其余梯度置零。
2. 通信：​ 只通信非零梯度及其索引。
3. 恢复：​ 接收方根据索引恢复稀疏梯度矩阵。
4. 使用稀疏梯度进行更新， 或与本地梯度累积结合。​

目的：​ 通过只通信重要梯度减少通信量。
稀疏率：​ 通常1%~10%。

通信压缩， 稀疏化。 通过只通信部分梯度减少通信量。

场景：​ 分布式训练， 梯度稀疏时。
特征：​ 梯度选择， 稀疏通信， 误差补偿。

g：​ 原始梯度。
k：​ 保留比例（如1%）。
τ：​ 阈值。
gsparse​：​ 稀疏梯度，只有重要梯度非零。

Top-k选择：​ 保留绝对值最大的 k% 梯度。
索引通信：​ 通信非零梯度的值和索引。

描述为“只选择绝对值最大的部分梯度进行通信，其余梯度不通信，从而减少通信量”。

1. 计算梯度 g。
2. 根据绝对值选择前 k% 的梯度，得到掩码 m（非零位置为1）。
3. 稀疏梯度 gsparse​=g⊙m。
4. 通信 gsparse​的非零值和索引。
5. 接收方恢复稀疏梯度。
6. 使用稀疏梯度更新，或将未通信的梯度累积到本地（误差补偿）。​

“稀疏化流”：​ 梯度流 g经过选择器，只保留重要梯度流，形成稀疏梯度流 gsparse​。通信流只传输非零值和索引流。接收方重建稀疏梯度流。为了减少误差，未传输的梯度流可以被累积到本地，在后续步骤中补偿。

梯度稀疏化可以大幅减少通信量，尤其当梯度稀疏时。在All-Reduce中，需要通信稀疏矩阵，可以使用专门的稀疏All-Reduce算法。

梯度量化， 通信压缩。

AI-A0-0250​

并行训练

PD分离领域

一种通信压缩方法，将多个小梯度打包成一个大的消息进行通信，减少通信次数。

梯度打包 (Gradient Packing)​

1. 打包：​ 将多个小张量（如每层的梯度）拼接成一个大张量。
2. 通信：​ 一次性通信这个大张量。
3. 解包：​ 接收方将大张量拆分成原始的小张量。
4. 目的：​ 减少通信次数， 提高带宽利用率。

优点：​ 减少通信启动开销， 提高带宽利用率。
注意：​ 需要所有张量类型一致。

通信优化， 打包。 通过合并多个小张量通信减少通信次数。

场景：​ 分布式训练， 梯度由多个小张量组成时。
特征：​ 张量拼接， 批量通信。

g1​,g2​,...,gn​：​ 各层的梯度张量。
G：​ 打包后的大张量，G=concat(g1​,g2​,...,gn​)。

拼接：​ G=[g1​,g2​,...,gn​]。
拆分：​ 接收方按原形状拆分。

描述为“将多个梯度张量拼接成一个大张量进行通信，以减少通信次数”。

1. 前向和反向传播后，得到各层梯度 gi​。
2. 将所有梯度 gi​拼接成一个大张量 G。
3. 通信 G（如All-Reduce）。
4. 接收方将 G拆分成原始的 gi​。
5. 使用 gi​更新参数。​

“打包流”：​ 多个小梯度流 gi​被拼接成一个大梯度流 G。通信流传输 G，然后接收方拆分成原始流。这减少了通信次数，提高了带宽利用率。

梯度打包通常由深度学习框架自动完成（如PyTorch的DistributedDataParallel会将所有梯度拼接成一个张量进行All-Reduce）。

All-Reduce， 通信优化。

AI-A0-0251​

并行训练

PD分离领域

一种重叠通信和计算的技术，在计算梯度的同时通信已计算好的梯度。

梯度通信重叠 (Gradient Communication Overlapping)​

1. 流水线：​ 在反向传播过程中，一旦某一层的梯度计算完成，立即开始通信该层的梯度，同时继续计算后面层的梯度。
2. 实现：​ 使用异步通信操作（如非阻塞All-Reduce）与计算重叠。
3. 同步：​ 在更新参数前，确保所有梯度通信完成。

目的：​ 隐藏通信延迟， 加速训练。
重叠程度：​ 取决于计算和通信时间的比例。

通信计算重叠， 流水线。 通过重叠梯度通信和梯度计算，隐藏通信延迟。

场景：​ 分布式训练， 通信开销较大时。
特征：​ 非阻塞通信， 计算通信重叠。

反向传播顺序：​ 从输出层到输入层。
通信操作：​ 非阻塞All-Reduce。

重叠：​ 通信和计算同时进行。
同步点：​ 更新参数前同步所有通信。

描述为“在反向传播中，一旦某层的梯度可用，就立即开始通信该层的梯度，同时继续计算其他层的梯度，从而重叠通信和计算”。

1. 反向传播开始。
2. 对于每一层 l从最后一层到第一层：
a. 计算该层的梯度 gl​。
b. 启动非阻塞All-Reduce通信 gl​（不等待完成）。
c. 继续计算下一层 l−1的梯度。
3. 当所有层梯度计算完成且通信完成后，更新参数。​

“重叠流”：​ 梯度计算流和梯度通信流并行进行。一旦一层梯度计算流产生，立即启动通信流，同时计算流继续流向下一层。这样，通信流和计算流在时间上重叠，减少了总时间。

梯度通信重叠需要非阻塞通信原语。在数据并行中，可以对每层梯度分别进行All-Reduce。通信可能需要额外的内存缓冲区。

流水线并行， 计算通信重叠。

AI-A0-0252​

并行训练

PD分离领域

一种内存优化技术，在训练中只保存部分中间激活值，在反向传播时重新计算其他激活。

激活检查点 (Activation Checkpointing)​

1. 分段：​ 将模型分成若干段（checkpoint segments）。
2. 前向传播：​ 只保存每段的输入和输出（检查点），不保存中间激活值。
3. 反向传播：​ 当计算梯度时，从最近的检查点开始重新运行前向传播以计算该段所需的中间激活值，然后计算梯度并释放这些激活值。

节省内存：​ 内存占用从 O(L)降低到 O(L​)或 O(logL)， 其中 L是层数。
计算开销：​ 增加约30%的前向计算。

内存-计算权衡。 通过重计算中间激活来减少内存占用。

场景：​ 训练极深模型， 内存受限时。
特征：​ 分段检查点， 重计算激活， 时间换空间。

模型分段：​ 将模型分为 k段。
检查点：​ 每段的输入和输出。
中间激活：​ 前向传播中的中间结果，通常不保存。

重计算：​ 从检查点重新运行前向传播。
内存节省：​ 与分段数 k有关。

描述为“将模型分成若干段，在前向传播时只保存每段的输入和输出作为检查点，在反向传播时根据需要从检查点重新计算中间激活，从而节省内存”。

1. 将模型划分为 k个段：[segment1​,segment2​,...,segmentk​]。
2. 前向传播：
a. 对于每个段 i，输入 xi​（来自上一段的输出或初始输入）。
b. 计算段输出 yi​=segmenti​(xi​)。
c. 保存检查点 (xi​,yi​)，丢弃段内中间激活。
3. 反向传播（从最后一段开始）：
a. 对于段 i从 k到 1：
i. 从检查点加载 xi​和 yi​。
ii. 重新运行段 i的前向传播，保存中间激活。
iii. 使用中间激活计算段 i的梯度。
iv. 将梯度传播到段 i−1的输入。
v. 丢弃中间激活。​

“检查点-重计算”流：​ 前向流经过模型分段，每段的输入流 xi​和输出流 yi​被保存为检查点流，而段内的中间激活流被丢弃。在反向流中，从最后一段开始，加载检查点流 xi​和 yi​，重新执行该段的前向流以生成中间激活流，然后计算梯度流。梯度流传播后，中间激活流被释放。这种流以额外的计算流为代价，减少了内存中需要同时保存的激活流数量。

激活检查点可以在单个GPU上实施，也可以与数据并行结合。在模型并行中，检查点可以设置在设备边界。重计算会增加计算时间，但允许训练更大的模型或更大的批量。

重计算， 内存优化， 梯度检查点。

AI-A0-0253​

并行训练

PD分离领域

一种混合精度训练方法，使用半精度（FP16）进行前向和反向传播，同时保留单精度（FP32）主权重副本。

混合精度训练 (Mixed Precision Training)​

1. 维护FP32主权重：​ θfp32​。
2. 前向传播：​ 将 θfp32​转换为FP16得到 θfp16​，使用 θfp16​和FP16输入进行计算，得到FP16损失。
3. 反向传播：​ 在FP16下计算梯度 gfp16​。
4. 梯度转换：​ 将 gfp16​转换为FP32得到 gfp32​。
5. 更新主权重：​ 使用 gfp32​和优化器（如Adam）更新 θfp32​。
6. 梯度缩放：​ 为防止梯度下溢，在反向传播前对损失乘以缩放因子 S（如1024），计算梯度后再除以 S。

优点：​ 加速计算， 减少内存占用， 保持数值稳定性。
缩放因子 S：​ 动态或静态， 如 210。

数值计算， 精度。 利用FP16加速计算，用FP32保持数值范围，通过梯度缩放防止下溢。

场景：​ 训练大型神经网络， 如Transformer， 需要加速和节省内存。
特征：​ FP16计算， FP32主权重， 梯度缩放。

θfp32​：​ FP32主权重。
θfp16​：​ FP16副本权重。
gfp16​：​ FP16梯度。
gfp32​：​ FP32梯度。
S：​ 梯度缩放因子。
α：​ 学习率。

精度转换：​ FP32 ↔ FP16。
梯度缩放：​ 损失乘以 S，梯度除以 S。

描述为“使用半精度进行前向和反向传播以加速计算并节省内存，同时保留单精度主权重副本用于更新，并通过梯度缩放防止梯度下溢”。

1. 将FP32主权重 θfp32​复制为FP16权重 θfp16​。
2. 前向传播：使用 θfp16​和FP16输入计算损失 Lfp16​。
3. 梯度缩放：计算缩放损失 Lscaled​=S⋅Lfp16​。
4. 反向传播：计算 Lscaled​对 θfp16​的梯度 gfp16​。
5. 梯度反缩放：gfp16​=gfp16​/S。
6. 将梯度转换为FP32：gfp32​=float32(gfp16​)。
7. 使用 gfp32​更新FP32主权重 θfp32​。
8. 重复。​

“精度混合流”：​ 权重流 θ以FP32格式存储（主权重流）。在前向流中，权重流被转换为FP16流 θfp16​，与FP16输入流进行运算，产生FP16激活流和损失流。损失流被缩放因子 S放大，以保留梯度信息。反向流计算FP16梯度流 gfp16​，然后反缩放并转换为FP32梯度流 gfp32​，最后用于更新FP32主权重流。这种流在计算密集型部分使用FP16加速，在权重更新时使用FP32保持精度。

混合精度训练需要GPU支持FP16计算（如Tensor Cores）。在数据并行中，每个GPU进行本地FP16前向/反向传播，梯度在FP32下进行All-Reduce。梯度缩放可以动态调整（如根据梯度范数）。

FP16， 梯度缩放， 数值稳定性。

AI-A0-0254​

并行训练

PD分离领域

一种半精度浮点数格式，比FP16具有更大的动态范围，更适合深度学习训练。

BFloat16 (Brain Floating Point 16)​

1. 格式：​ 1位符号位，8位指数位，7位尾数位（而FP16是1位符号，5位指数，10位尾数）。
2. 动态范围：​ 与FP32（8位指数）相同，但精度（尾数）较低。
3. 使用：​ 直接用于存储权重、激活和梯度，无需复杂的梯度缩放，因为其动态范围大，不易出现下溢/溢出。

优点：​ 动态范围大， 与FP32指数位相同， 训练更稳定， 简化混合精度训练流程。
缺点：​ 精度比FP16低（尾数位少）。

数值格式， 浮点数。 提供与FP32相同的指数范围，但使用16位存储，平衡范围和精度。

场景：​ 训练大型模型， 如Transformer， 在TPU和现代GPU上使用。
特征：​ 8位指数， 7位尾数， 大动态范围。

符号位：​ 1 bit。
指数位：​ 8 bits。
尾数位：​ 7 bits。
总位数：​ 16 bits。

指数范围：​ 与FP32相同（2−126到 2127）。
精度：​ 约2位十进制数字。

描述为“一种16位浮点数格式，具有与32位浮点数相同的指数范围，但尾数精度较低，适用于深度学习训练”。

1. 将权重、激活、梯度存储为BFloat16格式。
2. 前向传播和反向传播使用BFloat16计算。
3. 优化器状态（如动量）可能仍使用FP32，但权重更新可以使用BFloat16梯度。
4. 由于动态范围大，通常不需要梯度缩放。​

“大范围半精度”流：​ BFloat16数据流具有与FP32相同的指数范围，因此可以表示非常小和非常大的数，避免了FP16中容易出现的梯度下溢（值太小变为0）和溢出（值太大变为inf）问题。这使得BFloat16流可以直接用于训练，无需复杂的梯度缩放，简化了混合精度训练流程。计算流在BFloat16下进行，速度与FP16相当，但稳定性更好。

BFloat16得到现代AI加速器（如TPU、NVIDIA Ampere GPU）原生支持。在混合精度训练中，可以使用BFloat16代替FP16，简化流程。在多GPU中，通信可以使用BFloat16减少带宽。

FP16， FP32， 混合精度训练。

AI-A0-0255​

并行训练

PD分离领域

一种优化器，将权重衰减与参数更新解耦，直接添加到更新步骤中。

AdamW​

1. 计算梯度：​ gt​=∇θ​L(θt−1​)（不包含权重衰减项）。
2. 更新一阶矩和二阶矩：​ 同Adam：mt​=β1​mt−1​+(1−β1​)gt​, vt​=β2​vt−1​+(1−β2​)gt2​。
3. 偏差校正：​ m^t​=mt​/(1−β1t​), v^t​=vt​/(1−β2t​)。
4. 参数更新：​ θt​=θt−1​−α(v^t​​+ϵm^t​​+λθt−1​)，其中 λ是权重衰减系数。

优点：​ 权重衰减与自适应学习率解耦， 通常比Adam泛化更好。
解耦：​ 权重衰减项 λθ直接加到更新中。

自适应优化， 权重衰减。 将权重衰减从损失函数中分离，直接应用于参数更新，避免与自适应学习率耦合。

场景：​ 训练大型模型如Transformer， 需要权重衰减正则化。
特征：​ 解耦权重衰减， 更新公式包含显式权重衰减项。

θ：​ 参数。
λ：​ 权重衰减系数。
其他同Adam。​

加法项：​ 更新中直接加 λθ。
解耦：​ 权重衰减独立于梯度计算。

描述为“在Adam更新公式中，额外添加一个权重衰减项，直接作用于参数，而不是通过损失函数”。

1. 计算梯度 gt​（不包含权重衰减）。
2. 更新一阶矩 mt​和二阶矩 vt​同Adam。
3. 计算校正后矩 m^t​,v^t​。
4. 更新参数：θt​=θt−1​−α(v^t​​+ϵm^t​​+λθt−1​)。​

“解耦正则化”流：​ 在AdamW中，权重衰减流 λθ直接与自适应更新流 αm^t​/(v^t​​+ϵ)相加。这与传统Adam（权重衰减通过损失函数影响梯度）不同，避免了权重衰减与自适应学习率之间的耦合，使得正则化效果更稳定，模型泛化更好。

与Adam类似，但更新步骤中多了一项权重衰减。权重衰减项可以本地计算，无需额外通信。在多GPU数据并行中，每个GPU独立计算权重衰减项并更新本地参数副本。

Adam， 权重衰减， L2正则化。

AI-A0-0256​

并行训练

PD分离领域

一种学习率调度策略，学习率在训练过程中按余弦函数从初始值衰减到最小值。

余弦退火 (Cosine Annealing)​

1. 学习率公式：​ ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(Tmax​Tcur​​π))，其中 Tcur​是当前步数，Tmax​是总步数（或周期长度）。
2. 变化：​ 学习率从 ηmax​开始，按余弦函数平滑下降到 ηmin​。

特点：​ 平滑下降， 避免学习率突变， 有助于模型收敛到更优解。
超参数：​ ηmax​, ηmin​, Tmax​。

学习率调度， 余弦函数。 使用余弦函数平滑调整学习率。

场景：​ 深度学习训练， 如图像分类、自然语言处理。
特征：​ 余弦曲线， 平滑衰减， 可周期性重启。

ηt​：​ 当前学习率。
ηmax​：​ 最大学习率。
ηmin​：​ 最小学习率。
Tcur​：​ 当前步数。
Tmax​：​ 总步数或周期长度。

余弦函数：​ cos(πTcur​/Tmax​)。
线性变换：​ 映射到 [ηmin​,ηmax​]。

描述为“学习率按余弦函数从最大值平滑衰减到最小值”。

1. 设置最大学习率 ηmax​、最小学习率 ηmin​、总步数 Tmax​。
2. 对于每个训练步 t（Tcur​=t）：
a. 计算学习率 ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(πt/Tmax​))。
b. 使用 ηt​更新参数。
3. 当 t=Tmax​时，可停止或重启（带热重启）。​

“余弦衰减”流：​ 学习率流 ηt​随时间 t按余弦曲线从 ηmax​平滑下降到 ηmin​。这种平滑下降避免了阶梯式下降的突变，允许模型在初期以较大学习率快速收敛，后期以较小学习率精细调整，有助于找到更平坦的最小值。

学习率调度器在训练循环中每一步更新学习率。在多GPU训练中，通常由主进程计算学习率并广播，或每个进程独立计算相同值。

带热重启的余弦退火， 学习率调度。

AI-A0-0257​

并行训练

PD分离领域

一种学习率调度策略，学习率在指定步数或epoch处乘以一个衰减因子。

步长衰减 (Step Decay)​

1. 定义：​ 学习率在预定义的步数或epoch处衰减。例如，每 s步将学习率乘以 γ（如0.1）。
2. 公式：​ ηt​=η0​⋅γ⌊t/s⌋，其中 η0​是初始学习率，s是步长，γ是衰减因子。
3. 也可基于epoch：​ 每 k个epoch衰减一次。

特点：​ 简单， 常用， 但衰减可能过于激进。
超参数：​ 初始学习率 η0​， 衰减因子 γ， 步长 s。

学习率调度， 指数衰减。 按固定步长降低学习率。

场景：​ 各种深度学习任务， 尤其是训练收敛后期。
特征：​ 阶梯式下降， 预定义衰减点。

ηt​：​ 当前学习率。
η0​：​ 初始学习率。
γ：​ 衰减因子（0<γ<1）。
s：​ 衰减步长（多少步衰减一次）。
t：​ 当前步数。

指数衰减：​ ηt​=η0​γ⌊t/s⌋。
阶梯函数：​ 每隔 s步变化。

描述为“每经过固定的步数，学习率乘以一个小于1的衰减因子，呈阶梯式下降”。

1. 设置初始学习率 η0​，衰减因子 γ，步长 s。
2. 对于每个训练步 t：
a. 计算当前衰减次数 k=⌊t/s⌋。
b. 学习率 ηt​=η0​⋅γk。
c. 使用 ηt​更新参数。
3. 重复直到训练结束。​

“阶梯下降”流：​ 学习率流 ηt​在大多数时间保持恒定，每经过 s步就突然下降为原来的 γ倍。这种离散的下降允许模型在某个学习率下稳定训练一段时间，然后进入更精细的调整阶段。

实现简单，只需在训练循环中检查当前步数是否达到衰减点。在多GPU中，学习率值需要同步。

指数衰减， 学习率调度。

AI-A0-0258​

并行训练

PD分离领域

一种学习率调度策略，学习率随训练步数线性增加，然后线性或余弦衰减。

带热重启的余弦退火 (Cosine Annealing with Warm Restarts)​

1. 周期：​ 训练分为多个周期，每个周期内学习率按余弦函数从初始值衰减到最小值。
2. 公式：​ ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(Ti​Tcur​​π))，其中 Tcur​是当前周期内的步数，Ti​是当前周期的总步数。
3. 重启：​ 每个周期结束时，学习率重置为 ηmax​，并可能增加周期长度。

优点：​ 周期性重启有助于跳出局部最优， 提高模型性能。
超参数：​ ηmax​, ηmin​, Ti​（周期长度）。

学习率调度， 周期性重启。 通过余弦衰减和周期性重启来调整学习率。

场景：​ 训练深度神经网络， 尤其是图像分类和自然语言处理。
特征：​ 余弦衰减， 周期性重启， 学习率先增后减。

ηt​：​ 当前学习率。
ηmax​：​ 周期内最大学习率。
ηmin​：​ 周期内最小学习率。
Tcur​：​ 当前周期内已执行步数。
Ti​：​ 当前周期的总步数。

余弦函数：​ 学习率按余弦变化。
周期性：​ 周期结束后重启。

描述为“学习率在每个周期内按余弦函数从最大值衰减到最小值，周期结束后重启到最大值，并可能延长周期”。

1. 初始化周期长度 Ti​，最大学习率 ηmax​，最小学习率 ηmin​。
2. 每个训练步 t，计算当前周期内步数 Tcur​。
3. 计算学习率 ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(πTcur​/Ti​))。
4. 如果 Tcur​=Ti​，则重启：Tcur​=0，可选地增加 Ti​（如乘以因子）。​

“余弦振荡”流：​ 学习率流在每个周期内遵循余弦曲线，从高点 ηmax​平滑下降到低点 ηmin​。这种下降允许模型在初期快速收敛，后期精细调整。周期结束时，学习率流突然跳回高点（重启），模拟“重启”训练，有助于模型跳出可能的局部最优点，探索新的区域。

学习率调度器在训练循环中每一步更新学习率。在多GPU训练中，通常由主进程（rank 0）计算学习率并广播给所有进程，或每个进程独立计算相同值。

余弦退火， 学习率调度， 热重启。

AI-A0-0259​

并行训练

PD分离领域

一种优化技巧，在多个小批量上累积梯度，然后一次性更新参数，模拟更大的批量大小。

梯度累积 (Gradient Accumulation)​

1. 过程：​ 对于 N个连续的小批量（micro-batch），每次前向传播后计算梯度，但不立即更新参数，而是将梯度累加到累积变量中。
2. 更新：​ 每累积 N个小批量后，用累积梯度除以 N（可选，用于平均）更新参数，然后清零累积梯度。
3. 数学：​ 设第 i个小批量的梯度为 gi​，累积梯度 G=∑i=1N​gi​。更新参数 θ=θ−α⋅NG​（如果取平均）。

目的：​ 在内存有限时模拟大批量训练， 稳定训练， 允许使用更大的有效批量大小。
N：​ 累积步数， 如4、8、16。

优化技巧， 内存效率。 通过多次前向-反向传播累积梯度，实现更大的有效批量大小。

场景：​ 当GPU内存不足以容纳大批量时， 训练大模型。
特征：​ 梯度累加， 延迟更新， 模拟大批量。

gi​：​ 第 i个小批量的梯度。
G：​ 累积梯度。
N：​ 累积步数。
α：​ 学习率。
θ：​ 模型参数。

累加：​ G=∑i=1N​gi​。
平均：​ 可选除以 N。

描述为“在多个小批量上重复前向和反向传播，累积梯度但不更新参数，累积一定步数后，用累积梯度（或平均梯度）更新一次参数”。

1. 初始化累积梯度 G=0，计数器 count=0。
2. 对于每个小批量 xi​：
a. 前向传播计算损失 Li​。
b. 反向传播计算梯度 gi​。
c. 累积梯度 G=G+gi​。
d. count=count+1。
e. 如果 count==N：
i. 更新参数 θ=θ−α⋅(G/N)（或直接使用 G）。
ii. 重置 G=0,count=0。
3. 重复直到训练完成。​

“梯度缓冲”流：​ 在标准训练中，梯度流 gi​产生后立即用于更新参数流 θ。在梯度累积中，梯度流被暂时存储到累积缓冲区 G中。经过 N个小批量，N个梯度流汇合成一个累积梯度流 G。然后这个累积流被用于更新参数流，模拟了一个批量大小为 N×micro-batch size的更新。这允许在有限内存下使用更大的有效批量。

梯度累积在单个GPU或数据并行中均可使用。每个GPU独立计算本地梯度并累积。在数据并行中，如果使用梯度平均，需要在累积 N步后对所有GPU的累积梯度进行AllReduce，然后更新参数。

批量大小， 优化器。

AI-A0-0260​

并行训练

PD分离领域

一种优化技巧，限制梯度范数，防止梯度爆炸。

梯度裁剪 (Gradient Clipping)

AI-A0-0260​

优化技巧

PD分离领域

在训练过程中限制梯度范数，防止梯度爆炸。

梯度裁剪 (Gradient Clipping)​

1. 计算梯度范数：​ g=∇θ​L，总梯度范数 $

g

_2 = \sqrt{\sum_i g_i^2}。<br>∗∗2.裁剪：∗∗如果

g

_2 > threshold，则g = g \cdot \frac{threshold}{

g

AI-A0-0261​

优化技巧

PD分离领域

在训练过程中，将部分模型参数或激活从GPU内存转移到CPU内存或硬盘，以节省GPU内存。

卸载 (Offloading)​

1. 识别：​ 选择可以卸载的数据，如前向传播中的中间激活、优化器状态、梯度等。
2. 转移：​ 在需要之前将数据从GPU内存转移到CPU内存（或硬盘），在需要时再转移回GPU。
3. 权衡：​ 用通信时间换取内存空间。

目的：​ 在有限的GPU内存下训练更大模型。
通信开销：​ 增加GPU和CPU之间的数据传输。

内存优化， 计算换内存。 通过将数据暂时移到低速存储来节省GPU内存。

场景：​ 训练极大模型， GPU内存严重不足时。
特征：​ 数据转移， 通信开销， 内存节省。

MGPU​：​ GPU内存容量。
MCPU​：​ CPU内存容量。
D：​ 需要卸载的数据。

数据传输：​ GPU ↔ CPU。

描述为“将部分模型数据（如激活、梯度）从GPU内存转移到CPU内存，需要时再移回，以节省GPU内存”。

1. 在前向传播中，将某些层的输出激活从GPU复制到CPU内存，并释放GPU内存。
2. 在反向传播需要这些激活时，从CPU内存复制回GPU。
3. 同样，可以将优化器状态卸载到CPU。​

“卸载流”：​ 数据流在GPU和CPU之间流动。在前向流中，部分激活流被转移到CPU存储流中保存。在反向流中，这些激活流被取回GPU用于梯度计算。这扩大了可用内存流，但引入了数据传输延迟流。

卸载通常通过异步传输和计算重叠来减少开销。在多GPU中，每个GPU可以独立卸载自己的数据，但需要注意同步。

激活检查点， 内存优化。

AI-A0-0262​

优化技巧

PD分离领域

一种权重初始化方法，根据输入和输出维度调整初始化方差，保持前向和反向传播的方差稳定。

Xavier初始化 (Glorot初始化)​

1. 均匀分布：​ W∼U[−nin​+nout​​6​​,nin​+nout​​6​​]，其中 nin​和 nout​是输入和输出维度。
2. 正态分布：​ W∼N(0,nin​+nout​2​)。
3. 目标：​ 保持各层激活的方差一致。

适用：​ 使用sigmoid或tanh等饱和激活函数的网络。
原理：​ 基于方差守恒。

权重初始化， 方差缩放。 根据输入输出维度调整初始化范围，防止梯度消失或爆炸。

场景：​ 全连接层， 卷积层（需调整维度计算）， 使用sigmoid/tanh的网络。
特征：​ 均匀或正态分布， 方差与维度相关。

W：​ 权重矩阵，形状 (nout​,nin​)。
nin​：​ 输入维度。
nout​：​ 输出维度。

均匀分布：​ 边界由 6/(nin​+nout​)​决定。
方差：​ Var(W)=2/(nin​+nout​)。

描述为“权重从均匀或正态分布中初始化，其方差与输入和输出维度的和成反比”。

1. 计算缩放因子 scale=6/(nin​+nout​)​（均匀分布）或 std=2/(nin​+nout​)​（正态分布）。
2. 从 U[−scale,scale]或 N(0,std2)采样初始化 W。​

“方差均衡”流：​ Xavier初始化确保权重矩阵 W的初始化方差与输入维度 nin​和输出维度 nout​相关，使得前向传播中激活的方差和反向传播中梯度的方差在各层之间大致保持稳定，避免梯度消失或爆炸。

初始化在训练开始前执行一次。在多GPU上，每个GPU独立初始化相同的权重（如果使用相同随机种子），或按模型并行分区初始化。

Kaiming初始化， 权重初始化。

AI-A0-0263​

优化技巧

PD分离领域

针对ReLU及其变体设计的权重初始化方法，保持前向传播中激活的方差不变。

Kaiming初始化 (He初始化)​

1. 正态分布：​ W∼N(0,nin​2​)，其中 nin​是输入维度。
2. 均匀分布：​ W∼U[−nin​​6​​,nin​​6​​]。
3. 考虑ReLU：​ 由于ReLU将一半激活置零，方差减半，因此需要加倍方差补偿。

适用：​ 使用ReLU、LeakyReLU等非饱和激活函数的网络。
原理：​ 考虑ReLU的激活稀疏性。

权重初始化， 方差缩放。 针对ReLU族激活函数调整初始化方差。

场景：​ 使用ReLU的深度神经网络， 如ResNet、Transformer（FFN中的ReLU/GELU）。
特征：​ 方差与输入维度成反比， 考虑激活函数特性。

W：​ 权重矩阵，形状 (nout​,nin​)。
nin​：​ 输入维度。
a：​ ReLU负斜率（对于LeakyReLU）。

方差：​ Var(W)=(1+a2)nin​2​，对于ReLU a=0，故为 nin​2​。

描述为“针对ReLU激活函数，权重初始化方差与输入维度成反比，并考虑激活函数的稀疏性”。

1. 确定激活函数参数 a（ReLU为0，LeakyReLU为负斜率）。
2. 计算方差 var=(1+a2)nin​2​。
3. 从 N(0,var)或 U[−3var​,3var​]采样初始化 W。​

“ReLU方差校正”流：​ Kaiming初始化考虑了ReLU激活函数会将一半的激活置零，导致方差减半。因此，初始化时将权重方差放大一倍（nin​2​对比 Xavier 的 nin​+nout​2​），以补偿这种稀疏性，确保各层激活方差稳定。

同Xavier初始化，在训练前执行。对于Transformer，FFN层的权重通常使用Kaiming初始化。

Xavier初始化， ReLU， 权重初始化。

AI-A0-0264​

正则化

Token领域

在标签分布中引入噪声，将硬标签（one-hot）转换为软标签，防止模型过度自信。

标签平滑 (Label Smoothing)​

1. 硬标签：​ 对于真实类别 y，one-hot向量 q满足 qy​=1，其他为0。
2. 平滑：​ q′=(1−ϵ)q+ϵu，其中 ϵ是平滑参数（如0.1），u是均匀分布（ui​=1/K，K是类别数）。
3. 损失：​ 使用 q′作为目标计算交叉熵损失。

效果：​ 防止模型对正确类别过度自信， 提高泛化能力， 减轻过拟合。
参数 ϵ：​ 通常0.05到0.2。

正则化， 校准。 通过软化标签分布，鼓励模型保留不确定性。

场景：​ 分类任务， 尤其是大规模分类（如ImageNet）。
特征：​ 软化标签， 均匀噪声。

q：​ 原始one-hot标签向量。
ϵ：​ 平滑系数。
u：​ 均匀分布向量，ui​=1/K。
K：​ 类别总数。

凸组合：​ (1−ϵ)q+ϵu。
概率分布：​ 仍为概率分布。

描述为“将真实标签的1减去一个小量，并将这个小量均匀分配到其他类别上，得到软标签”。

1. 给定真实类别 y，创建one-hot向量 q。
2. 计算平滑标签 q′=(1−ϵ)q+ϵ⋅K1​。
3. 使用 q′作为目标计算交叉熵损失：L=−∑i​qi′​logpi​，其中 p是模型预测概率。​

“标签软化”流：​ 硬标签流（one-hot）包含绝对确定性，可能促使模型过度拟合。标签平滑将硬标签流与均匀噪声流混合，产生一个较软的标签流。这个软标签流鼓励模型对正确类别的预测概率接近 1−ϵ，同时对其他类别赋予小的概率 ϵ/K，从而保留一定程度的不确定性，提高泛化。

标签平滑在数据加载或损失计算时进行，计算简单。在多GPU数据并行中，每个GPU独立对本地数据的标签进行平滑。

交叉熵损失， 正则化。

AI-A0-0265​

正则化

Token领域

在训练过程中，随机将一部分神经元的输出置零，防止过拟合。

Dropout​

1. 训练阶段：​ 对于每一层，每个神经元以概率 p（dropout率）被置零，否则其输出乘以 1/(1−p)（缩放）。
2. 数学描述：​ y=x⊙m/(1−p)，其中 m∼Bernoulli(1−p)是掩码向量，⊙是逐元素乘法。
3. 测试阶段：​ 不使用dropout，所有神经元激活，但权重乘以 (1−p)（或等价地，训练时缩放，测试时不变）。

作用：​ 防止过拟合， 提高模型泛化能力， 相当于模型平均。
典型 p：​ 0.1到0.5， 输入层较低，隐藏层较高。

正则化， 模型平均。 通过随机丢弃神经元，强制网络不依赖特定神经元，提高鲁棒性。

场景：​ 全连接层， 卷积层， 注意力层（如Transformer中的dropout）。
特征：​ 随机丢弃， 训练和测试行为不同。

x：​ 输入向量或矩阵。
p：​ dropout率，神经元被丢弃的概率。
m：​ 掩码向量，元素独立服从 Bernoulli(1−p)。
y：​ 输出。

随机：​ 伯努利分布。
缩放：​ 除以 1−p以保持期望不变。

描述为“在训练时，随机将一部分神经元的输出置零，其余神经元按比例放大，以保持期望不变；测试时直接使用所有神经元”。

训练时：
1. 生成掩码 m∼Bernoulli(1−p)。
2. 计算 y=x⊙m/(1−p)。
测试时：
1. 直接使用 y=x（因为训练时已缩放）。​

“随机子网络”流：​ 在每次前向传播中，Dropout随机选择神经元子集构成一个“子网络”。信息流只能通过未被丢弃的神经元流动。这迫使网络学习冗余表示，不依赖于任何单个神经元。缩放操作确保信息流的总体强度在训练和测试间一致。

Dropout操作是逐元素乘法，可并行。掩码生成是随机的，但可以同步随机种子以确保多GPU一致性。在Transformer中，dropout常用于注意力权重和FFN激活后。

正则化， 模型平均。

AI-A0-0266​

正则化

Token领域

在注意力权重上应用dropout，随机丢弃一些注意力连接。

注意力Dropout (Attention Dropout)​

1. 位置：​ 在softmax之后，对注意力权重矩阵 A应用dropout。
2. 操作：​ A′=dropout(A,p)，即对 A的每个元素以概率 p置零，其余乘以 1/(1−p)。
3. 然后使用 A′与 V加权求和。​

作用：​ 防止注意力机制过拟合， 提高泛化， 增加注意力头的多样性。
注意：​ 通常与普通的激活dropout结合使用。

Dropout， 注意力机制。 在注意力权重上随机丢弃，减少特定注意力连接的依赖。

场景：​ Transformer的注意力层。
特征：​ 在softmax后应用， 随机丢弃注意力权重。

A：​ 注意力权重矩阵，形状 (L,L)或 (h,L,L)（多头）。
p：​ dropout率。
A′：​ dropout后的注意力权重。

随机：​ 元素级丢弃。
缩放：​ 保持期望。

描述为“对softmax后的注意力权重矩阵进行dropout，随机将一部分注意力权重置零”。

1. 计算注意力分数 S=QKT/dk​​。
2. 应用因果掩码（如果需要）。
3. 计算softmax：A=softmax(S)。
4. 对 A应用dropout：A′=dropout(A,p)。
5. 输出 O=A′V。​

“注意力连接随机化”流：​ 注意力权重流表示不同位置间的重要性分配。注意力dropout随机切断一部分注意力连接（权重置零），迫使模型不过度依赖某些特定的注意力模式，从而学习更鲁棒的表示。这可以看作是在注意力图上进行随机子图采样。

同标准dropout，逐元素操作，可并行。在多GPU上，每个头独立应用dropout，掩码可以不同，但通常同步随机种子以确保一致性。

Dropout， 注意力机制。

AI-A0-0267​

模型架构

Token领域

一种稀疏注意力模式，将序列划分为块，每个块内进行局部注意力，块之间通过全局token连接。

BigBird (稀疏注意力)​

1. 注意力模式：​ 结合三种注意力：随机注意力、局部窗口注意力、全局token注意力。
2. 随机注意力：​ 每个token随机关注 r个其他token。
3. 局部窗口注意力：​ 每个token关注其前后 w个邻居token。
4. 全局token注意力：​ 预设一些全局token（如[CLS]），所有token都关注它们，它们也关注所有token。
5. 计算：​ 注意力矩阵 A是这三种模式的并集，仅计算 A中非零位置的注意力分数。

优点：​ 将注意力复杂度从 O(L2)降低到 O(L)， 可处理更长序列。
全局token：​ 通常选择序列开头和结尾的token。

稀疏注意力， 图论。 通过限制每个token的注意力范围，实现线性复杂度，同时保持全局信息流。

场景：​ 长文本建模， 如文档分类、长序列问答。
特征：​ 随机+局部+全局注意力， 线性复杂度。

L：​ 序列长度。
w：​ 局部窗口大小。
r：​ 每个token随机关注的token数。
g：​ 全局token数量。
A：​ 稀疏注意力矩阵，Aij​=1表示token i关注token j。

稀疏矩阵：​ A是稀疏的，非零元素数 O(L)。
并集：​ A=Arandom​∪Alocal​∪Aglobal​。

描述为“每个token只关注三类token：随机选择的少数token、相邻的局部窗口内的token、以及一些全局token，从而大幅减少注意力计算量”。

**1. 构建稀疏注意力矩阵 A：
a. 局部窗口：对于每个位置 i，Aij​=1对于 j∈[i−w,i+w]。
b. 随机注意力：对于每个 i，随机选择 r个 j，设 Aij​=1。
c. 全局注意力：对于每个全局token g，所有 i设 Aig​=1和 Agi​=1。
2. 计算注意力：仅对 Aij​=1的位置计算 Qi​KjT​，然后softmax得到权重，加权求和 Vj​。

“稀疏信息流”：​ 注意力流被限制在稀疏图 A定义的路径上。局部窗口流确保每个token能感知其邻近上下文；随机流引入远程连接，允许信息在任意两个token间以一定概率流动；全局流通过少数全局token作为枢纽，收集和分发全局信息。这三种流的组合使得整个序列的信息可以在线性复杂度内有效传递。

BigBird的稀疏注意力模式允许使用稀疏矩阵乘法或掩码实现。在多头注意力中，每个头可以共享相同的稀疏模式或使用不同的随机模式。在多GPU中，序列可以按块划分，但全局token需要特殊处理（如广播）。

Longformer， Sparse Transformer。

AI-A0-0268​

模型架构

Token领域

一种稀疏注意力模式，结合局部滑动窗口注意力和任务特定的全局注意力（如全局token）。

Longformer (稀疏注意力)​

1. 注意力模式：​ 主要使用局部滑动窗口注意力，每个token关注其前后 w个token（窗口大小为 2w+1）。
2. 全局注意力：​ 为特定任务（如QA）预设全局token（如问题token），这些token关注所有token，所有token也关注它们。
3. 计算：​ 使用带状稀疏矩阵（滑动窗口）和全局token对应的全连接行/列。

优点：​ 线性复杂度 O(L×w)， 可处理数千token的序列。
全局token：​ 根据任务手动选择， 如QA中的问题token。

稀疏注意力， 滑动窗口。 通过局部窗口注意力捕获局部上下文，通过全局注意力捕获长距离依赖。

场景：​ 长文档建模， 如文本分类、问答、摘要。
特征：​ 滑动窗口， 任务特定全局注意力， 线性复杂度。

L：​ 序列长度。
w：​ 单侧窗口半径，总窗口大小 2w+1。
A：​ 注意力矩阵，局部为带状，全局为全连接行/列。

带状矩阵：​ 局部注意力对应带状稀疏矩阵。
全局行/列：​ 全局token对应的行和列是全连接的。

描述为“使用滑动窗口注意力，每个token只关注其附近固定窗口内的token，同时为一些特定token（如问题token）添加全局注意力，使其关注所有token并被所有token关注”。

1. 对于每个位置 i：
a. 局部注意力：计算 i与 j∈[i−w,i+w]的注意力分数。
b. 全局注意力：如果 i是全局token，计算 i与所有 j的注意力分数；如果 j是全局token，计算 i与 j的注意力分数。
2. 对注意力分数进行softmax归一化。
3. 加权求和值向量。​

“局部+全局流”：​ 大多数token的信息流被限制在局部窗口内，形成局部流。全局token作为信息枢纽，形成全局流：所有token的信息流向全局token，全局token的信息也流向所有token。这种设计使得模型既能高效处理长序列，又能通过全局token捕获整个序列的上下文。

Longformer的滑动窗口注意力可以通过带状矩阵乘法或因果掩码实现。全局注意力需要全连接计算，但全局token数量很少。在多GPU中，序列可以分区，但全局token可能需要跨GPU通信。

BigBird， Sparse Transformer。

AI-A0-0269​

模型架构

Token领域

将注意力计算分解为多个块，通过局部和全局交互来近似标准注意力。

Reformer (局部敏感哈希注意力)​

1. 局部敏感哈希（LSH）：​ 将查询和键投影到低维空间，并使用哈希函数将相似的向量分配到相同的桶中。
2. 分桶：​ 根据LSH哈希值将序列中的token分到多个桶中。
3. 桶内注意力：​ 在每个桶内进行标准的注意力计算。
4. 分块：​ 为了处理桶大小不均，将序列分块并允许相邻块之间的token交互。

优点：​ 将注意力复杂度从 O(L2)降低到 O(LlogL)， 内存效率高。
哈希函数：​ 通常使用随机旋转投影。

稀疏注意力， 局部敏感哈希。 利用LSH将相似的查询和键分组，只在组内计算注意力，减少计算量。

场景：​ 极长序列， 如蛋白质序列、长文档。
特征：​ LSH分桶， 桶内注意力， 近似全局注意力。

Q,K：​ 查询和键矩阵，形状 (L,dk​)。
哈希函数 h：​ h(x)=argmax([xR;−xR])，其中 R是随机矩阵。
桶：​ 哈希值相同的token属于同一桶。
块大小：​ m，用于分块处理。

LSH：​ 近似最近邻搜索技术。
分桶：​ 将序列划分为桶，桶内计算注意力。

描述为“使用局部敏感哈希将查询和键映射到哈希桶中，使得相似的向量落入同一个桶，然后只在每个桶内计算注意力，从而大幅减少计算量”。

1. 计算查询 Q和键 K。
2. 对每个查询向量 qi​和键向量 ki​计算LSH哈希值 h(qi​)和 h(ki​)。
3. 根据哈希值将token分到桶中。
4. 对每个桶内的token，按原始顺序排序，并分成长度为 m的块。
5. 对于每个块，计算其内部以及与前一个块的注意力（确保局部连续性）。
6. 聚合所有块的输出。​

“哈希分桶流”：​ 查询流 Q和键流 K通过LSH函数被映射到哈希桶中。相似度高的向量流倾向于落入同一个桶。注意力流被限制在每个桶内部以及相邻块之间。这样，每个token只与同一桶内和相邻块的token进行注意力交互，避免了全序列的成对计算，实现了近似但高效的注意力。

Reformer需要计算LSH哈希和分桶排序，这些操作在GPU上可能效率较低。桶内注意力可以并行计算，但负载可能不均衡。在多GPU中，需要根据哈希值重新分布序列，通信开销较大。

LSH， 稀疏注意力。

AI-A0-0270​

模型架构

Token领域

将注意力计算分解为块稀疏形式，通过组合局部和全局注意力块来近似全注意力。

Block-Sparse Transformer​

1. 分块：​ 将序列划分为多个块（如每块64个token）。
2. 注意力模式：​ 设计块稀疏模式，每个块只与其他少数块计算注意力。模式可以是固定的（如局部邻块）或学习的。
3. 计算：​ 对于每个查询块，只计算与它相关的键块的点积，形成稀疏的块注意力矩阵。
4. 输出：​ 加权求和值块。

优点：​ 通过减少块间注意力计算， 降低计算和内存复杂度。
块大小：​ 通常64或128， 平衡效率和表达能力。

稀疏注意力， 块计算。 在块级别进行稀疏注意力，减少计算量。

场景：​ 长序列建模， 如图像、音频、长文本。
特征：​ 块划分， 块稀疏模式， 可固定或学习。

L：​ 序列长度。
B：​ 块大小，序列被分为 N=L/B块。
Ablock​：​ 块注意力矩阵，Ablock​∈{0,1}N×N，Ablock​(i,j)=1表示块 i关注块 j。

块矩阵：​ 注意力矩阵是块稀疏的。
复杂度：​ O(L⋅B⋅s)，其中 s是每个查询块关注的键块数。

描述为“将序列分成块，每个块只与预先定义的一组其他块计算注意力，而不是与所有块计算，从而减少计算量”。

1. 将输入序列划分为 N个块，每块 B个token。
2. 对于每个查询块 i，根据预设的稀疏模式，确定其需要关注的键块集合 Si​。
3. 对于每个 j∈Si​，计算查询块 i与键块 j的注意力分数矩阵（大小为 B×B）。
4. 对每个查询块 i，将其与所有相关键块 j的注意力分数进行softmax（跨所有 j∈Si​和块内位置）。
5. 加权求和值块 j，得到查询块 i的输出。​

“块稀疏流”：​ 序列流被划分为块流。注意力流只在被允许的块对之间流动。例如，局部模式中，每个块只关注相邻的几个块；随机模式中，每个块随机关注几个其他块；全局模式中，某些块关注所有块。这种块级别的稀疏流大大减少了注意力计算的总量，同时保留了重要的长距离依赖。

块稀疏注意力可以利用块矩阵乘法优化。在多头注意力中，每个头可以使用不同的稀疏模式。在多GPU中，序列块可以分布在不同GPU上，注意力计算需要跨GPU通信相关块。

Sparse Transformer， BigBird。

AI-A0-0271​

模型架构

Token领域

通过低秩分解近似注意力矩阵，将复杂度从 O(L2)降为 O(L)。

Linformer (线性注意力)​

1. 低秩投影：​ 将键 K和值 V从 L×d投影到 k×d，其中 k是投影维度（k≪L）。
2. 投影矩阵：​ E,F∈Rk×L，将 K和 V投影为 K~=EK, V~=FV，形状 (k,d)。
3. 注意力计算：​ Attention(Q,K,V)=softmax(dk​​QK~T​)V~，其中 K~T∈Rd×k，QK~T∈RL×k，因此复杂度为 O(Lkd)，当 k固定时为 O(L)。

核心思想：​ 注意力矩阵 P=softmax(QKT/d​)是低秩的， 可以用低维投影近似。
k：​ 投影维度， 如256， 与 L无关。

低秩近似， 线性复杂度。 通过将键和值投影到低维空间，实现线性复杂度的注意力。

场景：​ 长序列编码， 如文档分类， 但仅适用于编码器（非自回归）。
特征：​ 线性复杂度， 低秩投影， 固定 k。

Q,K,V：​ 查询、键、值矩阵，形状 (L,d)。
E,F：​ 投影矩阵，形状 (k,L)，可学习或固定。
K~,V~：​ 投影后的键和值，形状 (k,d)。
k：​ 投影维度，超参数。

低秩投影：​ K∈RL×d→K~∈Rk×d。
矩阵乘法：​ QK~T∈RL×k。

描述为“将键和值矩阵通过投影压缩到固定长度，然后与查询矩阵计算注意力，使计算复杂度与序列长度呈线性关系”。

1. 输入 Q,K,V，形状 (L,d)。
2. 投影键和值：K~=EK, V~=FV，得到形状 (k,d)。
3. 计算注意力分数：S=QK~T/dk​​，形状 (L,k)。
4. 对 S进行softmax：P=softmax(S)，形状 (L,k)。
5. 计算输出：O=PV~，形状 (L,d)。​

“压缩流”：​ 键流 K和值流 V被投影矩阵 E和 F压缩到低维空间，形成压缩的键流 K~和值流 V~。注意力流变为：查询流 Q与压缩键流 K~交互，产生注意力权重流 P（L×k），然后与压缩值流 V~聚合。由于 k是固定的，整个流程的复杂度与序列长度 L成线性关系。

Linformer的投影操作是矩阵乘法，可以高效并行。投影矩阵 E和 F可以是可学习的参数。在多GPU中，序列可以按长度划分，但投影操作可能需要全局聚合（如果 E和 F是全局的）。

低秩近似， 线性注意力。

AI-A0-0272​

模型架构

Token领域

通过核函数将注意力计算重写为查询和键的特征映射的点积，然后利用矩阵乘法的结合律实现线性复杂度。

Linear Attention (线性注意力，核函数方法)​

1. 标准注意力：​ O=softmax(d​QKT​)V。
2. 核函数视角：​ 将softmax视为核函数：softmax(QKT)=1exp(QKT)exp(QKT)​，其中 exp逐元素。
3. 特征映射：​ 定义特征映射 ϕ，使得 ϕ(q)Tϕ(k)≈exp(qTk/d​)。例如，ϕ(x)=exp(−2∥x∥2​)⋅[1,x,2​x2​,...]（多项式展开）。
4. 线性化：​ O=ϕ(Q)(ϕ(K)T1)ϕ(Q)(ϕ(K)TV)​，其中 ϕ(Q)∈RL×m，ϕ(K)∈RL×m，m是特征维度。分母是归一化项。计算顺序改为先计算 ϕ(K)TV（m×d）和 ϕ(K)T1（m×1），再与 ϕ(Q)相乘，复杂度 O(Lmd)，当 m固定时为 O(L)。

关键：​ 找到合适的特征映射 ϕ来近似softmax核。
复杂度：​ O(Lmd)， 线性于 L。

核方法， 线性复杂度。 通过核技巧将注意力分解为线性运算。

场景：​ 需要线性复杂度的自回归或非自回归模型。
特征：​ 核特征映射， 改变计算顺序， 线性复杂度。

Q,K,V：​ 查询、键、值，形状 (L,d)。
ϕ：​ 特征映射函数，将 d维向量映射到 m维。
m：​ 特征维度，超参数。
1：​ 全1向量，形状 (L,1)。

核函数：​ k(q,k)=ϕ(q)Tϕ(k)近似 exp(qTk/d​)。
结合律：​ (ϕ(Q)ϕ(K)T)V=ϕ(Q)(ϕ(K)TV)。

描述为“使用核函数将注意力中的指数点积转化为特征映射的点积，然后利用矩阵乘法的结合律先计算键和值的聚合，再与查询相乘，实现线性复杂度”。

1. 计算特征映射：Q~​=ϕ(Q), K~=ϕ(K)，形状 (L,m)。
2. 计算键值聚合：KV=K~TV，形状 (m,d)。
3. 计算键和1的聚合：K1=K~T1，形状 (m,1)。
4. 计算输出：O=Q~​K1Q~​KV​，其中除法是逐元素除法（广播）。​

“核化线性流”：​ 查询流 Q和键流 K通过特征映射 ϕ转换为高维特征流 Q~​和 K~。注意力计算被分解为两个流：键值聚合流 K~TV和键和流 K~T1。然后，查询流 Q~​分别与这两个聚合流相乘，并通过除法归一化。这个流程将二次复杂度转化为线性复杂度，因为聚合操作 (K~TV)和 (K~T1)的计算与 L无关（m固定）。

Linear Attention需要计算特征映射，可能增加计算开销，但整体复杂度仍是线性的。特征映射 ϕ可以是简单的函数（如elu+1）。在自回归情况下，需要因果掩码，但线性注意力仍然可以应用，因为聚合可以递归计算。在多GPU中，序列可以分区，但聚合操作可能需要跨GPU归约。

核方法， 高效注意力。

AI-A0-0273​

模型架构

Token领域

使用正交随机特征（ORF）近似softmax核，实现线性注意力。

Performer (随机特征注意力)​

1. 随机特征映射：​ 使用随机特征来近似softmax核。具体地，exp(qTk)=Eω∼N(0,I)​[exp(ωTq−∥q∥2/2)exp(ωTk−∥k∥2/2)]。
2. 正交随机特征：​ 使用正交的随机矩阵 ω以减少方差。
3. 特征映射函数：​ ϕ(x)=m​1​exp(Wx−2∥x∥2​)，其中 W∈Rm×d的行是随机正交向量，m是特征数。
4. 注意力计算：​ O=ϕ(Q)(ϕ(K)T1)ϕ(Q)(ϕ(K)TV)​，与线性注意力相同。

优点：​ 无偏近似softmax， 线性复杂度， 支持自回归训练和推理。
m：​ 随机特征数， 通常64到256。

随机特征， 核近似， 线性复杂度。 使用随机特征映射来近似softmax核，实现线性注意力。

场景：​ 长序列建模， 需要精确softmax近似的场景。
特征：​ 随机特征， 正交化， 线性复杂度。

Q,K,V：​ 查询、键、值，形状 (L,d)。
W：​ 随机矩阵，行是正交随机向量，形状 (m,d)。
ϕ：​ 特征映射函数，输出形状 (L,m)。
m：​ 随机特征维度。

随机特征：​ ϕ(x)=m​1​exp(Wx−∥x∥2/2)。
期望：​ E[ϕ(q)Tϕ(k)]=exp(qTk)。

描述为“使用正交随机特征来近似softmax核函数，将注意力计算转化为线性形式，从而实现线性复杂度”。

1. 生成随机正交矩阵 W（或从正态分布采样后正交化）。
2. 计算特征映射：Q~​=ϕ(Q)=m​1​exp(WQT−2∥Q∥2​)T，形状 (L,m)。
3. 同样计算 K~=ϕ(K)。
4. 计算 KV=K~TV，K1=K~T1。
5. 计算输出：O=Q~​K1Q~​KV​。​

“随机特征流”：​ 查询流 Q和键流 K通过随机特征映射 ϕ转换，其中 ϕ使用随机正交矩阵 W和指数函数。这个映射流将原始的指数点积核近似为随机特征的点积。然后，与线性注意力相同，进行键值聚合流和键和聚合流，最后与查询特征流结合。随机特征流提供了对softmax核的无偏估计，且方差较小。

Performer需要生成随机矩阵 W，可以在训练前固定或定期更新。特征映射涉及指数计算，可能数值不稳定，需要小心实现。在多GPU中，W在所有GPU上一致，特征映射可以独立计算。

线性注意力， 随机特征。

AI-A0-0274​

模型架构

Token领域

在多头注意力中，将键和值在多个头之间共享，减少参数和计算量。

分组查询注意力 (Grouped-Query Attention, GQA)​

1. 分组：​ 将 h个头分为 g组，每组共享相同的键和值投影。设 h是头数，g是组数（g<h）。
2. 投影：​ 查询投影 WiQ​对每个头独立，键和值投影 WjK​,WjV​对每组共享，其中 j=1,...,g。
3. 计算：​ 对于第 j组，键和值 Kj​=KWjK​, Vj​=VWjV​。对于属于该组的每个头 i，使用独立的查询 Qi​=QWiQ​，但共享 Kj​和 Vj​计算注意力：headi​=softmax(dk​​Qi​KjT​​)Vj​。
4. 拼接：​ 同多头注意力。

优点：​ 减少键值缓存的内存占用， 加快推理速度， 同时保持与多头注意力相近的性能。
组数 g：​ 通常1（MQA）到8， 平衡效率和性能。

注意力机制， 参数共享。 多个查询头共享相同的键和值投影，减少参数和推理时键值缓存。

场景：​ 大语言模型推理， 如LLaMA-2 70B， 用于减少内存和加速。
特征：​ 查询头分组， 共享键值， 减少键值缓存。

h：​ 总头数。
g：​ 组数，g≤h。
WiQ​：​ 查询投影矩阵，每个头独立，形状 (dmodel​,dk​)。
WjK​,WjV​：​ 键和值投影矩阵，每组共享，形状 (dmodel​,dk​)和 (dmodel​,dv​)。
Kj​,Vj​：​ 第 j组的键和值，形状 (L,dk​)和 (L,dv​)。

共享：​ 每组共享键值投影。
独立：​ 每个头有独立查询投影。
参数减少：​ 键值投影参数从 h组减少到 g组。

描述为“将注意力头分成若干组，每组内的头共享相同的键和值投影，但每个头仍有独立的查询投影，从而在推理时减少键值缓存的大小”。

1. 将 h个头分为 g组，每组有 h/g个头（假设可整除）。
2. 对于每组 j：
a. 计算共享键和值：Kj​=KWjK​, Vj​=VWjV​。
b. 对于该组内的每个头 i：
i. 计算独立查询：Qi​=QWiQ​。
ii. 计算注意力：headi​=softmax(dk​​Qi​KjT​​)Vj​。
3. 拼接所有头的输出，然后进行输出投影。​

“分组共享流”：​ 键流 K和值流 V被投影到 g组共享的流 Kj​和 Vj​。查询流 Q被投影到 h个独立的流 Qi​。在注意力计算流中，属于同一组的多个查询流 Qi​与同一组键值流 Kj​,Vj​交互。这减少了需要存储的键值流的数量，从而降低了内存带宽需求，加速了推理。

GQA在推理时显著减少键值缓存的内存占用，因为只需要缓存 g组键值，而不是 h组。在训练时，键值投影的梯度会被组内所有头共享。在多GPU中，分组可以结合张量并行来分配。

多头注意力， 多查询注意力。

AI-A0-0275​

模型架构

Token领域

分组查询注意力的极端情况，所有头共享同一组键和值投影。

多查询注意力 (Multi-Query Attention, MQA)​

1. 共享键值：​ 所有头共享相同的键投影 WK和值投影 WV，即 g=1。
2. 独立查询：​ 每个头有独立的查询投影 WiQ​。
3. 计算：​ K′=KWK, V′=VWV。对于每个头 i，Qi​=QWiQ​，然后 headi​=softmax(dk​​Qi​K′T​)V′。
4. 拼接：​ 同多头注意力。

优点：​ 极大减少键值缓存， 显著加速推理， 但可能轻微降低模型质量。
应用：​ 用于推理优化， 如T5、一些GPT模型。

注意力机制， 参数共享。 所有查询头共享同一组键和值投影，极大减少内存占用。

场景：​ 对推理速度和内存有严格要求的场景， 如大规模部署。
特征：​ 单组键值， 多组查询， 减少键值缓存。

h：​ 头数。
WiQ​：​ 查询投影矩阵，每个头独立，形状 (dmodel​,dk​)。
WK,WV：​ 键和值投影矩阵，所有头共享，形状 (dmodel​,dk​)和 (dmodel​,dv​)。
K′,V′：​ 共享的键和值，形状 (L,dk​)和 (L,dv​)。

共享：​ 所有头共享 K′和 V′。
参数：​ 键值投影参数减少到1组。

描述为“所有注意力头共享同一组键和值投影，但每个头有自己独立的查询投影，从而大幅减少推理时的键值缓存”。

1. 计算共享键和值：K′=KWK, V′=VWV。
2. 对于每个头 i=1,...,h：
a. 计算独立查询：Qi​=QWiQ​。
b. 计算注意力：headi​=softmax(dk​​Qi​K′T​)V′。
3. 拼接所有头：MultiHead=Concat(head1​,...,headh​)。
4. 输出投影：Output=MultiHead⋅WO。​

“单键值流”：​ 键流 K和值流 V只被投影一次，生成共享的键流 K′和值流 V′。查询流 Q被投影 h次，生成 h个独立的查询流 Qi​。在注意力流中，所有查询流 Qi​都与同一个键流 K′和值流 V′交互。这极大地减少了需要缓存和传输的键值数据量，提高了推理效率，但限制了不同头关注不同键值子空间的能力。

MQA在推理时键值缓存最小，只需存储一份键值。在训练时，键值投影的梯度来自所有头。在多GPU中，共享键值可以存储在单个GPU上或广播，减少通信。

分组查询注意力， 多头注意力。

AI-A0-0276​

模型架构

Token领域

一种IO感知的精确注意力算法，通过分块和重计算减少内存访问，提高计算效率。

Flash Attention​

1. 目标：​ 计算注意力输出 O=softmax(QKT)V，同时减少高带宽内存（HBM）与片上内存（SRAM）之间的数据传输。
2. 分块：​ 将 Q,K,V分成块，在SRAM中逐块计算，避免将整个 QKT矩阵存入HBM。
3. 在线softmax：​ 使用在线softmax算法，逐块更新softmax分母和分子，无需存储整个注意力矩阵。
4. 重计算：​ 在反向传播时，从存储的 Q,K,V和输出 O重新计算注意力矩阵，而不是存储中间矩阵，以节省内存。

优点：​ 大幅减少内存访问， 加速注意力计算， 支持长序列。
复杂度：​ 计算复杂度仍为 O(L2d)， 但内存访问复杂度从 O(L2)降为 O(L)。

算法优化， 内存层次。 利用GPU内存层次，通过分块和重计算优化注意力计算的内存效率。

场景：​ 训练和推理大模型， 尤其是长序列场景。
特征：​ 分块计算， 在线softmax， 重计算， 内存高效。

Q,K,V：​ 查询、键、值矩阵，形状 (L,d)。
块大小：​ Bc​（键/值块大小），Br​（查询块大小），根据SRAM大小设置。
O：​ 输出矩阵，形状 (L,d)。
l：​ softmax分母向量，形状 (L)。
m：​ 每行的最大值向量，形状 (L)。

分块矩阵乘法：​ QKT分块计算。
在线softmax：​ 逐块更新 m和 l。
重计算：​ 反向传播时重新计算 S=QKT。

描述为“将注意力计算分块进行，在片上内存中逐块计算注意力分数和输出，并使用在线softmax避免存储整个注意力矩阵，从而减少内存访问”。

1. 初始化输出 O=0，softmax分母 l=0，最大值 m=−∞。
2. 将 K,V分成 Tc​块，每块大小 Bc​；将 Q分成 Tr​块，每块大小 Br​。
3. 对于每个查询块 i：
a. 加载查询块 Qi​到SRAM。
b. 初始化块输出 Oi​=0，块分母 li​=0，块最大值 mi​=−∞。
c. 对于每个键值块 j：
i. 加载键块 Kj​和值块 Vj​到SRAM。
ii. 计算块注意力分数 Sij​=Qi​KjT​。
iii. 更新 mi​=max(mi​,rowmax(Sij​))，li​=li​⋅emiold​−mi​+rowsum(eSij​−mi​)。
iv. 更新 Oi​=Oi​⋅emiold​−mi​+eSij​−mi​Vj​。
d. 将 Oi​写回HBM。
4. 最终输出 O，分母 l用于反向传播。​

“分块流”：​ 查询流 Q被分成小块流 Qi​，键值流 K,V被分成小块流 Kj​,Vj​。注意力计算流在SRAM中进行：对于每个 Qi​，依次与所有 Kj​,Vj​块流交互，通过在线softmax流逐步更新输出流 Oi​。这种流避免了将整个 QKT矩阵流经HBM，减少了数据移动。

Flash Attention 利用GPU的共享内存（SRAM）进行块计算，减少全局内存（HBM）访问。在多GPU中，序列可以分区，每个GPU计算本地注意力，但需要全局通信来聚合结果（如模型并行）。Flash Attention 可以结合模型并行使用。

注意力机制， 在线softmax。

AI-A0-0277​

模型架构

Token领域

一种线性偏置方法，在注意力分数中添加一个与相对距离成比例的偏置，无需学习的位置嵌入。

ALiBi (Attention with Linear Biases)​

1. 偏置项：​ 在注意力分数 Sij​=qiT​kj​上添加一个与相对距离 j−i成比例的负偏置：$\tilde{S}{ij} = S{ij} - m \cdot

j-i

，其中m是头特定的斜率。<br>∗∗2.斜率设置：∗∗对于头h（从0开始计数），m_h = 2^{-8h/H}，其中H是总头数。<br>∗∗3.注意力计算：∗∗\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T - m \cdot D}{\sqrt{d_k}}\right) V，其中D_{ij} =

j-i

（对于自回归解码器，j > i时D_{ij} = \infty$ 或大数，以掩码未来位置）。

优点：​ 无需位置嵌入， 外推性好， 在长序列上表现优异。
偏置：​ 线性偏置， 越远的token惩罚越大。

位置编码， 相对位置。 通过添加与相对距离成比例的线性偏置来注入位置信息。

场景：​ 自回归语言模型， 如GPT-like模型， 尤其擅长外推到更长序列。
特征：​ 无位置嵌入， 线性偏置， 头特定斜率。

qi​,kj​：​ 查询和键向量。
m：​ 斜率，头特定，mh​=2−8h/H。
Dij​：​ 相对距离，$

j-i

。<br>∗∗H：∗∗总头数。<br>∗∗h$：**​ 头索引（0-based）。

AI-A0-0278​

模型架构

Token领域

一种位置编码方法，通过旋转位置编码将绝对位置信息注入到注意力机制中，保持相对位置的相对性。

旋转位置编码 (Rotary Position Embedding, RoPE)​

1. 将位置信息融入查询和键：​ 对于位置 m的查询向量 qm​和位置 n的键向量 kn​，通过旋转矩阵 RΘ,m​和 RΘ,n​进行变换：q~​m​=RΘ,m​qm​, k~n​=RΘ,n​kn​，其中 RΘ,m​是一个旋转矩阵，Θ是预设的频率参数。
2. 旋转矩阵构造：​ 对于维度 i，旋转角度为 mθi​，其中 θi​=10000−2i/d，d是维度的一半（因为复数表示）。
3. 注意力分数：​ am,n​=Re(q~​mH​k~n​)=Re((RΘ,m​qm​)H(RΘ,n​kn​))，其中 Re表示取实部，H表示共轭转置。

优点：​ 保持相对位置关系， 可外推， 在长序列上表现好。
数学性质：​ am,n​=g(qm​,kn​,m−n)，即注意力分数只依赖于相对位置 m−n。

位置编码， 相对位置， 复数旋转。 通过旋转操作将绝对位置信息注入查询和键，使注意力分数仅依赖于相对位置。

场景：​ LLaMA、GPT-NeoX等现代大语言模型。
特征：​ 相对位置编码， 可外推， 融入注意力计算。

qm​,kn​：​ 位置 m和 n的查询和键向量，维度 d。
RΘ,m​：​ 位置 m的旋转矩阵，维度 d×d。
θi​：​ 频率，θi​=10000−2i/d，i=0,1,...,d/2−1。
d：​ 查询/键向量的维度（通常 d=dmodel​/h，h是头数）。

旋转矩阵：​ 块对角矩阵，每个块是2D旋转矩阵。
复数表示：​ 将向量视为复数，旋转即乘法。
相对性：​ 注意力分数只依赖于 m−n。

描述为“将查询和键向量视为复数，根据其位置进行旋转，使得点积注意力分数仅依赖于相对位置”。

1. 将查询 q和键 k重塑为复数形式：将每两个连续维度视为一个复数（实部和虚部）。
2. 对于每个位置 m，计算旋转角度 θm​=m⋅θi​（对每个维度对 i）。
3. 计算旋转后的查询和键：q~​m​=qm​⊙eimΘ, k~n​=kn​⊙einΘ，其中 ⊙是逐元素乘法，Θ是频率向量。
4. 计算注意力分数：am,n​=Re(q~​m​⋅k~n∗​)，其中 ∗表示共轭。​

“旋转流”：​ 查询流 qm​和键流 kn​根据其绝对位置 m和 n分别进行旋转操作流。旋转角度由预设的频率 θi​和位置决定。旋转后的查询 q~​m​和键 k~n​的点积结果只依赖于相对位置 m−n，因为旋转操作在复数乘法中表现为相位差。这使得模型能够自然地捕捉相对位置信息，并具有良好的外推性。

RoPE在计算注意力之前应用于查询和键。计算可以向量化。在多GPU中，每个GPU持有序列的一部分，需要知道其全局位置以进行旋转。旋转操作是逐元素的，可以并行计算。

相对位置编码， 注意力机制。

AI-A0-0279​

模型架构

Token领域

层归一化的变体，仅对输入进行缩放，不进行平移，且使用RMS（均方根）进行归一化。

RMSNorm (Root Mean Square Layer Normalization)​

1. 计算RMS：​ 对于输入 x∈Rd，RMS(x)=d1​∑i=1d​xi2​​。
2. 归一化：​ x^i​=RMS(x)+ϵxi​​，其中 ϵ是小常数。
3. 缩放：​ yi​=gi​x^i​，其中 g∈Rd是可学习的缩放参数。
4. 整体：​ RMSNorm(x)=RMS(x)x​⊙g。

特点：​ 去除了均值中心化， 仅使用RMS进行缩放， 计算更简单， 在有些模型中表现与LayerNorm相当。
与LayerNorm区别：​ 不减均值， 无偏置参数 β。

归一化， 缩放。 使用均方根进行归一化，仅学习缩放参数，简化计算。

场景：​ LLaMA、T5等模型， 作为LayerNorm的替代。
特征：​ 无均值减法， 可学习缩放， 计算高效。

x：​ 输入向量，维度 d。
RMS(x)：​ 均方根，d1​∑i​xi2​​。
ϵ：​ 小常数，防止除零。
g：​ 可学习的缩放参数，维度 d。

均方根：​ 平方和的平均再开方。
缩放：​ 逐元素乘以 g。

描述为“计算输入向量的均方根，然后用它来缩放输入，最后乘以可学习的缩放参数”。

1. 计算 RMS=d1​∑i=1d​xi2​+ϵ​。
2. 计算 x^=x/RMS。
3. 输出 y=g⊙x^，其中 ⊙是逐元素乘法。​

“RMS缩放”流：​ 输入流 x首先计算其均方根流 RMS(x)，该流衡量了输入的总体幅度。然后，输入流被 RMS(x)缩放，得到一个单位RMS的流 x^。最后，通过可学习的缩放参数流 g对每个维度进行重新缩放，恢复模型的表达能力。与LayerNorm相比，它省略了减去均值的步骤，假设零均值已由前一层的偏置项处理。

RMSNorm计算比LayerNorm少一步均值计算，因此略高效。同样可并行计算。在多GPU中，每个样本独立计算RMS，然后进行缩放。

LayerNorm， 归一化。

AI-A0-0280​

模型架构

Token领域

一种门控激活函数，结合了Swish（SiLU）和GLU（Gated Linear Unit）的思想。

SwiGLU​

1. 定义：​ SwiGLU(x,W,V,b,c)=Swish(xW+b)⊙(xV+c)，其中 Swish(x)=xσ(x)，σ是sigmoid函数，⊙是逐元素乘法。
2. 简化：​ 通常 W和 V是线性变换，将输入 x投影到更高维度。
3. 在FFN中：​ FFNSwiGLU​(x)=(Swish(xW1​)⊙(xV1​))W2​，其中 W1​,V1​将 x投影到 dff​，W2​投影回 dmodel​。

优点：​ 比ReLU或GELU表现更好， 在PaLM等大模型中采用。
参数量：​ 由于有两个投影矩阵 W1​和 V1​，参数量是标准FFN的 2/3倍（如果 W1​和 V1​输出维度相同）。

激活函数， 门控机制。 通过Swish激活的门控线性单元，增强非线性表达能力。

场景：​ Transformer的FFN层， 替代标准ReLU/GELU FFN。
特征：​ 门控， Swish激活， 两个线性变换。

x：​ 输入，形状 (L,dmodel​)。
W1​,V1​：​ 权重矩阵，形状 (dmodel​,dff​)。
b,c：​ 偏置（可选）。
W2​：​ 权重矩阵，形状 (dff​,dmodel​)。
σ：​ sigmoid函数。
⊙：​ 逐元素乘法。

门控：​ 逐元素乘法。
Swish：​ xσ(x)

AI-A0-0280​

推理优化

推理领域

一种用于自回归模型推理的优化技术，通过维护键值缓存来避免重复计算。

键值缓存 (Key-Value Cache)​

1. 缓存结构：​ 对于每个Transformer层，维护两个缓存：键缓存 Kcache​和值缓存 Vcache​，分别存储历史时间步的键和值。
2. 初始化：​ 在推理开始前，初始化缓存为空。
3. 更新：​ 每个时间步生成新token时，计算当前步的键 kt​和值 vt​，将它们追加到缓存中：Kcache​=[Kcache​,kt​], Vcache​=[Vcache​,vt​]。
4. 注意力计算：​ 在后续时间步，直接使用缓存的键和值计算注意力，无需重新计算历史token的键值。

优点：​ 大幅减少自回归推理时的计算量， 从 O(n2)降为 O(n)（每个时间步）。
内存开销：​ 缓存大小随序列长度线性增长。

动态规划， 缓存。 通过缓存历史键值避免重复计算，提高自回归生成效率。

场景：​ 自回归语言模型推理， 如GPT、LLaMA等。
特征：​ 键值缓存， 增量更新， 节省计算。

kt​,vt​：​ 当前时间步的键和值向量。
Kcache​,Vcache​：​ 缓存的键和值矩阵，形状为 (t,dk​)和 (t,dv​)。
t：​ 当前序列长度。

追加：​ 将新向量追加到缓存矩阵。
注意力：​ 使用缓存矩阵计算注意力。

描述为“在自回归生成过程中，将每个时间步计算出的键和值保存起来，后续时间步直接使用缓存，避免重新计算历史token的键值”。

1. 初始化：Kcache​=[], Vcache​=[]。
2. 对于每个生成步 t=1,2,…：
a. 计算当前token的查询 qt​、键 kt​、值 vt​。
b. 将 kt​和 vt​追加到缓存：Kcache​=[Kcache​;kt​], Vcache​=[Vcache​;vt​]。
c. 使用 qt​和缓存的 Kcache​, Vcache​计算注意力，得到当前步的输出。
d. 基于输出预测下一个token。​

“缓存流”：​ 键流和值流在生成过程中被持续存入缓存流。每个新时间步，查询流与整个缓存流进行注意力计算，生成输出流。缓存流随着生成不断增长，但避免了重新计算历史流。

键值缓存需要为每个层和每个头维护缓存，内存占用与序列长度和层数成正比。在多GPU推理中，如果使用模型并行，每个GPU维护自己部分的缓存。

自回归生成， 注意力机制。

AI-A0-0281​

推理优化

推理领域

一种推理加速技术，通过跳过部分层或头的计算来减少推理时间。

层跳跃 (Layer Skipping)​

1. 决策：​ 对于每个输入样本，动态决定跳过哪些层或注意力头。决策可以基于输入特征、中间激活的阈值等。
2. 执行：​ 如果决定跳过某层，则直接将该层的输入作为输出，或使用简单的变换（如恒等映射）。
3. 训练：​ 通常需要在训练时引入相关约束或辅助损失来学习跳跃决策。

优点：​ 减少计算量， 加速推理。
挑战：​ 可能降低模型性能， 需要精心设计跳跃策略。

动态计算， 自适应推理。 根据输入难度自适应跳过部分计算，提高效率。

场景：​ 对推理速度要求高， 且可以接受轻微性能下降的场景。
特征：​ 动态决策， 跳过层或头， 需要训练。

xl​：​ 第 l层的输入。
zl​：​ 跳跃决策，0表示跳过，1表示执行。
fl​：​ 第 l层的变换函数。

条件执行：​ yl​=zl​⋅fl​(xl​)+(1−zl​)⋅xl​。

描述为“根据输入样本的特征，动态决定是否执行某些层或注意力头，跳过不必要的计算”。

1. 对于每个输入样本，逐层处理：
a. 计算跳跃决策 zl​=g(xl​)（例如，通过一个轻量级分类器）。
b. 如果 zl​=1，则计算 yl​=fl​(xl​)；否则 yl​=xl​。
c. 将 yl​作为下一层的输入。
2. 重复直到输出层。​

“条件计算流”：​ 网络流在每一层经过一个决策节点，决定是否进入该层的计算流。如果跳过，则输入流直接绕过该层流；否则，输入流进入该层流进行变换。这使得简单样本可以快速通过，复杂样本经历更多计算流。

层跳跃在推理时可以减少计算量，但决策本身可能引入开销。在多GPU中，跳跃决策可能导致负载不均衡。

动态网络， 条件计算。

AI-A0-0282​

推理优化

推理领域

一种推理加速技术，将模型量化为低精度（如INT8）以减少内存占用和加速计算。

训练后量化 (Post-Training Quantization, PTQ)​

1. 校准：​ 使用少量校准数据，计算每一层激活的统计量（如最大值、最小值）。
2. 量化：​ 将权重和激活从FP32量化为INT8。例如，对于张量 x，xint8​=clip(⌊sx​⌉,−128,127)，其中 s是缩放因子，⌊⋅⌉表示四舍五入。
3. 反量化：​ 在计算过程中，将INT8值反量化为FP32进行运算，或直接使用整数运算。

优点：​ 减少模型大小， 加速推理， 降低内存带宽需求。
精度损失：​ 可能轻微降低模型精度。

模型压缩， 量化。 将模型参数和激活从高精度浮点数量化为低精度整数，以加速推理。

场景：​ 边缘设备部署， 需要减少模型大小和加速推理。
特征：​ 训练后量化， 无需重新训练， 校准数据。

x：​ 原始FP32张量。
s：​ 缩放因子，$s = \frac{\max(

x

)}{127}。<br>∗∗x_{\text{int8}}$：**​ 量化后的INT8张量。

线性量化：​ xint8​=round(x/s)。
反量化：​ x′=xint8​⋅s。

描述为“使用校准数据确定缩放因子，将训练好的模型权重和激活量化为低精度整数，推理时再进行反量化或直接使用整数计算”。

1. 准备少量校准数据。
2. 对于每一层：
a. 运行校准数据，收集激活的分布。
b. 根据分布确定缩放因子 s（例如，使用最大绝对值）。
c. 将权重和激活量化到INT8。
3. 将量化后的模型部署，推理时使用整数运算或反量化后计算。​

“量化压缩流”：​ 原始高精度权重流和激活流通过量化操作被压缩为低精度整数流。在推理时，整数流通过反量化恢复为近似的高精度流进行计算，或者直接使用整数运算流。这减少了数据流的大小，提高了计算效率。

AI-A0-0283​

推理优化

推理领域

一种推理加速技术，在训练过程中模拟量化操作，使模型适应量化误差。

量化感知训练 (Quantization-Aware Training, QAT)​

1. 插入伪量化节点：​ 在训练的前向传播中，在权重和激活后插入伪量化操作，模拟量化过程。伪量化包括量化和反量化：xquant​=quantize(x)=dequantize(round(x/s))。
2. 训练：​ 使用带有伪量化的模型进行训练，反向传播时通过直通估计器（Straight-Through Estimator, STE）传递梯度。
3. 部署：​ 训练完成后，将模型转换为真正的量化模型。

优点：​ 相比PTQ， 通常精度损失更小， 模型更适应量化。
训练开销：​ 增加了训练时间。

量化， 训练模拟。 在训练中模拟量化过程，使模型参数适应低精度表示。

场景：​ 对精度要求较高的量化部署。
特征：​ 训练时模拟量化， 使用STE， 精度更高。

x：​ 原始张量。
s：​ 缩放因子，可学习或固定。
round：​ 四舍五入函数。
STE：​ 在反向传播中，将伪量化节点的梯度直接传递。

伪量化：​ xquant​=dequantize(round(x/s))。
STE：​ ∂x∂L​=∂xquant​∂L​。

描述为“在训练过程中插入模拟量化的操作，使模型在训练时就适应量化带来的误差，从而在真正量化时保持更高精度”。

1. 在训练图中插入伪量化节点：在权重和激活后加入量化和反量化操作。
2. 前向传播：使用伪量化后的权重和激活进行计算。
3. 反向传播：通过STE传递梯度，即假设 ∂x∂round​=1。
4. 训练完成后，将模型转换为固定点整数模型。​

“量化模拟流”：​ 在训练流中，权重流和激活流经过伪量化模块，该模块模拟了量化噪声流。模型参数在噪声流下调整，使得最终模型对量化不敏感。训练完成后，真正的量化流取代模拟流。

QAT训练时需要模拟量化操作，可能增加训练时间。在推理时，与PTQ类似，可以使用低精度计算。

训练后量化， 模型压缩。

AI-A0-0284​

推理优化

推理领域

一种推理加速技术，将多个小矩阵乘法合并为一个大矩阵乘法，以提高GPU利用率。

矩阵乘法融合 (Matrix Multiplication Fusion)​

1. 识别：​ 在计算图中识别可以融合的连续矩阵乘法操作。例如，多个线性层可以合并为一个更大的线性层。
2. 融合：​ 将多个小矩阵乘法合并为一个大的矩阵乘法。例如，对于两个线性变换 y=W2​(W1​x)，可以合并为 y=(W2​W1​)x，前提是中间没有非线性激活。
3. 执行：​ 执行融合后的大矩阵乘法。

优点：​ 减少内核启动开销， 提高GPU利用率， 加速计算。
限制：​ 中间有非线性激活时不能直接融合。

计算图优化， 算子融合。 将多个连续的线性变换合并为一个，减少计算和内存访问开销。

场景：​ 深度学习模型推理， 尤其是Transformer中的线性层。
特征：​ 矩阵合并， 减少算子数量。

W1​,W2​：​ 两个权重矩阵。
x：​ 输入向量。
W=W2​W1​：​ 融合后的权重矩阵。

矩阵乘法结合律：​ W2​(W1​x)=(W2​W1​)x。

描述为“将多个连续的线性变换合并为一个线性变换，通过矩阵乘法的结合律减少计算步骤”。

1. 分析计算图，找到连续的线性变换（中间无非线性激活）。
2. 将多个权重矩阵相乘，得到融合后的权重矩阵 Wfused​=Wn​⋯W2​W1​。
3. 在推理时，只需计算一次矩阵乘法 y=Wfused​x。​

“融合流”：​ 多个线性变换流被合并为一个等效的线性变换流。输入流直接与融合后的权重流相乘，得到输出流，跳过了中间流，减少了计算和内存流。

矩阵乘法融合可以在编译时或运行时进行。在GPU上，大矩阵乘法可以更高效地利用Tensor Core。在多GPU中，融合后的矩阵可能更大，需要相应的并行策略。

算子融合， 计算图优化。

AI-A0-0285​

推理优化

推理领域

一种推理加速技术，将多个小操作（如加法、乘法、激活函数）融合为一个内核，减少内核启动开销。

算子融合 (Operator Fusion)​

1. 识别模式：​ 识别计算图中经常连续出现的小操作，如卷积后接批归一化再接激活函数。
2. 融合：​ 将这些小操作合并为一个自定义的内核（kernel）。
3. 执行：​ 调用融合内核一次完成所有操作。

优点：​ 减少内核启动和内存访问开销， 加速推理。
实现：​ 需要编写自定义CUDA内核或使用编译器优化。

计算图优化， 内核融合。 将多个逐元素操作或小操作合并为一个内核执行。

场景：​ 深度学习模型推理， 尤其是移动端和边缘设备。
特征：​ 小操作合并， 自定义内核。

多个小操作：​ 如 y=ReLU(BatchNorm(Conv(x)))。
融合内核：​ 一个内核实现所有操作。

组合函数：​ 将多个函数合并为一个复合函数。

描述为“将多个小的、连续的操作合并为一个内核执行，以减少内核启动次数和中间结果的内存读写”。

1. 分析计算图，找到可以融合的操作序列。
2. 编写融合内核，实现所有操作。
3. 在推理时，调用融合内核代替原来的多个小内核。​

“内核融合流”：​ 多个小操作流被合并为一个复合操作流。数据流在融合内核中连续处理，避免了中间结果流写回和读取，提高了数据局部性。

算子融合通常由深度学习编译器（如TVM、TensorRT）自动完成。在GPU上，融合内核可以减少全局内存访问，提高带宽利用率。

矩阵乘法融合， 计算图优化。

AI-A0-0286​

训练优化

训练领域

一种优化器，结合了动量和自适应学习率，并进行了偏差校正。

Adam (Adaptive Moment Estimation)​

1. 初始化：​ 一阶矩 m0​=0，二阶矩 v0​=0，时间步 t=0。
2. 计算梯度：​ gt​=∇θ​L(θt−1​)。
3. 更新一阶矩：​ mt​=β1​mt−1​+(1−β1​)gt​。
4. 更新二阶矩：​ vt​=β2​vt−1​+(1−β2​)gt2​。
5. 偏差校正：​ m^t​=mt​/(1−β1t​), v^t​=vt​/(1−β2t​)。
6. 参数更新：​ θt​=θt−1​−αv^t​​+ϵm^t​​。

优点：​ 自适应学习率， 对噪声鲁棒， 通常收敛快。
超参数：​ α（学习率），β1​=0.9，β2​=0.999，ϵ=1e−8。

自适应优化， 动量， 二阶矩。 结合动量法和RMSProp，并引入偏差校正。

场景：​ 深度学习训练， 尤其是Transformer。
特征：​ 一阶矩（动量）， 二阶矩（自适应学习率）， 偏差校正。

θ：​ 模型参数。
gt​：​ 当前梯度。
mt​,vt​：​ 一阶和二阶矩估计。
β1​,β2​：​ 衰减率。
α：​ 学习率。
ϵ：​ 小常数。
t：​ 时间步。

指数移动平均：​ 一阶和二阶矩。
偏差校正：​ 除以 1−βt。
逐元素更新：​ 每个参数有自己的学习率。

描述为“维护梯度的一阶矩（动量）和二阶矩（梯度平方）的指数移动平均，进行偏差校正后，用校正后的矩更新参数”。

1. 初始化 m=0,v=0,t=0。
2. 对于每个训练步：
a. t=t+1
b. 计算梯度 gt​
c. mt​=β1​mt−1​+(1−β1​)gt​
d. vt​=β2​vt−1​+(1−β2​)gt2​
e. m^t​=mt​/(1−β1t​)
f. v^t​=vt​/(1−β2t​)
g. θt​=θt−1​−αm^t​/(v^t​​+ϵ)
3. 重复直到收敛。​

“自适应动量”流：​ 梯度流 gt​被两个指数移动平均流捕获：一阶矩流 mt​（动量）和二阶矩流 vt​（梯度平方）。偏差校正流消除初始零偏置。更新流中，每个参数的学习率自适应地由 v^t​的平方根倒数缩放，使得梯度大的参数更新小，梯度小的参数更新大。动量流 m^t​提供平滑的更新方向。

Adam需要为每个参数维护两个状态 m和 v。在数据并行中，梯度聚合后，每个GPU用相同的梯度更新本地状态，因此状态保持一致。在模型并行中，参数和状态分布在多个GPU上，更新需要通信或本地进行。

AdamW， RMSProp， 动量法。

AI-A0-0287​

训练优化

训练领域

Adam的变体，将权重衰减与参数更新解耦，直接添加到更新步骤中。

AdamW​

1. 计算梯度：​ gt​=∇θ​L(θt−1​)（不包含权重衰减项）。
2. 更新一阶矩和二阶矩：​ 同Adam：mt​=β1​mt−1​+(1−β1​)gt​, vt​=β2​vt−1​+(1−β2​)gt2​。
3. 偏差校正：​ m^t​=mt​/(1−β1t​), v^t​=vt​/(1−β2t​)。
4. 参数更新：​ θt​=θt−1​−α(v^t​​+ϵm^t​​+λθt−1​)，其中 λ是权重衰减系数。

优点：​ 权重衰减与自适应学习率解耦， 通常比Adam泛化更好。
解耦：​ 权重衰减项 λθ直接加到更新中。

自适应优化， 权重衰减。 将权重衰减从损失函数中分离，直接应用于参数更新，避免与自适应学习率耦合。

场景：​ 训练大型模型如Transformer， 需要权重衰减正则化。
特征：​ 解耦权重衰减， 更新公式包含显式权重衰减项。

θ：​ 参数。
λ：​ 权重衰减系数。
其他同Adam。​

加法项：​ 更新中直接加 λθ。
解耦：​ 权重衰减独立于梯度计算。

描述为“在Adam更新公式中，额外添加一个权重衰减项，直接作用于参数，而不是通过损失函数”。

1. 计算梯度 gt​（不包含权重衰减）。
2. 更新一阶矩 mt​和二阶矩 vt​同Adam。
3. 计算校正后矩 m^t​,v^t​。
4. 更新参数：θt​=θt−1​−α(v^t​​+ϵm^t​​+λθt−1​)。​

“解耦正则化”流：​ 在AdamW中，权重衰减流 λθ直接与自适应更新流 αm^t​/(v^t​​+ϵ)相加。这与传统Adam（权重衰减通过损失函数影响梯度）不同，避免了权重衰减与自适应学习率之间的耦合，使得正则化效果更稳定，模型泛化更好。

与Adam类似，但更新步骤中多了一项权重衰减。权重衰减项可以本地计算，无需额外通信。在多GPU数据并行中，每个GPU独立计算权重衰减项并更新本地参数副本。

Adam， 权重衰减， L2正则化。

AI-A0-0288​

训练优化

训练领域

一种学习率调度策略，学习率在训练过程中按余弦函数从初始值衰减到最小值。

余弦退火 (Cosine Annealing)​

1. 学习率公式：​ ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(Tmax​Tcur​​π))，其中 Tcur​是当前步数，Tmax​是总步数（或周期长度）。
2. 变化：​ 学习率从 ηmax​开始，按余弦函数平滑下降到 ηmin​。

特点：​ 平滑下降， 避免学习率突变， 有助于模型收敛到更优解。
超参数：​ ηmax​, ηmin​, Tmax​。

学习率调度， 余弦函数。 使用余弦函数平滑调整学习率。

场景：​ 深度学习训练， 如图像分类、自然语言处理。
特征：​ 余弦曲线， 平滑衰减， 可周期性重启。

ηt​：​ 当前学习率。
ηmax​：​ 最大学习率。
ηmin​：​ 最小学习率。
Tcur​：​ 当前步数。
Tmax​：​ 总步数或周期长度。

余弦函数：​ cos(πTcur​/Tmax​)。
线性变换：​ 映射到 [ηmin​,ηmax​]。

描述为“学习率按余弦函数从最大值平滑衰减到最小值”。

1. 设置最大学习率 ηmax​、最小学习率 ηmin​、总步数 Tmax​。
2. 对于每个训练步 t（Tcur​=t）：
a. 计算学习率 ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(πt/Tmax​))。
b. 使用 ηt​更新参数。
3. 当 t=Tmax​时，可停止或重启（带热重启）。​

“余弦衰减”流：​ 学习率流 ηt​随时间 t按余弦曲线从 ηmax​平滑下降到 ηmin​。这种平滑下降避免了阶梯式下降的突变，允许模型在初期以较大学习率快速收敛，后期以较小学习率精细调整，有助于找到更平坦的最小值。

学习率调度器在训练循环中每一步更新学习率。在多GPU训练中，通常由主进程计算学习率并广播，或每个进程独立计算相同值。

带热重启的余弦退火， 学习率调度。

AI-A0-0289​

训练优化

训练领域

一种学习率调度策略，学习率在指定步数或epoch处乘以一个衰减因子。

步长衰减 (Step Decay)​

1. 定义：​ 学习率在预定义的步数或epoch处衰减。例如，每 s步将学习率乘以 γ（如0.1）。
2. 公式：​ ηt​=η0​⋅γ⌊t/s⌋，其中 η0​是初始学习率，s是步长，γ是衰减因子。
3. 也可基于epoch：​ 每 k个epoch衰减一次。

特点：​ 简单， 常用， 但衰减可能过于激进。
超参数：​ 初始学习率 η0​， 衰减因子 γ， 步长 s。

学习率调度， 指数衰减。 按固定步长降低学习率。

场景：​ 各种深度学习任务， 尤其是训练收敛后期。
特征：​ 阶梯式下降， 预定义衰减点。

ηt​：​ 当前学习率。
η0​：​ 初始学习率。
γ：​ 衰减因子（0<γ<1）。
s：​ 衰减步长（多少步衰减一次）。
t：​ 当前步数。

指数衰减：​ ηt​=η0​γ⌊t/s⌋。
阶梯函数：​ 每隔 s步变化。

描述为“每经过固定的步数，学习率乘以一个小于1的衰减因子，呈阶梯式下降”。

1. 设置初始学习率 η0​，衰减因子 γ，步长 s。
2. 对于每个训练步 t：
a. 计算当前衰减次数 k=⌊t/s⌋。
b. 学习率 ηt​=η0​⋅γk。
c. 使用 ηt​更新参数。
3. 重复直到训练结束。​

“阶梯下降”流：​ 学习率流 ηt​在大多数时间保持恒定，每经过 s步就突然下降为原来的 γ倍。这种离散的下降允许模型在某个学习率下稳定训练一段时间，然后进入更精细的调整阶段。

实现简单，只需在训练循环中检查当前步数是否达到衰减点。在多GPU中，学习率值需要同步。

指数衰减， 学习率调度。

AI-A0-0290​

训练优化

训练领域

一种学习率调度策略，学习率随训练步数线性增加，然后线性或余弦衰减。

带热重启的余弦退火 (Cosine Annealing with Warm Restarts)​

1. 周期：​ 训练分为多个周期，每个周期内学习率按余弦函数从初始值衰减到最小值。
2. 公式：​ ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(Ti​Tcur​​π))，其中 Tcur​是当前周期内的步数，Ti​是当前周期的总步数。
3. 重启：​ 每个周期结束时，学习率重置为 ηmax​，并可能增加周期长度。

优点：​ 周期性重启有助于跳出局部最优， 提高模型性能。
超参数：​ ηmax​, ηmin​, Ti​（周期长度）。

学习率调度， 周期性重启。 通过余弦衰减和周期性重启来调整学习率。

场景：​ 训练深度神经网络， 尤其是图像分类和自然语言处理。
特征：​ 余弦衰减， 周期性重启， 学习率先增后减。

ηt​：​ 当前学习率。
ηmax​：​ 周期内最大学习率。
ηmin​：​ 周期内最小学习率。
Tcur​：​ 当前周期内已执行步数。
Ti​：​ 当前周期的总步数。

余弦函数：​ 学习率按余弦变化。
周期性：​ 周期结束后重启。

描述为“学习率在每个周期内按余弦函数从最大值衰减到最小值，周期结束后重启到最大值，并可能延长周期”。

1. 初始化周期长度 Ti​，最大学习率 ηmax​，最小学习率 ηmin​。
2. 每个训练步 t，计算当前周期内步数 Tcur​。
3. 计算学习率 ηt​=ηmin​+21​(ηmax​−ηmin​)(1+cos(πTcur​/Ti​))。
4. 如果 Tcur​=Ti​，则重启：Tcur​=0，可选地增加 Ti​（如乘以因子）。​

“余弦振荡”流：​ 学习率流在每个周期内遵循余弦曲线，从高点 ηmax​平滑下降到低点 ηmin​。这种下降允许模型在初期快速收敛，后期精细调整。周期结束时，学习率流突然跳回高点（重启），模拟“重启”训练，有助于模型跳出可能的局部最优点，探索新的区域。

学习率调度器在训练循环中每一步更新学习率。在多GPU训练中，通常由主进程（rank 0）计算学习率并广播给所有进程，或每个进程独立计算相同值。

余弦退火， 学习率调度， 热重启。

AI-A0-0291​

训练优化

训练领域

一种优化技巧，在多个小批量上累积梯度，然后一次性更新参数，模拟更大的批量大小。

梯度累积 (Gradient Accumulation)​

1. 过程：​ 对于 N个连续的小批量（micro-batch），每次前向传播后计算梯度，但不立即更新参数，而是将梯度累加到累积变量中。
2. 更新：​ 每累积 N个小批量后，用累积梯度除以 N（可选，用于平均）更新参数，然后清零累积梯度。
3. 数学：​ 设第 i个小批量的梯度为 gi​，累积梯度 G=∑i=1N​gi​。更新参数 θ=θ−α⋅NG​（如果取平均）。

目的：​ 在内存有限时模拟大批量训练， 稳定训练， 允许使用更大的有效批量大小。
N：​ 累积步数， 如4、8、16。

优化技巧， 内存效率。 通过多次前向-反向传播累积梯度，实现更大的有效批量大小。

场景：​ 当GPU内存不足以容纳大批量时， 训练大模型。
特征：​ 梯度累加， 延迟更新， 模拟大批量。