Attention Is All You Need 注意力就是你所需要的一切 1706.03762

解读来源：论文解读_新人深度理解版.md

#第 1 章 Transformer：注意力就是你所需要的一切

#1.1 时代背景：2017 年，大家在烦什么？

2017 年之前做机器翻译/语言模型，主流是 RNN（循环神经网络）。RNN 处理一句话是这样的：

"我  →  爱  →  自然  →  语言  →  处理"
 ↓     ↓      ↓       ↓       ↓
 h₁ → h₂  →  h₃  →   h₄  →   h₅

每个词必须等前一个词处理完才能开始（h₂ 依赖 h₁），这导致两个致命问题：

问题 1：慢 GPU 一次能算几千个矩阵乘法，但 RNN 强迫你必须一个词一个词来。就像有一条 8 车道高速公路，你却让所有车排成一列开过去。

问题 2：记不住远处 要让"处理"这个词理解到句首的"我"，信息得从 h₁ 一路传到 h₅，每传一步信号就衰减一点。句子一长，开头就忘了。

💡 真实例子：翻译"昨天我在上海陆家嘴的星巴克遇到了一个穿红衣服戴眼镜的男人，他……" 等到处理"他"时，RNN 已经很难记清楚"他"指的是前面哪个人。

#1.2 灵感：人类阅读的方式

你读一句话时，是怎么理解"他"指代谁的？

你的眼睛会"跳回去"看前面。 当读到"他"，你会快速扫一眼前文里所有的人名/代词候选，然后挑一个最合适的。

这就是 Attention（注意力） 的核心思想：让每个位置直接看到所有其他位置，不用一步步传话。

#1.3 Attention 的"图书馆"比喻

想象你在图书馆找资料：

Query（查询，Q）：你的问题，比如"红楼梦谁写的"
Key（键，K）：每本书脊上的关键词标签
Value（值，V）：每本书的实际内容

流程：

拿你的 Q 去和每本书的 K 比对，算出"相似度分数"
分数高的书权重大，分数低的书权重小
按权重把所有书的 V 加权平均，得到答案

Attention 公式翻译成人话：

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

数学符号	人话
$QK^T$	我的问题 vs 每个候选的相关度
$\div \sqrt{d_k}$	把数字缩小防止 softmax 失真（技术细节）
$\text{softmax}(\cdot)$	把相关度变成"加起来=1 的权重"
$\cdot V$	按权重加权平均所有候选的内容

#1.4 Self-Attention：自己看自己

在 Transformer 里，Q、K、V 都从同一个输入算出来——句子里每个词同时扮演查询者、被查者、内容提供者。

举例处理 "The cat sat on the mat"：

处理 "cat" 这个词时：
  Q = "cat 想知道什么"
  K = ["The 是什么", "cat 是什么", "sat 是什么", "on 是什么", "the 是什么", "mat 是什么"]
  V = 上面 6 个词的实际语义内容

  → 算出来 "cat" 和 "sat"、"mat" 相关度高
  → "cat" 的新表示 = 0.1*The + 0.4*cat + 0.3*sat + 0.05*on + 0.05*the + 0.1*mat

这样 "cat" 这个词的向量就融合了整个句子的上下文。

#1.5 Multi-Head：多个视角同时看

一个 Attention 头只能学一种关系。但语言里关系有很多种：

谁是动作的主语？
哪个形容词修饰哪个名词？
代词指代谁？

Multi-Head Attention = 把 Q/K/V 切成 h 份（比如 8 份），每份独立做一次 Attention，最后拼起来。

💡 类比：8 个不同专业的人同时读一句话，语法学家关注主谓宾，语义学家关注词义，最后大家凑在一起讨论。

#1.6 还差什么：位置信息

注意，Attention 本身不关心顺序——"我爱你"和"你爱我"在纯 Attention 看来 K/V 集合一样，结果一样。这显然不对。

解决方案：给每个位置加一个位置编码（Positional Encoding），用 sin/cos 函数生成一串"位置指纹"加到 embedding 上。这样模型就能区分"第 1 个词"和"第 5 个词"。

#1.7 整体架构

            ┌──────────── Encoder（6 层堆叠）────────────┐
输入句子  →  │  词嵌入 + 位置编码                            │
            │       ↓                                       │
            │  Multi-Head Self-Attention（每个词看所有词）    │
            │       ↓                                       │
            │  前馈网络（每个位置独立过一个小 MLP）          │
            │       ↓ （重复 6 次）                          │
            └────────────────────────────────────────────────┘
                            ↓
            ┌──────────── Decoder（6 层堆叠）────────────┐
            │  Masked Self-Attention（只能看前面的词）       │
            │       ↓                                       │
            │  Cross-Attention（看 Encoder 的输出）         │
            │       ↓                                       │
            │  前馈网络 →  词表概率分布 →  输出下一个词      │
            └────────────────────────────────────────────────┘

💡 Encoder vs Decoder 区别：

Encoder：每个词可以看到句子里所有其他词（双向）。适合"理解"任务，BERT 走这条路线。

Decoder：每个词只能看到自己前面的词（单向、自回归）。适合"生成"任务，GPT/Claude 走这条路线。

#1.8 最小代码片段（PyTorch 风格）

import torch
import torch.nn.functional as F

def attention(Q, K, V):
    """最小可运行的 Scaled Dot-Product Attention"""
    d_k = Q.size(-1)
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)   # 算相似度
    weights = F.softmax(scores, dim=-1)               # 变概率
    return weights @ V                                # 加权平均

# 假设有 1 个 batch、5 个 token、每个 token 64 维
Q = K = V = torch.randn(1, 5, 64)
out = attention(Q, K, V)
print(out.shape)  # torch.Size([1, 5, 64])

就这 5 行，是整个大模型时代的起点。

#1.9 新人 FAQ

Q：为什么叫"Transformer"？没看出哪里在 transform。 A：每一层都把输入向量"变换（transform）"成融合了上下文的新向量。论文当时也没起出更好的名字。

Q：参数到底在哪里？Attention 公式里看不到 W。 A：Q、K、V 不是直接拿输入用，而是 Q = X·W_q, K = X·W_k, V = X·W_v——W_q/W_k/W_v 才是要训练的参数。论文里讲 Multi-Head 那部分有。

Q：上下文越长越慢，为什么？ A：$QK^T$ 是 n×n 的矩阵（n 是 token 数），计算量和显存都是 O(n²)。这就是为什么"长上下文"一直是大模型的瓶颈，FlashAttention、Sliding Window 这类优化都在解决这个。

解读来源：论文解读_Transformer_LoRA_ReAct.md

#一、Attention Is All You Need（Transformer，2017）

作者：Vaswani et al.（Google Brain / Google Research）
arXiv：1706.03762
领域：序列建模 / 机器翻译

#1. 提出背景

在 2017 年之前，序列建模（机器翻译、语言模型）主流是 RNN/LSTM/GRU + Attention，存在两大瓶颈：

串行计算：RNN 必须按时间步顺序计算，无法充分利用 GPU 的并行能力，训练慢。
长程依赖衰减：序列越长，梯度越难传播，远距离 token 之间的关系建模效果差。

CNN（如 ConvS2S）能并行，但需要堆很多层才能让远距离 token 进入同一个感受野。

#2. 核心思想

完全抛弃循环和卷积，只用注意力机制（Attention）建模 token 间依赖。

任意两个位置之间的距离都是 O(1)，长程依赖直接打通。
矩阵乘法本质，天然并行，训练效率大幅提升。

#3. 方法细节

#3.1 Scaled Dot-Product Attention