技术博客 | 记录学习笔记和思考

以下内容由AI辅助生成

大模型时代，“微调”和“蒸馏”几乎是绕不开的两个词。它们常被放在一起谈论，却很容易在直觉上造成混淆：微调像是在“补课”，蒸馏像是在“提纯”。尤其是蒸馏——这个词本身带来的隐喻，常常让人误以为小模型把大模型的“知识”抽出来装进自己身体里，从而变得更小、更强。要把这些误解拆干净，必须回到机器学习最底层的一件事：模型到底在学什么。

一、机器学习的本质：学的是函数，不是规则或知识库

神经网络在训练中做的事情，可以抽象为逼近一个映射：

输入 可能是文本 token、图像像素或多模态特征；输出 在多数任务里并不是一个确定值，而是一个概率分布（分类分布、下一个 token 分布、动作分布等）。训练的核心动作是通过反向传播调整参数 ，让模型输出的分布更接近我们希望它输出的分布。

这句话很关键：模型并不“存知识”，模型在参数空间里表示并实现一个函数。所谓“能力”，是该函数在某一类输入分布上的行为表现。理解这一点，是理解微调和蒸馏的前提。

二、微调：在同一个函数族里，朝目标任务的方向挪一步

预训练模型已经在海量数据上学到通用表征与语言规律，微调做的不是从零开始，而是在此基础上继续优化：

• 目标变化：从“通用语料上的预测/建模”变成“更贴近某个任务或领域的输出行为”
• 训练信号：来自任务数据（可以是监督标签、偏好对齐、指令数据等）
• 参数更新：通常相对温和，尽量保留通用能力，同时在目标分布上表现更好

从本质上看，微调是：在同一类模型结构与参数化方式下，把当前函数 推到更适合目标任务的局部最优区域。它并不要求模型变小，也不直接解决部署效率问题。

三、蒸馏为什么会出现：普通监督训练在信息上“太粗糙”

要理解蒸馏，必须先理解一个常被忽略的事实：很多监督训练的标签信息量非常低。

典型分类任务里，标签通常是 one-hot：正确类为 1，其余为 0。这种信号只表达“对/错”，但不表达“错得有多接近”。例如在图像分类中，“猫”和“狗”相似，“猫”和“车”差异巨大，但 one-hot 标签对两种错误一视同仁。于是模型只能从数据中自己摸索类别相似结构，训练过程更依赖容量和数据规模，也更受噪声影响。

而一个高容量、训练充分的大模型往往能输出更丰富、更结构化的分布：它不仅告诉你答案更可能是什么，还隐含表达了类别/候选之间的相对关系。这部分“分布形状里的结构信息”，是监督标签没有提供的。

蒸馏就是要利用这部分信息。

四、蒸馏的本质：让小模型逼近大模型的输入–输出函数

剥离所有隐喻，蒸馏就是一句话：

用一个已训练好的模型产生监督信号，让另一个模型在其可表达范围内逼近前者的函数行为。

形式化地说，Teacher（大模型）对输入 输出分布 ，Student（小模型）输出 。蒸馏训练让两者分布尽量一致，常见做法是最小化 KL 散度或交叉熵形式的距离：

这就是所谓“用大模型教小模型”的准确含义：Teacher 不“传递知识”，Teacher 生成目标函数值（软分布），Student 用这些值作为训练目标去拟合。Teacher 更像高质量标注器或目标函数提供者，而不是把内部结构“复制”给 Student。

温度参数（Temperature）常被用来“拉平”分布，让次优类别的差异更显著，使 Student 看见更细的相对关系。本质上这不是花活，而是增强监督信号的结构表达。

五、最关键的疑问：为什么“拟合得更好”反而还能更小？

直觉上的矛盾来自把三件事混为一谈：学到的东西多不多、拟合好不好、参数多不多。但这三者并不等价。蒸馏之所以能让小模型“更小却更好”，核心原因并不是小模型凭空获得了更多自由度，而是学习问题本身被 Teacher 改写并简化了。

1. Teacher 让学习目标更平滑、更低噪声

真实数据的标签往往带噪、带冲突、信息粗糙；而 Teacher 输出是对数据分布与表示结构的“平均化”结果，通常更稳定、更一致。Student 不需要在噪声里硬扛，而是在一个更干净的目标上学习。

2. Teacher 实际上缩小了 Student 的“搜索空间”

没有蒸馏时，小模型要在复杂、崎岖的损失地形上寻找一个能解释数据的解；蒸馏后，小模型面对的是 Teacher 已经找到的解所诱导的目标行为。换句话说，Teacher 做了“找解”的重活，Student 做的是“在有限表达能力下逼近这个解”。

从函数空间角度更准确地说：蒸馏是投影，不是提纯。Student 能达到的最优结果是把 Teacher 的行为投影到 Student 的函数族里：

因此，小模型“更好”往往意味着：在给定任务与输入分布上，它更接近 Teacher 的行为；并不意味着它获得了 Teacher 的全部能力，更不意味着它需要与 Teacher 同等容量。

3. “信息更多”并不意味着“不可压缩”

Teacher 输出分布包含更丰富的结构，但结构化信息往往高度可压缩。蒸馏提供的不是随机额外信息，而是带强规律、强冗余的函数形状；这类信息并不需要同等参数量才能表达。

大模型的巨大容量更多服务于训练阶段——需要覆盖多任务、处理极端样本、应对噪声数据。当 Teacher 将这些复杂性平滑与约束后，问题本身的复杂度下降，小模型就有机会以更少参数逼近核心行为。

一句话总结：蒸馏不是让小模型“变得拥有大模型同等复杂的内部”，而是让世界（训练目标）变得更容易学。

六、重新审视“蒸馏”这个词：确实容易误导

“蒸馏（distillation）”这个命名来自早期工程语境：把大模型性能“浓缩”到小模型，便于部署。它暗示一种“提纯精华”的过程，容易让人联想到知识可分离、能力可转移、内部机制可复制——这些都不是蒸馏的真实机制。

更贴近本质的描述其实是：

• 教师引导的函数逼近（teacher-guided function approximation）
• 行为模仿学习（behavioral imitation learning）
• 函数空间投影（function space projection）
• 模型到模型的监督（model-to-model supervision）

这些说法没有诗意，但准确：Student 学到的是 Teacher 在特定输入分布下的输出行为的可表示部分，并在该部分上得到强化。

七、把两者放在一起：微调解决“对不对”，蒸馏解决“省不省”

微调与蒸馏可以视为两种不同维度的操作：

• 微调：改变模型的能力边界——让模型学会它原本不擅长的事，改变输出的内容、风格、准确性
• 蒸馏：不改变能力，只改变实现方式——模型该会什么还是会什么，只是用更小的参数量来实现同样的行为

典型应用场景

只需要微调的情况：

• 现有模型在目标任务上表现不够好（如通用模型不精通医疗领域）
• 需要改变输出风格或遵循特定规范（如企业话术、格式要求）
• 要让模型适应新的数据分布或领域知识

只需要蒸馏的情况：

• 现有模型能力足够，但推理成本太高、速度太慢
• 需要部署到资源受限的环境（移动端、边缘设备）
• 在保持性能的前提下降低服务成本

两者结合的情况（工业界最常见）：
先把大模型微调成领域专家，再把该专家的行为蒸馏到小模型，以获得可落地的低成本版本。例如：用医疗数据微调 GPT-4 级别模型成为医疗助手，然后蒸馏到 GPT-3.5 级别大小，既保留专业能力，又控制部署成本。

决策逻辑

从需求方角度，可以问两个问题：

1. 现有模型能力够不够？ 不够 → 需要微调
2. 现有模型资源消耗能不能接受？ 不能 → 需要蒸馏

这两个问题是正交的：微调后你得到更聪明的模型，蒸馏后你得到更便宜的模型。其背后的统一视角很简单：先把目标函数找对，再把它表示得更省。

结语：从“知识”回到“函数”，很多矛盾会自动消失

一旦把模型从“知识容器”还原成“函数近似器”，微调与蒸馏就不再神秘：

• 微调是在参数空间里把函数挪向目标任务
• 蒸馏是让另一个受限函数族去逼近已得到的函数行为

小模型之所以能更小却更好，并不是违背容量常识，而是因为 Teacher 改写了学习目标、降低了问题复杂度，让 Student 不再在原始世界里盲搜，而是在更平滑、更结构化的监督信号上学习。

蒸馏这个词或许不够好，但它指向的机制很明确：不是“抽取能力”，而是“拟合行为”；不是“提纯精华”，而是“投影逼近”。理解这一点，就能在面对各种蒸馏、对齐、压缩、部署策略时保持清醒，并做出更符合实际的建模选择。

以下内容由AI辅助生成

围绕“梯度如何被正确使用”的完整演化路径

一、优化器的本质问题：梯度告诉我们方向，但不告诉我们步长

训练神经网络本质是求解优化问题：

反向传播提供梯度 ，它指明了损失下降最快的方向。

但梯度本身无法回答三个关键问题：

1. 该走多快？ —— 学习率的选择
2. 不同参数该以不同速度更新吗？ —— 自适应性需求
3. 如何在噪声和非平稳环境中保持稳定？ —— 鲁棒性需求

优化器的演化史，正是围绕这三个问题展开的。

二、SGD：最简单的假设，最脆弱的前提

2.1 SGD 的更新规则

它隐含一个强假设：所有参数的几何性质相似，可使用统一学习率。

2.2 SGD 的结构性缺陷

在高维非凸优化中（深度网络的常态）：

• 不同方向梯度尺度差异巨大：某些方向陡峭，某些方向平缓
• 统一步长导致震荡：在陡峭方向步长过大，在平缓方向步长过小

直觉图示（损失函数等高线）：

1
2
3
4
5
6

  陡峭方向
     ↓
x ← 震荡
 ↘ ↗
  ↘ ↗  ← SGD 在峡谷中左右震荡
    → 平缓方向（目标方向）

核心问题：步长对所有方向一视同仁。

三、Momentum：用惯性平滑震荡

3.1 引入历史信息

物理类比：像一个滚动的球，在主方向上加速，在震荡方向上相互抵消。

3.2 改进与局限

✅ 改进：平滑了更新方向，加速了沿一致方向的收敛
❌ 局限：仍使用统一学习率，无法解决参数间尺度差异问题

Momentum 提升了方向的稳定性，但没有解决步长的合理性。

四、Adam：参数级自适应学习率

4.1 核心创新：每个参数有独立的有效学习率

Adam 维护两类统计量：

一阶矩（梯度的指数移动平均）：

二阶矩（梯度平方的指数移动平均）：

4.2 自适应更新规则

（其中 为偏置修正后的估计）

关键机制：

• 梯度持续较大的参数 → 分母大 → 有效步长自动变小
• 梯度稀疏或较小的参数 → 分母小 → 有效步长相对变大

这是一种对角近似的二阶优化，为每个参数提供独立的“油门”。

4.3 为什么 Transformer 特别需要 Adam？

Transformer 的参数结构高度异质：

两个核心挑战：

1. 梯度尺度异质性：不同模块的梯度幅度可能相差数个量级
2. 训练过程非平稳性：注意力模式在训练中持续演化，梯度分布随之变化

SGD 的统一学习率在这种场景下极其脆弱，而 Adam 的自适应机制能够动态调整每个参数的学习速度。

五、AdamW：修正 Adam 的正则化语义

5.1 Adam + L2 正则的隐患

传统 L2 正则将惩罚项加入损失函数：

在 Adam 中，正则化项的梯度 会被二阶矩统计 缩放，导致：

• 不同参数的实际正则化强度不一致
• 偏离 weight decay 作为“参数收缩”的原始语义

5.2 AdamW 的解耦策略

关键改变：将 weight decay 从梯度计算中分离，直接作用于参数。

效果：

• 所有参数受到一致的衰减比例
• 泛化性能更稳定
• 更适合大规模 Transformer 模型

六、Warmup：应对训练初期的非平稳性

6.1 训练初期的特殊挑战

训练开始时：

• 参数随机初始化，注意力模式尚未形成
• 梯度分布极不稳定，方差巨大
• Adam 的二阶矩估计 尚未收敛到可靠值

此时若使用完整学习率，可能导致：

• 某些参数的更新幅度过大
• 训练轨迹进入不良局部区域
• 甚至数值不稳定（梯度爆炸）

6.2 Warmup 的策略

在前 步中，学习率从接近 0 线性增长到目标值 ：

1
2
3
4
5
6
7

学习率
  ^
  |          ___________
  |         /
  |        /
  |_______/________________> 训练步数
        warmup 阶段

6.3 Warmup 的本质作用

不是改善统计估计本身，而是降低对不可靠统计的依赖：

• 限制初期更新幅度，给模型“热身”时间
• 避免在梯度分布剧烈波动时做出激进更新
• 为注意力结构的形成提供稳定的初始化路径

这是针对训练初期高度非平稳性的工程性保护机制。

七、完整的演化逻辑链

1
2
3
4
5

SGD                    问题：统一步长 → 震荡
 └─ Momentum           改进：平滑方向 → 但仍统一步长
     └─ Adam           突破：参数级自适应 → 但正则化有问题
         └─ AdamW      修正：解耦 weight decay → 但初期不稳定
             └─ Warmup 保护：渐进式启动

这不是技巧的简单堆叠，而是针对深度学习训练的结构性难题，逐层提出的解决方案。

八、本质性总结

本质一：梯度方向 ≠ 合理的更新幅度

梯度只告诉我们“往哪走”，但：

• 不同参数的敏感度不同
• 不同训练阶段的可靠性不同
• 需要参数级的自适应调整

本质二：Transformer 训练是高度非平稳的系统

• 注意力模式从混乱到有序
• 梯度分布随结构演化而变化
• 需要动态适应梯度统计变化的机制

本质三：现代优化器更“谦虚”而非更“聪明”

• SGD 假设世界简单：所有参数同质
• Adam 承认世界复杂：不同参数不同尺度
• Warmup 承认认知有限：早期统计不可靠
• AdamW 承认需要解耦：优化与正则是不同的目标

核心结论

Transformer 的优化难点不在于“朝哪个方向走”，
而在于：

• 谁该走多快？ → Adam 的自适应机制
• 正则化如何不干扰优化？ → AdamW 的解耦
• 什么时候可以全速前进？ → Warmup 的渐进策略

这三者的组合，构成了现代 Transformer 训练的标准配置。

以下内容由AI辅助生成

在前文中，我们已经看到：在 Skip-gram + Negative Sampling 中，embedding 是通过一个明确的预测任务（预测上下文）和损失函数，从语料中逐步学习得到的。那么在 Transformer 模型中，embedding 是否还是同一件事？是否还在「学习词向量」？如果是，学习机制发生了哪些变化？

要回答这些问题，关键不是看模型结构有多复杂，而是看 embedding 在优化目标中处于什么位置、承担什么功能。

1. 统一视角：embedding 本质上都是「可学习的参数表」

无论是 Word2Vec 还是 Transformer，embedding 在数学形式上完全一致：

• 都是一个矩阵
• 每个 token id 对应一行向量
• 向量的数值由随机初始化开始，通过反向传播不断更新

embedding 并不是「预定义的语义表示」，而是模型参数的一部分。

两类模型的差异不在于 embedding 「是不是参数」，而在于：

embedding 通过什么任务、在什么结构中、被什么损失函数约束。

2. Word2Vec 中的 embedding：直接优化目标

在 Skip-gram + Negative Sampling 中，embedding 具有以下特点：

2.1 训练机制

• 直接目标：区分「真实共现的词对」和「随机词对」
• 损失函数：只依赖于
• 更新驱动：完全由局部上下文共现统计驱动

2.2 核心特征

1. 训练目标是「预测上下文」
2. 上下文窗口是局部的、固定大小的
3. embedding 本身就是最终产出（训练完成即可单独使用）
4. embedding 是上下文无关的：同一个词始终对应同一个向量

2.3 两张表的设计

Word2Vec 显式区分：

• 输入向量表
• 输出向量表

这种设计不是偶然的，而是一个更一般建模选择的特例（我们稍后会在 Transformer 中看到它的推广）。

3. Transformer 中的 embedding：深层计算的起点

3.1 结构位置的变化

以 GPT/BERT 为例，Transformer 的输入层由三部分组成：

1. Token Embedding（词或子词向量）
2. Position Embedding（位置信息）
3. （BERT 中还有 Segment Embedding）

它们相加后形成模型的初始输入：

1

h_0 = E_token[x] + E_pos[p] (+ E_seg)

从这一刻开始，token embedding 不再直接用于预测，而是：

• 作为整个深层计算图的起点
• 被送入多层 self-attention 与前馈网络
• 在多层变换后，间接影响最终的预测结果

3.2 训练目标的根本变化

Transformer 中，embedding 不再通过「预测上下文词」这个局部任务来学习，而是通过语言模型目标：

• GPT（自回归语言模型）：

• BERT（掩码语言模型）：

3.3 梯度传播路径

embedding 的更新路径是：

只要某个 token 出现在输入中，其 embedding 向量就会：

1. 参与 self-attention 的 Q/K/V 计算
2. 影响上下文表示
3. 间接影响最终的预测概率
4. 在反向传播中获得梯度并被更新

这一点与 Word2Vec 完全一致：只要 embedding 参数出现在 loss 的计算路径上，就会被梯度下降更新。embedding 的梯度来源是：

预测整个序列中某个 token 的损失，通过多层 Transformer 反向传播而来。

4. 关键区分：上下文无关 embedding vs 上下文相关表示

这是连接 Word2Vec 与 Transformer 时最容易混淆、也最关键的一点。

4.1 Transformer 中真正「上下文相关」的是什么？

在 Transformer 中：

• Token embedding 表本身仍然是上下文无关的

• 真正随上下文变化的是每一层 Transformer 的 hidden state

1

h_l^(t) = f_l( h_(l-1)^(1:t) )

因此：

• embedding ≈ 初始词表示（类似 Word2Vec 的输出）
• hidden states ≈ 上下文相关的动态表示

4.2 对比总结

5. 权重共享：从「两张表」到统一设计

Transformer 中通常采用 weight tying（权重共享）：

其中 是输出 softmax 层的权重矩阵。

这可以被理解为：

• Word2Vec 中「输入表/输出表是否共享」的一个推广版本
• Transformer 在大模型、充足数据下显式引入共享约束
• 以减少参数量、提高泛化性

这说明：Word2Vec 中「两张表」的设计并非偶然，而是一个更一般建模选择的特例。

6. 统一原理：embedding 都是被损失函数塑造的参数

将 Word2Vec 与 Transformer 统一起来，可以得到以下结构化理解：

6.1 共同点

1. Embedding 在两类模型中都是可学习参数
2. Embedding 的更新都来源于预测任务的损失函数
3. Embedding 都是被梯度下降间接塑造的，而非预定义的语义容器

6.2 差异点

1. 预测目标复杂度：局部上下文 vs 全局序列
2. 上下文建模能力：固定窗口 vs 多层 self-attention
3. 最终产出：Word2Vec 在 embedding 层「结束」，Transformer 在 embedding 层「开始」
4. 语义表示：Word2Vec 直接使用 embedding，Transformer 使用经过多层变换的 hidden states

6.3 演化总结

用一句话概括这种演化：

在 Word2Vec 中，embedding 是学习的最终目标；
在 Transformer 中，embedding 是深层推理的起点。

更具体地说：

• Word2Vec：embedding ≈ 对语料共现结构的直接建模结果
• Transformer：embedding ≈ 底层词汇信息的参数化入口，真正的语义组合发生在多层 self-attention 中

但二者在本质上仍然统一于同一原则：

Embedding 是被损失函数通过梯度下降间接塑造的参数，而非预定义的语义容器。

7. 总结

理解 embedding 从 Word2Vec 到 Transformer 的演化，关键在于认识到：

1. 数学本质不变：都是可学习的参数矩阵，都通过反向传播更新
2. 训练目标升级：从局部上下文预测到全局序列建模
3. 功能定位转变：从最终输出到计算起点
4. 上下文建模深化：Transformer 的上下文相关性来自 hidden states，而非 embedding 表本身
5. 设计选择延续：输入/输出表的关系在两类模型中都是重要的建模决策

这种演化不是断裂的，而是在统一的优化原理下，针对更复杂任务的自然扩展。

以下内容由AI辅助生成

神经网络训练的过程，看起来是在“学习语义”或“理解结构”，但在更底层，它其实是一件非常朴素的事情：
一层一层地传递和变换数字。

而几乎所有训练不稳定、梯度异常、不收敛的问题，最终都可以归结为一个原因：

中间数值的尺度失控了。

LayerNorm（Layer Normalization）正是为了解决这个问题而出现的。但要真正理解它，不能从公式开始，而必须先回到一个更基础的问题：什么是归一化，神经网络为什么需要归一化。

一、什么是“归一化”：先抛开神经网络

先从一个生活中的例子出发。

假设你要比较两次考试成绩：

• 一次考试满分 150
• 另一次考试满分 100

你不能直接比较 120 分和 80 分谁更好，因为它们的尺度不同。

一个更合理的做法是：

• 减去平均值
• 再除以标准差

这样得到的数值不再依赖原始分数范围，而只反映相对水平——平均值约为 0，波动程度约为 1。

这就是归一化（Normalization）的本质思想：

不改变相对差异，只统一数值尺度。

二、神经网络为什么必须做归一化

回到神经网络。神经网络的基本操作是反复进行线性变换：

如果输入 的尺度稍微偏大，权重 没有被精细约束，那么输出 很容易比 更大或更小。

当层数不断增加时：

1

x → y → z → u → …

哪怕每一层只“放大或缩小一点点”，结果也会变成：

• 激活值越来越大（数值爆炸）
• 或越来越小（数值消失）

这就像一张图片被反复复印：复印次数一多，画面一定会失真。

于是，一个非常直接但极其重要的工程直觉出现了：

能不能在每一层之间，把数值拉回到一个“正常范围”？

这正是神经网络中各种 Normalization 方法存在的根源。

三、LayerNorm 到底在归一化什么

在 Transformer 中，每个 token 在某一层都会被表示成一个向量：

这 个数一起，构成了模型在当前层对这个 token 的全部状态描述。

LayerNorm 的做法非常明确：

• 不看其他 token
• 不看 batch
• 只对当前这个 token 自己的向量做归一化

具体来说，它会在特征维度（hidden dimension）上计算均值和方差：

然后进行标准化，并加上可学习的缩放与平移参数：

归一化之后，向量的均值约为 0、方差约为 1，但通过 和 ，模型仍然可以学习合适的尺度。

一句话总结：

LayerNorm 是对“每一个 token 自己的向量”做归一化，完全不依赖其他 token 或 batch。

四、为什么 Transformer 特别容易“数值失控”

理解了归一化之后，再看 Transformer 的结构，就会发现：它在数值层面上，天然是一个不稳定系统。

原因来自三个叠加的结构性因素：

1. Attention 是不受约束的加权求和

Attention 的输出形式是：

它本质上是多个向量的线性组合，目标是混合信息，而不是控制输出尺度。缺少约束时，某些 head 的输出可能越来越大，某些维度可能长期主导，不同 token 的数值分布会逐渐漂移。

2. 残差连接会层层累加数值

Transformer 中每一层都有残差结构：

残差的作用是保证信息通路，但它也意味着新信息会不断叠加到旧表示上，数值会随着层数持续累积。

一个常见的误解是把 residual 当作“稳定器”。更准确的说法是：

Residual 负责信息通路，但并不负责数值稳定。

3. Softmax 对尺度极其敏感

Attention 内部使用 softmax，而 softmax 只在一个很窄的数值区间内工作得好：

• 输入过大 → 接近 one-hot → 梯度几乎为 0
• 输入过小 → 接近均匀分布 → 注意力失效

Transformer 同时包含 Attention 的加权求和、Residual 的数值累加、Softmax 的高敏感性——如果没有归一化，数值失控几乎是必然的结果。

五、LayerNorm 如何“救场”

LayerNorm 的作用可以概括为一句话：

在每一层，把每个 token 的表示拉回到同一个稳定的统计坐标系。

它在 Transformer 中的分工可以用这张图来理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输入 token 向量 x
        |
        v
   [ Attention ]        <- 看别人：混合信息
        |
        v
      f(x)
        |
        +-------------------+
        |                   |
        v                   |
   [ Residual: x + f(x) ]   <- 保自己：信息不断
        |
        v
   [ LayerNorm ]            <- 稳自己：归一化、控数值
        |
        v
     交给下一层

三者的职责是：

• Attention 管信息交流
• Residual 管信息传承
• LayerNorm 管数值纪律

LayerNorm 带来的直接效果包括：

• 各层输入分布保持相对一致
• 数值不再随层数漂移
• softmax 始终工作在有效区间
• 梯度能够稳定传播

因此可以说：

没有 LayerNorm，Transformer 在数学上是一个不稳定系统；有了 LayerNorm，它才成为可训练的深层模型。

六、为什么不用 BatchNorm

在讨论 LayerNorm 时，BatchNorm 经常被拿来对比。它们同属“归一化家族”，但适用场景完全不同。

BatchNorm 的核心思想是：

利用一个 batch 内所有样本的统计量来做归一化。

这在 CNN 中非常合理（输入尺寸固定、batch 结构稳定），但在 Transformer / NLP 中，会遇到根本性冲突：

1. Batch 本身不稳定

• 句子长短不同
• padding 复杂
• 推理时常常 batch = 1

2. Token 不应被迫参考其他样本

Transformer 的设计是让 token 之间的交互只发生在 Attention 中，归一化阶段不应引入额外耦合。而 BatchNorm 恰恰会让一个 token 的数值受其他 token、其他样本影响。

LayerNorm 则完全相反：不看 batch、不看其他 token，只对自身状态做校准。

一句话总结区别：

BatchNorm 在“群体里”找尺度，LayerNorm 对“自己”做校准。

Transformer 需要的是后者。

结语：把 LayerNorm 放回正确的位置

LayerNorm 并不是 Transformer 的“附加技巧”，而是归一化思想在序列建模中的一次精准落地：

• 以 token 为基本单位
• 不依赖 batch
• 不混淆语义交互与数值校准

它让 Transformer 能在极深的结构中，始终保持数值可控、梯度可传、注意力可学习。

以下内容由AI辅助生成

引言：三个核心抽象

在理解 Transformer 之前,可以先记住三句话：

• Attention = 状态之间的信息路由
• FFN = 状态内部的非线性变换
• Multi-Head = 多种关系子空间的并行建模

这三句话不是对 Transformer 的技巧性总结,而是对其核心思想的抽象表达。它们并非 Transformer 独有的新概念,而是长期存在于神经网络中的通用思想,在 Transformer 中被系统化、模块化、工程化地组织在了一起。

Transformer 的重要性不在于它「发明了什么全新的思想」,而在于它第一次把信息如何流动和状态如何更新这两件事彻底解耦,并用统一、可扩展的结构反复堆叠,从而构建出今天的大模型体系。

整体架构概览

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输入序列: [x₁, x₂, ..., xₙ]
    ↓
[Token Embedding + Position Encoding]
    ↓
┌─────────────────────────────────────┐
│     Transformer Block (×N层)        │
│  ┌───────────────────────────────┐  │
│  │   Multi-Head Self-Attention   │  │
│  │   (信息路由：谁和谁交互)         │  │
│  └───────────────────────────────┘  │
│             ↓                       │
│      [Residual + LayerNorm]         │
│             ↓                       │
│  ┌───────────────────────────────┐  │
│  │  Feed-Forward Network (FFN)   │  │
│  │  (信息变换：交互后如何变化)       │  │
│  └───────────────────────────────┘  │
│             ↓                       │
│      [Residual + LayerNorm]         │
└─────────────────────────────────────┘
    ↓
[LM Head: 映射到词表]
    ↓
输出概率分布

上图展示了 Transformer 的整体数据流：输入经过 embedding 和位置编码后,通过 N 层相同的 Block 进行处理。每个 Block 包含两个核心组件（Attention 和 FFN）,以及用于稳定训练的残差连接和归一化。下文将逐一展开这些组件的细节。

一、Transformer 解决什么问题？

Transformer 是一种序列建模架构。它的输入和输出本质上都是 token 序列,目标是学习如下形式的函数：

其中最大的困难只有一个：

每个位置的表示,既要知道其他位置的信息,又要知道自己该如何变化。

Transformer 对这个问题的解决方案：

• 用 Attention 解决「谁和谁交互」
• 用 FFN 解决「交互之后如何变化」

这构成了 Transformer 的第一性原理。

更进一步看,Transformer 用纯 Attention 结构解决了序列建模的并行性和长距离依赖问题,也是现代大模型的结构源头：

• 并行性主要由 Self-Attention 机制 解决
• 长距离依赖主要由 Self-Attention + 多头机制 + 结构设计 共同解决

并行性是怎么解决的？

核心在于 Self-Attention + 去掉 RNN/CNN：

• Self-Attention 对整个序列做矩阵运算
• 所有 token 同时计算
• 不再有时间步依赖
• 训练从 O(n) 串行 → O(1) 层级并行

长距离依赖是怎么解决的？

靠 Self-Attention 为核心的一组组件协作完成：

• Self-Attention：任意两个位置一步直连
• Multi-Head Attention：不同 head 专门学不同远程关系
• Residual + LayerNorm：远程信息和梯度不易消失
• Positional Encoding：让“远近”有意义

一句话总括：Self-Attention 让所有位置直接互相看到,从而同时解决并行计算和长距离依赖问题。

二、输入不是「文字」,而是状态向量

1. Token 与 Tokenizer

模型不直接处理字符或词语,而是处理 token。输入文本首先经过 tokenizer,被切分为 token_id 序列。

现代 tokenizer 采用子词或字节级策略（BPE、WordPiece、Unigram、Byte-level BPE）,核心原则是：

任何输入字符最终都能被表示成 token_id 序列。

即使遇到生僻文字或罕见字符,tokenizer 也不会「找不到词表」,而是退化为更细粒度的子词甚至 UTF-8 字节表示（代价是 token 数变多）。

词表中允许存在重叠 token（如「我 / 非常 / 喜欢 / 非常喜欢」同时存在）,但一次分词只选择一条最优切分路径,不产生冗余。

2. Token Embedding

token_id 通过 embedding 矩阵映射为向量：

1

token_id  →  embedding ∈ R^d

三个关键事实：

• token_id 是固定的索引
• embedding 向量是可训练参数
• embedding 的具体值在训练过程中不断学习更新

embedding 不是人为定义的语义,而是完全数据驱动学出来的状态表示。

3. 位置编码：为什么必须有？

Attention 的核心计算基于内容相似度,本身不关心顺序。如果不引入位置信息：

「我 喜欢 你」与「你 喜欢 我」在 Attention 看来只是同一组 token 的不同排列。

这在数学上对应 Attention 的置换等变性（Permutation Equivariance）：重排输入只会导致输出对应重排,不会产生「顺序语义」。

但语言、时间序列、音频、代码都是顺序敏感的,因此必须引入位置信息。

常见方式：

• 可训练的位置 embedding
• 正弦位置编码
• RoPE、ALiBi 等相对位置机制

需要特别指出：

位置编码在训练和推理中都参与 forward 计算
只是有些实现把位置作为参数存储,有些作为计算规则存在

位置编码不是「知识」,而是 Transformer 理解序列的坐标系。

三、Attention：可学习的信息路由机制

1. Q / K / V 的定义

给定某一层的输入状态 ：

关键点：

• 是参数矩阵
• 对所有 token 共享
• Q / K / V 是运行时动态计算的

模型不保存「每个 token 的 Q/K/V 表」,而是保存「如何从任意状态映射到 Q/K/V 的规则」。

核心理解：

Q / K / V 本质是同一个 token 在不同「视角空间」的表示。

Attention 的计算过程 = 用 Query 空间去 Key 空间里做相似度搜索,再把 Value 空间的信息加权汇总。

从语义角色看：

• Query：查询目标（「我在找什么」）
• Key：匹配索引（「我能被什么找到」）
• Value：传递信息（「我要传递什么内容」）

这是典型的内容寻址（content-based addressing）。

为什么要分离 Q / K / V？

如果用同一向量同时表示「查询需求」「匹配标识」「传递内容」,会导致：

• 表达能力受限：查找规则和信息内容被绑定
• 优化困难：一个维度的变化同时影响三种语义角色
• 学习粗糙：无法独立学习不同的关系模式

分离后的优势：

• 解耦需求与内容：不同维度专门用于「问问题」（Q）、「当索引」（K）、「装内容」（V）
• 更高表达自由度：使 Attention 从简单的「相似度混合」升级为「可学习的信息检索」
• 稳定的优化路径：三个投影矩阵可独立学习

2. Attention 的计算公式

这一过程：

1. 用 Q 和所有 K 做相似度匹配
2. softmax 得到注意力权重分配
3. 对 V 做加权求和完成信息汇聚

这正是「状态之间的信息路由」。

公式背后的设计逻辑

为什么是 （点积）？

点积计算向量相似度：

score[i, j] = Q_i · K_j^T
            = Σ (d = 1 → d_k) Q[i, d] × K[j, d]

• 若 和 方向一致（需求匹配）,点积大
• 若方向不一致,点积小甚至为负
• 点积满足：可微、高效（GPU 友好）、在高维空间稳定

这是典型的基于内容的相似度匹配。

为什么除以 ？

这是数值稳定性问题。当维度 很大时：

• 点积的方差随维度线性增长
• 导致 softmax 输入值过大,迅速饱和
• 梯度接近 0,难以训练

通过 缩放,将数值分布控制在合理范围。

为什么用 softmax？

softmax 提供三个关键性质：

1. 所有权重 ≥ 0
2. 所有权重和 = 1（归一化的概率分布）
3. 可微且梯度稳定

这使注意力权重具有明确的概率解释：「当前 token 有 60% 在看 A,30% 在看 B,10% 在看 C」。

为什么最后乘 V？

因为 只决定看谁、看多少,而 决定拿什么内容。最终输出是加权信息汇聚：

1

output[i] = Σ_j α[i, j] · V[j]

其中 是归一化后的注意力权重。

3. Self-Attention 与 Cross-Attention

Self-Attention 的定义

Self-Attention 的核心特征：Q、K、V 都来自同一条序列（同一组状态）。

这里 是同一序列的隐状态。即：

• 同一批 token
• 既提问（Query）
• 又被提问（Key）
• 又提供信息（Value）

可理解为：序列「对自己」做 Attention,是序列内部的信息路由与整合。

Cross-Attention（交叉注意力）

在 Encoder-Decoder 架构中：

• Query 来自 Decoder
• Key 和 Value 来自 Encoder

这是 Decoder 「对 Encoder 做 Attention」,用于对齐两个不同序列。

对比总结

Self-Attention 的设计意义

Transformer 选择 Self-Attention 作为核心机制,有三个关键优势：

1. 打破顺序依赖：不像 RNN 需要逐步处理,可全局并行计算
2. 任意两点直接交互：第 1 个 token 可直接关注第 1000 个 token,路径长度为 1
3. 对称、通用、可扩展：不假设语法结构、不假设距离关系,所有结构由数据驱动学习

核心直觉：

可把序列想象成一群人在讨论：

• 每个人既听别人说话,又被别人听
• 没有「外部信息源」,所有信息都在这群人之间流动
• 这就是 「Self」 的含义——序列内部的自我关联

Masked Self-Attention

Decoder 中使用的 Masked Self-Attention 仍是 Self-Attention,只是增加了约束：

• 每个位置只能看到之前的位置（因果 mask）
• 但 Q、K、V 依然来自同一序列

因此：Masked Self-Attention = 带因果约束的 Self-Attention

四、Multi-Head：并行的关系子空间

基本原理

Multi-Head Attention 不是「多算几次同样的 Attention」,而是：

• 每个 head 有自己的
• 从同一输入状态投影到不同子空间
• 在不同子空间中学习不同关系模式

实现上通常把 划分为多个 head 的维度并行计算,最后拼接,并通过线性矩阵 融合。

子空间的具体实现

假设 ,,则每个 head 的维度 。

实现方式（不是 8 套完全独立的小 Attention）：

1. 一次性线性投影：
2. Reshape：,分配给 8 个 head
3. 每个 head 独立计算 Attention
4. Concat + 融合

「子空间」的含义：

• 不是人工预先指定的「语法子空间」或「语义子空间」
• 而是：同一输入在不同线性投影下,被映射到不同方向的表示空间
• 每个 head 有独立的 ,天然定义了不同子空间

的关键作用

为什么不能直接 concat？

因为：

• 每个 head 只在低维子空间中工作
• concat 只是简单拼接,不同 head 之间没有交互
• 缺少信息融合机制

的本质作用：

1. 信息融合：把多个 head 的结果线性混合,允许 head 之间交互
2. 维度映射：将拼接后的向量映射回 ,以便与残差连接相加
3. 输出投影：作为 Attention 层真正的「输出投影层」

可将 理解为「多头专家讨论结束后的总编辑」。

为什么每一层都要自己的 ？

因为不同层关注的关系层级不同：

• 底层：偏局部、句法关系
• 高层：偏语义、抽象关系

每一层的「信息融合方式」应该不同,所以每层都有独立的 参数。

不同 Head 如何实现分化？

Multi-Head Attention 没有显式的互斥机制来强制不同 head 学习不同模式。那为什么它们通常不会学成完全一样？

三种隐式分化机制

1. 参数初始化的差异

每个 head 的 初始值不同,导致：

• 优化轨迹不同
• 早期梯度方向不同
• 进入不同的局部最优区域

2. 路径依赖的梯度更新（核心机制）

这是最关键的分化压力：

• 每个 head 接收到的梯度,取决于它当前「已经在关注什么」
• 一旦 head 之间产生微小差异,梯度会放大这种差异,而非抹平
• 优化是路径依赖的：不同的 attention pattern → 不同的梯度信号 → 进一步分化

例如,即使两个 head 都偏向「长距离依赖」,它们可能分别专注于：

• head A：句法长距离（主语-谓语跨句）
• head B：指代长距离（代词-先行词）

Attention pattern 不同 → 对 loss 的贡献路径不同 → 梯度方向不同 → 继续分化

3. 带来的隐式竞争

所有 head 的输出最终通过 融合,这产生资源竞争机制：

• 模型的最终 loss 只关心「哪些 head 的信息真的有用」
• 若两个 head 提供高度相似的信息,对 loss 的边际贡献是冗余的
• 梯度会倾向于：强化其中一个,让另一个转向其他有用方向
• 这是隐式的多样性压力：冗余 head 是「浪费参数」,优化倾向于减少浪费

Head 分化的实际表现

在训练好的语言模型中,常见现象：

• 某些 head 专注局部依赖（相邻 token）
• 某些 head 专注长距离依赖
• 某些 head 偏向句法关系（主谓宾）
• 某些 head 偏向指代关系（he/she/it）

没有任何硬编码规则,这些模式都是训练自发形成的。

Head 冗余现象与过参数化设计

需要指出：Multi-Head Attention 确实会出现冗余。

已知现象：

• 多个 head 可能学到非常相似的 attention pattern
• 某些 head 几乎「没在干活」
• Head 利用率不均

实验证据：

• 论文表明：可剪掉相当一部分 head,性能几乎不变
• Head pruning（头剪枝）后的模型：参数更少、推理更快、性能基本不降

这说明：Multi-Head Attention 在实践中是过参数化的。

为什么接受过参数化？

1. 过参数化是特性,不是 bug

   • 让优化更容易
   • 给模型更多「自组织」的自由度
   • 降低了设计者必须「手工指定结构」的需求

2. 显式互斥约束反而可能伤性能

   • 历史上有人尝试过：强制 head 正交、去相关 loss、specialization 正则项
   • 结果往往是：训练更难、收敛更慢、泛化未必更好
   • 原因：模型「知道自己该怎么分工」,人为强行规定反而限制了自由度

核心理解

Multi-Head Attention 是一种「软分工、自发组织」的机制：

• 没有显式互斥机制来防止多个 head 学到相似模式
• 通过参数初始化差异、路径依赖的梯度更新、输出融合层的隐式竞争,在实践中形成自发分工
• 这种结构是刻意过参数化的,允许一定程度的冗余,而非强制最优分解
• Head 数量（8、16、32、64）是超参数,代表并行关系建模的容量上限,而非「关系类型数」

五、FFN：状态内部的非线性变换

Attention 完成了「信息路由」——决定了从哪里汇聚信息。但汇聚后的信息如何变换？这就是 FFN 的职责。

FFN 的结构

核心特征：

• 逐 token 计算：对序列中每个 token 独立应用同一套参数
• 参数共享：所有位置使用相同的
• 无交互性：token 之间不发生信息交换
• 强非线性：通过激活函数 引入非线性变换
• 升维-压缩：通常先升维（如 4×d）再降维

典型配置：

• （升维,通常 ）
• （降维）
• ：激活函数（ReLU、GELU、SwiGLU 等）

为什么 Attention 本身不够？

Attention 的核心输出是：

这是线性加权和。即使注意力权重 通过 softmax 非线性计算,但对 的操作仍是线性的。

线性操作的局限：

• 不能创造新特征
• 不能做复杂的特征组合
• 不能实现条件逻辑（「A 且 B」这类组合）

深度学习的基本原理：没有非线性,深度网络再深也等价于一个线性变换。

FFN 为什么能「重塑表示」？

1. 非线性激活打破线性限制

激活函数 引入了真正的非线性,使模型能够学习复杂的非线性函数。

2. 升维 → 非线性 → 压缩 = 特征重组

可将 FFN 理解为：

1. 展开：将 token 表示投影到高维空间（）
2. 变换：在高维空间进行非线性「切割」和「门控」
3. 压缩：再投影回原空间（）

这允许模型学到：

• 高阶特征组合：复杂的特征交互模式
• 条件激活：某些特征只在特定上下文中生效
• 抽象语义方向：更高层次的语义表示

Attention 与 FFN 的分工

这两个组件在 Transformer 中扮演互补角色：

• Attention：负责「关系建模」

  • token 之间可以交互
  • 决定「看谁」
  • 完成信息汇聚

• FFN：负责「表达变换」

  • token 之间不交互
  • 决定「变成什么」
  • 完成信息重组

直观比喻：

把序列想象成一排学生：

• Attention 阶段：学生之间讨论、互相参考答案
• FFN 阶段：每个学生回到座位,用同一套规则独立思考

没有学生和旁边的人交流,但大家使用的是同一本「公式书」（共享参数）。

「逐 token」的精确含义

关键点：FFN 不让 token 之间交互。

如果有序列 ,FFN 的计算是：

特征：

• ✔ 每个 token 独立计算
• ✔ 参数共享（同一套 ）
• ✔ 可完全并行（所有 token 同时计算）
• ❌ token 之间 无信息交换

这种设计有三个优势：

1. 解耦职责：Attention 专注关系,FFN 专注变换
2. 高效并行：所有位置可同时计算
3. 增强非线性：每个 token 都经历完整的非线性变换

这种设计实现了关系建模与表示变换的解耦,两者各司其职又相辅相成。

如果没有 FFN 会怎样？

如果只堆叠 Attention + Residual,而没有 FFN：

• 整个网络退化为多次线性混合
• 表示空间无法被真正「变形」
• 模型退化成复杂的线性滤波器
• 表达能力严重受限,无法逼近复杂非线性函数

实验和理论都表明：FFN 是 Transformer 表达能力的关键来源。

六、Residual 与 LayerNorm：深度可训练性的关键

为了让多层堆叠可行,Transformer 使用了两项关键技术：

• 残差连接（Residual Connection）：防止信息退化,允许深层网络
• LayerNorm：稳定数值分布,避免训练崩溃

现代模型几乎全部采用 Pre-LN 结构以增强稳定性。

这两项技术不是 Transformer 的创新,但它们对于构建深层网络至关重要。没有它们,Transformer 无法堆叠到几十层甚至上百层。

七、Transformer Block：整体架构

现在已经理解了所有核心组件,可以看看它们如何组织成完整的架构。

Block 的基本结构

无论 Encoder 还是 Decoder,Transformer 的核心都是反复堆叠同一种 Block。典型结构：

1. Multi-Head Self-Attention
2. Residual + LayerNorm
3. Position-wise FFN
4. Residual + LayerNorm

Transformer 本质就是：这个 Block 堆叠 N 次。

N 取决于模型规模,从十几层到上百层不等。

信息流动的完整路径

在每个 Block 中：

1. Attention 阶段：通过 Self-Attention 完成信息路由,让每个 token 从其他 token 汇聚相关信息
2. 残差连接：保留原始信息,防止信息丢失
3. LayerNorm：稳定数值分布
4. FFN 阶段：对汇聚后的信息进行非线性变换,重塑表示
5. 再次残差 + LayerNorm：稳定输出

这个过程反复进行 N 层,逐步抽象和精炼信息。

Encoder vs Decoder

Encoder：

• 可看到完整输入序列
• 没有因果 mask
• 输出的是「被充分理解后的表示」
• 典型应用：文本理解、分类、检索向量（BERT）

Decoder：

• 使用 Masked Self-Attention（因果 mask）
• 每个位置只能看到之前的位置
• 用于自回归生成
• 典型应用：语言模型（GPT）

Encoder-Decoder：

• Decoder 中额外包含 Cross-Attention 层
• 用于对齐两个序列（如机器翻译）
• 典型应用：T5、BART

为什么大模型几乎都是 Decoder-only？

因为大模型的核心训练目标是自回归语言建模：

而互联网数据天然是连续文本流,不是严格的输入/输出对。Decoder-only：

• 目标函数最简单
• 数据利用率最高
• 工程实现最统一
• 推理与 KV Cache 高度契合

因此成为通用大模型的事实标准。

八、训练与推理：模型到底在「存什么」？

1. 模型参数存储的内容

训练完成后,模型保存的是：

• token embedding 矩阵
• 各层的
• FFN 参数（）
• LayerNorm 参数
• 输出层参数（）

Q/K/V 本身不是参数,只是中间计算结果。

模型保存的是「规则」而非「结果」——保存的是如何计算 Q/K/V 的权重矩阵,而非每个 token 的具体 Q/K/V 值。

2. 推理过程概览

推理时,模型以自回归方式反复执行：

1. 当前 token 序列 → forward
2. 预测下一个 token 的概率
3. 采样或选择 token
4. 拼接到序列末尾
5. 重复

上下文长度始终等于：

输入 token 数 + 已生成 token 数

hidden states 是中间变量,不算 token,不占上下文长度。

3. 完整推理流程详解

以 Decoder-only 模型（如 GPT）为例,假设当前输入序列为 [x₁, x₂, ..., xₜ]：

第 1 步：Embedding + 位置编码

得到第 0 层（输入层）的隐状态矩阵：

第 2 步：逐层 Transformer Block

对第 层（）：

1. LayerNorm（Pre-LN）
   

2. 计算 Q/K/V
   

3. Masked Self-Attention（每个位置只能看到之前的位置）
   
   

4. Multi-Head 融合
   

5. 残差连接
   

6. FFN + 残差
   

第 3 步：提取最后一个 token 的表示

因为语言模型的目标是预测：

第 4 步：映射到词表（LM Head）

第 5 步：采样下一个 token

通过采样策略（greedy、top-k、top-p、temperature）得到：

第 6 步：拼接并重复

将新 token 加入序列：[x₁, x₂, ..., xₜ, x_{T+1}],然后重新执行整个 forward 过程。

关键理解：推理不是「在同一个 forward 里不断计算」,而是每次 forward 只预测一个 token,然后将其接到序列后面再完整计算一遍（或使用 KV Cache 加速）。

4. KV Cache：推理加速的关键优化

在生成第 个 token 时,Attention 需要所有历史 token 的 K/V。但这些历史 K/V 在后续步骤中不会改变。

因此在推理阶段：

• 历史 token 的 K/V 被缓存
• 新 token 只需计算一次 K/V
• Attention 直接使用缓存 + 新值

KV Cache 不是新结构,而是 Attention 在推理阶段的缓存优化,使生成从反复重算历史变为高效增量计算。

什么是「历史 token」？

在自回归生成中：

历史 token = 当前这一步之前,已经确定下来的所有 token

包括两部分：

1. 最初输入的 prompt token
2. 之前步骤中模型生成并已接纳的 token

生成过程示例

假设输入 prompt：[我, 喜欢]

• 第 1 步：预测第 3 个 token

  • 当前序列：[我, 喜欢]
  • 历史 token：[我, 喜欢]
  • 它们的 K/V 被计算并缓存
  • 预测出：吃

• 第 2 步：预测第 4 个 token

  • 当前序列：[我, 喜欢, 吃]
  • 历史 token：[我, 喜欢, 吃]（注意「吃」已成为历史）
  • 只需为「吃」计算新的 K/V 并追加到缓存
  • 预测出：苹果

• 第 3 步：预测第 5 个 token

  • 当前序列：[我, 喜欢, 吃, 苹果]
  • 历史 token：所有 4 个 token
  • 只为「苹果」计算新 K/V

Token 实例 vs Token 类型

关键区分：

• Token 类型（token_id）：tokenizer 层面的概念,如「我」的 token_id 可能是 1234
• Token 实例（token occurrence）：序列中特定位置的 token,即使 token_id 相同,不同位置也是不同实例

为什么相同 token_id 的 K/V 也不同？

假设序列是：[我, 喜欢, 我]

两个「我」虽然 token_id 相同,但：

1. 位置不同
   
   

2. 上下文不同（这是更关键的原因）

   • 第 1 个「我」只能看到自己
   • 第 3 个「我」能看到 [我, 喜欢, 我]
   • Attention 结果完全不同

3. 因此 K/V 不同
   
   

   由于 ,所以 ,

KV Cache 的精确含义

Transformer 不关心「这个 token 是否重复出现」,只关心「这是序列中的第几个位置」。

KV Cache 缓存的是：

• 某一层、某一 head、某一位置的 K 和 V
• 不是某一 token_id 的 K/V

缓存结构：[(pos=1, token=我), (pos=2, token=喜欢), (pos=3, token=我)]

每个位置都是独立的 token 实例,即使 token_id 重复。

历史 K/V 「不会改变」的含义

在推理阶段（参数固定的前提下）：

• 某个 token 实例一旦被计算过,它在该层的 K/V 就完全确定
• 后续生成步骤中不会再修改这些缓存值
• 新生成的 token 会计算新的 K/V 并追加到缓存中

这就是为什么 KV Cache 能大幅加速推理：避免了对历史 token 的重复计算。

九、设计哲学：演化与涌现

经过前面的技术细节,现在可以从更高层次理解 Transformer 的设计哲学。

演化而非推导

需要强调一个常被忽视的事实：

Transformer 并不是从第一性原理必然推导出的最优结构,而是在数学约束、工程约束和实验验证下,逐步演化出来的高度有效的架构。

其设计逻辑可以概括为：

1. 目标是表达能力：所有数学结构（Attention、FFN、Multi-Head 等）共同构造一个高表达力、可优化的函数空间
2. 训练填充能力：通过大规模数据和梯度下降,让参数收敛到该空间中能有效建模数据分布的区域
3. 推理是涌现结果：所谓的「推理能力」不是显式编程的,而是模型在训练后自然呈现的行为模式

核心洞察

现代深度模型不是在「显式地教模型如何推理」,而是构造一个足够大、足够灵活的函数空间,让「推理能力」作为训练后的自然涌现结果出现。模型学到的是「在什么样的上下文下,下一个 token 的条件分布是什么」,而不是「如果 A 且 B,则推出 C」这样的显式逻辑规则。

这意味着：

• Transformer 的各个组件共同构成一个可学习的表示空间,而非独立的「智能模块」
• 每个「数学技巧」（LayerNorm、Residual、缩放、softmax）本质都是在让训练能够找到好解
• 结构的有效性来自：表达力（能表示什么）+ 可优化性（能不能学到）+ 工程可行性（能不能实现）的综合平衡

三层架构的本质

Transformer 的成功来自三层要素的协同：

第一层：函数空间（结构设计）

• Attention：决定状态如何互相连接
• FFN：决定状态如何非线性变换
• Multi-Head：决定并行关系容量
• → 这一层决定了「能表示什么」

第二层：优化可达性（数学与工程）

• LayerNorm、Residual：稳定训练
• 参数初始化、缩放技巧：控制数值
• 自回归目标：简化优化
• → 这一层决定了「能不能学到」

第三层：数据分布（语义与行为）

• 语言结构、逻辑模式
• 世界知识、推理痕迹
• 人类文本中的统计规律
• → 这一层决定了「学成什么样」

关键洞察：所谓的「推理能力」不在任何一层内部,而是在三层叠加后的整体行为上自然涌现。

设计的演化本质

Transformer 的诞生过程可以理解为四重约束下的结构搜索：

1. 可微约束：必须端到端可训练、能在 GPU 上高效计算
2. 表达约束：必须能表示足够复杂的函数、能够 scale
3. 工程约束：必须并行友好、易于分布式训练
4. 实验约束：必须在当时的计算资源和数据规模下表现明显更好

这不是演绎推理的结果,而是一种受约束的经验演化过程——更像生物进化、工程设计,而非形式逻辑证明。

许多看起来「有道理」的解释,实际上是事后合理化：结构先被实验验证为有效,理论解释是在「理解为什么它能活下来」。这是典型的科学路径：先发现 → 再解释 → 再抽象 → 再指导下一轮设计。

从结构到能力的涌现

核心理念：

现代深度模型的设计,本质上不是在「显式地教模型如何推理」,而是：

1. 构造一个高表达力、可优化的函数空间
2. 让训练过程在大规模数据的约束下,将参数收敛到该空间中的某个有效区域
3. 从外部观察,这种函数行为呈现出类似推理、理解与规划的能力

这意味着：

• 模型没有「推理模块」,它只是学到了一个在训练分布上表现得「像在推理」的函数
• 推理是外部观察者给出的解释,不是模型内部的显式过程
• 能力的涌现依赖于：结构设计允许的表达空间 × 数据分布蕴含的模式 × 优化过程能够到达的区域

结语：Transformer 的最终抽象

技术层面的总结

Transformer 是一种以 token 为单位的序列建模框架：

• 通过 Attention 实现可学习的全局信息路由
• 通过 FFN 实现逐 token 的非线性状态变换
• 通过多头并行建模不同关系子空间
• 依靠残差与归一化稳定深度训练
• 在 Decoder-only 形态下以自回归方式逐步生成输出
• 所有长期知识存于参数中,短期上下文由 token 序列动态提供

理解的三个层次

理解 Transformer,有三个层次：

1. 技术层次：知道每个组件是什么、怎么算
2. 原理层次：理解为什么需要这些组件、它们解决什么问题
3. 哲学层次：认识到这些结构不是理论推导的必然,而是在约束空间中探索的产物

当开始思考「为什么是这个结构而不是别的」时,认知就从第二层进入了第三层。

这一思考过程本身就是深入理解的标志——它意味着不再将 Transformer 视为完美的理论大厦,而是理解其本质：在当前认知、资源和工程能力约束下,演化出的一条可行且有效的路径。

Transformer 的成功,本质上是：在正确的约束下,允许了正确的涌现。

以下内容由AI辅助生成

一、自然语言建模的真正难点

自然语言处理的困难，并不在于单词本身，而在于单词之间如何构成有意义的整体。一句话的语义，往往由跨越较长距离、受句法和语义结构约束的成分共同决定。主语与谓语之间可能相隔多个从句，但它们之间的依赖关系依然是理解句子的关键。

因此，自然语言建模的核心问题，本质上是一个序列建模问题：模型需要在任意位置上，合理利用来自序列中其他位置的信息，尤其是那些距离较远但语义上至关重要的部分。

二、表示与结构的分离：从词向量说起

在神经网络进入 NLP 之前，单词只是离散符号，计算机无法直接处理。word2vec 等词向量模型通过分布式假设，将单词映射到连续向量空间，使语义相近的词在向量空间中彼此接近，从而为神经网络提供可计算的输入表示。

这类方法解决的是“词如何用向量表示”的问题：把离散的 token 变成可计算、可度量相似性、可组合的向量。但词向量并不理解语言结构，它不包含顺序、依赖或句法信息。在词向量层面，“dog bites man” 与 “man bites dog” 的差异极小。因此，词向量只是语言处理的表示层，而真正负责建模语言结构和依赖关系的，是后续的序列模型。

三、RNN：用状态表达序列的直觉解法

循环神经网络（RNN）是最早系统性处理序列数据的神经网络结构。它的核心思想非常直观：将序列看作一个随时间推进的过程，用一个隐藏状态不断吸收历史信息，并与当前输入共同决定下一状态。

在这一框架中，隐藏状态被视为“到目前为止的全部记忆”，序列信息被逐步压缩进一个向量中。对于较短、依赖结构简单的序列，这种机制能够有效工作。然而，在自然语言中，这一设计逐渐显露出根本性的局限。

四、编码器思想与固定长度向量的隐患

在 RNN 的基础上，Encoder–Decoder 架构成为早期机器翻译等任务的主流范式。该架构试图将任意长度的输入序列编码为一个固定长度的向量，再由解码器生成输出。这种设计在工程上极具吸引力：接口统一、结构简洁，似乎也符合“一句话有一个整体含义”的直觉。

但这一设计隐含了一个极强的假设：序列中的所有关键信息都可以被无损压缩进一个固定维度的向量中。语言并不满足这一假设。自然语言包含多实体、多关系、多层次结构，将这些信息压缩为单一向量，必然带来信息丢失。

五、从 RNN 到 LSTM：为“记不住”而生的改造

随着 RNN 被用于更长的句子、更复杂的翻译与生成任务，人们发现一个反复出现的问题：模型很难稳定地保留长距离信息。训练中常见的现象包括梯度在长序列上逐步衰减或放大，导致早期输入对后期输出的影响越来越弱；同时，隐藏状态维度固定，使得历史信息被不断覆盖，重要但较早出现的内容容易丢失。

LSTM（以及后来的 GRU）正是在这一背景下提出的。它并不改变“用递归方式推进序列”的总体框架，而是对 RNN 的内部记忆结构做了加强：引入显式的记忆通道，并用门控机制控制信息的写入、保留与读取，从而使模型在训练上更容易保留较长时间跨度的关键信息。

然而，LSTM 仍然继承了 RNN 的结构性前提：所有历史信息最终仍要通过有限维度的状态来承载，并且信息的使用仍遵循顺序访问。也就是说，LSTM 能显著缓解“记不住”的训练困难，但并未从根本上改变“固定容量 + 顺序传递”的结构限制。

六、RNN 与 LSTM 的结构性瓶颈

RNN 与 LSTM 的第一个核心问题是表示容量受限。隐藏状态维度是固定的，而输入序列长度却可变且可能很长。随着序列增长，新信息不断进入，早期但重要的信息容易被覆盖，出现表示能力饱和的现象。

第二个问题是依赖路径过长。远距离依赖必须通过逐步状态传递来实现，依赖路径长度随序列长度线性增长。这使得信息需要经过多次非线性变换才能抵达目标位置，导致远距离信息逐渐被稀释；同时也加剧了训练中梯度不稳定的风险。

第三个问题是访问方式受限。无论是 RNN 还是 LSTM，当模型在某一步需要利用很早之前的某个 token 信息时，都无法直接读取那个位置的表示，只能依赖逐步传递后的“残留痕迹”。这使得模型很难做到“按需回看”，更谈不上对不同上下文进行灵活检索。

七、CNN 的引入：以并行与局部模式补足序列建模

在深度学习体系中，CNN 以并行计算效率高、善于捕捉局部模式而著称。将 CNN 引入序列建模的动机，主要来自两个现实需求：一是希望摆脱 RNN 的严格时间依赖，从而提升训练与推理的并行效率；二是希望利用卷积对局部 n-gram 结构的强归纳偏置，更高效地抽取短程组合模式。

在文本序列中，CNN 通常通过局部卷积提取短程特征，再通过堆叠多层扩大视野，以期覆盖更长距离的上下文。这种思路在一定程度上能兼顾速度与局部结构建模，因此一度成为与 RNN 并行发展的路线。

八、CNN 的“感受野”问题及其语言局限

所谓感受野，指网络中某个位置的表示最终能够“看到”的输入范围。在 CNN 中，单层卷积只能关注局部窗口，想要覆盖更远的距离，必须不断增加网络深度。于是出现了第一个问题：感受野增长缓慢，要覆盖整句往往需要非常深的网络。

更关键的是第二个问题：即使感受野在理论上覆盖了全句，远距离信息仍需要经过多层非线性变换才能传递到目标位置，路径长度与网络深度直接相关。距离越远，通常意味着需要更多层的传递，信息更容易在层层变换中衰减，远距离依赖的贡献被持续稀释。

此外，卷积窗口是固定的，它无法根据当前语义需求动态改变“该看谁”。语言中的关键依赖往往是稀疏且结构化的：当模型处理某个词时，它真正需要关注的可能是远处的某个主语或指代对象，而不是附近的若干词。CNN 的局部、固定窗口机制难以提供这种基于上下文的选择性访问能力。

九、长距离依赖：语言建模的本质矛盾

自然语言中的依赖关系具有三个显著特征：依赖在整体中是稀疏的，但一旦存在便至关重要；依赖的重要性并不随距离单调衰减，而由句法和语义结构决定；依赖是动态的，不同位置在不同上下文中需要关注不同的历史信息。

而 RNN、LSTM 与 CNN 的共同问题在于，它们都在用固定结构提前决定信息如何被压缩或传播：要么将历史压缩进有限维度的状态，要么通过局部堆叠被动扩大视野。这种结构假设与语言依赖的选择性与动态性存在根本冲突。

十、注意力机制：从“压缩历史”到“动态选择”

注意力机制的提出标志着序列建模思路的关键转向。与其将所有历史信息压缩进一个固定向量，注意力机制选择保留所有位置的中间表示，并在当前任务需要时，通过可学习的权重对历史信息进行加权选择。

在这种机制下，模型不再依赖单一记忆状态，而是根据当前上下文动态决定“该看谁、看多少”。注意力提供了一种可学习的软指针，使模型能够直接访问与当前预测最相关的部分，从而显著缩短了信息传递路径，并缓解了固定长度表示带来的信息瓶颈。

十一、Transformer：结构性转变的完成

Transformer 正是在注意力机制的基础上构建的。它彻底放弃了以时间步为核心的顺序递归结构，转而采用基于自注意力的全局依赖建模方式。在 Transformer 中，任意两个位置之间都可以直接建立联系，依赖路径长度不再随序列长度增长。

同时，由于不再依赖前一时间步的隐藏状态，Transformer 可以对所有位置并行计算注意力权重。这一特性使其在 GPU 上具备极高的计算效率，为大规模模型和海量数据训练提供了可行性。自注意力机制既实现了“保留所有信息”，又通过权重分配实现“按需选择”，从结构上更贴合语言依赖稀疏、动态且不随距离衰减的特性。

十二、总结

从词向量到序列模型，问题从“词如何用向量表示”逐步走向“词如何形成结构化语义”。RNN 用递归状态试图承载历史，LSTM 在此基础上通过门控增强记忆保留能力，CNN 以卷积堆叠的方式在并行效率与局部模式建模上提供替代路径。然而，它们共同面临的结构性限制是：要么依赖固定容量的压缩状态，要么依赖固定窗口与多层传递的被动传播，难以对语言中稀疏而关键的长距离依赖进行动态、直接的访问。

Transformer 的关键突破在于改变了这一前提：它不再提前压缩历史，而是保留所有位置的表示，通过自注意力为每个位置动态分配依赖权重，实现对关键信息的直接访问；同时，其计算天然支持并行，使得在大规模数据与算力条件下训练更深更大的模型成为可能。这种从“顺序传递”到“全局访问、动态选择”的结构转变，构成了序列建模范式演进的核心脉络。

十三、关键要点

1. 核心问题

自然语言的长距离依赖具有稀疏性、非单调性、动态性三大特征，这与传统序列模型的固定结构假设存在根本冲突。

2. 两种范式

• 压缩传递（RNN/LSTM）：将历史压缩进固定维度状态，像把整本书总结成一句话
• 选择访问（Transformer）：保留所有位置的完整表示，通过动态计算注意力权重决定“该看谁、看多少”，再加权提取信息——相当于保留整本书，每次根据需要重点阅读相关章节

3. 依赖路径

信息传递路径长度决定了远距离依赖的建模能力：RNN/LSTM 为 ，CNN 为 至 ，Transformer 为 。

4. 结构性瓶颈

• RNN/LSTM：固定容量 vs. 可变序列 → 表示瓶颈
• CNN：固定窗口 vs. 稀疏依赖 → 访问受限
• Transformer：全局注意力 → 并行高效，但复杂度为

5. 范式转变

从“如何更好地压缩”（LSTM 的工程优化）到“是否需要压缩”（Attention 的结构创新），后者带来了序列建模的根本性突破。

以下内容由AI辅助生成

在自然语言处理任务中，模型面对的基本对象是离散的符号（词或 token），而大多数机器学习方法只能处理连续数值。因此，一个核心问题是：如何将离散的词表示为数值向量，并使这些向量能够反映词的语义与用法差异。

词向量（word embedding）正是对这一问题的系统性回答。本文将从最基础的表示方法出发，逐步引入分布式表示与 embedding 的训练机制，并以 Skip-gram + Negative Sampling 为例，说明词向量是如何通过损失函数和梯度下降从大规模语料中学习得到的。

1. One-hot 表示：离散符号的直接编码

最直接的词表示方法是 one-hot 编码。

设词表大小为 ，则每个词对应一个 维向量，仅在该词对应的位置为 1，其余位置为 0。例如，词表为：

则“北京”的 one-hot 表示为：

one-hot 的优点在于形式简单、语义唯一、不需要训练；但其缺点同样明显：

• 向量维度随词表线性增长，难以扩展
• 表示高度稀疏，计算与存储效率低
• 不包含任何语义信息，不同词之间的相似度恒为 0

因此，one-hot 只能作为索引机制，而无法承担“语义表示”的角色。

2. 分布式表示的核心思想

2.1 分布式表示的基本假设

分布式表示（distributed representation）基于一个经典假设：

一个词的意义可以通过它的上下文分布来刻画。

在这一思想下，每个词不再由一个孤立的维度表示，而是由一个低维、稠密、连续的向量表示；语义相近的词，其向量在空间中也应当相近。

2.2 构建分布式表示的两类方法

构建词的分布式表示，主要有两大类方法：

1. 基于计数的方法（count-based methods）

   • 典型代表：LSA、基于共现矩阵的 SVD、PMI / PPMI
   • 思路：先统计词与上下文的共现频次，再通过矩阵分解获得低维表示
   • 特点：依赖全局统计，数学结构清晰，但在大规模语料上扩展性较差

2. 基于神经网络的推理方法（prediction-based methods）

   • 典型代表：Word2Vec（Skip-gram / CBOW）、GloVe（部分融合统计思想）
   • 思路：将“学习词向量”转化为一个预测任务，通过最小化损失函数学习向量参数
   • 特点：可在线训练、扩展性好、在实践中效果优异

本文后续讨论的 embedding 学习机制，属于第二类：基于神经网络的推理方法。

3. Embedding 的形式化定义

在神经网络框架中，embedding 可以形式化为一个可学习的查表映射：

• 词表大小：
• 向量维度：
• embedding 矩阵：

对于任意一个词（或 token），embedding 层的作用可以理解为：
根据词的 id，从矩阵中取出对应的一行，作为该词的向量表示。

embedding 的参数并非人工设定，而是通过下游训练目标、借助梯度下降从数据中学习得到。

4. Skip-gram + Negative Sampling：从语料到训练目标

4.1 训练样本的构造

给定一个 token 序列：

设窗口大小为 ，对每个位置 ，构造训练对：

• 中心词：
• 上下文词：，其中

这样即可从原始语料中构造大量 正样本对。

4.2 输入向量表与输出向量表

在 Skip-gram 模型中，会维护两张独立的 embedding 表：

• 输入向量表：用于中心词
• 输出向量表：用于上下文 / 候选词

对词表中任意词 id 为 i：

• 在输入向量表中，取到它作为“中心词”时使用的向量
• 在输出向量表中，取到它作为“候选上下文词”时使用的向量

这两种向量使用相同的词表索引，但参数彼此独立，承担的统计角色也不同。

4.3 打分函数与概率建模

在 Skip-gram 中，模型会为“中心词 + 候选词”这一对分配一个匹配分数。

这个分数可以理解为：
中心词向量与候选词向量在向量空间中的相似程度。

随后，模型会把这个分数映射成一个介于 0 和 1 之间的值，用来表示“该候选词是否真的是中心词上下文”的概率。

5. 损失函数与向量学习机制

5.1 Negative Sampling 的训练目标

对于一个真实的中心词–上下文词对 ，Negative Sampling 的训练目标可以分解为两点：

1. 正样本目标
   让中心词 与真实上下文词 的匹配分数变大。

2. 负样本目标
   随机采样若干个与 无关的词作为负样本，
   并让中心词 与这些负样本的匹配分数变小。

训练时，模型会把“真实上下文”当作正类，“随机词”当作负类，
并对每一对样本计算二分类的对数损失，然后把这些损失加起来进行优化。

5.2 为什么一次更新会同时影响多种向量

需要强调的是：
输入向量和输出向量并不是分别训练的，而是由同一个训练目标同时驱动。

在一次训练中：

• 中心词对应的输入向量会被更新
• 真实上下文词对应的输出向量会被更新
• 每一个负样本对应的输出向量也都会被更新

从几何角度看，训练过程等价于：

• 把中心词向量与真实上下文向量在空间中拉近
• 把中心词向量与随机负样本向量在空间中推远

6. 为什么需要两张向量表

引入输入表与输出表的根本原因在于：同一个词在训练目标中承担了两种不同的功能：

• 作为中心词：用于生成一个中间表示，以预测周围词
• 作为候选词：用于与中心词表示进行匹配，判断是否为真实上下文

这两种角色在语言统计中并不对称。强制它们共享同一套参数，相当于引入了不必要的约束，会削弱模型对真实共现结构的拟合能力。

训练完成后，实践中通常仅使用输入向量表中的向量作为最终词向量表示，因为它更稳定地反映了词在语义空间中的位置。

7. 一个最小可跑的 PyTorch 示例（核心机制版）

下面给出一个极简的 Skip-gram + Negative Sampling 实现，仅保留核心机制：

• 输入 / 输出向量的分离
• 正负样本共同驱动参数更新

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import torch
import torch.nn as nn
import torch.nn.functional as F

V, D = 3, 2   # 示例：吃 / 苹果 / 北京

class SGNS(nn.Module):
    def __init__(self):
        super().__init__()
        self.in_emb = nn.Embedding(V, D)
        self.out_emb = nn.Embedding(V, D)

    def forward(self, center, pos, neg):
        v = self.in_emb(center)
        u_pos = self.out_emb(pos)
        u_neg = self.out_emb(neg)

        pos_loss = -F.logsigmoid(torch.sum(v * u_pos, dim=1))
        neg_loss = -F.logsigmoid(-torch.sum(v * u_neg, dim=1))

        return (pos_loss + neg_loss).mean()

在这个示例中可以看到：

• 一个损失函数同时作用于多种向量
• 每一步更新只涉及当前样本用到的向量行

8. 总结

• One-hot 只是离散索引，不包含语义
• 分布式表示的目标是用低维稠密向量刻画词的使用规律
• 分布式表示可以通过计数方法或基于神经网络的推理方法构建
• Skip-gram + Negative Sampling 将词向量学习转化为正负样本的区分问题
• 同一个训练目标同时驱动输入向量与输出向量的学习
• 通过大量样本的迭代更新，词的语义结构自然在向量空间中形成

以下内容由AI辅助生成

一、问题背景：我们到底在担心什么？

在 Transformer 的注意力机制中，有一个非常经典的公式：

很多人在第一次看到这个公式时都会产生疑问：

• 为什么注意力机制使用点积来计算相关性？
• 为什么点积之后要接一个 softmax？
• 最关键的是：为什么一定要除以 ？

如果只是把它当成论文中的经验公式，那么对注意力机制的理解仍然停留在表面。事实上，这个结构并不是为了“效果更好看”，而是为了解决一个在训练过程中非常具体、而且非常致命的问题。

二、softmax 的作用，以及它对输入尺度的敏感性

softmax 的定义如下：

它的作用是把一组实数打分映射为一个概率分布。但 softmax 有一个非常重要的性质：

softmax 对输入的整体尺度极其敏感

当输入数值较为温和时，softmax 会产生一个相对平滑的分布；而当输入整体变大时，softmax 的输出会迅速变得极端。

一个简单的数值例子

情况一：输入尺度适中

1
2

输入: z = [1, 0]
输出: softmax(z) ≈ [0.73, 0.27]

两个位置都有明显概率，模型仍然保留不确定性。

情况二：输入尺度变大

1
2

输入: z = [10, 0]
输出: softmax(z) ≈ [0.9999, 0.0001]

此时 softmax 的输出已经几乎等同于 one-hot 分布 [1, 0]。

这是因为指数函数会将线性差距放大为指数级差距，只要输入的整体尺度变大，softmax 的输出就会迅速向极端塌缩。

三、注意力分数为什么会天然变大：点积的统计性质

在注意力机制中，softmax 的输入来自查询向量和键向量的点积：

对于单个 query-key 对，这个分数可以写成：

在常见训练设置中（例如经过 LayerNorm 之后），可以合理假设：

• 各维度的 相互独立
• 均值为 0
• 方差为 1

点积方差的数学推导

在上述假设下，对于每一项 ：

• 均值：
• 方差：

当 项独立相加时：

因此标准差为：

关键结论：点积的典型数值规模与 成正比

这并非实现细节或偶然现象，而是高维点积在统计意义上的必然结果。

具体数值示例

当 时，点积值可能达到 ±45，这会让 softmax 严重饱和。

四、softmax 的梯度结构：什么是 Jacobian？

softmax 是一个向量到向量的函数：

• 输入：
• 输出：

当输入和输出都是向量时，需要描述这样一件事：

某一个输入分量发生微小变化，会如何影响所有输出分量

所有这些“偏导关系”组成的一整张表，称为 Jacobian 矩阵：

softmax 的 Jacobian 具体形式

对于 softmax，其 Jacobian 有明确的数学形式：

关键观察：

• 当 （饱和状态）时，
• 当 时，

梯度大小直接由输出概率本身控制

五、softmax 饱和：输出分布发生了什么变化

对比：适中尺度 vs 大尺度

输入尺度适中时（例如 ）：

1
2
3
4
5
6
7
8
9

位置:    1      2      3      4
输入:    2      1      0     -1
概率:  0.52   0.28   0.14   0.06

可视化:
位置 1: ██████████████████ (52%)
位置 2: ████████████ (28%)
位置 3: ██████ (14%)
位置 4: ██ (6%)

在这种状态下，多个位置都具有非零概率，输出对输入变化是敏感的。

输入尺度变大时（例如 ）：

1
2
3
4
5
6
7
8
9

位置:    1      2       3        4
输入:   20     10       0      -10
概率:  1.00   0.00    0.00     0.00

可视化:
位置 1: ████████████████████████████████ (≈100%)
位置 2: (≈0%)
位置 3: (≈0%)
位置 4: (≈0%)

此时，几乎所有概率质量都集中在单一位置，其余位置的概率被压缩到接近零。

这种从“平滑分布”到“极端分布”的转变，称为 softmax 饱和（saturation）。

六、梯度是如何在 softmax 处消失的

在反向传播中，梯度的传递遵循链式法则：

未饱和状态：梯度正常传播

1
2
3
4
5
6
7
8
9
10
11
12

反向传播路径：

Loss
  │ ∂L/∂s (来自上游)
  ↓
softmax
  │ ∂s/∂z ≈ [0.2, 0.3, 0.1, ...] (梯度有效)
  ↓
logits z
  │ ∂z/∂Q, ∂z/∂K (梯度继续传播)
  ↓
Q, K (参数可以更新)

饱和状态：梯度被截断

1
2
3
4
5
6
7
8
9
10
11
12

反向传播路径：

Loss
  │ ∂L/∂s (来自上游)
  ↓
softmax
  │ ∂s/∂z ≈ [0.00001, 0, 0, ...] (梯度几乎为0！)
  ↓
logits z
  │ ∂z/∂Q ≈ 0, ∂z/∂K ≈ 0 (梯度消失)
  ↓
Q, K (参数无法更新！)

梯度不是在网络深处逐层衰减的，而是在 softmax 这一层被直接截断的

这是一种发生位置非常明确的梯度消失问题。

七、从点积到梯度消失的完整因果链

将前面的所有环节串联起来，可以得到一条完整因果链：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

高维点积统计性质
    ↓
点积方差 ∝ d_k
    ↓
点积值的典型尺度 ∝ √d_k
    ↓
softmax 输入整体变大
    ↓
指数函数放大差距
    ↓
softmax 输出趋向 one-hot 分布
    ↓
softmax Jacobian 中梯度项趋近于 0
    ↓
∂s/∂z ≈ 0 导致梯度截断
    ↓
Q、K 无法更新，注意力权重过早固定

问题的本质是：点积让 softmax 过早进入了饱和区间，从而导致梯度消失。

八、为什么这不是梯度爆炸问题

这一现象有时会被误认为是梯度爆炸，但两者在机制上完全不同。

梯度爆炸 vs 梯度消失对比

关键区别：

softmax 的梯度由其输出概率控制，具体形式为 和 。由于概率值 ，这些导数在数值上是有上界的，不可能随着输入增大而放大梯度。

softmax 只会压缩梯度，而不会放大梯度。

因此，这里出现的问题不是梯度失控增大，而是梯度被系统性压缩并最终消失。

九、根本解决方案：Scaled Dot-Product Attention

既然问题的根源在于点积的方差与维度成正比（），那么最直接的解决方式就是对点积进行缩放：

缩放后的统计性质

缩放后，点积的方差变为：

效果：