Transformer 的原理与计算过程

Transformer 的原理与计算过程

Jackknifer
Jackknifer 博主

Transformer 以注意力机制为核心,在同一网络中结合跨位置的信息交流、逐位置的非线性计算、残差连接和归一化。本文从 Query、Key、Value 的计算开始,逐层说明原始 Transformer 的编码器、解码器、训练和生成过程,并通过小规模数值与交互实验解释 Dropout、H1H_1、H2H_2 和 Add & Norm 的含义。

内容主要依据 Vaswani 等人在 2017 年发表的 Attention Is All You Need[1]。涉及现代模型时,会说明它与原始架构的区别。

1. 从注意力机制开始

1.1 模型为什么需要关注其他位置

考虑一句话:“小明把苹果放进冰箱,因为它需要冷藏。”理解“它”的指代,需要利用前面的“苹果”及整个句子的语义。对于神经网络,可以将每个词语表示成向量,再让当前词语按照学习得到的权重整合其他位置的信息。

设当前有 nn 个信息向量 v1,…,vnv_1,\ldots,v_n,注意力输出的一般形式为:

o=∑i=1nαivio=\sum_{i=1}^{n}\alpha_i v_i

其中 αi\alpha_i 描述当前位置对第 ii 个信息来源分配的权重。权重可以随着当前目标发生变化。对于候选篮球鞋,历史篮球行为可能更有用;对于候选耳机,历史耳机行为可能更有用。

1.2 Query、Key、Value 的作用

Query(查询向量,记为 QQ)描述当前需要的信息;Key(键向量,记为 KK)用于计算信息之间的关联分数;Value(值向量,记为 VV)提供最终参与加权的内容。

可以借助图书馆理解:读者想查找的主题类似 Query,书籍的主题标签类似 Key,书籍内容类似 Value。模型利用 Query 与 Key 判断关联程度,再整合对应 Value。

对于输入向量矩阵 X∈Rn×dmodelX\in\mathbb R^{n\times d_{\mathrm{model}}},模型使用三个独立的可学习投影矩阵:

Q=XWQ,K=XWK,V=XWVQ=XW_Q,\qquad K=XW_K,\qquad V=XW_V

若 WQ,WK∈Rdmodel×dkW_Q,W_K\in\mathbb R^{d_{\mathrm{model}}\times d_k},WV∈Rdmodel×dvW_V\in\mathbb R^{d_{\mathrm{model}}\times d_v},那么 Q,KQ,K 的每一行均为 dkd_k 维,VV 的每一行为 dvd_v 维。三个投影的参数通过训练得到。

Key 与 Value 分别承担相关性计算和内容提供的任务,因此同一个输入可以形成不同的两种表示。

1.3 缩放点积注意力的三个步骤

标准 Scaled Dot-Product Attention(缩放点积注意力)计算为:[1]

Attention⁡(Q,K,V)=softmax⁡(QK⊤dk)V\boxed{\operatorname{Attention}(Q,K,V)=\operatorname{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V}

先用 Query 与各个 Key 的点积计算分数:

sij=qikj⊤dks_{ij}=\frac{q_i k_j^\top}{\sqrt{d_k}}

然后在每个 Query 对应的行上执行 Softmax:

αij=exp⁡(sij)∑r=1nexp⁡(sir)\alpha_{ij}=\frac{\exp(s_{ij})}{\sum_{r=1}^{n}\exp(s_{ir})}

最后用权重对 Value 加权:

oi=∑j=1nαijvjo_i=\sum_{j=1}^{n}\alpha_{ij}v_j

Softmax 使每行权重为正,且总和为 1。每个 Query 都会产生一行自己的权重。

1.4 为什么除以平方根维度

假设 qjq_j 与 kjk_j 各维独立、均值为 0、方差为 1,且二者相互独立。点积为:

qk⊤=∑j=1dkqjkjqk^\top=\sum_{j=1}^{d_k}q_jk_j

在这些假设下,每一项乘积的方差为 1。因此:

Var⁡(qk⊤)=dk\operatorname{Var}(qk^\top)=d_k

除以 dk\sqrt{d_k} 后:

Var⁡(qk⊤dk)=1\operatorname{Var}\left(\frac{qk^\top}{\sqrt{d_k}}\right)=1

维度增大时,未经缩放的点积分数容易变得很大。Softmax 可能集中到极少数位置,导致部分梯度较小。缩放能够帮助控制分数的典型范围,改善训练。

1.5 使用三个向量计算 Self-Attention

设词语“我”“喜欢”“篮球”的向量为:

X=[100111]X=\begin{bmatrix}1&0\\0&1\\1&1\end{bmatrix}

为了演示,取 WQ=WK=WV=IW_Q=W_K=W_V=I。于是 Q=K=V=XQ=K=V=X,维度为 dk=2d_k=2。

点积矩阵为:

QK⊤=[101011112]QK^\top=\begin{bmatrix}1&0&1\\0&1&1\\1&1&2\end{bmatrix}

除以 2\sqrt2,再逐行执行 Softmax:

A≈[0.40110.19780.40110.19780.40110.40110.24830.24830.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}

然后计算 O=AVO=AV:

O≈[0.80220.59890.59890.80220.75170.7517]\boxed{O\approx\begin{bmatrix}0.8022&0.5989\\0.5989&0.8022\\0.7517&0.7517\end{bmatrix}}

第三个输出向量来自三个位置的加权:

o3=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]

原来的“篮球”向量为 [1,1][1,1],新表示包含了其他位置的信息。这里只为说明计算过程,数值并不具有预先定义的语义。

下面的组件可以选择 Query,观察完整注意力矩阵、权重分布与输出向量如何变化。Query 强度滑块用于演示 Softmax 分数变化。

单独打开Self-Attention 数值计算

2. Self-Attention 与多头注意力

2.1 自注意力是什么

Self-Attention(自注意力)的特点是 Q,K,VQ,K,V 均由同一个序列生成:

Q=XWQ,K=XWK,V=XWVQ=XW_Q,\quad K=XW_K,\quad V=XW_V

当模型允许一个位置关注整个序列时,每个位置的新表示都能够利用所有有效位置的信息。相同词语在不同上下文中可以得到不同的新向量。

注意力权重矩阵一般不对称。例如,前面数值例子中:

α13≈0.4011,α31≈0.2483\alpha_{13}\approx0.4011,\qquad\alpha_{31}\approx0.2483

第一个位置关注第三个位置,与第三个位置关注第一个位置,是不同的计算。

2.2 多头注意力怎样计算

Multi-Head Attention(多头注意力)使用 hh 组独立的投影矩阵:[1]

head⁡r=Attention⁡(XWQ(r),XWK(r),XWV(r))\operatorname{head}_r=\operatorname{Attention}(XW_Q^{(r)},XW_K^{(r)},XW_V^{(r)})

所有头的结果拼接,再经过输出投影:

MHA⁡(X)=Concat⁡(head⁡1,…,head⁡h)WO\boxed{\operatorname{MHA}(X)=\operatorname{Concat}(\operatorname{head}_1,\ldots,\operatorname{head}_h)W_O}

例如原始 Transformer Base 的 dmodel=512d_{\mathrm{model}}=512、h=8h=8,每个头的 dk=dv=64d_k=d_v=64。若输入有 4 个 Token:

计算步骤 张量形状
输入 XX 4×5124\times512
每个头的 Q,K,VQ,K,V 4×644\times64
每个头的注意力权重 4×44\times4
每个头的输出 4×644\times64
8 个头拼接 4×5124\times512
输出投影之后 4×5124\times512

多个头允许模型在不同参数空间中计算信息联系。某些头可能学到语法关系,某些头可能学到时间或语义关系。每个头的实际用途由训练结果决定。

2.3 原始自注意力为何需要位置信息

考虑“小狗咬小猫”和“小猫咬小狗”。词语相同,顺序改变后含义发生变化。

没有额外位置处理的标准双向 Self-Attention,对于输入位置的重新排列,输出也会按对应方式重新排列。因此,模型需要能表示位置的机制。

原始 Transformer 使用正弦、余弦位置编码:[1]

PE(pos,2i)=sin⁡(pos100002i/dmodel)PE(pos,2i)=\sin\left(\frac{pos}{10000^{2i/d_{\mathrm{model}}}}\right) PE(pos,2i+1)=cos⁡(pos100002i/dmodel)PE(pos,2i+1)=\cos\left(\frac{pos}{10000^{2i/d_{\mathrm{model}}}}\right)

输入可写为:

Z=dmodelE+PEZ=\sqrt{d_{\mathrm{model}}}E+PE

其中 EE 是 Token Embedding 矩阵。以 dmodel=4d_{\mathrm{model}}=4 为例,位置 0 的编码为 [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]。

现代模型还可能使用 RoPE(旋转位置编码)等方式,将相对位置信息引入注意力分数。[2]

3. 原始 Transformer 的整体结构

2017 年的 Transformer 由 Encoder(编码器)与 Decoder(解码器)组成。编码器将源文本转换为上下文表示;解码器利用这些表示与目标端已有 Token,预测后续 Token。

原始 Transformer Base 包含 6 层 Encoder、6 层 Decoder,每层的模型维度为 512,注意力头数为 8,前馈网络中间维度为 2048。

文本进入模型的主要流程为:

  1. Tokenization(文本分词):将文字映射为 Token 编号。
  2. Embedding(嵌入):使用可学习参数将编号转换为向量。
  3. Positional Encoding(位置编码):加入序列位置的信息。
  4. Encoder:反复执行多头自注意力与前馈计算。
  5. Decoder:执行带因果掩码的自注意力、交叉注意力与前馈计算。
  6. 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]

输入 XX 经过注意力模块得到:

H=LayerNorm⁡(X+Dropout⁡(MHA⁡(X,X,X)))\boxed{H=\operatorname{LayerNorm}\left(X+\operatorname{Dropout}(\operatorname{MHA}(X,X,X))\right)}

再经过 FFN:

Y=LayerNorm⁡(H+Dropout⁡(FFN⁡(H)))\boxed{Y=\operatorname{LayerNorm}\left(H+\operatorname{Dropout}(\operatorname{FFN}(H))\right)}

公式中的 MHA⁡(X,X,X)\operatorname{MHA}(X,X,X) 表示 Query、Key、Value 的输入来源均是 XX,内部仍包含三个投影矩阵。

每个 Encoder Layer 的输出仍有 LsL_s 个位置。重复 6 层之后,得到最终 Encoder Memory:

M=Encoder⁡(X)∈RLs×dmodelM=\operatorname{Encoder}(X)\in\mathbb R^{L_s\times d_{\mathrm{model}}}

3.2 FFN 为什么夹在注意力之间

原始 Transformer 的前馈网络采用两个线性变换与 ReLU:

FFN⁡(x)=ReLU⁡(xW1+b1)W2+b2\operatorname{FFN}(x)=\operatorname{ReLU}(xW_1+b_1)W_2+b_2

对于 Transformer Base,维度为 512→2048→512512\to2048\to512。每个 Token 使用同一组 FFN 参数,各个 Token 的输入值不同。

注意力负责整合不同位置的信息,FFN 负责对当前位置的特征进一步计算。重复这两个模块,可以逐层形成更加丰富的表示。

举例,令 x=[1,2]x=[1,2]:

W1=[10101−1],W2=[11201−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}

忽略偏置后:

xW1=[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]

因此,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)}

以自注意力为例,F(x)=MHA⁡(x,x,x)F(x)=\operatorname{MHA}(x,x,x)。

4.2 残差连接如何帮助梯度传播

假设一个子模块的计算为 F(x)F(x),残差连接给出:[3]

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}

这里的 II 表示恒等映射的直接路径。它有助于信息和梯度在深层网络中传播。完整模块还包括归一化等操作,因此完整梯度需要继续使用链式法则计算。

4.3 LayerNorm 具体计算什么

对于一个 Token 的 dd 维向量 rr,LayerNorm 在特征维度计算均值与方差:[4]

μ=1d∑j=1drj,σ2=1d∑j=1d(rj−μ)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

然后:

LN⁡(r)j=γjrj−μσ2+ϵ+βj\boxed{\operatorname{LN}(r)_j=\gamma_j\frac{r_j-\mu}{\sqrt{\sigma^2+\epsilon}}+\beta_j}

γj\gamma_j 和 βj\beta_j 是可学习的缩放、平移参数;ϵ\epsilon 用于保证数值稳定。

例如 r=[5,7,9]r=[5,7,9],均值为 7、方差为 8/38/3。在 γ=1,β=0\gamma=1,\beta=0 且忽略 ϵ\epsilon 时,归一化结果约为 [−1.2247,0,1.2247][-1.2247,0,1.2247]。

4.4 Dropout 会发生什么

Dropout(随机失活)是一种正则化方法。训练时,它按照指定概率 pp 将部分输出元素设为 0。常见的反向缩放实现将保留的元素除以 1−p1-p:[5][6]

yi=mi1−pxi,mi∼Bernoulli⁡(1−p)y_i=\frac{m_i}{1-p}x_i,\qquad m_i\sim\operatorname{Bernoulli}(1-p)

由于 E[mi]=1−p\mathbb E[m_i]=1-p:

E[yi]=xi\mathbb E[y_i]=x_i

所以,Dropout 输出的期望与原输入一致。常见实现会在模型推理阶段关闭 Dropout。

例如 p=0.5p=0.5,原注意力输出为 [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]

如果残差输入为 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]

计算均值为 5,方差为 24。取 γ=1,β=0\gamma=1,\beta=0 且忽略很小的 ϵ\epsilon,最终:

LN⁡(R)≈[0,−0.8165,1.6330,−0.8165]\operatorname{LN}(R)\approx[0,-0.8165,1.6330,-0.8165]

这就是从注意力输出经过 Dropout、Add 和 Norm 得到隐藏状态的完整数值过程。

下面可以调整丢弃概率、重新生成随机掩码,并观察残差结果和 LayerNorm 输出。归一化使用 ϵ=10−5\epsilon=10^{-5}。

单独打开Dropout 与 Add & Norm 数值计算

4.5 Post-LN 与 Pre-LN

原始 Transformer 使用 Post-LN:

y=LN⁡(x+F(x))y=\operatorname{LN}(x+F(x))

很多后续模型采用 Pre-LN(归一化前置):

y=x+F(LN⁡(x))y=x+F(\operatorname{LN}(x))

两者的归一化位置不同,完整梯度传播路径也不同。Pre-LN 常用于改善较深 Transformer 的训练稳定性。阅读具体模型时,需要依据模型结构判断采用哪种顺序。[7]

5. Decoder 的三个子模块

一个原始 Decoder Layer 有三个子模块:Masked Self-Attention(带掩码的自注意力)、Cross-Attention(交叉注意力)和 FFN。三个模块都使用 Add & Norm。

5.1 Masked Self-Attention

对于自回归生成,当前位置只能使用当前以及之前的目标 Token。可以在注意力分数中加入因果掩码 CC:[1]

A=softmax⁡(QK⊤dk+C)A=\operatorname{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}+C\right)

对于长度为 4 的目标序列:

C=[0−∞−∞−∞00−∞−∞000−∞0000]C=\begin{bmatrix}0&-\infty&-\infty&-\infty\\0&0&-\infty&-\infty\\0&0&0&-\infty\\0&0&0&0\end{bmatrix}

被掩盖位置的 Softmax 权重为 0。填充位置还可以通过 Padding Mask 单独处理。

5.2 第一段隐藏状态 H1H_1

用 DD 表示 Decoder Layer 的输入。完成 Masked Self-Attention 及 Add & Norm 后:

H1=LN⁡(D+Dropout⁡(MaskedMHA⁡(D,D,D)))\boxed{H_1=\operatorname{LN}\left(D+\operatorname{Dropout}(\operatorname{MaskedMHA}(D,D,D))\right)}

H1H_1 已经整合目标端允许访问的位置的信息。若批次大小为 BB、目标长度为 LtL_t,则:

H1∈RB×Lt×dmodelH_1\in\mathbb R^{B\times L_t\times d_{\mathrm{model}}}

5.3 第二段隐藏状态 H2H_2 是什么

接下来的 Cross-Attention 让解码器访问编码器输出的 MM。

Q=H1WQ,K=MWK,V=MWVQ=H_1W_Q,\qquad K=MW_K,\qquad V=MW_V

于是:

H2=LN⁡(H1+Dropout⁡(MHA⁡(H1,M,M)))\boxed{H_2=\operatorname{LN}\left(H_1+\operatorname{Dropout}(\operatorname{MHA}(H_1,M,M))\right)}

H2H_2 就是第二个子模块的隐藏状态。它包含目标端上下文与源语言信息。

这里的 MHA⁡(H1,M,M)\operatorname{MHA}(H_1,M,M) 分别说明 Q、K、V 的来源。H1H_1 负责查询,MM 为查询提供 Key 和 Value。

若英文输入长度为 5,目标端长度为 4,Batch Size 为 2,模型维度为 512:

张量 形状
H1H_1 2×4×5122\times4\times512
MM 2×5×5122\times5\times512
单头 Cross-Attention 权重 2×4×52\times4\times5
Cross-Attention 完整输出 2×4×5122\times4\times512
H2H_2 2×4×5122\times4\times512

因此,H2H_2 的位置数量与 H1H_1 相同,内部的信息已经通过 Cross-Attention 得到更新。

5.4 第三个子模块与最终输出

Decoder Layer 再执行前馈计算:

Y=LN⁡(H2+Dropout⁡(FFN⁡(H2)))Y=\operatorname{LN}\left(H_2+\operatorname{Dropout}(\operatorname{FFN}(H_2))\right)

原始 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θ(yt∣y<t,x)P_\theta(y_t\mid y_{<t},x),其中 xx 是源语言输入。常见训练损失为:

L(θ)=−∑t=1Tlog⁡Pθ(yt∣y<t,x)\boxed{\mathcal L(\theta)=-\sum_{t=1}^{T}\log P_\theta(y_t\mid y_{<t},x)}

训练程序可以对有效位置取平均,并忽略 Padding Token。

损失通过反向传播更新 Embedding、WQ,WK,WVW_Q,W_K,W_V、FFN 和输出层等参数。优化器使用梯度调整模型,使正确 Token 的预测概率逐渐提高。

6.3 生成为什么逐步进行

推理时,模型只有已经生成的 Token。它从 BOS 开始,预测下一个 Token,将该 Token 加入上下文,再继续计算:

P(y∣x)=∏t=1TP(yt∣y<t,x)P(y\mid x)=\prod_{t=1}^{T}P(y_t\mid 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 math

import torch
import torch.nn.functional as F

# 使用三词语、两个特征的输入
x = 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,3)(1,3,3),输出形状为 (1,3,2)(1,3,2)。与前面的手动推导一致,第三个 Token 的输出约为 [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 math

import torch
from torch import nn

torch.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)

# True 表示不允许关注的位置
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 分别表示批次大小、目标长度和词表大小。

8. 不同 Transformer 架构

架构 典型模型 主要特点
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 注意力的计算成本

对于长度为 LL 的序列,完整 Self-Attention 的注意力矩阵大小为 L×LL\times L。主要注意力计算量通常为:

O(L2d)O(L^2d)

其中 dd 表示相关向量维度的量级。若直接保存完整注意力矩阵,每个头需要 O(L2)O(L^2) 级别的空间。

例如长度由 512 增加到 1024,注意力分数数量从 262,144 增加到 1,048,576。FlashAttention 可以通过更高效的数据读取和分块计算改善运行效率,并在标准注意力目标下减少中间存储开销。[15]

9.2 推荐系统的目标注意力

DIN(Deep Interest Network)会根据当前候选商品,判断用户历史行为与候选商品的关联程度。

设用户历史行为向量为 viv_i,候选商品向量为 qq:

u(q)=∑i=1nai(q)viu(q)=\sum_{i=1}^{n}a_i(q)v_i

这里的 ai(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 查看或参与讨论。