Lecture 07: BERT 与评测基准

核心主题：GLUE/SuperGLUE 基准、BERT vs GPT zero-shot 评测、HLE、ARC-AGI-3

1. 模型架构分类

2. Zero-Shot 评测策略

2.1 BERT — Fill-Mask Scoring

模板：

# Template: "{sentence} It was [MASK]."
# Compare P("great") vs P("terrible") for sentiment

from transformers import pipeline
unmasker = pipeline("fill-mask", model="bert-base-uncased")

text = "This movie was amazing. It was [MASK]."
results = unmasker(text)
# 比较 "great" 和 "terrible" 的概率

2.2 GPT-2 — Likelihood Scoring

核心思路：计算每个候选标签的条件对数概率，选择最高者。

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer

model = GPT2LMHeadModel.from_pretrained("gpt2")
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")

def score_sequence(prompt, label):
    """计算 label 在 prompt 条件下的对数概率"""
    input_text = prompt + " " + label
    input_ids = tokenizer.encode(input_text, return_tensors="pt")
    prompt_len = len(tokenizer.encode(prompt))
    
    with torch.no_grad():
        outputs = model(input_ids)
        logits = outputs.logits  # (1, seq_len, vocab_size)
    
    log_probs = torch.log_softmax(logits, dim=-1)
    # 只计算 label tokens 的对数概率
    label_log_prob = 0.0
    for i in range(prompt_len - 1, input_ids.shape[1] - 1):
        next_token = input_ids[0, i + 1]
        label_log_prob += log_probs[0, i, next_token].item()
    
    return label_log_prob

2.3 Instruction-tuned (Qwen3) — Chat Format

核心思路：利用 chat template 格式化输入，比较 label token 的 logits。

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

messages = [
    {"role": "user", "content": "Classify sentiment: 'This movie is great.' Answer: positive or negative?"}
]

input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
input_ids = tokenizer(input_text, return_tensors="pt").input_ids

with torch.no_grad():
    logits = model(input_ids).logits[0, -1, :]  # 最后一个位置

# 比较 "positive" 和 "negative" 对应 token 的 logit
pos_id = tokenizer.encode("positive", add_special_tokens=False)[0]
neg_id = tokenizer.encode("negative", add_special_tokens=False)[0]
prediction = "positive" if logits[pos_id] > logits[neg_id] else "negative"

3. GLUE 基准详解 ⭐

GLUE (General Language Understanding Evaluation) 是 NLU 评测的标准基准，包含 9 个子任务。

3.1 单句任务 (Single-Sentence Tasks)

3.2 相似/释义任务 (Similarity & Paraphrase Tasks)

3.3 推理任务 (Inference Tasks)

4. Zero-Shot 实验结果 ⭐⭐

4.1 SST-2 (情感分类)

4.2 MRPC (释义检测)

4.3 RTE (文本蕴含)

4.4 MNLI (多体裁自然语言推理)

5. 关键发现

5.1 BERT 在 Zero-Shot 下几乎无用

• 所有任务接近随机水平 (binary ~0.5, ternary ~0.33)
• Scale (base → large) 几乎不改善 zero-shot 性能
• 原因：BERT 的 MLM 预训练目标与下游分类任务不直接对齐

5.2 Instruction Tuning + Scale = 强 Zero-Shot

• Qwen3-1.7B 在所有任务上显著超越其他模型
• Instruction tuning 提供了任务理解能力
• Scale 放大了这种能力

5.3 架构适用性

6. HLE (Humanity's Last Exam)

6.1 基本信息

• 规模：约 2500 道题目
• 难度：PhD 级别，跨学科
• 目标：测试 AI 在人类最难学术问题上的能力
• 格式：多选题 + 开放问答

6.2 难度表现

6.3 评测格式

7. ARC-AGI-3

7.1 基本信息

• 类型：交互式推理基准 (Interactive Benchmark)
• 设计：测试抽象推理与模式归纳能力
• 格式：给定输入-输出网格对，推断变换规则并应用到新输入
• 特点：每道题的规则都是全新的，无法靠记忆解决

7.2 实验结果

8. 基准难度层级

┌─────────────────────────────────────────────────────────────────┐
│                    NLU 基准难度层级                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  GLUE          →    SuperGLUE      →    HLE         → ARC-AGI-3│
│  (基础 NLU)         (更难 NLU)          (PhD 级别)     (抽象推理)│
│                                                                 │
│  已饱和              接近饱和            GPT-4 ~5%     所有模型 0%│
│  BERT fine-tune     需要更大模型         极其困难       未解决    │
│  可达 ~90%+         ~90%+                                       │
│                                                                 │
│  ◀──────────── 难度递增 ──────────────────────────────────────▶  │
│  ◀──────────── 从语言理解 → 深度推理 ────────────────────────▶  │
└─────────────────────────────────────────────────────────────────┘

9. 评测方法论

9.1 指标选择

9.2 Likelihood Scoring 完整实现

import torch
import torch.nn.functional as F
from transformers import AutoModelForCausalLM, AutoTokenizer

def likelihood_scoring(model, tokenizer, prompt, candidates):
    """
    对候选标签进行 likelihood scoring
    
    Args:
        model: 语言模型
        tokenizer: 分词器
        prompt: 输入文本
        candidates: 候选标签列表, e.g. ["positive", "negative"]
    
    Returns:
        best_candidate: 得分最高的候选标签
        scores: 所有候选的分数字典
    """
    scores = {}
    
    for candidate in candidates:
        # 拼接 prompt 和候选标签
        full_text = prompt + " " + candidate
        input_ids = tokenizer.encode(full_text, return_tensors="pt")
        prompt_ids = tokenizer.encode(prompt, return_tensors="pt")
        prompt_len = prompt_ids.shape[1]
        
        with torch.no_grad():
            outputs = model(input_ids)
            logits = outputs.logits  # (1, seq_len, vocab_size)
        
        # 计算 label tokens 的平均对数概率
        log_probs = F.log_softmax(logits, dim=-1)
        total_log_prob = 0.0
        num_tokens = 0
        
        for i in range(prompt_len - 1, input_ids.shape[1] - 1):
            next_token_id = input_ids[0, i + 1]
            total_log_prob += log_probs[0, i, next_token_id].item()
            num_tokens += 1
        
        # 长度归一化
        scores[candidate] = total_log_prob / num_tokens if num_tokens > 0 else float('-inf')
    
    best_candidate = max(scores, key=scores.get)
    return best_candidate, scores

# 使用示例
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

prompt = "The movie was fantastic. The sentiment is"
candidates = ["positive", "negative"]
prediction, scores = likelihood_scoring(model, tokenizer, prompt, candidates)
print(f"Prediction: {prediction}")
print(f"Scores: {scores}")

核心要点总结