Transformer 面试题及答案详解
二、训练与优化
1. Transformer中的可训练Queries、Keys和Values矩阵从哪儿来?
答案:
Q、K、V矩阵是通过可学习的线性投影矩阵对输入序列进行线性变换得到的。这些投影矩阵(W_Q、W_K、W_V)是模型的核心可训练参数,在训练过程中通过反向传播学习优化。
1.1 输入来源与基本变换
输入序列经过词嵌入(Embedding)和位置编码(Positional Encoding)后得到矩阵 X,其形状为 (batch_size, seq_len, d_model)。Q、K、V 由 X 分别与三个独立的线性层(全连接层)相乘得到:
# 输入 X: (batch_size, seq_len, d_model)
Q = X @ W_Q + b_Q # W_Q: (d_model, d_k)
K = X @ W_K + b_K # W_K: (d_model, d_k)
V = X @ W_V + b_V # W_V: (d_model, d_v)其中 d_k 和 d_v 通常等于 d_model(在多头上会分割)。这些线性层的权重矩阵 W_Q、W_K、W_V 以及偏置 b_Q、b_K、b_V 就是可训练参数。
1.2 Q、K、V的语义含义
| 矩阵 | 来源 | 形象比喻 | 作用 |
|---|---|---|---|
| Q (Query) | X @ W_Q | “我想找什么?” | 当前位置发出的查询,去匹配其他位置的Key |
| K (Key) | X @ W_K | “我能提供什么?” | 各位置的索引标签,与Query计算相似度 |
| V (Value) | X @ W_V | “我有什么信息?” | 各位置的实际内容,按注意力权重聚合 |
1.3 参数从何而来?—— 初始化与存储
- 初始化:模型构建时,这些矩阵被随机初始化,常用方法包括 Xavier/Glorot 初始化或 Kaiming 初始化。
# Xavier 均匀初始化
nn.init.xavier_uniform_(W_Q.weight)
nn.init.zeros_(W_Q.bias) # 偏置通常初始为0-
存储位置:参数存储在
nn.Linear层的.weight和.bias属性中,并随训练更新。 -
参数量:每个投影矩阵有
d_model × d_model个参数(若d_k = d_model)。以d_model=512为例:W_Q:512×512 = 262,144 参数W_K:512×512 = 262,144 参数W_V:512×512 = 262,144 参数- 加上输出投影
W_O,单层注意力约 1M 参数。
1.4 训练过程中的参数更新
# 前向传播
Q = W_Q(x)
K = W_K(x)
V = W_V(x)
output = attention(Q, K, V)
loss = criterion(output, target)
# 反向传播计算梯度 ∂loss/∂W_Q, ∂loss/∂W_K, ∂loss/∂W_V
loss.backward()
# 优化器更新参数(如 Adam、SGD)
optimizer.step() # W_Q.weight -= lr * grad参数通过梯度下降不断调整,最终学习到对任务最有效的查询、键、值表示。
1.5 Encoder vs Decoder 中的来源对比
| 场景 | Q 的来源 | K 的来源 | V 的来源 |
|---|---|---|---|
| Encoder Self-Attention | 同一输入 X(源序列) | 同一输入 X | 同一输入 X |
| Decoder Masked Self-Attention | 同一输入 X(目标序列已生成部分) | 同一输入 X | 同一输入 X |
| Decoder Cross-Attention | Decoder 上一子层输出 | Encoder 最终输出(Memory) | Encoder 最终输出(Memory) |
# Encoder Self-Attention
Q = W_Q(encoder_input) # encoder_input = src_embed + pos_enc
K = W_K(encoder_input)
V = W_V(encoder_input)
# Decoder Cross-Attention
Q = W_Q(decoder_output) # 来自解码器
K = W_K(encoder_output) # 来自编码器
V = W_V(encoder_output)1.6 多头情况下的分割
多头注意力将 d_model 分割成 h 个头,每个头维度 d_k = d_model // h。投影矩阵仍为 d_model × d_model,但输出会被重塑:
# 分割
Q = W_Q(x) # (batch, seq_len, d_model)
Q = Q.view(batch, seq_len, h, d_k).transpose(1, 2) # (batch, h, seq_len, d_k)
# 每个头独立计算注意力
for i in range(h):
head_i_output = attention(Q[:,i], K[:,i], V[:,i])
# 合并
output = concat(head_outputs) # (batch, seq_len, d_model)
output = W_O(output) # 输出投影每个头可以学习不同的注意力模式(如语法关系、指代关系等)。
1.7 为什么需要这些可训练参数?
- 无投影矩阵:Q=K=V=x,则注意力矩阵对称,无法区分“查询”和“键”的角色,表达能力受限。
- 有投影矩阵:
- 将输入映射到不同的语义空间(Q空间、K空间、V空间)。
- 增强模型灵活性,允许每个头关注不同特征。
- 通过调整
d_k、d_v控制计算复杂度。
1.8 参数共享情况
Transformer 的每一层都有自己独立的投影矩阵,层与层之间不共享参数:
for layer in range(6):
W_Q_layer = nn.Linear(d_model, d_model) # 每层独立这样每层可以学习不同抽象层次的特征。
1.9 完整代码示例
import torch
import torch.nn as nn
import math
class MultiHeadAttention(nn.Module):
def __init__(self, d_model=512, num_heads=8, dropout=0.1):
super().__init__()
assert d_model % num_heads == 0
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
# 可训练投影矩阵
self.W_Q = nn.Linear(d_model, d_model, bias=False)
self.W_K = nn.Linear(d_model, d_model, bias=False)
self.W_V = nn.Linear(d_model, d_model, bias=False)
self.W_O = nn.Linear(d_model, d_model, bias=False)
self.dropout = nn.Dropout(dropout)
self._init_weights()
def _init_weights(self):
for module in [self.W_Q, self.W_K, self.W_V, self.W_O]:
nn.init.xavier_uniform_(module.weight)
def forward(self, x, mask=None):
batch_size = x.size(0)
# 线性投影
Q = self.W_Q(x) # (batch, seq_len, d_model)
K = self.W_K(x)
V = self.W_V(x)
# 分割多头
Q = Q.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
K = K.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
V = V.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
# 注意力计算
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attn = torch.softmax(scores, dim=-1)
attn = self.dropout(attn)
output = torch.matmul(attn, V)
# 合并多头
output = output.transpose(1, 2).contiguous()
output = output.view(batch_size, -1, self.d_model)
# 输出投影
output = self.W_O(output)
return output1.10 可视化总结
输入 X (batch, seq_len, d_model)
↓
┌─────────────────────────────────┐
│ 可训练投影矩阵 │
│ W_Q (d_model×d_model) │
│ W_K (d_model×d_model) │ ← 随机初始化,训练中更新
│ W_V (d_model×d_model) │
└─────────────────────────────────┘
↓ ↓ ↓
┌─────────┐┌─────────┐┌─────────┐
│Q = X·W_Q││K = X·W_K││V = X·W_V│
└─────────┘└─────────┘└─────────┘
↓ ↓ ↓
└──────┬──┴──────┬──┘
↓ ↓
┌──────────────────────┐
│ Attention计算 │
│ scores = Q·K^T / √d │
│ output = softmax(scores)·V │
└──────────────────────┘
↓
┌──────────────────────┐
│ 输出投影 W_O │ ← 另一个可训练参数
└──────────────────────┘
↓
最终输出
总结:Q、K、V矩阵的来源
| 问题 | 答案 |
|---|---|
| 参数从哪来? | 随机初始化(Xavier/Kaiming) |
| 参数存哪? | nn.Linear层的weight属性中 |
| 参数怎么学? | 反向传播 + 梯度下降 |
| 参数量? | 每层 4×d_model²(含输出投影) |
| 输入是什么? | 词嵌入 + 位置编码 |
| 为什么需要? | 将输入投影到不同语义空间,增强表达能力 |
这些可训练的投影矩阵是Transformer能够学习复杂注意力模式、适应不同任务的核心机制!
2. Transformer的Feed Forward层在训练的时候到底在训练什么?
答案:
Feed Forward Network (FFN) 在训练时学习对输入进行非线性特征变换和信息融合。
详细解析:
1. FFN的结构:
class FeedForward(nn.Module):
def __init__(self, d_model=512, d_ff=2048, dropout=0.1):
super().__init__()
self.linear1 = nn.Linear(d_model, d_ff) # 512 → 2048
self.dropout = nn.Dropout(dropout)
self.linear2 = nn.Linear(d_ff, d_model) # 2048 → 512
def forward(self, x):
# x shape: (batch, seq_len, d_model)
return self.linear2(self.dropout(F.relu(self.linear1(x))))数学表达:
FFN(x) = max(0, xW₁ + b₁)W₂ + b₂
2. FFN在训练什么?
a. 学习特征变换矩阵:
# W₁: (d_model, d_ff) = (512, 2048)
# 将512维向量映射到2048维高维空间
# W₂: (d_ff, d_model) = (2048, 512)
# 将2048维映射回512维
训练目标:学习最优的W₁和W₂b. 学习非线性特征组合:
# 第一层线性变换
z = xW₁ + b₁ # (batch, seq_len, 2048)
# ReLU激活(引入非线性)
activated = ReLU(z) # 将负值置为0
# 第二层线性变换
output = activated W₂ + b₂ # (batch, seq_len, 512)
# 整个过程:
输入512维 → 扩展到2048维(学习更丰富的特征)
→ 非线性激活
→ 压缩回512维(特征选择)3. 为什么需要FFN?
a. Attention的局限性:
# Attention只做加权求和,是线性操作
Attention(Q,K,V) = softmax(QK^T/√d_k)V
# 没有参数化的非线性变换
# FFN补充了非线性建模能力b. 增加模型容量:
# 单层Transformer参数分布:
Attention: ~1M参数(4×512²)
FFN: ~2M参数(512×2048×2)
# FFN占了约2/3的参数!
# 这些参数用于学习复杂的特征变换4. FFN具体学到了什么?
通过研究发现,FFN在学习:
a. 特征检测器(Feature Detectors):
# W₁的每一列可以看作一个特征检测器
# 2048个神经元 = 2048个特征检测器
例如:
- 某些神经元检测"是否是动词"
- 某些神经元检测"是否是名词"
- 某些神经元检测"是否是否定词"
- 某些神经元检测特定的语义模式b. 记忆和知识存储(Knowledge Storage):
# FFN层可以看作Key-Value记忆
# 研究表明FFN层存储了大量事实性知识
例如:
输入: "The capital of France is"
FFN激活特定神经元 → 输出与"Paris"相关的表示
# 不同的神经元组合表示不同的知识c. 位置特定的处理(Position-wise):
# FFN独立处理每个位置
for i in range(seq_len):
output[i] = FFN(x[i]) # 每个位置独立
# 学习:每个词在其上下文中应该如何变换5. 训练过程示例:
# 前向传播
def forward_ffn(x):
# x: (batch, seq_len, 512)
# 第一层:扩展维度
h = x @ W1 + b1 # (batch, seq_len, 2048)
h = relu(h) # 激活
# 第二层:压缩维度
output = h @ W2 + b2 # (batch, seq_len, 512)
return output
# 反向传播
def backward_ffn(grad_output):
# 计算W2, b2的梯度
grad_W2 = h.T @ grad_output
grad_b2 = sum(grad_output)
# 通过ReLU反向传播
grad_h = grad_output @ W2.T
grad_h[h <= 0] = 0 # ReLU的梯度
# 计算W1, b1的梯度
grad_W1 = x.T @ grad_h
grad_b1 = sum(grad_h)
# 更新参数
W1 -= lr * grad_W1
W2 -= lr * grad_W2
# ...6. FFN vs Attention的分工:
# Attention层:
- 建模token之间的关系
- "这个词应该关注哪些其他词"
- 聚合上下文信息
# FFN层:
- 对每个token独立进行非线性变换
- "这个词的表示应该如何调整"
- 提取和组合特征
# 两者配合:
输入 → Attention(聚合上下文)→ FFN(特征变换)→ 输出7. 不同层FFN学到的不同东西:
# 研究表明,不同层的FFN学习不同层次的特征
浅层FFN (Layer 1-2):
- 学习基础的语法特征
- 词性、基本语法结构
中层FFN (Layer 3-8):
- 学习语义关系
- 实体识别、关系抽取
深层FFN (Layer 9-12):
- 学习高层语义
- 推理、常识知识8. 可视化FFN的学习:
# 假设输入:"The cat sat on the mat"
# 观察某个FFN神经元的激活:
Neuron_42的激活值:
"The": 0.1 (低激活)
"cat": 0.8 (高激活) ← 检测到动物!
"sat": 0.2 (低激活)
"on": 0.1 (低激活)
"the": 0.1 (低激活)
"mat": 0.3 (中等激活)
# 这个神经元可能在检测"动物"这个语义特征9. FFN参数量计算:
# 以标准Transformer为例
d_model = 512
d_ff = 2048
num_layers = 6
# 单层FFN参数:
W1: 512 × 2048 = 1,048,576
b1: 2048
W2: 2048 × 512 = 1,048,576
b2: 512
单层总计: 2,097,152 + 2560 ≈ 2.1M
# 全模型FFN参数:
6层 × 2.1M ≈ 12.6M参数
# 占总参数比例:
FFN参数 / 总参数 ≈ 60-70%10. 为什么FFN中间维度通常是4倍d_model?
d_ff = 4 × d_model
原因:
1. 经验值:实验表明4倍效果较好
2. 平衡性能和计算:
- 太小:表达能力不足
- 太大:计算成本高,过拟合
3. 提供足够的特征空间总结:
FFN在训练时学习:
| 层面 | 学习内容 |
|---|---|
| 低层 | 局部语法特征、词性 |
| 中层 | 语义关系、实体识别 |
| 高层 | 抽象语义、推理知识 |
| 参数 | 特征检测器、知识存储 |
| 功能 | 非线性变换、特征融合 |
关键点:
- FFN提供非线性建模能力(Attention是线性的)
- FFN是position-wise的(每个位置独立)
- FFN占据模型大部分参数(约60-70%)
- FFN可以看作存储知识的记忆层
- FFN学习不同层次的特征表示
3. 具体分析Transformer的Embeddings层、Attention层和Feedforward层的复杂度
答案:
分析Transformer各层的时间和空间复杂度。
符号定义:
n: 序列长度
d: 模型维度(d_model)
k: 注意力头的维度(d_k = d/h)
h: 注意力头数
d_ff: FFN中间层维度(通常4d)
V: 词表大小
1. Embeddings层复杂度
组成:
class Embeddings(nn.Module):
def __init__(self, vocab_size, d_model):
self.token_embedding = nn.Embedding(vocab_size, d_model)
self.position_encoding = PositionalEncoding(d_model)Token Embedding:
时间复杂度: O(n)
# 查表操作,对于每个token
for i in range(n):
embed[i] = embedding_table[token_ids[i]] # O(1)查表
# 总计:O(n)空间复杂度: O(V × d)
# Embedding表大小
embedding_table: vocab_size × d_model
= V × d
# 例如:
V = 50000, d = 512
参数量 = 50000 × 512 = 25,600,000 ≈ 25M参数Positional Encoding:
时间复杂度: O(n × d)
# 计算或查表位置编码
for pos in range(n):
for i in range(d):
if i % 2 == 0:
PE[pos, i] = sin(pos / 10000^(i/d)) # O(1)
else:
PE[pos, i] = cos(pos / 10000^(i/d)) # O(1)
# 总计:O(n × d)空间复杂度: O(n × d) 或 O(d)
# 如果预计算存储:O(max_len × d)
# 如果实时计算:O(d)(只存储公式参数)Embeddings层总复杂度:
- 时间: O(n × d)
- 空间: O(V × d)(主要是Embedding表)
2. Multi-Head Attention层复杂度
详细分解:
a. 计算Q, K, V:
时间复杂度: O(n × d²)
# 三个线性变换
Q = XW_Q # (n, d) × (d, d) = O(n × d²)
K = XW_K # (n, d) × (d, d) = O(n × d²)
V = XW_V # (n, d) × (d, d) = O(n × d²)
# 总计:3 × O(n × d²) = O(n × d²)空间复杂度: O(d²)
# 参数存储
W_Q, W_K, W_V: 各 d × d
总计:3 × d² = O(d²)b. 计算Attention Scores:
时间复杂度: O(n² × d)
# 点积计算
scores = Q @ K.T # (n, d) × (d, n) = O(n² × d)
# 对于多头:每个头维度 d_k = d/h
scores_per_head = Q_h @ K_h.T # (n, d/h) × (d/h, n) = O(n² × d/h)
# h个头:h × O(n² × d/h) = O(n² × d)空间复杂度: O(n²)
# 存储attention矩阵
attention_matrix: (batch, h, n, n)
= O(h × n²)c. Scaling和Softmax:
时间复杂度: O(n²)
# Scaling: 除以sqrt(d_k)
scores = scores / sqrt(d_k) # O(n²)元素操作
# Softmax: 对每一行
for i in range(n):
softmax(scores[i, :]) # O(n)
# 总计:O(n²)d. 加权求和V:
时间复杂度: O(n² × d)
# Attention矩阵乘以V
output = attention @ V # (n, n) × (n, d) = O(n² × d)e. 输出投影:
时间复杂度: O(n × d²)
# 线性变换
output = output @ W_O # (n, d) × (d, d) = O(n × d²)Multi-Head Attention总复杂度:
时间复杂度:
主要项:
- Q,K,V计算: O(n × d²)
- Attention计算: O(n² × d) ← 这是瓶颈!
- 加权求和: O(n² × d)
- 输出投影: O(n × d²)
总计:O(n × d² + n² × d)
关键观察:
# 当 n < d 时:O(n × d²) 占主导(通常情况)
# 当 n > d 时:O(n² × d) 占主导(长序列)
# 对于n=512, d=512:
n × d² = 512 × 512² ≈ 134M
n² × d = 512² × 512 ≈ 134M
# 两者相当空间复杂度:
- 参数: O(d²)
- 激活: O(n² + nd)(attention矩阵 + Q,K,V,输出)
3. Feed-Forward层复杂度
结构:
FFN(x) = ReLU(xW₁ + b₁)W₂ + b₂
# W₁: d × d_ff
# W₂: d_ff × d时间复杂度: O(n × d × d_ff)
详细分解:
# 第一层线性变换
h = x @ W1 # (n, d) × (d, d_ff) = O(n × d × d_ff)
# ReLU激活
h = relu(h) # O(n × d_ff)(元素操作)
# 第二层线性变换
output = h @ W2 # (n, d_ff) × (d_ff, d) = O(n × d × d_ff)
# 总计:2 × O(n × d × d_ff) + O(n × d_ff)
# = O(n × d × d_ff)具体数值(d_ff = 4d):
d_ff = 4d
复杂度 = O(n × d × 4d) = O(4nd²) = O(nd²)
# 与Attention的O(n × d²)相同量级空间复杂度:
- 参数: O(d × d_ff + d_ff × d) = O(d × d_ff)
= O(4d²) = O(d²)
- 激活: O(n × d_ff) = O(4nd)
4. 完整Transformer层复杂度总结
单层Transformer Block:
class TransformerBlock:
def forward(self, x):
# 1. Multi-Head Attention
x = x + MultiHeadAttention(x) # O(n²d + nd²)
x = LayerNorm(x) # O(nd)
# 2. Feed-Forward
x = x + FeedForward(x) # O(nd²)
x = LayerNorm(x) # O(nd)
return x时间复杂度(单层):
Attention: O(n²d + nd²)
FFN: O(nd²)
LayerNorm: O(nd)
总计:O(n²d + nd²)
L层Transformer:
总时间复杂度:L × O(n²d + nd²)
= O(L × n²d + L × nd²)
空间复杂度(单层):
参数:
- Attention: 4d² (Q,K,V,O)
- FFN: 2d × d_ff = 8d² (W1, W2)
- LayerNorm: 2d (γ, β)
总计:≈ 12d²
激活:
- Attention矩阵: O(n²)
- 中间激活: O(nd + n × d_ff)
总计:O(n² + nd_ff)
5. 复杂度对比表
| 层/操作 | 时间复杂度 | 空间复杂度(参数) | 空间复杂度(激活) |
|---|---|---|---|
| Embedding | O(nd) | O(Vd) | O(nd) |
| Positional Encoding | O(nd) | O(1)或O(d) | O(nd) |
| Self-Attention | O(n²d + nd²) | O(d²) | O(n² + nd) |
| Feed-Forward | O(nd²) | O(d × d_ff) | O(n × d_ff) |
| LayerNorm | O(nd) | O(d) | O(d) |
| 单层Transformer | O(n²d + nd²) | O(d²) | O(n² + nd) |
| L层Transformer | O(L(n²d + nd²)) | O(Ld²) | O(L(n² + nd)) |
6. 瓶颈分析
当 n < d 时(常见):
# 例如:n=512, d=512
# FFN和线性变换占主导
复杂度 ≈ O(nd²)
# 每层操作时间:
Attention投影: nd² = 512 × 512² ≈ 134M ops
FFN: nd² = 512 × 512² × 4 ≈ 536M ops ← 瓶颈!
# FFN计算量是Attention的4倍!当 n > d 时(长序列):
# 例如:n=2048, d=512
# Attention计算占主导
复杂度 ≈ O(n²d)
# 每层操作时间:
Attention矩阵: n²d = 2048² × 512 ≈ 2.1B ops ← 瓶颈!
FFN: nd² = 2048 × 512² ≈ 537M ops
# Attention计算量是FFN的4倍!7. 实际数值示例
GPT-3规模:
n = 2048 # 序列长度
d = 12288 # 模型维度
h = 96 # 注意力头数
L = 96 # 层数
# 单层复杂度:
Attention: n²d + nd²
= 2048² × 12288 + 2048 × 12288²
≈ 51B + 309B = 360B ops
FFN (d_ff=4d): nd² × 4
= 2048 × 12288² × 4
≈ 1.2T ops ← FFN占主导!
# 96层总计:≈ 150T ops8. 优化方向
针对n²复杂度(长序列问题):
1. Sparse Attention: 只关注部分位置
Longformer, BigBird: O(n × k) where k << n
2. Linformer: 线性attention
复杂度: O(nd)
3. Reformer: LSH attention
复杂度: O(n log n)
4. Flash Attention: 优化内存访问
不改变复杂度,但加速实际计算针对参数量:
1. 参数共享: 减少d²
2. 低秩分解: d² → d×k + k×d, k<<d
3. MoE: 稀疏激活,只用部分FFN
4. 量化: 减少存储但不减少计算总结:
Transformer复杂度特点:
- Self-Attention的O(n²)是长序列的主要瓶颈
- FFN的O(nd²)在短序列时是主要计算量
- 参数量O(Ld²)随层数和维度平方增长
- 内存占用:激活值的O(n²)在长序列时显著
实践启示:
- 短序列(<512): 优化FFN效率
- 长序列(>1024): 优化Attention(稀疏化)
- 大模型: 参数量和内存是关键约束
- 训练时: 梯度存储需要2-3倍激活内存
4. Transformer的Positional Encoding如何表达相对位置关系?
答案:
Transformer的原始位置编码虽然是绝对位置编码,但通过巧妙的三角函数设计,能够间接表达相对位置关系。
1. 位置编码的数学定义
Sin/Cos位置编码:
PE(pos, 2i) = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
其中:
- pos: 位置索引 (0, 1, 2, ...)
- i: 维度索引 (0 to d_model/2)
- d_model: 模型维度实现代码:
def positional_encoding(max_len, d_model):
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp(
torch.arange(0, d_model, 2) *
-(math.log(10000.0) / d_model)
)
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
return pe2. 为什么Sin/Cos能表达相对位置?
核心数学原理:三角恒等式
对于位置pos和pos+k,它们的位置编码之间存在线性关系:
数学推导:
# 对于偶数维度(sin):
PE(pos+k, 2i) = sin((pos+k) / 10000^(2i/d))
= sin(pos/10000^(2i/d)) × cos(k/10000^(2i/d))
+ cos(pos/10000^(2i/d)) × sin(k/10000^(2i/d))
= PE(pos,2i) × cos(k/10000^(2i/d))
+ PE(pos,2i+1) × sin(k/10000^(2i/d))
# 对于奇数维度(cos):
PE(pos+k, 2i+1) = cos((pos+k) / 10000^(2i/d))
= cos(pos/10000^(2i/d)) × cos(k/10000^(2i/d))
- sin(pos/10000^(2i/d)) × sin(k/10000^(2i/d))
= PE(pos,2i+1) × cos(k/10000^(2i/d))
- PE(pos,2i) × sin(k/10000^(2i/d))矩阵形式:
[PE(pos+k, 2i) ] [cos(θ) sin(θ)] [PE(pos, 2i) ]
[PE(pos+k, 2i+1)] = [-sin(θ) cos(θ)] [PE(pos, 2i+1)]
其中 θ = k / 10000^(2i/d)关键点:PE(pos+k)可以表示为PE(pos)的线性变换,变换矩阵只依赖于相对位置k!
3. 相对位置的表达机制
a. 点积能捕获相对位置信息:
# Attention中的点积
score = Q_i · K_j = (x_i + PE_i) · (x_j + PE_j)
# 展开:
= x_i · x_j + x_i · PE_j + PE_i · x_j + PE_i · PE_j
# PE_i · PE_j项包含了相对位置信息b. 相对位置距离的影响:
# 计算不同相对距离的PE点积
def pe_similarity(pos1, pos2, d_model):
pe1 = positional_encoding(pos1, d_model)
pe2 = positional_encoding(pos2, d_model)
return torch.dot(pe1, pe2)
# 示例结果:
distance = |pos1 - pos2|
distance=0: PE点积 = 1.0 (同一位置)
distance=1: PE点积 = 0.95 (相邻位置)
distance=5: PE点积 = 0.82
distance=10: PE点积 = 0.65
distance=50: PE点积 = 0.15
# 相对距离越远,PE相似度越低c. 不同频率编码不同尺度的相对位置:
# 低频分量(低维度):
PE(pos, 0) = sin(pos / 10000^0) = sin(pos)
# 周期短,编码局部相对位置
# 高频分量(高维度):
PE(pos, d-2) = sin(pos / 10000^((d-2)/d))
≈ sin(pos / 10000)
# 周期长,编码全局相对位置
# 多尺度表示:
低维度 → 短距离相对位置(相邻词)
高维度 → 长距离相对位置(远距离词)4. 可视化示例
不同位置的PE相似度矩阵:
import matplotlib.pyplot as plt
def visualize_pe_similarity(max_len=50, d_model=128):
pe = positional_encoding(max_len, d_model)
# 计算任意两个位置的相似度
similarity = torch.matmul(pe, pe.T)
plt.imshow(similarity, cmap='viridis')
plt.title('Positional Encoding Similarity Matrix')
plt.xlabel('Position j')
plt.ylabel('Position i')
plt.colorbar()
plt.show()
# 可视化结果:
# - 对角线(同一位置):相似度最高
# - 离对角线越远(相对距离越大):相似度越低
# - 呈现带状结构:相同相对距离的位置对有相似的编码不同维度的周期性:
# 第0,1维(低频):
pos = [0, 1, 2, 3, ..., 100]
PE[:, 0] 波形:快速振荡,周期短
PE[:, 1] 波形:快速振荡,周期短
# 第126,127维(高频):
PE[:, 126] 波形:缓慢变化,周期长
PE[:, 127] 波形:缓慢变化,周期长
# 解释:
低维度 → 区分相邻位置
高维度 → 区分远距离位置5. 为什么不直接使用相对位置编码?
原始Transformer使用绝对位置编码的原因:
优点:
1. 实现简单:预计算,查表即可
2. 参数效率:无需学习,不占参数
3. 外推性:理论上可以处理任意长度
4. 稳定性:确定性编码,不需要训练
缺点:
1. 相对位置表达间接
2. 长度外推效果有限
3. 不如相对位置编码直接6. 改进方案:相对位置编码(Relative Position Encoding)
a. Transformer-XL的相对位置编码:
# 直接在Attention计算中加入相对位置
Attention(q, k, v) = softmax(
(q · k^T) / √d + relative_bias(i, j)
) · v
其中:
relative_bias(i, j) = q · R[i-j]
R[k] 是可学习的相对位置嵌入b. T5的相对位置偏置:
# 为每个相对距离学习一个偏置
attention_score[i,j] += relative_position_bias[i-j]
# 将相对距离分桶:
distance = i - j
if distance == 0: bucket = 0
elif distance < 8: bucket = distance
elif distance < 64: bucket = 8 + (distance-8)//8
else: bucket = 16
bias = learned_bias[bucket]c. ALiBi (Attention with Linear Biases):
# 简单的线性偏置
attention_score[i,j] += -m × |i - j|
其中 m 是每个头的固定斜率:
head 1: m = 1/2^1
head 2: m = 1/2^2
head 3: m = 1/2^3
...
# 优点:
- 极简实现
- 长度外推性好
- 无需参数7. 绝对 vs 相对位置编码对比
| 特性 | 绝对位置编码 | 相对位置编码 |
|---|---|---|
| 实现 | 简单,Sin/Cos | 稍复杂 |
| 参数 | 无(或很少) | 需要学习 |
| 表达 | 间接表达相对位置 | 直接表达 |
| 外推 | 理论可外推 | 通常更好 |
| 性能 | 足够好 | 可能稍好 |
| 代表 | 原始Transformer | T5, Transformer-XL |
8. 实践建议
何时使用绝对位置编码:
✓ 序列长度固定或变化不大
✓ 追求简单实现
✓ 不需要极致性能
✓ 计算资源受限何时使用相对位置编码:
✓ 需要处理变长序列
✓ 需要长度外推
✓ 性能要求高
✓ 有充足训练资源总结:
Transformer如何表达相对位置:
-
数学基础:
- Sin/Cos的三角恒等式
- PE(pos+k) = Linear_Transform(PE(pos))
- 变换矩阵只依赖相对位置k
-
实现机制:
- Attention中的点积自然捕获相对位置
- 不同频率编码不同尺度的相对关系
- PE相似度随相对距离衰减
-
优劣权衡:
- 绝对编码:简单高效,间接表达
- 相对编码:直接有效,稍复杂
-
关键洞察:
绝对位置编码 ≠ 只能表达绝对位置 通过巧妙设计(Sin/Cos): 绝对位置编码 → 能表达相对位置关系
这是Transformer位置编码的精妙之处:用简单的绝对编码,实现了相对位置的表达!
5. Layer Normalization蕴含的神经网络的假设是什么?
答案:
Layer Normalization (LayerNorm) 背后蕴含着关于神经网络的几个重要假设。
1. 核心假设:样本内部特征统计的一致性
基本假设:
对于单个样本,其内部所有特征应该在相似的数值范围内。
数学表达:
# LayerNorm在特征维度上归一化
对于输入 x ∈ R^d (d维特征)
假设:这d维特征应该具有相似的统计特性
- 相似的均值和方差
- 不应该某些维度特别大/小对比BatchNorm的假设:
BatchNorm假设:
- 同一维度的特征在不同样本间应该一致
- 归一化跨batch维度
LayerNorm假设:
- 同一样本的不同特征维度应该一致
- 归一化跨特征维度2. LayerNorm的数学定义
def layer_norm(x, gamma, beta, eps=1e-5):
"""
x: (batch, seq_len, d_model) 或 (batch, d_model)
gamma, beta: (d_model,) 可学习参数
"""
# 对最后一个维度(特征维度)计算统计量
mean = x.mean(dim=-1, keepdim=True) # 每个样本的均值
var = x.var(dim=-1, keepdim=True) # 每个样本的方差
# 归一化
x_norm = (x - mean) / torch.sqrt(var + eps)
# 放缩和平移(可学习)
out = gamma * x_norm + beta
return out关键点:
# 对于输入 (batch=2, seq_len=3, d=4)
x = [
[[1,2,3,4], [5,6,7,8], [9,10,11,12]], # 样本1
[[2,4,6,8], [1,3,5,7], [10,20,30,40]] # 样本2
]
# LayerNorm分别对每个位置的4维特征归一化:
# 位置(0,0)的[1,2,3,4] → 归一化
# 位置(0,1)的[5,6,7,8] → 归一化
# ...
# 每个位置独立归一化,不跨位置,不跨batch3. 蕴含的假设详解
假设1:特征维度的可交换性(Feature Permutation Invariance)
假设:特征维度的顺序不重要(在统计意义上)
# LayerNorm对所有特征维度一视同仁
mean = (x1 + x2 + ... + xd) / d
var = ((x1-μ)² + (x2-μ)² + ... + (xd-μ)²) / d
# 如果交换特征顺序:
x' = [x2, x1, x3, ..., xd]
# 归一化结果也会相应交换,统计量不变
解释:
- 所有特征维度在统计上是平等的
- 没有某个维度天然更重要
- 适合Transformer(每个维度都是学到的表示)假设2:样本独立性(Sample Independence)
假设:每个样本应该独立归一化
# 样本1的归一化不影响样本2
LN(样本1) 只依赖 样本1的统计量
LN(样本2) 只依赖 样本2的统计量
# 这意味着:
- Batch size不影响归一化
- 推理时和训练时行为一致
- 无需维护running statistics假设3:位置独立性(Position Independence)
# 在Transformer中:
x: (batch, seq_len, d_model)
# LayerNorm独立处理每个位置:
for pos in range(seq_len):
x[:, pos, :] = LayerNorm(x[:, pos, :])
假设:每个位置应该独立归一化
- 位置0的token不应该影响位置1的归一化
- 序列长度变化不影响归一化行为假设4:特征尺度的重要性(Feature Scale Matters)
假设:特征的绝对值尺度不重要,相对关系才重要
例如:
x1 = [1, 2, 3, 4] # 小数值
x2 = [100, 200, 300, 400] # 大数值
# 归一化后:
norm(x1) = norm(x2) # 相同的标准正态分布
# 但通过γ和β可以恢复必要的尺度信息4. 为什么这些假设适合Transformer?
a. 序列长度可变:
# LayerNorm不跨序列位置
# 因此不受序列长度影响
训练:seq_len = 512
推理:seq_len = 100 # 也能正常工作
# BatchNorm做不到这一点b. Batch size可变:
# LayerNorm不跨batch
# 因此不受batch size影响
训练:batch_size = 64
推理:batch_size = 1 # 也能正常工作
# BatchNorm在小batch时不稳定c. 特征分布均匀:
# Transformer的表示是学出来的
# 没有预定义的语义
# 所有维度地位平等
# 例如d_model=512:
# 没有哪个维度天然代表"名词"或"动词"
# 所有维度共同编码语义
# → 适合跨维度归一化d. 稳定训练深层网络:
# 深层网络容易梯度消失/爆炸
# LayerNorm在每层都归一化
# 确保激活值不会爆炸
# 假设:每层输出应该在合理范围内5. LayerNorm vs BatchNorm的假设对比
| 维度 | BatchNorm | LayerNorm |
|---|---|---|
| 归一化维度 | 跨batch,同一特征 | 跨特征,同一样本 |
| 核心假设 | 不同样本的同一特征应该一致 | 同一样本的不同特征应该一致 |
| 适用场景 | CNN,特征有物理意义 | RNN,Transformer,学习的表示 |
| batch依赖 | 依赖batch统计 | 不依赖 |
| 序列长度 | 要求固定 | 可变 |
| 推理一致性 | 需要running stats | 天然一致 |
代码对比:
# BatchNorm
class BatchNorm:
def forward(self, x):
# x: (batch, features) 或 (batch, C, H, W)
# 对batch维度归一化
mean = x.mean(dim=0) # (features,) 跨样本
var = x.var(dim=0)
return (x - mean) / sqrt(var + eps)
# LayerNorm
class LayerNorm:
def forward(self, x):
# x: (batch, features)
# 对features维度归一化
mean = x.mean(dim=1) # (batch,) 跨特征
var = x.var(dim=1)
return (x - mean) / sqrt(var + eps)6. 隐含的更深层假设
假设5:加性偏移和乘性缩放足够
# LayerNorm的重参数化
y = γ * (x - μ) / σ + β
假设:
- 线性变换(γ, β)足以表达任何需要的分布
- 不需要更复杂的变换
这相当于假设:
- 归一化后的高斯分布是好的起点
- 网络可以通过γ, β学习到需要的分布假设6:零均值单位方差是好的初始化
x_norm ~ N(0, 1) # 归一化后
假设:
- 标准正态分布是合理的中间表示
- 避免激活值过大/过小
- 利于梯度传播假设7:统计稳定性假设
假设:
- 样本内部的均值和方差是稳定的统计量
- 足以capture特征的分布信息
- 不需要更高阶矩(偏度、峰度等)7. 假设的局限性
不完全成立的情况:
1. 特征语义差异大:
x = [位置信息, 语义信息, 句法信息, ...]
# 不同类型的信息可能需要不同的尺度
# LayerNorm会强制它们在相同尺度
2. 特征分布严重不均:
x = [0.1, 0.2, 100, 200]
# 大值特征主导统计量
# 小值特征被过度放大
3. 位置间强相关:
# 序列中相邻位置高度相关
# 独立归一化可能不optimal8. 实践启示
何时使用LayerNorm:
✓ 序列模型(RNN, Transformer)
✓ 学习的表示(非hand-crafted特征)
✓ 可变长度输入
✓ 小batch或单样本推理
✓ 需要训练/推理一致性何时使用BatchNorm:
✓ CNN(空间特征)
✓ 固定大小输入(图像)
✓ 大batch训练
✓ 特征有明确物理意义何时两者都不够:
考虑:
- GroupNorm: 特征分组归一化
- InstanceNorm: 每个样本的每个通道独立
- WeightNorm: 归一化权重而非激活
- RMSNorm: 只除以RMS,不减均值(更快)总结:
LayerNorm的核心假设:
- 特征统计一致性:同一样本的不同特征应该有相似的统计特性
- 样本独立性:每个样本应该独立归一化
- 特征可交换性:特征维度没有预定义的重要性排序
- 位置独立性:序列不同位置应该独立归一化
- 尺度相对性:绝对尺度不重要,相对关系才重要
为什么这些假设合理:
- Transformer的表示是学习出来的,没有预定义语义
- 适应可变长度序列和可变batch size
- 提供训练稳定性和推理一致性
- 简单有效,易于实现
关键洞察:
LayerNorm的设计哲学:
"每个样本自己管自己"
vs
BatchNorm的设计哲学:
"相同特征的样本要相互学习"
这些假设的选择,直接决定了LayerNorm更适合序列模型,而BatchNorm更适合卷积网络!
6. 从数据的角度分析Transformer中的Decoder和Encoder的依存关系
答案:
从数据流动和信息依赖的角度,深入分析Encoder和Decoder之间的关系。
1. 整体数据流图
源序列数据 (Source)
↓
┌──────────────────┐
│ ENCODER │
│ (Bidirectional) │
│ │
│ - Token Embed │
│ - Pos Encoding │
│ - Self-Attention │ ← 可以看到所有源tokens
│ - FFN │
│ × N layers │
└──────────────────┘
↓
Encoder Output (Memory)
↓ ← 作为Key和Value
┌──────────────────┐
│ DECODER │
│ (Autoregressive) │
│ │
│ - Token Embed │
│ - Pos Encoding │
│ - Masked Self- │ ← 只能看到之前的tokens
│ Attention │
│ - Cross- │ ← **依赖Encoder Output**
│ Attention │
│ - FFN │
│ × N layers │
└──────────────────┘
↓
目标序列输出 (Target)
2. 详细的数据依存关系
a. Encoder的数据流(完全独立)
# Encoder的输入
source_tokens = ["I", "love", "AI"] # 源序列
source_embed = Embedding(source_tokens) + PosEnc
# shape: (batch, src_len, d_model)
# Encoder Layer的处理
def encoder_layer(x):
# 1. Self-Attention(源序列内部)
Q = K = V = x # 都来自输入
attn_out = SelfAttention(Q, K, V)
# 每个源token关注所有其他源tokens
x = x + attn_out # 残差
x = LayerNorm(x)
# 2. Feed-Forward
ffn_out = FFN(x)
x = x + ffn_out
x = LayerNorm(x)
return x # (batch, src_len, d_model)
# 堆叠N层
encoder_output = x
for layer in encoder_layers:
encoder_output = layer(encoder_output)
# Encoder Output = Memory
# shape: (batch, src_len, d_model)关键点:
Encoder的数据流:
- 只依赖源序列数据
- 与目标序列无关
- 与Decoder无关
- 可以独立并行计算
b. Decoder的数据流(依赖Encoder)
# Decoder的输入
target_tokens = ["<BOS>", "我", "爱"] # 目标序列(已生成部分)
target_embed = Embedding(target_tokens) + PosEnc
# shape: (batch, tgt_len, d_model)
# Decoder Layer的处理
def decoder_layer(x, encoder_output):
# 1. Masked Self-Attention(目标序列内部)
Q = K = V = x # 都来自目标序列
attn_out = MaskedSelfAttention(Q, K, V)
# 每个目标token只关注之前的目标tokens
x = x + attn_out
x = LayerNorm(x)
# 2. Cross-Attention(★ 依赖Encoder ★)
Q = x # Query来自Decoder
K = V = encoder_output # Key和Value来自Encoder!
cross_attn_out = CrossAttention(Q, K, V)
# Decoder的每个token关注所有Encoder的tokens
x = x + cross_attn_out
x = LayerNorm(x)
# 3. Feed-Forward
ffn_out = FFN(x)
x = x + ffn_out
x = LayerNorm(x)
return x
# 堆叠N层(每层都需要encoder_output)
decoder_output = target_embed
for layer in decoder_layers:
decoder_output = layer(decoder_output, encoder_output)
# ↑ 必须传入encoder_output关键点:
Decoder的数据依存:
1. Masked Self-Attention: 只依赖目标序列
2. Cross-Attention: 依赖Encoder输出 ← 核心依存!
3. FFN: 只依赖当前层激活
3. Cross-Attention中的详细数据依存
数学表达:
# Cross-Attention的计算
def cross_attention(decoder_hidden, encoder_output):
# decoder_hidden: (batch, tgt_len, d_model)
# encoder_output: (batch, src_len, d_model)
# Query: 来自Decoder
Q = decoder_hidden @ W_Q # (batch, tgt_len, d_model)
# Key & Value: 来自Encoder
K = encoder_output @ W_K # (batch, src_len, d_model)
V = encoder_output @ W_V # (batch, src_len, d_model)
# Attention Scores
scores = Q @ K.T / sqrt(d_k)
# shape: (batch, tgt_len, src_len)
# scores[i][j]: 目标位置i对源位置j的注意力分数
attn_weights = softmax(scores, dim=-1)
# shape: (batch, tgt_len, src_len)
# Weighted Sum
output = attn_weights @ V
# shape: (batch, tgt_len, d_model)
return output数据依存关系:
目标token i 的Cross-Attention输出依赖:
1. Decoder自身的hidden state(Query)
2. Encoder的所有输出(Key & Value)
具体来说:
output[i] = Σⱼ attention[i][j] × encoder_output[j]
其中:
- j遍历所有源序列位置
- attention[i][j]: 目标i对源j的注意力权重
- encoder_output[j]: 源位置j的Encoder表示
4. 数据依存的层次分析
第一层Decoder:
# Decoder Layer 1
x = target_embedding # (batch, tgt_len, d)
# Masked Self-Attention
x = x + MaskedSelfAttn(x, x, x)
# 依赖:目标序列的embedding
# Cross-Attention
x = x + CrossAttn(Q=x, K=encoder_out, V=encoder_out)
# 依赖:
# - Decoder Layer 1的中间状态(Query)
# - Encoder的最终输出(Key & Value)
# FFN
x = x + FFN(x)
# 依赖:当前层的激活第二层Decoder:
# Decoder Layer 2
# 输入是Layer 1的输出
x = x + MaskedSelfAttn(x, x, x)
# 依赖:Layer 1的输出
x = x + CrossAttn(Q=x, K=encoder_out, V=encoder_out)
# 依赖:
# - Decoder Layer 2的中间状态
# - **同一个** Encoder的最终输出
# FFN
x = x + FFN(x)关键观察:
# 所有Decoder层共享同一个Encoder Output
for decoder_layer in decoder_layers:
x = decoder_layer(x, encoder_output)
# ↑ 同一个encoder_output
# 不是:
# Layer 1用Encoder Layer 1的输出
# Layer 2用Encoder Layer 2的输出
# ✗ 错误!
# 而是:
# 所有Decoder层都用Encoder的最终输出
# ✓ 正确!5. 训练时的数据并行性
Encoder端(完全并行):
# 训练时,Encoder可以完全并行
source = ["I", "love", "AI"]
# 所有位置同时计算
encoder_out = Encoder(source) # 一次前向传播
# shape: (batch, 3, d_model)
# encoder_out[0]: "I"的表示
# encoder_out[1]: "love"的表示
# encoder_out[2]: "AI"的表示
# 不需要等待,一次性计算完成Decoder端(训练时并行,推理时序列):
# 训练时(Teacher Forcing):
target = ["<BOS>", "我", "爱", "AI"]
labels = ["我", "爱", "AI", "<EOS>"]
# 使用Causal Mask,所有位置可以并行计算
decoder_out = Decoder(target, encoder_out)
# shape: (batch, 4, d_model)
# 每个位置的计算虽然并行,但attention mask保证:
# decoder_out[0]: 只看到 "<BOS>"
# decoder_out[1]: 只看到 "<BOS>", "我"
# decoder_out[2]: 只看到 "<BOS>", "我", "爱"
# decoder_out[3]: 只看到 "<BOS>", "我", "爱", "AI"
# 但所有位置都看到完整的encoder_out推理时(必须序列):
# 推理时,Decoder必须逐token生成
encoder_out = Encoder(source) # 一次性完成
# 自回归生成
generated = ["<BOS>"]
for t in range(max_len):
# 当前生成的序列
decoder_input = generated
# 预测下一个token
decoder_out = Decoder(decoder_input, encoder_out)
next_token = argmax(decoder_out[-1]) # 最后一个位置
generated.append(next_token)
if next_token == "<EOS>":
break
# 每一步都需要:
# 1. 当前已生成的target序列
# 2. Encoder的输出(不变,可以cache)6. 数据依存的可视化
翻译任务示例:
Source: "I love AI"
Target: "我 爱 AI"
Step 1: Encode source
─────────────────────
I love AI
↓ ↓ ↓
[Encoder Processing]
↓ ↓ ↓
e₁ e₂ e₃ ← Encoder outputs
│ │ │
└─────┴─────┘
↓
Memory (固定)
Step 2: Decode target (Training)
─────────────────────
<BOS> 我 爱
↓ ↓ ↓
[Masked Self-Attention]
↓ ↓ ↓
[Cross-Attention with Memory]
│ │ │
├────┼───┼── attend to e₁
├────┼───┼── attend to e₂
└────┴───┴── attend to e₃
↓ ↓ ↓
我 爱 AI ← Predictions
每个Decoder位置都:
- 通过Self-Attention看之前的目标tokens
- 通过Cross-Attention看所有源tokens(via Memory)
7. 依存关系的数学表达
Encoder Output:
E = Encoder(X_src)
E ∈ R^(n_src × d)
其中:
- X_src: 源序列
- n_src: 源序列长度
- d: 模型维度
Decoder Output:
Y = Decoder(X_tgt, E)
Y ∈ R^(n_tgt × d)
其中:
- X_tgt: 目标序列
- E: Encoder的输出(依赖)
- n_tgt: 目标序列长度
梯度反向传播:
# 训练时的梯度流
Loss = CrossEntropy(Y, labels)
# 梯度流向Decoder参数
∂Loss/∂W_decoder = ...
- 通过Decoder的所有层
- 包括Cross-Attention中的Q投影矩阵
# 梯度流向Encoder参数(通过Cross-Attention)
∂Loss/∂W_encoder = ∂Loss/∂E × ∂E/∂W_encoder
# Cross-Attention的K, V来自Encoder
# 因此梯度会通过Cross-Attention传回Encoder
# 数据依存 → 梯度依存:
Decoder依赖Encoder的输出(前向)
Encoder接收Decoder的梯度(反向)8. 依存关系的实践影响
a. 推理效率:
# Encoder只需计算一次
encoder_out = Encoder(source) # 计算一次,cache
# Decoder每个时间步都要用encoder_out
for t in range(max_len):
decoder_out = Decoder(generated[:t+1], encoder_out)
# ↑ 重复使用同一个encoder_out
# 优化:Encoder输出可以复用,不需要重新计算b. 内存占用:
# 训练时需要存储:
- Encoder outputs: (batch, n_src, d) ← 固定大小
- Decoder每层的中间激活
- Attention矩阵: (batch, n_tgt, n_src) ← 取决于序列长度
# 总内存 ∝ batch × (n_src + n_tgt) × dc. 并行化:
# 可并行:
✓ Encoder内部:所有位置并行
✓ Decoder训练:所有位置并行(用mask)
✓ 批处理:多个样本并行
# 不可并行:
✗ Decoder推理:必须序列生成
✗ Encoder→Decoder:必须先Encoder后Decoder9. Encoder-Decoder vs Decoder-only的依存对比
Encoder-Decoder(如原始Transformer):
# 明确的依存关系
Decoder 依赖 Encoder的输出
优点:
✓ 源序列双向理解(Encoder)
✓ 目标序列单向生成(Decoder)
✓ 适合Seq2Seq任务
缺点:
✗ 结构复杂
✗ 两套参数Decoder-only(如GPT):
# 没有显式依存
只有Decoder,没有Encoder
优点:
✓ 结构简单
✓ 参数效率高
✓ 易于扩展
缺点:
✗ 只能单向理解输入总结:
Encoder-Decoder的数据依存关系:
-
Encoder侧(独立):
- 只依赖源序列数据
- 输出固定的Memory表示
- 可完全并行计算
-
Decoder侧(依赖):
- Masked Self-Attention: 依赖目标序列
- Cross-Attention: 依赖Encoder输出 ← 核心依存
- 每一层都使用同一个Encoder输出
-
数据流动:
Source → Encoder → Memory ↓ Target → Decoder → Output -
训练 vs 推理:
- 训练:两端都可并行(用mask)
- 推理:Encoder并行,Decoder序列
-
梯度流动:
- 前向:Decoder依赖Encoder
- 反向:Encoder接收Decoder梯度
关键洞察:
Cross-Attention是Encoder和Decoder之间
唯一的数据桥梁!
它允许Decoder的每个位置
attend to Encoder的所有位置
从而实现源到目标的信息传递。
这种设计使得:
- Encoder专注于理解源序列(双向)
- Decoder专注于生成目标序列(单向)
- Cross-Attention连接两者(信息桥梁)