Final Project 实战完全指南

📝 Proposal 模板（直接 copy 改）

1. Motivation (3-5 句)
   - 任务是什么；为什么值得做；现状什么样
2. Key Paper Summary (1 段)
   - 引用核心论文 + 它的 setup / 贡献 / 局限
3. Proposed Approach (1 段)
   - 你打算怎么做（具体到模型类型、损失、训练流程）
   - 标出 "我们的创新点是 …"
4. Data & Preprocessing (短表格 + 1 段)
   - 数据集名、规模、source、license、所需预处理
5. Evaluation Plan (短表格)
   - 指标（accuracy / BLEU / ROUGE / F1 / human eval）
   - Baseline（一定要列具体名字 + 论文里的数字）
   - 计划做的 ablation
6. Milestone (2-3 句)
   - "到 Feb 24 我们将完成 X，得到初步结果 Y"
7. References (BibTeX 风格)

📑 报告 8 段标准写法

案例 1：Deep Poetry — Word + Char LM 生成莎士比亚十四行诗（Xie, Rastogi, Chang）

• 类型：新变体模型（type 3）
• 方法：Gated LSTM，把 char-level 和 word-level 两路向量按可学习 gate 融合 — $(1-g_{w_t}) x^{\text{word}}_{w_t} + g_{w_t} x^{\text{char}}_{w_t}$
• 为什么 strong：明确动机（莎士比亚词汇罕见，char-level 能 backoff）+ 完整定性输出 + 工程实现清晰
• 2026 借鉴：相同的"两路融合"思想现在用在 mixture-of-experts、tokenizer-free LM (Byte Latent Transformer 2024) 上

案例 2：Differentiable Neural Computer (DNC) 实现 — Carol Hsin

• 类型：复杂架构实现（type 2）
• 价值：DNC 论文（Graves et al. 2016 Nature）实现极难且没开源；学生重新实现 + 在 bAbI + copy task 上验证
• 为什么 strong：选择了"硬骨头"，文档化优化挑战的过程本身就有价值
• 2026 视角：DNC 思路在现代"长记忆 LLM"（Memorizing Transformer、RecurrentGemma、Titans 2024）里复活

案例 3：Improved Learning through Augmenting the Loss — Inan & Khosravi → ICLR 2017

• 类型：新方法（type 3）
• 贡献：(a) tied embeddings，(b) 用 word embedding 相似度做 label smoothing
• 为什么变成 ICLR 论文：方法简单 + 在 Penn Treebank 上 SOTA + ablation 干净
• 对你的启示：项目→顶会论文的最短路径，往往是"loss / training 上的小但有效的改动"

案例 4：ConCoRD — 两组 CS224N 项目合并 → EMNLP 2022

• 类型：应用 + 新方法（type 1 + 3）
• 动机：QA 模型对"麻雀是鸟吗""鸟有脚吗""麻雀有脚吗"会自相矛盾
• 方法：sample 候选答案 → 用 NLI 模型估计两两 entailment/contradiction → MaxSAT 求最优一致赋值
• 2026 视角：相同思想现在叫 self-consistency（Wang et al. 2022），是 reasoning 的关键技巧之一

🐍 单卡训练循环（最小可用版）

import torch, math, time, os, json
from torch.utils.data import DataLoader
from torch.optim import AdamW
from torch.optim.lr_scheduler import LambdaLR
from torch.cuda.amp import autocast, GradScaler

# ---------- config ----------
cfg = dict(
    lr=3e-4, weight_decay=0.1, betas=(0.9, 0.95), eps=1e-8,
    warmup=500, total_steps=10_000,
    grad_accum=4, grad_clip=1.0,
    bf16=True,                       # H100/A100 推荐 BF16
    log_every=20, eval_every=500, save_every=2000,
    out_dir="runs/exp01",
)
os.makedirs(cfg["out_dir"], exist_ok=True)
device = "cuda"

# ---------- model / data ----------
model = build_model().to(device)
train_loader = DataLoader(train_ds, batch_size=8, shuffle=True,
                          num_workers=4, pin_memory=True, drop_last=True)

# ---------- optimizer ----------
# 标准做法：bias 和 LayerNorm 不加 weight decay
decay, no_decay = [], []
for n, p in model.named_parameters():
    if not p.requires_grad: continue
    (no_decay if p.ndim < 2 or "bias" in n else decay).append(p)
optim = AdamW(
    [{"params": decay,    "weight_decay": cfg["weight_decay"]},
     {"params": no_decay, "weight_decay": 0.0}],
    lr=cfg["lr"], betas=cfg["betas"], eps=cfg["eps"], fused=True,
)

# ---------- lr schedule: linear warmup + cosine ----------
def lr_lambda(step):
    if step < cfg["warmup"]:
        return step / max(1, cfg["warmup"])
    progress = (step - cfg["warmup"]) / max(1, cfg["total_steps"] - cfg["warmup"])
    return 0.5 * (1 + math.cos(math.pi * progress))
sched = LambdaLR(optim, lr_lambda)

# ---------- AMP ----------
dtype = torch.bfloat16 if cfg["bf16"] else torch.float16
scaler = GradScaler(enabled=not cfg["bf16"])   # BF16 不需要 loss scaling

# ---------- loop ----------
step, micro = 0, 0
model.train()
t0 = time.time()
for epoch in range(99):
    for batch in train_loader:
        batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}

        with autocast(dtype=dtype):
            out = model(**batch)
            loss = out.loss / cfg["grad_accum"]    # 平均

        if cfg["bf16"]:
            loss.backward()
        else:
            scaler.scale(loss).backward()

        micro += 1
        if micro % cfg["grad_accum"] != 0:
            continue

        # ---- 梯度裁剪 + step ----
        if cfg["bf16"]:
            torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["grad_clip"])
            optim.step()
        else:
            scaler.unscale_(optim)
            torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["grad_clip"])
            scaler.step(optim)
            scaler.update()
        sched.step()
        optim.zero_grad(set_to_none=True)

        step += 1
        if step % cfg["log_every"] == 0:
            tok_s = step * cfg["grad_accum"] * 8 * 1024 / (time.time() - t0)
            print(f"step {step}  loss {out.loss.item():.4f}  "
                  f"lr {sched.get_last_lr()[0]:.2e}  tok/s {tok_s:.0f}")
        if step % cfg["save_every"] == 0:
            torch.save({"model": model.state_dict(), "step": step},
                       f"{cfg['out_dir']}/ckpt_{step}.pt")
        if step >= cfg["total_steps"]: raise SystemExit

📊 W&B 三行集成

import wandb
wandb.init(project="cs224n-fp", name="exp01-lora-r8", config=cfg)

# 训练循环里
wandb.log({"loss": loss.item(), "lr": sched.get_last_lr()[0], "step": step})
# 评估循环里
wandb.log({"eval/acc": acc, "eval/ppl": math.exp(eval_loss)})

🤗 完整 SFT 脚本（accelerate 启动）

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from trl import SFTTrainer
from datasets import load_dataset

model_name = "Qwen/Qwen2.5-1.5B-Instruct"
tok = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name, torch_dtype="bfloat16", attn_implementation="flash_attention_2")

ds = load_dataset("HuggingFaceH4/ultrachat_200k", split="train_sft[:5000]")

args = TrainingArguments(
    output_dir="out/qwen-sft", num_train_epochs=2,
    per_device_train_batch_size=2, gradient_accumulation_steps=8,
    learning_rate=2e-5, warmup_ratio=0.03, lr_scheduler_type="cosine",
    bf16=True, gradient_checkpointing=True,
    logging_steps=10, save_steps=500,
    report_to="wandb", run_name="qwen-sft-v1",
)

trainer = SFTTrainer(
    model=model, tokenizer=tok, args=args,
    train_dataset=ds, max_seq_length=2048,
    dataset_text_field="messages",          # 自动 apply chat template
)
trainer.train()
trainer.save_model()

启动：accelerate launch --num_processes 4 sft.py（4 卡 DDP 自动并行）。

🧪 PEFT-LoRA 8 行接入

from peft import LoraConfig, get_peft_model
peft_cfg = LoraConfig(
    r=16, lora_alpha=32, lora_dropout=0.05, bias="none",
    target_modules=["q_proj","k_proj","v_proj","o_proj"],   # LLaMA / Qwen
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, peft_cfg)
model.print_trainable_parameters()
# trainable: 8.4M  ||  all params: 1.5B  ||  trainable%: 0.55

🚀 vLLM 离线批推理

from vllm import LLM, SamplingParams
llm = LLM(model="Qwen/Qwen2.5-7B-Instruct", tensor_parallel_size=2,
          dtype="bfloat16", max_model_len=8192,
          gpu_memory_utilization=0.9)
sp = SamplingParams(temperature=0.7, top_p=0.9, max_tokens=512)
outs = llm.generate(prompts=batch_of_prompts, sampling_params=sp)
for o in outs: print(o.outputs[0].text)

📦 一个可复现的实验目录长什么样

runs/exp01_lora-qwen1.5/
├── config.yaml          # 全部超参（含 seed）
├── git_info.txt         # git rev-parse HEAD + diff
├── env.txt              # pip freeze
├── train.log            # 完整 stdout
├── wandb_url.txt        # W&B run URL
├── ckpt/
│   ├── step_500.pt
│   ├── step_1000.pt
│   └── best.pt          # 按 dev 指标
├── eval/
│   ├── dev_preds.jsonl  # {input, gold, pred, score}
│   └── dev_metrics.json
└── README.md            # 一段话写清楚: 我做了什么、结果如何

🔬 几个 2024-25 值得了解的 benchmark（讲义只提了 4 个）

• SWE-bench (Jimenez et al. 2024)：从真实 GitHub issue + PR 构造的 bug-fix 基准。模型要读懂 repo 并提交可通过 unit test 的 patch。SWE-bench Verified（人工标注的 500 题子集）是 2024-25 主流。
• WebArena (Zhou et al. 2023)：在自托管的 OneStopShop / GitLab / Reddit 镜像里完成真实 web 任务，端到端评估 agent。
• TruthfulQA (Lin et al. 2022)：817 道"人类常错"的题（"咳嗽能止心脏病吗？"），测模型有没有学到人类偏见。
• Egonormia (Rezaei et al. 2025)：从 ego-centric video 测社交规范判断（"你应该接住朋友的鞋还是让他自己捡？"）。

🧹 文本数据 6 步清洗模板

import re, hashlib
from datasets import load_dataset

def clean_text(s: str) -> str:
    s = re.sub(r"\s+", " ", s).strip()      # 1. normalize whitespace
    s = re.sub(r"http\S+|www\.\S+", "", s)  # 2. drop URLs（任务允许时）
    s = "".join(c for c in s if c.isprintable())   # 3. 控制字符
    return s

def is_quality(s: str) -> bool:
    if len(s.split()) < 20: return False           # 4. 过短
    if len(set(s)) / len(s) < 0.05: return False   # 5. 重复字符
    return True

seen = set()
def dedup(s: str) -> bool:                          # 6. MinHash / 简化版 hash dedup
    h = hashlib.md5(s.encode()).hexdigest()[:16]
    if h in seen: return False
    seen.add(h); return True

ds = load_dataset("your-dataset")
ds = ds.map(lambda x: {"text": clean_text(x["text"])})
ds = ds.filter(lambda x: is_quality(x["text"]) and dedup(x["text"]))

🔍 错误分析五步法

1. 抽样 50-100 个错例（uniformly from dev set）。直接看模型 input + gold + pred。
2. 开个 Google Sheet，每行一个错例，自己定义 5-10 个 error 类别打 tag。
3. 统计各类比例：长尾分布常见（例如 60% 错例属于同一类）。
4. 定向修复 head 类别：把数据增强 / loss 函数 / 后处理对准最大那 1-2 类。
5. 重新评估 + 报告：在 report 里贴出 "before/after error breakdown" 表 —— 这是研究品味的体现。

DFP-1：用 LoRA + 4-bit 把 GPT-2 蒸成 7M 可训练参数

• 动机：原 starter code 全参微调，验证 PEFT 能不能不掉点
• 方法：QLoRA (r=16) + bitsandbytes 4-bit；对 attn 的 q/k/v/o 加 LoRA
• 数据：DFP 默认三任务（情感 + 改写 + 十四行诗）
• 评估：与 full FT 在每个任务上对比 ± 显存 / 训练时长 trade-off
• 难度：⭐⭐

DFP-2：Sonnet generation 加 RLHF/DPO（让"诗更莎士比亚"）

• 动机：生成质量是主观的，cross-entropy 不能反映"风格契合度"
• 方法：标 200 对偏好（mine 自动生成 vs Shakespeare 原作），用 DPO 微调
• 数据：Shakespeare sonnet corpus + 自合成偏好
• 评估：押韵率 / 五步抑扬 / 人工评 + LLM-as-judge
• 难度：⭐⭐⭐

DFP-3：替换 attention 为 SSM / Mamba 看长上下文

• 动机：自己实现一个非 quadratic attention 替代
• 方法：把 GPT-2 一半层换成 Mamba block，混合架构
• 数据：WikiText-103；测 perplexity 在不同长度下的曲线
• 评估：perplexity vs context length；显存 vs context length
• 难度：⭐⭐⭐⭐

DFP-4：情感分类的对抗鲁棒性

• 动机：fine-tune 后 in-domain 准确率高，OOD 怎样？
• 方法：训 baseline + FreeLB / 对抗数据增强
• 数据：训 Rotten Tomatoes，测 IMDB、Yelp、Amazon、SST-2
• 评估：OOD acc + checklist (Ribeiro 2020) 行为测试
• 难度：⭐⭐⭐

DFP-5：Decoding 策略比较（greedy / top-k / top-p / contrastive / speculative）

• 动机：所有人都用 top-p=0.9，但有更好的吗？
• 方法：在 sonnet 生成上对比 6 种 decoding，加 speculative decoding 加速
• 数据：DFP sonnet 任务
• 评估：质量（人工 + judge）+ 多样性（distinct-n）+ tokens/sec
• 难度：⭐⭐

CFP-1：Agents — 对比 ReAct vs Reflexion 在 τ-Bench 的 cost-success tradeoff

• 动机：多步 agent 框架的实际收益 vs cost 没有统一对比
• 方法：用 Qwen2.5-7B-Instruct 作 backbone，跑 3 个开源 agent 框架
• 数据：τ-Bench retail / airline 任务
• 评估：success rate, cost/task, # tool calls, # tokens
• 难度：⭐⭐⭐

CFP-2：Reasoning — 在 1.5B 模型上复现 RLVR/GRPO，研究 reward shape

• 动机：DeepSeek-R1 证明纯 RL 可以 emerge reasoning，但什么 reward 设计最关键？
• 方法：Qwen2.5-1.5B + GRPO + verifiable reward；对比 binary vs format-aware reward
• 数据：GSM8K-1k 子集
• 评估：MATH-500 / AIME; emergence curve
• 难度：⭐⭐⭐⭐

CFP-3：Sycophancy — 跨 5 个开源模型的让步率对比

• 动机：sycophancy 与模型规模 / 对齐方法的关系
• 方法：手工构造 200 道"用户错误前提"问题，用 LLM-as-judge 打 sycophancy 分
• 数据：自构 + SycophancyEval 子集
• 评估：让步率、推理一致性
• 难度：⭐⭐

CFP-4：Hallucination — 用 semantic entropy 检测特定领域 hallucination

• 动机：Farquhar 2024 Nature 在通用 QA 验证；医学 / 法律领域呢？
• 方法：复现 semantic entropy；扩展到中文医学 QA
• 数据：MedMCQA, CMB-Exam, 自构 200 题
• 评估：AUROC of hallucination detection
• 难度：⭐⭐⭐

CFP-5：Mech Interp — 在 Gemma-2-2B 上定位"否定"的 SAE feature

• 动机：LLM 处理否定有名地差，定位机制可能指导改进
• 方法：在 Neuronpedia 公开 SAE 上搜索 + activation patching 验证
• 数据：自构 5000 条否定/肯定对照 prompt
• 评估：因果干预后否定理解 accuracy 变化
• 难度：⭐⭐⭐⭐

CFP-6：长上下文 — RULER 上测 5 个开源 128K 模型，找"真实有效长度"

• 动机："声称 128K"和"真能用 128K"差很多
• 方法：直接跑 RULER；按 13 个 subtask 分别画 acc vs length 曲线
• 数据：RULER 基准
• 评估：每模型的"effective context"（acc 跌破 80% 的 length）
• 难度：⭐⭐

CFP-7：合成数据 — 测试 model collapse 在 SFT 上的强度

• 动机：Shumailov 2024 Nature 在 pre-training 显示 collapse；SFT 呢？
• 方法：用 LLM-A 生成 100K SFT 数据，训 LLM-B；再用 B 生成下一代 SFT 数据训 C；迭代 5 代
• 数据：起始用 Alpaca 5K 引导
• 评估：每代在 MT-Bench / Arena-Hard / 多样性指标 (distinct-n)
• 难度：⭐⭐⭐⭐

CFP-8：VLM — 评估 Qwen2-VL / LLaVA-Next / InternVL 在中文 OCR-VQA 上

• 动机：中文 VLM 评估资源稀缺
• 方法：构造中文图文 QA 1000 题（含繁体）
• 数据：自构 + 公开 ChartQA-zh
• 评估：accuracy + 错误类型分布
• 难度：⭐⭐⭐

CFP-9：对齐 — DPO vs SimPO vs ORPO 在同一 SFT base 上的可重复对比

• 动机：原论文各自只报最好结果，缺少受控对比
• 方法：固定 base = Qwen2.5-1.5B-SFT + 同一份偏好数据 (UltraFeedback) + 三种 loss
• 数据：UltraFeedback 训练 + Arena-Hard 评估
• 评估：胜率、calibration、训练稳定性曲线
• 难度：⭐⭐⭐

CFP-10：评估 — LLM-as-judge 的 length bias 量化

• 动机：Singhal 2023 指出 judge 偏好长回答；定量影响多大？
• 方法：用同一答案 + 添加无信息冗余生成"配对样本"，看 judge 打分变化
• 数据：MT-Bench prompt 池
• 评估：length 与 judge 打分的相关系数；分模型对比 GPT-4o / Claude 3.5 / Llama-3.1-70B
• 难度：⭐⭐

📋 Proposal Checklist

• ☐ 任务一句话能讲清楚（电梯演讲）
• ☐ 引用了 ≥ 1 篇核心论文，并写了 takeaway
• ☐ 数据集名 + 规模 + 来源 + 许可
• ☐ Baseline 写了具体名字 + 论文里的数字
• ☐ 评估指标具体（不写 "evaluate qualitatively"）
• ☐ Milestone 有可验证目标（"我们将在 Feb 24 前得到 baseline + 一组 ablation"）
• ☐ 团队成员姓名 + 邮箱
• ☐ 3-4 页，PDF

📋 Milestone Checklist

• ☐ 有跑出来的数字（不只是 "we plan to"）
• ☐ baseline 复现成功
• ☐ 至少一个"主方法"训练完跑出数字
• ☐ 剩余时间表（按周）
• ☐ 遇到的问题 + 解决方案 / 妥协
• ☐ 2-3 页

📋 Final Report Checklist

• ☐ Abstract 含一句量化主结果
• ☐ Intro 末尾有 bullet 形式的 contributions
• ☐ 至少 1 张架构图 + 1 张主结果表 + 1 张 ablation 表 + 1 张错误分析
• ☐ 模型公式带符号定义
• ☐ 数据切分 + 规模写清
• ☐ 多 seed 训练（≥ 2-3 个）并报 mean ± std
• ☐ 错误分析：定量 + 定性 examples
• ☐ 失败的 ablation 也写
• ☐ 资源 / 时间 cost 报告
• ☐ 代码 link + README（可复现）
• ☐ Contributions statement（多人项目）
• ☐ AI 使用声明（见 C.）