很抱歉，我无法直接为您绘制 Transformer 结构的图画。但我可以为您提供一个非常详尽的、基于字符的图示，并结合详细的文字描述来解释其整体架构和核心组件。您可以根据这些描述，轻松地使用任何绘图工具（如 draw.io、Visio 或手绘）来创建清晰的 Transformer 结构图。 ### Transformer 整体架构图（字符示意图） 以下是一个简化的字符示意图，展示了 Transformer 模型的核心数据流。实际的 Transformer 包含 N 个这样的编码器和解码器层堆叠而成。 ``` 输入序列: [我, 爱, 机, 器, 学, 习] 输出序列: [I, love, machine, learning] ┌─────────────────────────────────────────────────┐ │ Transformer │ │ │ 输入序列 ──────> │ ┌─────────────┐ ┌─────────────┐ │ ──────> 输出序列 │ │ 编码器 │ │ 解码器 │ │ │ │ (N×) │ │ (N×) │ │ │ └─────────────┘ └─────────────┘ │ │ ↑ ↑ │ │ │ │ │ │ └──────────────────────┘ │ │ 注意力机制连接 │ └─────────────────────────────────────────────────┘ ``` ### Transformer 核心组件分解 #### 1. 编码器 (Encoder) 结构 每个编码器层由两个核心子层构成，其内部结构如下： ``` ┌─────────────────────────────────────────────────────────┐ │ 编码器层 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 子层 1: 多头自注意力 │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ │ │ 注意力头1 │ │ 注意力头2 │ │ 注意力头h │ ... │ │ │ │ └──────────┘ └──────────┘ └──────────┘ │ │ │ │ ↘ ↓ ↙ │ │ │ │ └───────────────────────┘ │ │ │ │ ↓ │ │ │ │ 拼接 & 线性变换 │ │ │ └─────────────────────────────────────────────────────┘ │ │ ↓ (残差连接 & 层归一化) │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 子层 2: 前馈神经网络 │ │ │ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │ │ │ 线性层 │ -> │ ReLU │ -> │ 线性层 │ │ │ │ │ └────────┘ └────────┘ └────────┘ │ │ │ └─────────────────────────────────────────────────────┘ │ │ ↓ (残差连接 & 层归一化) │ │ │ └─────────────────────────────────────────────────────────┘ ``` #### 2. 解码器 (Decoder) 结构 解码器比编码器多一个子层，用于处理编码器-解码器间的注意力： ``` ┌─────────────────────────────────────────────────────────┐ │ 解码器层 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 子层 1: 掩码多头自注意力 (防止看到未来信息) │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ │ │ 注意力头1 │ │ 注意力头2 │ │ 注意力头h │ ... │ │ │ │ └──────────┘ └──────────┘ └──────────┘ │ │ │ │ ↘ ↓ ↙ │ │ │ │ └───────────────────────┘ │ │ │ │ ↓ │ │ │ │ 拼接 & 线性变换 │ │ │ └─────────────────────────────────────────────────────┘ │ │ ↓ (残差连接 & 层归一化) │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 子层 2: 编码器-解码器注意力 (连接编码器输出) │ │ │ │ Query: 来自上一子层 Key/Value: 来自编码器输出 │ │ │ └─────────────────────────────────────────────────────┘ │ │ ↓ (残差连接 & 层归一化) │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 子层 3: 前馈神经网络 │ │ │ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │ │ │ 线性层 │ -> │ ReLU │ -> │ 线性层 │ │ │ │ │ └────────┘ └────────┘ └────────┘ │ │ │ └─────────────────────────────────────────────────────┘ │ │ ↓ (残差连接 & 层归一化) │ │ │ └─────────────────────────────────────────────────────────┘ ``` #### 3. 输入输出处理流程 **输入嵌入与位置编码流程：** ``` 原始输入: ["我", "爱", "机", "器", "学", "习"] ↓ (词嵌入查找) 词向量: [512维向量] [512维向量] [512维向量] ... [512维向量] ↓ (加上位置编码) 最终输入: 词向量 + 位置编码向量 ↓ 编码器输入 ``` ### 核心机制详解 #### 1. 自注意力机制 (Self-Attention) 自注意力机制允许序列中的每个位置关注序列中的所有位置，其计算过程如下： ```python import torch import torch.nn as nn import math def self_attention(query, key, value, mask=None): """ 自注意力机制计算过程 query, key, value: [batch_size, seq_len, d_model] """ d_k = query.size(-1) # 计算注意力分数 [ref_1] scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) # Softmax 得到注意力权重 [ref_2] attention_weights = torch.softmax(scores, dim=-1) # 加权求和得到输出 [ref_4] output = torch.matmul(attention_weights, value) return output, attention_weights # 示例：计算一个简单的自注意力 d_model = 512 seq_len = 6 batch_size = 1 query = torch.randn(batch_size, seq_len, d_model) key = torch.randn(batch_size, seq_len, d_model) value = torch.randn(batch_size, seq_len, d_model) output, weights = self_attention(query, key, value) print(f"输入形状: {query.shape}") print(f"输出形状: {output.shape}") print(f"注意力权重形状: {weights.shape}") ``` #### 2. 多头注意力机制 (Multi-Head Attention) 多头注意力将模型分为多个"头"，每个头学习不同的注意力模式： ``` ┌─────────────────────────────────────────────────────────┐ │ 多头注意力机制 │ │ │ │ 输入: [batch_size, seq_len, d_model] │ │ ↓ (线性变换到h个头) │ │ Head1: [batch_size, seq_len, d_k] │ │ Head2: [batch_size, seq_len, d_k] │ │ ... │ │ Headh: [batch_size, seq_len, d_k] │ │ ↓ (分别计算自注意力) │ │ 输出1, 输出2, ..., 输出h │ │ ↓ (拼接) │ │ 拼接结果: [batch_size, seq_len, h * d_k] │ │ ↓ (最终线性变换) │ │ 最终输出: [batch_size, seq_len, d_model] │ └─────────────────────────────────────────────────────────┘ ``` #### 3. 位置编码 (Positional Encoding) 由于 Transformer 没有递归结构，需要位置编码来注入序列的顺序信息： ```python class PositionalEncoding(nn.Module): def __init__(self, d_model, max_seq_len=5000): super(PositionalEncoding, self).__init__() # 创建位置编码矩阵 [ref_1] pe = torch.zeros(max_seq_len, d_model) position = torch.arange(0, max_seq_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) # 偶数位置用sin pe[:, 1::2] = torch.cos(position * div_term) # 奇数位置用cos self.register_buffer('pe', pe.unsqueeze(0)) def forward(self, x): # x: [batch_size, seq_len, d_model] return x + self.pe[:, :x.size(1)] # 使用示例 d_model = 512 seq_len = 10 batch_size = 2 pos_encoder = PositionalEncoding(d_model) input_embeddings = torch.randn(batch_size, seq_len, d_model) output_with_pos = pos_encoder(input_embeddings) print(f"加入位置编码后的形状: {output_with_pos.shape}") ``` ### 完整 Transformer 数据流总结 | 组件 | 输入形状 | 输出形状 | 主要功能 | |------|----------|----------|----------| | 词嵌入 | [batch, seq_len] | [batch, seq_len, d_model] | 将离散词汇映射为连续向量 [ref_1] | | 位置编码 | [batch, seq_len, d_model] | [batch, seq_len, d_model] | 注入序列位置信息 [ref_2] | | 编码器层 | [batch, seq_len, d_model] | [batch, seq_len, d_model] | 提取输入序列特征 [ref_4] | | 解码器层 | [batch, seq_len, d_model] | [batch, seq_len, d_model] | 生成输出序列 [ref_1] | | 输出线性层 | [batch, seq_len, d_model] | [batch, seq_len, vocab_size] | 映射到词汇表概率 [ref_5] | | Softmax | [batch, seq_len, vocab_size] | [batch, seq_len, vocab_size] | 生成最终概率分布 [ref_5] | ### 实际应用中的变体 现代 Transformer 架构有多种变体，特别是在大语言模型中： 1. **仅编码器架构** (Encoder-only): 如 BERT，适用于理解任务 [ref_4] 2. **仅解码器架构** (Decoder-only): 如 GPT 系列、Qwen3-32B，适用于生成任务 [ref_6] 3. **编码器-解码器架构**: 原始 Transformer，适用于机器翻译等序列到序列任务 [ref_1] ### 绘制建议 基于以上详细描述，您可以按以下步骤绘制清晰的 Transformer 结构图： 1. **从整体框架开始**: 先画出编码器堆叠和解码器堆叠的宏观结构 2. **细化单层结构**: 详细绘制单个编码器层和解码器层的内部组件 3. **标注数据流**: 用箭头明确标注信息的流动方向 4. **添加关键参数**: 标注主要的维度信息（如 d_model, h头数等） 5. **突出核心机制**: 特别标注自注意力、位置编码等关键组件 这种模块化的绘图方法既能体现 Transformer 的整体架构，又能展示其核心工作机制的细节。