### 多层Transformer架构与实现 多层Transformer架构是一种基于注意力机制的深度学习模型，通常用于自然语言处理任务。其核心思想是通过堆叠多个Transformer层来捕获输入序列中的复杂关系[^1]。以下是对多层Transformer架构及其实现的详细说明： #### 1. Transformer的基本结构 每个Transformer层由两个主要子层组成：自注意力机制（Self-Attention）和前馈神经网络（Feed-Forward Neural Network）。这些子层之间通常包含残差连接（Residual Connection）和层归一化（Layer Normalization），以提高模型的稳定性和表达能力[^3]。 - **自注意力机制**：自注意力机制允许模型在不同位置关注输入序列的不同部分。它通过计算查询（Query）、键（Key）和值（Value）之间的点积注意力得分来实现[^1]。 - **前馈神经网络**：这是一个简单的全连接层，通常包含两个线性变换和一个ReLU激活函数[^2]。 #### 2. 多层Transformer的架构 多层Transformer通过堆叠多个Transformer层来构建更深层次的模型。每层的输出作为下一层的输入，从而逐步提取更高层次的特征[^2]。以下是多层Transformer的主要组成部分： - **嵌入层（Embedding Layer）**：将输入序列转换为固定维度的向量表示。此外，为了捕捉序列的位置信息，通常会添加位置编码（Positional Encoding）[^3]。 - **编码器（Encoder）**：由多个Transformer层堆叠而成，负责提取输入序列的特征。 - **解码器（Decoder）**：同样由多个Transformer层组成，但还包括一个额外的注意力子层，用于关注编码器的输出。 - **输出层（Output Layer）**：将解码器的输出映射到目标词汇表，通常使用softmax函数进行概率分布预测[^4]。 #### 3. 实现细节 以下是多层Transformer的一个简化实现示例： ```python import torch import torch.nn as nn class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super(MultiHeadAttention, self).__init__() self.d_model = d_model self.num_heads = num_heads assert d_model % num_heads == 0 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, q, k, v, mask=None): batch_size = q.size(0) q = self.split_heads(self.wq(q), batch_size) # (batch_size, num_heads, seq_len_q, depth) k = self.split_heads(self.wk(k), batch_size) # (batch_size, num_heads, seq_len_k, depth) v = self.split_heads(self.wv(v), batch_size) # (batch_size, num_heads, seq_len_v, depth) scaled_attention = self.scaled_dot_product_attention(q, k, v, mask) concat_attention = scaled_attention.permute(0, 2, 1, 3).contiguous().view(batch_size, -1, self.d_model) output = self.dense(concat_attention) return output class TransformerLayer(nn.Module): def __init__(self, d_model, num_heads, dff, rate=0.1): super(TransformerLayer, self).__init__() self.mha = MultiHeadAttention(d_model, num_heads) self.ffn = nn.Sequential( nn.Linear(d_model, dff), nn.ReLU(), nn.Linear(dff, d_model) ) self.layernorm1 = nn.LayerNorm(d_model, eps=1e-6) self.layernorm2 = nn.LayerNorm(d_model, eps=1e-6) self.dropout1 = nn.Dropout(rate) self.dropout2 = nn.Dropout(rate) def forward(self, x, mask=None): attn_output = self.mha(x, x, x, mask) attn_output = self.dropout1(attn_output) out1 = self.layernorm1(x + attn_output) ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output) out2 = self.layernorm2(out1 + ffn_output) return out2 class MultiLayerTransformer(nn.Module): def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, target_vocab_size, max_seq_length, rate=0.1): super(MultiLayerTransformer, self).__init__() self.d_model = d_model self.embedding = nn.Embedding(input_vocab_size, d_model) self.pos_encoding = self.positional_encoding(max_seq_length, d_model) self.transformer_layers = nn.ModuleList([TransformerLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]) self.final_layer = nn.Linear(d_model, target_vocab_size) def positional_encoding(self, max_seq_length, d_model): angle_rads = self.get_angles(torch.arange(max_seq_length).unsqueeze(1), torch.arange(d_model).unsqueeze(0), d_model) angle_rads[:, 0::2] = torch.sin(angle_rads[:, 0::2]) angle_rads[:, 1::2] = torch.cos(angle_rads[:, 1::2]) pos_encoding = angle_rads.unsqueeze(0) return pos_encoding def get_angles(self, pos, i, d_model): angle_rates = 1 / torch.pow(10000, (2 * (i // 2)) / torch.tensor(d_model, dtype=torch.float32)) return pos * angle_rates def forward(self, inp, mask=None): seq_len = inp.size(1) inp = self.embedding(inp) * torch.sqrt(torch.tensor(self.d_model, dtype=torch.float32)) inp += self.pos_encoding[:, :seq_len, :] for layer in self.transformer_layers: inp = layer(inp, mask) output = self.final_layer(inp) return output ``` #### 4. 关键技术点 - **位置编码**：由于Transformer不包含递归或卷积操作，因此需要显式地引入位置编码来保留序列顺序信息[^3]。 - **梯度优化**：在训练过程中，可以通过调整前向和后向操作的顺序来降低GPU内存利用率，从而支持更大的批处理尺寸[^5]。