Transformer 以注意力机制为核心,在同一网络中结合跨位置的信息交流、逐位置的非线性计算、残差连接和归一化。本文从 Query、Key、Value 的计算开始,逐层说明原始 Transformer 的编码器、解码器、训练和生成过程,并通过小规模数值与交互实验解释 Dropout、H 1 H_1 H 1 、H 2 H_2 H 2 和 Add & Norm 的含义。
内容主要依据 Vaswani 等人在 2017 年发表的 Attention Is All You Need[1] 。涉及现代模型时,会说明它与原始架构的区别。
1. 从注意力机制开始 1.1 模型为什么需要关注其他位置 考虑一句话:“小明把苹果放进冰箱,因为它需要冷藏。”理解“它”的指代,需要利用前面的“苹果”及整个句子的语义。对于神经网络,可以将每个词语表示成向量,再让当前词语按照学习得到的权重整合其他位置的信息。
设当前有 n n n 个信息向量 v 1 , … , v n v_1,\ldots,v_n v 1 , … , v n ,注意力输出的一般形式为:
o = ∑ i = 1 n α i v i o=\sum_{i=1}^{n}\alpha_i v_i o = i = 1 ∑ n α i v i
其中 α i \alpha_i α i 描述当前位置对第 i i i 个信息来源分配的权重。权重可以随着当前目标发生变化。对于候选篮球鞋,历史篮球行为可能更有用;对于候选耳机,历史耳机行为可能更有用。
1.2 Query、Key、Value 的作用 Query(查询向量,记为 Q Q Q )描述当前需要的信息;Key(键向量,记为 K K K )用于计算信息之间的关联分数;Value(值向量,记为 V V V )提供最终参与加权的内容。
可以借助图书馆理解:读者想查找的主题类似 Query,书籍的主题标签类似 Key,书籍内容类似 Value。模型利用 Query 与 Key 判断关联程度,再整合对应 Value。
对于输入向量矩阵 X ∈ R n × d m o d e l X\in\mathbb R^{n\times d_{\mathrm{model}}} X ∈ R n × d model ,模型使用三个独立的可学习投影矩阵:
Q = X W Q , K = X W K , V = X W V Q=XW_Q,\qquad K=XW_K,\qquad V=XW_V Q = X W Q , K = X W K , V = X W V
若 W Q , W K ∈ R d m o d e l × d k W_Q,W_K\in\mathbb R^{d_{\mathrm{model}}\times d_k} W Q , W K ∈ R d model × d k ,W V ∈ R d m o d e l × d v W_V\in\mathbb R^{d_{\mathrm{model}}\times d_v} W V ∈ R d model × d v ,那么 Q , K Q,K Q , K 的每一行均为 d k d_k d k 维,V V V 的每一行为 d v d_v d v 维。三个投影的参数通过训练得到。
Key 与 Value 分别承担相关性计算和内容提供的任务,因此同一个输入可以形成不同的两种表示。
1.3 缩放点积注意力的三个步骤 标准 Scaled Dot-Product Attention(缩放点积注意力)计算为:[1]
Attention ( Q , K , V ) = softmax ( Q K ⊤ d k ) V \boxed{\operatorname{Attention}(Q,K,V)=\operatorname{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V} Attention ( Q , K , V ) = softmax ( d k Q K ⊤ ) V
先用 Query 与各个 Key 的点积计算分数:
s i j = q i k j ⊤ d k s_{ij}=\frac{q_i k_j^\top}{\sqrt{d_k}} s ij = d k q i k j ⊤
然后在每个 Query 对应的行上执行 Softmax:
α i j = exp ( s i j ) ∑ r = 1 n exp ( s i r ) \alpha_{ij}=\frac{\exp(s_{ij})}{\sum_{r=1}^{n}\exp(s_{ir})} α ij = ∑ r = 1 n exp ( s i r ) exp ( s ij )
最后用权重对 Value 加权:
o i = ∑ j = 1 n α i j v j o_i=\sum_{j=1}^{n}\alpha_{ij}v_j o i = j = 1 ∑ n α ij v j
Softmax 使每行权重为正,且总和为 1。每个 Query 都会产生一行自己的权重。
1.4 为什么除以平方根维度 假设 q j q_j q j 与 k j k_j k j 各维独立、均值为 0、方差为 1,且二者相互独立。点积为:
q k ⊤ = ∑ j = 1 d k q j k j qk^\top=\sum_{j=1}^{d_k}q_jk_j q k ⊤ = j = 1 ∑ d k q j k j
在这些假设下,每一项乘积的方差为 1。因此:
Var ( q k ⊤ ) = d k \operatorname{Var}(qk^\top)=d_k Var ( q k ⊤ ) = d k
除以 d k \sqrt{d_k} d k 后:
Var ( q k ⊤ d k ) = 1 \operatorname{Var}\left(\frac{qk^\top}{\sqrt{d_k}}\right)=1 Var ( d k q k ⊤ ) = 1
维度增大时,未经缩放的点积分数容易变得很大。Softmax 可能集中到极少数位置,导致部分梯度较小。缩放能够帮助控制分数的典型范围,改善训练。
1.5 使用三个向量计算 Self-Attention 设词语“我”“喜欢”“篮球”的向量为:
X = [ 1 0 0 1 1 1 ] X=\begin{bmatrix}1&0\\0&1\\1&1\end{bmatrix} X = 1 0 1 0 1 1
为了演示,取 W Q = W K = W V = I W_Q=W_K=W_V=I W Q = W K = W V = I 。于是 Q = K = V = X Q=K=V=X Q = K = V = X ,维度为 d k = 2 d_k=2 d k = 2 。
点积矩阵为:
Q K ⊤ = [ 1 0 1 0 1 1 1 1 2 ] QK^\top=\begin{bmatrix}1&0&1\\0&1&1\\1&1&2\end{bmatrix} Q K ⊤ = 1 0 1 0 1 1 1 1 2
除以 2 \sqrt2 2 ,再逐行执行 Softmax:
A ≈ [ 0.4011 0.1978 0.4011 0.1978 0.4011 0.4011 0.2483 0.2483 0.5035 ] A\approx\begin{bmatrix}0.4011&0.1978&0.4011\\0.1978&0.4011&0.4011\\0.2483&0.2483&0.5035\end{bmatrix} A ≈ 0.4011 0.1978 0.2483 0.1978 0.4011 0.2483 0.4011 0.4011 0.5035
然后计算 O = A V O=AV O = A V :
O ≈ [ 0.8022 0.5989 0.5989 0.8022 0.7517 0.7517 ] \boxed{O\approx\begin{bmatrix}0.8022&0.5989\\0.5989&0.8022\\0.7517&0.7517\end{bmatrix}} O ≈ 0.8022 0.5989 0.7517 0.5989 0.8022 0.7517
第三个输出向量来自三个位置的加权:
o 3 = 0.2483 [ 1 , 0 ] + 0.2483 [ 0 , 1 ] + 0.5035 [ 1 , 1 ] ≈ [ 0.7517 , 0.7517 ] o_3=0.2483[1,0]+0.2483[0,1]+0.5035[1,1]\approx[0.7517,0.7517] o 3 = 0.2483 [ 1 , 0 ] + 0.2483 [ 0 , 1 ] + 0.5035 [ 1 , 1 ] ≈ [ 0.7517 , 0.7517 ]
原来的“篮球”向量为 [ 1 , 1 ] [1,1] [ 1 , 1 ] ,新表示包含了其他位置的信息。这里只为说明计算过程,数值并不具有预先定义的语义。
下面的组件可以选择 Query,观察完整注意力矩阵、权重分布与输出向量如何变化。Query 强度滑块用于演示 Softmax 分数变化。
2. Self-Attention 与多头注意力 2.1 自注意力是什么 Self-Attention(自注意力)的特点是 Q , K , V Q,K,V Q , K , V 均由同一个序列生成:
Q = X W Q , K = X W K , V = X W V Q=XW_Q,\quad K=XW_K,\quad V=XW_V Q = X W Q , K = X W K , V = X W V
当模型允许一个位置关注整个序列时,每个位置的新表示都能够利用所有有效位置的信息。相同词语在不同上下文中可以得到不同的新向量。
注意力权重矩阵一般不对称。例如,前面数值例子中:
α 13 ≈ 0.4011 , α 31 ≈ 0.2483 \alpha_{13}\approx0.4011,\qquad\alpha_{31}\approx0.2483 α 13 ≈ 0.4011 , α 31 ≈ 0.2483
第一个位置关注第三个位置,与第三个位置关注第一个位置,是不同的计算。
2.2 多头注意力怎样计算 Multi-Head Attention(多头注意力)使用 h h h 组独立的投影矩阵:[1]
head r = Attention ( X W Q ( r ) , X W K ( r ) , X W V ( r ) ) \operatorname{head}_r=\operatorname{Attention}(XW_Q^{(r)},XW_K^{(r)},XW_V^{(r)}) head r = Attention ( X W Q ( r ) , X W K ( r ) , X W V ( r ) )
所有头的结果拼接,再经过输出投影:
MHA ( X ) = Concat ( head 1 , … , head h ) W O \boxed{\operatorname{MHA}(X)=\operatorname{Concat}(\operatorname{head}_1,\ldots,\operatorname{head}_h)W_O} MHA ( X ) = Concat ( head 1 , … , head h ) W O
例如原始 Transformer Base 的 d m o d e l = 512 d_{\mathrm{model}}=512 d model = 512 、h = 8 h=8 h = 8 ,每个头的 d k = d v = 64 d_k=d_v=64 d k = d v = 64 。若输入有 4 个 Token:
计算步骤
张量形状
输入 X X X
4 × 512 4\times512 4 × 512
每个头的 Q , K , V Q,K,V Q , K , V
4 × 64 4\times64 4 × 64
每个头的注意力权重
4 × 4 4\times4 4 × 4
每个头的输出
4 × 64 4\times64 4 × 64
8 个头拼接
4 × 512 4\times512 4 × 512
输出投影之后
4 × 512 4\times512 4 × 512
多个头允许模型在不同参数空间中计算信息联系。某些头可能学到语法关系,某些头可能学到时间或语义关系。每个头的实际用途由训练结果决定。
2.3 原始自注意力为何需要位置信息 考虑“小狗咬小猫”和“小猫咬小狗”。词语相同,顺序改变后含义发生变化。
没有额外位置处理的标准双向 Self-Attention,对于输入位置的重新排列,输出也会按对应方式重新排列。因此,模型需要能表示位置的机制。
原始 Transformer 使用正弦、余弦位置编码:[1]
P E ( p o s , 2 i ) = sin ( p o s 10000 2 i / d m o d e l ) PE(pos,2i)=\sin\left(\frac{pos}{10000^{2i/d_{\mathrm{model}}}}\right) P E ( p os , 2 i ) = sin ( 1000 0 2 i / d model p os )
P E ( p o s , 2 i + 1 ) = cos ( p o s 10000 2 i / d m o d e l ) PE(pos,2i+1)=\cos\left(\frac{pos}{10000^{2i/d_{\mathrm{model}}}}\right) P E ( p os , 2 i + 1 ) = cos ( 1000 0 2 i / d model p os )
输入可写为:
Z = d m o d e l E + P E Z=\sqrt{d_{\mathrm{model}}}E+PE Z = d model E + P E
其中 E E E 是 Token Embedding 矩阵。以 d m o d e l = 4 d_{\mathrm{model}}=4 d model = 4 为例,位置 0 的编码为 [ 0 , 1 , 0 , 1 ] [0,1,0,1] [ 0 , 1 , 0 , 1 ] ,位置 1 约为 [ 0.8415 , 0.5403 , 0.0100 , 1.0000 ] [0.8415,0.5403,0.0100,1.0000] [ 0.8415 , 0.5403 , 0.0100 , 1.0000 ] 。
现代模型还可能使用 RoPE(旋转位置编码)等方式,将相对位置信息引入注意力分数。[2]
2017 年的 Transformer 由 Encoder(编码器)与 Decoder(解码器)组成。编码器将源文本转换为上下文表示;解码器利用这些表示与目标端已有 Token,预测后续 Token。
原始 Transformer Base 包含 6 层 Encoder、6 层 Decoder,每层的模型维度为 512,注意力头数为 8,前馈网络中间维度为 2048。
文本进入模型的主要流程为:
Tokenization(文本分词):将文字映射为 Token 编号。
Embedding(嵌入):使用可学习参数将编号转换为向量。
Positional Encoding(位置编码):加入序列位置的信息。
Encoder:反复执行多头自注意力与前馈计算。
Decoder:执行带因果掩码的自注意力、交叉注意力与前馈计算。
Linear + Softmax:为词表中的 Token 计算下一步预测概率。
例如英文“I love cats.”可以编码成一组向量,由 Encoder 得到 Memory;Decoder 再逐步生成“我喜欢猫。”。
3.1 Encoder 中的计算 一个原始 Encoder Layer 有两个主要子模块:
Multi-Head Self-Attention:在源序列内部交换信息。
Position-wise Feed-Forward Network:对每个位置的特征进行独立的非线性变换。
每个子模块使用 Dropout、残差连接和 LayerNorm。原始架构把 LayerNorm 放在残差相加之后,称为 Post-LN(后置层归一化)。[1]
输入 X X X 经过注意力模块得到:
H = LayerNorm ( X + Dropout ( MHA ( X , X , X ) ) ) \boxed{H=\operatorname{LayerNorm}\left(X+\operatorname{Dropout}(\operatorname{MHA}(X,X,X))\right)} H = LayerNorm ( X + Dropout ( MHA ( X , X , X )) )
再经过 FFN:
Y = LayerNorm ( H + Dropout ( FFN ( H ) ) ) \boxed{Y=\operatorname{LayerNorm}\left(H+\operatorname{Dropout}(\operatorname{FFN}(H))\right)} Y = LayerNorm ( H + Dropout ( FFN ( H )) )
公式中的 MHA ( X , X , X ) \operatorname{MHA}(X,X,X) MHA ( X , X , X ) 表示 Query、Key、Value 的输入来源均是 X X X ,内部仍包含三个投影矩阵。
每个 Encoder Layer 的输出仍有 L s L_s L s 个位置。重复 6 层之后,得到最终 Encoder Memory:
M = Encoder ( X ) ∈ R L s × d m o d e l M=\operatorname{Encoder}(X)\in\mathbb R^{L_s\times d_{\mathrm{model}}} M = Encoder ( X ) ∈ R L s × d model
3.2 FFN 为什么夹在注意力之间 原始 Transformer 的前馈网络采用两个线性变换与 ReLU:
FFN ( x ) = ReLU ( x W 1 + b 1 ) W 2 + b 2 \operatorname{FFN}(x)=\operatorname{ReLU}(xW_1+b_1)W_2+b_2 FFN ( x ) = ReLU ( x W 1 + b 1 ) W 2 + b 2
对于 Transformer Base,维度为 512 → 2048 → 512 512\to2048\to512 512 → 2048 → 512 。每个 Token 使用同一组 FFN 参数,各个 Token 的输入值不同。
注意力负责整合不同位置的信息,FFN 负责对当前位置的特征进一步计算。重复这两个模块,可以逐层形成更加丰富的表示。
举例,令 x = [ 1 , 2 ] x=[1,2] x = [ 1 , 2 ] :
W 1 = [ 1 0 1 0 1 − 1 ] , W 2 = [ 1 1 2 0 1 − 1 ] W_1=\begin{bmatrix}1&0&1\\0&1&-1\end{bmatrix},\quad W_2=\begin{bmatrix}1&1\\2&0\\1&-1\end{bmatrix} W 1 = [ 1 0 0 1 1 − 1 ] , W 2 = 1 2 1 1 0 − 1
忽略偏置后:
x W 1 = [ 1 , 2 , − 1 ] ⟶ ReLU = [ 1 , 2 , 0 ] ⟶ FFN ( x ) = [ 5 , 1 ] xW_1=[1,2,-1]\;\longrightarrow\;\operatorname{ReLU}=[1,2,0]\;\longrightarrow\;\operatorname{FFN}(x)=[5,1] x W 1 = [ 1 , 2 , − 1 ] ⟶ ReLU = [ 1 , 2 , 0 ] ⟶ FFN ( x ) = [ 5 , 1 ]
因此,FFN 可以学习非线性特征变化,同时保持前后向量维度相同。
4. Add & Norm、Dropout 与隐藏状态 4.1 Add & Norm 的含义 原始 Transformer 架构图中的 Add & Norm 包含两个操作:
Add:将子模块输出与其输入相加,即残差连接。
Norm:对相加后的向量应用 Layer Normalization(层归一化)。
结合训练时使用的 Dropout,可以写为:
AddNorm ( x , F ) = LN ( x + Dropout ( F ( x ) ) ) \boxed{\operatorname{AddNorm}(x,F)=\operatorname{LN}\left(x+\operatorname{Dropout}(F(x))\right)} AddNorm ( x , F ) = LN ( x + Dropout ( F ( x )) )
以自注意力为例,F ( x ) = MHA ( x , x , x ) F(x)=\operatorname{MHA}(x,x,x) F ( x ) = MHA ( x , x , x ) 。
4.2 残差连接如何帮助梯度传播 假设一个子模块的计算为 F ( x ) F(x) F ( x ) ,残差连接给出:[3]
r = x + F ( x ) r=x+F(x) r = x + F ( x )
忽略后续 LayerNorm,残差相加这一步的导数为:
∂ r ∂ x = I + ∂ F ( x ) ∂ x \frac{\partial r}{\partial x}=I+\frac{\partial F(x)}{\partial x} ∂ x ∂ r = I + ∂ x ∂ F ( x )
这里的 I I I 表示恒等映射的直接路径。它有助于信息和梯度在深层网络中传播。完整模块还包括归一化等操作,因此完整梯度需要继续使用链式法则计算。
4.3 LayerNorm 具体计算什么 对于一个 Token 的 d d d 维向量 r r r ,LayerNorm 在特征维度计算均值与方差:[4]
μ = 1 d ∑ j = 1 d r j , σ 2 = 1 d ∑ j = 1 d ( r j − μ ) 2 \mu=\frac{1}{d}\sum_{j=1}^{d}r_j,\qquad\sigma^2=\frac{1}{d}\sum_{j=1}^{d}(r_j-\mu)^2 μ = d 1 j = 1 ∑ d r j , σ 2 = d 1 j = 1 ∑ d ( r j − μ ) 2
然后:
LN ( r ) j = γ j r j − μ σ 2 + ϵ + β j \boxed{\operatorname{LN}(r)_j=\gamma_j\frac{r_j-\mu}{\sqrt{\sigma^2+\epsilon}}+\beta_j} LN ( r ) j = γ j σ 2 + ϵ r j − μ + β j
γ j \gamma_j γ j 和 β j \beta_j β j 是可学习的缩放、平移参数;ϵ \epsilon ϵ 用于保证数值稳定。
例如 r = [ 5 , 7 , 9 ] r=[5,7,9] r = [ 5 , 7 , 9 ] ,均值为 7、方差为 8 / 3 8/3 8/3 。在 γ = 1 , β = 0 \gamma=1,\beta=0 γ = 1 , β = 0 且忽略 ϵ \epsilon ϵ 时,归一化结果约为 [ − 1.2247 , 0 , 1.2247 ] [-1.2247,0,1.2247] [ − 1.2247 , 0 , 1.2247 ] 。
4.4 Dropout 会发生什么 Dropout(随机失活)是一种正则化方法。训练时,它按照指定概率 p p p 将部分输出元素设为 0。常见的反向缩放实现将保留的元素除以 1 − p 1-p 1 − p :[5] [6]
y i = m i 1 − p x i , m i ∼ Bernoulli ( 1 − p ) y_i=\frac{m_i}{1-p}x_i,\qquad m_i\sim\operatorname{Bernoulli}(1-p) y i = 1 − p m i x i , m i ∼ Bernoulli ( 1 − p )
由于 E [ m i ] = 1 − p \mathbb E[m_i]=1-p E [ m i ] = 1 − p :
E [ y i ] = x i \mathbb E[y_i]=x_i E [ y i ] = x i
所以,Dropout 输出的期望与原输入一致。常见实现会在模型推理阶段关闭 Dropout。
例如 p = 0.5 p=0.5 p = 0.5 ,原注意力输出为 [ 2 , 4 , 6 , 8 ] [2,4,6,8] [ 2 , 4 , 6 , 8 ] ,假设随机保留第一个、第三个位置,则:
Dropout ( [ 2 , 4 , 6 , 8 ] ) = [ 4 , 0 , 12 , 0 ] \operatorname{Dropout}([2,4,6,8])=[4,0,12,0] Dropout ([ 2 , 4 , 6 , 8 ]) = [ 4 , 0 , 12 , 0 ]
如果残差输入为 X = [ 1 , 1 , 1 , 1 ] X=[1,1,1,1] X = [ 1 , 1 , 1 , 1 ] ,得到:
R = X + Dropout ( A ) = [ 5 , 1 , 13 , 1 ] R=X+\operatorname{Dropout}(A)=[5,1,13,1] R = X + Dropout ( A ) = [ 5 , 1 , 13 , 1 ]
计算均值为 5,方差为 24。取 γ = 1 , β = 0 \gamma=1,\beta=0 γ = 1 , β = 0 且忽略很小的 ϵ \epsilon ϵ ,最终:
LN ( R ) ≈ [ 0 , − 0.8165 , 1.6330 , − 0.8165 ] \operatorname{LN}(R)\approx[0,-0.8165,1.6330,-0.8165] LN ( R ) ≈ [ 0 , − 0.8165 , 1.6330 , − 0.8165 ]
这就是从注意力输出经过 Dropout、Add 和 Norm 得到隐藏状态的完整数值过程。
下面可以调整丢弃概率、重新生成随机掩码,并观察残差结果和 LayerNorm 输出。归一化使用 ϵ = 10 − 5 \epsilon=10^{-5} ϵ = 1 0 − 5 。
4.5 Post-LN 与 Pre-LN 原始 Transformer 使用 Post-LN:
y = LN ( x + F ( x ) ) y=\operatorname{LN}(x+F(x)) y = LN ( x + F ( x ))
很多后续模型采用 Pre-LN(归一化前置):
y = x + F ( LN ( x ) ) y=x+F(\operatorname{LN}(x)) y = x + F ( LN ( x ))
两者的归一化位置不同,完整梯度传播路径也不同。Pre-LN 常用于改善较深 Transformer 的训练稳定性。阅读具体模型时,需要依据模型结构判断采用哪种顺序。[7]
5. Decoder 的三个子模块 一个原始 Decoder Layer 有三个子模块:Masked Self-Attention(带掩码的自注意力)、Cross-Attention(交叉注意力)和 FFN。三个模块都使用 Add & Norm。
5.1 Masked Self-Attention 对于自回归生成,当前位置只能使用当前以及之前的目标 Token。可以在注意力分数中加入因果掩码 C C C :[1]
A = softmax ( Q K ⊤ d k + C ) A=\operatorname{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}+C\right) A = softmax ( d k Q K ⊤ + C )
对于长度为 4 的目标序列:
C = [ 0 − ∞ − ∞ − ∞ 0 0 − ∞ − ∞ 0 0 0 − ∞ 0 0 0 0 ] C=\begin{bmatrix}0&-\infty&-\infty&-\infty\\0&0&-\infty&-\infty\\0&0&0&-\infty\\0&0&0&0\end{bmatrix} C = 0 0 0 0 − ∞ 0 0 0 − ∞ − ∞ 0 0 − ∞ − ∞ − ∞ 0
被掩盖位置的 Softmax 权重为 0。填充位置还可以通过 Padding Mask 单独处理。
5.2 第一段隐藏状态 H 1 H_1 H 1 用 D D D 表示 Decoder Layer 的输入。完成 Masked Self-Attention 及 Add & Norm 后:
H 1 = LN ( D + Dropout ( MaskedMHA ( D , D , D ) ) ) \boxed{H_1=\operatorname{LN}\left(D+\operatorname{Dropout}(\operatorname{MaskedMHA}(D,D,D))\right)} H 1 = LN ( D + Dropout ( MaskedMHA ( D , D , D )) )
H 1 H_1 H 1 已经整合目标端允许访问的位置的信息。若批次大小为 B B B 、目标长度为 L t L_t L t ,则:
H 1 ∈ R B × L t × d m o d e l H_1\in\mathbb R^{B\times L_t\times d_{\mathrm{model}}} H 1 ∈ R B × L t × d model
5.3 第二段隐藏状态 H 2 H_2 H 2 是什么 接下来的 Cross-Attention 让解码器访问编码器输出的 M M M 。
Q = H 1 W Q , K = M W K , V = M W V Q=H_1W_Q,\qquad K=MW_K,\qquad V=MW_V Q = H 1 W Q , K = M W K , V = M W V
于是:
H 2 = LN ( H 1 + Dropout ( MHA ( H 1 , M , M ) ) ) \boxed{H_2=\operatorname{LN}\left(H_1+\operatorname{Dropout}(\operatorname{MHA}(H_1,M,M))\right)} H 2 = LN ( H 1 + Dropout ( MHA ( H 1 , M , M )) )
H 2 H_2 H 2 就是第二个子模块的隐藏状态。它包含目标端上下文与源语言信息。
这里的 MHA ( H 1 , M , M ) \operatorname{MHA}(H_1,M,M) MHA ( H 1 , M , M ) 分别说明 Q、K、V 的来源。H 1 H_1 H 1 负责查询,M M M 为查询提供 Key 和 Value。
若英文输入长度为 5,目标端长度为 4,Batch Size 为 2,模型维度为 512:
张量
形状
H 1 H_1 H 1
2 × 4 × 512 2\times4\times512 2 × 4 × 512
M M M
2 × 5 × 512 2\times5\times512 2 × 5 × 512
单头 Cross-Attention 权重
2 × 4 × 5 2\times4\times5 2 × 4 × 5
Cross-Attention 完整输出
2 × 4 × 512 2\times4\times512 2 × 4 × 512
H 2 H_2 H 2
2 × 4 × 512 2\times4\times512 2 × 4 × 512
因此,H 2 H_2 H 2 的位置数量与 H 1 H_1 H 1 相同,内部的信息已经通过 Cross-Attention 得到更新。
5.4 第三个子模块与最终输出 Decoder Layer 再执行前馈计算:
Y = LN ( H 2 + Dropout ( FFN ( H 2 ) ) ) Y=\operatorname{LN}\left(H_2+\operatorname{Dropout}(\operatorname{FFN}(H_2))\right) Y = LN ( H 2 + Dropout ( FFN ( H 2 )) )
原始 Transformer 重复 6 个这样的 Decoder Layer。最终解码器输出再经过线性层与 Softmax,产生词表上的预测概率。
6. 训练与生成 6.1 训练时的目标序列 以英文“I love cats.”翻译成中文“我喜欢猫”为例。为了训练模型预测下一个 Token,目标端使用错开一个位置的输入和标签。[1]
Decoder 输入位置
该位置正确的预测目标
BOS
我
我
喜欢
喜欢
猫
猫
EOS
BOS 表示序列开始标记,EOS 表示序列结束标记。训练时,Decoder Input 为“BOS 我 喜欢 猫”,标签为“我 喜欢 猫 EOS”。
通过因果掩码,每个位置只能利用允许访问的目标端前文。因为训练数据中已经包含正确目标序列,多个位置可以在一次前向传播中同时计算预测。
6.2 交叉熵与反向传播 预测目标 Token 的概率记为 P θ ( y t ∣ y < t , x ) P_\theta(y_t\mid y_{<t},x) P θ ( y t ∣ y < t , x ) ,其中 x x x 是源语言输入。常见训练损失为:
L ( θ ) = − ∑ t = 1 T log P θ ( y t ∣ y < t , x ) \boxed{\mathcal L(\theta)=-\sum_{t=1}^{T}\log P_\theta(y_t\mid y_{<t},x)} L ( θ ) = − t = 1 ∑ T log P θ ( y t ∣ y < t , x )
训练程序可以对有效位置取平均,并忽略 Padding Token。
损失通过反向传播更新 Embedding、W Q , W K , W V W_Q,W_K,W_V W Q , W K , W V 、FFN 和输出层等参数。优化器使用梯度调整模型,使正确 Token 的预测概率逐渐提高。
6.3 生成为什么逐步进行 推理时,模型只有已经生成的 Token。它从 BOS 开始,预测下一个 Token,将该 Token 加入上下文,再继续计算:
P ( y ∣ x ) = ∏ t = 1 T P ( y t ∣ y < t , x ) P(y\mid x)=\prod_{t=1}^{T}P(y_t\mid y_{<t},x) P ( y ∣ x ) = t = 1 ∏ T P ( y t ∣ y < t , x )
训练时可以并行计算已知目标序列的多个位置;自回归生成通常需要按顺序确定新的 Token。
6.4 KV Cache 的作用 自回归生成时,前面位置的 Key、Value 可以缓存下来。生成新的 Token 时,计算当前 Query,并重复利用此前保存的 Key、Value,减少重复处理已生成序列的计算。[8]
在 Encoder-Decoder 模型中,编码器输出产生的 Cross-Attention Key、Value 也可以重复利用。缓存通常会随着上下文长度增加而占用更多存储空间。
7. 使用 PyTorch 理解计算接口 PyTorch 的 nn.MultiheadAttention 提供多头注意力计算,nn.Transformer 提供 Encoder-Decoder Transformer 的参考实现。布尔掩码的语义必须按接口区分:在这两个模块的布尔注意力掩码中,True 表示禁止关注;在 F.scaled_dot_product_attention 的布尔 attn_mask 中,True 则表示允许参与注意力。两种掩码不能不加转换地混用。[9] [10] [11]
下面的代码使用一个三词语输入,并对照内置的缩放点积注意力验证手动矩阵运算。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 import mathimport torchimport torch.nn.functional as Fx = torch.tensor([[ [1.0 , 0.0 ], [0.0 , 1.0 ], [1.0 , 1.0 ], ]]) query = x key = x value = x scores = query @ key.transpose(-2 , -1 ) scores = scores / math.sqrt(key.shape[-1 ]) weights = torch.softmax(scores, dim=-1 ) output = weights @ value reference = F.scaled_dot_product_attention(query, key, value) torch.testing.assert_close(output, reference) print ("注意力权重:" , weights.round (decimals=4 ))print ("输出:" , output.round (decimals=4 ))
上述程序中的三个输入张量形状都是 ( 1 , 3 , 2 ) (1,3,2) ( 1 , 3 , 2 ) ;注意力矩阵形状为 ( 1 , 3 , 3 ) (1,3,3) ( 1 , 3 , 3 ) ,输出形状为 ( 1 , 3 , 2 ) (1,3,2) ( 1 , 3 , 2 ) 。与前面的手动推导一致,第三个 Token 的输出约为 [ 0.7517 , 0.7517 ] [0.7517,0.7517] [ 0.7517 , 0.7517 ] 。
下面进一步构建一个带正弦位置编码的小型 Encoder-Decoder Transformer。代码包含输入、因果掩码、Padding Mask、输出投影、交叉熵损失和参数更新。样本中的 Token 编号是教学示例,训练一次只能验证计算连接与梯度更新。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 import mathimport torchfrom torch import nntorch.manual_seed(0 ) pad_id = 0 vocab_size = 20 model_dim = 32 source_tokens = torch.tensor([ [3 , 4 , 5 , 2 ], [3 , 6 , 2 , 0 ], ]) target_input = torch.tensor([ [1 , 7 , 8 , 9 ], [1 , 7 , 10 , 0 ], ]) target_labels = torch.tensor([ [7 , 8 , 9 , 2 ], [7 , 10 , 2 , 0 ], ]) class TinyTransformer (nn.Module): def __init__ (self ): super ().__init__() self .source_embedding = nn.Embedding(vocab_size, model_dim) self .target_embedding = nn.Embedding(vocab_size, model_dim) self .transformer = nn.Transformer( d_model=model_dim, nhead=4 , num_encoder_layers=2 , num_decoder_layers=2 , dim_feedforward=64 , dropout=0.0 , batch_first=True , ) self .output_projection = nn.Linear(model_dim, vocab_size) def add_position (self, embeddings ): length = embeddings.size(1 ) positions = torch.arange( length, device=embeddings.device ).unsqueeze(1 ) indices = torch.arange( 0 , model_dim, 2 , device=embeddings.device ) frequencies = torch.exp( -math.log(10000.0 ) * indices / model_dim ) angles = positions * frequencies position_encoding = torch.zeros( length, model_dim, device=embeddings.device ) position_encoding[:, 0 ::2 ] = torch.sin(angles) position_encoding[:, 1 ::2 ] = torch.cos(angles) return ( embeddings * math.sqrt(model_dim) + position_encoding.unsqueeze(0 ) ) def forward (self, source, target ): length = target.size(1 ) causal_mask = torch.triu( torch.ones( length, length, dtype=torch.bool , device=target.device, ), diagonal=1 , ) source_vectors = self .add_position( self .source_embedding(source) ) target_vectors = self .add_position( self .target_embedding(target) ) hidden = self .transformer( source_vectors, target_vectors, tgt_mask=causal_mask, src_key_padding_mask=source.eq(pad_id), tgt_key_padding_mask=target.eq(pad_id), memory_key_padding_mask=source.eq(pad_id), ) return self .output_projection(hidden) model = TinyTransformer() optimizer = torch.optim.Adam(model.parameters(), lr=0.001 ) logits = model(source_tokens, target_input) loss = nn.functional.cross_entropy( logits.reshape(-1 , vocab_size), target_labels.reshape(-1 ), ignore_index=pad_id, ) optimizer.zero_grad() loss.backward() optimizer.step() assert torch.isfinite(loss)print ("Logits shape:" , logits.shape)print ("Loss:" , round (loss.detach().item(), 4 ))
实际执行后,预测张量的形状为 ( 2 , 4 , 20 ) (2,4,20) ( 2 , 4 , 20 ) ,在固定随机种子与所用环境下得到有限的损失值。这里的 2、4、20 分别表示批次大小、目标长度和词表大小。
架构
典型模型
主要特点
Encoder-Only
BERT
双向 Self-Attention,常用于语义理解和特征提取
Decoder-Only
GPT
因果 Self-Attention,常用于自回归文本生成
Encoder-Decoder
原始 Transformer、T5
编码器处理输入,解码器利用 Cross-Attention 生成目标序列
上表的 BERT、GPT 与 T5 分别对应编码器、因果解码器和编码器—解码器的代表结构。GPT 的基础 Decoder-Only 主干不包含原始 Encoder-Decoder 架构中的编码器交叉注意力;不能将原始 Transformer 的整套结构套用于所有后续模型。[12] [13] [14] 不同模型的归一化位置、位置编码与 FFN 激活还可能不同,需以各模型论文为准。
9. 计算成本与推荐系统应用 9.1 注意力的计算成本 对于长度为 L L L 的序列,完整 Self-Attention 的注意力矩阵大小为 L × L L\times L L × L 。主要注意力计算量通常为:
O ( L 2 d ) O(L^2d) O ( L 2 d )
其中 d d d 表示相关向量维度的量级。若直接保存完整注意力矩阵,每个头需要 O ( L 2 ) O(L^2) O ( L 2 ) 级别的空间。
例如长度由 512 增加到 1024,注意力分数数量从 262,144 增加到 1,048,576。FlashAttention 可以通过更高效的数据读取和分块计算改善运行效率,并在标准注意力目标下减少中间存储开销。[15]
9.2 推荐系统的目标注意力 DIN(Deep Interest Network)会根据当前候选商品,判断用户历史行为与候选商品的关联程度。
设用户历史行为向量为 v i v_i v i ,候选商品向量为 q q q :
u ( q ) = ∑ i = 1 n a i ( q ) v i u(q)=\sum_{i=1}^{n}a_i(q)v_i u ( q ) = i = 1 ∑ n a i ( q ) v i
这里的 a i ( q ) a_i(q) a i ( q ) 是针对候选商品计算的激活权重。DIN 的经典局部激活单元通常直接使用这些分数加权,无须强制 Softmax 权重之和为 1。[16]
SASRec(Self-Attentive Sequential Recommendation)则通过因果 Self-Attention,学习用户历史行为序列中各位置的关系,并预测后续可能的交互商品。[17]
9.3 注意力权重可以解释最终预测吗 一个位置的注意力权重越大,说明它的 Value 在当前加权操作中获得更大的系数。但最终预测还受到 Value 向量数值、其他注意力头、后续层与输出投影的影响。
因此,注意力矩阵有助于理解信息交互过程,但不能自动等同于对最终预测的可靠解释。Jain 与 Wallace 在特定 NLP 模型上的实验展示了这一风险;这不是对所有架构的因果定理,更不能仅凭一张推荐注意力图确定因果贡献。要判断输入对最终结果的影响,还需要结合完整模型与干预或消融进行分析。[18]
参考文献 [1] VASWANI A, SHAZEER N, PARMAR N, et al. Attention Is All You Need [C]//Advances in Neural Information Processing Systems. 2017, 30.
[2] SU J, AHMED M, LU Y, et al. RoFormer: Enhanced transformer with Rotary Position Embedding [J]. Neurocomputing, 2024, 568: 127063. DOI: 10.1016/j.neucom.2023.127063.
[3] HE K, ZHANG X, REN S, et al. Deep Residual Learning for Image Recognition [C]//Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2016.
[4] BA J L, KIROS J R, HINTON G E. Layer Normalization [EB/OL]. arXiv:1607.06450, 2016.
[5] SRIVASTAVA N, HINTON G, KRIZHEVSKY A, et al. Dropout: A Simple Way to Prevent Neural Networks from Overfitting [J]. Journal of Machine Learning Research, 2014, 15(56): 1929–1958.
[6] PyTorch Contributors. Dropout [EB/OL]. PyTorch 2.10.
[7] XIONG R, YANG Y, HE D, et al. On Layer Normalization in the Transformer Architecture [C]//Proceedings of the International Conference on Machine Learning. 2020, 119: 10524–10533.
[8] Hugging Face. How caching works [EB/OL].
[9] PyTorch Contributors. MultiheadAttention [EB/OL]. PyTorch 2.10.
[10] PyTorch Contributors. Transformer [EB/OL]. PyTorch 2.10.
[11] PyTorch Contributors. scaled_dot_product_attention [EB/OL]. PyTorch 2.10.
[12] DEVLIN J, CHANG M W, LEE K, et al. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding [C]//Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. 2019.
[13] RADFORD A, NARASIMHAN K, SALIMANS T, et al. Improving Language Understanding by Generative Pre-Training [R/OL]. OpenAI, 2018.
[14] RAFFEL C, SHAZEER N, ROBERTS A, et al. Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer [J]. Journal of Machine Learning Research, 2020, 21(140): 1–67.
[15] DAO T, FU D Y, ERMON S, et al. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness [C]//Advances in Neural Information Processing Systems. 2022, 35.
[16] ZHOU G, SONG C, ZHU X, et al. Deep Interest Network for Click-Through Rate Prediction [C]//Proceedings of the ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. 2018.
[17] KANG W C, MCAULEY J. Self-Attentive Sequential Recommendation [C]//Proceedings of the IEEE International Conference on Data Mining. 2018.
[18] JAIN S, WALLACE B C. Attention is not Explanation [C]//Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. 2019: 3543–3556.
评论由 GitHub Giscus 提供。若当前网络无法加载,可 前往 GitHub Discussions 查看或参与讨论。