数学形式化#

从数学角度看，自监督学习可以形式化为：

给定：无标注数据集 $\mathcal{D} = \{x_1, x_2, ..., x_n\}$

目标：学习一个表征函数 $f_\theta: \mathcal{X} \rightarrow \mathcal{Z}$，将输入空间 $\mathcal{X}$ 映射到表征空间 $\mathcal{Z}$

方法：设计预文本任务 $\mathcal{T}_{\text{pretext}}$，从数据 $x$ 自动构造输入-标签对 $(x', y')$：

训练：最小化预文本任务的损失：

参数说明：

• $\theta$：模型参数
• $x'$：从原始数据 $x$ 变换得到的输入（如遮蔽部分词的句子）
• $y'$：自动生成的伪标签（如被遮蔽的词）
• $\ell$：损失函数（如交叉熵）

预文本任务与下游任务#

自监督学习遵循两阶段范式：

阶段一：预训练（Pre-training）

• 任务：预文本任务 $\mathcal{T}_{\text{pretext}}$（如掩码预测、对比学习）
• 数据：大规模无标注数据
• 目标：学习通用表征 $f_\theta$
• 特点：不需要人工标注，可以利用海量数据

阶段二：下游任务（Downstream Task）

• 任务：实际应用任务 $\mathcal{T}_{\text{downstream}}$（如情感分类、问答）
• 数据：少量标注数据
• 目标：利用预训练表征解决特定问题
• 方法：微调（Fine-tuning）或线性探针（Linear Probing）

关键洞察：

• 预文本任务的设计决定了学到的表征质量
• 好的预文本任务能让模型学到可迁移的通用知识
• 预文本任务不需要与下游任务完全一致，但应该能捕捉数据的本质结构

示例：

1
预文本任务：预测句子中被遮蔽的词
2
→ 模型学会理解语言的语法和语义
3

4
下游任务：情感分类
5
→ 利用预训练的语言理解能力，只需少量标注数据即可完成

自监督学习与无监督学习的关系#

相同点：

• 都不需要人工标注的数据
• 都从数据本身学习

不同点：

• 无监督学习：直接学习数据的分布或结构（如聚类、降维）

  • 目标：$p(x)$ 或数据的低维表示
  • 方法：K-means、PCA、自编码器等
  • 特点：没有明确的”任务”概念

• 自监督学习：通过构造监督任务来学习表征

  • 目标：$p(y|x)$，其中 $y$ 是自动生成的伪标签
  • 方法：掩码预测、对比学习等
  • 特点：有明确的”预文本任务”，训练过程类似监督学习

本质：自监督学习是无监督学习的一种实现策略，它巧妙地将无监督问题转化为监督学习问题，从而可以利用监督学习的强大优化方法。

任务一：掩码语言建模（Masked Language Modeling, MLM）#

核心思想：随机遮住部分词，让模型预测被遮住的内容。

具体做法：

1. 随机遮蔽：随机选择 15% 的词进行处理

   • 80% 替换为 [MASK] 标记
   • 10% 替换为随机词
   • 10% 保持不变

2. 双向编码：利用左右两侧的上下文预测

   1
   输入：我 [MASK] 深度学习
   2
   上下文：左边"我" + 右边"深度学习"
   3
   预测：[MASK] = "爱"

3. 训练目标：

   $$\mathcal{L}_{\text{MLM}} = -\sum_{i \in \text{masked}} \log P(x_i | \text{context})$$

参数说明：

• $x_i$：被遮蔽位置的原始词
• $\text{context}$：双向上下文（未被遮蔽的所有词）
• $P(x_i | \text{context})$：模型预测的词表概率分布

MLM的输入输出详解：

输入格式：

1
# 原始文本
2
text = "我爱深度学习"
3

4
# 分词后的token IDs
5
input_ids = [101, 2769, 4263, 3995, 2428, 2110, 739, 102]
6
# 对应：[CLS] 我 爱 深度 学习 [SEP]
7

8
# 随机遮蔽15%的词（假设遮蔽"爱"）
9
masked_input_ids = [101, 2769, 103, 3995, 2428, 2110, 739, 102]
10
# 对应：[CLS] 我 [MASK] 深度 学习 [SEP]
11
# 103是[MASK]的token ID
12

13
# 输入张量形状
14
input_ids: [batch_size, seq_length]  # 例如 [32, 128]
15
attention_mask: [batch_size, seq_length]  # 标记哪些位置是真实token
16
token_type_ids: [batch_size, seq_length]  # 区分句子A和句子B

BERT处理过程：

1
# BERT编码
2
hidden_states = BERT(input_ids, attention_mask, token_type_ids)
3
# 输出形状：[batch_size, seq_length, hidden_size]
4
# 例如：[32, 128, 768] (BERT-base)
5

6
# 只取被遮蔽位置的输出
7
masked_positions = [2]  # 第2个位置被遮蔽（"爱"）
8
masked_hidden = hidden_states[:, masked_positions, :]
9
# 形状：[batch_size, num_masked, hidden_size]
10

11
# 预测词表分布
12
logits = MLM_head(masked_hidden)
13
# 形状：[batch_size, num_masked, vocab_size]
14
# 例如：[32, 1, 21128] (中文BERT词表大小)
15

16
# 应用softmax得到概率分布
17
probs = softmax(logits, dim=-1)
18
predicted_token_id = argmax(probs, dim=-1)  # 预测的token ID

输出格式：

1
# 模型输出
2
outputs = {
3
    'loss': 标量,  # MLM损失
4
    'logits': [batch_size, seq_length, vocab_size],  # 每个位置的词表预测
5
    'hidden_states': [batch_size, seq_length, hidden_size],  # 每层的隐藏状态
6
    'attentions': [batch_size, num_heads, seq_length, seq_length]  # 注意力权重
7
}
8

9
# 预测结果示例
10
predicted_token = "爱"  # 模型成功预测出被遮蔽的词

关键维度说明：

• batch_size：批量大小，如32
• seq_length：序列长度，最大512
• hidden_size：隐藏层维度，BERT-base为768，BERT-large为1024
• vocab_size：词表大小，中文BERT约21128，英文BERT约30522
• num_heads：注意力头数，BERT-base为12，BERT-large为16

为什么不全部替换为 [MASK]？

• 如果全部替换为 [MASK]，微调时会遇到问题（微调时没有 [MASK] 标记）
• 10% 替换为随机词：让模型学会纠错
• 10% 保持不变：让模型学会利用上下文

深层动机：缓解预训练-微调的分布偏移

这个 80%-10%-10% 的策略设计非常巧妙，背后有深刻的考虑：

问题：预训练和微调阶段的输入分布不一致

• 预训练：输入包含 [MASK] 标记
• 微调：输入是正常文本，没有 [MASK] 标记
• 风险：模型可能过度依赖 [MASK] 标记的存在，导致微调时性能下降

解决方案：混合策略

1. 80% 用 [MASK]：主要训练目标，让模型学会预测
2. 10% 用随机词：
   • 模拟噪声环境，提升鲁棒性
   • 强迫模型不能仅依赖当前位置的词，必须利用上下文
   • 类似于去噪自编码器的思想
3. 10% 保持原词：
   • 缩小预训练和微调的分布差异
   • 让模型习惯处理正常文本
   • 模型需要判断：这个词是否需要”修正”

数学视角：

• 设 $x_i$ 为原始词，$\tilde{x}_i$ 为替换后的词
• 预训练时模型看到：$P(x_i | x_1, ..., \tilde{x}_i, ..., x_n)$
• 微调时模型看到：$P(y | x_1, ..., x_i, ..., x_n)$
• 通过 10% 保持原词，让两个分布更接近

实验验证：

• 如果 100% 替换为 [MASK]，下游任务性能下降约 1-2%
• 混合策略在预训练效率和微调性能之间取得最佳平衡

任务二：下一句预测（Next Sentence Prediction, NSP）#

核心思想：判断两个句子是否在原文中连续出现。

具体做法：

1
输入：[CLS] 句子A [SEP] 句子B [SEP]
2
输出：IsNext（连续） 或 NotNext（不连续）

训练数据构造：

• 50% 的样本：句子B确实是句子A的下一句（正样本）
• 50% 的样本：句子B是随机选择的句子（负样本）

目的：让模型学习句子间的关系，有助于问答、自然语言推理等任务。

NSP的输入输出详解：

输入格式：

1
# 正样本示例（IsNext）
2
sentence_A = "今天天气很好"
3
sentence_B = "我们去公园散步吧"  # 原文中的下一句
4

5
# 负样本示例（NotNext）
6
sentence_A = "今天天气很好"
7
sentence_B = "量子计算机的发展很快"  # 随机选择的句子
8

9
# Token化后的输入
10
input_ids = [101, ...sentence_A_ids..., 102, ...sentence_B_ids..., 102]
11
# [CLS] + 句子A + [SEP] + 句子B + [SEP]
12

13
# 输入张量
14
input_ids: [batch_size, seq_length]  # 例如 [32, 256]
15
attention_mask: [batch_size, seq_length]  # 标记有效位置
16
token_type_ids: [batch_size, seq_length]  # 句子A为0，句子B为1
17
# 例如：[0, 0, 0, ..., 0, 1, 1, 1, ..., 1]

BERT处理过程：

1
# BERT编码
2
hidden_states = BERT(input_ids, attention_mask, token_type_ids)
3
# 输出形状：[batch_size, seq_length, hidden_size]
4

5
# 取[CLS]位置的输出（第0个位置）
6
cls_output = hidden_states[:, 0, :]
7
# 形状：[batch_size, hidden_size]
8
# 例如：[32, 768]
9

10
# NSP分类头
11
logits = NSP_head(cls_output)
12
# 形状：[batch_size, 2]  # 2分类：IsNext vs NotNext
13
# 例如：[32, 2]
14

15
# 预测
16
probs = softmax(logits, dim=-1)
17
# probs[:, 0] = P(NotNext)
18
# probs[:, 1] = P(IsNext)

输出格式：

1
# 模型输出
2
outputs = {
3
    'loss': 标量,  # NSP损失
4
    'logits': [batch_size, 2],  # IsNext/NotNext的logits
5
    'prediction': [batch_size],  # 0或1
6
}
7

8
# 预测结果示例
9
prediction = 1  # IsNext（句子B是句子A的下一句）
10
confidence = 0.92  # 置信度

联合训练：

1
# BERT同时训练MLM和NSP
2
total_loss = MLM_loss + NSP_loss
3

4
# 输入
5
input_ids: [batch_size, seq_length]
6
masked_lm_labels: [batch_size, seq_length]  # MLM标签
7
next_sentence_labels: [batch_size]  # NSP标签（0或1）
8

9
# 输出
10
mlm_loss: 标量
11
nsp_loss: 标量
12
total_loss: 标量

NSP任务的争议：真的有用吗？

NSP任务在BERT原论文中被认为是重要的预训练任务，但后续研究对其有效性提出了质疑：

支持NSP的观点：

• 句子间关系对某些任务（如问答、自然语言推理）很重要
• NSP能让模型学习长距离依赖关系
• [CLS] 标记的表征可以捕捉句子对的语义关系

质疑NSP的观点：

• RoBERTa实验（2019）：去除NSP后，性能不降反升

  • 原因：NSP任务可能太简单了
  • 随机选择的句子通常来自不同文档，主题差异明显
  • 模型可能只是学会了”主题分类”，而非真正的句子关系

• ALBERT改进（2019）：用句子顺序预测（SOP）替代NSP

  • SOP任务：判断两个连续句子的顺序是否正确
  • 正样本：A → B（正确顺序）
  • 负样本：B → A（颠倒顺序）
  • 难度更大，因为两个句子来自同一文档，主题相同
  • 实验表明SOP比NSP更有效

当前共识：

• NSP对某些任务有帮助，但不是必需的
• 更重要的是MLM任务和足够的训练数据
• 许多现代预训练模型（如RoBERTa）选择去除NSP
• 如果需要句子关系建模，SOP是更好的选择

关键洞察：预文本任务的设计需要平衡难度——太简单学不到有用信息，太难又无法收敛。

BERT的输入表示#

BERT的输入不是简单的词嵌入，而是三种嵌入的求和：

三种嵌入：

1. Token Embeddings（词嵌入）

   • 将每个词映射到向量空间
   • 词表大小：通常30,000个词
   • 维度：768（BERT-base）或1024（BERT-large）

2. Position Embeddings（位置嵌入）

   • 编码词在句子中的位置信息
   • 与Transformer原论文不同，BERT使用可学习的位置嵌入
   • 最大序列长度：512
   • 每个位置有独立的嵌入向量

3. Segment Embeddings（段落嵌入）

   • 区分句子A和句子B
   • 只有两个向量：$E_A$（句子A）和 $E_B$（句子B）
   • 用于句子对任务（如NSP、自然语言推理）

输入表示公式：

示例：

1
输入：[CLS] 我 爱 深度 学习 [SEP] 它 很 有趣 [SEP]
2

3
Token Emb:    E_[CLS]  E_我  E_爱  E_深度  E_学习  E_[SEP]  E_它  E_很  E_有趣  E_[SEP]
4
Position Emb: E_0      E_1   E_2   E_3     E_4     E_5      E_6   E_7   E_8     E_9
5
Segment Emb:  E_A      E_A   E_A   E_A     E_A     E_A      E_B   E_B   E_B     E_B
6

7
最终输入 = Token Emb + Position Emb + Segment Emb

设计考虑：

• 为什么用可学习位置嵌入？

  • 更灵活，可以适应不同的位置模式
  • 实验表明效果优于固定的正弦位置编码

• 为什么需要Segment Embeddings？

  • 让模型明确知道哪些词属于句子A，哪些属于句子B
  • 对句子对任务至关重要
  • 单句任务中，所有词都使用 $E_A$

特殊标记：

• [CLS]（Classification）：句子级表征，用于分类任务
• [SEP]（Separator）：分隔不同句子
• [MASK]：掩码标记，仅在预训练时使用
• [PAD]：填充标记，用于对齐不同长度的序列

使用场景一：输入为单句子（情感分类）#

任务：判断电影评论的情感（正面/负面）

输入格式：

1
[CLS] 这部电影太精彩了 [SEP]

输出：使用 [CLS] 位置的向量进行分类

1
[CLS] 向量 → 线性层 → Softmax → 正面/负面

详细的输入输出流程：

输入准备：

1
# 原始文本
2
text = "这部电影太精彩了"
3

4
# Token化
5
tokens = ["[CLS]", "这", "部", "电影", "太", "精彩", "了", "[SEP]"]
6
input_ids = [101, 6821, 6956, 4510, 2512, 1922, 4689, 749, 102]
7

8
# 输入张量
9
input_ids: [batch_size, seq_length]  # 例如 [32, 64]
10
attention_mask: [batch_size, seq_length]  # 例如 [32, 64]
11
token_type_ids: [batch_size, seq_length]  # 单句任务全为0
12
labels: [batch_size]  # 例如 [32]，值为0（负面）或1（正面）

BERT编码：

1
# 通过BERT编码
2
outputs = BERT(input_ids, attention_mask, token_type_ids)
3
hidden_states = outputs.last_hidden_state
4
# 形状：[batch_size, seq_length, hidden_size]
5
# 例如：[32, 64, 768]
6

7
# 提取[CLS]位置的表征
8
cls_output = hidden_states[:, 0, :]
9
# 形状：[batch_size, hidden_size]
10
# 例如：[32, 768]

分类头：

1
# 添加分类层
2
logits = classifier(cls_output)
3
# classifier是一个线性层：nn.Linear(768, 2)
4
# 形状：[batch_size, num_classes]
5
# 例如：[32, 2]
6

7
# 计算概率
8
probs = softmax(logits, dim=-1)
9
# probs[:, 0] = P(负面)
10
# probs[:, 1] = P(正面)
11

12
# 预测类别
13
predictions = argmax(probs, dim=-1)
14
# 形状：[batch_size]
15
# 例如：[32]，值为0或1

输出结果：

1
# 完整输出
2
outputs = {
3
    'loss': 标量,  # 交叉熵损失
4
    'logits': [32, 2],  # 原始分数
5
    'probs': [32, 2],  # 概率分布
6
    'predictions': [32],  # 预测类别
7
}
8

9
# 示例结果
10
prediction = 1  # 正面
11
confidence = 0.95  # 置信度

微调方式：

• 在 BERT 之上添加一个简单的分类层
• 使用少量标注数据进行端到端微调
• 整个 BERT 模型的参数都会更新

使用场景二：输入为句子对（自然语言推理）#

任务：判断两个句子的关系（蕴含/矛盾/中立）

输入格式：

1
[CLS] 前提句 [SEP] 假设句 [SEP]

示例：

1
前提：一个人在踢足球
2
假设：一个人在运动
3
关系：蕴含

输出：同样使用 [CLS] 位置的向量进行三分类

详细的输入输出流程：

输入准备：

1
# 原始文本
2
premise = "一个人在踢足球"
3
hypothesis = "一个人在运动"
4

5
# Token化
6
input_ids = [101, ...premise_ids..., 102, ...hypothesis_ids..., 102]
7
# [CLS] + 前提句 + [SEP] + 假设句 + [SEP]
8

9
# 输入张量
10
input_ids: [batch_size, seq_length]  # 例如 [32, 128]
11
attention_mask: [batch_size, seq_length]
12
token_type_ids: [batch_size, seq_length]
13
# token_type_ids: 前提句为0，假设句为1
14
# 例如：[0,0,0,...,0, 1,1,1,...,1]
15

16
labels: [batch_size]  # 0=蕴含, 1=矛盾, 2=中立

BERT处理：

1
# BERT编码
2
hidden_states = BERT(input_ids, attention_mask, token_type_ids)
3
# 形状：[batch_size, seq_length, hidden_size]
4

5
# 提取[CLS]表征
6
cls_output = hidden_states[:, 0, :]
7
# 形状：[batch_size, hidden_size]
8
# 例如：[32, 768]
9

10
# 三分类
11
logits = classifier(cls_output)
12
# classifier: nn.Linear(768, 3)
13
# 形状：[batch_size, 3]
14

15
probs = softmax(logits, dim=-1)
16
# probs[:, 0] = P(蕴含)
17
# probs[:, 1] = P(矛盾)
18
# probs[:, 2] = P(中立)

输出结果：

1
outputs = {
2
    'logits': [32, 3],
3
    'predictions': [32],  # 0, 1, 或 2
4
}
5

6
# 示例
7
prediction = 0  # 蕴含
8
confidence = 0.89

使用场景三：输入为单句子，输出为序列（词性标注）#

任务：为句子中的每个词标注词性

输入格式：

1
[CLS] 我 爱 深度 学习 [SEP]

输出：每个词位置的向量都用于分类

1
我    → 代词
2
爱    → 动词
3
深度  → 形容词
4
学习  → 名词

详细的输入输出流程：

输入准备：

1
# 原始文本
2
text = "我爱深度学习"
3
tokens = ["[CLS]", "我", "爱", "深度", "学习", "[SEP]"]
4

5
# 输入张量
6
input_ids: [batch_size, seq_length]  # 例如 [32, 64]
7
attention_mask: [batch_size, seq_length]
8
labels: [batch_size, seq_length]  # 每个位置的词性标签
9
# 例如：[-100, 3, 5, 2, 1, -100]  # -100表示不计算损失

BERT处理：

1
# BERT编码
2
hidden_states = BERT(input_ids, attention_mask)
3
# 形状：[batch_size, seq_length, hidden_size]
4
# 例如：[32, 64, 768]
5

6
# 对每个位置进行分类
7
logits = token_classifier(hidden_states)
8
# token_classifier: nn.Linear(768, num_tags)
9
# 形状：[batch_size, seq_length, num_tags]
10
# 例如：[32, 64, 20]  # 假设有20种词性
11

12
# 预测每个位置的标签
13
predictions = argmax(logits, dim=-1)
14
# 形状：[batch_size, seq_length]
15
# 例如：[32, 64]

输出结果：

1
outputs = {
2
    'logits': [32, 64, 20],
3
    'predictions': [32, 64],
4
}
5

6
# 示例（忽略[CLS]和[SEP]）
7
tokens = ["我", "爱", "深度", "学习"]
8
predictions = ["代词", "动词", "形容词", "名词"]

微调方式：

• 在每个词的输出向量上添加分类层
• 对每个位置独立进行分类

使用场景四：抽取式问答（Question Answering）#

任务：从文章中抽取答案片段

输入格式：

1
[CLS] 问题 [SEP] 文章 [SEP]

输出：预测答案的起始位置和结束位置

1
文章：爱因斯坦于1879年出生于德国
2
问题：爱因斯坦何时出生？
3
答案：1879年（起始位置=5，结束位置=9）

详细的输入输出流程：

输入准备：

1
# 原始文本
2
question = "爱因斯坦何时出生？"
3
context = "爱因斯坦于1879年出生于德国"
4

5
# Token化
6
input_ids = [101, ...question_ids..., 102, ...context_ids..., 102]
7

8
# 输入张量
9
input_ids: [batch_size, seq_length]  # 例如 [32, 384]
10
attention_mask: [batch_size, seq_length]
11
token_type_ids: [batch_size, seq_length]
12
# token_type_ids: 问题为0，文章为1
13

14
# 标签（答案的位置）
15
start_positions: [batch_size]  # 答案起始位置的索引
16
end_positions: [batch_size]    # 答案结束位置的索引

BERT处理：

1
# BERT编码
2
hidden_states = BERT(input_ids, attention_mask, token_type_ids)
3
# 形状：[batch_size, seq_length, hidden_size]
4
# 例如：[32, 384, 768]
5

6
# 预测起始位置
7
start_logits = start_classifier(hidden_states)
8
# start_classifier: nn.Linear(768, 1)
9
# 形状：[batch_size, seq_length]
10
# 例如：[32, 384]
11

12
# 预测结束位置
13
end_logits = end_classifier(hidden_states)
14
# 形状：[batch_size, seq_length]
15
# 例如：[32, 384]
16

17
# 找到最可能的起始和结束位置
18
start_probs = softmax(start_logits, dim=-1)
19
end_probs = softmax(end_logits, dim=-1)
20

21
start_pos = argmax(start_probs, dim=-1)  # [batch_size]
22
end_pos = argmax(end_probs, dim=-1)      # [batch_size]

输出结果：

1
outputs = {
2
    'start_logits': [32, 384],
3
    'end_logits': [32, 384],
4
    'start_position': [32],
5
    'end_position': [32],
6
}
7

8
# 提取答案
9
answer_tokens = input_ids[start_pos:end_pos+1]
10
answer_text = tokenizer.decode(answer_tokens)
11
# 例如："1879年"

微调方式：

• 训练两个向量：起始位置向量和结束位置向量
• 计算每个位置是起始/结束的概率
• 选择概率最高的区间作为答案

原因一：上下文相关的词向量#

传统词嵌入的问题：

• Word2Vec、GloVe 等方法为每个词生成固定的向量
• 无法处理一词多义现象

示例：

1
句子1：我在银行存钱
2
句子2：我在河岸边散步

在传统词嵌入中，“银行”和”河岸”（bank）得到相同的向量。

BERT的优势：

• 根据上下文动态生成词向量
• 同一个词在不同句子中得到不同的表征
• 自动解决一词多义问题

原因二：注意力的可解释性#

分析方法：可视化注意力权重，理解模型关注什么。

发现：

• 某些注意力头关注语法关系（如主谓关系）
• 某些注意力头关注共指消解（代词指向的实体）
• 某些注意力头关注语义相关性

示例：

1
句子：The animal didn't cross the street because it was too tired.

分析 “it” 的注意力权重，发现模型正确地将 “it” 关联到 “animal”，而非 “street”。

原因三：各层表征的差异#

实验方法：线性探针（Linear Probing）

线性探针是分析自监督模型的重要工具：

• 固定BERT参数：不更新预训练模型的权重
• 训练线性分类器：在某一层的输出上训练一个简单的线性层
• 观察性能：通过分类器的性能判断该层学到了什么信息

这种方法就像用”显微镜”观察BERT的每一层，探测它们学到的知识。

发现：

• 底层（1-4层）：更关注语法信息（词性、句法结构）
  • 线性探针在词性标注任务上表现好
• 中层（5-8层）：捕捉语义信息（词义、句子含义）
  • 线性探针在语义相似度任务上表现好
• 高层（9-12层）：学习任务相关的抽象表征
  • 线性探针在情感分类等任务上表现好

启示：

• 不同任务可能需要不同层的表征
• 可以根据任务特点选择合适的层进行微调
• Linear Probing 是理解和分析预训练模型的重要方法

GLUE是什么？#

定义：

• GLUE是一个多任务基准测试集合
• 包含9个不同的自然语言理解任务
• 涵盖句子分类、句子对关系判断、语义相似度等多个方面
• 由纽约大学、华盛顿大学和DeepMind于2018年提出

目的：

• 提供标准化的评估框架
• 促进不同模型之间的公平比较
• 推动自然语言理解技术的发展
• 避免模型在单一任务上过拟合

GLUE包含的9个任务#

1. CoLA（Corpus of Linguistic Acceptability）

• 任务类型：单句分类
• 目标：判断句子的语法是否正确
• 示例：

  1
  正确："The book was written by John."
  2
  错误："Was written the book by John."

• 评估指标：Matthews相关系数（MCC）

2. SST-2（Stanford Sentiment Treebank）

• 任务类型：单句分类
• 目标：电影评论的情感分类（正面/负面）
• 示例：

  1
  正面："This movie is absolutely fantastic!"
  2
  负面："A complete waste of time."

• 评估指标：准确率（Accuracy）

3. MRPC（Microsoft Research Paraphrase Corpus）

• 任务类型：句子对分类
• 目标：判断两个句子是否语义等价
• 示例：

  1
  句子1："The company will lay off 5,000 workers."
  2
  句子2："5,000 employees will lose their jobs."
  3
  标签：等价

• 评估指标：准确率和F1分数

4. STS-B（Semantic Textual Similarity Benchmark）

• 任务类型：句子对回归
• 目标：预测两个句子的语义相似度（0-5分）
• 示例：

  1
  句子1："A man is playing a guitar."
  2
  句子2："A person is playing music."
  3
  相似度：4.2

• 评估指标：Pearson和Spearman相关系数

5. QQP（Quora Question Pairs）

• 任务类型：句子对分类
• 目标：判断两个问题是否语义相同
• 示例：

  1
  问题1："How do I learn Python?"
  2
  问题2："What's the best way to learn Python?"
  3
  标签：相同

• 评估指标：准确率和F1分数

6. MNLI（Multi-Genre Natural Language Inference）

• 任务类型：句子对分类（3分类）
• 目标：自然语言推理（蕴含/矛盾/中立）
• 示例：

  1
  前提："A man is playing guitar on stage."
  2
  假设："A musician is performing."
  3
  关系：蕴含（Entailment）

• 评估指标：准确率（匹配和不匹配两个测试集）

7. QNLI（Question Natural Language Inference）

• 任务类型：句子对分类
• 目标：判断段落是否包含问题的答案
• 示例：

  1
  问题："When was the university founded?"
  2
  段落："The university was established in 1850."
  3
  标签：包含答案

• 评估指标：准确率

8. RTE（Recognizing Textual Entailment）

• 任务类型：句子对分类（2分类）
• 目标：判断是否存在文本蕴含关系
• 示例：

  1
  文本1："Google acquired YouTube."
  2
  文本2："YouTube is owned by Google."
  3
  标签：蕴含

• 评估指标：准确率

9. WNLI（Winograd Natural Language Inference）

• 任务类型：句子对分类
• 目标：代词消歧和常识推理
• 示例：

  1
  句子："The trophy doesn't fit in the suitcase because it's too big."
  2
  问题："it"指的是trophy还是suitcase？

• 评估指标：准确率
• 注意：这是GLUE中最难的任务，很多模型表现不佳

GLUE评分机制#

总分计算：

• GLUE总分是所有任务得分的平均值
• 每个任务使用其特定的评估指标
• 归一化到0-100的范围

基准对比：

1
人类表现（Human Baseline）：87.1
2
BERT-Large（2018）：80.5
3
RoBERTa-Large（2019）：88.5
4
ALBERT-xxlarge（2019）：89.4

BERT在GLUE上的突破性表现#

历史意义：

• BERT首次让预训练模型在GLUE上接近人类水平
• 在8个任务上创造了新的SOTA（State-of-the-Art）
• 证明了预训练-微调范式的有效性

性能对比：

关键发现：

1. 模型规模的影响：BERT-Large比BERT-Base平均提升2.2分
2. 预训练的重要性：预训练显著提升了所有任务的性能
3. 迁移学习的有效性：同一个预训练模型可以适应多种不同任务

GLUE的意义与局限#

重要意义：

• 标准化评估：提供统一的评估框架，避免cherry-picking
• 多任务覆盖：涵盖多种语言理解能力，全面评估模型
• 推动进步：激励研究者开发更强大的模型
• 公平比较：相同的数据集和评估指标，确保可比性

已知局限：

• 任务规模：部分任务的训练集较小（如RTE只有2.5k样本）
• 难度饱和：顶级模型已接近或超过人类表现，区分度下降
• 评估范围：未涵盖所有NLP能力（如生成、推理、常识等）
• 数据泄露风险：大规模预训练可能见过测试集相似数据

后续发展：

• SuperGLUE（2019）：更难的任务集合，包含更具挑战性的任务
• XTREME：跨语言评估基准
• BigBench：包含200+任务的大规模基准

关键洞察：

• GLUE是评估预训练模型的重要工具，但不是唯一标准
• 高GLUE分数不等于模型在所有场景下都表现优秀
• 需要结合实际应用场景进行综合评估

RoBERTa（Robustly Optimized BERT）#

改进：

• 去除NSP任务：实验发现NSP任务帮助不大
• 更大的批量：从256增加到8192
• 更多的数据：训练数据量增加10倍
• 更长的训练：训练步数大幅增加

结果：在多个任务上超越BERT

ALBERT（A Lite BERT）#

目标：减少参数量，提升训练效率

改进：

• 参数共享：所有层共享参数
• 嵌入矩阵分解：将大的嵌入矩阵分解为两个小矩阵
• 句子顺序预测：用SOP（Sentence Order Prediction）替代NSP

结果：参数量减少18倍，性能相当甚至更好

DistilBERT#

目标：通过知识蒸馏压缩模型

方法：

• 使用BERT作为教师模型
• 训练一个更小的学生模型（6层）
• 学生模型学习教师模型的输出分布

结果：

• 参数量减少40%
• 速度提升60%
• 性能保留97%

Multilingual BERT（多语言BERT）#

神奇现象：跨语言的通用语义空间

BERT展现出一个令人惊讶的能力：

实验发现：

• 用英文预训练的BERT，没有见过中文数据
• 但在中文任务上也能取得一定效果
• 说明BERT学到了跨语言的通用语义表征

多语言BERT（mBERT）：

• 在104种语言的数据上预训练
• 不同语言的相似概念在表征空间中靠近
• 支持零样本跨语言迁移（Zero-shot Cross-lingual Transfer）

示例：

1
英文训练：The cat sits on the mat.
2
中文测试：猫坐在垫子上。
3
→ mBERT能识别出两者语义相似

关键洞察：

• 语言的底层语义结构是相通的
• 自监督学习能够发现这种通用结构
• 为跨语言NLP任务提供了强大基础

因果自注意力（Causal Self-Attention）的实现#

GPT的单向特性是通过因果自注意力机制实现的，这是与BERT最核心的架构差异。

标准自注意力（BERT使用）：

每个位置可以关注所有位置（包括左边和右边）。

因果自注意力（GPT使用）：

其中 $M$ 是因果掩码矩阵（Causal Mask）：

参数说明：

• $i$：查询位置（当前词）
• $j$：键位置（被关注的词）
• $i \geq j$：只能关注当前位置及之前的位置
• $-\infty$：经过softmax后变为0，完全屏蔽未来信息

可视化示例：

对于句子”我 爱 深度 学习”，注意力掩码矩阵为：

1
       我  爱  深度  学习
2
我    [0  -∞  -∞   -∞]
3
爱    [0   0  -∞   -∞]
4
深度  [0   0   0   -∞]
5
学习  [0   0   0    0]

解释：

• “我”只能看到”我”自己
• “爱”可以看到”我”和”爱”
• “深度”可以看到”我”、“爱”、“深度”
• “学习”可以看到所有前面的词

实现细节：

1
def causal_attention_mask(seq_len):
2
    """生成因果注意力掩码"""
3
    # 创建上三角矩阵（不包括对角线）
4
    mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1)
5
    # 将1替换为-inf，0保持不变
6
    mask = mask.masked_fill(mask == 1, float('-inf'))
7
    return mask
8

9
# 使用示例
10
seq_len = 4
11
mask = causal_attention_mask(seq_len)
12
# 输出：
13
# [[0., -inf, -inf, -inf],
14
#  [0., 0., -inf, -inf],
15
#  [0., 0., 0., -inf],
16
#  [0., 0., 0., 0.]]

为什么用 -∞ 而不是 0？

• 掩码加在softmax之前的logits上
• $\text{softmax}(-\infty) = 0$，完全屏蔽
• 如果直接用0，softmax后仍有非零概率

训练与推理的一致性：

• 训练时：并行计算，一次性预测所有位置，但每个位置只能看到之前的内容
• 推理时：逐词生成，自然只能看到已生成的内容
• 因果掩码保证了训练和推理的一致性

规模定律（Scaling Law）的直观理解#

规模定律是GPT系列成功的核心发现之一，揭示了模型性能与规模之间的可预测关系。

核心发现（OpenAI，2020）：

模型的损失（Loss）与三个因素呈现幂律关系：

参数说明：

• $L$：测试集上的损失（越小越好）
• $N$：模型参数量（Number of parameters）
• $D$：训练数据量（Dataset size）
• $C$：计算量（Compute budget，FLOPs）
• $\alpha, \beta, \gamma$：幂律指数（实验测定）

关键结论：

1. 平滑可预测：性能提升遵循平滑的幂律曲线，不是随机的

   • 可以通过小规模实验预测大规模模型的性能
   • 为模型设计和资源分配提供指导

2. 三要素协同：模型大小、数据量、计算量需要协调增长

   • 只增加模型大小而不增加数据，效果有限
   • 只增加数据而不增加模型容量，也无法充分利用
   • 最优策略：三者同步扩展

3. 无饱和迹象：在实验范围内，性能持续提升

   • GPT-3（175B参数）仍未达到性能上限
   • 更大的模型（如GPT-4）继续验证这一规律

直观理解：

为什么模型越大越好？

• 容量假说：更大的模型有更多参数，可以存储更多知识
• 类比：就像更大的图书馆可以存放更多书籍
• 数学视角：参数空间更大，可以拟合更复杂的函数

为什么数据越多越好？

• 泛化假说：更多数据提供更丰富的模式，减少过拟合
• 类比：见过更多例子的学生，考试时更不容易遇到完全陌生的题
• 数学视角：更好地逼近真实数据分布 $p(x)$

为什么会有涌现能力？

• 相变现象：当模型规模超过某个临界点，新能力突然出现
• 示例：
  • GPT-2（1.5B）：基本的文本生成
  • GPT-3（175B）：上下文学习、推理、代码生成
• 解释：某些复杂任务需要最小的模型容量才能完成

实际数据：

启示：

• 工程实践：投资更大的模型和更多数据是值得的
• 研究方向：理解规模定律的理论基础
• 未来展望：规模定律能持续多久？是否存在物理极限？

局限性：

• 规模定律主要适用于语言建模损失，不一定直接对应下游任务性能
• 计算成本随规模指数增长，存在经济和环境成本
• 更大不一定总是更好，需要考虑效率和可解释性

上下文学习（In-Context Learning）详解#

这是GPT-3最令人惊讶的能力之一：

核心思想：通过Prompt（提示）激发模型已有的知识，而非微调模型参数。

零样本学习（Zero-shot）：

1
Prompt: 将下面的英文翻译成中文：
2
Hello, how are you?
3
翻译：

模型直接输出：你好，你好吗？

少样本学习（Few-shot）：

1
Prompt:
2
英文：Good morning
3
中文：早上好
4

5
英文：Thank you
6
中文：谢谢
7

8
英文：Hello, how are you?
9
中文：

模型通过几个示例就能理解任务，输出：你好，你好吗？

关键机制：

• 不更新参数：模型权重保持不变
• Prompt设计：通过精心设计的提示词引导模型
• 上下文理解：模型从示例中推断任务模式
• 知识激发：唤醒预训练时学到的知识

为什么有效？

• GPT在预训练时见过大量”模式识别”的例子
• 通过自回归预测，学会了从上下文推断规律
• 大规模模型有足够的容量存储和调用知识

与微调的对比：

这种能力展示了大规模语言模型的”智能涌现”——当模型足够大时，会自然出现训练时未明确优化的能力。

MAE的非对称编码器-解码器设计#

MAE的另一个关键创新是非对称架构，这与传统自编码器有本质区别。

传统自编码器（对称设计）：

1
输入 → 编码器（大） → 潜在表征 → 解码器（大） → 输出

• 编码器和解码器规模相当
• 处理所有输入数据

MAE（非对称设计）：

1
可见patch → 编码器（大，ViT-Large） → 表征
2
                                        ↓
3
遮蔽patch + 表征 → 解码器（小，8层Transformer） → 重建

关键设计决策：

1. 编码器只处理可见patch

动机：

• 如果编码器处理所有patch（包括mask token），计算量巨大
• 75%遮蔽意味着75%的计算是在处理无信息的mask token
• 这是巨大的浪费

实现：

• 输入：只有可见的25% patch（64个patch）
• 编码器：标准ViT-Large（24层，1024维）
• 输出：64个patch的表征

好处：

• 计算量减少约75%（只处理25%的patch）
• 训练速度提升3-4倍
• 使得大规模预训练变得可行

2. 解码器处理所有patch

动机：

• 解码器需要重建所有被遮蔽的patch
• 必须处理完整的patch序列（256个）

实现：

• 输入：编码器输出（64个） + mask tokens（192个）
• 解码器：轻量级Transformer（8层，512维）
• 输出：256个patch的像素重建

为什么解码器可以很小？

• 解码器只在预训练时使用，微调时丢弃
• 重建任务相对简单（像素级预测）
• 编码器已经学到了高层语义，解码器只需”填充细节”

3. 架构对比

数学形式化：

编码阶段：

参数说明：

• $\mathbf{X}_{\text{vis}} \in \mathbb{R}^{N_{\text{vis}} \times D}$：可见patch（$N_{\text{vis}} = 64$）
• $\mathbf{Z}_{\text{vis}} \in \mathbb{R}^{N_{\text{vis}} \times D_{\text{enc}}}$：编码器输出（$D_{\text{enc}} = 1024$）

解码阶段：

参数说明：

• $\mathbf{M}_{\text{mask}} \in \mathbb{R}^{N_{\text{mask}} \times D_{\text{enc}}}$：可学习的mask tokens（$N_{\text{mask}} = 192$）
• $[\cdot; \cdot]$：拼接操作
• $\mathbf{X}_{\text{recon}} \in \mathbb{R}^{N \times P^2 \times 3}$：重建的所有patch（$N = 256$）

重建损失：

关键：只计算被遮蔽patch的重建损失，不计算可见patch。

为什么这个设计如此有效？

1. 计算效率：

• 编码器处理25%数据，解码器虽然处理100%但很小
• 总计算量远小于对称设计
• 使得在ImageNet上预训练只需几天（而非几周）

2. 表征质量：

• 编码器专注于从稀疏信息中提取语义
• 强制学习全局理解，而非局部纹理
• 学到的表征更适合下游任务

3. 训练稳定性：

• 解码器轻量，不会主导训练
• 避免了”解码器过拟合”问题
• 编码器学到的表征更通用

实验验证：

关键洞察：

• 非对称设计是MAE成功的关键
• 它平衡了计算效率和表征质量
• 这个设计思想可以推广到其他模态（如视频、音频）

CLIP的双编码器架构详解#

CLIP采用对称的双编码器设计，分别处理图像和文本，然后在共享的嵌入空间中进行对比学习。

架构组成：

1. 图像编码器（Image Encoder）

• 架构选择：Vision Transformer (ViT) 或 ResNet
• 输入：图像 $I \in \mathbb{R}^{H \times W \times 3}$
• 输出：图像嵌入 $\mathbf{v}_I \in \mathbb{R}^d$

2. 文本编码器（Text Encoder）

• 架构选择：Transformer（类似GPT）
• 输入：文本描述 $T$（token序列）
• 输出：文本嵌入 $\mathbf{v}_T \in \mathbb{R}^d$

3. 投影到共享空间

• 两个编码器的输出都投影到相同维度的嵌入空间
• 典型维度：$d = 512$ 或 $1024$
• 嵌入向量经过L2归一化

数学形式化：

编码过程：

参数说明：

• $f_I$：图像编码器
• $f_T$：文本编码器
• 归一化后的向量模长为1，位于单位超球面上

对比学习目标：

给定一个batch的 $N$ 个图像-文本对 $\{(I_i, T_i)\}_{i=1}^N$：

相似度矩阵：

其中 $\tau$ 是可学习的温度参数。

对比损失（双向）：

图像到文本方向：

文本到图像方向：

总损失：

直观理解：

训练时：

1
Batch中的N个样本：
2
(图像1, 文本1) ✓ 匹配
3
(图像2, 文本2) ✓ 匹配
4
...
5
(图像N, 文本N) ✓ 匹配
6

7
目标：
8
- 拉近匹配对：(图像1, 文本1)
9
- 推远不匹配对：(图像1, 文本2), (图像1, 文本3), ...

推理时（Zero-shot分类）：

1
给定图像和K个类别：
2
1. 为每个类别生成文本提示："a photo of a {类别}"
3
2. 编码图像和所有文本提示
4
3. 计算相似度，选择最高的类别
5

6
示例：
7
图像：一只猫的照片
8
文本提示：
9
  - "a photo of a cat" → 相似度 0.85 ✓
10
  - "a photo of a dog" → 相似度 0.23
11
  - "a photo of a car" → 相似度 0.12
12
预测：cat