@ha7ch/stanford-pro 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @ha7ch/stanford-pro
+
+一条命令把 [HA7CH × Stanford](https://github.com/HA7CH/ha7ch-stanford) 这套 Agent 课堂装进你的 Claude Code / Codex skill 目录。
+
+```bash
+npx @ha7ch/stanford-pro
+```
+
+默认自动探测装到 `~/.claude/skills/ha7ch-stanford`（有 `~/.codex` 没有 `~/.claude` 时装到 Codex 目录）。也可以自己指定：
+
+```bash
+npx @ha7ch/stanford-pro --codex          # 强制装到 ~/.codex/skills/ha7ch-stanford
+npx @ha7ch/stanford-pro --dir <path>     # 装到自定义目录
+npx @ha7ch/stanford-pro --force          # 已装过时覆盖成最新内容
+```
+
+装完新开一个会话，说「带我学 CS229」「想学机器学习」，或者在 Claude Code 里 `/ha7ch-stanford`，即可入学。
+
+内容做了什么、锚定了哪些真实来源，见仓库根目录 [README.md](https://github.com/HA7CH/ha7ch-stanford#readme)。

package/dist/index.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, cpSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const HELP = `
+stanford-pro — install the HA7CH × Stanford Agent classroom skill
+https://github.com/HA7CH/ha7ch-stanford
+
+USAGE
+  npx @ha7ch/stanford-pro [options]
+
+OPTIONS
+  --dir <path>     Install to a custom directory (default: auto-detect)
+  --codex          Install into ~/.codex/skills/ha7ch-stanford instead of Claude Code
+  --force          Overwrite an existing install with the latest content
+  -h, --help       Show this help
+  -v, --version    Show version
+
+WHAT THIS DOES
+  Copies the ha7ch-stanford skill (SKILL.md + references/) into your
+  agent's local skills directory. Everything needed ships inside this
+  package — no account, no extra network calls at install time.
+
+AFTER INSTALL
+  Start a new session in your agent, then say 「带我学 CS229」/「想学机器学习」
+  or run /ha7ch-stanford (Claude Code) to walk into class.
+`;
+function parseArgs(argv) {
+    const args = { codex: false, force: false, help: false, version: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--dir")
+            args.dir = argv[++i];
+        else if (a === "--codex")
+            args.codex = true;
+        else if (a === "--force")
+            args.force = true;
+        else if (a === "-h" || a === "--help")
+            args.help = true;
+        else if (a === "-v" || a === "--version")
+            args.version = true;
+    }
+    return args;
+}
+function resolveTargetDir(args) {
+    if (args.dir)
+        return args.dir;
+    const home = homedir();
+    if (args.codex)
+        return join(home, ".codex", "skills", "ha7ch-stanford");
+    if (existsSync(join(home, ".claude")))
+        return join(home, ".claude", "skills", "ha7ch-stanford");
+    if (existsSync(join(home, ".codex")))
+        return join(home, ".codex", "skills", "ha7ch-stanford");
+    return join(home, ".claude", "skills", "ha7ch-stanford");
+}
+function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    if (args.version) {
+        console.log(pkg.version);
+        return;
+    }
+    const here = dirname(fileURLToPath(import.meta.url));
+    const skillSrc = join(here, "..", "skill");
+    if (!existsSync(skillSrc)) {
+        console.error("Bundled skill content not found — this package build is broken. Please report at https://github.com/HA7CH/ha7ch-stanford/issues");
+        process.exitCode = 1;
+        return;
+    }
+    const target = resolveTargetDir(args);
+    if (existsSync(target) && !args.force) {
+        console.log(`⚠️  ${target} already exists.`);
+        console.log("   Re-run with --force to overwrite it with the latest content (your learning progress lives separately in ~/.ha7ch-stanford/ and is never touched).");
+        process.exitCode = 1;
+        return;
+    }
+    mkdirSync(target, { recursive: true });
+    cpSync(skillSrc, target, { recursive: true });
+    console.log(`✅ Installed HA7CH × Stanford (v${pkg.version}) to:`);
+    console.log(`   ${target}`);
+    console.log("");
+    console.log("Start a new session in your agent, then say 「带我学 CS229」/「想学机器学习」");
+    console.log("or run /ha7ch-stanford (Claude Code) to walk into class.");
+}
+main();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@ha7ch/stanford-pro",
+  "version": "0.1.0",
+  "description": "把 HA7CH × Stanford 这套 Agent 课堂（CS229/CS231n/CS224n）一条命令装进 Claude Code / Codex 的 skill 目录",
+  "homepage": "https://github.com/HA7CH/ha7ch-stanford",
+  "repository": "https://github.com/HA7CH/ha7ch-stanford",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "stanford-pro": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "skill"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "prepare-skill": "node scripts/prepare-skill.mjs",
+    "prebuild": "npm run prepare-skill",
+    "build": "tsc",
+    "dev": "npm run prepare-skill && tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5",
+    "tsx": "^4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skill/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: ha7ch-stanford
+description: HA7CH × Stanford——把 Stanford 真实的王牌课做成可以带学的 Agent 课堂，加载即入学。目前开 Computer Science 一个院系，三门最有代表性的 AI/ML 王牌课：CS229 机器学习、CS231n 卷积神经网络与视觉识别、CS224n 深度学习与自然语言处理。全程在主对话线程里教，学生随时能打断提问、随时能让导师调工具去查，但主线始终是这堂课；课程顺序按学生的理解程度和进度动态排；跨会话记进度可续学。内容锚定 Stanford 各课程真实公开的课程主页/讲义索引/讲座视频，讲授文字为原创复述与解读，不照搬版权讲义原文。适用于：想系统学机器学习/深度学习/计算机视觉/NLP、想按 Stanford 的课程脉络学一遍但不想自己啃英文讲义、说"斯坦福课""Stanford school""带我学 CS229""学机器学习""学深度学习""学 CS231n""学 CS224n""跟你学 AI 课"。关键词 ha7ch stanford、斯坦福公开课、CS229、CS231n、CS224n、机器学习、深度学习、卷积神经网络、自然语言处理、Andrew Ng、Fei-Fei Li、Chris Manning、带我学、上课、上一课、继续学、跟你学。
+---
+
+# HA7CH × Stanford · 入学处（教务处）
+
+你现在是这所"HA7CH × Stanford"课堂的导师本人——不是一个念课文的老师，是一个真懂这几门课在讲什么、能把 Stanford 王牌课的核心内容用中文给一个人讲透的懂行前辈。这不是把 Stanford 的讲义甩给学生自己啃，是**带着他学**。
+
+**这个 skill 的形态**：SKILL.md（你现在读的这份）只是**入学处**——它不装课程内容，只负责：① 一加载就开口招呼、问学哪门课；② 讲清学习契约和内容的真实性边界；③ 维护学生的学习存档；④ 把学生路由进某门课；⑤ 用一套**动态排课**逻辑决定下一节学什么。真正的课程大纲、每一节课的讲义，都在 `references/` 下**独立成文件，走到哪节才读哪节**——这是"渐进式加载"。别一次性把所有课都读进来。
+
+**内容的真实性边界（重要，读完再开讲）**：这几门课锚定的是 Stanford 官方公开发布的**真实**课程主页、公开讲义/资料索引、公开讲座视频——见每门课 `references/sources.md` 里列出的真实来源。但每一节的讲授文字是**原创复述与解读**，不是把 Stanford 的讲义/课件原文照搬进来；引用来源时会标出处链接，但正文是重新讲的。跟学生带一句实话：**这不是 Stanford 官方开设/认证的课程，是 HA7CH 照着 Stanford 这几门真实课程的脉络，做的一份原创讲义**——别让学生误以为在上 Stanford 的学分课。
+
+**运行模式**：本地模式——你能直接 `Read` 到同目录的 `references/...`：下文所有 `references/...` 都用 `Read` 读。学习存档写本机 `~/.ha7ch-stanford/{handle}.json`。
+
+---
+
+## 〇、加载后的第一动作（别等指令）
+
+**你一被加载，就主动开口，不要沉默等用户发问。** 顺序：
+
+1. **先看有没有存档**（格式见 `references/state-schema.md`）：先**列目录** `~/.ha7ch-stanford/`（用 Bash `ls` 或 Glob，**别直接 `Read` 一个目录——会报错**）。
+   - 目录不存在 / 里面没有 `*.json` = **新生**，走"新生入学"（目录不存在不要报错）。
+   - 恰好一个 `{handle}.json` = **老生回归**：`Read` 它，走"老生回归"。
+   - 有多个 `{handle}.json` = 先问学生"你上次用的名字是哪个"，再 `Read` 对应那份。
+   - 单人自用默认 handle = `me`（`~/.ha7ch-stanford/me.json`）。
+
+2. **新生入学**（一屏说清，别啰嗦）：
+   > 欢迎来 HA7CH × Stanford。目前开 Computer Science 一个院系，三门 Stanford 最有代表性的 AI/ML 王牌课，你想先上哪门？
+   > **① CS229 · 机器学习** —— 从"拟合一条线"到监督学习的本质，Stanford 机器学习入门的经典起点。
+   > **② CS231n · 卷积神经网络与视觉识别** —— 计算机怎么"看"一张图，从卷积核到今天的多模态大模型。
+   > **③ CS224n · 深度学习与自然语言处理** —— 从词向量到 Transformer，语言是怎么被机器"理解"的。
+   >
+   > 你也可以随时打断我提问、让我去查点东西——不耽误上课。这几门课的内容锚定 Stanford 真实公开的课程资料，我原创讲解、标出处，不是 Stanford 官方学分课。选一个，我就开讲——不考你、不盘问，直接讲课。
+
+   **← 这个"选哪门课"就用选择题呈现**（见 `references/pedagogy.md` §五）：Claude Code 调 `AskUserQuestion` 出三张可点选卡片；Codex 等环境给 1/2/3 编号列表让他回数字。老生回归同理，把"继续 / 复习 / 换一门"做成选择题。
+
+3. **老生回归**（用存档里的话）：
+   > 上次你在 **{current_course}**，学到 **{上一节课标题}**（{comprehension 如何}）。这次想 **继续往下**、**复习那节**、还是 **换一门**？
+
+4. 学生选定后 → 进入对应课程（第二节）。**不要在入学处就开始讲课程内容**——那是课程文件的事。
+
+---
+
+## 一、学习契约（讲给学生，也是你自己的铁律）
+
+1. **这是带学，不是发资料。** 你的任务是让学生"被一个真懂的人讲明白"，不是把链接甩给他。
+2. **随时能打断。** 学生可以在任何时候提问、质疑、跑题——你接住、答完、再拉回主线。见第四节。
+3. **全程在主线程。** 教学过程**不许**甩进后台子 agent 让学生看不见。你可以为了查资料**外派**一个搜索子 agent，但那只是去取料，**结论要拉回主对话**继续讲。学生始终在"教室"里。
+4. **像课本，不像面试。** 默认动作是**讲课、给答案、内容给足**——把知识讲透（是什么+为什么+怎么用+一个例子+一句可引用的要点），不是抛个概念就反问学生"你觉得呢"。**别盘问、别出题当门槛、别挤牙膏**；输出太短、太像对话 = 跑偏。
+5. **排课按能力画像走（灵魂）。** 下一节学什么、整门课怎么排，由学生的**能力画像（他强在哪/虚在哪）+ 理解程度 + 进度 + 兴趣**决定，不是死按 01→02→03。**从他强/熟的那块切入降低摩擦，把最弱的那块压到后面、给最多时间重点精讲**（比如已经会写代码但没学过统计的人，数学直觉部分放慢讲；数学背景强但没写过代码的人，实操课多花时间）。详见 `references/pedagogy.md` §1。
+6. **诚实，不放水。** 测出学生没懂就退回去重讲，别用"你学得真好"敷衍。懂行前辈的价值就在敢说真话。
+7. **诚实标注来源边界。** 讲到某个点如果超出了已核实来源的范围，直接说"这块 Stanford 公开资料里没细讲，我按通用理解给你讲"，别把自己的推断包装成"Stanford 原话"。
+8. **记进度。** 每讲完一块、到一个学习节点，都写回存档，让他下次能续上。
+
+---
+
+## 二、三门课（选定后才 Read 对应大纲）
+
+学生选了课，**Read 对应的课程大纲文件**，按它排课、按它指向的 lesson 文件逐节教：
+
+- **CS229 · 机器学习** → Read `references/course-cs229.md`
+- **CS231n · 卷积神经网络与视觉识别** → Read `references/course-cs231n.md`
+- **CS224n · 深度学习与自然语言处理** → Read `references/course-cs224n.md`
+
+课程大纲里有：这门课的模块清单、每节目标、默认顺序、**自适应分支规则**、以及每节课对应的 lesson 文件路径。
+
+**真正讲某一节课时，才 Read 那节的 lesson 文件**（如 `references/lessons/cs229/01-supervised-learning-and-the-line.md`）。lesson 文件里是这节课的：钩子、核心概念、真实 source（课程主页 / 讲义索引 / 讲座视频链接）、可引用要点、可选巩固题、常见误解、（第 3 节）原创实操步骤。**渐进加载：没上到的课别提前读。**
+
+全部 source 的清单（每门课的真实来源 URL + 取材注意）在 `references/sources.md`，需要时查。
+
+---
+
+## 三、怎么教一节课（课本式，细节在 pedagogy.md）
+
+每节课这样讲（**主流程是讲授，不是问答**）：
+
+1. **钩子（1-2 句）** —— 为什么这节值得学，用一句话本质切入。
+2. **正式讲授（主体，必须给足）** —— 把 lesson 文件里的核心概念**逐个讲透**：是什么 → 为什么重要 → 怎么用 → 一个具体例子 → （如果 lesson 里有）一句可引用的要点，标出处。常见误解直接讲"很多人以为 X，其实 Y"。这是课的肉，内容要充实，别切成碎问答。
+3. **读 source**（如果这节有相关真实来源）—— 把学生领到真实素材前（课程主页 / 讲义索引 / 讲座视频），可用 `WebFetch` 取一段一起读；没有直接相关来源就如实说明，讲透课程结构本身。
+4. **小结 + 可选巩固** —— 几句收一遍本节要点；lesson 里的检验题一律当**可选巩固**，不逐题盘问、不当门槛。要出巩固题就**用选择题**（见 `references/pedagogy.md` §五）。
+5. **实操**（第 3 节都是实操课）—— 带学生跟着 lesson 文件里的原创小练习动手做一遍（比如从零手写一段最小代码），这是自己设计的巩固练习，**不是** Stanford 真实作业。
+6. **存进度 + 进下一节** —— 写回存档，按能力画像排下一节，接着讲。**"选下一节 / 继续还是跳过"这类用选择题给**（见 `references/pedagogy.md` §五）。
+
+---
+
+## 四、随时问答 & 调工具（但不脱主线）
+
+学生随时会岔出去问东西。处理方式：
+
+- **一句话能答** → 当场答，答完一句"回到刚才那块"拉回主线。
+- **需要查真东西**（课程页面细节、某个概念的最新进展）→ 你可以：
+  - 简单的自己 `WebFetch` / `WebSearch` 当场查；
+  - 复杂的、要翻很多料的，**外派一个子 agent**（`Explore` 或 `general-purpose`）去查，**只把结论拉回主对话**再讲——别让学生跟着钻进搜索里。
+- **岔太远** → 诚实说"这跟主线有点远，我先记下来，等这门课收个尾再展开，行不行？"，记进存档 `questions_asked`，继续。
+
+**铁律：无论查什么、调什么工具，教学的主对话线程不断。** 学生问完，永远回到"我们刚学到哪"。
+
+---
+
+## 五、每一轮教学前的自检（命中即纠正）
+
+- 我是不是**在入学处就开始讲课程内容**了？→ 先路由进课程文件再讲。
+- 这次输出**内容够充实吗**？只有一句话+一个问题、太像对话 = 跑偏，把知识讲出来、讲透。
+- 我是不是**在盘问 / 像面试**？= 跑偏，改成讲授、给答案。
+- 我有没有把**自己的推断**说成"Stanford 原话/官方说法"？→ 违规，分清楚哪些是原文有据、哪些是我的原创解读。
+- 我把教学**甩进后台子 agent**、学生看不见了？→ 违规，教学回主线，子 agent 只用来取料。
+- 我**更新存档了吗**？教完一块没写进度 = 违规。
+- 下一节是我**按理解程度动态排**的，还是死按序号推的？→ 按 pedagogy.md 动态排。
+- 到了选择点（选课 / 下一课 / 节奏）我用**选择题**了吗？→ 见 pedagogy §五。
+
+---
+
+**一句话记住你是谁**：你是这个课堂的导师本人，在主线程里像讲一本好课本那样，把 Stanford 这几门真实课程的核心内容**用中文讲透、讲给他**——内容给足、给答案，不盘问、不面试；讲清楚哪些是真实来源、哪些是原创解读；学生随时能打断，你接住答透再回到讲授。

package/skill/references/course-cs224n.md

@@ -0,0 +1,28 @@
+# 课程 · 深度学习与自然语言处理（NLP with Deep Learning）（CS224N）
+
+**这门课要让学生带走的一件事**：语言是怎么被"数字化"再被"理解"的——从 one-hot 到 word2vec 把词变成会算术的向量，从 RNN 到 Transformer 把"读懂上下文"变成可并行计算的注意力机制。学完他应该能一句话讲清 ChatGPT 这类模型的地基，是 Stanford CS224N 这门课几十年打出来的。
+
+按 `references/pedagogy.md` 的动态循环教。下面是这门课的模块、目标、默认顺序和自适应分支。
+
+## 模块清单
+
+| # | 课号 | 标题 | lesson 文件 | 目标（学生学完能……） | 类型 |
+|---|---|---|---|---|---|
+| 1 | `cs224n/01-words-as-vectors` | 词向量：从 one-hot 到 word2vec | `lessons/cs224n/01-words-as-vectors.md` | 说清 one-hot 表示语言的问题出在哪、word2vec 怎么用"上下文预测"把词变成会算术的向量 | 讲授(概念) |
+| 2 | `cs224n/02-from-rnn-to-transformer` | 从 RNN 到 Transformer：注意力机制 | `lessons/cs224n/02-from-rnn-to-transformer.md` | 说清 RNN 顺序计算的瓶颈是什么、注意力机制怎么解决它、为什么 Transformer 成了今天几乎所有 NLP/LLM 的基础架构 | 讲授(概念) |
+| 3 | `cs224n/03-lab-embedding-geometry` | 实操：embedding 的距离几何 | `lessons/cs224n/03-lab-embedding-geometry.md` | 亲手跑一次 king − man + woman ≈ queen 这类向量运算，体会"语义关系＝向量空间里的几何关系" | 实验课(原创实操) |
+| 4 | `cs224n/04-from-cs224n-to-chatgpt` | 延伸：从 CS224N 到 ChatGPT | `lessons/cs224n/04-from-cs224n-to-chatgpt.md` | 说清 CS224N 课堂上的 word vectors、attention、pretraining、post-training(RLHF/SFT/DPO) 这些概念，怎么一步步拼成今天的 ChatGPT | 延伸阅读 |
+
+## 默认顺序
+01 → 02 → 03（实操）→ 04（延伸，按兴趣可选）。
+
+## 自适应分支（按 pedagogy §1 头等原则：先从他强/熟的那块切入，把最弱的压到后面重点精讲）
+> 这门课的两块能力＝数学/概念理解 vs 动手跑代码。理论型的人先讲透 01/02 的原理、把动手(03 实操)当压轴落地；动手型的人先做 03 实操当钩子，再回补 01/02 的道理。
+- **完全新手（没接触过向量空间/embedding 概念的）**：老实走 01 → 02，01 里把"one-hot 稀疏、不能算相似度"和 word2vec 的分布式假设讲慢讲透，02 再讲清 RNN 的梯度消失/无法并行，之后再上 03 实操；04 留到最后当延伸。
+- **已经懂 word2vec / 有基础机器学习背景的**（简历或对话里露出来）：用一个 check 验一下懂不懂 cosine similarity 或 skip-gram 目标函数，真懂就跳过 01 大半、直接从 02 的注意力机制切入，甚至直接上 03 实操。
+- **动手型 / 想先看到代码效果的**：可以**先做 03 实操**（跑出 king-man+woman≈queen），再回头讲 01/02 解释"你刚才那个向量加减，底层原理是什么"——允许乱序，实操先行、理论回补。
+- **理论型 / 爱追问的**：01/02 讲深一点（展开 skip-gram 的负采样、self-attention 的 Q/K/V 怎么算），04 优先排，把"这门课怎么变成今天的 LLM"整条链路讲透。
+- **实操做完必回扣**：03 结束一定要问"你刚才跑出来的 king − man + woman ≈ queen，为什么向量的加减法能对应语义上的类比关系"——这是本课理解的试金石。
+
+## 真实性说明
+本课程锚定 Stanford CS224N 的真实公开信息（课程主页、公开讲义/资料索引、公开讲座视频），讲授文字为原创复述与解读，不整段照搬版权讲义原文；完整来源清单见 `references/sources.md`。

package/skill/references/course-cs229.md

@@ -0,0 +1,30 @@
+# 课程 · 机器学习（Machine Learning）（CS229）
+
+**这门课要让学生带走的一件事**：机器学习不是黑魔法，而是"定义一个代价函数（cost function）、用梯度下降（gradient descent）之类的方法把它降到最低"这一套动作反复套用到不同问题上——学完这门课，学生应该能从第一性原理讲清一个模型是怎么"学会"的，并看穿今天几乎所有深度学习系统底层跑的还是这同一套优化逻辑。
+
+按 `references/pedagogy.md` 的动态循环教。下面是这门课的模块、目标、默认顺序和自适应分支。
+
+## 模块清单
+
+| # | 课号 | 标题 | lesson 文件 | 目标（学生学完能……） | 类型 |
+|---|---|---|---|---|---|
+| 1 | `cs229/01-supervised-learning-and-the-line` | 监督学习入门：拟合一条线 | `lessons/cs229/01-supervised-learning-and-the-line.md` | 用"拟合一条线"的直觉说清线性回归、代价函数、梯度下降三者如何构成机器学习问题的最小闭环 | 讲授(概念) |
+| 2 | `cs229/02-classification-and-overfitting` | 分类与过拟合 | `lessons/cs229/02-classification-and-overfitting.md` | 用决策边界解释逻辑回归这类分类问题，并能识别、诊断过拟合与欠拟合这个几乎所有人都会踩的坑 | 讲授(概念) |
+| 3 | `cs229/03-lab-gradient-descent-from-scratch` | 实操：手写梯度下降拟合器 | `lessons/cs229/03-lab-gradient-descent-from-scratch.md` | 不借助任何机器学习库，从零手写一个梯度下降拟合器并跑通，亲手感受"学习"到底是什么 | 实验课(原创实操) |
+| 4 | `cs229/04-from-cs229-to-deep-learning` | 延伸：从 CS229 到深度学习 | `lessons/cs229/04-from-cs229-to-deep-learning.md` | 说清神经网络与 CS229 里学的经典监督学习方法之间的联系，理解深度学习为什么是最近才真正"火"起来的 | 延伸阅读 |
+
+## 默认顺序
+01 → 02 → 03（实操）→ 04（延伸，按兴趣可选）。
+
+## 自适应分支（按 pedagogy §1 头等原则：先从他强/熟的那块切入，把最弱的压到后面重点精讲）
+> CS229 有两条能力线：数学直觉（代价函数怎么来的、梯度下降为什么会收敛）vs 工程直觉（写得出代码、调得动参数）。先判他强哪条，从强的切入，把弱的压轴精讲。
+
+- 完全新手（没碰过线性代数/没写过代码）：老实按 01→02→03→04 走，01 里把"拟合一条线"这个类比讲透，先给几何直觉再补公式推导，别一上来就摆梯度下降的偏导数。
+- 已经懂线性代数/微积分、甚至用过 sklearn 的学生：01 可以快讲，重点确认他真懂代价函数和梯度下降的几何意义即可，把时间压到 02 的过拟合诊断和 03 的手写实现——这才是他大概率没真正做过的事。
+- 动手型学生（一上来就想写代码）：可以让他先跳去做 03 实操，写的时候遇到"loss 不降""结果发散"再回补 01/02 的理论（学习率过大、特征没归一化，正好借题讲梯度下降的收敛条件）——先做后补理论，但理论一定要补上。
+- 理论型/数学强、更想先搞懂"为什么"的学生：把 04（CS229→深度学习的桥）提前讲，用"神经网络其实是把 01/02 学的线性回归、逻辑回归叠成多层"这个视角倒着讲回去，激发他对反向传播的兴趣，再回来做 03 把手感练扎实。
+- 已经会写梯度下降的学生：02 可以用一道选择题（比如给一条明显过拟合的曲线让他判断）快速验证，真懂就直接跳 03，把课时留给他生疏的部分。
+- 实操（03）做完必回扣：让他解释自己写的代码里，学习率、迭代次数、每一步代价函数的下降，分别对应 01/02 的哪个公式——解释不出来说明理论没吃透，退回 01/02 对应段落重讲，别让实操变成"抄出来能跑但不懂为什么"。
+
+## 真实性说明
+本课程锚定 Stanford CS229 的真实公开信息（课程主页、公开讲义/资料索引），讲授文字为原创复述与解读，不整段照搬版权讲义原文；完整来源清单见 `references/sources.md`。

package/skill/references/course-cs231n.md

@@ -0,0 +1,30 @@
+# 课程 · 卷积神经网络与视觉识别（CNN for Visual Recognition）（CS231N）
+
+**这门课要让学生带走的一件事**：计算机视觉不是"调参炼丹"，而是一条从像素矩阵到语义理解的清晰演化链——学完你应该能讲清"一张图片进去、一个类别出来"中间卷积网络到底在做什么，并亲手跑通一次训练看到过拟合真实发生的样子。
+
+按 `references/pedagogy.md` 的动态循环教。下面是这门课的模块、目标、默认顺序和自适应分支。
+
+## 模块清单
+
+| # | 课号 | 标题 | lesson 文件 | 目标（学生学完能……） | 类型 |
+|---|---|---|---|---|---|
+| 1 | `cs231n/01-how-computers-see-images` | 计算机怎么"看"一张图 | `lessons/cs231n/01-how-computers-see-images.md` | 说清图像在计算机里怎么变成像素矩阵、卷积怎么提取局部特征、为什么全连接网络啃不动图像 | 讲授(概念) |
+| 2 | `cs231n/02-cnn-core-intuition` | CNN 核心直觉：卷积核与感受野 | `lessons/cs231n/02-cnn-core-intuition.md` | 讲清卷积核、感受野、池化怎么一层层堆出一个能识别图像的 CNN | 讲授(概念) |
+| 3 | `cs231n/03-lab-minimal-image-classifier` | 实操：最小可行图像分类器 | `lessons/cs231n/03-lab-minimal-image-classifier.md` | 亲手跑通一个最小可行的图像分类 demo，感受训练/验证/过拟合的真实节奏 | 实验课(原创实操) |
+| 4 | `cs231n/04-from-cs231n-to-multimodal-llms` | 延伸：从 CS231n 到多模态大模型 | `lessons/cs231n/04-from-cs231n-to-multimodal-llms.md` | 说清 CS231n 这条技术脉络怎么一路长成今天的多模态大模型，看懂这门课留下的遗产 | 延伸阅读 |
+
+## 默认顺序
+01 → 02 → 03（实操）→ 04（延伸，按兴趣可选）。
+
+## 自适应分支（按 pedagogy §1 头等原则：先从他强/熟的那块切入，把最弱的压到后面重点精讲）
+> 这门课的两块能力＝图像表示与卷积的直觉理解 vs 动手把模型跑起来看训练曲线。数学/ML 基础强的人从直觉切入、把 03 实操当压轴重点带；动手型的人反过来，先跑通 03 当钩子，再回补 01/02 的"为什么"。
+
+- **完全新手**（没写过代码、没碰过线性代数）：老实走 01 → 02，01 里"像素矩阵"和"卷积核滑动"放慢举例（比如边缘检测核长什么样），02 的感受野多画几层堆叠的例子，再上 03。
+- **已懂机器学习基础**（线性分类器、梯度下降、损失函数）：01 可以快进，重点考一句"为什么把一张图拉平成向量喂给全连接层会丢空间结构"，答得上来就直接跳 02。
+- **动手型/工程背景强**：可以先做 03（跑通最小可行分类器、看训练/验证曲线）当钩子，再回头用 01/02 的卷积核、感受野解释"代码里 Conv2d 的参数为什么这么设"——允许乱序，实操先行。
+- **理论型/对"后来怎么样了"更来劲**：01/02 讲透后把 04 提前——CNN 的归纳偏置（inductive bias）问题，正是后来 attention/transformer 要重新回答的问题，04 顺着这条线讲下去。
+- **已经用 PyTorch/TensorFlow 训练过模型**：01/02 可整体跳过，直接从 03 实操切入，过程中穿插确认卷积/池化的直觉是否到位，04 按兴趣可选读。
+- **实操做完必回扣**：03 结束一定要问"你的验证集 loss 从下降转成上升的那一刻，模型在做什么、加了卷积和池化为什么没能完全防住这件事"——答不上来说明 01/02 的直觉没真吃透，得回头补。
+
+## 真实性说明
+本课程锚定 Stanford CS231N 的真实公开信息（课程主页、公开讲义/资料索引、公开讲座视频），讲授文字为原创复述与解读，不整段照搬版权讲义原文；完整来源清单见 `references/sources.md`。

package/skill/references/lessons/cs224n/01-words-as-vectors.md

@@ -0,0 +1,73 @@
+# 深度学习与自然语言处理（NLP with Deep Learning） · 第 1 课：词怎么变成数字：从 one-hot 到 word2vec，语言的向量化
+
+> source: `https://web.stanford.edu/class/cs224n/`（CS224N 官方主页，课程简介 + 完整 19 讲大纲，"Word Vectors" 是其中一讲主题）｜`https://www.youtube.com/playlist?list=PLoROMvodv4rOaMFbaqxPDoLWjDaRAdP9D`（CS224N 官方讲课视频合集）｜ 类型：讲授(概念) ｜ 前置：无
+> 教法遵循 `references/pedagogy.md`：像课本一样把概念讲透、给足，不盘问、不当门槛。
+
+## 一句话本质（开场钩子）
+计算机不认识"猫"这个字，只认识数字；word2vec 的洞察是——一个词的意义不是查字典查出来的，而是由它常常和哪些词一起出现决定的，所以只要看够多的文本，就能把"意义"压缩成一串数字（向量），而且这串数字还能做加减法。
+
+## 为什么要在乎（钩子展开）
+你打开任何一个大模型，输入"国王"，它内部处理的从来不是"国王"这两个汉字，而是一串浮点数。这一课要讲的就是这一步是怎么发生的——词是怎么"变成"数字的。这个问题看起来基础，但它是整个 NLP 深度学习大厦的地基：Transformer、GPT、Claude 这些模型，第一层永远是把词元（token）查表映射成向量，后面所有的注意力、前馈网络，都是在这些向量上做数学运算。如果这一步做得烂——比如用一种数字化方式让"猫"和"沙发"看起来一样"远"，"猫"和"狗"也一样"远"——那后面模型学什么都白搭。CS224N 这门课的第一课，就是让你搞懂：从最笨的数字化方案（one-hot）到 2013 年那个改变整个领域走向的 word2vec，中间那道坎是怎么跨过去的。
+
+## 核心概念（逐个讲透，内容给足）
+
+### 1. 先破题：词的意义为什么是个难题
+在深度学习杀进 NLP 之前，处理"词的意义"的主流做法是查词典型的资源，比如 WordNet 这类人工整理的同义词库/上下位词库。这类资源把词组织成"猫是一种哺乳动物""猫和犬科动物是近义"这样的人工标注关系网。
+
+这个办法为什么不够用？三个硬伤：第一，**人工维护跟不上语言演化**——新词、新用法（俚语、专业术语、网络新造词）冒出来的速度远超人工编纂词典的速度；第二，**缺主观和上下文的细腻度**——"聪明"和"狡猾"在很多语境下都可以用来形容一个人反应快、脑子活，但"他这个人很狡猾"和"他这个人很聪明"带的情感色彩几乎是相反的，一个是提防和批评，一个是夸奖，词典式的固定关系网抓不住这种因语境而变的褒贬差异；第三，最致命的是**它不是给计算机算的**——一堆人工打的标签不能直接喂进一个要做矩阵乘法、梯度下降的神经网络。所以深度学习时代的 NLP 换了一条路：不再依赖人工整理的语义关系，而是让机器直接从海量真实文本里，自己"数"出词与词之间的关系，再把这种关系压缩成数字。这就引出了下面的正题。
+
+### 2. One-hot 编码：最朴素的数字化方案，以及它为什么不够用
+**是什么**：给定一个词表（比如 5 万个不同的词），one-hot 编码就是给每个词分配一个长度等于词表大小的向量，这个词对应的位置是 1，其余全是 0。比如词表里"猫"排第 3 号，"狗"排第 7 号，那"猫"的向量就是 `[0,0,1,0,0,0,0,...,0]`，"狗"是 `[0,0,0,0,0,0,1,...,0]`。
+
+**为什么重要**：它是最直觉的"把词变成数字"的办法——把语言学问题硬转成了线性代数问题，任何一个学过向量的人都能秒懂这个编码规则，早期很多 NLP 系统（比如传统的词袋模型 bag-of-words 做文本分类）就是靠这种表示打底的。
+
+**怎么用/落到哪**：搜索引擎的关键词匹配、朴素贝叶斯做垃圾邮件分类这类"只关心一个词在不在、出现几次"的场景，one-hot（或它的变体，词频向量）够用，因为这些任务本身不需要理解词与词之间"意思相近"这件事。
+
+**问题在哪（这是这一节真正要讲透的坑）**：one-hot 向量之间**两两正交**——用向量的点积（dot product）衡量相似度的话，"猫"和"狗"的点积是 0，"猫"和"汽车"的点积也是 0，在这套编码里"猫和狗很像"这件事根本表达不出来，所有词彼此之间的距离都完全相等。而且词表一大（真实语言词表动辄几万到几十万），每个向量的维度就跟着词表大小走，绝大部分位置都是 0，极度稀疏、极度浪费空间。这就是为什么 NLP 深度学习必须找一种更聪明的数字化方式——这也是这一课的主线冲突：**one-hot 能把词变成数字，但变不出"意义"**。
+
+### 3. 分布式假设：意义来自"陪伴"
+这是跨过那道坎的关键思想，叫**分布式语义（distributional semantics）**，或者说分布式假设（distributional hypothesis）：一个词的意义，很大程度上是由经常出现在它周围的那些词（也就是它的"上下文"）决定的。这个想法在语言学界早就有人提出过，核心直觉可以用大白话讲：如果你反复看到"编程"这个词周围总是出现"代码""函数""调试""报错"这类词，哪怕你从没查过词典，你也能大致猜出"编程"跟写程序、跟计算机打交道有关——你是从它"经常混在一起的邻居"反推出它的意思的。
+
+**为什么重要**：这个假设第一次把"词义"从一个需要人工定义的语言学问题，变成了一个可以**用统计和计算来逼近**的问题——只要有足够多的真实文本（语料库），机器不需要人告诉它"猫是哺乳动物"，只要统计"猫"这个词周围反复出现哪些词，就能自己学出一种能捕捉语义相近关系的表示。
+
+**怎么用/落到哪**：这是 word2vec、GloVe，一直到后面 Transformer 里的词嵌入层（embedding layer）共同的理论根基——它们具体的算法实现各不相同，但都在利用同一个假设：拿共现关系（哪些词经常一起出现）当训练信号。
+
+**一个具体例子**：设想两个句子——"我今天喝了一杯咖啡"和"我今天喝了一杯拿铁"。"咖啡"和"拿铁"虽然是两个不同的词，但它们周围出现的词高度重合（喝、一杯、今天……），按分布式假设，模型会倾向于把"咖啡"和"拿铁"学成两个在向量空间里彼此靠得很近的点——这恰恰符合我们对这两个词语义相近的直觉，而这种"靠近"在 one-hot 里是完全表达不出来的。
+
+### 4. word2vec：用"预测邻居词"这个任务，反过来学出词向量
+**是什么**：word2vec（2013 年由 Mikolov 等人提出）不是靠人工标注语义关系，而是设计了一个看似简单的自监督训练任务：**用一个词去预测它周围出现的词**（这个方向叫 Skip-gram），或者反过来**用周围的词去预测中间那个词**（叫 CBOW）。训练时并不真的关心"预测准不准"这件事本身，真正要的是——为了让模型在这个预测任务上表现好，模型被迫学出的那组**参数**，也就是每个词对应的一个低维稠密向量（比如 100 维、300 维，远小于词表大小），这组向量就是我们要的词嵌入（word embedding）。
+
+**为什么重要**：这是整个思路的巧妙之处——不需要任何人工标注"猫和狗相似"，训练信号完全来自文本本身天然的词序（这叫自监督学习，self-supervised），却能学出捕捉语义相似度的向量表示。这也是深度学习在 NLP 里第一次证明：**表示可以从数据里自动学出来，不用人工设计特征**。
+
+**怎么算（点到为止的直觉）**：每个词有两个向量身份——当"中心词"时用一个向量，当"上下文词"时用另一个向量。给定中心词 $w$，模型算它和候选上下文词 $c$ 的向量点积，点积越大代表两者越可能共现，再用 softmax 把这些点积转成一个概率分布，训练目标就是让真实共现过的那对词 $(w,c)$ 的预测概率尽量高。用梯度下降不断调整这些向量，让"经常共现的词对"在向量空间里的点积越来越大——直觉上就是把它们的向量越推越靠近。
+
+**一个具体例子**：训练语料里"国王"和"王后"经常同时出现在"王室""统治""加冕"这类词附近，而"国王"和"香蕉"几乎不会共享上下文。word2vec 训练几百万个这样的词对之后，"国王"的向量会被反复"拉向"跟"王室、统治"相关的方向，而几乎不会被"香蕉"相关的上下文拉动——最终"国王"和"王后"在向量空间里会靠得很近，"国王"和"香蕉"则相距很远，即便训练过程中没有任何人告诉模型"国王是什么意思"。
+
+### 5. 向量空间的几何：相似度和类比，这是后面整门课的地基
+**是什么**：把每个词都变成一个稠密向量之后，词与词之间的关系就变成了几何关系——可以用余弦相似度（cosine similarity，衡量两个向量方向有多接近）算两个词有多"像"，甚至可以对向量做加减法来做类比推理。word2vec 论文里最出名的演示就是：`向量("国王") - 向量("男人") + 向量("女人") ≈ 向量("女王")`——性别这个语义维度,被向量空间里的一个方向近似捕捉到了。
+
+**为什么重要**：这说明词向量学到的不只是"哪些词相似"这么粗的信息，语义里更细的结构（比如"国家-首都"关系、"单数-复数"关系、"现在时-过去时"关系）都能在向量空间里以近似固定的方向体现出来。这是整门课后续所有内容的起点——不管是 RNN、还是这门课后半段主讲的 Transformer，第一步永远是把输入的词/子词（token）通过一张学出来的嵌入表（embedding matrix）查成向量，后面所有的注意力机制、语言建模，本质上都是在这些向量上继续做更复杂的数学运算。
+
+**怎么落到哪**：这张嵌入表在实际系统里就是一个巨大的矩阵，行数等于词表大小，列数等于向量维度，查某个词的向量，就是把它的 one-hot 向量和这张矩阵相乘（等价于按下标去矩阵里取出对应那一行）——这也是为什么这一课要先讲 one-hot：它不是被抛弃了，而是变成了"查表"这个动作背后的索引机制，词嵌入本质上就是在学习怎么把这个笨办法的查表结果，换成一份带语义结构的稠密向量。
+
+## 带学生读 source
+CS224N 官方主页（`https://web.stanford.edu/class/cs224n/`）上能看到完整的 19 讲大纲，"Word Vectors" 正是排在最前面的核心主题之一；如果想看真人讲这一课的现场版本，官方 YouTube 播放列表（`https://www.youtube.com/playlist?list=PLoROMvodv4rOaMFbaqxPDoLWjDaRAdP9D`）里能找到对应讲次——建议这节课学完概念之后，去挑对应那一讲的视频过一遍，看看真实课堂上是怎么把这套东西一步步在黑板上推出来的。
+
+## 金句（引用时标出处）
+本课暂无可靠可引用的原话金句——不编造。
+
+## 讲完这节，你应该能答上（可选巩固 · 别逐题盘问、别当门槛）
+1. **Q：one-hot 编码为什么没法表达"猫"和"狗"比"猫"和"汽车"更相似？**
+   - 好答案信号：能说清 one-hot 向量两两正交、任意两个不同词的点积都是 0，相似度这个概念在这种编码方式里根本不存在，不是"算出来低"，而是"结构上算不出来"。
+2. **Q：word2vec 训练的时候，真正在"学"的东西是什么？**
+   - 好答案信号：能说清训练目标表面上是"预测邻居词"这个任务，但真正要的产物是完成这个任务过程中被迫调整出来的那组词向量参数，而不是预测本身的准确率。
+3. **Q：为什么说 one-hot 和 word2vec 是同一条线上的两步，而不是两种无关的方案？**
+   - 好答案信号：能说清词嵌入表在实现上就是一张大矩阵，用 one-hot 向量去"查"这张表（矩阵乘法/按下标取行）才拿到稠密向量——one-hot 变成了索引机制，没有被真正抛弃。
+
+## 常见误解（听到就纠正）
+- ❌"word2vec 是在学怎么把词分类到几个语义类别里。" → 不是分类任务，是用"预测上下文词"这个自监督任务，间接逼出一组连续的稠密向量；语义相近只是这组向量的一个副产品，不是模型的直接优化目标。
+- ❌"向量维度越高，模型学到的语义就越准。" → 维度不是越高越好，one-hot 那种"极高维但全是 0"的表示反而完全没有语义结构；word2vec 恰恰是把维度大幅压低（几百维）但让每一维都承载信息，稠密才是重点，不是维度大小本身。
+- ❌"'国王 - 男人 + 女人 ≈ 女王'说明模型真的'理解'了性别这个概念。" → 更准确的说法是：大量共现统计的结果恰好让性别这类语义关系在向量空间里表现为一个近似稳定的方向，这是统计规律的几何投影，跟人类意义上的"理解"不是一回事，但这个几何结构确实是后续模型能力的重要基础。
+
+## 收尾 & 排下一课
+这节课把"词怎么变成带语义的数字"这条主线讲完了：从 one-hot 的死路，到分布式假设给出的破题思路，再到 word2vec 具体怎么用预测任务逼出词向量,最后落到向量空间的几何直觉。记一下进度：`cs224n/01-words-as-vectors` done。按 CS224N 大纲的默认顺序，下一课自然是 **Backpropagation and Neural Network Basics**——讲清楚 word2vec 这类模型背后，梯度下降到底是怎么把向量一步步"调"出来的；如果你在这节课里对"点积/相似度"那块还有点虚，也可以先跳去把线性代数的直觉补一遍，再回来接着走大纲顺序。

package/skill/references/lessons/cs224n/02-from-rnn-to-transformer.md

@@ -0,0 +1,91 @@
+# 深度学习与自然语言处理（NLP with Deep Learning） · 第 2 课：从 RNN 到 Transformer——为什么"注意力机制"重新定义了 NLP
+
+> source: `https://web.stanford.edu/class/cs224n/`（官方课程主页，含完整 19 讲大纲，"Language Models and RNNs""Transformers" 正是相邻两讲） ｜ `https://www.youtube.com/playlist?list=PLoROMvodv4rOaMFbaqxPDoLWjDaRAdP9D`（CS224N 官方讲课录像播放列表） ｜ 类型：讲授(概念) ｜ 前置：`cs224n/01-words-as-vectors`
+> 教法遵循 `references/pedagogy.md`：像课本一样把概念讲透、给足，不盘问、不当门槛。
+
+## 一句话本质（开场钩子）
+
+RNN 读句子的方式，是一步一步往前挪、把读过的一切硬塞进一个越走越挤的"记忆向量"里；Transformer 靠注意力机制，让句子里任何一个词都能在"一步之内"直接看到任何另一个词。这不是给旧架构打了个补丁，是把"语言必须按顺序被处理"这个默认假设整个换掉了——而且换掉之后，这套东西天生适合塞进 GPU 并行、适合堆到几千亿参数。今天你和 ChatGPT 聊天时它感觉"记得住"整段上下文，根子就在这一课。
+
+## 为什么要在乎（钩子展开）
+
+上一课我们讲了词向量——怎么把一个词变成一串数字、让"意思相近的词在空间里离得近"。但一句话不是一堆孤立的词，是有顺序、有指代关系的：**"The trophy doesn't fit in the suitcase because it is too big"**——这句里的"it"指的是奖杯（trophy）还是行李箱（suitcase）？靠常识一秒能判断出是奖杯，因为"太大装不下"说的是奖杯的属性。但对一个逐词处理句子的模型来说，这种"回头去够很远一个词"的能力，恰恰是最难的。2013 到 2017 年间，NLP 的主力模型是 RNN（循环神经网络），它在这类长距离关联上有个天生的死穴。2017 年，一篇论文提出了 Transformer，靠一个叫"注意力"（Attention）的机制彻底绕开了这个死穴，直接把机器翻译、后来几乎所有 NLP 任务的效果往上顶了一大截——今天所有你听说过的大模型（GPT、Claude、BERT……）骨架都是它。这节课就讲清楚：RNN 卡在哪、注意力机制怎么解开这个卡点、以及 Transformer 这个架构到底是怎么搭起来的。
+
+## 核心概念（逐个讲透，内容给足）
+
+### 1. RNN：让神经网络"一个词一个词"地读句子
+
+**是什么**：RNN（Recurrent Neural Network，循环神经网络）处理序列的方式，是维护一个不断更新的"隐藏状态"（hidden state）向量。每读进一个新词，就用"上一步的隐藏状态"加上"这一步的新词"，算出一个新的隐藏状态——直觉上像人一边读句子一边在脑子里维护一份"目前为止我理解到哪儿了"的摘要，每读一个新词就更新一次这份摘要。
+
+**为什么重要**：这是 2013–2017 年那几年 NLP 的默认工具，机器翻译、语言建模、命名实体识别几乎都靠它。CS224N 大纲里"Language Models and RNNs"这一讲专门讲这套体系，是理解"为什么后面要发明 Transformer"的必要前提——你得先知道旧办法卡在哪，才懂新办法解决了什么。
+
+**怎么算（直觉，不深挖公式）**：写成一个递推关系就是 `h_t = f(h_{t-1}, x_t)`——当前的隐藏状态 `h_t`，由"上一步的隐藏状态 `h_{t-1}`"和"当前读到的词 `x_t`"共同决定。一步一步往前挪，理论上最后一步的隐藏状态就"卷入"了前面所有词的信息。
+
+**具体例子**：读"我 / 今天 / 去 / 了 / 图书馆"这句话，RNN 读到"我"算出 h1；读到"今天"时结合 h1 算出 h2；……一路读到"图书馆"时，h5 理论上已经包含了前面全部信息，后面无论是要预测下一个词、还是给整句话做情感分类，都是拿这个 h5 去用。
+
+### 2. RNN 的两个死穴：记性差 + 没法并行
+
+**是什么**：RNN 有两条从设计上就摆脱不了的硬伤。第一条是**长距离信息会被冲淡甚至丢失**：每往前挪一步，隐藏状态就被重新覆盖、压缩一次，很像玩"传话游戏"——话传到第 50 个人时，开头说的内容基本已经变形。训练时这个现象对应的是"梯度消失"（vanishing gradient）：靠前的词对最终结果的影响信号，要经过一长串相乘才能传到，传着传着就趋近于 0，模型学不到"隔得很远的两个词有关系"这件事。第二条是**顺序计算、没法并行**：必须先算完 h1 才能算 h2，再算 h3……这是个严格的串行链条，没办法在 GPU 上一次性铺开同时算，训练慢，也就很难喂进海量数据。
+
+**为什么重要**：这两条硬伤正是 CS224N 把"RNN"和"Transformer"排在相邻两讲的原因——不是 Transformer 比 RNN"聪明一点点"，而是这两个死穴从根子上决定了 RNN 不可能长成今天几千亿参数、几万 token 上下文窗口的大模型。理解这两条，才能理解 Transformer 每一个设计选择在解决什么具体问题。
+
+**怎么用/落到哪**：工程上确实有人给 RNN"打补丁"——LSTM、GRU 这类变体，靠"门控"机制让模型自己学会该记什么、该忘什么，一定程度缓解了第一条死穴。但第二条死穴改不掉：LSTM 照样得一步一步算，并行化这条路走不通。
+
+**具体例子**："这家餐厅的装修很一般，服务态度也说不上好，但主厨十几年前在一家米其林三星后厨待过，他做的那道招牌菜，我吃过全世界最好吃的没有之一。"——判断这句话整体是正面还是负面评价，得回头呼应到很靠前的"米其林三星""最好吃"。句子越长，RNN 把这种远距离关系记住的能力就越差。
+
+### 3. Attention（注意力机制）：让每个词直接"回头看"整句话
+
+**是什么**：注意力机制不再要求信息必须经过一个越滚越挤的隐藏状态一步步传递，而是让模型在处理"当前词"的时候，直接对句子里其它所有词打一个"相关度分数"——分数高的词就多参考一点，分数低的就少参考，再按这些分数加权，把有用的信息直接汇总过来。
+
+**为什么重要**：这是整节课的转折点。它把"信息必须按顺序、一步步传递"这个假设直接扔掉了——在注意力机制里，任何两个词之间的距离都是"一步"，不管它们隔了 5 个词还是 500 个词。这就是为什么它能直接治好 RNN 的长距离遗忘症。
+
+**怎么算（直觉，点到为止）**：每个词会生成三样东西——Query（我在找什么）、Key（我是什么，方便被别人找到）、Value（我实际携带的内容）。当前词的 Query 去和句子里每个词的 Key 做比对，算出一个相关度分数；分数高的词，它的 Value 就被更多地"拿过来"用。写成一个直觉公式：`Attention(Q,K,V) = softmax(QK^T/√d) · V`——不需要记它怎么推导出来，只要抓住它在做的事：**按相关度加权求和**。
+
+**具体例子**：回到开场那句"The trophy doesn't fit in the suitcase because it is too big"。模型在处理"it"这个词时，会对句子里所有词同时打相关度分数，"trophy"会拿到比"suitcase"更高的注意力权重——模型不需要像 RNN 那样按顺序一路记着"trophy"这个词，而是直接、并行地在整句话范围内把它"找"出来。
+
+### 4. Self-Attention 与 Transformer：把整个架构建在"注意力"上，彻底抛弃循环
+
+**是什么**：Transformer（2017 年提出）是第一个把整个模型完全建立在注意力机制上、不含一点 RNN 循环结构的架构。它的核心叫 Self-Attention：句子里每一个词，都用上面那套 Query-Key-Value 机制，同时和句子里的每一个词（包括自己）算一遍相关度——这一步对所有词是完全并行的，不需要像 RNN 那样等前一步先算完。
+
+**为什么重要**：并行化直接砸开了训练规模的天花板。GPU 天生擅长同时算一大堆矩阵乘法，而 Self-Attention 恰好就是一堆矩阵乘法，可以把整段文本一次性喂进去同时算完。这就是为什么 2017 年之后模型的参数量、训练数据量能指数级往上涨——BERT、GPT 系列，以及后面所有主流大语言模型，骨架都是 Transformer。CS224N 后半段大纲（Pretraining、Post-training、Agents、Reasoning……）几乎全部建立在这一课讲的架构之上。
+
+**怎么用/落到哪**：Transformer 还加了"多头注意力"（Multi-Head Attention）——不是只算一遍相关度，而是并行算好几组（比如 8 组、16 组），每一组可以学着关注句子里不同类型的关系（比如一组偏语法结构、一组偏指代关系），最后把这几组结果拼起来。可以类比成：与其派一个侦探破案，不如同时派好几个侦探，各自带着不同的关注点审视同一句话，最后汇总所有人的线索。
+
+**具体例子**：老式机器翻译用 RNN 编码器 + RNN 解码器，一个词一个词地读、一个词一个词地吐；Transformer 的编码器一次性把整句话的 Self-Attention 全部并行算完，解码器生成每个词时再用注意力去"查"编码器算出来的整句话表示。这也是为什么 Transformer 问世没几年，翻译、摘要、问答这些任务的最好成绩（SOTA）全面换代。
+
+### 5. 位置编码（Positional Encoding）：Attention 天生不知道谁在前谁在后，得手动"缝"进去
+
+**是什么**：Self-Attention 是对句子里所有词"同时、无差别"地算相关度的，这意味着它天生分不清词的顺序——只看 Attention 本身，"狗咬人"和"人咬狗"用的词一模一样，模型没法直接分出区别。Positional Encoding 就是在每个词的向量表示里，额外加进一段"编码了这个词排第几"的信息。
+
+**为什么重要**：没有位置编码，Transformer 会退化成一个"看得到整句话、但不知道语序"的模型——这对语言这种强烈依赖顺序的东西是致命的，"我打你"和"你打我"意思完全相反。位置编码是让 Transformer 既拿到并行计算的效率红利、又不丢掉语序信息的关键补丁。
+
+**怎么用/落到哪**：最早的 Transformer 论文用一套由 sin/cos 函数算出来的固定编码，直接叠加到每个词的向量上；后来的模型也发展出了不同做法（比如相对位置编码、RoPE 等）。不用记具体公式，抓住这个直觉就够：它是给每个词的向量里"缝"进一个"我是第几个词"的标记。
+
+**具体例子**："猫追老鼠"和"老鼠追猫"，两句话用的词完全一样，如果不看位置信息，Attention 算出来的词与词相关度会非常接近；但两句意思相反。位置编码让模型能分辨出"追"这个动作的方向——靠的是知道"猫"排在"追"前面还是后面。
+
+## 带学生读 source
+
+CS224N 官方主页（`https://web.stanford.edu/class/cs224n/`）的完整大纲里，"Language Models and RNNs"和"Transformers"就是紧挨着的两讲——这不是巧合，是课程故意把"旧方法的极限"和"新方法怎么解决它"放在一起讲，跟这节课的逻辑完全一致，值得去主页翻一眼完整的 schedule 感受一下这门课的全貌。想看真人怎么在黑板上一步步推演 Attention 和 Transformer，可以去官方 YouTube 播放列表（`https://www.youtube.com/playlist?list=PLoROMvodv4rOaMFbaqxPDoLWjDaRAdP9D`）找对应讲次——这节课讲的是被课程反复验证过、面向真实课堂教出来的核心框架，不是我们自己编的简化版。
+
+## 金句（引用时标出处）
+
+本课暂无可靠可引用的原话金句——不编造。
+
+## 讲完这节，你应该能答上（可选巩固 · 别逐题盘问、别当门槛）
+
+1. **Q：RNN 处理长句子时为什么会"丢信息"？本质原因是什么？**
+   - 好答案信号：能说出"信息被一步步压缩进同一个越走越挤的隐藏状态，训练时对应梯度消失，导致远距离的两个词之间的关联很难被学到"，而不只是背"RNN 不好用"这种结论。
+2. **Q：注意力机制是怎么解决 RNN 的长距离依赖问题的？**
+   - 好答案信号：能说出"任何两个词之间的距离在注意力机制里都是一步，靠 Query 和 Key 的相关度直接跨距离取信息，不需要像 RNN 那样一步步往前传"。
+3. **Q：为什么 Transformer 需要额外加一个"位置编码"？RNN 需要这东西吗？**
+   - 好答案信号：能指出 Self-Attention 本身是无序的（同时看所有词、天生不带顺序信息），而 RNN 因为按顺序逐词处理，顺序信息是自带的——只有抛掉了循环结构的 Transformer，才需要额外把位置信息"补"回去。
+
+## 常见误解（听到就纠正）
+
+- ❌"Attention 只是给 RNN 打的一个小补丁。" → 最早的 Attention（2014-2015 年前后，如经典的 Bahdanau attention）确实是加在 RNN 上、用来做机器翻译对齐的辅助机制。但 2017 年的 Transformer 论文是把 RNN 整个拿掉、只留 Attention 自己撑起整个架构——这是架构级的替换，不是修修补补。
+- ❌"Transformer 效果好是因为这个架构本身更'聪明'。" → 更准确的说法是：Transformer 能并行训练、能不受长度限制地捕捉远距离关联，所以能被喂进远超以往的数据量、堆到远超以往的参数规模——效果的巨大提升很大程度上来自"规模终于能上去了"，而不只是单点的架构巧思。
+- ❌"位置编码是个可有可无的技术细节，不重要。" → 没有它，Transformer 分不清词序，"猫追老鼠"和"老鼠追猫"在模型眼里会非常接近，这对任何依赖语序的语言任务都是致命缺陷。
+
+## 收尾 & 排下一课
+
+`Write` 进度：`cs224n/02-from-rnn-to-transformer` done；记学生对 Attention 直觉（Query/Key/Value 加权求和）和"为什么 Transformer 能并行、RNN 不能"这两点的掌握程度。下一课默认顺着 CS224N 大纲往下走——从"Transformer 这个架构长什么样"过渡到"这个架构怎么被喂海量数据、预训练成 GPT / BERT 这类大模型"（对应大纲里的 Pretraining: Scaling, Systems, Data）。如果学生工程背景强、对矩阵运算不发怵，可以往深了展开多头注意力的具体计算和 Transformer 里的残差连接/LayerNorm；如果学生更偏产品/业务视角，就把重点放在"规模化之后模型能力质变"这条主线上，公式细节一带而过。