Transformer 深度解析：从神经网络到大模型

本文从 RNN 的历史局限出发，逐层剖析注意力机制、Self-Attention、Multi-Head Attention 的数学原理，完整还原 Transformer 编解码结构，再延伸到 BERT、GPT 系列乃至现代大模型的演进脉络。面向有一定工程基础的 Java 开发者，所有公式均配有直觉解释，关键模块附 Java 伪代码辅助理解。

---

一、历史背景：RNN 为什么被淘汰

1.1 序列建模的早期方案

在 Transformer 问世（2017 年）之前，自然语言处理领域的主流序列模型是 RNN（Recurrent Neural Network） 及其变体 LSTM、GRU。它们的核心思想是：按时间步逐字处理，用隐藏状态 $h_t$ 传递历史信息。

x_1 → [RNN] → h_1
x_2 → [RNN] → h_2   (依赖 h_1)
x_3 → [RNN] → h_3   (依赖 h_2)
...
x_n → [RNN] → h_n   (依赖 h_{n-1})

1.2 RNN 的三大致命缺陷

RNN 核心问题

梯度消失/爆炸 是 RNN 的根本性缺陷，即使 LSTM 通过门控机制缓解了部分问题，但在超长序列（> 512 token）上依然力不从心。

缺陷一：长程依赖丢失

考虑句子："The cat that was sitting on the mat was hungry."

"cat" 和最后的 "was hungry" 相关，但它们之间隔了 7 个词。RNN 需要将 "cat" 的信息通过 7 次矩阵乘法传递到末尾——每次乘法都会损失信息，梯度在反向传播时同样如此。

缺陷二：无法并行计算

RNN 的时序依赖性决定了 $h_t$ 必须等待 $h_{t-1}$ 计算完毕，天然无法在 GPU 上做序列维度的并行。在 2017 年 GPU 算力爆发的时代，这是致命的工程瓶颈。

缺陷三：信息瓶颈问题（Seq2Seq 架构中）

经典机器翻译的 Seq2Seq 架构将整个源句子压缩成一个固定长度的向量（context vector），再由 decoder 解码。长句子的所有语义被迫塞入单个向量，信息严重损失。

[Encoder RNN] → 固定向量 c → [Decoder RNN] → 译文

这三个问题共同催生了注意力机制（Attention Mechanism）的诞生。

---

二、注意力机制：从 Seq2Seq 到 Self-Attention

2.1 Bahdanau Attention（2015）

2015 年，Bahdanau 等人在论文 Neural Machine Translation by Jointly Learning to Align and Translate 中提出了一个优雅的解法：decoder 在生成每个词时，动态地"回头看"encoder 的所有隐藏状态，而不是只靠一个压缩向量。

设 encoder 输出的隐藏状态序列为 $h_1, h_2, ..., h_n$，decoder 当前状态为 $s_t$，注意力权重计算为：

$$e_{ti} = a(s_{t-1}, h_i)$$

$$\alpha_{ti} = \frac{\exp(e_{ti})}{\sum_{j=1}^{n} \exp(e_{tj})}$$

$$c_t = \sum_{i=1}^{n} \alpha_{ti} h_i$$

其中 $a(\cdot)$ 是一个对齐函数（通常是小型 MLP），$c_t$ 是当前解码步的上下文向量。

直觉理解

翻译 "cat" 时，decoder 会对 encoder 中对应 "猫" 位置的隐藏状态分配高权重；翻译 "hungry" 时，权重自动转移到 "饿" 附近。这就是注意力的本质：软性对齐（soft alignment）。

2.2 从 Cross-Attention 到 Self-Attention

Bahdanau Attention 是 Cross-Attention：query 来自 decoder，key/value 来自 encoder。

一个自然的推广是：让序列自己关注自己——这就是 Self-Attention（自注意力）。在同一个序列内部，每个位置既作为 query，也作为 key 和 value 的来源。

Self-Attention 的威力在于：

• "它" 能直接关联到句首的 "猫"，无需通过中间的隐藏状态传播
• 所有位置的注意力可以并行计算，不存在时序依赖

---

三、Scaled Dot-Product Attention 数学原理

3.1 Q、K、V 的来源

给定输入序列的词向量矩阵 $X \in \mathbb{R}^{n \times d_{model}}$（$n$ 为序列长度，$d_{model}$ 为模型维度），通过三个可学习的权重矩阵进行线性投影：

$$Q = X W^Q, \quad K = X W^K, \quad V = X W^V$$

其中 $W^Q, W^K \in \mathbb{R}^{d_{model} \times d_k}$，$W^V \in \mathbb{R}^{d_{model} \times d_v}$。

Q、K、V 的含义类比

可以把注意力机制类比成数据库检索：

• Q（Query）：当前词的"查询请求"，表达"我想找什么"
• K（Key）：每个词的"索引标签"，表达"我能回答什么"
• V（Value）：每个词的"实际内容"，表达"我真正包含的信息"

注意力分数衡量 Q 和 K 的匹配度，再用这个分数对 V 做加权求和。

3.2 核心公式推导

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

逐步拆解：

Step 1：计算原始注意力分数

$$S = QK^T \in \mathbb{R}^{n \times n}$$

$S_{ij}$ 表示位置 $i$ 的 query 与位置 $j$ 的 key 的点积相似度。点积越大，说明两个位置语义越相关。

Step 2：缩放（Scaling）

$$S_{\text{scaled}} = \frac{S}{\sqrt{d_k}}$$

为什么必须缩放？

当 $d_k$ 较大时（如 64 或 128），$QK^T$ 的数值会随维度增大而增大（期望值为 $d_k$，方差为 $d_k$），导致 softmax 输入进入梯度接近零的饱和区域。

数学推导：假设 $q_i, k_j \sim \mathcal{N}(0,1)$，则 $q_i \cdot k_j = \sum_{l=1}^{d_k} q_l k_l$ 的方差为 $d_k$，标准差为 $\sqrt{d_k}$。除以 $\sqrt{d_k}$ 后，方差重新归一为 1，softmax 工作在合理区间。

Step 3：Softmax 归一化

$$A = \text{softmax}(S_{\text{scaled}}) \in \mathbb{R}^{n \times n}$$

对每一行（即每个 query 位置）独立做 softmax，得到归一化的注意力权重矩阵。$A_{ij}$ 表示位置 $i$ 对位置 $j$ 分配的注意力比例，所有 $j$ 之和为 1。

Step 4：加权求和

$$\text{Output} = AV \in \mathbb{R}^{n \times d_v}$$

每个位置的输出是所有位置 value 向量的加权和，权重由注意力分布决定。

3.3 Causal Mask（因果掩码）

在 Decoder 的自回归生成中，位置 $i$ 不能看到位置 $i+1$ 之后的信息（否则就"剧透"了）。实现方式是在 softmax 之前将上三角区域置为 $-\infty$：

$$S_{\text{masked}} = S + M, \quad M_{ij} = \begin{cases} 0 & j \leq i \\ -\infty & j > i \end{cases}$$

经过 softmax 后，$-\infty$ 对应的权重变为 0，实现了对未来信息的屏蔽。

// Java 伪代码：Causal Mask 实现
public static double[][] applyCausalMask(double[][] scores) {
    int n = scores.length;
    double[][] masked = new double[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            masked[i][j] = (j <= i) ? scores[i][j] : Double.NEGATIVE_INFINITY;
        }
    }
    return masked;
}

---

四、Multi-Head Attention

4.1 为什么需要多头？

单个注意力头只能捕获一种语言关系。但自然语言中，词与词之间的关联是多维的：

• 语法依存（主谓宾关系）
• 指代关系（"它" → "这只猫"）
• 语义相似（"快速" ↔ "迅速"）
• 位置相邻关系

Multi-Head Attention 通过 $h$ 个并行注意力头，让模型在不同的表示子空间中同时学习多种关联模式。

4.2 完整公式

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

其中每个头独立计算：

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

参数维度：

• 每头的 $d_k = d_v = d_{model} / h$
• $W_i^Q, W_i^K \in \mathbb{R}^{d_{model} \times d_k}$，$W_i^V \in \mathbb{R}^{d_{model} \times d_v}$
• 输出投影矩阵 $W^O \in \mathbb{R}^{h \cdot d_v \times d_{model}}$

参数量计算示例

原始 Transformer 论文：$d_{model} = 512$，$h = 8$，则每头 $d_k = d_v = 64$。

• 每头参数：$3 \times (512 \times 64) = 98304$
• 8 个头：$8 \times 98304 = 786432 \approx 0.79M$
• 输出投影：$512 \times 512 = 262144 \approx 0.26M$
• Multi-Head Attention 总参数：约 1.05M

// Java 伪代码：单头注意力计算
public class ScaledDotProductAttention {

    private final int dk;

    public ScaledDotProductAttention(int dk) {
        this.dk = dk;
    }

    // 假设 Q[n][dk], K[n][dk], V[n][dv]
    public double[][] forward(double[][] Q, double[][] K, double[][] V) {
        int n = Q.length;
        double scale = Math.sqrt(dk);

        // Step 1: 计算 QK^T
        double[][] scores = matMul(Q, transpose(K)); // [n, n]

        // Step 2: 缩放
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                scores[i][j] /= scale;

        // Step 3: Softmax（逐行）
        double[][] attnWeights = softmaxRows(scores); // [n, n]

        // Step 4: 加权求和
        return matMul(attnWeights, V); // [n, dv]
    }

    private double[][] softmaxRows(double[][] mat) {
        int n = mat.length;
        double[][] result = new double[n][mat[0].length];
        for (int i = 0; i < n; i++) {
            double maxVal = Arrays.stream(mat[i]).max().getAsDouble();
            double sumExp = 0;
            for (int j = 0; j < mat[i].length; j++) {
                result[i][j] = Math.exp(mat[i][j] - maxVal); // 数值稳定性
                sumExp += result[i][j];
            }
            for (int j = 0; j < mat[i].length; j++)
                result[i][j] /= sumExp;
        }
        return result;
    }

    // matMul / transpose 省略（标准矩阵操作）
}

---

五、位置编码（Positional Encoding）

5.1 为什么需要位置编码？

Self-Attention 的计算是置换不变的（permutation-invariant）——打乱输入序列的顺序不会改变注意力分数的集合（只是重新排列）。但语言是有序的："猫吃鱼" 和 "鱼吃猫" 语义截然不同。

Transformer 需要显式地将位置信息注入到输入向量中。

5.2 正弦位置编码（原论文方案）

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

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

其中 $pos$ 是序列位置（0-indexed），$i$ 是维度索引，$d_{model}$ 是模型维度。

设计巧思：

• 不同维度使用不同频率的正弦/余弦波，低维度变化快（区分相邻位置），高维度变化慢（捕获远程位置关系）
• 对于任意固定偏移 $k$，$PE_{pos+k}$ 可以表示为 $PE_{pos}$ 的线性变换（利用三角恒等式）
• 位置编码不需要学习，可以直接推广到训练时未见过的序列长度

// Java 实现：正弦位置编码
public class PositionalEncoding {

    public static double[][] compute(int maxLen, int dModel) {
        double[][] pe = new double[maxLen][dModel];
        for (int pos = 0; pos < maxLen; pos++) {
            for (int i = 0; i < dModel / 2; i++) {
                double angle = pos / Math.pow(10000.0, (2.0 * i) / dModel);
                pe[pos][2 * i]     = Math.sin(angle);
                pe[pos][2 * i + 1] = Math.cos(angle);
            }
        }
        return pe;
    }
}

现代位置编码演进

原论文的绝对位置编码已被更先进的方案替代：

• 可学习位置编码（BERT、GPT-2）：每个位置对应一个可训练的向量，灵活但无法外推
• 相对位置编码（Transformer-XL、T5）：编码词间相对距离而非绝对位置，对长度更鲁棒
• RoPE（旋转位置编码）（LLaMA、Qwen、DeepSeek）：通过旋转矩阵将位置信息融入 Q/K，支持序列长度外推，是目前主流大模型的首选方案
• ALiBi（MPT）：在注意力分数上直接添加线性位置偏置，无需修改 embedding

---

六、Transformer 完整架构

6.1 整体结构图

6.2 Encoder 的三个子模块

子模块一：Multi-Head Self-Attention

每层 Encoder 的输入序列对自身做 Multi-Head Attention，每个位置都能感知序列中所有其他位置。无因果掩码，双向建模。

子模块二：Position-wise Feed-Forward Network（FFN）

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

• 对序列中每个位置独立应用同一个两层 MLP（position-wise）
• 中间层维度 $d_{ff}$ 通常为 $4 \times d_{model}$（原论文：$d_{model}=512$，$d_{ff}=2048$）
• 激活函数：原论文 ReLU，现代模型多用 GELU 或 SwiGLU

FFN 的作用

FFN 可以理解为"记忆模块"——研究表明 FFN 存储了大量事实性知识（如 "巴黎 is the capital of 法国"）。这也解释了为何扩大 $d_{ff}$ 能显著提升模型知识容量。

子模块三：残差连接 + Layer Normalization

$$\text{Output} = \text{LayerNorm}(x + \text{SubLayer}(x))$$

残差连接（Residual Connection） 来自 ResNet，解决了深层网络的梯度消失问题，也让每一层只需学习残差（增量）而非完整变换。

Layer Normalization 对每个样本的特征维度做归一化（而非 Batch Norm 跨样本归一化），对变长序列友好：

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

6.3 Decoder 的三个子模块

Decoder 在 Encoder 的基础上增加了一个 Cross-Attention 子层：

1. Masked Multi-Head Self-Attention：因果掩码保证自回归生成的正确性
2. Multi-Head Cross-Attention：query 来自 Decoder 当前状态，key/value 来自 Encoder 输出
3. FFN + Add & Norm：与 Encoder 结构相同

6.4 Pre-LN vs Post-LN

原论文使用 Post-LN（残差连接后再 LayerNorm）。现代大模型几乎全部改用 Pre-LN（每个子层输入前先 LayerNorm）：

Post-LN: Output = LayerNorm(x + SubLayer(x))
Pre-LN:  Output = x + SubLayer(LayerNorm(x))

Pre-LN 的优势：训练更稳定，允许使用更大学习率，梯度流更顺畅，不再需要 Warm-up 那么长。

---

七、从 Transformer 到 BERT

7.1 BERT 的核心创新（2018）

Google 的 BERT（Bidirectional Encoder Representations from Transformers）只使用了 Transformer 的 Encoder 部分，并提出了两个自监督预训练任务：

任务一：Masked Language Model（MLM）

随机掩盖 15% 的输入 token（替换为 [MASK]），让模型预测被掩盖的词。相比 GPT 的单向语言模型，MLM 允许利用双向上下文。

被选中的 15% token 处理策略：

• 80% 替换为 [MASK]
• 10% 替换为随机词（增加鲁棒性）
• 10% 保持不变（迫使模型对所有位置保持表示能力）

任务二：Next Sentence Prediction（NSP）

输入句对 [CLS] 句A [SEP] 句B [SEP]，预测句 B 是否是句 A 的后续句子。（后续研究如 RoBERTa 发现 NSP 效果有限，已被多数后继模型放弃。）

7.2 BERT 输入格式

Token Embeddings:    [CLS] 今天 天气 很 好 [SEP] 适合 出门 [SEP]
Segment Embeddings:   A     A    A   A  A   A    B    B    B
Position Embeddings:  0     1    2   3  4   5    6    7    8

三种 embedding 相加作为输入：词嵌入 + 段落嵌入 + 位置嵌入。

7.3 BERT 模型规格

版本	层数 (L)	隐层维度 (H)	注意力头数 (A)	参数量
BERT-Base	12	768	12	110M
BERT-Large	24	1024	16	340M

7.4 BERT 的下游任务适配

BERT 采用微调范式（fine-tuning）：在预训练权重基础上，根据任务类型添加少量任务特定层，用有标签数据训练整个网络。

---

八、从 Transformer 到 GPT 系列

8.1 GPT 的路线选择

OpenAI 的 GPT 系列走了一条截然不同的路：只用 Transformer Decoder，用自回归语言模型（预测下一个 token）作为唯一的预训练目标。

$$\mathcal{L} = -\sum_{t=1}^{T} \log P(x_t \mid x_1, x_2, ..., x_{t-1})$$

这个目标极为简单，但配合海量数据和足够大的模型，涌现出令人惊叹的能力。

8.2 GPT 系列演进

8.3 涌现能力（Emergent Abilities）

GPT-3 展示了一个震惊学界的现象：随着模型规模突破某个阈值，模型在从未明确训练过的任务上突然获得能力，且在小模型上完全看不到这种能力的苗头。

典型涌现能力：

• In-Context Learning（ICL）：提供几个示例后，模型无需更新权重即可学习新任务
• Chain-of-Thought（CoT）：通过提示引导逐步推理，解决需要多步骤的复杂问题
• 指令跟随：理解并执行自然语言指令

涌现能力的争议

2023 年有研究指出，许多"涌现能力"是评测指标非线性造成的假象——换用连续性指标后，能力增长其实是平滑的。这场争论揭示了 Scaling Law 的边界问题，至今未有定论。

---

九、现代大模型架构改进

相比 2017 年的原始 Transformer，现代 LLM（LLaMA、Qwen、DeepSeek）在架构上做了系统性改进：

9.1 RMSNorm

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

省去了 LayerNorm 中的均值中心化步骤，计算量减少约 7-15%，实验表明效果相当。

9.2 SwiGLU

$$\text{SwiGLU}(x, W, V, b, c) = \text{Swish}(xW + b) \odot (xV + c)$$

$$\text{Swish}(x) = x \cdot \sigma(x)$$

SwiGLU 引入门控机制，在 PaLM、LLaMA、Qwen 等主流大模型中广泛采用。为保持参数量不变，FFN 中间层维度通常调整为 $\frac{8}{3} d_{model}$（而非 4 倍）。

9.3 GQA（Grouped Query Attention）

标准 MHA：每个注意力头有独立的 Q/K/V

$$\text{MHA: } h \text{ 个头各有独立的 } K, V \text{ → KV Cache 为 } 2 \times h \times d_k \times L$$

GQA：将 $h$ 个 query 头分成 $g$ 组，同组共享一对 K/V

$$\text{GQA: KV Cache 为 } 2 \times g \times d_k \times L \quad (g \ll h)$$

例如 LLaMA-3-70B：32 个 Q 头，8 个 KV 头，KV Cache 节省 4 倍。

---

十、大模型微调技术体系

10.1 微调技术全景

10.2 全量微调（Full Fine-Tuning）

更新模型全部参数，需要与预训练相当的计算资源。对于 7B 参数模型，混合精度（fp16）下需要约 14GB 显存仅存储参数，加上梯度和优化器状态（AdamW 需要存储一阶/二阶矩），总需约 56-84GB 显存。

适用场景：有充足算力资源，且目标领域与预训练数据差异极大（如代码、医疗专业领域）。

10.3 LoRA（Low-Rank Adaptation）

LoRA 是目前最流行的参数高效微调方法（微软 2021），核心思想：预训练权重冻结，只在原权重旁添加低秩分解矩阵。

对于预训练权重矩阵 $W_0 \in \mathbb{R}^{d \times k}$，LoRA 添加：

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

其中 $B \in \mathbb{R}^{d \times r}$，$A \in \mathbb{R}^{r \times k}$，$r \ll \min(d, k)$。

训练时只更新 $A$ 和 $B$，推理时可以将 $BA$ 合并回 $W_0$，零额外推理延迟。

参数节省计算：

以 $d=k=4096$，$r=16$ 为例：

• 原参数：$4096 \times 4096 = 16.8M$
• LoRA 参数：$(4096 + 4096) \times 16 = 131K$（节省 99.2%）

// Java 伪代码：LoRA 前向传播
public class LoRALayer {
    private final double[][] W0; // 冻结的预训练权重 [d, k]
    private double[][] A;        // 可训练，初始化为高斯随机 [r, k]
    private double[][] B;        // 可训练，初始化为全零 [d, r]
    private final double alpha;  // 缩放因子
    private final int r;         // rank

    public double[] forward(double[] x) {
        // 标准前向
        double[] w0x = matVecMul(W0, x);           // W0 * x
        // LoRA 增量
        double[] ax  = matVecMul(A, x);             // A * x   [r]
        double[] bax = matVecMul(B, ax);            // B * Ax  [d]
        // 缩放并叠加
        double scale = alpha / r;
        for (int i = 0; i < w0x.length; i++) {
            w0x[i] += scale * bax[i];
        }
        return w0x;
    }
}

LoRA 超参数选择经验

• rank r：4-64 范围内，任务越复杂 r 越大。通常从 r=16 开始调优。
• alpha：通常设为 r 的 1-2 倍（$\alpha = 2r$ 等效于学习率 × 2）
• target modules：一般对 Q/V 矩阵（有时加 K/O）施加 LoRA，不建议对 FFN 全加（反而可能过拟合）
• QLoRA：在 4-bit 量化基础上做 LoRA，7B 模型仅需 6-8GB 显存即可微调

10.4 Prompt Tuning 与 Prefix Tuning

Prompt Tuning（Google 2021）：仅在输入层添加一段可训练的"软提示" token（不对应真实词汇），模型权重全部冻结。

$$\text{Input} = [\underbrace{p_1, p_2, ..., p_m}_{\text{可训练软提示}}, x_1, x_2, ..., x_n]$$

Prefix Tuning（Stanford 2021）：在每一层的注意力 Key/Value 前面拼接可训练向量，提供更强的条件控制能力。

方法	参数量	修改位置	推理开销
Full Fine-Tuning	100%	全部层	无
LoRA（r=16）	~0.1-1%	Q/V/K/O 矩阵	可合并为零
Prompt Tuning	< 0.01%	仅输入层	微小
Prefix Tuning	~0.1%	每层 K/V	有（prefill）

10.5 RLHF（人类反馈强化学习）

RLHF 是让大模型对齐人类价值观的核心技术，由三个阶段构成：

奖励函数：

$$R(x, y) = r_\theta(x, y) - \beta \cdot \mathbb{KL}[\pi_{\phi}(y|x) \| \pi_{\text{ref}}(y|x)]$$

KL 散度项防止模型为获高奖励而"钻空子"，偏离语言模型本身的语言质量。

10.6 DPO（Direct Preference Optimization）

RLHF 的训练流程复杂，需要同时维护奖励模型和策略模型。DPO（斯坦福 2023）将偏好学习直接转化为一个二分类损失，无需奖励模型：

$$\mathcal{L}_{\text{DPO}}(\pi_\theta) = -\mathbb{E}_{(x, y_w, y_l)} \left[ \log \sigma \left( \beta \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)} \right) \right]$$

其中 $y_w$ 是偏好的回答（winner），$y_l$ 是不偏好的回答（loser）。

DPO 的优势：训练更简单稳定，不需要 PPO 的精妙超参调整，效果与 RLHF 相当或更好。Llama-3、Qwen2、DeepSeek-V3 的对齐阶段均大量使用 DPO 或其变体。

---

十一、KV Cache：推理加速的关键

11.1 自回归生成的计算瓶颈

Decoder 生成每个新 token 时，需要对整个历史序列做 Self-Attention。若序列长度为 $L$，生成第 $t$ 个 token 时的注意力计算量为 $O(L \cdot d)$。

朴素实现中，每步都重新计算所有历史 token 的 K/V 向量——这是极大的浪费，因为它们在上一步已经计算过了。

11.2 KV Cache 原理

KV Cache 缓存历史 token 的 K/V 向量，生成新 token 时只计算新 token 的 Q/K/V，然后将其 K/V 追加到缓存中：

第 t 步：
  - 新 token 的 Q_t, K_t, V_t：O(d²) 计算
  - 从缓存读取历史 K_cache, V_cache：O(t·d) 内存读取
  - 注意力：Attention(Q_t, [K_cache; K_t], [V_cache; V_t])
  - 更新缓存：K_cache ← [K_cache; K_t]

内存开销： 每个 token 每层需存储 $2 \times h \times d_k = 2 \times d_{model}$ 的 KV 向量。LLaMA-3-70B（80层，GQA 8头，$d_k=128$）下，1K tokens 的 KV Cache ≈ 80 × 8 × 2 × 128 × 2 bytes ≈ 320MB。

KV Cache 与显存的权衡

KV Cache 是大模型推理的主要显存瓶颈之一。长上下文（128K token）下 KV Cache 可达数十 GB。这也是 GQA、MLA（DeepSeek 提出的 Multi-head Latent Attention）等技术的核心动机——大幅压缩 KV Cache 体积。

---

十二、Scaling Law 与模型能力预测

12.1 Chinchilla Scaling Law

OpenAI 的 Kaplan 等人（2020）和 DeepMind 的 Hoffmann 等人（2022）发现，模型性能（loss）与参数量 N 和训练 token 数 D 之间存在可预测的幂律关系：

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

Chinchilla 定律给出了最优的计算分配策略：在固定算力（FLOPs = $C \approx 6ND$）下，最优的 N 和 D 应保持大致相等的缩放。

$$N_{\text{opt}} \propto C^{0.5}, \quad D_{\text{opt}} \propto C^{0.5}$$

工程含义：GPT-3（175B 参数，仅训练 300B token）是严重的"参数过多、数据不足"。Chinchilla（70B 参数，1.4T token）性能更好，计算效率更高。

模型	参数	训练 Token	Chinchilla 最优比
GPT-3	175B	300B	参数过多
Chinchilla	70B	1.4T	接近最优
LLaMA-3-8B	8B	15T	数据过多（小模型推理优先）
DeepSeek-V3	671B	14.8T	数据偏多（平衡推理效率）

12.2 超越 Scaling Law 的方向

2024-2025 年，纯 Scaling 的收益开始递减，新的突破路径出现：

• MoE（Mixture of Experts）：同参数量下激活更少参数，提升算力效率（DeepSeek-V3、Mixtral）
• Inference-time Scaling：o1/o3 系列通过延长推理链（思维链搜索）换取性能提升，补充了训练时 Scaling 的不足
• 数据质量：高质量合成数据（如 Phi 系列）证明数据质量可以在一定程度上弥补规模差距

---

十三、面试高频考点速览

13.1 Attention 复杂度分析

操作	时间复杂度	空间复杂度
计算 $QK^T$	$O(n^2 d_k)$	$O(n^2)$
Softmax	$O(n^2)$	$O(n^2)$
$AV$	$O(n^2 d_v)$	$O(n d_v)$
全部 Attention	$O(n^2 d)$	$O(n^2)$

这就是标准 Transformer 在长上下文下的瓶颈——注意力的计算和存储都是序列长度的平方。FlashAttention 通过分块计算 IO 优化将实际内存访问从 $O(n^2)$ 降为 $O(n)$，但理论复杂度不变。

13.2 核心考点问答

常见面试题

Q: Transformer 为什么比 RNN 更适合并行训练？

A: Self-Attention 中，序列所有位置的 Q/K/V 投影和注意力分数计算都是独立的矩阵运算，可完全并行。RNN 因时序依赖 $h_t$ 依赖 $h_{t-1}$，无法在序列维度并行。这使得 Transformer 能充分利用 GPU 的大规模矩阵运算能力。

Q: Scaled Dot-Product 为何除以 $\sqrt{d_k}$ 而不是 $d_k$？

A: 假设 Q/K 的元素满足标准正态分布，点积的方差为 $d_k$，标准差为 $\sqrt{d_k}$。除以 $\sqrt{d_k}$ 使分数方差重归为 1，避免 softmax 进入饱和区。除以 $d_k$ 会过度缩小，同样不好。

Q: Layer Norm 和 Batch Norm 的区别？

A: Batch Norm 在 batch 维度归一化（跨样本），要求 batch 内统计量稳定，不适合变长序列和在线推理。Layer Norm 在特征维度归一化（每个样本独立），与 batch 大小无关，更适合 NLP 的变长、小 batch 场景。

Q: LoRA 为什么有效？对什么参数做低秩分解？

A: 实验和理论（Aghajanyan et al. 2021）表明，预训练模型的内在维度很低——微调时权重变化矩阵 $\Delta W$ 具有低秩结构，用低秩分解能捕获核心语义偏移。通常对 Attention 的 Q/V 矩阵效果最好（K 有时也加），FFN 矩阵效果次之。

Q: 为什么现代大模型都用 Decoder-Only 而非 Encoder-Decoder？

A: 三方面原因：(1) 自回归语言模型目标简单统一，无需设计复杂预训练任务；(2) Decoder-Only 在 ICL（in-context learning）范式下展现出更强的 few-shot 能力；(3) 规模扩展时 Encoder-Decoder 的编解码不均匀问题更难处理。GPT-3 之后，Decoder-Only 已成为大模型事实标准。

Q: BERT 和 GPT 的本质区别？

A: 架构上，BERT 是 Encoder（双向注意力），GPT 是 Decoder（因果注意力）。目标上，BERT 做 MLM（填空），GPT 做自回归语言模型（续写）。用途上，BERT 更擅长理解/分类任务，GPT 更擅长生成任务。现代趋势下，GPT 系列（Decoder-Only）已几乎在所有任务上超越 BERT。

13.3 数字速记

指标	原论文 Transformer	BERT-Base	GPT-3	LLaMA-3-8B
层数	6E + 6D	12	96	32
模型维度	512	768	12288	4096
注意力头数	8	12	96	32
FFN 维度	2048	3072	49152	14336
参数量	~65M	110M	175B	8B

---

十四、总结：Transformer 的设计哲学

Transformer 的成功不是单一创新的结果，而是多个设计决策的协同作用：

1. Self-Attention 取代循环结构 → 解决并行性和长程依赖
2. Scaled Dot-Product → 数值稳定的相似度度量
3. Multi-Head 机制 → 多视角特征提取
4. 残差连接 + LayerNorm → 深层网络训练稳定性
5. Position-wise FFN → 位置独立的非线性变换（知识存储）
6. 统一的 Encoder-Decoder 框架 → 覆盖理解与生成两大任务范式

从 2017 年的 NLP 专用模型，到今天覆盖语言、图像、音频、代码、蛋白质结构的通用骨干架构，Transformer 证明了：足够通用的归纳偏置 + 足够可扩展的架构 + 足够多的数据，是通往通用智能的可行路径。

---

推荐阅读

核心论文

• Attention Is All You Need — 原始 Transformer 论文，Vaswani et al. 2017
• BERT: Pre-training of Deep Bidirectional Transformers — BERT 原论文，Devlin et al. 2018
• GPT-3: Language Models are Few-Shot Learners — GPT-3 原论文，Brown et al. 2020
• LoRA: Low-Rank Adaptation of Large Language Models — LoRA 参数高效微调，Hu et al. 2021
• Flash Attention — IO 感知的高效精确注意力实现

---

参考文献：Vaswani et al. (2017) "Attention Is All You Need" · Devlin et al. (2018) "BERT" · Brown et al. (2020) "GPT-3" · Hoffmann et al. (2022) "Chinchilla" · Hu et al. (2021) "LoRA" · Rafailov et al. (2023) "DPO"