Transformer模型的核心结构是基于Encoder-Decoder的堆叠架构。其中，`Nx=6` 特指模型由6个完全相同的编码器（Encoder）层堆叠而成，每个编码器层内部又由两个核心子层构成：多头自注意力机制（Multi-Head Attention）和前馈神经网络（Feed Forward Network）[ref_1][ref_4][ref_5]。 ### **Encoder Block 的详细结构** 一个完整的Encoder Block（即一个编码器层）的输入与输出流程可以概括如下表所示： | 处理步骤 | 核心组件/操作 | 主要功能与作用 | | :--- | :--- | :--- | | **输入** | 词嵌入向量 + 位置编码 | 将输入序列的每个词转换为向量，并注入位置信息 [ref_1][ref_3][ref_4]。 | | **子层1** | Multi-Head Attention | 计算序列中每个词与其他所有词之间的相关性权重，捕获上下文信息 [ref_1][ref_2][ref_6]。 | | **操作1** | 残差连接 & Layer Normalization | 将多头注意力层的输出与原始输入相加，并进行层归一化，缓解梯度消失问题 [ref_5][ref_6]。 | | **子层2** | Feed Forward Network | 对每个位置的向量进行独立、相同的非线性变换，增强模型表达能力 [ref_2][ref_3][ref_4]。 | | **操作2** | 残差连接 & Layer Normalization | 将前馈网络的输出与子层1的归一化结果相加，再次进行层归一化 [ref_5][ref_6]。 | | **输出** | 编码后的向量序列 | 作为下一个Encoder Block的输入，或最终传递给解码器。 | ### **核心组件详解与代码示例** #### **1. 多头自注意力机制 (Multi-Head Attention)** 这是Transformer的核心创新。它将输入向量通过线性变换分别映射为查询（Q）、键（K）、值（V）三组向量，然后并行地进行多次（例如8次）“头”的注意力计算，最后将结果拼接并线性变换回原维度 [ref_1][ref_4][ref_6]。 ```python import torch import torch.nn as nn import torch.nn.functional as F class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() assert d_model % num_heads == 0 self.d_model = d_model # 模型维度，例如512 self.num_heads = num_heads # 注意力头数，例如8 self.d_k = d_model // num_heads # 每个头的维度，例如64 # 定义用于生成Q, K, V的线性变换层 self.W_q = nn.Linear(d_model, d_model) self.W_k = nn.Linear(d_model, d_model) self.W_v = nn.Linear(d_model, d_model) self.W_o = nn.Linear(d_model, d_model) # 输出变换层 def scaled_dot_product_attention(self, Q, K, V, mask=None): # Q, K, V: [batch_size, num_heads, seq_len, d_k] attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5) if mask is not None: attn_scores = attn_scores.masked_fill(mask == 0, -1e9) attn_probs = F.softmax(attn_scores, dim=-1) # 计算注意力权重 output = torch.matmul(attn_probs, V) # 加权求和 return output def forward(self, x, mask=None): batch_size, seq_len, _ = x.size() # 线性投影得到Q, K, V Q = self.W_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) K = self.W_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) V = self.W_v(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) # 计算缩放点积注意力 attn_output = self.scaled_dot_product_attention(Q, K, V, mask) # 拼接多头输出并线性变换 attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model) output = self.W_o(attn_output) return output ``` #### **2. 前馈神经网络 (Feed Forward Network)** 这是一个简单的两层全连接网络，通常在第一层使用ReLU激活函数，第二层不使用激活函数。它对序列中**每个位置的向量独立且相同地**进行处理 [ref_2][ref_3]。 ```python class FeedForwardNetwork(nn.Module): def __init__(self, d_model, d_ff): super().__init__() # 通常 d_ff = 4 * d_model，例如2048 self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) self.relu = nn.ReLU() def forward(self, x): # x: [batch_size, seq_len, d_model] return self.linear2(self.relu(self.linear1(x))) ``` #### **3. 残差连接与层归一化 (Add & Norm)** 在每个子层（多头注意力和前馈网络）之后，都会执行“Add & Norm”操作。残差连接有助于缓解深层网络中的梯度消失问题，层归一化则稳定了训练过程 [ref_5][ref_6]。 ```python class EncoderLayer(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads) self.ffn = FeedForwardNetwork(d_model, d_ff) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): # 子层1: Multi-Head Attention + Add & Norm attn_output = self.self_attn(x, mask) x = self.norm1(x + self.dropout(attn_output)) # 残差连接后归一化 # 子层2: Feed Forward Network + Add & Norm ffn_output = self.ffn(x) x = self.norm2(x + self.dropout(ffn_output)) # 残差连接后归一化 return x ``` ### **堆叠与整体流程** 最终的Transformer编码器（`Nx=6`）就是将这6个`EncoderLayer`堆叠起来。每个编码器层的输出作为下一层的输入，经过层层抽象，最终得到富含全局上下文信息的序列表示 [ref_1][ref_4]。 ```python class TransformerEncoder(nn.Module): def __init__(self, num_layers, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.layers = nn.ModuleList([ EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers) # num_layers = Nx = 6 ]) def forward(self, x, mask=None): for layer in self.layers: x = layer(x, mask) return x ``` 这种由多头注意力捕获依赖关系、前馈网络进行非线性变换、残差和归一化保障训练稳定的模块化设计，是Transformer能够并行高效处理长序列并取得卓越性能的关键 [ref_2][ref_3][ref_5]。