Transformer 编码器深度解读 + 代码实战
1. 编码器核心作用
Transformer 编码器的核心任务是将输入序列（如文本、语音）转换为富含上下文语义的高维特征表示。它通过多层自注意力（Self-Attention）和前馈网络（FFN），逐步建模全局依赖关系，解决传统RNN/CNN的长距离依赖缺陷。
2. 编码器单层结构详解
每层编码器包含以下模块（附 PyTorch 代码）：
2.1 多头自注意力（Multi-Head Self-Attention）
class MultiHeadAttention(nn.Module):def __init__(self, embed_size, heads):super().__init__()self.embed_size = embed_sizeself.heads = headsself.head_dim = embed_size // heads# 线性变换层生成 Q, K, Vself.to_qkv = nn.Linear(embed_size, embed_size * 3) # 同时生成 Q/K/Vself.scale = self.head_dim ** -0.5 # 缩放因子# 输出线性层self.to_out = nn.Linear(embed_size, embed_size)def forward(self, x, mask=None):batch_size, seq_len, _ = x.shape# 生成 Q, K, V 并分割多头qkv = self.to_qkv(x).chunk(3, dim=-1) # 拆分为 [Q, K, V]q, k, v = map(lambda t: t.view(batch_size, seq_len, self.heads, self.head_dim), qkv)# 计算注意力分数 (QK^T / sqrt(d_k))attn = torch.einsum('bhid,bhjd->bhij', q, k) * self.scale# 掩码（编码器通常不需要，但保留接口）if mask is not None:attn = attn.masked_fill(mask == 0, -1e10)# Softmax 归一化attn = torch.softmax(attn, dim=-1)# 加权求和out = torch.einsum('bhij,bhjd->bhid', attn, v)out = out.reshape(batch_size, seq_len, self.embed_size)# 输出线性变换return self.to_out(out)
代码解析：
nn.Linear生成 Q/K/V 矩阵，通过chunk分割。einsum实现高效矩阵运算，计算注意力分数。- 支持掩码（虽编码器通常不用，但为兼容性保留）。
2.2 前馈网络（Feed-Forward Network）
class FeedForward(nn.Module):def __init__(self, embed_size, expansion=4):super().__init__()self.net = nn.Sequential(nn.Linear(embed_size, embed_size * expansion), # 扩展维度nn.GELU(), # 更平滑的激活函数（比ReLU效果更好）nn.Linear(embed_size * expansion, embed_size) # 压缩回原维度)def forward(self, x):return self.net(x)
代码解析：
- 典型结构：扩展维度（如512→2048）→激活→压缩回原维度。
- 使用
GELU替代ReLU（现代Transformer的常见选择）。
2.3 残差连接 + 层归一化（Add & Norm）
class TransformerEncoderLayer(nn.Module):def __init__(self, embed_size, heads, dropout=0.1):super().__init__()self.attn = MultiHeadAttention(embed_size, heads)self.ffn = FeedForward(embed_size)self.norm1 = nn.LayerNorm(embed_size)self.norm2 = nn.LayerNorm(embed_size)self.dropout = nn.Dropout(dropout)def forward(self, x):# 自注意力子层attn_out = self.attn(x)x = x + self.dropout(attn_out) # 残差连接x = self.norm1(x)# 前馈子层ffn_out = self.ffn(x)x = x + self.dropout(ffn_out) # 残差连接x = self.norm2(x)return x
代码解析：
- 每个子层后执行
x = x + dropout(sublayer(x))，再层归一化。 - 残差连接确保梯度稳定，层归一化加速收敛。
3. 位置编码（Positional Encoding）
class PositionalEncoding(nn.Module):def __init__(self, embed_size, max_len=5000):super().__init__()pe = torch.zeros(max_len, embed_size)position = torch.arange(0, max_len).unsqueeze(1)div_term = torch.exp(torch.arange(0, embed_size, 2) * (-math.log(10000.0)/embed_size)pe[:, 0::2] = torch.sin(position * div_term) # 偶数位置pe[:, 1::2] = torch.cos(position * div_term) # 奇数位置self.register_buffer('pe', pe.unsqueeze(0)) # (1, max_len, embed_size)def forward(self, x):return x + self.pe[:, :x.size(1)] # 自动广播到 (batch_size, seq_len, embed_size)
代码解析：
- 通过正弦/余弦函数编码绝对位置。
register_buffer将位置编码注册为模型常量（不参与训练）。
4. 完整编码器实现
class TransformerEncoder(nn.Module):def __init__(self, vocab_size, embed_size, layers, heads, dropout=0.1):super().__init__()self.embedding = nn.Embedding(vocab_size, embed_size)self.pos_encoding = PositionalEncoding(embed_size)self.layers = nn.ModuleList([TransformerEncoderLayer(embed_size, heads, dropout)for _ in range(layers)])def forward(self, x):# 输入x形状: (batch_size, seq_len)x = self.embedding(x) # (batch_size, seq_len, embed_size)x = self.pos_encoding(x)for layer in self.layers:x = layer(x)return x # (batch_size, seq_len, embed_size)
5. 实战测试
# 参数设置
vocab_size = 10000 # 假设词表大小
embed_size = 512 # 嵌入维度
layers = 6 # 编码器层数
heads = 8 # 注意力头数# 初始化模型
encoder = TransformerEncoder(vocab_size, embed_size, layers, heads)# 模拟输入（batch_size=32, seq_len=50）
x = torch.randint(0, vocab_size, (32, 50)) # 随机生成句子# 前向传播
output = encoder(x)
print(output.shape) # 预期输出: torch.Size([32, 50, 512])
