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-AttentionDecoder 上一子层输出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 output

1.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在训练时学习:

层面学习内容
低层局部语法特征、词性
中层语义关系、实体识别
高层抽象语义、推理知识
参数特征检测器、知识存储
功能非线性变换、特征融合

关键点:

  1. FFN提供非线性建模能力(Attention是线性的)
  2. FFN是position-wise的(每个位置独立)
  3. FFN占据模型大部分参数(约60-70%)
  4. FFN可以看作存储知识的记忆层
  5. 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. 复杂度对比表

层/操作时间复杂度空间复杂度(参数)空间复杂度(激活)
EmbeddingO(nd)O(Vd)O(nd)
Positional EncodingO(nd)O(1)或O(d)O(nd)
Self-AttentionO(n²d + nd²)O(d²)O(n² + nd)
Feed-ForwardO(nd²)O(d × d_ff)O(n × d_ff)
LayerNormO(nd)O(d)O(d)
单层TransformerO(n²d + nd²)O(d²)O(n² + nd)
L层TransformerO(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 ops

8. 优化方向

针对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复杂度特点:

  1. Self-Attention的O(n²)是长序列的主要瓶颈
  2. FFN的O(nd²)在短序列时是主要计算量
  3. 参数量O(Ld²)随层数和维度平方增长
  4. 内存占用:激活值的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 pe

2. 为什么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稍复杂
参数无(或很少)需要学习
表达间接表达相对位置直接表达
外推理论可外推通常更好
性能足够好可能稍好
代表原始TransformerT5, Transformer-XL

8. 实践建议

何时使用绝对位置编码:

✓ 序列长度固定或变化不大
✓ 追求简单实现
✓ 不需要极致性能
✓ 计算资源受限

何时使用相对位置编码:

✓ 需要处理变长序列
✓ 需要长度外推
✓ 性能要求高
✓ 有充足训练资源

总结:

Transformer如何表达相对位置:

  1. 数学基础:

    • Sin/Cos的三角恒等式
    • PE(pos+k) = Linear_Transform(PE(pos))
    • 变换矩阵只依赖相对位置k
  2. 实现机制:

    • Attention中的点积自然捕获相对位置
    • 不同频率编码不同尺度的相对关系
    • PE相似度随相对距离衰减
  3. 优劣权衡:

    • 绝对编码:简单高效,间接表达
    • 相对编码:直接有效,稍复杂
  4. 关键洞察:

    绝对位置编码 ≠ 只能表达绝对位置
    
    通过巧妙设计(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] → 归一化
# ...
# 每个位置独立归一化,不跨位置,不跨batch

3. 蕴含的假设详解

假设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的假设对比

维度BatchNormLayerNorm
归一化维度跨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. 位置间强相关:
   # 序列中相邻位置高度相关
   # 独立归一化可能不optimal

8. 实践启示

何时使用LayerNorm:

✓ 序列模型(RNN, Transformer)
✓ 学习的表示(非hand-crafted特征)
✓ 可变长度输入
✓ 小batch或单样本推理
✓ 需要训练/推理一致性

何时使用BatchNorm:

✓ CNN(空间特征)
✓ 固定大小输入(图像)
✓ 大batch训练
✓ 特征有明确物理意义

何时两者都不够:

考虑:
- GroupNorm: 特征分组归一化
- InstanceNorm: 每个样本的每个通道独立
- WeightNorm: 归一化权重而非激活
- RMSNorm: 只除以RMS,不减均值(更快)

总结:

LayerNorm的核心假设:

  1. 特征统计一致性:同一样本的不同特征应该有相似的统计特性
  2. 样本独立性:每个样本应该独立归一化
  3. 特征可交换性:特征维度没有预定义的重要性排序
  4. 位置独立性:序列不同位置应该独立归一化
  5. 尺度相对性:绝对尺度不重要,相对关系才重要

为什么这些假设合理:

  • 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) × d

c. 并行化:

# 可并行:
✓ Encoder内部:所有位置并行
✓ Decoder训练:所有位置并行(用mask)
✓ 批处理:多个样本并行
 
# 不可并行:
✗ Decoder推理:必须序列生成
✗ Encoder→Decoder:必须先Encoder后Decoder

9. Encoder-Decoder vs Decoder-only的依存对比

Encoder-Decoder(如原始Transformer):

# 明确的依存关系
Decoder 依赖 Encoder的输出
 
优点:
✓ 源序列双向理解(Encoder)
✓ 目标序列单向生成(Decoder)
✓ 适合Seq2Seq任务
 
缺点:
✗ 结构复杂
✗ 两套参数

Decoder-only(如GPT):

# 没有显式依存
只有Decoder,没有Encoder
 
优点:
✓ 结构简单
✓ 参数效率高
✓ 易于扩展
 
缺点:
✗ 只能单向理解输入

总结:

Encoder-Decoder的数据依存关系:

  1. Encoder侧(独立):

    • 只依赖源序列数据
    • 输出固定的Memory表示
    • 可完全并行计算
  2. Decoder侧(依赖):

    • Masked Self-Attention: 依赖目标序列
    • Cross-Attention: 依赖Encoder输出 ← 核心依存
    • 每一层都使用同一个Encoder输出
  3. 数据流动:

    Source → Encoder → Memory
                        ↓
    Target → Decoder → Output
    
  4. 训练 vs 推理:

    • 训练:两端都可并行(用mask)
    • 推理:Encoder并行,Decoder序列
  5. 梯度流动:

    • 前向:Decoder依赖Encoder
    • 反向:Encoder接收Decoder梯度

关键洞察:

Cross-Attention是Encoder和Decoder之间
唯一的数据桥梁!

它允许Decoder的每个位置
attend to Encoder的所有位置
从而实现源到目标的信息传递。

这种设计使得:

  • Encoder专注于理解源序列(双向)
  • Decoder专注于生成目标序列(单向)
  • Cross-Attention连接两者(信息桥梁)