Transformer 架构图（下）

1 课程概览

本课讲解 Transformer 架构图下半部分——解码器和输出部分。解码器包含 Output Embedding、Positional Encoding、Masked Multi-Head Attention、Multi-Head Attention（关联编码器）、Feed Forward。重点讲解掩码多头注意力（防止偷看未来词）和多头注意力（让解码器关注编码器输出）。

2 核心概念与定义

Output Embedding：目标文本嵌入层，将目标文本转为词向量。
Masked Multi-Head Attention：掩码多头注意力，防止偷看未来词。
Multi-Head Attention：多头注意力，让解码器关注编码器输出。
Linear：线性层。
Softmax：输出概率分布。

3 模型与算法详解

解码器部分

第一层：Output Embedding（目标文本嵌入层）

作用：将输出的目标（法语）转成词向量
白话：英译法案例中，将法语单词转成词向量
注意：法语单词是已知的

第二层：Positional Encoding（位置编码）

作用：给输出词向量加位置信息
白话：让模型懂得输出的顺序

解码器层结构（3 个子层）

子层1：Masked Multi-Head Attention → Add & Norm
子层2：Multi-Head Attention → Add & Norm
子层3：Feed Forward → Add & Norm

子层1：Masked Multi-Head Attention（掩码多头注意力）

作用：防止偷看未来的词
白话：解码器一步步生成输出，只能用已生成的词，不能用未生成的词
示例：
- 预测第 3 个法语单词时，只能看第 1、2 个
- 不能看第 4 个及以后的（防止偷看正确答案）

子层2：Multi-Head Attention（多头注意力）

作用：让解码器关注编码器输出的内容
说明：接收编码器的输出（中间语义张量 C）
白话：翻译时，解码器生成法语词时关注编码器的英语内容

子层3：Feed Forward（前馈全连接层）

与编码器相同

输出部分

Linear（线性层）

将解码器输出映射到词汇表大小

Softmax

输出概率分布
选择概率最高的词

完整架构图

输入文字 → Input Embedding → Positional Encoding
                                    ↓
    ┌─────────────────────────────────┐
    │  编码器 × 6                      │
    │  Multi-Head Attention + Add&Norm │
    │  Feed Forward + Add&Norm          │
    └─────────────────────────────────┘
              ↓                    ↓
    ┌─────────────────────────────────┐
    │  解码器 × 6                      │
    │  Masked Multi-Head + Add&Norm    │
    │  Multi-Head Attention + Add&Norm │ ← 编码器输出
    │  Feed Forward + Add&Norm          │
    └─────────────────────────────────┘
              ↓
    Linear → Softmax → 输出概率选词

4 数学原理与推导

掩码多头注意力

$$\text{MaskedAttention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} + M\right)V$$

其中 $M$ 是掩码矩阵，未来位置为 $-\infty$。

多头注意力（关联编码器）

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

Q 来自解码器
K, V 来自编码器

输出

$$\text{output} = \text{softmax}(\text{Linear}(x))$$

5 代码示例

import torch
import torch.nn as nn


class DecoderLayer(nn.Module):
    """解码器层：3 个子层"""
    def __init__(self, d_model, n_heads):
        super().__init__()
        # 子层1：Masked Multi-Head Attention
        self.masked_attention = MultiHeadAttention(d_model, n_heads)
        self.norm1 = nn.LayerNorm(d_model)
        
        # 子层2：Multi-Head Attention（关联编码器）
        self.attention = MultiHeadAttention(d_model, n_heads)
        self.norm2 = nn.LayerNorm(d_model)
        
        # 子层3：Feed Forward
        self.ffn = FeedForward(d_model)
        self.norm3 = nn.LayerNorm(d_model)
    
    def forward(self, x, encoder_output, mask=None):
        # 子层1：Masked Multi-Head Attention + Add & Norm
        attn_output = self.masked_attention(x, x, x, mask)
        x = self.norm1(x + attn_output)
        
        # 子层2：Multi-Head Attention + Add & Norm
        # Q 来自解码器，K, V 来自编码器
        attn_output = self.attention(x, encoder_output, encoder_output)
        x = self.norm2(x + attn_output)
        
        # 子层3：Feed Forward + Add & Norm
        ffn_output = self.ffn(x)
        x = self.norm3(x + ffn_output)
        
        return x


class Transformer(nn.Module):
    """完整 Transformer 架构"""
    def __init__(self, input_size, output_size, d_model, n_heads, n_layers):
        super().__init__()
        # 输入部分
        self.input_embedding = nn.Embedding(input_size, d_model)
        self.positional_encoding = PositionalEncoding(d_model)
        
        # 编码器
        self.encoder_layers = nn.ModuleList([
            EncoderLayer(d_model, n_heads) for _ in range(n_layers)
        ])
        
        # 解码器
        self.output_embedding = nn.Embedding(output_size, d_model)
        self.decoder_layers = nn.ModuleList([
            DecoderLayer(d_model, n_heads) for _ in range(n_layers)
        ])
        
        # 输出部分
        self.linear = nn.Linear(d_model, output_size)
        self.softmax = nn.LogSoftmax(dim=-1)
    
    def forward(self, src, trg):
        # 输入部分
        src_embedded = self.input_embedding(src)
        src_embedded = self.positional_encoding(src_embedded)
        
        # 编码器
        encoder_output = src_embedded
        for layer in self.encoder_layers:
            encoder_output = layer(encoder_output)
        
        # 解码器
        trg_embedded = self.output_embedding(trg)
        trg_embedded = self.positional_encoding(trg_embedded)
        
        decoder_output = trg_embedded
        for layer in self.decoder_layers:
            decoder_output = layer(decoder_output, encoder_output)
        
        # 输出部分
        output = self.softmax(self.linear(decoder_output))
        
        return output