### Transformer架构中的自注意力机制位置及实现 #### 自注意力机制的位置 在Transformer架构中，自注意力机制（Self-Attention Mechanism）是编码器（Encoder）和解码器（Decoder）的核心组件之一。具体而言，自注意力机制位于编码器的多头自注意力层（Multi-Head Self-Attention Layer）以及解码器的第一层多头自注意力层[^1]。此外，在解码器中还存在交叉注意力（Cross-Attention），但此处主要讨论自注意力机制。 #### 自注意力机制的工作原理 自注意力机制通过计算输入序列中每个位置与其他位置之间的相关性，生成加权表示。以下是其具体工作原理： 1. **输入表示** 输入序列被表示为一个矩阵 \( X \in \mathbb{R}^{n \times d_{model}} \)，其中 \( n \) 是序列长度，\( d_{model} \) 是模型的维度。 2. **线性变换** 通过三个可学习的权重矩阵 \( W^Q \)，\( W^K \)，\( W^V \)，分别对输入序列进行线性变换以生成查询（Query）、键（Key）和值（Value）： ```python Q = X @ W^Q K = X @ W^K V = X @ W^V ``` 其中，\( @ \) 表示矩阵乘法[^1]。 3. **计算注意力分数** 使用点积方法计算查询与键之间的相似度，并通过缩放因子 \( \sqrt{d_k} \) 进行归一化，然后应用Softmax函数得到注意力权重： \[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \] 其中，\( d_k \) 是键向量的维度。 4. **输出生成** 将注意力权重与值向量相乘，得到最终的输出表示。 #### 多头自注意力机制 为了捕获不同子空间中的信息，Transformer引入了多头自注意力机制（Multi-Head Attention）。该机制通过并行执行多个自注意力计算，并将结果拼接后再次进行线性变换： ```python def multi_head_attention(Q, K, V, num_heads): # 分割成多个头 Q_split = split_heads(Q, num_heads) K_split = split_heads(K, num_heads) V_split = split_heads(V, num_heads) # 计算每个头的注意力 attention_output = [] for i in range(num_heads): attention_output.append(attention(Q_split[i], K_split[i], V_split[i])) # 拼接所有头的输出 concatenated_output = concat_heads(attention_output) # 最终线性变换 final_output = concatenated_output @ W^O return final_output ``` #### 相对位置编码的作用 虽然原始Transformer使用绝对位置编码，但后续的研究表明相对位置编码可以增强模型对序列中元素之间相对位置关系的理解能力[^2]。相对位置编码通过函数型位置编码方式，使模型能够更关注元素之间的相对距离。 --- ### 示例代码 以下是一个简化的自注意力机制实现： ```python import torch import torch.nn as nn class SelfAttention(nn.Module): def __init__(self, d_model, num_heads): super(SelfAttention, self).__init__() self.d_model = d_model self.num_heads = num_heads self.depth = d_model // num_heads self.WQ = nn.Linear(d_model, d_model) self.WK = nn.Linear(d_model, d_model) self.WV = nn.Linear(d_model, d_model) self.dense = nn.Linear(d_model, d_model) def split_heads(self, x, batch_size): x = x.view(batch_size, -1, self.num_heads, self.depth) return x.permute(0, 2, 1, 3) def forward(self, x): batch_size = x.size(0) Q = self.WQ(x) # (batch_size, seq_len, d_model) K = self.WK(x) # (batch_size, seq_len, d_model) V = self.WV(x) # (batch_size, seq_len, d_model) Q = self.split_heads(Q, batch_size) # (batch_size, num_heads, seq_len, depth) K = self.split_heads(K, batch_size) # (batch_size, num_heads, seq_len, depth) V = self.split_heads(V, batch_size) # (batch_size, num_heads, seq_len, depth) scaled_attention = self.scaled_dot_product_attention(Q, K, V) scaled_attention = scaled_attention.permute(0, 2, 1, 3).contiguous() concat_attention = scaled_attention.view(batch_size, -1, self.d_model) output = self.dense(concat_attention) return output def scaled_dot_product_attention(self, Q, K, V): matmul_qk = torch.matmul(Q, K.transpose(-2, -1)) dk = K.size(-1) scaled_attention_logits = matmul_qk / torch.sqrt(torch.tensor(dk, dtype=torch.float32)) attention_weights = torch.softmax(scaled_attention_logits, dim=-1) output = torch.matmul(attention_weights, V) return output ``` ---