前言

本文是阅读论文《Attention Is All You Need》的笔记。在本文中 Google（2017）提出了 Transformer 结构，一种完全用注意力机制组成的模型结构，相比之前的 CNN 和 RNN 等模型，并行化能力变强了，训练效率提升。在 Transformer 之前，大家更多是在魔改模型结构，比如 CNN、RNN、ResNet、CRNN、CRNN-Attention… 这些模型基本都基于卷积、RNN 记忆缓存和注意力机制。Transformer 论文解决机器翻译问题，输入可能是很长的文字序列。CNN 利用局部感受野，如果要捕获到所有输入信息，需要叠加很多层，不适合处理变长序列。而 RNN 是自回归的，每层需要逐个状态传递信息，无法并行化，对于长序列内存有限制，且一句话读到后面，容易忘记句首信息。注意力机制在当时常常作为 RNN 的辅助模块，用来提点，常见的是 CRNN 后面接一个 Attention，或者像 LAS 一样利用 Attention 来信息对齐。作者的贡献在于完全舍弃卷积和 RNN，只用注意力机制，并行化处理输入，大幅提高训练效率，且在翻译任务中性能 SOTA。
本文从模型结构、编码器、解码器、位置编码 4 方面说明 Transformer，理解每个模块的设计。

一、模型结构

机器翻译任务流行采用编解码器（Encoder-Decoder）结构，比如英-汉翻译，输入是英文符号序列 $\mathbf{x}=(x_1,\dots ,x_n)$，经过编码器处理 $\mathbf{z}=Encoder(\mathbf{x}),\mathbf{z}=(z_1,\dots ,z_n)$，再由 Decoder 生成中文序列 $\mathbf{y}=(y_1,\dots ,y_m)$。注意模型是自回归的，需要利用上一个汉字来解码下一个字符，即 $y_n=Decoder(\mathbf{z},y_{n-1}),n\le m$ 。

Transformer 也是编解码器结构，如图 1.1 所示，左边是编码器，右边是解码器。

二、编码器

图 1.1 左边是 Embedding（可以理解为文本词元 Token） 结合位置编码，输入到粗线框中，我们称粗线框模块为编码器块，左边的 “N×” 意思是 N 个一模一样的编码器块顺序连接，N 一般为 6 或 12。编码器块由多头自注意力层、残差连接、层归一化（LayerNorm）和前馈网络（FFN）组成。

2.1 自注意力(Self-attention)

注意力机制，一般是权重（注意力分数）与输入的加权求和。相较平均，利用不同权重处理信息，更加符合现实场景。比如打 MOBA 类 5v5，一般想要取得团队胜利，资源的分配是按权重设计的，假设总权重为 1，

位置	中单	Carry	优势路	劣势路	辅助打野
分配资源	0.3	0.4	0.15	0.1	0.05

每个位置获得的资源是不一样的。那么权重怎么获得？以游戏举例，可以统计几百场比赛每个位置前期获得的金币收益，做归一化 $\text{softmax}$（$\text{softmax}$ 后的权重总和是1，权重作为百分比更容易理解一些，也可以用其他归一化方法），统计得到每个位置的资源权重。我们发现权重是可以通过具体问题来进行统计的。但是作为一个模型，没有这些先验信息，所有的权重要靠模型自己去学，这就有了自注意力。
自注意力层，对于输入 { x i ∈ R d } i = 1 L \{\mathbf{x_{i}}\in \mathbb{R}^d\}_{i=1}^L {xi​∈Rd}i=1L​，其中 $d$ 是 Embedding 维度，我们需要算出权重，再用权重和输入加权求和。
Transformer 引入了 3 个线性变换 $W^Q\in {\mathbb{R}}^{d\times d_q}$， $W^K\in {\mathbb{R}}^{d\times d_k}$，$W^V\in {\mathbb{R}}^{d\times d_v}$，使得
$$Q=X{W}^Q\text{\hspace{1em}(2.1)}$$
$$K=X{W}^K\text{\hspace{1em}(2.2)}$$
$$V=X{W}^V\text{\hspace{1em}(2.3)}$$
然后
$$Z=\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V\text{\hspace{1em}(2.4)}$$
一般情况下 $d_q=d_k=d_v$，这样 $Q$ 和 $K$ 的维度是 $d\times d$，$Q$ 可以和 $K$ 的转置做内积。 也允许 $d_q\ne d_k$，可以用线性变换将维度对齐[3]。
观察（2.4）式，这里做了缩放 $\frac{1}{\sqrt{d_k}}$。因为 $Q{K}^T$ 做内积，计算出的每个值是与$d_k$ 相关的，比如论文中设 $d_k=512$，每一次点乘的值可能会很大或很小(负数)，过了 $\text{softmax}$ 大的值会接近 1，小的值会接近 0，容易导致梯度接近 0，梯度消失。通过缩放将 $d_k$ 的影响抵消掉，而在论文中假设做内积的向量 $q$ 和 $k$ 服从均值 0 方差 1 的独立同分布，故
$$Var\left(\frac{q\cdot k}{\sqrt{d_k}}\right)=\frac{1}{d_k}Var\left(\sum _{i=1}^{d_k}{q}_i{k}_i\right)=\frac{{\sum }_{i=1}^{d_k}Var(q_i)Var(k_i)}{d_k}=1$$
第二个等号用到 $q_i$ 之间独立，$k_i$ 之间独立，那么 $q_i{k}_i$ 和 $q_j{k}_j(i\ne j)$ 是独立的。
$Q$、$K$、$V$分别称为询问（query）、键（key）和值（value），(2,4) 式 $\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)$ 是权重，与 $V$ 加权求和得到输出。

2.2 多头注意力层(Multi-Head Attention)

将 Embedding 维度 $d$ 拆分成 $h$ 个子空间（要求 $h$ 整除 $d$），在每个子空间做线性映射，然后将每个子空间的信息 $\text{Concat}$ 起来，如下
$$\begin{array}{rl}\text{MultiHead}(X_Q,X_K,X_V)& =\text{Concat}({\text{head}}_1,\dots ,{\text{head}}_h)W^O\\ \text{where}{\text{head}}_i& =\text{Attention}(X_Q{W}_i^Q,X_K{W}_i^K,X_V{W}_i^V),i=1,...,h\end{array}$$
其中 $W_i^Q\in {\mathbb{R}}^{d\times d_k}$， $W_i^K\in {\mathbb{R}}^{d\times d_k}$，$W_i^V\in {\mathbb{R}}^{d\times d_v}$，$W^O\in {\mathbb{R}}^{h{d}_v\times d}$。
下面举例说明多头自注意力层的计算。
假设参数：

• d = 512
• $d_k$ = 256（key 的嵌入维度）
• $d_v$ = 384（value 的嵌入维度）
• h = 8
• h_dim = 512 // 8 = 64
• batch_size = 32
• seq_len = 100
• $W_Q$: (512, 512)
• $W_K$: (512, 256)
• $W_V$: (512, 384)
• $W_O$: (512, 512)

步骤	操作	输入维度	输出维度
输入	$X_Q$,$X_K$,$X_V$	(100,32,512),(100,32,256),(100,32,384)	(100,32,512)×3
Reshape	多头分割	(100,32,512)	(256,100,64)
注意力	Attention	(256,100,64)	(256,100,64)
输出	合并+投影	(256,100,64)	(100,32,512)

Reshape 多头分割是

# Q: (100, 32, 512) -> (100, 32*8, 64) -> (256, 100, 64)
q = Q.view(100, 32*8, 64).transpose(0, 1)  # (256, 100, 64)

# K: (100, 32, 512) -> (100, 32*8, 64) -> (256, 100, 64)
k = K.view(100, 32*8, 64).transpose(0, 1)  # (256, 100, 64)

# V: (100, 32, 512) -> (100, 32*8, 64) -> (256, 100, 64)
v = V.view(100, 32*8, 64).transpose(0, 1)  # (256, 100, 64)

维度说明：

• 256 = 32 * 8（批次大小 × 头数）
• 100 是序列长度
• 64 是每个头的维度

最后的合并+投影是

# 1. 转置并 reshape
# (256, 100, 64) -> (100, 256, 64) -> (100*32, 512)
attn_output = attn_output.transpose(0, 1).contiguous().view(100*32, 512)
# = (3200, 512)

# 2. 输出投影
out_proj_weight: (512, 512)
out_proj_bias: (512,)
attn_output = attn_output @ out_proj_weight.T + out_proj_bias
# (3200, 512) @ (512, 512) = (3200, 512)

# 3. Reshape 回原始格式
attn_output = attn_output.view(100, 32, 512)  # (100, 32, 512)

2.3 残差连接、层归一化（LayerNorm）和前馈网络（FFN）

如图 1.1，过了多头自注意力层（_sa_block），会进行残差连接，可以缓解梯度消失，稳定训练。然后进行 $\text{LayerNorm}$，是特征维度进行归一化，可以提高稳定性，加速训练。下面对 $\text{BatchNorm}$ 和 $\text{LayerNorm}$ 做一下比较。
$\text{BatchNorm}$ 是在 batch 维度上归一化。这种方式比较符合直觉，比如我们想拟合一个班学生的身高分布，在模型训练前，算出平均身高和方差，做归一化，稳定训练，我们关心的是整个样本集合的分布。在 CNN 类的网络中效果好，推理的时候如果是逐个样本推理，可以使用训练时保存的均值方差等参数。
而 $\text{LayerNorm}$ 是对单个样本进行归一化，比如机器翻译，输入一个 token 序列，对这个序列做归一化。每个样本独立归一化，不依赖批次大小，适合序列模型，实时计算统计量。$\text{BatchNorm}$ 不适合处理变长序列，处理变长序列可能需要 padding 操作，导致统计量不稳定。所以 Transformer 中采用 $\text{LayerNorm}$ 。
编码器块的执行顺序为：

1. 自注意力： $x+\text{sa\_block}(x)$ (残差连接)
2. $\text{LayerNorm}$： $\text{norm1}(x+\text{sa\_block}(x))$
3. 前馈网络：$x+\text{FFN}(x)=x+max(0,x{W}_1+b_1)W_2+b_2$(残差连接)
4. $\text{LayerNorm}$：$\text{norm2}(x+\text{FFN}(x))$

FFN 加入了线性变换，容易控制特征尺寸，比如 FFN 将维度扩展到 $4\times d_{model}$，再压缩回 $d_{model}$，可以有效控制参数量，提供更大的表示空间，增强模型的拟合能力。另一方面，通过 $\text{ReLU}$ 可以引入非线性，增强模型的表达能力。

三、解码器

右边黑色框为解码器块，相较编码器块，解码器多了掩码多头注意力，并且融合了来自编码器的信息。最终经过线性变换和 $\text{softmax}$ 来预测下一个 token 的概率。

3.1 掩码多头注意力

Transformer 用于变长序列的训练，会生成 Key Padding Mask，标记哪些位置是 padding，应该被忽略。我们这一节主要说明解码器的因果掩码（Causal Mask）。
在机器翻译中，编码器用于融合上下文语义信息，而解码器负责生成目标语言序列。过程是自回归的，需要利用之前生成 token 的信息，而不能看到后面解码的信息。所以需要因果掩码来屏蔽后续文本信息。

import torch

# 生成大小为 5×5 的 causal mask
mask = torch.triu(torch.full((5, 5), float('-inf')), diagonal=1)
print(mask)

输出

tensor([[  0., -inf, -inf, -inf, -inf],
        [  0.,   0., -inf, -inf, -inf],
        [  0.,   0.,   0., -inf, -inf],
        [  0.,   0.,   0.,   0., -inf],
        [  0.,   0.,   0.,   0.,   0.]])

计算流程

# 1. 计算注意力分数
attn_scores = Q @ K^T / sqrt(d_k)  # (batch*heads, seq_len, seq_len)

# 2. 应用 mask
if attn_mask is not None:
    attn_scores = attn_mask + attn_scores  # mask 中的 -inf 会让对应位置变成 -inf

# 3. Softmax（-inf 会被映射到 0）
attn_weights = softmax(attn_scores, dim=-1)  # -inf → 0, 正常值 → 概率分布

# 4. 加权求和
output = attn_weights @ V

3.2 交叉注意力

编码器输出的信息通过交叉注意力传输给解码器，是在掩码多头注意力模块之后。
整体流程

# 步骤 1: 编码器处理源序列
memory = encoder(src)  # (src_len, batch, d_model)

# 步骤 2: 解码器使用编码器输出
output = decoder(tgt, memory)  # (tgt_len, batch, d_model)

交叉注意力核心是 $Q$ 来自上一层的解码器，$K$ 和 $V$ 来自编码器。

# 交叉注意力计算
Q = x @ W_Q          # (tgt_len, batch, d_model) - 来自解码器
K = memory @ W_K     # (src_len, batch, d_model) - 来自编码器
V = memory @ W_V     # (src_len, batch, d_model) - 来自编码器

# 注意力分数
attn_scores = Q @ K^T / sqrt(d_k)  # (tgt_len, src_len)

四、位置编码

以上是 Transformer 的大致框架，我们看到，核心运算都来自 self_attention 和 FFN，其中基本都是矩阵点积运算，长距离依赖和下一个 token 一样，只做一次点积，这样 Transformer 可以并行处理数据。但由于加和运算的可交换性，导致无法区分输入 token 的位置，翻译时 上海 和 海上，两个含义差异巨大的名词，对于模型是一样的运算。为了区分 token 位置，文中引入了位置编码。
$$\begin{array}{r}P{E}_{(pos,2i)}=sin(pos/10000^{2i/d_{model}})\\ P{E}_{(pos,2i+1)}=cos(pos/10000^{2i/d_{model}})\end{array}\text{\hspace{1em}(4.1)}$$
其中 $pos$ 是位置，$i$ 是维度。
既然是为了区分 token 的位置，我给第 1 个 token 向量加 1， 第 2 个 token 向量加 2，…，以此类推，不就做出区分了吗，为什么要用（4.1）这么复杂的编码？
我们举个简单的例子，比如输入形状为 (batch=1, seq_len=5, d_model=4)，我们来计算正余弦位置编码。

# 输入 x: (1, 5, 4)
x = torch.randn(1, 5, 4)
# 例如:
# x = [[[ 0.1,  0.2,  0.3,  0.4],
#       [ 0.5,  0.6,  0.7,  0.8],
#       [ 0.9,  1.0,  1.1,  1.2],
#       [ 1.3,  1.4,  1.5,  1.6],
#       [ 1.7,  1.8,  1.9,  2.0]]]

# pe 形状: (5, 4)
# 位置编码:
pe = [
    # 位置 0: [sin(0*1.0), cos(0*1.0), sin(0*0.01), cos(0*0.01)]
    [ 0.0000,  1.0000,  0.0000,  1.0000],
    # 位置 1: [sin(1*1.0), cos(1*1.0), sin(1*0.01), cos(1*0.01)]
    [ 0.8415,  0.5403,  0.0100,  0.9999],
    # 位置 2: [sin(2*1.0), cos(2*1.0), sin(2*0.01), cos(2*0.01)]
    [ 0.9093, -0.4161,  0.0200,  0.9998],
    # 位置 3: [sin(3*1.0), cos(3*1.0), sin(3*0.01), cos(3*0.01)]
    [ 0.1411, -0.9900,  0.0300,  0.9996],
    # 位置 4: [sin(4*1.0), cos(4*1.0), sin(4*0.01), cos(4*0.01)]
    [-0.7568, -0.6536,  0.0400,  0.9992]
]

# 缩放输入
xscale = sqrt(4) = 2.0
x_scaled = x * xscale

# 添加位置编码
x_with_pos = x_scaled + pe

对于 $sin(\omega \ast pos)$ 或 $cos(\omega \ast pos)$ 我们称 $\omega$ 是角频率，决定了函数变化的快慢。频率高 ($\omega$ 大)，函数变化快，相邻位置的值差异大；频率低 ($\omega$ 小)，函数变化慢，相邻位置的值差异小。对于维度 $i$，频率为
$$\omega =1/10000^{(2i/d_{model})}$$

PE	0	1	2	3
维度 $i$	0	0	1	1
频率 $\omega$	1	1	0.01	0.01
位置 $pos$=0	0.0000	1.0000	0.0000	1.0000
位置 $pos$=1	0.8415	0.5403	0.0100	0.9999
位置 $pos$=2	0.9093	-0.4161	0.0200	0.9998
位置 $pos$=3	0.1411	-0.9900	0.0300	0.9996
位置 $pos$=4	-0.7568	-0.6536	0.0400	0.9992

观察表 4.1，我们发现正余弦位置编码第 1 列相邻位置差异大，第 4 列相邻位置差异小，正余弦位置编码是利用高频捕获局部信息，比如在维度 0 时，位置 0 和 位置 1 有明显的差异，易于区分。
利用低频捕获全局信息，比如维度 1 时，PE(0,3) 和 PE(1,3) 几乎相同，但 PE(0,3) 和 PE(4,3) 差异较大。我们举例中 $d_{model}=4$，若 $d_{model}$ 比较大，比如 512，则差异会更加明显。所以正余弦编码可以多尺度地捕获输入位置信息。可以看出，如果按照本节开头，给输入向量简单加一个常数，则会导致相邻位置差异大，但远距离位置可能无法区分。
由于
$$\begin{array}{r}P{E}_{(pos+k,2i)}=P{E}_{(pos,2i)}\ast cos({\omega }_i\ast k)+P{E}_{(pos,2i+1)}\ast sin({\omega }_i\ast k)\\ P{E}_{(pos+k,2i+1)}=P{E}_{(pos,2i+1)}\ast cos({\omega }_i\ast k)-P{E}_{(pos,2i)}\ast sin({\omega }_i\ast k)\end{array}$$
对于任意位置 $pos+k$，可以表示为 $pos$ 的线性组合，这个特性使得模型易于学习相对位置关系。
正余弦编码每个位置都有唯一的编码表示，且编码是确定的，不用引入额外的训练参数，编码稳定，不会随训练过程变化。可以处理未见过的序列长度。值域在 $[-1,1]$ 之间，好控制，有利于模型训练的稳定性。

总结

Transformer 是深度学习里程碑式的成果，提高并行效率的同时，能保证性能 SOTA，这使得模型拥有了处理海量数据的能力，开启了 LLM 的“大航海时代”。

参考文献

[1]: Chan W , Jaitly N , Le Q V ,et al.Listen, Attend and Spell[J].Computer Science, 2015.DOI:10.48550/arXiv.1508.01211.
[2]: 张奇，桂韬，郑锐，黄萱菁，《大规模语言模型：从理论到实践（第2版）》，2025.
[3]: https://github.com/pytorch/pytorch/blob/main/torch/nn/modules/transformer.py