深度学习 on 方糖猫Blog

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

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

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

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

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

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

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

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

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

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

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

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

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

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

答案可以简化成三步：

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

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

    style E fill:#fff4e1

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

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

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

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

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

3.1 词向量的神奇性质

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

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

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

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

3.2 词向量是怎么得到的？

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

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

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

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

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

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

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

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

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

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

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

一句话串起来：

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

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

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

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

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

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

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

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

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

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

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

6.1 Token 与 Embedding

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

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

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

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

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

用流程图表示：

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

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

6.2 位置编码

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

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

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

最终输入向量是：

x_i = Embedding(token_i) + PE(pos_i)

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

    style D fill:#fff4e1

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

七、Self-Attention：核心计算

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

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

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

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

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

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

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

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

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

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

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

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

    style D fill:#fff4e1

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

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

    style Z fill:#fff4e1

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

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

7.3 多头 Attention

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

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

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

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

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

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

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

    style F fill:#fff4e1

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

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

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

第 1 步：生成 Q、K、V

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

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

第 2 步：应用因果掩码

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

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

含义：

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

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

第 3 步：计算 z₁

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

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

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

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

    style Z fill:#fff4e1

第 4 步：计算 z₂

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

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

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

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

    style Z fill:#fff4e1

第 5 步：用 z₂ 预测 x₃

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

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

    style X3 fill:#fff4e1

z₁ 有必要算吗？

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

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

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

那因果掩码还有必要吗？

有必要，原因有两个：

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

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

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

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

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

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

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

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

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

九、Add & Norm 与 FFN

9.1 残差连接

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

Output = LayerNorm(Z + X)

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

残差连接的作用：

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

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

    style F fill:#fff4e1

9.2 Feed Forward Network

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

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

注意：

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

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

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

    style E fill:#fff4e1

9.3 一个完整的 Transformer Block

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

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

    style H fill:#fff4e1

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

十、Decoder 与自回归生成

10.1 编码器 vs 解码器

原始 Transformer 有 Encoder 和 Decoder：

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

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

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

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

10.2 因果掩码

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

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

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

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

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

10.3 预测下一个 Token

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

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

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

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

    style G fill:#fff4e1

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

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

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

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

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

10.5 自回归生成流程

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

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

    style I fill:#fff4e1

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

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

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

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

10.7 生成什么时候结束？

通常有两个停止条件：

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

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

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

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

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

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

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

11.1 预训练：词语接龙

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

例如：

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

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

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

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

可以看到：

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

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

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

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

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

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

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

每一行包含：

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

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

11.3 RLHF：人类反馈强化学习

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

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

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

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

十二、上下文窗口的限制

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

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

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

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

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

对 AI 工程师的启示：

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

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

13.1 理解 Token 消耗

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

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

13.2 设计更好的 RAG

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

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

13.3 理解 LLM 的局限性

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

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

十四、延伸：DeepSeek 的 MLA

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

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

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

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

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

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

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

十五、总结

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

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

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

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

    style J fill:#fff4e1

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

参考文章：

《深度学习的数学》核心算法学习总结：从梯度下降到 CNN 反向传播（中学生友好版）

Sat, 01 Nov 2025 11:16:00 +0800

《深度学习的数学》核心算法学习总结

目标读者：学过函数、导数、向量/矩阵基础的中学生生或刚转行的工程师。
参考书籍：涌井良幸《深度学习的数学》
Excel 示例：https://www.ituring.com.cn/book/2593

写在前面：为什么要先搞懂这 5 个算法？

深度学习的代码看起来很复杂，但核心无非是这五个环节：

梯度下降法：告诉模型“往哪走、走多远”。
NN 求解器：用 Excel/数值方法直接“暴力”找出神经网络权重。
NN 误差反向传播法：用导数的链式法则高效计算每个权重的调整量。
CNN 求解器：把同样的思路用到图像上，用卷积和池化提取特征。
CNN 误差反向传播法：把反向传播扩展到卷积层和池化层。

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

一、梯度下降法（Gradient Descent）

1.1 一句话理解

想象你蒙着眼睛站在山坡上，想走到最低点。你每一步都：用脚感觉最陡的方向，然后朝相反方向跨一小步。重复很多次，就能接近山谷。

“最陡的方向” = 梯度（gradient）。
“相反方向” = 梯度前面加负号。
“一小步” = 学习率 η（eta）。

1.2 数学表达式

要找函数 $z = f(x, y)$ 的最小值，每一步：

$$ \begin{aligned} x_{\text{新}} &= x_{\text{旧}} - \eta \cdot \frac{\partial z}{\partial x} \\ y_{\text{新}} &= y_{\text{旧}} - \eta \cdot \frac{\partial z}{\partial y} \end{aligned} $$

其中 $\frac{\partial z}{\partial x}$ 读作“z 对 x 的偏导数”，意思是：只有 x 动一点点时，z 会变多少。

1.3 计算例子：z = x² + y²

这是最简单的碗状函数，最小值在 $(0, 0)$。

偏导数很容易算：

$$ \begin{aligned} \frac{\partial z}{\partial x} &= 2x \\ \frac{\partial z}{\partial y} &= 2y \end{aligned} $$

取学习率 $\eta = 0.1$，起点 $(3, 2)$：

步数 $i$	$x_i$	$y_i$	$\frac{\partial z}{\partial x}$	$\frac{\partial z}{\partial y}$	$\Delta x$	$\Delta y$	$z = x^2 + y^2$
0	3.00	2.00	6.00	4.00	-0.60	-0.40	13.00
1	2.40	1.60	4.80	3.20	-0.48	-0.32	8.32
2	1.92	1.28	3.84	2.56	-0.38	-0.26	5.32
3	1.54	1.02	3.07	2.05	-0.31	-0.20	3.41
4	1.23	0.82	2.46	1.64	-0.25	-0.16	2.18
13	0.16	0.11	0.33	0.22	-0.03	-0.02	0.04
18	0.05	0.04	0.11	0.07	-0.01	-0.01	0.00
30	0.00	0.00	0.01	0.00	0.00	0.00	0.00

可以看到：z 越来越小，x、y 越来越靠近 0。Excel 文件 2-11 梯度下降法.xlsx 就是用完全相同的公式做出来的。

1.4 流程图

flowchart TD
    A[初始化参数 x, y] --> B[计算当前梯度]
    B --> C{梯度是否足够小？}
    C -->|是| D[结束，得到近似最优解]
    C -->|否| E[按 x := x - η·grad 更新]
    E --> B

1.5 结构分解图

flowchart LR
    subgraph 输入
        X["x"]
        Y["y"]
    end
    subgraph 目标函数
        F["z = x² + y²"]
    end
    subgraph 输出
        G["梯度 (∂z/∂x, ∂z/∂y)"]
        L["当前损失 z"]
    end
    X --> F
    Y --> F
    F --> G
    F --> L
    G --> U["更新 x, y"]
    U --> X

1.6 使用注意点 / 避坑指南

坑	现象	处理方法
学习率 η 太大	左右震荡、loss 不下降甚至发散到 NaN	先设小一点（如 0.001、0.01），再调大
学习率 η 太小	收敛极慢，训练一万轮还在原地	逐步放大，或使用学习率衰减/热身
局部最小值	卡在不是全局最低的山谷	换初始化、用 Momentum/Adam、增加随机性
特征尺度不一致	某个参数梯度特别大，更新不稳定	先标准化/归一化输入数据
没有检查收敛	一直在迭代，不知道何时停	设定 loss 阈值、最大迭代次数或早停 Early Stopping

1.7 异常场景处理

Loss 变成 NaN/Inf：立刻减小学习率，检查输入是否归一化，检查是否出现 log(0) 或除零。
Loss 不动：检查梯度是否接近 0（可能进入平台或死区），换激活函数（如 ReLU），或减少正则化。
Loss 震荡不下降：学习率过大，改用 Momentum 或 Adam，或者降低 batch size。

二、NN 求解器（用优化器/求解器训练神经网络）

2.1 神经网络在做什么？

神经网络 = 很多层“加权求和 + 激活函数”拼在一起。

以书中“0 和 1 的识别”为例：

输入：3×4 = 12 个像素（0 或 1）。
隐藏层：3 个神经元。
输出层：2 个神经元，分别代表“是 0”还是“是 1”。

下面就是它的经典结构图：

flowchart LR
    subgraph 输入层["输入层（12 个像素）"]
        I1((x₁))
        I2((x₂))
        I3((x₃))
        IDOTS[...]
        I12((x₁₂))
    end
    subgraph 隐藏层["隐藏层（3 个神经元）"]
        H1((h₁))
        H2((h₂))
        H3((h₃))
    end
    subgraph 输出层["输出层（2 个神经元）"]
        O1((是 0))
        O2((是 1))
    end

    I1 --> H1
    I1 --> H2
    I1 --> H3
    I2 --> H1
    I2 --> H2
    I2 --> H3
    I3 --> H1
    I3 --> H2
    I3 --> H3
    I12 --> H1
    I12 --> H2
    I12 --> H3

    H1 --> O1
    H1 --> O2
    H2 --> O1
    H2 --> O2
    H3 --> O1
    H3 --> O2

每个箭头都代表一个权重 w，每个圆圈（神经元）里都会做“加权求和 + 激活函数”。

2.2 前向传播公式

对单个神经元：

$$ \begin{aligned} \text{加权求和：} \quad z &= w_1 x_1 + w_2 x_2 + \dots + w_n x_n + b \\ \text{激活输出：} \quad a &= \sigma(z) = \frac{1}{1 + e^{-z}} \end{aligned} $$

σ 叫 Sigmoid 函数，能把任意实数压到 0-1 之间，适合当“概率”。

如果写成更清晰的“层”形式：

隐藏层第 j 个神经元：

$$ \begin{aligned} z_j^{(2)} &= \sum_{i=1}^{12} w_{ji}^{(1)} \cdot x_i + b_j^{(1)} \\ a_j^{(2)} &= \sigma\left(z_j^{(2)}\right) \end{aligned} $$

输出层第 k 个神经元：

$$ \begin{aligned} z_k^{(3)} &= \sum_{j=1}^{3} w_{kj}^{(2)} \cdot a_j^{(2)} + b_k^{(3)} \\ a_k^{(3)} &= \sigma\left(z_k^{(3)}\right) \end{aligned} $$

$x_i$：输入像素（12 个）。
$w_{ji}^{(1)}$：输入到隐藏层的权重。
$b_j^{(1)}$：隐藏层的偏置。
$a_j^{(2)}$：隐藏层输出。
$w_{kj}^{(2)}$：隐藏层到输出层的权重。
$b_k^{(3)}$：输出层的偏置。

2.3 Excel 里的实现（测试表）

在 3-5 NN（求解器）.xlsx 的“测试”表中，核心公式长这样：

# 隐藏层第一个神经元
=SUMPRODUCT(L5:N8, $D$5:$F$8) + $G$5

# Sigmoid 激活
=1/(1+EXP(-O11))

# 输出层
=MMULT($D$17:$F$17, O14:O16) + $G$17

对应上面的数学公式：

Excel 公式	数学含义	Excel 函数说明
`SUMPRODUCT(L5:N8, $D$5:$F$8)`	$\sum_{i=1}^{12} w_i \cdot x_i$	把两个区域里对应位置相乘，再把所有乘积加起来，本质就是向量的点积/内积。这里输入像素放在 `L5:N8`，对应权重放在 `$D$5:$F$8`。
`+ $G$5`	$+ b_j^{(1)}$	加上隐藏层第 1 个神经元的偏置。
`1/(1+EXP(-O11))`	$\sigma(z) = \frac{1}{1 + e^{-z}}$	Sigmoid 激活函数。
`MMULT($D$17:$F$17, O14:O16)`	$\sum_{j=1}^{3} w_{kj}^{(2)} \cdot a_j^{(2)}$	矩阵乘法。`$D$17:$F$17` 是 1×3 的输出行权重，`O14:O16` 是 3×1 的隐藏层输出列向量，乘出来是一个标量。
`+ $G$17`	$+ b_k^{(3)}$	加上输出层第 k 个神经元的偏置。

一句话总结：Excel 里先用 SUMPRODUCT 做点积，再用 MMULT 做矩阵乘法，最后都加上偏置、过 Sigmoid。

2.4 计算例子

例子 1：隐藏层神经元（SUMPRODUCT 在算什么）

完整公式是：

$$ z_j^{(2)} = \sum_{i=1}^{12} w_{ji}^{(1)} \cdot x_i + b_j^{(1)} $$

为了手写方便，下面只看前 3 个输入和权重，演示这个过程。假设：

$$ \mathbf{w} = [-2.06,\ 3.36,\ -0.63]^\top,\quad b = -0.99,\quad \mathbf{x} = [1,\ 1,\ 1]^\top $$

$$ \begin{aligned} z &= (-2.06) \times 1 + 3.36 \times 1 + (-0.63) \times 1 + (-0.99) \\ &= -0.32 \\[6pt] a &= \sigma(-0.32) = \frac{1}{1 + e^{0.32}} \approx 0.42 \end{aligned} $$

Excel 里会用 SUMPRODUCT(L5:N8, $D$5:$F$8) 一次性把 12 项都乘好再加起来，然后 + $G$5 加上偏置。

例子 2：输出层神经元（MMULT 在算什么）

隐藏层输出（来自书中 Excel 第一个样本的近似值）：

$$ \mathbf{a}^{(2)} = [1.5 \times 10^{-6},\ 0.99999999,\ 0.99999997]^\top $$

输出神经元 1 的权重和偏置：

$$ \mathbf{w}_1^{(2)} = [-14.25,\ -3.70,\ 9.33],\quad b_1^{(2)} = 6.64 $$

输出层的计算就是一次 1×3 矩阵 × 3×1 向量：

$$ \begin{aligned} z_1^{(3)} &= (-14.25) \times 1.5 \times 10^{-6} + (-3.70) \times 0.99999999 + 9.33 \times 0.99999997 + 6.64 \\ &\approx -3.70 + 9.33 + 6.64 \\ &\approx 12.28 \\[6pt] a_1^{(3)} &= \sigma(12.28) \approx 0.999995 \end{aligned} $$

含义：模型非常确信这个样本是“0”。Excel 里的 MMULT($D$17:$F$17, O14:O16) 做的就是这一步矩阵乘法。

2.5 流程图

flowchart LR
    I["输入图像像素 x"] --> W1["隐藏层加权求和 z²"]
    W1 --> A1["Sigmoid 激活 a²"]
    A1 --> W2["输出层加权求和 z³"]
    W2 --> A2["输出概率 a³"]
    A2 --> C["计算损失 C"]
    C --> S["Excel 求解器调整 w, b"]
    S --> W1

2.6 使用注意点 / 避坑

求解器=黑盒：Excel Solver 是通过数值方法搜索最优解，参数多的时候很慢，且容易陷入局部最优。
权重初始化别全 0：如果所有权重相同，所有神经元学到的东西也相同，模型退化成“单神经元”。
数据量不能太少：书中只有几十张图是为了教学，真实项目通常需要成千上万张。
输出层要配对损失函数：二分类用 Sigmoid + 交叉熵，多分类用 Softmax + 交叉熵。

2.7 异常场景处理

求解器提示“找不到可行解”：检查公式是否有 #VALUE!、输入是否规范、约束是否合理。
训练集准确率 100% 但测试集很差：过拟合，增加数据或加正则化/Dropout。
输出全是一个类别：标签不平衡，或最后一层权重初始化导致，检查损失函数是否写对。

三、NN 误差反向传播法（Backpropagation）

3.1 核心思想：链式法则

反向传播就是从输出倒推，计算每个权重对最终误差的贡献。

中学学过的复合函数求导：

如果 $y=f(u)$，$u=g(x)$，那么 $\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}$。

神经网络层数很多，就是一层一层套起来的复合函数。反向传播只是把链式法则系统化地算一遍。

3.2 计算图

flowchart LR
    X["x"] --> M["× w"]
    B["b"] --> S["+ b = z"]
    M --> S
    S --> A["Sigmoid a"]
    A --> L["损失 C"]
    L --> D["反向求 ∂C/∂w, ∂C/∂b"]
    D --> M
    D --> B

3.3 反向传播公式（简化版）

设某层输出为 $a$，加权输入为 $z$，下一层传来的误差为 $\delta_{\text{next}}$：

$$ \begin{aligned} \delta &= \delta_{\text{next}} \cdot w \cdot \sigma’(z) \\ \frac{\partial C}{\partial w} &= a_{\text{prev}} \cdot \delta \\ \frac{\partial C}{\partial b} &= \delta \end{aligned} $$

其中 $\sigma’(z)$ 是 Sigmoid 的导数：

$$ \sigma’(z) = \sigma(z) \cdot (1 - \sigma(z)) $$

3.4 计算例子

假设只有一个输入 x = 1，目标输出 t = 1。

网络：

$$ \begin{aligned} z &= w \cdot x + b \\ a &= \sigma(z) \\ C &= \frac{1}{2}(a - t)^2 \quad \text{（平方误差）} \end{aligned} $$

初始 w = 0.5，b = 0，学习率 η = 0.1。

前向：

$$ \begin{aligned} z &= 0.5 \times 1 + 0 = 0.5 \\ a &= \sigma(0.5) \approx 0.6225 \\ C &= \frac{1}{2}(0.6225 - 1)^2 \approx 0.0712 \end{aligned} $$

反向：

$$ \begin{aligned} \frac{\partial C}{\partial a} &= a - t = -0.3775 \\ \sigma’(z) &= a(1 - a) \approx 0.6225 \times 0.3775 \approx 0.2350 \\ \delta &= \frac{\partial C}{\partial a} \cdot \sigma’(z) \approx -0.0887 \\[6pt] \frac{\partial C}{\partial w} &= x \cdot \delta = -0.0887 \\ \frac{\partial C}{\partial b} &= \delta = -0.0887 \end{aligned} $$

更新：

$$ \begin{aligned} w_{\text{new}} &= 0.5 - 0.1 \times (-0.0887) \approx 0.5089 \\ b_{\text{new}} &= 0 - 0.1 \times (-0.0887) \approx 0.0089 \end{aligned} $$

再算一次前向，a 会比 0.6225 更接近 1，误差减小。

3.5 流程图

flowchart TD
    F["前向传播：算 z, a, C"] --> B["从输出层开始反向求 δ"]
    B --> G["计算 ∂C/∂w, ∂C/∂b"]
    G --> U["梯度下降更新权重"]
    U --> F

3.6 使用注意点 / 避坑

坑	说明	处理
Sigmoid 梯度消失	输入很大或很小时，Sigmoid 导数接近 0，深层网络传不动误差	用 ReLU / LeakyReLU
ReLU 死亡	某些神经元永远输出 0，梯度也永远 0	用 LeakyReLU、PReLU，或调小学习率
梯度爆炸	深层网络梯度越乘越大，权重变成 NaN	梯度裁剪（Gradient Clipping）、BatchNorm、残差连接
损失与输出不匹配	用 Sigmoid 配 Softmax 损失会出问题	二分类用 `binary_crossentropy`，多分类用 `categorical_crossentropy`
batch 太小	梯度噪声大，训练抖动	增大 batch，或使用带动量的优化器

3.7 异常场景处理

某层梯度全为 0：可能是激活函数“死”了，或学习率过大导致参数进入饱和区。检查激活函数输出分布。
训练 loss 下降但验证 loss 上升：典型过拟合，早停或加 Dropout。
不同层梯度尺度差 1000 倍：深层网络梯度不稳定，考虑 Batch Normalization 或更合适的初始化（He/Xavier）。

四、CNN 求解器（卷积神经网络训练）

4.1 卷积是什么？

卷积 = 用一个小窗口（卷积核 / filter）在图片上滑来滑去，局部加权求和。

好处：

捕捉边缘、纹理等局部特征。
同一个核扫完整张图，参数少很多。

4.2 池化（Pooling）

池化 = 把一小块区域压缩成一个数，常用 Max Pooling（取最大值）。

作用：降维、减少计算量、让特征对位置变化不那么敏感。

4.3 计算例子

输入图像（4×4）：

卷积核（2×2）：

1  1
1 -1

卷积（无 padding，stride=1）第一步取左上角：

1×1 + 1×1 + 1×1 + (-1)×1 = 2

滑完得到 3×3 特征图：

2  0  0
0  2  0
0  0  2

Max Pooling（2×2，stride=2）：

2  0
0  2

然后拉平成 [2, 0, 0, 2]，接到全连接层做分类。

书中 5-4 CNN（求解器）.xlsx 就是用类似流程识别“文字 1、2、3”。

4.4 结构图

flowchart LR
    I["输入图像"] --> C["卷积层"]
    C --> R["激活函数 ReLU/Sigmoid"]
    R --> P["池化层 Max Pooling"]
    P --> F["拉平 Flatten"]
    F --> D["全连接层"]
    D --> O["输出分类"]

4.5 使用注意点 / 避坑

输出尺寸算错：卷积后尺寸为 $H_{\text{out}} = \frac{H_{\text{in}} - K + 2P}{S} + 1$，忘记 padding 会导致后续层维度不匹配。
核太大：会丢失细节，图像任务一般 3×3 最常用。
池化丢失位置信息：如果任务需要精确定位（如目标检测的边界框），Max Pooling 不宜太多。
通道数暴涨：每加一个卷积层通道数翻倍会迅速爆显存，要结合池化或stride=2降采样。

4.6 异常场景处理

特征图全 0：可能是权重初始化太差，或学习率过大导致 ReLU 全部死亡。加 BatchNorm 或换初始化。
输出尺寸报错：逐层打印特征图 shape，检查核大小、stride、padding。
显存不足：减小 batch size，或减少通道数/层数。

五、CNN 误差反向传播法

5.1 卷积层的反向传播

卷积的反向传播本质上仍是卷积，只是：

误差图需要和旋转 180° 的卷积核做卷积。
再乘以当前层激活函数的导数。

简化公式：

$$ \delta_l = \delta_{l+1} \circledast \text{rot180}(W_{l+1}) \odot f’(z_l) $$

其中 ⊛ 表示卷积，⊙ 表示对应元素相乘。

5.2 池化层的反向传播

Max Pooling 反向传播最简单：把误差传回给“最大值所在位置”，其余位置填 0。

flowchart LR
    subgraph 前向
        A["2 1\n0 3"] --> B["Max=3"]
    end
    subgraph 反向
        E["误差 0.5"] --> C["0   0\n0 0.5"]
    end
    B -.-> E

5.3 计算例子

前向 Max Pooling 2×2：

输入：          输出：
2  1            3
0  3

反向时，如果输出位置误差是 0.5，传回输入应为：

0    0
0  0.5

然后继续往前传给卷积层。

5.4 流程图

flowchart TD
    subgraph 前向
        F1["卷积 + 激活"] --> F2["Max Pooling"] --> F3["全连接输出"]
    end
    subgraph 反向
        B1["输出层误差 δ"] --> B2["池化层反向：把误差还给最大值位置"]
        B2 --> B3["卷积层反向：rot180 核卷积 δ"]
        B3 --> B4["更新卷积核权重"]
    end
    F3 -.-> B1

5.5 使用注意点 / 避坑

坑	说明	处理
Max Pooling 不可导	它本身不是光滑函数，但反向传播时我们只把梯度传给最大值位置，工程上可行	注意保存前向时的“最大值位置掩码”
stride > 1 反向 upsample 复杂	误差图尺寸变小，传回去要补 0	框架会自动处理，手写时要小心
Padding 的梯度	padding 区域不应该有梯度，加 padding 时要把这些位置屏蔽	反向传播只更新非 padding 区域
BatchNorm 插在卷积后	会改变反向传播的梯度分布，但通常更稳定	BN 需要和卷积一起训练

5.6 异常场景处理

卷积核学不到东西：检查初始化、学习率，或前面层是否已经“死掉”。
深层 CNN loss 不下降：可能是梯度消失，加残差连接（ResNet）或 BatchNorm。
训练集准确率很高，测试集很低：CNN 参数多，极易过拟合，加数据增强、Dropout、L2 正则化。

六、通用训练避坑指南

下面这 10 条适用于 NN 和 CNN：

数据先归一化：像素除以 255，数值特征减去均值除以标准差。
划分训练 / 验证 / 测试集：不要拿测试集调参。
从小模型开始：先跑通一个两层的 baseline，再加深。
学习率是最重要的超参数：先用默认值，再按 10 倍上下调。
监控 loss 曲线：训练 loss 和验证 loss 一起画，才能判断是否过拟合。
早停 Early Stopping：验证 loss 连续 N 轮不降就停。
权重初始化：ReLU 用 He 初始化，Sigmoid/Tanh 用 Xavier/Glorot 初始化。
Batch Size：小 batch（16-64）通常泛化更好，大 batch 训练更快但可能陷在尖锐最小值。
标签检查：花 10 分钟抽样看标签是否正确，比调一周模型都有效。
随机种子固定：方便复现和对比实验。

七、异常场景与业务异常处理

7.1 训练阶段

异常	可能原因	处理
Loss = NaN	学习率过大、梯度爆炸、log(0)	降低学习率、梯度裁剪、加 ε
Loss 完全不降	学习率太小、数据损坏、标签全相同	逐步调大 lr、检查数据pipeline
验证 loss 上升	过拟合	早停、Dropout、数据增强、简化模型
训练 loss 和验证 loss 都高	欠拟合	增加模型容量、训练更久、减少正则
类别严重不平衡	某些类别样本极少	加权损失、过采样、Focal Loss

7.2 部署/业务阶段

业务异常	表现	处理
概念漂移	线上数据分布变了，模型准确率下降	监控分布、定期重训、在线学习
输入越界	用户上传纯黑图、超大图、非图片文件	前置校验、异常输入兜底规则
adversarial 样本	人眼看不出区别，模型却错判	对抗训练、输出置信度+人工复核
长尾类别错误	冷门类别识别率低	收集更多样本、用度量学习/少样本学习
时延/成本超标	模型太大，推理慢	剪枝、量化、蒸馏、换小模型

7.3 一个实用的排查 checklist

□ 输入数据范围对吗？（0~1 还是 -1~1？）
□ 标签编码对吗？（one-hot / integer / 概率？）
□ 损失函数和输出激活匹配吗？
□ 第一层输出 shape 符合预期吗？
□ 权重还有在更新吗？（打印梯度范数）
□ 训练一个 batch 能过拟合吗？（ Sanity Check ）
□ 学习率是不是在合理区间？

八、总结

算法	核心作用	一句话口诀
梯度下降法	找函数最小值	看梯度，反方向，迈小步
NN 求解器	用优化器直接调权重	输入加权求和，Sigmoid 出概率
NN 反向传播	高效算每个权重的梯度	从后往前，链式求导
CNN 求解器	图像特征提取 + 分类	卷积找局部特征，池化降维
CNN 反向传播	卷积和池化的梯度回传	卷积核旋转 180°，池化只传最大值

如果你是第一次接触，建议：

先打开 2-11 梯度下降法.xlsx，改改 η 和起点，看 z 怎么变。
再打开 3-5 NN（求解器）.xlsx，试着改输入像素，观察输出概率。
最后对照 4-4、5-4、5-6 这几个 Excel，理解“求解器版”和“反向传播版”其实是同一套东西的不同实现方式。

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