从零到多模态大模型 · 学习笔记

《从零到多模态大模型》学习笔记

读者画像：软件工程大三、代码有基础、DL/CV 零基础、目标多模态大模型方向科研、导师做图像×美术学交叉。 配套《多模态学习路线.md》：路线图是时间表，本笔记是教材。周级执行计划见卷9。

全书学习路径一张图

flowchart LR
  V0["卷0 基础篇<br>数学·PyTorch·反向传播<br>训练工程·远程开发"] --> V1["卷1 现代CV<br>CNN→注意力→Transformer<br>ViT·自监督·CLIP·SAM"]
  V1 --> V2["卷2 LLM内功<br>BPE·nanoGPT·预训练<br>SFT·LoRA·DPO/GRPO·vLLM"]
  V2 --> V3["卷3 多模态理解<br>三条路线·LLaVA复现<br>connector·tokenizer·评测"]
  V3 --> V4["卷4 生成模型<br>DDPM→SD→DiT/Flow<br>可控生成·视频·统一模型"]
  V4 --> V5["卷5 前沿专题<br>推理RL·数据中心·具身<br>世界模型·3D·Agent·医学"]
  V3 -. "并行读" .-> V8["卷8 美术学交叉 ★<br>美术基础·计算美学·风格史<br>看画VLM·数据集·选题库"]
  V5 --> V6["卷6 方法论<br>读论文·复现·选题<br>写作·开源·伦理"]
  V6 --> V9["卷9 生涯执行<br>周计划·四条路<br>作品集·面试"]
  V0 -. "全程伴随" .-> V7["卷7 工程手册<br>显存/OOM·调试案例<br>分布式·部署·数据管线·AI协作"]

怎么用这套笔记

1. 学练读结合：按执行计划推进，每章末尾有「自测题」和「动手作业」，不写作业等于没学。
2. 保持生长：全书 72 章已完结，但它是活文档——发现某章需要加深/有新论文出现/想增补新主题，随时说一声即可定向更新；7.2 调试案例集预留给你的真实踩坑。
3. 实践回写：实际训练踩的坑（OOM、NaN、数据对齐错误），让 AI 整理进卷7「工程实战手册」——那是未来最值钱的部分。
4. 卷8 随时可读：美术学交叉卷不依赖前置卷，可与卷0 并行读；8.1 第 10 节是和导师谈话的问题清单。
5. 速查与图解：附录·术语速查表 支持面试/复习前快速过牌；附录·十卷思维导图 开卷/合卷各看一眼；多个核心章内含 Mermaid 图解与手算案例（0.1/1.2/2.2/2.3/2.6/2.7/3.1/3.2/3.3/4.2/4.4/4.5/5.1/7.1/9.2）。
6. 主动自测三件套：交互测验页（20 题点击判分）、Anki 卡组（84 张，间隔重复）、各章自测题——读一章测一章。另有进度追踪 + 专注计时器（本机保存）。
7. 导出 PDF：访问 全书打印版 后 Ctrl+P → “另存为 PDF”——全书合并成一个可批注的 PDF（平板友好）。
8. 科研衔接件：论文精读包（10 篇核心论文的预读地图）、延伸资源二维码索引、scripts/ 目录三个实用工具（数据体检/美术质检/算力估算）、GitHub Pages 一键部署（见仓库 README）。

全书结构（10 卷 · 70 章）

卷0 基础篇——数学与工程底座（零基础起点）

对应执行计划 W1–W6。目标：读懂后续所有章节的公式和代码。

• 0.1 ✅ 数学基础：线性代数·概率·优化（DL视角三合一）
• 0.2 ✅ Python 与 PyTorch 实战
• 0.3 ✅ 神经网络与反向传播从零实现
• 0.4 ✅ 训练工程常识：混合精度、断点续训、调试与监控
• 0.5 ✅ Git / Linux / 远程开发生存包

卷1 深度学习与CV基础

对应 W7–W12。目标：吃透现代CV最小核心，传统内容只留一层底。

• 1.1 ✅ 从 CNN 到 ResNet：卷积时代的遗产
• 1.2 ✅ 注意力机制
• 1.3 ✅ Transformer 逐层拆解：从 Block 到小 GPT
• 1.4 ✅ ViT 与视觉 Transformer 谱系：图像成为 token
• 1.5 ✅ 自监督三巨头：MAE、CLIP、DINO
• 1.6 ✅ CLIP 精读与 zero-shot 评测实操
• 1.7 ✅ SAM 与分割基础模型：提示式视觉
• 1.8 ✅ 检测/分割极简史：知道即可的一章
• 1.9 ✅ 图像形成与相机模型：几何底座

卷2 LLM 内功（最关键的桥梁）

寒假主战场 W13–W20。目标：“能手写、能微调、能部署”。

• 2.1 ✅ 语言模型前史：n-gram → RNN → 注意力
• 2.2 ✅ BPE tokenizer 原理与实现
• 2.3 ✅ GPT 架构工程版：从 TinyGPT 到 nanoGPT
• 2.4 ✅ 预训练：数据、Scaling Law 与稳定性
• 2.5 ✅ SFT 与指令微调实战
• 2.6 ✅ 参数高效微调：LoRA 与 QLoRA
• 2.7 ✅ 对齐技术：RLHF → DPO → GRPO
• 2.8 ✅ 推理优化与 vLLM
• 2.9 ✅ 架构前沿：MoE、长上下文与注意力变体
• 2.10 ✅ 小模型时代的科研机会（1B–7B 甜点区）

卷3 多模态理解（VLM）

W21–W24。目标：复现 LLaVA 式训练，读懂开源双雄。

• 3.1 ✅ 多模态总览：双塔 / 桥接 / 原生融合三条路线
• 3.2 ✅ LLaVA 范式精读与复现
• 3.3 ✅ Connector 设计空间：Flamingo / BLIP-2 / Qwen-VL
• 3.4 ✅ 视觉 tokenizer：VQ-VAE / VQGAN
• 3.5 ✅ 开源双雄精读：Qwen-VL 与 InternVL 系列
• 3.6 ✅ 文档理解与 OCR-free
• 3.7 ✅ 多模态评测体系与陷阱
• 3.8 ✅ VLM 数据案例研读：caption、合成数据、配比

卷4 生成模型

W25–W28。目标：把扩散演化线串成一条河。

• 4.1 ✅ 生成模型地图：AR / VAE / GAN / Diffusion / Flow
• 4.2 ✅ DDPM 原理与从零实现
• 4.3 ✅ 采样器与 Classifier-Free Guidance
• 4.4 ✅ Latent Diffusion 与 Stable Diffusion
• 4.5 ✅ DiT 与 Flow Matching（SD3 / FLUX 的现代化）
• 4.6 ✅ 可控生成：ControlNet / IP-Adapter / 风格 LoRA
• 4.7 ✅ 视频生成：Sora 范式与开源阵营
• 4.8 ✅ 统一模型之争：Chameleon / Transfusion / Janus
• 4.9 ✅ 前沿瞭望：扩散语言模型

卷5 前沿专题（科研选题池）

暑假起按兴趣选读。

• 5.1 ✅ 多模态推理与 RL：当前最热的研究现场
• 5.2 ✅ 数据为中心的 VLM 研究
• 5.3 ✅ 具身智能与 VLA
• 5.4 ✅ 世界模型与空间智能
• 5.5 ✅ 3D 视觉：NeRF → 3DGS → 前馈重建
• 5.6 ✅ 视觉 Agent 与 Computer Use
• 5.7 ✅ AI for Science 与医学影像
• 5.8 ✅ 高效化：蒸馏、量化、剪枝与小模型

卷6 科研方法论

• 6.1 ✅ 如何读论文：三遍法与精读模板
• 6.2 ✅ 如何复现：最小复现方法论
• 6.3 ✅ 如何选题：价值判断、文献扫描与资源匹配
• 6.4 ✅ 如何写作与投稿：从图表到 rebuttal
• 6.5 ✅ 开源贡献指南：用 PR 说话
• 6.6 ✅ 学术诚信与 AIGC 时代的科研伦理

卷7 工程实战手册（随实践持续增补）

• 7.1 ✅ 显存估算速查与 OOM 排查大全
• 7.2 ✅ 训练调试案例集：十大经典翻车与处置
• 7.3 ✅ 分布式训练入门：DDP / FSDP / DeepSpeed
• 7.4 ✅ 推理部署与成本估算
• 7.5 ✅ 数据管线工程：把数据当代码对待
• 7.6 ✅ AI 协作守则：驾驭代码 agent 而不被其驾驭

卷8 视觉 × 美术学交叉 ★对接导师方向

不依赖前置卷。目标：能与导师对话、在交叉带选题。

• 8.1 ✅ 美术学基础：三层框架·色彩·构图·光影·艺术史
• 8.2 ✅ 计算美学：美学评分与偏好奖励模型
• 8.3 ✅ 风格迁移演化史：Gatys → AdaIN → 扩散时代
• 8.4 ✅ 面向艺术的生成：从控制工具到创作系统
• 8.5 ✅ 艺术理解：让 VLM 真正”看懂”一幅画
• 8.6 ✅ AIGC 时代的艺术评价与人类偏好对齐
• 8.7 ✅ 艺术数据集与基准构建：从 WikiArt 到自建
• 8.8 ✅ 文化遗产数字化与数字人文：AI 进博物馆
• 8.9 ✅ 交叉选题库：结合导师方向的 20 个可执行题目

卷9 生涯执行手册

• 9.1 ✅ 九个月周级执行计划（含夏令营材料清单与导师联系模板）
• 9.2 ✅ 保研/考研/留学/就业四条路分析
• 9.3 ✅ 作品集打造与个人品牌：让 GitHub 替你说话
• 9.4 ✅ 实习申请与面试准备：从简历到 offer

进度 · 全书完结（v2.0，2026.10）

• 🎉 74 章正文全部完成，约 24 万字：卷0（5）+ 卷1（9）+ 卷2（10）+ 卷3（8）+ 卷4（9）+ 卷5（8）+ 卷6（6）+ 卷7（6）+ 卷8（9）+ 卷9（4）
• 🔍 已做通篇一致性检查：导航全部有效、章节内链零损坏、无草稿残留（python check_site.py 可随时复查）
• 📌 这套笔记是活文档：7.2 调试案例集等你用真实踩坑回填；各章延伸资源里的论文在新发表时按需增补；目录结构调整说一声即可

本周就该做的三件事（按 8.9 选题库）

1. 读 8.1 + 8.9，选 top3 题目，给 top1 写一页 proposal；
2. 拿着它和 9.1 的模板联系导师（W5–W6 的既定动作）；
3. 开始 A1 评测集的 v0 标注规范（30 条样例）——全线受益的基础设施。

写作约定

• 公式配直觉解释，所有数学都回答”这在模型里的哪里出现”
• 代码可运行优先，标注版本；每章末尾：自测题（带提示）+ 动手作业 + 延伸资源（≤5 个）
• 观点有争议处标注「业界有分歧」，不装成定论

0.1 数学基础：线性代数 · 概率 · 优化（深度学习视角三合一）

本章目标：不是把你变成数学系学生，而是把后续所有章节会用到的数学一次配齐，并且每个概念都告诉你它在模型里的哪个位置出现。学完标准：能看懂后续所有章节的公式，能自己推导 softmax+交叉熵 的梯度。

1. 为什么学这三样

深度学习里，数学只有三个角色：

传统数学课按”定义→定理→证明”推进，我们反过来：先看它在模型里的用法，再回头看定义。

2. 线性代数

2.1 向量与内积：相似度的度量

向量是一列数。内积（点积）$\mathbf{a} \cdot \mathbf{b} = \sum_i a_i b_i$，几何意义是”对齐程度”：方向越一致，内积越大。

为什么这是最重要的概念：整个多模态大模型都在算内积。

• CLIP 把图像和文本各编码成一个向量，用内积衡量”图文是否匹配”；
• Attention 的核心就是 Query 和 Key 的内积（$QK^\top$），内积大 = “这个位置值得注意”；
• 向量数据库检索图片 = 查询向量与百万张图的特征向量算内积。

2.2 矩阵乘法：三种视角

$C = AB$（$A$ 是 $m\times n$，$B$ 是 $n\times p$）可以同时理解为：

1. 变换的复合：$A$ 对空间做一次线性变换，$B$ 再做一次。神经网络的每一层就是一次变换，100 层网络 = 100 次复合。
2. 批量内积：$C$ 的第 $(i,j)$ 元 = $A$ 的第 $i$ 行与 $B$ 的第 $j$ 列的内积。Attention 矩阵 $QK^\top$ 就是这个视角。
3. 加权求和：$C$ 的每一列是 $A$ 的列的线性组合，组合权重来自 $B$。全连接层 $y = Wx$ 就是”用 $W$ 的行作为权重，混合输入特征”。

三种视角在调试时各有用处。看到矩阵乘法报 shape 错误，先问自己用的是哪个视角。

2.3 范数与距离

• $L_2$ 范数 $\|\mathbf{x}\|_2 = \sqrt{\sum_i x_i^2}$：欧氏长度，默认选项。
• $L_1$ 范数 $\sum_i |x_i|$：对离群值不敏感，稀疏化时用。

常见用法：权重衰减（weight decay）约束的是权重的 $L_2$ 范数；归一化（normalize）把向量除以自己的 $L_2$ 范数后，内积就变成了余弦相似度——CLIP 检索、向量库检索都这么做。

2.4 特征分解与 SVD：低秩的世界

SVD（奇异值分解）说：任何矩阵 $A$ 都可以拆成 $A = U\Sigma V^\top$，其中 $\Sigma$ 是对角阵，对角元（奇异值）从大到小排。保留前 $r$ 个最大奇异值，就能用低秩矩阵近似 $A$。

这在多模态大模型里的出现位置：

• LoRA：微调大模型时不直接更新权重矩阵 $W$，而是学一个低秩增量 $\Delta W = BA$（$B$ 是 $d\times r$，$A$ 是 $r\times k$，$r \ll d,k$）。理论基础就是”微调带来的权重变化近似低秩”。你在路线阶段2就会用它。
• 图像压缩、PCA 降维、推荐系统，本质都是”砍掉小的奇异值”。

2.5 矩阵求导与链式法则

深度学习的”学习”= 对数百万个参数求梯度，然后沿梯度反方向走。你需要的矩阵求导其实只有一条规则：

链式法则：$y = f(g(x))$，则 $\frac{dy}{dx} = \frac{dy}{dg}\cdot\frac{dg}{dx}$。多变量的情况就是把雅可比矩阵相乘——这就是”反向传播”的全部数学。

必会推导：softmax + 交叉熵的梯度 = 预测 − 标签

softmax 把任意分数向量 $\mathbf{z}$ 变成概率分布：$\text{softmax}(\mathbf{z})_i = \frac{e^{z_i}}{\sum_j e^{z_j}}$。 交叉熵损失：$L = -\sum_i t_i \log p_i$，其中 $\mathbf{p} = \text{softmax}(\mathbf{z})$，$\mathbf{t}$ 是 one-hot 标签。

直接对 $z_i$ 求导（过程略，建议自己推一遍，用到的只有链式法则和 $\frac{d\log x}{dx} = 1/x$），结论：

$\frac{\partial L}{\partial \mathbf{z}} = \mathbf{p} - \mathbf{t}$

为什么这个结论是深度学习里最重要的一行公式：梯度恰好是”预测概率分布减去真实分布”。模型错得越离谱，梯度越大——学习的方向自动就是”把概率从错误的类挪到正确的类”。语言模型预测下一个 token、VLM 回答问题，输出的都是这个形式。你以后看到 loss = cross_entropy(logits, labels)，脑子里应该浮现 p − t。

3. 概率与信息论

3.1 速通核心概念

• 随机变量与分布：图像分类模型输出 $P(\text{猫}), P(\text{狗}), ...$，就是一个分类分布（categorical distribution）。
• 条件概率 $P(y|x)$：给定输入图像 $x$，输出标签 $y$ 的概率。监督学习学到的就是这个——所以分类模型叫”判别式”，生成模型学 $P(x)$ 或 $P(x|\text{文本})$，叫”生成式”。扩散模型和 GPT 都是生成式。
• 期望与方差：随机初始化下 loss 的波动、batch 之间的梯度噪声，都用它们来描述。

3.2 极大似然：训练到底在干嘛

给定数据 $\{x_1,...,x_N\}$ 和带参数 $\theta$ 的模型 $P_\theta(x)$，极大似然估计（MLE）就是选 $\theta$ 让数据出现的概率最大：

$\theta^* = \arg\max_\theta \prod_i P_\theta(x_i) \quad\Longleftrightarrow\quad \arg\min_\theta \sum_i -\log P_\theta(x_i)$

右边就是”最小化负对数似然（NLL）“——你训练过的每一个模型的损失函数，几乎都是它换个名字：

• 分类任务的交叉熵 = NLL；
• 语言模型”预测下一个 token”= 对下一个 token 的 NLL；
• 扩散模型预测噪声的 MSE = 高斯假设下 NLL 的简化版。

建立这个等式感：以后看到任何奇怪的 loss，第一反应问”它是谁的负对数似然”。

3.3 熵、交叉熵、KL 散度

• 熵 $H(p) = -\sum_i p_i \log p_i$：分布的不确定性。均匀分布熵最大。
• 交叉熵 $H(p, q) = -\sum_i p_i \log q_i$：用 $q$ 编码真实分布 $p$ 的代价。训练时 $p$ 是数据/标签，$q$ 是模型输出。
• KL 散度 $D_{KL}(p\|q) = H(p,q) - H(p)$：两个分布的差异。$p$ 固定时，最小化交叉熵 = 最小化 KL。

出现位置：

• 知识蒸馏：让学生的输出分布逼近老师的（KL）；
• DPO / RLHF：约束微调后的模型别偏离原模型太远（KL 惩罚）；
• VAE：后验分布逼近标准正态（KL）。

一句话：交叉熵管”学什么”，KL 管”别学歪”。

3.4 softmax 与温度

$\text{softmax}(z/T)$ 里的 $T$ 是温度：$T \to 0$ 逼近取最大值（独断），$T$ 大则分布平坦（犹豫）。出现位置：LLM 采样时的 top-p/top-k 温度参数；蒸馏时高温让老师的”暗知识”（次优选项的相对概率）显现。

4. 优化

4.1 损失曲面的高维直觉

参数量上亿的模型，损失曲面在高维空间里。高维空间的重要事实：真正的”局部极小值”很少，绝大多数驻点是鞍点——某些方向向上、某些方向向下，总能找到出路。所以不用担心”卡在局部最优”，实际问题是”下降太慢”和”震荡”。

4.2 从 SGD 到 AdamW

• SGD：沿当前 batch 的梯度走一小步。问题：不同参数的梯度尺度差异大，一个学习率伺候不了一堆参数。
• Momentum：积累历史梯度方向，冲过小沟坎。
• Adam：为每个参数自适应缩放步长（除以梯度的一阶/二阶动量）。现代默认。
• AdamW：修复了 Adam 中 weight decay 与自适应步长耦合的 bug，把权重衰减解耦出来。现在所有 LLM/VLM 训练默认都是 AdamW，你只需要记住这个名字和”decay 系数一般 0.01~0.1”。

4.3 学习率：最重要的单一超参

现代默认配方：warmup + cosine decay。前 1~5% 步数从 0 线性升到峰值（大模型早期梯度方向不可信，直接大步会崩），然后余弦缓降到接近 0。

经验参考值：从零训小模型峰值 1e-3 量级；微调 7B 用 LoRA 峰值 1e-4 ~ 2e-4；全参数微调大模型 1e-5 量级。微调的学习率几乎总比预训练小 10~100 倍——别把人家学好的东西一脚踢翻。

4.4 Batch size 与梯度累积

大 batch 梯度更稳但单步更贵，且一般认为大 batch 要配大学习率（线性缩放法则，够用即可不必深究）。显存不够时用梯度累积：小 batch 算多次梯度，攒够了再更新一步，等效于大 batch。LoRA 微调 7B 时你几乎一定会用到它。

4.5 过拟合与正则化

• 现象：训练 loss 降、验证 loss 升。数据少 + 模型大 + 训练久 = 必然。
• 手段按优先级：更多/更好的数据 > 数据增强 > weight decay/dropout > 早停。
• 微调场景的特殊性：数据只有几千条时，与其调正则，不如减 epoch、降学习率、用 LoRA。

4.6 训练曲线诊断速查表（先背下来）

5. 自测十题（答案提示在括号里）

1. 两个单位向量的内积最大是多少？此时几何关系是什么？（1；同向）
2. 为什么归一化后内积 = 余弦相似度？（$\|\mathbf{a}\|=\|\mathbf{b}\|=1$ 时 $\mathbf{a}\cdot\mathbf{b}=\cos\theta$）
3. 一个 $4096\times 4096$ 的权重矩阵，LoRA 取 $r=16$，参数量从多少降到多少？（16.8M → 131K，两个矩阵 $4096\times16 + 16\times4096$）
4. $QK^\top$ 里，$Q$ 的一行和 $K$ 的一行分别是什么？（一个 query 向量、一个 key 向量；结果是注意力分数）
5. 为什么交叉熵可以写成”负对数似然”？（对 one-hot 标签，$-\sum t_i\log p_i = -\log p_y$，即真实类的对数概率取负）
6. 熵为 0 的分布是什么？（one-hot，完全确定）
7. KL(p‖q) 和 KL(q‖p) 一样吗？不对称会带来什么行为差异？（不一样；前者在 q 概率低处惩罚重——“宁可信其有”，后者在 p 概率低处惩罚重——“宁可漏掉”。蒸馏里两种选择行为不同，是活跃的研究细节）
8. AdamW 和 Adam 的区别一句话？（weight decay 从梯度自适应缩放里解耦出来）
9. 微调时学习率应该比预训练大还是小？为什么？（小；预训练权重是好解，只做局部修整）
10. 梯度累积解决什么问题？代价是什么？（显存不够模拟大 batch；代价是单位样本耗时几乎不变但每步更慢、BN/LN 统计与真大 batch 有细微差异）

6. 动手作业

1. 用 NumPy 手写 softmax 和交叉熵，并用第 2.5 节结论 $\nabla_z L = p - t$ 写出梯度函数，再数值验证（随机小扰动下 $(L(z+\epsilon)-L(z-\epsilon))/2\epsilon \approx \nabla_z L$）。
2. 用 NumPy 对一个随机 $100\times 100$ 矩阵做 SVD，分别保留前 5/20/50 个奇异值重构，算重构误差随秩的下降曲线。这就是”LoRA 为什么可行”的直观感受。

图解 · 数学地图与一次手算

flowchart LR
  A["线性代数：数据的语言"] --> A1["内积 → CLIP 相似度 / 检索"]
  A --> A2["QKᵀ → Attention 打分"]
  A --> A3["SVD / 低秩 → LoRA"]
  B["概率与信息论：学习的目标"] --> B1["交叉熵 = 负对数似然<br>一切训练目标"]
  B --> B2["KL 散度 → DPO / 蒸馏的缰绳"]
  B --> B3["softmax 温度 → 采样与蒸馏"]
  C["优化：学习的发生机制"] --> C1["AdamW + warmup/cosine<br>所有现代训练"]
  C --> C2["6ND → 任何实验的算力预算"]

案例：手算一次 softmax + 交叉熵

设三类 logits $z = [2.0,\ 0.0,\ -1.0]$，真实类为第 0 类（$t=[1,0,0]$）。

第一步 softmax：$e^2=7.389,\ e^0=1,\ e^{-1}=0.368$，总和 8.757， 故 $p = [0.844,\ 0.114,\ 0.042]$。

第二步 loss：$L = -\ln 0.844 = 0.170$。

第三步梯度：$\nabla_z L = p - t = [-0.156,\ +0.114,\ +0.042]$。

读出三件事：① 正确类的梯度为负——下一步要抬高它的 logit；② 两个错误类按”谁错得离谱谁多分”，分摊了挪走概率的任务；③ 所有分量之和为 0（概率守恒）。以后你在任何训练日志里看到交叉熵，背后都是这三个数字在动。

7. 延伸资源

• 3Blue1Brown《线性代数的本质》《微积分的本质》（B 站官方翻译版）——直觉构建第一名
• 《Mathematics for Machine Learning》（Deisenroth 等，免费电子版）——按需查阅，不必通读
• Karpathy《The spelled-out intro to neural networks》——把本章数学第一次和代码接起来

0.2 Python 与 PyTorch 实战：从装环境到手写训练循环

本章目标：搭建可用的 GPU 开发环境，把 PyTorch 五大件（张量/autograd/nn.Module/DataLoader/训练循环）全部打通，最后给出一份完整可运行的 CIFAR-10 训练脚本。学完标准：能独立写出一个完整的图像分类训练项目，能自己估算显存。

1. 环境（一次配好，少踩三天坑）

推荐用 uv（快）或 conda（稳）管理环境：

# 方式一：uv（推荐，快）
uv venv --python 3.11 && uv pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
uv pip install wandb tqdm numpy matplotlib jupyter

# 方式二：conda
conda create -n dl python=3.11 -y && conda activate dl
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

验证 GPU 可用（没有 NVIDIA 卡也没关系，本卷所有代码 CPU 能跑，只是慢；租卡见第 8 节）：

import torch
print(torch.__version__, torch.cuda.is_available())
print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else "CPU only")

2. 张量：形状操作是 80% 的日常

2.1 创建与基本属性

import torch
x = torch.randn(2, 3, 224, 224)   # 常见图像 batch：N×C×H×W
x.shape, x.dtype, x.device, x.requires_grad

2.2 图像相关：NCHW 与形状变换（必背）

图像张量约定为 NCHW（batch, channel, 高, 宽）。RGB 图在 PIL/NumPy 里通常是 HWC，进模型前要转 CHW。

img = torch.randn(224, 224, 3)          # HWC
img = img.permute(2, 0, 1)              # → CHW，注意 permute 不移动内存，只改"索引方式"
img = img.contiguous()                  # 需要真实重排内存时才调用
batch = img.unsqueeze(0)                # → NCHW，在前面加一维

reshape / view / permute 的区别（面试和 debug 双高频）：

• view：不复制数据，要求内存连续，快；
• reshape：能 view 就 view，不行就复制；
• permute/transpose：交换维度顺序，只改索引，之后常需要 contiguous。

2.3 广播（broadcasting）：省代码也埋大坑

形状不同也能算，规则是从最后一维向前对齐，缺的或为 1 的维度自动复制：

mean = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)  # ImageNet 通道均值
img = (img - mean) / torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)

大坑：(N, 3, 224, 224) 和 (3, 224) 相加会广播成 N 份同样的操作（正确）；但 (N, 224, 224, 3) 和 (3,) 相加会把 3 广播到 W 维——shape 看似能算，语义完全错了且不报错。广播 bug 的特征：loss 能下降但结果莫名其妙。防法：关键操作前 assert x.shape == 期望形状。

2.4 dtype 与显存

同一模型，dtype 换一半，显存减一半——这是后面所有显存估算的底层常数。

3. autograd：自动求导

w = torch.randn(3, requires_grad=True)
loss = (w * torch.tensor([1.0, 2.0, 3.0])).sum()
loss.backward()
print(w.grad)                    # = [1, 2, 3]，链式法则自动算出

三条纪律：

1. 更新参数用 with torch.no_grad(): 包住（否则梯度历史越滚越大）；
2. 每个 iteration 开头 optimizer.zero_grad()（PyTorch 默认累加梯度）；
3. 推理用 with torch.inference_mode():，比 no_grad 更省。

4. nn.Module：模型的容器

import torch.nn as nn

class TinyNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Flatten(),
            nn.Linear(3 * 32 * 32, 256), nn.ReLU(),
            nn.Linear(256, 10),
        )
    def forward(self, x):
        return self.net(x)

要点：__init__ 里赋值为 nn.Module 的属性会自动注册参数；model.state_dict() / load_state_dict() 是存取权重的标准方式（存 .pth 文件）；model.to("cuda") 把参数搬到 GPU；model.train() / model.eval() 切换 dropout/batchnorm 行为——评估忘切 eval 是经典 bug。

5. Dataset 与 DataLoader

from torch.utils.data import Dataset, DataLoader
from torchvision import datasets, transforms

tf = transforms.Compose([
    transforms.RandomHorizontalFlip(),          # 数据增强：只对训练集
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
train_set = datasets.CIFAR10("data", train=True, download=True, transform=tf)
train_loader = DataLoader(train_set, batch_size=128, shuffle=True,
                          num_workers=4, pin_memory=True, drop_last=True)

num_workers（多进程读数据）和 pin_memory（锁页内存加速传输）是两条免费性能；drop_last=True 丢掉不满的最后一个 batch，避免训练末尾统计失真。

6. 完整训练脚本（逐段精读版）

下面是你要吃透的第一个完整项目。核心训练循环的模式，从 CIFAR 上的小 CNN 到微调 7B 的 VLM，结构完全一样：取数据 → 前向 → 算 loss → 反向 → 更新。

import torch, torch.nn as nn, time
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

torch.manual_seed(0)                                  # 可复现
device = "cuda" if torch.cuda.is_available() else "cpu"

tf_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
tf_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])

train_ds = datasets.CIFAR10("data", True, download=True, transform=tf_train)
test_ds  = datasets.CIFAR10("data", False, download=True, transform=tf_test)
train_ld = DataLoader(train_ds, 256, shuffle=True,  num_workers=4, pin_memory=True, drop_last=True)
test_ld  = DataLoader(test_ds, 512, shuffle=False, num_workers=2, pin_memory=True)

class ConvBlock(nn.Sequential):
    def __init__(self, cin, cout):
        super().__init__(
            nn.Conv2d(cin, cout, 3, padding=1, bias=False),
            nn.BatchNorm2d(cout), nn.ReLU(inplace=True))

class Net(nn.Module):
    def __init__(self, ch=64):
        super().__init__()
        self.features = nn.Sequential(
            ConvBlock(3, ch),  ConvBlock(ch, ch),          # 32×32
            nn.MaxPool2d(2),                               # 16×16
            ConvBlock(ch, ch*2), ConvBlock(ch*2, ch*2),
            nn.MaxPool2d(2),                               # 8×8
            ConvBlock(ch*2, ch*4),
            nn.AdaptiveAvgPool2d(1))                       # 全局平均池化 → 1×1
        self.head = nn.Linear(ch*4, 10)
    def forward(self, x):
        x = self.features(x).flatten(1)
        return self.head(x)

model = Net().to(device)
opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.05)
sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=20)   # 20 epoch
scaler = torch.amp.GradScaler(enabled=(device == "cuda"))           # AMP 混合精度

for epoch in range(20):
    model.train(); t0 = time.time()
    for step, (x, y) in enumerate(train_ld):
        x, y = x.to(device, non_blocking=True), y.to(device, non_blocking=True)
        with torch.autocast("cuda", dtype=torch.bfloat16, enabled=(device=="cuda")):
            logits = model(x)
            loss = nn.functional.cross_entropy(logits, y)
        opt.zero_grad(set_to_none=True)
        scaler.scale(loss).backward()
        scaler.step(opt); scaler.update()
        if step % 50 == 0:
            print(f"ep{epoch} step{step} loss={loss.item():.3f} lr={sched.get_last_lr()[0]:.2e}")
    sched.step()

    model.eval(); correct = total = 0                     # 每 epoch 评估一次
    with torch.inference_mode():
        for x, y in test_ld:
            x, y = x.to(device), y.to(device)
            correct += (model(x).argmax(1) == y).sum().item(); total += y.size(0)
    print(f"[ep{epoch}] test acc={correct/total:.4f} time={time.time()-t0:.0f}s")
    torch.save(model.state_dict(), f"ckpt_ep{epoch}.pth")  # checkpoint

这个脚本里藏着本章所有知识点：种子、设备、数据增强、AMP（autocast 包前向 + GradScaler 包反向）、zero_grad、调度器、train/eval 切换、inference_mode、checkpoint。把它跑通、改坏、修好各一遍，PyTorch 就入门了。

（建议接 wandb：wandb.init(project="cifar") 后把 loss/acc wandb.log() 上去，实验管理习惯从此建立。）

7. 显存速算与 OOM 三板斧

7.1 训练显存速算（全参数、AdamW、fp16/bf16 混合精度）

$\text{显存} \approx \underbrace{2P}_{\text{混合精度权重}} + \underbrace{2P}_{\text{梯度}} + \underbrace{8P}_{\text{AdamW 两个状态(fp32)}} + \underbrace{4P}_{\text{fp32主权重}} + \text{激活值}$

其中 $P$ 是参数量。粗算约 16 字节/参数 + 激活，所以：

• 7B 模型全参数训练 ≈ 16×7GB ≈ 112GB+激活 → 单张消费级卡不可能，要 FSDP/DeepSpeed（卷7详述）；
• 7B 模型 LoRA 微调：冻结主干，只训 ~0.1% 参数 → 权重 14GB + 少量梯度和优化器状态 ≈ 24GB 卡（4090）正好能跑。这就是为什么”学生甜点区”是 LoRA + 7B/4B 模型。

7.2 OOM 三板斧（按顺序试）

1. 降 batch size，配梯度累积补等效 batch；
2. 开 gradient_checkpointing（用重算换显存，速度约慢 30%）；
3. 检查是否忘了 torch.no_grad() / inference_mode()，或把整段历史 logits 攒进了 list（日志里 loss.item() 要立刻取标量，别存 tensor）。

8. 学生算力方案

• 免费：Kaggle（每周约 30h GPU）、魔搭 ModelScope 免费算力、Colab 免费档；
• 租用：AutoDL / 仙宫云，4090 约 1.5–2 元/小时，LoRA 微调一个 7B 跑几小时就是一杯奶茶钱；
• 本地无卡：卷0、卷1 全部内容 CPU 或免费档即可完成，训练类实验攒到租卡时段集中跑。

9. 自测题

1. view 和 reshape 什么时候行为不同？（内存不连续时：view 报错，reshape 复制）
2. HWC 转 CHW 该用 view 吗？（不该，维度语义变了要用 permute；view 只能拆并相邻的内存维度）
3. optimizer.zero_grad() 忘写会怎样？（梯度跨 step 累加，loss 不降甚至爆炸）
4. eval 忘切会怎样？（dropout/BN 用训练行为，测试精度异常波动）
5. bf16 比 fp16 好在哪？（指数位同 fp32，动态范围大，不需要 loss scale，几乎不会溢出）
6. 为什么 loss.item() 而不是把 loss tensor 存进列表？（存 tensor 会保留整张计算图，显存爆）
7. batch size 减半后想保持等效更新，两个办法？（梯度累积 2 步；或调 lr）
8. 一个 3B 模型 fp16 权重占多少显存？加 AdamW 训练状态呢？（6GB；约 3×8+4=28GB 起步，还没算激活）

10. 动手作业（对应路线阶段0里程碑）

1. 跑通第 6 节脚本，记录最终精度（ConvBlock 结构约 87–91%）。
2. 把 Net 换成 torchvision.models.resnet18（num_classes=10），加更多增强（trivialaugment），目标：CIFAR-10 测试精度 ≥ 93%。这一步会逼你读懂 torchvision 源码。
3. 接入 wandb，画出 loss/lr/acc 三条曲线；故意把 lr 设成 0.1 观察发散，再设 1e-5 观察学不动——亲手建立第 4.6 节速查表的手感。
4. 手写一个自定义 Dataset：从文件夹读图片（ImageFolder 之外自己实现 __getitem__），这是后面做 VLM 数据 pipeline 的地基。

11. 延伸资源

• PyTorch 官方教程《60 Minute Blitz》→《Training a Classifier》——和本章互补
• Karpathy《Let’s build GPT from scratch》前 20 分钟——张量操作的真实工程用法
• 《Dive into Deep Learning》（动手学深度学习）中文版第 2–4 章——系统查漏

0.3 神经网络与反向传播：从零实现（micrograd 路线）

本章目标：不借助 PyTorch 的 autograd，亲手造一个能自动求导、能训练的最小神经网络引擎。学完标准：别人问你”反向传播到底在干嘛”，你能用代码+一行数学回答，而不是背口诀。 本章跟着 Karpathy《The spelled-out intro to neural networks and backpropagation: building micrograd》食用效果最佳——本笔记补足其中的数学直觉和中文讲解。

1. 一个神经元：线性 + 非线性

神经元 = 加权求和 + 偏置 + 激活函数：

$y = \sigma(w_1 x_1 + w_2 x_2 + b)$

激活函数 $\sigma$ 必不可少：如果不用非线性激活，多层线性变换的复合还是线性变换（$W_2(W_1x) = (W_2W_1)x$），100 层等价于 1 层。非线性是深度的来源。

常用激活：ReLU（$\max(0,x)$，CNN 时代默认）、GELU（Transformer 默认）、tanh（教学常用，光滑好求导）。

2. 计算图：反向传播的舞台

任何计算（比如 loss）都能画成一张有向无环图：输入和参数是叶子，运算符是中间节点，loss 是根。反向传播 = 把链式法则自动化在这张图上：

1. 前向：从叶子到根，算出每个节点的值；
2. 反向：从根到叶子，用链式法则把”loss 对每个节点的梯度”逐层乘回去。

关键直觉：每个节点只需知道两件事——(a) 它怎么由输入算出（局部前向公式）；(b) 它的输出梯度怎么分摊给各输入（局部梯度公式）。局部规则 + 全局调度 = 自动求导。PyTorch 的 autograd 干的就是这件事，只是规模大、优化多。

3. 必须亲手推一遍的梯度

以两层网络 + softmax + 交叉熵为例（符号与 0.1 章 §2.5 一致）：

前向：$\mathbf{h} = \tanh(W_1 \mathbf{x} + \mathbf{b}_1)$，$\mathbf{z} = W_2 \mathbf{h} + \mathbf{b}_2$，$\mathbf{p} = \text{softmax}(\mathbf{z})$，$L = -\log p_y$。

反向（从后往前，每步只用链式法则）：

1. $\dfrac{\partial L}{\partial \mathbf{z}} = \mathbf{p} - \mathbf{t}$（0.1 章推导过；tanh 的导数是 $1 - \tanh^2$）
2. $\dfrac{\partial L}{\partial W_2} = \dfrac{\partial L}{\partial \mathbf{z}} \mathbf{h}^\top$，$\dfrac{\partial L}{\partial \mathbf{b}_2} = \dfrac{\partial L}{\partial \mathbf{z}}$
3. $\dfrac{\partial L}{\partial \mathbf{h}} = W_2^\top \dfrac{\partial L}{\partial \mathbf{z}}$（注意转置：误差从上层”倒着流回来”）
4. $\dfrac{\partial L}{\partial \mathbf{a}_1} = \dfrac{\partial L}{\partial \mathbf{h}} \odot (1 - \mathbf{h}^2)$（$\odot$ 是逐元素乘，激活导数逐点作用）
5. $W_1, \mathbf{b}_1$ 的梯度同第 2 步模式。

观察结构：每层都是”上游梯度 × 本层局部导数，再往上传”。这就是为什么框架只需要每个算子定义 backward()，任意深度的网络都能自动求导。

4. 从零造引擎：micrograd 式实现

4.1 标量自动求导引擎（约 60 行，核心中的核心）

import math

class Value:
    """一个数 + 它的计算历史 + 自动求导能力"""
    def __init__(self, data, _children=(), _op=""):
        self.data = data
        self.grad = 0.0              # d(loss)/d(self)
        self._backward = lambda: None
        self._prev = set(_children)  # 计算图的前驱
        self._op = _op

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), "+")
        def _backward():             # 加法：梯度原样传给两边
            self.grad  += out.grad
            other.grad += out.grad
        out._backward = _backward
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), "*")
        def _backward():             # 乘法：交换律式分摊
            self.grad  += other.data * out.grad
            other.grad += self.data * out.grad
        out._backward = _backward
        return out

    def tanh(self):
        x = self.data
        t = (math.exp(2*x) - 1) / (math.exp(2*x) + 1)
        out = Value(t, (self,), "tanh")
        def _backward():             # d(tanh)/dx = 1 - tanh²
            self.grad += (1 - t**2) * out.grad
        out._backward = _backward
        return out

    def backward(self):
        # 拓扑排序：保证先算完所有下游，再算自己
        topo, visited = [], set()
        def build(v):
            if v not in visited:
                visited.add(v)
                for c in v._prev: build(c)
                topo.append(v)
        build(self)
        self.grad = 1.0                              # d(loss)/d(loss) = 1
        for node in reversed(topo):                  # 从根往叶子走
            node._backward()

    # 语法糖
    __rmul__ = __mul__
    def __neg__(self): return self * -1
    def __sub__(self, other): return self + (-other)
    def __truediv__(self, other): return self * other**-1
    def __pow__(self, k):
        out = Value(self.data ** k, (self,), f"**{k}")
        def _backward(): self.grad += k * self.data ** (k-1) * out.grad
        out._backward = _backward
        return out
    def __repr__(self): return f"Value({self.data:.4f}, grad={self.grad:.4f})"

读代码时盯住三个设计：

1. += 而不是 =：一个变量被多次使用时（比如 c = a + a），梯度要累加（$dc/da = 2$）。漏掉累加是最经典的自动求导 bug；
2. _backward 存在节点上而不是立刻执行：因为要等所有下游节点贡献完梯度才能跑；
3. backward() 里拓扑排序 + 逆序执行：这就是”反向”二字的实现。

4.2 用它搭 MLP 并训练（完整可运行）

import random
random.seed(0)

class Neuron:
    def __init__(self, nin):
        self.w = [Value(random.uniform(-1, 1)) for _ in range(nin)]
        self.b = Value(0.0)
    def __call__(self, x):
        act = sum((wi*xi for wi, xi in zip(self.w, x)), self.b)
        return act.tanh()

class Layer:
    def __init__(self, nin, nout):
        self.neurons = [Neuron(nin) for _ in range(nout)]
    def __call__(self, x):
        out = [n(x) for n in self.neurons]
        return out[0] if len(out) == 1 else out

class MLP:
    def __init__(self, nin, nouts):                      # 如 [2, 8, 8, 1]
        sizes = [nin] + nouts
        self.layers = [Layer(sizes[i], sizes[i+1]) for i in range(len(nouts))]
    def __call__(self, x):
        for layer in self.layers: x = layer(x)
        return x

def train_step(model, x, y_target, lr=0.05):
    y_pred = model(x)                                     # 前向
    loss = (y_pred - y_target) ** 2                       # MSE（用我们的引擎算！）
    for p in model.parameters(): p.grad = 0.0             # 手动 zero_grad（和 PyTorch 纪律一致）
    loss.backward()                                       # 自动求导
    for p in model.parameters():                          # 梯度下降
        p.data -= lr * p.grad
    return loss.data

model = MLP(2, [8, 8, 1])
model.parameters = lambda: [p for l in model.layers for n in l.neurons
                            for p in n.w + [n.b]]

# 玩具任务：判断点在圆内还是圆外
data = []
for _ in range(200):
    x, y = random.uniform(-1, 1), random.uniform(-1, 1)
    data.append(([x, y], 1.0 if x*x + y*y < 0.5 else -1.0))

for step in range(200):
    losses = [train_step(model, x, y) for x, y in random.sample(data, 20)]
    if step % 20 == 0:
        acc = sum((model(x).data > 0) == (y > 0) for x, y in data) / len(data)
        print(f"step {step:3d}  loss {sum(losses)/len(losses):.4f}  acc {acc:.2%}")

跑起来你会看到 loss 下降、acc 爬升——这是你亲手从数学造出来的学习，里面没有一行 PyTorch。

4.3 验证正确性：数值梯度

自动求导写错了不报错，只会”学得慢”。验证方法是对拍：用定义 $(L(\theta+\epsilon) - L(\theta-\epsilon)) / 2\epsilon$ 数值算梯度，和引擎的 grad 对比。PyTorch 里对应 torch.autograd.gradcheck。养成对新写的梯度代码做数值对拍的习惯——这是你区别于”纯 vibe coder”的第一个标志。

5. 初始化：为什么一开始就”该差不多”

若权重全零或方差过大，信号会逐层衰减/爆炸。经验规则：

• He 初始化（ReLU 配套）：$W \sim \mathcal{N}(0, 2/n_{in})$
• Xavier（tanh/sigmoid 配套）：$W \sim \mathcal{N}(0, 1/n_{in})$

现代大模型初始化的要点其实就一句话：让每一层输出的方差和输入大致相同。残差连接的层常乘一个 0.02~0.1 的小系数（GPT 做法），让训练初期网络接近恒等映射。

6. Normalization：从 BatchNorm 到 RMSNorm

问题：深层网络里，前面层的参数一变，后面层看到的输入分布就漂移，训练不稳。

• BatchNorm：对每个通道，用 batch 内统计量做标准化 + 可学习的缩放平移。CNN 时代标配。缺点：依赖 batch 统计（推理时要用训练期累计的滑动平均），batch 小时不稳。
• LayerNorm：对每个样本自己的所有特征做标准化，与 batch 无关。Transformer 标配。
• RMSNorm：LayerNorm 的简化——只除以均方根、不减均值，少一半计算。LLaMA/Qwen 系全部用它。省掉的均值中心化被证明基本无害，这是”简单方法赢了”的又一例。

卷2 拆 GPT 架构时会再见到 RMSNorm；现在只需要知道它的位置（每个子层前，Pre-Norm）和动机（稳定深层训练）。

7. NumPy ↔ 引擎 ↔ PyTorch 概念映射表

你会发现第 0.2 章的训练循环和 4.2 节的训练循环逐行同构。从此 PyTorch 对你不再是黑盒。

8. 自测题

1. 为什么 __add__ 的 _backward 里用 +=？举一个会出错的场景。（c = a + a；共享节点梯度叠加）
2. 加法的反向传播是什么形式？乘法呢？（恒等分摊给两边；交叉乘对方的值）
3. 为什么拓扑排序必须”逆序”执行 _backward？（梯度依赖下游已算完，loss 是根，逆拓扑 = 从根到叶）
4. tanh 导数在 |x| 很大时趋近多少？这对梯度意味着什么？（0；饱和区梯度消失，GELU/ReLU 缓解此问题）
5. 为什么全零初始化会让”对称神经元”永远一样？（同层神经元收到相同梯度，永远同步更新，网络等效宽度 1）
6. BatchNorm 和 LayerNorm 的统计维度差在哪？为什么 LLM 用后者？（BN 沿 batch 维统计、LN 沿特征维；LLM 序列长度可变且 batch 小，且推理不依赖滑动统计）
7. RMSNorm 砍掉了什么？为什么基本无害？（减均值；特征均值信息弱，且残差流本身提供中心化）
8. 数值梯度的公式是什么？$\epsilon$ 太大会怎样、太小会怎样？（中心差分；太大截断误差、太小浮点舍入，一般 1e-5 左右）

9. 动手作业

1. 给 Value 加 exp、log 方法，并推导它们的 _backward。（提示：d(e^x)/dx = e^x，前向已算出的 out.data 可直接复用）
2. 用数值梯度对拍验证第 1 题和整个 MLP 的梯度（构造 20 个随机输入，最大相对误差应 < 1e-6 量级）。
3. 把玩具任务换成 XOR 和”同心圆环”（$r<0.3$ 或 $r>0.6$ 为正类），观察不同宽度的网络谁学得动——体会”容量”。
4. 挑战题：把引擎升级成支持向量化的版本（参考 Karpathy 后续的 micrograd → tinygrad 思路），为卷1手写 attention 做准备。

10. 延伸资源

• Karpathy《The spelled-out intro to neural networks and backpropagation》（YouTube/B站）——与本章一一对应
• micrograd 官方 repo（约 100 行）——读完本章后对照
• 《Neural Networks: Zero to Hero》系列 playlist——通往卷2 的 GPT 章节

0.4 训练工程常识：混合精度、断点续训、调试与监控

本章目标：把”能跑起来”和”跑得专业”之间的差距补上。这些是 AI 代码助手最容易漏掉、而实验失败时最烧时间的部分。学完标准：你的训练脚本具备断点续训、梯度裁剪、EMA、完整日志四件套，并且知道”训练出问题时的标准排查顺序”。

1. 混合精度（AMP）：不只是”换个 dtype”

原理拆解：训练时前向和反向用低精度（bf16/fp16）加速，但主权重和优化器状态保持 fp32：

• 前向在 autocast 里：框架自动把 matmul/conv 换成低精度，而 softmax、log、norm 统计等对精度敏感的算子保持 fp32（框架替你做了，但自己手写 loss 时要注意：对 logits 求对数前先 .float() 是保命习惯）；
• fp32 主权重：梯度更新量可能小于低精度的最小可表示数，直接在 fp16 权重上累加会被”吞掉”，所以低精度只是”计算现场”，真身永远 fp32；
• GradScaler 只在 fp16 下需要：fp16 指数位只有 5 位，小梯度会下溢为 0，所以先放大 loss（乘个 2^16 级别的数），反向后再缩小。bf16 指数位与 fp32 相同，动态范围大，完全不需要 scaler——这就是现代 GPU 上 bf16 一统江湖的原因。

回报：速度约 2 倍、显存大头（激活）减半。纪律：所有训练默认开 AMP；报 NaN 时第一嫌疑人是精度/学习率。

2. 梯度裁剪：LLM 训练的保险丝

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

放在 backward() 之后、step() 之前：若全体梯度的 L2 范数超过阈值，按比例整体缩小。动机：训练中偶发 loss spike（坏数据、精度抖动），spike 往往伴随梯度爆炸，一步就把权重打飞。NLP/LLM 训练默认裁剪到 1.0；CV 分类任务可不加。日志里同时记录裁剪前的 grad norm——它的突变是最好的异常报警器。

3. EMA：训练一份，评测另一份

指数滑动平均：维护权重影子副本 $\theta_{EMA} \leftarrow \beta \theta_{EMA} + (1-\beta)\theta$（$\beta$ 常取 0.999）。理论依据：SGD 最终解附近来回震荡，EMA 是”震荡轨迹的平均”，落在更平坦的盆里，评测/部署普遍好零点几个点。LLM 和扩散模型训练标配（checkpoint 里经常同时存 raw 和 ema 两份权重）。实现可以直接用 torch.optim.swa_utils.AveragedModel，或几十行手写。

4. 断点续训（长训练的命根子）

只存 model.state_dict() 是新手做法。完整的 checkpoint 至少包含五样东西——否则中断后训练无法严格复原：

ckpt = {
    "model": model.state_dict(),
    "opt":   opt.state_dict(),        # AdamW 的动量状态丢了 = 训练"失忆"
    "sched": sched.state_dict(),      # 学习率进度
    "epoch": epoch,
    "rng":   torch.get_rng_state(),   # 随机状态（数据增强、dropout）
}
torch.save(ckpt, f"ckpt_ep{epoch}.pth")

# 恢复
model.load_state_dict(ckpt["model"]); opt.load_state_dict(ckpt["opt"])
sched.load_state_dict(ckpt["sched"])
for ep in range(ckpt["epoch"] + 1, total): ...   # 从断点继续

工程惯例：定期存（每 N epoch）+ 只留最近 2 份 + 单独留最优 1 份，硬盘会被写爆的。LoRA 微调时额外注意：get_peft_model 后的模型要存 peft 格式，别直接存完整 state_dict（10GB 白送给硬盘）。

5. 可复现性三件套

1. 全链路 seed：random、numpy、torch、torch.cuda 各设一次（封装成 set_seed(s) 函数）；
2. 记录配置：git commit hash + 完整超参 dump 成 json/yaml 随 checkpoint 一起存——三个月后你会感谢自己；
3. 接受不完全复现：cuDNN 非确定性算子（torch.backends.cudnn.deterministic=True 可关掉但速度损失大）。原则：复现 seed 内逐位一致不追求，追求同配置下结果稳定（多次运行指标方差小于效应量）。

6. 监控清单：训练时到底看什么

用 wandb（或 tensorboard）记录，缺一不可：

训练远程挂着时的正确姿势：loss spike 报警（wandb alert）+ 每小时自动 checkpoint，而不是盯屏。

7. 调试的标准动作：单 batch 过拟合

任何新模型/新数据/新 loss，跑全量训练前先做这一步——DL 调试的第一定律：

x, y = next(iter(train_loader))          # 只取一个 batch
for i in range(200):
    loss = train_step(model, x, y)       # 反复喂同一个 batch
print(loss)   # 必须趋近 0

• loss 降不到接近 0 → 代码有 bug（标签错位、loss 写错、数据没对齐、梯度断了），不是模型能力问题。先修代码再谈调参；
• 能过拟合单 batch 但全量数据学不动 → 数据量/容量/增强过度的问题，方向是调参而非 debug。

配套两招：① 训练前可视化 8 个样本及其标签（眼睛看，30 秒抓住标签错位）；② 先用最小模型 + 5% 数据跑通全流程（含评估和 checkpoint），再放大。顺序错了就是”训了 8 小时才发现标签错位”的悲剧。

8. 训练时长估算（租卡前必做）

$\text{时长} = \frac{\text{样本数} \times \text{epoch}}{\text{batch size} \times \text{吞吐(samples/s)}}$

例：LoRA 微调 7B，1 万条样本、3 epoch、batch 4、4090 实测约 0.5 samples/s → 10000×3/(4×0.5×3600) ≈ 4.2 小时 ≈ 10 元。下单前先跑 50 step 实测吞吐再乘，不要拍脑袋。

9. 自测题

1. AMP 里什么是 fp32、什么是 bf16？为什么主权重必须 fp32？（激活与计算用 bf16；权重/优化器状态 fp32；低精度累加小更新会被吞）
2. bf16 为什么不需要 GradScaler？（指数位 8 位同 fp32，动态范围大，小梯度不下溢）
3. GradScaler 只在哪一步起作用？（backward 前 scale loss，step 前 unscale 梯度）
4. 断点续训只存模型权重会怎样？（优化器动量清零、lr 进度重置、随机流错位——训练”失忆”且结果不可比）
5. 单 batch 过拟合降不到 0，说明什么？（代码有 bug，按标签→loss→数据对齐→梯度链顺序排查）
6. grad norm 趋近 0 且 loss 不降，两种可能？（学习率太小/梯度断了（detach 误用）；或模型输出饱和）
7. 吞吐骤降但 GPU 利用率低，先查什么？（数据加载：num_workers、磁盘 IO、pin_memory）

10. 动手作业（把 0.2 的脚本升级为”专业版”）

给 CIFAR 脚本加装四件套，每件独立 commit：

1. set_seed 函数 + 配置 dump 成 json；
2. 完整 checkpoint（第 4 节五要素）+ 断点续训自测（kill 掉重启，loss 曲线应无缝衔接）；
3. clip_grad_norm_ + wandb 记录 grad norm；
4. 单 batch 过拟合测试脚本 debug_overfit.py，以及一个故意注入标签错误的版本，观察它如何暴露问题。

11. 延伸资源

• Karpathy 博客《A Recipe for Training Neural Networks》——本章的加长原版，必读
• PyTorch 官方文档 AMP / autocast 页——API 细节查询
• wandb 官方 quickstart——10 分钟接入

0.5 Git / Linux / 远程开发生存包

本章目标：把”租了卡连不上、跑了实验找不到、改了代码乱了版”这三类新手事故一次性免疫——Git 工作流、Linux 命令生存集、远程开发环境三件套。学完标准：能独立在 AutoDL 上开机 → 拉代码 → 后台训练 → 断线恢复 → 取回结果。

1. Git：五个动作 + 一条铁律

日常 95% 的场景只需要：

git clone <url>                 # 取
git checkout -b feat/xxx        # 开分支（实验与主线隔离）
git add -p && git commit -m "..."   # 小步提交（-p 逐块审，防误提交大文件）
git push origin feat/xxx        # 推
git log --oneline / git diff    # 查

铁律：数据、权重、大文件不进 Git（.gitignore 里写死 data/ checkpoints/ *.pth *.gguf）——Git 是管代码的，二进制让它的一半历史都会爆。大文件的正确归宿：HuggingFace/ModelScope（模型）、网盘/对象存储（数据）、wandb（实验记录）。

与实验管理的接线（0.4 §5）：每次实验记录 git commit hash——三个月后”这个结果对应哪版代码”永远有答案。

2. Linux 生存二十条（租卡环境的全部日常）

# 看：系统在干什么
nvidia-smi                # GPU 占用（watch -n1 nvidia-smi 持续看）
htop                      # CPU/内存；df -h 磁盘；free -h 内存
# 找：文件与文本
find . -name "*.pth"      # 按名找；du -sh * 看各目录体积（磁盘爆前的第一动作）
grep -rn "OOM" logs/      # 文本内搜（-r 递归 -n 行号）
# 管：进程
ps aux | grep python      # 找进程；kill -9 <pid> 清僵尸（7.1 的第一步）
# 传：本地 ↔ 服务器
scp local.zip user@host:/root/          # 上传；反向即下载
# 解压/环境
tar -xzf file.tar.gz ; unzip file.zip

强制纪律：长训练必须挂后台——SSH 断线 = 前台进程死光 = 白训一夜（新手最痛的一课）：

tmux new -s train         # 新建会话，在其中跑 python train.py
# Ctrl+B 再按 D 脱离（进程继续）；tmux attach -t train 随时回来
tmux ls                   # 查看所有会话

tmux/screen 二选一学会即可，这 30 分钟的学习换来你所有长训练的安全。

3. 远程开发三件套（按舒适度递增）

1. SSH 直连：ssh -p <端口> root@<主机>（AutoDL 会给完整命令）；密钥登录（ssh-keygen + 上传公钥）免密码；
2. VS Code Remote-SSH（推荐）：本地 VS Code 装插件 → 连远程 → 像本地一样编辑远程文件、开远程终端、断点调试——本地写码的舒适 + 远程算力的实惠一次拿到；
3. JupyterLab（平台自带）：交互探索/画图方便，长训练仍走 tmux。

租卡流程模板（AutoDL 为例）：开机 → 进 ~/autodl-tmp（数据盘，不扣费空间大）→ 克隆代码 → 下数据（huggingface-cli download 或平台网盘）→ 装环境（优先用平台的镜像/pip install -r requirements.txt）→ 先跑 50 step 冒烟（0.4 §8 的算力估算）→ tmux 里挂长训练 → 关机前把 checkpoint 拷回数据盘/下载。磁盘会满、进程会残留、接口会记错端口——第 2 节的命令就是为这些准备的。

4. 自测题

1. Git 铁律是什么？大文件的三个正确归宿？（数据权重不进库；HF/网盘/wandb）
2. 为什么前台跑长训练是事故？（SSH 断=进程死；tmux 会话独立于连接）
3. tmux 脱离和杀掉的区别？（detach 保留进程 / kill 终止）
4. 磁盘告急的第一个动作？（du -sh * 定位大头 + 清 checkpoint/缓存）
5. 远程开发推荐哪套？它解决了什么？（VS Code Remote——本地体验+远程算力）
6. 租卡流程里”冒烟”指什么？为什么必做？（50 step 实测吞吐与显存——估算租期与预算，防”跑了一天才发现配置错”）

5. 动手作业（今天就能练，全部免费）

1. 给你的笔记/代码 repo 建正式 Git 仓库：写好 .gitignore，完成”开分支→提交→合并”一轮；
2. 本机装 tmux（Windows 用 WSL 或 Git Bash 的 screen），体验 detach/attach 三次；
3. 试跑 VS Code Remote-SSH：连任意一台你能访问的机器（或本地 WSL）；
4. 挑战：在 Kaggle/魔搭的免费环境里完成”clone 你自己的 repo → 跑通 CIFAR 5 epoch → 把日志和权重取回本地”的完整闭环——这个闭环跑通，你就有了全世界的算力。

6. 延伸资源

• 《Pro Git》前 2、3 章——免费官方书，够用终身
• The Missing Semester（MIT）——Shell/Git/工具课，与本章互补的第一名
• AutoDL 帮助文档——平台细节（端口/网盘/镜像）

1.1 从 CNN 到 ResNet：卷积时代的遗产

本章目标：用最小的篇幅吃透卷积神经网络——不是为了拥抱传统，而是因为：① 视觉 Transformer 至今仍在用卷积做 patch 化和下采样；② 小数据、小模型、边缘部署场景 CNN 仍是首选；③ CNN 时代沉淀的训练技术（数据增强、初始化、残差、蒸馏）全部延续到了大模型时代。学完标准：能手写 ResNet-18 在 CIFAR-10 上跑到 93%+，并能讲清”为什么残差连接有效”。

1. 卷积的四种视角（核心中的核心）

一维卷积你已熟悉（0.3 章）。二维图像卷积 $O[i,j] = \sum_{m,n} K[m,n]\, I[i+m, j+n]$ 有四种等价的理解，调试和阅读论文时来回切换：

1. 模板匹配：卷积核是一组可学习的权重模板，滑动扫描图像找模式。第一层学到的常是边缘/色块检测器（Gabor 形状），这是数据自己学出来的，不是设计出来的。
2. 感受野：输出某一点”看得见”输入的多大范围。堆叠规律：每叠一层 3×3 卷积，感受野 +2——两层 3×3 = 5×5 的感受野，但参数只有 2×9=18 而不是 25，还多了一次非线性。小核堆叠优于大核，这条设计法则统治了 2014–2020。
3. 参数共享：同一组核扫过全图 = “猫在左上角和右下角是同一种猫”的先验。这叫平移等变性。全连接层没有这个先验，所以需要更多数据——这个观点是理解”卷积 → Transformer”变迁的钥匙（见第 6 节）。
4. 稀疏的矩阵乘法：卷积 = 权重共享的全连接层（用 im2col 展开后就是一次矩阵乘）。所以 GPU 对卷积优化得极好，卷积从不”慢”在数学上，而是”慢”在内存访问模式上。

实用公式（必背）：输出尺寸 $= \lfloor (N + 2P - K)/S \rfloor + 1$（输入 N、核 K、填充 P、步长 S）。参数量 $= K \times K \times C_{in} \times C_{out}$（无 bias 时）。

2. 一个现代卷积块的标准结构

$\text{Conv}(\text{no bias}) \rightarrow \text{BatchNorm} \rightarrow \text{ReLU}$

• Conv 不带 bias：因为 BN 里本来就有可学习的平移项，加 bias 纯属浪费参数；
• BN 在 0.3 章讲过：稳定各层输入分布；
• 1×1 卷积：跨通道的加权混合，用于降维/升维（bottleneck 结构里先降再升，省算力）；
• 池化/步长卷积负责下采样：MaxPool 取局部最大（保显著特征），步长卷积让下采样本身可学习（现代默认）。

3. ResNet：深度的闸门被打开

2015 年之前，网络加深到 20+ 层反而变差——不是过拟合（训练误差也差），而是退化：深层网络难以优化。

残差连接把每个块改成学习”增量”：$y = x + F(x)$，其中 $F$ 是普通卷积堆。

为什么有效（两层解释都要会）：

1. 梯度直通：反向传播时 $\frac{\partial y}{\partial x} = 1 + \frac{\partial F}{\partial x}$，那个”1”给梯度修了一条高速公路，100 层的梯度也不会层层衰减。消融实验：110 层网络去掉残差后训练误差降不下去，加上后正常——证明是优化问题而非容量问题。
2. 学习目标的重塑：网络学的是”在恒等映射基础上改多少”。对多数层来说最优解接近恒等，把恒等设为默认值，让”什么都不做”变得容易——这是所有现代架构（Transformer 残差流、LoRA 的 $\Delta W$）共享的哲学：学习增量，而不是从头学。

代码（BasicBlock，背下来，作业要用）：

import torch, torch.nn as nn

class BasicBlock(nn.Module):
    def __init__(self, cin, cout, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(cin, cout, 3, stride, 1, bias=False)
        self.bn1   = nn.BatchNorm2d(cout)
        self.conv2 = nn.Conv2d(cout, cout, 3, 1, 1, bias=False)
        self.bn2   = nn.BatchNorm2d(cout)
        self.shortcut = nn.Sequential()                      # 默认恒等
        if stride != 1 or cin != cout:                       # 形状不一致时用 1×1 投影
            self.shortcut = nn.Sequential(
                nn.Conv2d(cin, cout, 1, stride, bias=False),
                nn.BatchNorm2d(cout))
    def forward(self, x):
        out = torch.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        return torch.relu(out + self.shortcut(x))            # y = x + F(x)

ResNet-18 = 一个 7×7 stem + 4 个 stage（每 stage 2 个 BasicBlock，通道 64→128→256→512）+ 全局平均池化 + 线性头。CIFAR-10 上把 stem 换成 3×3（图像小，7×7 太浪费）。

4. CNN 时代留给大模型时代的遗产

这些技术你会在所有后续章节反复遇到，现在建立索引：

5. 检测与分割：知道即可

• 检测：YOLO 系（快，工业部署多）、DETR 系（transformer 化）；分割：FCN → U-Net（医学影像至今主流）→ Mask R-CNN → SAM。你不需要复现它们，只需要：知道任务定义、知道 U-Net 的编码器-解码器 + 跳跃连接结构（扩散模型的 U-Net 就是它）、知道 SAM 是”可提示分割基础模型”（1.7 章）。

6. 卷积让位给了什么？——归纳偏置与数据规模的交易

卷积内置了两个先验：局部性（近邻像素相关）+ 平移等变。先验强 = 小数据学好，大数据下变成天花板（没法学全局关系，感受野增长太慢）。ViT 的赌注是：把图像切成 16×16 patch 当作 token 序列，用几乎无视觉先验的 Transformer，让数据补足先验——数据规模到亿级后反超 CNN，且天然兼容文本 token（这条兼容性直接通向多模态，卷3 的主角）。

记住这条主线：CV 的十年 = 先验逐渐变少、数据规模逐渐变大、架构逐渐统一到 Transformer。这不是”CNN 错了”，而是不同数据规模下的最优权衡。小数据（医学影像标注贵）场景 CNN/混合架构至今能打。

7. 自测题

1. 输入 224×224，3×3 卷积、stride=2、padding=1，输出多大？（112×112，套公式）
2. 为什么现代卷积块里 Conv 不带 bias？（BN 的平移参数替代了它）
3. 两层 3×3 卷积的感受野等于一层多大卷积？参数量对比？（5×5；18 vs 25，还多一次非线性）
4. 残差连接的梯度公式里”1”意味着什么？（梯度至少有一部分不衰减地直通，缓解深层退化）
5. “学习增量而非从头学”这个哲学还出现在哪两处？（Transformer 残差流；LoRA 的低秩增量）
6. ViT 为什么在大数据下反超 CNN？（弱先验架构容量上限高，数据规模补足先验）
7. U-Net 的跳跃连接解决什么问题？（下采样丢失的空间细节通过 skip 直接传给解码器；扩散模型沿用此结构）

8. 动手作业

1. 用第 3 节的 BasicBlock 搭 CIFAR 版 ResNet-18（stem 用 3×3，无 maxpool），在 0.2 章训练脚本里替换 Net，目标 ≥93%（配合 TrivialAugment 增强）。
2. 训练完后可视化第一层卷积核（model.features[0].weight 归一化后 plt.imshow）——亲眼看看”学出来的边缘检测器”。
3. 挑战：故意删掉所有 shortcut 再训 20 epoch，对比训练曲线，亲手复现”退化”现象。
4. 把你的训练记录写成 README 传 GitHub——作品集第一块砖。

9. 延伸资源

• CS231n 课程笔记（卷积网络部分）——卷积直觉的第一名
• 李沐《论文精读》ResNet 一期 + 原论文 Deep Residual Learning（2015）
• CS231n 2024 新版公开课——后半程直接过渡到 Transformer

1.2 注意力机制：从加权检索到万物的基础操作

本章目标：把”注意力”从玄学变成一个你闭眼能写的函数。它是整个大模型时代唯一的计算原语——CV 里它取代了卷积，LLM 里它就是全部，多模态里它负责图文对齐。学完标准：能手写带 causal mask 的多头注意力并与 PyTorch 内置实现对拍，能解释 1/√d 的来历。

1. 为什么需要注意力：RNN 的两大死穴

Transformer 之前序列建模靠 RNN/LSTM：逐 token 读取，用隐状态”记忆”历史。两个致命问题：

1. 无法并行：第 t 步依赖第 t−1 步，GPU 上万个核心干等着看一个序列爬行；
2. 长程依赖衰减：信息要经过 O(N) 次状态更新才能传到远处，距离一长就被冲淡（梯度消失的序列版）。

注意力的解法釜底抽薪：不递归传递信息，让任意位置一步直达任意位置——距离消失，同时整个序列的计算可以一次矩阵乘完成。2017 年《Attention Is All You Need》标题的狂妄就在于此。

2. 注意力的通用形式：一次可微分的”查字典”

想象查字典：你有一个查询 Q（想找什么），字典里每个词条有键 K（索引）和值 V（内容）。硬字典是 argmax 检索（不可导），注意力做的是软检索：

$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V$

三步拆解（每步都有几何直觉）：

1. 打分：$QK^\top$ 算出每个 query 和每个 key 的内积——内积 = 对齐程度 = 相关性（0.1 章 §2.1）；
2. 归一化：softmax 把分数变成总和为 1 的权重分布——“把 100% 注意力分配给各位置”；
3. 加权求和：输出 = 各位置的 value 按注意力权重混合。

一句话本质：注意力是按相关性加权的加权平均，而相关性用内积度量，权重用 softmax 归一，全部可导，因此可以端到端学习。 图像块之间做它 = ViT；图像与文本之间做它 = CLIP 式对齐；序列自己内部做它 = GPT。万物皆注意力。

3. 为什么除以 √d_k（面试与理解双高频）

假设 q 和 k 的各分量独立、零均值、方差 1，则内积 $q \cdot k = \sum_{i=1}^{d} q_i k_i$ 的方差是 $d$（方差相加），标准差 $\sqrt{d}$。d=128 时，打分普遍在 ±11 上下波动——softmax 在这么大的输入下会饱和：最大项拿到几乎全部概率，其余趋近 0，梯度消失，且分布对输入噪声极其敏感。

除以 $\sqrt{d_k}$ 把打分的方差拉回 1，softmax 保持”清醒”。这是”方差控制”思想——和初始化（0.3 章 §5）、RMSNorm 是同一个思想在不同位置的应用：让每层输出的数值尺度保持稳定。

4. Self-Attention 与 Multi-Head

• Self-attention：Q、K、V 全部来自同一个序列（各自过三个线性投影 $W_Q, W_K, W_V$）。每个位置同时是查询者、被查者和内容提供者——序列内的信息交换。
• Cross-attention：Q 来自 A 序列，K/V 来自 B 序列。多模态的桥（LLaVA 里文本 query 查图像特征）、翻译里译文查原文，都是它。
• Multi-Head：把 d 维投影拆成 h 个 64 维子空间，各自独立做注意力再拼接。动机：一组 QKV 只能表达一种”关注模式”，多头 = 多个视角并行（语法一=head1，指代一=head2……）。与 CNN 的多通道异曲同工：并行多组特征提取器，各学各的。

5. Causal Mask：让 GPT 不会”作弊”

语言模型预测第 t 个 token 时只能看前文。实现：把 $QK^\top$ 矩阵的上三角（未来位置）在 softmax 前填 $-\infty$，softmax 后权重为 0：

mask = torch.tril(torch.ones(N, N, dtype=torch.bool))   # 下三角为 True
scores = scores.masked_fill(~mask, float("-inf"))

记住这个机制的名字：解码器里的自回归 = causal mask + 逐位预测。卷3 LLaVA 复现、卷4 自回归生成模型（Janus 路线），全靠它。

6. 手写实现 + 对拍（本章作业的骨架）

import torch, torch.nn as nn, torch.nn.functional as F, math

def attention(q, k, v, mask=None):
    """q,k,v: (B, H, N, D)  mask: (N, N) bool, True=可见"""
    d = q.size(-1)
    scores = q @ k.transpose(-2, -1) / math.sqrt(d)          # (B,H,N,N)
    if mask is not None:
        scores = scores.masked_fill(~mask, float("-inf"))
    return F.softmax(scores, dim=-1) @ v                     # (B,H,N,D)

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_head):
        super().__init__()
        assert d_model % n_head == 0
        self.h, self.dh = n_head, d_model // n_head
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)   # 一次投影三份，省两次 GEMM
        self.proj = nn.Linear(d_model, d_model, bias=False)      # 输出融合投影
    def forward(self, x, mask=None):
        B, N, D = x.shape
        q, k, v = self.qkv(x).split(D, dim=2)                    # 各 (B,N,D)
        q, k, v = (t.view(B, N, self.h, self.dh).transpose(1, 2) for t in (q, k, v))  # (B,H,N,dh)
        out = attention(q, k, v, mask)                           # (B,H,N,dh)
        out = out.transpose(1, 2).contiguous().view(B, N, D)
        return self.proj(out)

# 对拍验证
x = torch.randn(2, 16, 128)
mha = MultiHeadAttention(128, 8); mha.eval()
mine = mha(x)
q, k, v = mha.qkv(x).split(128, dim=2)
ref = F.scaled_dot_product_attention(
    q.view(2,16,8,16).transpose(1,2), k.view(2,16,8,16).transpose(1,2), v.view(2,16,8,16).transpose(1,2))
ref = ref.transpose(1,2).reshape(2,16,128)
print((mha.proj(ref) - mine).abs().max())   # 应 < 1e-6

工程常识：真实训练用 F.scaled_dot_product_attention——它自动分派到 FlashAttention 内核。FlashAttention 你不需要实现，只需记住它的思想：不做优化数学，优化显存读写（避免把巨大的 N×N 注意力矩阵写进显存再读出来，用分块重算换取 10 倍级速度）——这是”系统工作”在大模型里值钱程度的最好例子。

7. 代价与对比

• 复杂度 $O(N^2 d)$：注意力矩阵 N×N 是显存和时间的大头。长上下文、高分辨率图像（patch 数多）、视频（帧数爆炸）的成本都从这里来——卷3/4 里所有”长上下文""多帧”问题，根源都是这个平方项。
• 与卷积的对比表（理解架构选择的地图）：

8. 自测题

1. 注意力的三步是什么？各自的作用？（打分/归一化/加权求和）
2. 1/√d 的方差推导为什么假设零均值独立？（中心极限式的和：分量方差相加，d 项 → 方差 d）
3. Self 和 Cross attention 的区别一句话？（Q 和 K/V 是否同源）
4. 为什么多头而不是一个大的头？（多组子空间并行学不同关注模式；总计算量不变）
5. causal mask 填 −∞ 而不是 0，为什么？（softmax 后 0 权重需要 −∞ 分数；填 0 会产生非零注意力泄漏未来信息）
6. 注意力的平方复杂度在哪一步产生？它如何影响视频生成的帧数上限？（$QK^\top$ 的 N×N 矩阵；帧数↑→N↑→平方爆炸）
7. FlashAttention 优化的是什么资源？（显存读写 IO，不是浮点计算）

9. 动手作业

1. 跑通第 6 节对拍代码；然后给 MultiHeadAttention 加 causal mask 支持，用 is_causal=True 的内置实现再对拍。
2. 可视化注意力：随机初始化 + 训练一个 2 层小模型在玩具序列任务上（如反转数字序列），用 matplotlib 画 softmax(scores) 热力图，观察注意力”看见了什么”。
3. 把第 6 节的 MHA 包进 Transformer block（残差 + LayerNorm + MLP），就是 1.3 章的开头——提前搭好骨架。
4. 挑战：读 FlashAttention 论文第 1-2 节，用三句话讲清”分块 + 重算”为什么省显存。

图解 · 一次注意力的完整数据流

flowchart TB
  X["输入 x (B×N×D)"] --> QKV["单个 Linear 投影出 3D 维"]
  QKV --> S["拆成 Q / K / V (B×H×N×d_h)"]
  S --> SC["scores = QKᵀ/√d_h  →  (B×H×N×N)"]
  SC --> M["causal mask：未来位置填 −∞"]
  M --> SM["softmax（每行归一成权重）"]
  SM --> AV["加权求和 scores @ V"]
  AV --> CO["concat 所有头 (B×N×D)"]
  CO --> PJ["输出投影 W_O"]

平方成本就藏在 scores 那个 N×N 矩阵里——N 翻倍它变四倍：这是 2.3 的 KV cache 账、2.8 的 prefill 瓶颈、3.3 的 token 压缩，全部问题的同一源头。

案例：两个 token 的迷你注意力（全手算）

设 D=2、单头，序列 [“the”, “cat”]，投影后 $q_1=[1,0]$，$k_1=[1,1],\ k_2=[0,1]$，V 取值同 K。

位置 1（有 causal mask）只看自己 → 权重 $[1, 0]$； 位置 2 看两个：$s_{2,1}=1{\cdot}1+0{\cdot}1=1$，$s_{2,2}=0{\cdot}1+1{\cdot}1=1$ → softmax 各 0.5 → 输出 $o_2 = 0.5\,v_1 + 0.5\,v_2 = [0.5,\ 1]$。

你刚刚手动执行了 GPT 的一层。四句话总结注意力：mask 决定能看谁，内积决定多想看，softmax 归一成百分比，加权求和取材料。

10. 延伸资源

• 李沐《论文精读》Transformer 一期——逐段精读 Attention Is All You Need
• Jay Alammar《The Illustrated Transformer》——图解第一名
• Karpathy《Let’s build GPT: from scratch》——本笔记 1.3/2.3 章的实拍版

1.3 Transformer 逐层拆解：从 Block 到小 GPT

本章目标：把 1.2 的注意力装进完整的 Transformer，逐个组件搞清”它解决什么问题、现代版本是什么”，最后手写一个能跑的小 GPT。这一章是卷2（LLM 内功）的地基——学完它，nanoGPT 对你只剩工程细节。前置：1.2（注意力）、0.3（RMSNorm）。

1. 宏观地图：三种架构，为什么 decoder-only 赢了

decoder-only 胜出的原因（面试高频）：训练目标最简单（每个位置都预测下一个 token，1 个 token 的数据产出 1 个监督信号）、生成和理解是同一件事（都是”给定前文续写”）、架构最简（没有 encoder-decoder 的交互设计）、天然支持 in-context learning。BERT 式”完形填空”目标学到的表示很好，但生成弱、扩展性叙事输给了 GPT。

2. Block 结构：Pre-Norm 为什么取代了 Post-Norm

原版 Transformer（Post-Norm）：

$x = \text{LN}(x + \text{Attn}(x)) \quad\text{→}\quad x = \text{LN}(x + \text{MLP}(x))$

现代（Pre-Norm，GPT-2 之后所有主流模型）：

$x = x + \text{Attn}(\text{LN}(x)) \quad\text{→}\quad x = x + \text{MLP}(\text{LN}(x))$

区别在 Norm 包住的是子层输入还是子层输出。Pre-Norm 的残差主干上没有任何变换，梯度从顶层直通底层不经过任何 LN/非线性——深层网络（百层）训练稳定的关键。代价是表达力略降，所以现代模型在最后加一个 final norm（你读 Qwen/LLaMA 代码时看到的 ln_f 就是它）。0.3 章讲过 Norm 本身，现在你有了它为什么”在这里”的完整答案。

3. 逐组件拆解

3.1 输入端：token embedding + 位置信息

注意力本身是置换等变的——打乱输入顺序，输出跟着同样打乱，“位置”完全丢失。序列任务必须显式注入位置：

• 正弦编码（原版）：固定三角函数，相对位置可线性表达；
• 可学习绝对位置（GPT-2）：一张 nn.Embedding(n_ctx, d) 表，简单有效，但不能外推到训练长度之外；
• RoPE（旋转位置编码）：现代主流（LLaMA/Qwen/GLM 全家）。直觉版：把 q、k 的维度两两配对，在 attention 内积前按位置旋转一个角度——旋转角随位置线性增长，于是 $q_m \cdot k_n$ 只依赖相对距离 $m-n$，天然相对位置、天然可外推（配合 NTK/YaRN 等缩放技巧做长上下文）。不需要会推导，需要会一句话讲清思想和好处。

3.2 注意力层

1.2 章已手写。现代补充细节：qkv 用一个矩阵一次投影（省两次 GEMM）；对 q、k 做 norm（QK-Norm，稳定大模型训练的新趋势，Qwen3 等在用）。

3.3 MLP：不比注意力次要

原版：Linear(d → 4d) → GELU → Linear(4d → d)，占每层约 2/3 参数（见第 5 节的账）。现代升级为 SwiGLU：三个矩阵（gate/up/down），down(silu(gate(x)) * up(x))——门控让网络自己决定”哪些特征放行”。LLaMA/Qwen 全在用；为保持参数量与 4d 版本对齐，中间维度取约 8d/3。注意力的作用是”位置间搬运信息”，MLP 的作用是”位置内加工信息”——可解释性研究（残差流视角）的基本分工认知。

3.4 残差流视角（建立这个心智模型）

把 Block 看成：残差主干是一条”信息高速公路”，注意力层和 MLP 层以加法方式向主干读写信息。训练后期大量层接近恒等映射。这个视角来自可解释性研究，但工程上同样有用：调 bug 时想”信息怎么流的”比想”第几层算错了”更有效。

4. 手写小 GPT（完整可运行）

import torch, torch.nn as nn, torch.nn.functional as F, math

class CausalSelfAttention(nn.Module):
    def __init__(self, d, h, n_ctx):
        super().__init__()
        self.h, self.dh = h, d // h
        self.qkv = nn.Linear(d, 3 * d, bias=False)
        self.proj = nn.Linear(d, d, bias=False)
        mask = torch.tril(torch.ones(n_ctx, n_ctx)).view(1, 1, n_ctx, n_ctx)
        self.register_buffer("mask", mask)          # 随模型保存/迁移，不参与训练
    def forward(self, x):
        B, N, D = x.shape
        q, k, v = self.qkv(x).split(D, dim=2)
        q, k, v = (t.view(B, N, self.h, self.dh).transpose(1, 2) for t in (q, k, v))
        att = (q @ k.transpose(-2, -1)) / math.sqrt(self.dh)
        att = att.masked_fill(self.mask[:, :, :N, :N] == 0, float("-inf"))
        y = F.softmax(att, dim=-1) @ v
        y = y.transpose(1, 2).contiguous().view(B, N, D)
        return self.proj(y)

class Block(nn.Module):
    def __init__(self, d, h, n_ctx):
        super().__init__()
        self.ln1, self.ln2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = CausalSelfAttention(d, h, n_ctx)
        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
    def forward(self, x):                            # Pre-Norm
        x = x + self.attn(self.ln1(x))
        x = x + self.mlp(self.ln2(x))
        return x

class TinyGPT(nn.Module):
    def __init__(self, vocab, d=256, h=4, L=4, n_ctx=128):
        super().__init__()
        self.tok = nn.Embedding(vocab, d)
        self.pos = nn.Embedding(n_ctx, d)
        self.blocks = nn.ModuleList([Block(d, h, n_ctx) for _ in range(L)])
        self.ln_f = nn.LayerNorm(d)
        self.head = nn.Linear(d, vocab, bias=False)  # 可与 tok.weight 绑定（权重 tying）
        self.n_ctx = n_ctx
    def forward(self, idx):
        x = self.tok(idx) + self.pos(torch.arange(idx.size(1), device=idx.device))
        for blk in self.blocks: x = blk(x)
        return self.head(self.ln_f(x))

@torch.no_grad()
def generate(model, idx, n_new=60, temperature=1.0, top_k=20):
    for _ in range(n_new):
        logits = model(idx[:, -model.n_ctx:])[:, -1] / temperature   # 只看最近 n_ctx
        if top_k:
            kth = logits.topk(top_k, dim=-1).values[..., -1, None]
            logits = logits.masked_fill(logits < kth, float("-inf"))
        probs = F.softmax(logits, dim=-1)
        idx = torch.cat([idx, torch.multinomial(probs, 1)], dim=1)
    return idx

训练循环就是 0.2 章那套：logits = model(x); loss = F.cross_entropy(logits[:, :-1].reshape(-1, V), y[:, 1:].reshape(-1))——注意输入右移一位（预测下一个 token）。加上 0.4 章的四件套，你就有了一个完整的 nanoGPT。

5. 参数量的账（必须会算）

每个 Block：注意力 $4d^2$（QKV 投影 $3d^2$ + 输出投影 $d^2$）+ MLP $8d^2$ = $12d^2$。

验算 GPT-2 small：$L=12, d=768$ → $12 \times 12 \times 768^2 \approx 85M$；词表嵌入 $50257 \times 768 \approx 38.6M$；位置 $1024 \times 768 \approx 0.8M$。合计 ≈124M，和论文对上了。会算这笔账，你就能自己估算任何模型的显存（0.2 章 §7）和 LoRA 目标模块的选择（LoRA 常挂在哪些 $12d^2$ 上）。

6. 自测题

1. Pre-Norm 相比 Post-Norm 的核心优势？（残差主干无变换，梯度直通，百层可训；final norm 补表达力）
2. 为什么必须有位置编码？RoPE 一句话思想？（注意力置换等变；按位置旋转 q/k 使内积只依赖相对距离）
3. MLP 占每层参数的比例？它和注意力分工是什么？（约 2/3；位置内加工 vs 位置间搬运）
4. decoder-only 赢在哪些点？（目标简单数据利用率高、生成理解统一、架构简洁、支持 in-context learning）
5. 权重 tying 是什么，省多少？（embedding 和输出投影共享，省 $V \times d$，小词表模型占比可观）
6. 采样时 temperature=0.1 和 5 分别是什么行为？（接近贪心；接近均匀随机、胡言乱语）
7. 为什么 generate 时要裁剪 idx 到最近 n_ctx？（位置编码表长度有限——绝对位置的硬伤，RoPE 缓解此问题）

7. 动手作业

1. 跑通 TinyGPT：用莎士比亚字符级数据（Karpathy input.txt，词表 65）训到 loss ≈ 1.5，generate 出一段”伪莎翁”。对照 Karpathy《Let’s build GPT》逐行验证你的实现。
2. 算一笔账：你的 TinyGPT（d=256, L=4）参数量是多少？用 sum(p.numel()) 验证。
3. 把 LayerNorm 换成 RMSNorm、把 top-k 换成 top-p，各写一版。
4. 挑战：加 dropout 和权重衰减后把 L 加到 6，观察过拟合边界——体会”小数据喂不大模型”。

案例 · 手算：TinyGPT 一次前向的形状流

案例：张量形状从头流到尾（B=4, N=128, D=256, H=4, 词表=65）

1. 输入 idx：(4, 128) 整数；
2. tok+pos embedding：(4, 128, 256)；
3. 每个 Block 内：q/k/v 各 (4, 4, 128, 64)；注意力分数 (4, 4, 128, 128)——这 26 万个数就是”平方成本”的本体；
4. 加权求和回 (4, 128, 256)，MLP 内部先膨胀到 (4, 128, 1024) 再压回；
5. 最终 head：(4, 128, 65) logits → 对 127 个位置算 next-token loss。

参数量（§5 公式）：每 Block 12×256²=786K，4 个 Block=3.15M；加词表嵌入 65×256≈17K——sum(p.numel()) 应约 3.2M。形状对不上 = 90% 的 reshape/transpose bug（0.2 §2.2 的三兄弟再查一遍）。

8. 延伸资源

• Karpathy《Let’s build GPT: from scratch, in code, spelled out》——与本章一一对应，必跟
• nanoGPT repo——工业级微缩版（DDP、配置系统、都在）
• Jay Alammar《The Illustrated GPT-2》——图解推理时 KV 的流动

1.4 ViT 与视觉 Transformer 谱系：图像成为 token

本章目标：理解”图像怎么变成 token 序列”——这是整个多模态大厦的第一块砖。学完标准：能讲清 ViT 的最简设计与它成立的前提，知道主流变体解决什么问题，明白”视觉 token 数量”为什么是多模态的核心矛盾（卷3 的伏笔）。

1. ViT：最简单的设计为什么成立

《An Image is Worth 16x16 Words》(2020) 的做法简单到失礼：

1. 把 224×224 图像切成 196 个 16×16 patch；
2. 每个 patch 展平（16×16×3=768 维），过一个线性层 → 768 维 token；
3. 加 [CLS] token（汇总全局信息，作分类头输入）+ 位置编码；
4. 喂给标准 Transformer encoder（和 NLP 一模一样），CLS 输出接分类头。

工程等价性（必懂）：切 patch + 线性投影 = 一个 stride=16、kernel=16 的卷积：

self.patch_embed = nn.Conv2d(3, 768, kernel_size=16, stride=16)  # (B,3,224,224) → (B,768,14,14)
# 再 flatten + transpose → (B, 196, 768)，拼上 CLS token，加位置编码，进 Transformer

第一层卷积参数 = 16×16×3×768，就是 N 个”patch → token”的线性映射。所以 ViT 并没有抛弃卷积，只是把卷积压缩成了一次 token 化，之后全交给注意力。

成立的前提：1.1 章讲过，弱先验架构需要大数据。ViT 论文自己的实验梯度——ImageNet-1k（百万级）上 ViT 输给 ResNet；ImageNet-21k + JFT-300M（亿级）上反超。结论不是”ViT 更好”，而是”数据规模换架构先验”的交易曲线。小数据场景（医疗影像常见）ViT 未必赢——这正是 DeiT 和混合架构存在的原因。

2. 谱系速览：每个变体在解决什么

读谱系的正确姿势：不是记名字，而是看张力轴——局部先验 vs 全局交互、窗口稀疏 vs 全局平方复杂度、纯视觉 vs 图文联合。所有变体都在这几根轴上找位置。

3. 视觉 token 数量：多模态的核心矛盾（卷3 伏笔）

算一笔账：224² 分辨率 → 196 token，没问题。但：

• 文档/OCR 要看清小字：需要 1024+ 分辨率 → 数千 token；
• 检测要 800×1333 → 约 2700 token（patch16）；
• 视频每帧 196 token，16 帧就是 3136 token；
• 而 LLM 的注意力对 token 数平方敏感（1.2 章的账）。

多模态模型设计的核心工程问题之一就是：视觉 token 塞多少、怎么压。你以后会遇到的每个设计——Qwen-VL 的 pixel shuffle 压缩、BLIP-2 的 Q-Former（32 个 query token 打包整图）、Qwen3-VL 的动态分辨率 patch 化——都是在回答同一道题。现在记住题目本身：分辨率↑ → token 爆炸 → 注意力平方爆炸。

4. 实操：用 timm 玩真模型

import timm, torch
model = timm.create_model("vit_base_patch16_224", pretrained=True)
model.eval()
print(model)              # 逐行读：patch_embed / cls_token / pos_embed / blocks.0...11 / head
x = torch.randn(1, 3, 224, 224)
feats = model.forward_features(x)   # (1, 197, 768)：196 patch + 1 CLS
print(feats.shape)

要求自己能对着打印输出说出每个模块的角色（对照本章 §1 和 1.3）。再从 model.blocks[i].attn 里抓 attention 权重画热力图，看最后一层注意力聚焦在哪——通常围绕物体轮廓（1.5 章 DINO 会把这个现象做到极致）。

5. 视觉编码器在多模态里的位置（前瞻）

到 2026 年，几乎所有开源 VLM 的视觉塔都是 ViT 变体（CLIP ViT、SigLIP、InternViT、AIMv2……），差别在训练目标和数据。你将来做 VLM 微调时冻结/解冻的就是这个东西。现在建立”视觉塔 = 冻结的 ViT 特征提取器”的直觉，卷3 会反复用到。

6. 自测题

1. 切 patch + linear 等价于什么卷积？（k=16, s=16；参数即投影矩阵）
2. ViT 为什么需要 CLS token 或全局池化？（输出是 196 个 token，要一个汇聚全局的向量做分类）
3. ViT 在 ImageNet-1k 上输给 ResNet 说明什么先验问题？（弱先验架构数据不足时不如强先验；平移等变/局部性在中小数据仍有价值）
4. Swin 的窗口注意力在省什么？（N² 注意力 → 窗口内线性增长；代价是牺牲部分全局交互，用移位窗口补偿）
5. 1024×1024 图像 patch16 是多少 token？对 VLM 意味着什么？（4096 个；不压缩的话 LLM 端注意力代价爆炸——token 压缩是多模态核心工程题）
6. ConvNeXt 的结论对科研方法论有什么启示？（配方与架构同样重要——复现失败先怀疑训练配方，再怀疑思想）

7. 动手作业

1. 手写 PatchEmbed（conv 实现 + CLS + 可学习位置编码），前向输出 (B, 197, 768)，与 timm 的 model.patch_embed 对比参数量。
2. 用 timm 加载 ViT，冻结全部参数，只把 head 换成 10 类，在 CIFAR-10 上微调（只训 head，lr 1e-3；再试解冻最后 2 个 block，lr 1e-5）——体会”预训练特征 + 轻量适配”的威力与冻结/解冻的取舍。
3. 可视化第 0/6/11 层 block 的 CLS→patch 注意力图，对比”低层看纹理、高层看物体”。
4. 挑战：把输入改成 384×384（timm 的 img_size 参数或直接换 vit_base_patch16_384），观察位置编码怎么变——引出”插值位置编码”这一经典工程 trick。

8. 延伸资源

• ViT 原论文 + 李沐《论文精读》ViT 一期——必读必看
• Swin / ConvNeXt 论文泛读（看图说话级别即可）
• timm repo（pytorch-image-models）——视觉 backbone 的瑞士军刀，后面项目反复用

1.5 自监督三巨头：MAE、CLIP、DINO

本章目标：理解”没有标签，监督信号从哪来”——这是预训练范式的燃料学。三巨头对应三条路线：遮住重建（MAE）、图文对齐（CLIP）、自己教自己（DINO）。学完标准：能说清每种方法的信号构造方式和防坍塌机制，明白为什么 CLIP 成为多模态地基、DINO 成为机器人底座。CLIP 的实操放在 1.6。

1. 为什么需要自监督

监督学习的燃料是人工标注，两个天花板：标注贵（分割一个像素级标注几分钟）和标注偏（人标的分类体系 ≠ 模型需要的特征）。自监督（self-supervised learning）的思路：构造一个”答案就在数据里”的代理任务——遮住一部分让模型补全、把配对的图文拼起来、对同一张图做两次增强要求输出一致。预训练学到的通用特征再迁移到下游。这个”预训练 → 迁移”范式，就是后来 LLM”预训练 → 微调”的直系祖先。

2. MAE：遮住 75%，重建像素

《Masked Autoencoders Are Scalable Vision Learners》(2021)，思路来自 BERT 的完形填空：

1. 把图像切成 patch（16×16），随机遮住 75%；
2. 编码器（ViT）只处理可见的 25%（196 → 49 个 token，计算量省 3 倍多）；
3. 轻量解码器拿”可见 token + 可学习的 mask token”去重建被遮 patch 的像素；
4. loss 只在被遮位置算 MSE。

两个设计点是全文精华：

• 75% 这么高的遮罩率为什么行：自然图像冗余度极高（遮 15% 邻居一 interpolation 就补上了，学不到东西）；75% 迫使模型利用全局语义推断（补全人脸必须懂人脸结构）。语言的信息密度高，BERT 只遮 15%——遮罩率跟着模态冗余度走，这个对比本身就是一道理解题；
• 非对称架构：重编码器 + 轻解码器。重建任务只是训练的”脚手架”，推理时解码器直接扔掉，只留编码器产特征。

遗产：MAE 证明了”生成式代理任务”在视觉成立，遮罩重建思想后来汇入多模态预训练和统一模型（卷3/4）。

3. 对比学习：CLIP 及其思想基础

在讲 CLIP 之前先给对比学习的最小内核（SimCLR/MoCo 一句话历史：同一张图两次增强互为正样本，batch 内其余为负样本，拉近正样本、推远负样本——难点在防坍塌）。

CLIP（Contrastive Language-Image Pre-training, 2021） 把”正样本”换成”配对的图文”：

• 数据：4 亿张互联网图文对（WIT-400M）——不标注，只利用”网页图片旁边通常有描述”这个天然结构；
• 模型：图像塔（ViT）+ 文本塔（Transformer），各自输出归一化嵌入；
• 目标（对称 InfoNCE）：batch 内 N 对图文，对角线上的图文对相似度拉高，其余 N²−N 对推低：

$L = -\frac{1}{N}\sum_{i=1}^{N}\left[\log\frac{e^{\text{sim}(I_i,T_i)/\tau}}{\sum_j e^{\text{sim}(I_i,T_j)/\tau}} + \log\frac{e^{\text{sim}(I_i,T_i)/\tau}}{\sum_j e^{\text{sim}(I_j,T_i)/\tau}}\right]$

（前半：每张图找它的文本；后半：每段文本找它的图。$\tau$ 是可学习温度。）

几行就能实现的灵魂代码：

def info_nce(img_emb, txt_emb, tau=0.07):        # 两个嵌入都已 L2 归一化, (N, d)
    logits = img_emb @ txt_emb.T / tau           # (N, N) 相似度矩阵
    labels = torch.arange(len(img_emb))
    return (F.cross_entropy(logits, labels) + F.cross_entropy(logits.T, labels)) / 2

防坍塌机制：负样本（batch 内其他对）就是排斥力——如果所有嵌入坍到一点，loss 会是 log(N) 而降不下去。代价是需要大 batch（CLIP 用 32768），且假负样本（batch 里恰好有语义相同的图文对）会被错误排斥——已知缺陷，知道即可。

4. DINO：自己教自己，注意力里长出分割

《Self-Distillation with No Labels》(2021)：

1. 同一张图做多尺度裁剪（global + local crops）；
2. 教师（学生权重的 EMA 副本，0.4 章 EMA 的思想）看 global view，学生看所有 crops；
3. 学生最小化与教师输出分布的交叉熵；
4. 防坍塌靠 centering（教师输出减去运行均值，防某类独大）+ sharpening（低温度锐化）——没有负样本，全靠这两招维持输出分布不退化。

成名点：训练完不微调直接看注意力图，物体的分割轮廓自己浮现（这是本章作业的彩蛋）。后续 DINOv2（2023）用数据策展 + 大规模训练把冻结特征推到”万能视觉特征”：分类、深度、分割、检索全线可用——并且成为机器人/具身智能的视觉底座（pi0 等 VLA 模型大量使用 DINOv2 特征，卷5.3 呼应）。

5. 三巨头对比（背下来）

三条路线没有胜负：CLIP 赢在”文本锚点”打开了多模态大门；DINO 特征在无文本的具身场景称王；MAE 思想活在生成模型和统一架构里。你未来研究用到哪个，取决于你的题目需要”对齐空间”还是”通用特征”。

6. 自测题

1. 自监督和监督学习的本质区别一句话？（监督信号是否由人工标注产生；自监督的”标签”从数据结构中构造）
2. MAE 为什么遮 75% 而 BERT 只遮 15%？（图像像素冗余、语言信息密度高；遮罩率应匹配模态冗余度）
3. MAE 的解码器为什么可以扔？（重建是训练脚手架，部署只要编码器特征——“训练目标 ≠ 部署需求”的经典案例）
4. 对比学习的坍塌是什么？CLIP 和 DINO 各靠什么防？（输出全相同；负样本排斥 / centering+sharpening）
5. InfoNCE 里温度 τ 小意味着什么？（分布更尖，难负样本主导梯度——训练后期常见动态调整的原因）
6. 为什么 DINOv2 成了机器人底座而不是 CLIP？（具身场景没有文本查询，需要的是稠密、空间敏感的通用视觉特征，而非跨模态对齐）
7. 假负样本问题是什么，什么场景更严重？（batch 内本为同类/同义的对被错误推远；细粒度数据集、概念密集的图文对）

7. 动手作业

1. 手写 info_nce（第 3 节代码），用随机嵌入验证：完美对齐时 loss→0，全坍塌时 loss≈log(N)——亲手看见坍塌。
2. 用 open_clip 加载 CLIP，对一张图做 75% 掩码”提问式”实验：遮住半张图问 CLIP”这是什么”，体会对齐空间对不完整输入的鲁棒与脆弱。
3. 用 timm 加载 vit_base_patch16_224.dino，抓最后一层 CLS→patch 注意力画热力图，和 1.4 作业的监督 ViT 对比（DINO 的分割感通常明显更强）。
4. 挑战：读 MAE 论文 §3，用三句话向别人解释”非对称设计”省了多少计算、为什么不影响学到的特征质量。

8. 延伸资源

• MAE / CLIP / DINO 三篇原论文——配合李沐《论文精读》对应各期（他全讲过）
• 《Understanding Self-Supervised Learning》类综述——按需查阅
• DINOv2 repo——冻结特征跑深度估计 demo，十分钟见效

1.6 CLIP 精读与 zero-shot 评测实操（第一个完整项目）

本章目标：把 1.5 的 CLIP 思想落到一个完整可交付的项目——用预训练 CLIP 在 CIFAR-10 上做 zero-shot 分类、prompt 集成提分、跨模态检索 demo，写成规范的 repo。这是你作品集的第一块”多模态”砖，也是卷3 理解 VLM 的钥匙。

1. 精读地图：CLIP 论文里该带走什么

1.5 章已讲清目标函数，精读时重点补三块：

• 训练配方：4 亿图文对、batch 32768、可学习温度初始化 0.07（上限钳到 100）、图像增强只有”随机裁剪+flip”（对比学习界花哨增强在此无用）、AdamW+cosine、训 32 epoch 量级。启示：对比学习怕假负样本，增强过度反而破坏图文对语义；
• zero-shot 分类：把分类变成检索——每个类别写一句 prompt（“a photo of a {class}”），编码成嵌入，看图像嵌入和哪个类嵌入最近。prompt 就是分类器的权重；
• prompt engineering 与集成：单个 prompt 在细粒度任务上不稳（“boxer”是人还是狗？），论文对每个类用 80 个模板（“a photo of a big {class}”、“a sculpture of a {class}”…）编码后取平均——集成后 ImageNet 从 63% → 76%。这是本章作业的提分点。

2. 嵌入空间的性质（理解它，才能用好它）

• 余弦相似度：塔输出强制 L2 归一化，内积即余弦。所有检索、打分、分类都建立在”归一化嵌入的内积”这一个操作上；
• 跨模态检索：同一空间里 image↔text 双向检索（以文搜图的商品化技术底座就是它）；
• 方向即语义：嵌入空间中的平移/方向对应语义变化（“好照片 vs 差照片”的方向 = 8.2 章美学探针的原理）；
• 已知怪癖：对”词序”近乎无感（scrambled words 实验）、计数与空间关系弱、训练分布是英文互联网——评测时永远记住”CLIP 分数是它见过的分布的镜像”。

3. 项目实操：三件事（完整代码）

环境：pip install open_clip_torch（open_clip 是 CLIP 的开源复现集合，学术界事实标准）。

3.1 Zero-shot 分类（CIFAR-10）

import torch, torch.nn.functional as F
import open_clip
from torchvision import datasets, transforms

device = "cuda" if torch.cuda.is_available() else "cpu"
model, _, preprocess = open_clip.create_model_and_transforms("ViT-B-32", pretrained="openai")
tokenizer = open_clip.get_tokenizer("ViT-B-32")
model = model.to(device).eval()

CLASSES = ["airplane", "automobile", "bird", "cat", "deer",
           "dog", "frog", "horse", "ship", "truck"]
TEMPLATES = ["a photo of a {}.", "a photo of the {}.", "a blurry photo of a {}.",
             "a bright photo of a {}.", "a photo of one {}."]     # 先 5 个，作业里扩

# 文本侧：每个类 = 各模板嵌入的平均（再归一化）
with torch.no_grad():
    class_emb = []
    for c in CLASSES:
        toks = tokenizer([t.format(c) for t in TEMPLATES]).to(device)
        e = model.encode_text(toks)
        e = F.normalize(e, dim=-1).mean(0)
        class_emb.append(F.normalize(e, dim=0))
    class_emb = torch.stack(class_emb)                      # (10, 512)

# 图像侧 + 评测
test = datasets.CIFAR10("data", train=False, transform=preprocess)
loader = torch.utils.data.DataLoader(test, batch_size=512, num_workers=4)

correct = total = 0
with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16, enabled=(device=="cuda")):
    for x, y in loader:
        img = F.normalize(model.encode_image(x.to(device)), dim=-1)
        pred = (img @ class_emb.T).argmax(dim=1).cpu()      # 余弦最近邻 = 分类
        correct += (pred == y).sum().item(); total += y.size(0)
print(f"zero-shot acc: {correct/total:.4f}")                 # ViT-B/32 通常 0.85~0.90

对照读法：encode_image 是 1.4 的 ViT；encode_text 是 1.3 的 decoder-only Transformer（取 EOT 位置的输出）；img @ class_emb.T 是 1.2 的注意力打分函数去掉了 softmax（归一化内积）。三个前章在这里会师。

3.2 Prompt 集成实验（提分点）

把 TEMPLATES 扩到 20+ 个（模仿论文的 80 个：光照、风格、尺寸、视角…），记录 acc 曲线。观察收益递减的位置——写进 README，这就是你的第一份”实验报告”。

3.3 跨模态检索 demo

准备 100 张图 + 自定义查询（“a dog on the beach”），编码后 img_emb @ query_emb 排序，matplotlib 拼出 top-5 结果图。这个 demo 在面试里比分类数字更有说服力。

3.4 repo 规范（作品集标准）

clip-zero-shot/
├── README.md        # 结果表 + 曲线图 + 三个发现（用数字说话）
├── requirements.txt
├── src/
│   ├── zeroshot.py      # 3.1
│   ├── prompt_sweep.py  # 3.2
│   └── retrieval.py     # 3.3
└── assets/          # 检索结果图

4. CLIP 的产业角色（为什么值得花一周）

1. 数据引擎：LAION 用 CLIP 给数十亿图文对打分过滤 → 文生图模型的训练集（你训练的 SD/FLUX 的血统里都有 CLIP）；
2. 奖励模型底座：美学评分（8.2 章）、人类偏好对齐（PickScore 等）全在 CLIP 空间上建；
3. VLM 视觉塔：早期 LLaVA 直接用 CLIP ViT 当视觉编码器（卷3.2）；
4. 内容审核与搜索：以文搜图、违规内容向量分类，工业界每天在跑。

一句话：CLIP 是多模态产业的”公共基础设施”，也是你科研里最常用的预训练底座。

5. 自测题

1. zero-shot 分类为什么可行？“分类器权重”是什么？（对齐空间使图文可比；各类 prompt 的嵌入向量）
2. 为什么 prompt 集成有效、收益为何递减？（多视角消解 prompt 偏差；覆盖同类语义后饱和）
3. 温度可学习化在训练中起什么作用？（自适应难度：早期拉近粗对齐，后期聚焦难样本）
4. CLIP 在计数/空间关系上为什么弱？（训练目标是全局对齐，监督信号不要求局部结构理解）
5. 用 CLIP 做数据过滤的系统性风险是什么？（过滤偏差会烙进下游模型——“谁定义了好数据”成为权力，也是研究题）
6. batch 32768 除了算力还防什么问题？（对比学习需要足够负样本密度；小 batch 排斥力不足，学不到细粒度区分）

6. 动手作业（项目交付标准）

1. 跑通 3.1，基线 acc 记入 README；
2. prompt sweep：5 → 20 → 50 模板三档 acc 曲线（wandb 或 matplotlib 图贴 README）；
3. 检索 demo 出 5 张结果拼图；
4. 加做：zero-shot 迁移到你自己挑的细粒度数据集（如 8.1 的 WikiArt 流派分类，21 类），对比论文报告的水平——顺手完成 8.1 作业 2 的升级版；
5. README 里写一节”失败与怪癖”：找到至少 1 个 CLIP 分类翻车的例子并分析原因（用 1.5/8.1 的语言）。

7. 延伸资源

• CLIP 论文（Learning Transferable Visual Models From Natural Language Supervision）+ 李沐精读一期
• open_clip repo + 文档——model zoo 里 ViT-B/32 → ViT-L → SigLIP 逐个玩
• LAION-5B 论文泛读——数据引擎视角看 CLIP

1.7 SAM 与分割基础模型：提示式视觉

本章目标：吃透 SAM（Segment Anything）——它不只是分割模型，而是”提示式交互视觉”这一新范式的开端，也是数据引擎自举的经典案例。学完标准：能画出 SAM 三件套架构并解释”为什么这么设计”，会用 box/point prompt 完成实操，知道 SAM 2 把什么搬到了视频。

1. SAM 是什么：分割界的 GPT 时刻

Meta（2023）的三件事：① SA-1B 数据集：1100 万张图、11 亿个掩码——史上最大分割数据；② 可提示范式：模型接受点/框/粗掩码作为”提示”，输出对应物体的分割——像 GPT 接受 prompt 输出文本一样；③ 零样本泛化：没见过的物体/域（医学影像、素描）也能分——通用性首次出现在分割任务上。

范式意义：CV 从”每个任务训一个模型”转向”一个基础模型 + 任务提示”。这与 LLM 的 in-context learning 是同一次思想迁移（1.5 自监督 → 基础模型 → 提示交互，视觉侧的完整三连）。

2. 架构三件套（设计的聪明之处）

图像编码器（ViT-H，MAE 预训练，最重）→ 图像嵌入（一张图算一次）
提示编码器（点/框/掩码 → 编码，极轻）      ↘
掩码解码器（轻量双向 attention，~50ms）→ 分割掩码（可多次交互）

关键设计：重的一端（图像编码）与轻的一端（解码）解耦——交互场景下图像嵌入缓存复用，用户每点一下只需 50ms 重解码。这是”为交互而设计的架构”教科书案例：把昂贵的计算放在不变量上，把便宜的计算放在交互变量上（KV cache 是同一哲学，2.3）。

训练：三阶段（监督→数据引擎自举：模型辅助标注→新数据回灌→模型更强，5.2 数据为中心的经典案例）→RL 式微调对齐交互。

3. SAM 2（2024）：提示式视频分割

把”分割一切”搬到视频：流式记忆——当前帧通过 memory attention 关注之前的关键帧记忆与提示记忆，逐帧传播掩码；图像与视频统一进一个模型。能力：track anything——点一下视频里的物体，全程跟住（遮挡后还能找回）。实用地位：视频标注、VLA 数据采集（5.3 的演示数据标注）、特效制作的底层工具。

4. 家族与应用接口

• Grounded-SAM：文本开集检测（Grounding DINO）出框 → SAM 精细分割——“说一句话分出指定物体”的标准管线（5.6 agent 的感知件）；
• MedSAM：医学域微调——基础模型 + 领域数据的典型配方；
• SAM-HQ：边界质量增强；MobileSAM/FastSAM：端侧化（5.8 的效率路线）；
• 你的方向：线稿提取（8.4 画师管线的自动前置步骤）、文物图像的自动分割编目（8.8）、生成图的结构分析（A3 鉴别的特征源）。

5. 实操十分钟

from segment_anything import sam_model_registry, SamPredictor
sam = sam_model_registry["vit_b"](checkpoint="sam_vit_b.pth").cuda()
predictor = SamPredictor(sam)
predictor.set_image(image_rgb)                      # 重计算只做一次
masks, scores, _ = predictor.predict(
    box=np.array([x1, y1, x2, y2]), multimask_output=True)   # 轻解码随便点

自动全图分割用 SamAutomaticMaskGenerator（网格撒点提示）——批量产出训练数据的工具形态。

6. 自测题

1. SAM 的三件套里哪个最重？交互设计怎么利用这一点？（图像编码器；嵌入缓存、只重跑轻解码——“贵计算放不变量”）
2. 可提示范式的意义？（一个模型+任务提示替代每任务一模型——LLM in-context 思想的视觉迁移）
3. SA-1B 的掩码哪来的？（数据引擎自举：模型辅助标注→回灌→迭代的经典闭环）
4. SAM 2 用什么机制做视频跟踪？（流式 memory attention——当前帧查历史记忆）
5. Grounded-SAM 的两级管线是什么？（文本开集检测出框 + SAM 精细分）
6. 它对你方向的三处接口？（线稿提取/文物分割编目/生成图结构分析）

7. 动手作业

1. 完成第 5 节实操：对一张名画（8.1 的素材）做 box 提示分割，把主体抠出；
2. 用 AutomaticMaskGenerator 对同一张画全图分割，数一数掩码数量与平均面积——“细节密度”的另一种测量（对照 8.1 映射表）；
3. 跑 SAM 2 的视频 demo：给一段水墨运笔视频 tracking 笔尖——感受”提示式”在时序上的延伸；
4. 挑战：读 SAM 论文 §3 的数据引擎部分，画自举闭环图——对照 5.2 写 200 字。

8. 延伸资源

• SAM / SAM 2 论文——各精读一遍（SAM 的消融与数据引擎章节是精华）
• Grounded-SAM repo——组合管线的工程范本
• segment_anything 官方 notebook——十分钟上手

1.8 检测与分割极简史：知道即可的一章

本章定位：诚实的定位——这是全书最薄的一章。检测/分割的传统内容已工业化（1.1 §6 的存量市场判断），你需要的只是：任务定义、演化脉络、几个绕不开的名字（U-Net！），以及评测常识。学完标准：30 分钟后能在任何对话里不掉链子，并把注意力留给真正要紧的 U-Net。

1. 任务定义一张表

评测常识：检测用 mAP（按 IoU 阈值判定命中，对置信度排序算精度-召回曲线下面积）；分割用 IoU/mIoU（交并比）。知道”IoU 0.5 是及格线惯例、mAP@50 vs mAP@50:95 的区别”即可。

2. 检测极简四幕剧

1. 传统时代：HOG+SVM、DPM——滑窗+手工特征（1.1 存量市场的注脚）；
2. 两阶段 CNN 时代：R-CNN 家族（选择性搜索/Region Proposal Network 先提候选框，再分类精修）——精度高、速度中；Faster R-CNN 是两阶段的完成体；
3. 单阶段时代：YOLO/SSD——一次前向直接出框（回归式），快到能上嵌入式——工业部署至今的主力（巡检/安防/车载）；Focal Loss（RetinaNet）解决正负样本失衡，是训练技巧史的名场面；
4. Transformer 时代：DETR——把检测改写成”集合预测”：固定 100 个 object query（可学习的”格子”）查图像特征，输出恰好 100 个（类别, 框），用匈牙利匹配做一对一监督——彻底删掉了 NMS 后处理和候选框概念，架构优雅；后续 DINO-DETR 等把精度做到全面领先。

现状一句话：部署看 YOLO 系，研究看 DETR 系；两者你都不必复现。

3. 分割极简四站

FCN（全卷积，像素级预测的开山）→ U-Net（★全书级重要）→ Mask R-CNN（检测+实例分割合体）→ SAM（1.7 的基础模型时代）。

为什么 U-Net 单独加星：编码器-解码器 + 跳跃连接的结构（4.4 §2.2 讲过），是医学影像的常青主力，也是 SD 扩散 U-Net 的直系祖先——“学会了 U-Net，半只脚踏进医学影像 + 一只脚站在扩散模型里”。它的思想（下采样提语义、上采样还细节、跳跃连接直通细节）在 4.4 已拆解，这里只需记住名字与血缘。

4. 与你主线的接口

• 检测 → grounding：VLM 的指框能力（Qwen-VL 系，3.5）本质是”语言条件检测”——DETR 的 query 思想与 LLM 的结合是当前开放词汇检测的研究面；
• 分割 → SAM 时代：1.7 已讲；传统分割（U-Net 系）仍统治医学影像——AI for Science（5.7）的主要工具；
• 对你的行动建议：知道即可（本章定位），把省下的时间投给卷2/卷3——这是本笔记”传统只留薄底”原则的最后一次执行。

5. 自测题

1. 语义/实例/全景分割的区别一句话？（逐类 vs 逐物体 vs 两者合体）
2. 两阶段与单阶段检测的取舍？（精度 vs 速度——候选框精修 vs 直接回归）
3. DETR 的”集合预测”新在哪？（固定 query + 匈牙利一对一匹配，删掉 NMS 与候选框）
4. U-Net 为什么单独加星？（医学主力 + 扩散 U-Net 祖先——跳跃连接思想贯穿两域）
5. mAP 和 IoU 各测什么？（排序后的命中精度 / 掩码重叠度）
6. 本章为什么敢于”薄”？（传统检测分割已工业化——你的增量在多模态，不在 YOLO 调参）

6. 动手作业

1. 用 ultralytics（YOLO）跑一张图的目标检测，10 分钟体验”工业现成品”；
2. 手画 U-Net 结构图，标注每层分辨率与跳跃连接——为 4.4 的 SD 复习做准备；
3. 用 open 数据（如 COCO 的 20 张子图）手算 IoU 与 mAP@50（numpy 实现）——评测常识的肌肉记忆。

7. 延伸资源

• 《Object Detection in 20 Years: A Survey》——四幕剧的完整版（选读）
• U-Net 原论文（15 分钟）——血缘关系值得
• DETR 论文 §1–2——集合预测的思想

1.9 图像形成与相机模型：给 3D/具身留的几何底座

本章目标：补上”光怎么变成像素、像素怎么回到空间”的物理与几何底座——5.5 的 COLMAP、4.7 的视角控制、5.3 的机器人相机，全部站在这块地基上。学完标准：能写出针孔投影公式并解释内外参的作用，知道 COLMAP 在解什么问题。

1. 图像形成：光到像素的三段旅程

场景反射的光 → 镜头（聚焦，光圈控制景深）→ 传感器（曝光：快门时间 × 光圈 × ISO 的组合）→ 数字化（拜耳滤色阵列 + 去马赛克 + gamma 编码）。

两个与生成/处理直接相关的点：① 曝光三角（光圈/快门/ISO）决定了运动模糊、噪点、景深——生成模型学到的”摄影感”本质是这些物理参数的分布（prompt 里的 “shallow depth of field, f/1.4” 就是在索要光圈物理）；② gamma/sRGB 编码（8.1 §2.1 已讲）是”人眼非线性”的存储妥协——处理图像的数学最好在线性光空间做。

2. 针孔相机模型：三维到二维的投影

空间点 $P = (X, Y, Z)$（相机坐标系）投到像素平面的完整链条：

$\tilde{p} = K \begin{bmatrix} R | t \end{bmatrix} \tilde{P}_w, \quad K = \begin{bmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{bmatrix}$

• 内参 K（相机自己的属性）：焦距 $f_x, f_y$（换算成像素单位）与主点 $(c_x, c_y)$（光轴落点）；
• 外参 $[R|t]$（相机在世界里的位姿）：旋转 + 平移——NeRF/3DGS 训练需要逐张照片的 $[R|t]$，COLMAP 的核心工作就是从照片对里把它们恢复出来（5.5 的伏笔在此收线）；
• 齐次坐标：用多一维的坐标让投影变成一次矩阵乘（平移也能线性表达）——机器人学/3D 视觉的通用语言，习惯即可。

畸变：真实镜头不是理想针孔（桶形/枕形畸变），标定即求解畸变系数并在投影前后校正——手机相机的”超广角校正”就是它。

3. 多视角几何的最小概念集（概念级，不推导）

• 对极几何：两个相机看同一点，该点在各视图的投影位置受”对极约束”限制——这是不需要 3D 点就能从 2D 对应关系恢复相机相对位姿的钥匙（essential/fundamental 矩阵，概念知道即可）；
• 三角化：两个已知位姿的相机 + 同一点的两个投影 → 交出该点的 3D 位置——重建的原理本体；
• SfM（Structure from Motion）/COLMAP：特征匹配（1.1 的”模板匹配”回归！）→ 对极约束求位姿 → 三角化出稀疏点云 → 光束法平差（bundle adjustment，全局优化）。5.5 作业里你跑的 COLMAP 就是这套；
• 对偶问题记住一句话：已知位姿求点是三角化，已知点求位姿是定位，都不知道就交替着来（SfM）。

4. 与你主线的四个接口

1. 3D 管线（5.5）：COLMAP 位姿是 NeRF/3DGS 的输入——现在你知道它内部的几何；
2. 生成模型的视角控制：相机的 $[R|t]$ 与焦距是物理意义上的可控生成旋钮（相机轨迹控制视频、焦距控制景深）——比”换视角的 prompt”硬核得多的控制量；
3. 具身（5.3）：机器人头上的相机内外参标定是”手眼标定”问题——VLA 部署的第一天就会遇到；
4. 艺术（8.x）：线性透视法的数学就是投影几何（8.1 §5 的文艺复兴透视）——达芬奇和针孔模型写的是同一套数学。

5. 自测题

1. 内参和外参各是什么属性？谁需要逐图估计？（相机固有属性 / 相机在世界中的位姿；外参逐图——SfM 的产出）
2. 为什么投影要用齐次坐标？（平移纳入线性变换——一次矩阵乘完成投影）
3. 对极约束”强”在哪？（不需要任何 3D 信息就能约束两视图对应关系并恢复相对位姿）
4. 曝光三角的三个物理量各控制什么视觉效果？（光圈→景深；快门→运动模糊；ISO→噪点）
5. 生成模型里”相机参数作为控制旋钮”比 prompt 好在哪？（物理精确、连续可微、与 3D 管线兼容）
6. COLMAP 的四步流水线？（匹配→对极求位姿→三角化→光束法平差）

6. 动手作业

1. 用 OpenCV 对手机拍的一张棋盘格做相机标定（cv2.calibrateCamera），读出你手机的内参和畸变系数；
2. 用标定结果对一张广角照片做去畸变（cv2.undistort），前后对比；
3. 在 5.5 的 COLMAP 输出里找到 cameras.txt/images.txt，把某一行的外参翻译成”相机的位置与朝向”（人话）；
4. 挑战：手写针孔投影（numpy 十行），把一个立方体的 8 个顶点投影到图上并连线渲染——你的第一个 3D 渲染器。

7. 延伸资源

• 《Multiple View Geometry in Computer Vision》（Hartley & Zisserman）——圣经级参考（选读第 1、6 章）
• OpenCV 相机标定官方教程——工程直达
• COLMAP 文档 §Getting started——配合 5.5 作业

2.1 语言模型前史：n-gram → RNN → 注意力（20 分钟走完 30 年）

本章目标：理解”预测下一个词”为什么从 1950 年的玩具问题变成今天的圣杯任务，以及 GPT 范式赢在哪几个关键决策上。学完标准：能用五分钟向别人讲清”从 n-gram 到 ChatGPT 发生了什么、每一步解决了上一个的什么死穴”。

1. 任务定义与它的特殊性

语言模型估计 $P(w_t \mid w_1, \dots, w_{t-1})$。用概率的链式法则，整句概率可以分解为逐词条件概率的连乘：

$P(w_1, \dots, w_T) = \prod_{t=1}^{T} P(w_t \mid w_1, \dots, w_{t-1})$

这个任务看起来平淡，却同时满足三个苛刻条件：

1. 数据无限：互联网上任何文本都是训练样本（自监督，1.5 章思想的文字版）；
2. 目标极简但要求全面：预测“‘明天开盘后，上证指数最可能’ 的下一个词”，需要语法、事实、逻辑、世界知识的全部；
3. 评测自然：loss / 困惑度（perplexity = $2^{\text{loss}}$，直觉是”模型眼里每个位置平均有多少个候选词在纠结”）随能力单调改善。

“压缩即智能”：预测得好 = 用模型压缩文本压得好（算术编码的联系）。这是理解”为什么一个 next-token 任务能涌现推理”的最好心智模型——也是 Hutter Prize 一直奖励压缩算法的原因。

2. n-gram 时代（1948–2000s）：统计机器

Shannon 用马尔可夫假设开山：只看前 n−1 个词，数语料里下一词的频率，加平滑处理没见过的组合。问题立现：

• 组合爆炸：n=3 时常见词组合已数不过来，n=5 时几乎所有组合都稀疏；
• 泛化失败（根子）：“the cat sat” 和 “the dog sat” 的后续统计完全隔离——明明语义相似，统计上互不相干。

但 n-gram 留下了两笔遗产：next-token 这个任务本身，和困惑度这个指标。

3. 神经语言模型（2003）与 word2vec（2013）：词变成向量

Bengio 的神经 LM 给每个词一张稠密向量（embedding），用神经网络输出下一词分布。关键贡献一句话：语义相似的词向量相似 → 它们的统计自动共享——“cat” 和 “dog” 的嵌入接近，“the __ sat” 的预测互相支援，n-gram 的泛化死穴被解决。

word2vec 把嵌入训练做成独立任务并发现：向量算术 $v_{king} - v_{man} + v_{woman} \approx v_{queen}$。嵌入空间 = 语义几何——这个思想一路延续：CLIP 的图文对齐空间、8.2 章在嵌入空间里找”美丑方向”，都是它的后代。

4. RNN/LSTM（≈2003–2017）：循环与门控

$h_t = f(h_{t-1}, x_t)$：理论上无限长上下文，十年统治翻译/语音。LSTM 用门控（记忆细胞 + 输入/遗忘/输出门）缓解梯度消失。但 1.2 章讲过的两大死穴没救：顺序计算不可并行（GPU 干瞪眼）+ 长程依赖衰减（信息要路过每一步）。

5. 2017–2022：五年定乾坤

理解这段历史的关键：2018 年时行业主流押的是 BERT（理解任务刷榜快、训练便宜），GPT 线是少数派押注”生成式 + 规模”。三张牌——自回归目标、规模定律、指令对齐——2020 年起逐一验证，才有 2022 的引爆。读论文时要练习识别”哪个赌注被时间验证了”，这是研究品味的原料。

6. Scaling law 预告（2.4 详讲）

Kaplan 等（2020）发现：test loss 随参数量、数据量、算力呈光滑幂律，跨 7 个数量级成立。它把”更大的模型会更好”从信仰变成工程预算表——这是资本敢投百亿建集群的数学依据。Chinchilla（2022）修正了配比（每个参数约 20 token 最优）。对你的启示：做实验先在小规模建立趋势线，再谈放大。

7. 自测题

1. 链式法则把句子概率分解成什么？这和模型训练目标什么关系？（逐词条件概率连乘；模型逐位置优化 $P(w_t\mid \text{前文})$ 即等价优化整句似然）
2. n-gram 的根子问题是什么？谁解决的？（相似上下文统计不共享；稠密嵌入）
3. perplexity=2^loss 的直觉含义？（模型每步平均在多少个等概率候选中犹豫）
4. BERT 和 GPT 的路线差异各是什么？为什么 GPT 线最终通向大模型？（掩码双向刷理解榜 vs 自回归生成；生成即通用接口 + 自回归目标数据利用率高）
5. ChatGPT 相比 GPT-3 缺哪块拼图补上了？（指令微调 + 人类偏好对齐——能力变可用）
6. “压缩即智能”怎么理解？（预测好等价于压缩好；压缩要求抓住数据生成规律）
7. scaling law 为什么是工业决策的定心丸？（损失可外推 → 投资回报可预算）

8. 动手作业

1. 用 gensim 训一个 word2vec（或加载现成中文向量），复现若干组向量算术，找一个失败案例并分析为什么（词频、多义性）。
2. 手算：模型在词表 5 万、uniform 分布下的困惑度是多少？（=词表大小 50000；这就是”模型学到任何东西”的起点线）
3. 费曼测试：不看笔记，向同学（或录音）讲 5 分钟”n-gram→GPT”时间线，讲不清的地方回炉。

9. 延伸资源

• 《Speech and Language Processing》(Jurafsky & Martin) 第 3、9 章——n-gram 与神经 LM 的系统版
• 李沐《论文精读》GPT-1 / GPT-2 / GPT-3 三连——历史现场感
• Shannon《A Mathematical Theory of Communication》(1948)——选读，感受源头

2.2 BPE tokenizer 原理与实现

本章目标：搞清模型真正”看到”的东西——token。tokenizer 是所有诡异行为（数字比较、字母计数、计费差异）的第一嫌疑人。学完标准：能手写 BPE 的训练与编码，能用 tiktoken 检查任何文本的 token 边界，能解释”strawberry 数不出 r”的机理。

1. 为什么需要 tokenizer，以及三条路线

模型做的是对离散符号的 softmax（0.1 章的分类分布），输入必须变成有限词表里的 id。三个候选粒度的 trade-off：

子词的哲学：常见序列合并成单元，罕见内容退回字节。英文单词 ≈ 1 个 token，生僻词拆成几块，任何语言任何符号最终都有字节兜底——永不出 OOV。

2. 字节级 BPE：算法（必须能白板实现）

BPE（Byte Pair Encoding）本质是贪心的数据压缩：

训练（从语料学”合并表”）：

1. 把所有文本转成 UTF-8 字节序列（起点：256 个基础 token）；
2. 统计当前序列中相邻 token 对的出现频率；
3. 把最高频的一对合并成新 token（id = 257, 258, …），记录到合并表；
4. 重复第 2–3 步，直到词表达到目标大小（如 15 万）。

编码（推理时用）：把输入转成字节，按训练时学到的合并顺序逐条贪心重放合并。

极简实现（~40 行，Karpathy minbpe 的骨架）：

def merge(ids, pair, new_id):
    out, i = [], 0
    while i < len(ids):
        if i < len(ids) - 1 and (ids[i], ids[i+1]) == pair:
            out.append(new_id); i += 2          # 命中：两个 token 换成一个
        else:
            out.append(ids[i]); i += 1
    return out

def train_bpe(text, vocab_size):
    ids = list(text.encode("utf-8"))            # 起点永远是 0..255 字节
    vocab = {i: bytes([i]) for i in range(256)}
    merges = {}
    for step in range(vocab_size - 256):
        cnt = {}
        for a, b in zip(ids, ids[1:]):          # 1. 统计相邻对频率
            cnt[(a, b)] = cnt.get((a, b), 0) + 1
        best = max(cnt, key=cnt.get)            # 2. 最高频对
        new_id = 256 + step
        merges[best] = new_id                   # 3. 记入合并表
        vocab[new_id] = vocab[best[0]] + vocab[best[1]]
        ids = merge(ids, best, new_id)          # 4. 全量重放
    return merges, vocab

def encode(text, merges):
    ids = list(text.encode("utf-8"))
    for pair, new_id in merges.items():         # 按学习顺序贪心重放
        ids = merge(ids, pair, new_id)
    return ids

def decode(ids, vocab):
    return b"".join(vocab[i] for i in ids).decode("utf-8", errors="replace")

细节红线：合并表必须按学习顺序重放（顺序即优先级）；errors="replace" 处理”半个中文字”的截断（token 边界可能切开 UTF-8 多字节字符）。

3. tiktoken 实操：把 token 变成看得见的东西

import tiktoken                                   # pip install tiktoken
enc = tiktoken.get_encoding("o200k_base")         # GPT-4o 系词表
ids = enc.encode("多模态大模型是真香")
print(ids)                                        # 每个 id 一个 token
print([enc.decode([i]) for i in ids])             # token 边界可视化
print(len(enc.encode("一句话")))                   # token 数 = 计费/上下文的单位

必做观察：中文字符通常 1 字 = 1~2 token（国产模型用大中文词表压到约 1.5 字/token——Qwen 15.2 万词表对中文更省，这是”国产模型中文便宜”的底层原因之一）；英文平均 1 词 ≈ 1.3 token；代码和数字切分有自己的脾气（下节）。

4. tokenizer 造成的经典翻案（懂机理，见怪不怪）

1. “9.11 和 9.9 哪个大”：老 tokenizer 把数字按 2–3 位一切，模型看到的可能是 [9.1][1] vs [9.9]——它做的是 token 序列比较，不是数值比较。现代 tokenizer 改进数字切分 + 训练数据加了算术，但机理要懂；
2. “strawberry 有几个 r”：模型看到的是 2–4 个 token 的 id，不是 10 个字母——字符级信息被 tokenizer 抹掉了。它必须靠训练里学到的”间接知识”回答；
3. 特殊 token 注入：<|endoftext|> 这类保留 token 拥有特权（终止符、系统标记）。用户输入里出现它们可能逃逸出当前角色——所以推理框架把 special token 与普通文本分开编码（tiktoken 的 encode(..., allowed_special=) 参数就是干这个的）；
4. 中文/代码的序列长度差：同样的内容换 tokenizer，上下文占用和 API 费用差几十个百分比。

一句话：模型的一切能力都作用在 token 上，token 是 tokenizer 决定的——分析任何诡异行为，先看 token 边界。

5. 词表大小的权衡

• 词表大 → 序列短（省注意力平方的钱）、中文友好；代价是嵌入层参数大（$V \times d$，15 万词表 × 4096 维 ≈ 6 亿参数，比很多模型还大）和 softmax 计算大；
• 词表小 → 模型小序列长；
• 现代主流：12.8 万–15.2 万（LLaMA 128k，Qwen 152k），多语料时代的甜点区。

6. 自测题

1. BPE 训练和编码各自在干什么？（训练学合并表：反复合并最高频相邻对；编码按学习顺序贪心重放）
2. 为什么字节级起点保证”永不出 OOV”？（任何 UTF-8 都是字节序列，256 基础 token 兜底）
3. “半个中文字”是什么现象？（token 边界切开 UTF-8 多字节字符；decode 用 errors=“replace”）
4. 为什么数字和字母计数是 LLM 的经典弱项？（字符级结构被 token 化抹掉，模型看到的是块 id）
5. 词表加大的两个收益两个代价？（序列短/中文省 token vs 嵌入参数大/softmax 开销）
6. special token 为什么要和普通文本分开编码？（防用户输入伪造终止符/系统标记越权）

7. 动手作业

1. 用第 2 节代码在一段中文+英文混合文本上训练 BPE（vocab_size=512），decode 自己的 encode，验证无损往返；
2. 用 tiktoken 分别统计：同一段中文新闻、同长度英文新闻、一段 Python 代码的 token 数，算”字符/token 比”并解释差异；
3. 找出 o200k_base 里”多模态”三个字的切分边界，画出每个 token 的字节构成；
4. 挑战：读 Karpathy《Let’s build the GPT Tokenizer》前半段，把你的实现升级为支持 special token 的版本。

案例 · BPE 三步合并全记录

语料（词频）：low ×3，lower ×1，slower ×1（词尾统一加 </w> 标记，从 256 个字节 token 起步）。

三轮之后，low 已是单个 token；lower 只差最后一并（low+er → lower，频次 2，第 4 轮完成）。

读出 BPE 的品格：高频模式永远优先获得 token 席位——常见词先被”压缩成词”，罕见组合后合并。词表大小就是压缩轮数的预算：15 万词表 = 允许 15 万次贪心合并。中文同理，“的""是”这类高频字会极早合并成整字 token——这就是 2.3 说”国产大词表对中文更省”的机理演示。

8. 延伸资源

• Karpathy《Let’s build the GPT Tokenizer》——与本章一一对应
• minbpe repo（~100 行的生产级参考实现）
• tiktoken repo / HuggingFace tokenizers——工业实现（Rust 底座）

2.3 GPT 架构工程版：从 TinyGPT 到 nanoGPT

本章目标：1.3 章你造出了”教学版”GPT；这一章做工业版升级清单——现代开源模型（LLaMA/Qwen）相对教科书版本的每一处改动及其理由，外加推理侧最重要的两件事：KV cache 与 prefill/decode 两阶段。这是读开源模型源码（卷3 的 Qwen-VL/InternVL）前的最后一站。

1. 升级清单：教学版 → 现代开源版

读源码的预期：卷3 你打开 Qwen-VL 源码时，逐项对号入座——所有”新东西”你都已见过。

2. nanoGPT 精读地图

nanoGPT（Karpathy）的三个文件对应你已经掌握的三块知识：

• model.py：1.3 的 Block + 工业化细节。值得抄的两个初始化 trick：所有权重 $\mathcal{N}(0, 0.02)$；残差路径上的输出投影（c_proj）再乘 $1/\sqrt{2L}$——让残差流方差不随深度累积（GPT-2 原版技巧，解释了”为什么深层初始化要按层数缩放”）；
• train.py：0.2+0.4 章训练循环的全配置化版本。配方：AdamW($\beta_2$=0.95，非默认 0.999——大模型经验值)、weight decay 只作用在 2 维矩阵参数（1 维的 norm/bias 不 decay——“参数形状决定 decay 与否”是行规）、grad clip 1.0、warmup+cosine、bf16；
• configurator.py：key=value 文本覆盖配置的小机制——工程品味样本，10 分钟读懂。

3. KV cache：推理为什么必须缓存

问题：自回归生成第 $t$ 个 token 时，因果 mask 意味着历史 token 的 K、V 不会变。朴素做法每步都重算全部历史的前向——生成 $T$ 个 token 要 $O(T^2)$ 次注意力计算，浪费一倍以上。