PyTorch on Zewang's Blog

makemore Part 2：从 Bigram 到 MLP

Sun, 05 Jul 2026 00:00:00 +0000

makemore Part 2：从 Bigram 到 MLP

资料源：The spelled-out intro to neural networks and backpropagation: building micrograd（Andrej Karpathy，访问于 2026-07-05）

视频概览

Part 2 是 makemore 系列的第二集。Part 1 用 bigram（只统计相邻两字符的共现频率）来生成名字，单次准确率天花板很低。本集升级到 MLP（多层感知器）：用上下文窗口内的多个字符作为输入，预测下一个字符。

具体路线：

数据集构造：滑动窗口取 block_size 个字符预测下一个
Embedding 查表：每个字符映射为一个低维向量
MLP 前向：embedding → 拼成向量 → 两层线性层 → softmax → 概率分布
损失函数：交叉熵（多分类）
训练循环：SGD 反向传播，更新参数
学习率调度：学习率扫描（LR range test），挑最优 LR
过拟合与评估：train/val/test 三分，监控 loss

最终目标：在名字数据集上把 validation loss 压到 2.17 以下。

一、数据集构造：滑动窗口

类比 Part 1 的 bigram，这里用 block_size = 3（上下文 3 个字符）预测第 4 个。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


block_size = 3 # 上下文长度

def build_dataset(words):
 X, Y = [], []
 for w in words:
 # 用 . 填充开头和结尾，让模型学会"在哪里开始"和"在哪里结束"
 context = [0] * block_size
 for ch in w + '.':
 ix = stoi[ch]
 X.append(context)
 Y.append(ix)
 context = context[1:] + [ix] # 滚动窗口
 X = torch.tensor(X)
 Y = torch.tensor(Y)
 return X, Y

要点：

用 . 作为特殊的"开始/结束"标记，让模型知道什么时候该停止生成
每个样本 X[i] 是长度为 3 的整数序列，Y[i] 是下一个字符的整数索引
32 个 batch size × 3 字符 = 96 维的输入张量

二、Embedding Lookup Table

模型第一步：把每个字符的整数索引映射为低维向量。

1
2


# vocab_size = 27 (26 字母 + .), embedding_dim = 2
C = torch.randn((27, 2))

C 是一个 (27, 2) 的查找表。给定字符索引 i，C[i] 就是它的 2 维向量。

关键技巧：PyTorch 索引支持多维张量。

1
2
3
4
5


# 1D 索引
C[5] # 第 5 个字符的 embedding (2,)

# 2D 索引 — 对 X (32, 3) 直接索引
emb = C[X] # (32, 3, 2)

后者直接得到 (32, 3, 2) 的张量，每个位置是 X[i,j] 字符对应的 embedding。这一步不需要循环，完全向量化。

深入理解 `C[X]`

C[X] 是 PyTorch 的张量索引（fancy indexing）——对 X 里每个整数取对应行，保持 X 的形状不变：

1
2
3


X = torch.tensor([[5, 3, 7], # 样本 0 的 3 个字符
 [2, 8, 1]]) # 样本 1 的 3 个字符
emb = C[X] # (2, 3, 2)

展开来看：

1
2
3
4
5


emb[0][0] = C[X[0][0]] = C[5] # 样本0, 位置0的字符
emb[0][1] = C[X[0][1]] = C[3]
emb[0][2] = C[X[0][2]] = C[7]
emb[1][0] = C[X[1][0]] = C[2]
...

`C[X][i, j]` 的含义

C[X] 得到 (32, 3, 2) 张量后，用普通下标访问任意元素：

表达式	含义	形状
`C[X][13, 2]`	第 13 个样本的第 2 个位置的字符向量	`(2,)`
`C[X][13]`	第 13 个样本的全部 3 个字符	`(3, 2)`
`C[X][:, 2]`	所有样本的第 2 个位置的字符	`(32, 2)`
`C[X][i, j]`	本质等价于 `C[X[i, j]]`	`(2,)`

最后一行尤其重要：C[X][:, 2] 这种"切某列"的操作非常常用，相当于一次性提取所有样本在某一上下文位置的字符向量。

为什么用 embedding？

字符本身没有"语义距离"的概念。‘a’ 和 ‘b’ 的整数 ID 是相邻的，但 ‘a’ 和 ‘z’ 的"距离"也是相邻的——这不对
把字符映射到连续向量空间后，相似的字符（比如元音）可以聚在一起
embedding 是可学习的，训练过程会自然把"用得上的"字符聚类

C 表 vs One-hot：本质等价

两种方式数学上完全等价——这是个隐藏得很巧妙的等价关系：

1
2
3
4
5
6
7
8


# One-hot 方式
x = torch.zeros(27)
x[5] = 1
v = x @ W # W 形状 (27, 2) → 得到 2 维向量

# Embedding 方式
C = W # 同一个矩阵
v = C[5]

x @ W 和 C[5] 结果完全相同。区别只在工程层面：

维度	One-hot × W	C 表（Embedding）
效率	稀疏矩阵乘法 (27×27)	直接索引 O(1)
内存	临时 (27, 27) 向量	复用 (27, 2) 表
可读性	`one_hot[5] @ W`	`C[5]`

Karpathy 用 C 表不是为了引入新概念，而是把"one-hot × 权重矩阵"打包成更优雅的形式。真正不同的设计选择是 embedding 维度（比如 2 维），不是 lookup 这件事本身。

三、MLP 前向传播

把 (32, 3, 2) 的 embedding 拼成一个 (32, 6) 的向量，过两层线性层 + tanh：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


W1 = torch.randn((6, 100)) # hidden = 100
b1 = torch.randn(100)
W2 = torch.randn((100, 27)) # 输出 = vocab_size
b2 = torch.randn(27)

# 拼接
emb = C[X].view(-1, 6) # (32, 6)

# hidden 层
h = torch.tanh(emb @ W1 + b1) # (32, 100)

# 输出 logits
logits = h @ W2 + b2 # (32, 27)

W1 形状的拆解

W1 = torch.randn((6, 100))：

6 = 输入特征数（每个样本展平后的维度 = block_size * n_embd = 3 × 2）
100 = 隐藏层神经元数量（输出维度）

也就是说：输入 6 维向量 → 经过 W1 线性变换 → 变成 100 维向量，再用 tanh 压缩到 [-1, 1]。

整条链：x (6) → Wx + b (100) → tanh (100) → W₂h + b₂ (27) → softmax → 概率

h = tanh(...) 这一步是引入非线性的关键——没有它，多层线性层会坍缩成单层（数学上等价）。

关键操作：`view(-1, 6)`

view 改变张量的视图（shape），不复制数据——只要内存连续、形状兼容。

1
2


emb.shape == (32, 3, 2)
emb.view(-1, 6).shape == (32, 6)

更激进的写法：emb.view(emb.shape[0], -1)，让框架自动推断维度。

📝 背景知识：view vs reshape：view 要求内存连续（contiguous），reshape 在不连续时会自动复制。view 更快但条件严格。

四、损失函数：交叉熵

从 logits 到概率：softmax；然后和真实标签算 negative log likelihood。

1
2
3
4


# 手写版（教学）
counts = logits.exp() # (32, 27)
probs = counts / counts.sum(1, keepdim=True)
loss = -probs[torch.arange(32), Y].log().mean()

但是 exp 容易数值溢出。PyTorch 内置的 F.cross_entropy 内部做了数值稳定处理（减去 max），并把 softmax + NLL 合并：

1

loss = F.cross_entropy(logits, Y) # 一行搞定

永远优先用 F.cross_entropy，不要自己手写 softmax + NLL，除非在教学场景。

`F.cross_entropy` 的两个核心好处

Karpathy 在视频里明确讲了（其实是三个，但核心两条）：

1. 效率（forward + backward 都快）

手写 softmax + NLL 每一步都创建中间张量（exp、/、log、mean…），内存读写多。F.cross_entropy 在底层把这些运算融合（fused kernels）——一次算完，少几次内存往返。forward 更快，backward 也更快（不用分别对 exp、log、div 求导再 chain 起来）。

2. 数值稳定性

手写版的隐患：

1

logits = [-2, 3, -3, 0, 100] → exp(100) = inf → NaN

F.cross_entropy 内部有个关键技巧：先减去 logits 的最大值，再做 softmax：

1

counts = exp(logits - max(logits)) # max=100 → exp(0) = 1

数学上等价（归一化消掉 max），但数值上稳定。

五、训练循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


for i in range(1000):
 # forward
 emb = C[Xtr]
 h = torch.tanh(emb.view(-1, 6) @ W1 + b1)
 logits = h @ W2 + b2
 loss = F.cross_entropy(logits, Ytr)

 # backward
 for p in parameters:
 p.grad = None
 loss.backward()

 # update
 lr = 0.1
 for p in parameters:
 p.data += -lr * p.grad

关于 `p.grad = None`

PyTorch 推荐 p.grad = None 而不是 p.grad.zero_()——前者更省内存。

Mini-batch：真实工程的样子

Karpathy 演示时用 full-batch（一次算整个训练集的梯度），但实际中几乎没人这么干。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


batch_size = 32
for epoch in range(1000):
 # 随机抽 32 个样本的下标
 ix = torch.randint(0, Xtr.shape[0], (batch_size,))
 # 用这 32 个样本算 forward / backward
 emb = C[Xtr[ix]]
 h = torch.tanh(emb.view(-1, 6) @ W1 + b1)
 logits = h @ W2 + b2
 loss = F.cross_entropy(logits, Ytr[ix])
 loss.backward()
 # ... update

维度	Full-batch（Karpathy 演示）	Mini-batch（实际工程）
每次梯度用多少样本	全部	32 / 64 / 256
单步速度	慢	快
内存占用	大	小
梯度方向	确定性	有噪声但无偏
收敛曲线	平滑	抖动

Mini-batch 的三个核心好处：

快：单步只算 32 个样本，能并行做很多次更新
正则化：带噪声的梯度能跳出尖锐的局部极小，泛化更好
可扩展：数据上千万级时必须分批

batch size 本身是个超参数——太小梯度太不稳，太大丧失噪声正则化。

六、学习率调度：LR Range Test

固定学习率（比如 0.1）跑一跑，loss 下降得不错，但怎么知道这个 lr 是最优的？

直觉上：

学习率太小，几乎不下降——参数原地踏步
学习率太高，明显波动，甚至完全失效——步子太大跳过最优点
所以：先框定范围，然后逐步扫描，作图找最合适的地方

具体做法：指数扫描。

1
2
3
4
5
6
7


lre = torch.linspace(-3, 0, 1000) # 10^-3 到 10^0 = 0.001 到 1.0
lrs = 10 ** lre

for i in range(1000):
 lr = lrs[i]
 # ... train step
 # 记录 loss

为什么指数而不是线性？

lr 的有效范围通常跨好几个数量级（0.0001 到 1）。线性扫描的话，大部分采样点都集中在中间某个范围，log 空间的尾部被浪费。

1
2
3


# 指数扫：lre 从 -3 到 0，1000 步
lre = torch.linspace(-3, 0, 1000) # -3, -2.997, ..., 0
lrs = 10 ** lre # 0.001, 0.001003, ..., 1.0

这样 0.001 → 1.0 在 log 空间均匀分布，每个数量级都被等量采样。

画 loss vs lr 曲线（x 轴必须 log 尺度）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


loss
 ↑ ╱╲
 │ ╱ ╲ ← 爆炸区：lr 太大，loss 飙升
 │ ╱ ╲
 │ ╱ ★ ╲ ← ★ 最优 lr 附近
 │ ╱ ╲
 │ ╱ ╲
 │╱ ╲ ← 几乎不下降：lr 太小
 └─────────────────→ log10(lr)
 10^-3 10^0

挑谷底附近的 lr（一般选谷底左侧一点，更保守）。

Karpathy 实验里他从 lre = lre[i] 改成 lre = lre[i/10]（步进更慢），发现最优 lr 大约在 0.001 附近，比之前的 0.1 小一个数量级。

关键洞见：loss 不是单调下降的，lr 不应该用固定的，可以随训练变化（学习率衰减）。

七、过拟合与 Train/Val/Test Split

如果只看训练 loss 不断下降，就误以为模型越来越好。真正能反映泛化能力的是 validation loss。

1
2
3
4
5
6


数据集 (18 万)
 ↓ 划分
┌─────────────┬───────────┬────────┐
│ train (80%) │ dev (10%) │ test │
│ 训参数 │ 调超参数 │ 最终评估│
└─────────────┴───────────┴────────┘

三划分是对抗过拟合的诊断工具，不是过拟合本身。

什么时候用哪个 split？

任务	用什么
训练参数（W, b, C）	train
调超参（hidden size, lr, block_size…）	dev
选模型（MLP vs Transformer vs …）	dev
报告最终性能	test（只用一次）

⚠️ 常见错误：在 test 上调超参 → test 沦为第二个 dev，污染了最终评估。

Overfitting 信号

训练 loss 持续下降，但 validation loss 不再下降 → 过拟合。模型在背训练集，没有学到泛化规律。

1
2
3
4
5
6
7


loss
 ↑ train loss ──╲___
 │ ╲___ ← 应该在这里停
 │ ╲___
 ↑ dev loss ─────────╲___
 │ ↑ ╲___
 │ 过拟合开始 

Karpathy 在视频里做了一个极端实验：只取一个 batch 训练，让 loss 几乎为 0。模型完全记住了那几个样本，但 val loss 很差。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 常见比例 80/10/10
import random
random.seed(42)
random.shuffle(words)
n1 = int(0.8 * len(words))
n2 = int(0.9 * len(words))

Xtr, Ytr = build_dataset(words[:n1])
Xdev, Ydev = build_dataset(words[n1:n2])
Xte, Yte = build_dataset(words[n2:])

八、模型可视化

训练完后，把 C（embedding 表）画出来看：

1
2
3
4


plt.figure(figsize=(4, 4))
plt.scatter(C[:, 0].data, C[:, 1].data, s=200)
for i in range(C.shape[0]):
 plt.text(C[i, 0].item(), C[i, 1].item(), itoi[i])

观察发现：

元音（a, e, i, o, u）聚成一簇
辅音分布在外圈
字符的"语义相似性"在 2 维空间里被自然学到了

九、调优实验记录

Karpathy 在视频末尾展示了一轮完整的调优流程——这不是事先设计好的实验，而是边调边看、边看边改的迭代过程。把过程如实记录下来很值得学习。

Stage 1：识别瓶颈

lr 从 0.1 降到合适值后，train/dev loss 稳定在 2.23 / 2.24，再降不下去。

1
2
3


# 上面 LR Range Test 发现 lr ≈ 0.001 是最优
# 但 Karpathy 实际用了稍大一点的 lr（兼顾收敛速度）
# 最终 lr 调度: 前半 0.1, 后半 0.01

降不动的常见原因：

模型容量不够 → 加宽/加深
embedding 维度太小（=2） ← Karpathy 的判断

Stage 2：可视化 embedding 验证假设

1
2
3
4


plt.figure(figsize=(4, 4))
plt.scatter(C[:, 0].data, C[:, 1].data, s=200)
for i in range(C.shape[0]):
 plt.text(C[i, 0].item(), C[i, 1].item(), itoi[i])

观察到的结构：

元音 a/e/i/o/u 自动聚成一簇 → 网络把它们当作"可互换"的相似字符
q 远离主簇 → 因为训练集中 q 极少，模型学不到它的协同模式
. 也远离主簇 → 特殊 token，行为独特
辅音散开成一片 → 模型认为它们之间也有差异

这正是反向传播自动涌现出来的"语义结构"——没用任何监督信息，纯粹从下一字符预测的损失里浮现。

Stage 3：扩大 embedding 维度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 改前
n_embd = 2
n_hidden = 300
block_size = 3
# 输入维度 = block_size * n_embd = 6

# 改后
n_embd = 10
n_hidden = 200
block_size = 3
# 输入维度 = 30 ← hardcoded 6 要同步改

⚠️ 坑：上面把 6 当 hardcoded magic number 用，扩 embedding 后必须同步改。生产代码应该用 block_size * n_embd 自动算。

参数量从 ~3000 涨到 ~11K，train 50K steps：

train loss ≈ 2.30
dev loss ≈ 2.38（涨了一点——但更多 step 应该能下来）

Stage 4：阶梯式学习率衰减

继续做了一步关键动作：lr × 0.1：

1
2
3


# 总共 200K steps
# 前 100K steps: lr = 0.1
# 后 100K steps: lr = 0.01

结果：

train loss ≈ 2.17
dev loss ≈ 2.20
训练和 dev 开始"慢慢分离" → 刚刚开始过拟合

这个阶梯式衰减虽然粗暴，但抓住了本质：训练前期大步走、后期小步精修。

Stage 5：从模型采样

训练完怎么生成新名字？用 sampling：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


g = torch.Generator().manual_seed(2147483647 + 10)

for _ in range(20):
 out = []
 context = [0] * block_size # 全 . 开始
 while True:
 emb = C[torch.tensor([context])] # (1, block_size, n_embd)
 h = torch.tanh(emb.view(1, -1) @ W1 + b1)
 logits = h @ W2 + b2
 probs = F.softmax(logits, dim=1) # 内置防溢出
 ix = torch.multinomial(probs, num_samples=1, generator=g).item()
 context = context[1:] + [ix]
 out.append(ix)
 if ix == 0:
 break
 print(''.join(itos[i] for i in out))

生成结果示例：ham, joes 等，已经"听起来像名字"了。

Karpathy 在这里特别提了一句：采样和评估是两件事。loss 是对数似然的均值，反映模型对所有可能下一个字符的预测质量；而 sampling 是从这个分布里"抽一个"出来看效果。

十、与 Part 1 的对比

维度	Part 1 (Bigram)	Part 2 (MLP)
上下文长度	1	3（可调）
参数量	27² ≈ 729	~3000+
概率分布来源	频率统计	神经网络学习
关键技巧	拉普拉斯平滑	embedding + tanh
Val loss	~2.45	< 2.17

MLP 的核心优势：参数共享 + 非线性。同一个字符在不同上下文里出现，embedding 是同一个，但 MLP 会根据上下文产生不同的预测。

思考与延伸

每一个词，对应一个多维度的向量。

随机 → 反向传播 → 语义聚集。

这是 Embedding 最精炼的一句话概括——网络里"没有预设任何语义"，所有语义结构都是从损失函数的梯度里涌现出来的。元音聚类、q 远离主簇，这些都不是人告诉模型的。

多层神经网络。

例子： The cat is walking in the bedroom A dog was running in a room → the cat is running in a __ → 语义，room？

之前的"概率的统计"可能没办法做到。

这是 MLP 相比 bigram 最根本的飞跃。bigram 只能看 (a, room) 出现频率高，完全无法跨过 (bedroom, room) 的"语义等价"。而 MLP 因为 embedding 把 bedroom 和 room 放在相近的位置，配合非线性层，就能推断出"in a room" 的 room 比 “the bedroom” 更通用。

C 表是干什么的：look-up table。字符索引 → 查 C 表 → 得到这个字符的向量表示。

C 表的本质就是"用整数索引查向量"——和查字典是一个意思。它和 one-hot × W 在数学上完全等价，只是写法更直接。

W1 = torch.randn((6, 100)) → 6 是输入特征数，100 是隐藏层神经元数。输入 6 维 → 经过 W1 → 变成 100 维 → 再 tanh 压缩到 [-1, 1]。

W1 形状的两个数字决定了 MLP 的"宽度变换"：左边是输入维度，右边是输出维度。整条链 6 → 100 → 27 就是把"上下文"先扩到高维提炼特征，再压回词表大小做分类。

总结

Part 2 把 bigram 升级到了 MLP，迈出了"深度学习"的关键一步。几个核心要点：

滑动窗口 + padding：构造训练数据的基础范式
Embedding lookup：把离散符号映射到连续空间
MLP = view + linear + tanh + linear：看似简单的堆叠已经能做语言模型
交叉熵：永远用 F.cross_entropy，别手写
LR range test：指数扫描是找最优学习率的实用技巧
Train/Val/Test：过拟合是默认会发生的事，必须有独立评估

下一步（Part 3）会进入更深的网络：更深、更宽、更复杂的架构——但基本套路已经完全建立起来了。

用 makemore 理解语言模型：Bigram 字符级生成

Sat, 04 Jul 2026 00:00:00 +0000

用 makemore 理解语言模型：Bigram 字符级生成

视频：The spelled-out intro to language modeling: building makemore by Andrej Karpathy 代码：karpathy/makemore

1. 什么是 makemore

makemore 是一个字符级语言模型：给它一组名字（32,000 个真实人名），它能学会生成"听起来像名字"的全新字符串。

这不是检索——它生成的名字是训练集中没有的全新组合，比如 Dontal、Irot、Zendy。

整个 makemore 系列从最简单的 Bigram 模型开始，逐步演进到 Transformer，完整覆盖了现代语言模型的技术栈。

2. Bigram 模型：最简语言模型

核心思想

Bigram 的假设极其简单：下一个字符只和当前字符有关。

用概率语言描述：给定当前字符 $c$，生成下一个字符 $c’$ 的概率是 $P(c’ | c)$。

这显然是个过于简化的假设——真实语言中下一个字符往往和前面很多字符都相关。但 Bigram 是个好起点：它足够简单，能让我们先理解语言模型的基本框架，再逐步加入复杂度。

从数据中学习概率

数据集是 32,000 个名字的文本文件，每行一个名字。

我们需要从数据中学习两个东西：

词表：所有出现的字符（英文字母 + 一个特殊结束符 .，共 27 个字符）
转移概率表：每个字符后面出现各个字符的频率

第一步：统计计数

用 Python 字典统计每个字符后面跟着各个字符的次数：

1
2
3
4
5
6
7


# 遍历所有名字，统计 bigram 频率
bigram_counts = {}
for name in names:
 name = '.' + name + '.' # 加上开始和结束标记
 for ch1, ch2 in zip(name, name[1:]):
 key = (ch1, ch2)
 bigram_counts[key] = bigram_counts.get(key, 0) + 1

('.', 'a') 的计数就是在所有名字中，字符 . 后面出现字符 a 的次数——也就是以 a 开头的名字的数量。

第二步：转成概率

用 Softmax 把计数转成概率分布：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import torch

# 创建 27x27 的计数表
N = torch.zeros((27, 27), dtype=torch.int32)

# 填充计数...
for (c1, c2), count in bigram_counts.items():
 N[stoi[c1]][stoi[c2]] = count

# 归一化成概率（按行 softmax）
P = N.float()
P = P / P.sum(dim=1, keepdim=True) # 每行加起来等于 1

现在 P[i, j] 就是当当前字符是 i 时，下一个字符是 j 的概率。

3. 生成名字：采样

有了概率表，生成一个名字很简单：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def generate_name():
 name = []
 ix = 0 # 从开始符 '.' 开始
 while True:
 p = P[ix] # 当前字符对应的概率分布
 ix = torch.multinomial(p, num_samples=1, replacement=True).item()
 if ix == 0: # 0 是结束符 '.'
 break
 name.append(itos[ix])
 return ''.join(name)

torch.multinomial(p, 1) 按概率分布 $P$ 采样一个字符。这就是语言模型的"自回归"生成——每一步的输出作为下一步的输入。

生成结果示例：Dontal、Irot、Zendy、Raxwin、Faydra。

4. 评估模型：交叉熵损失

我们需要一个指标来衡量模型的好坏。

似然（likelihood）

对于一个名字（比如 "alex"），模型认为它有多合理？

$$L = \prod_{t} P(x_t | x_{t-1})$$

即每个 bigram 的概率乘积。概率越高，模型越"信任"这个名字。

负对数似然（Negative Log Likelihood）

连乘不好算，转成对数相加：

$$\text{NLL} = -\sum_{t} \log P(x_t | x_{t-1})$$

这个值叫做负对数似然（NLL），是深度学习中最常见的损失函数形式。

交叉熵（Cross Entropy）

实际训练中，我们用平均负对数似然——除以 token 数量，消除序列长度的影响：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


log_likelihood = 0.0
count = 0
for name in names:
 name = '.' + name + '.'
 for ch1, ch2 in zip(name, name[1:]):
 prob = P[stoi[ch1]][stoi[ch2]]
 log_likelihood += torch.log(prob)
 count += 1

nll = -log_likelihood / count
print(f"Average NLL: {nll:.4f}")

NLL 越低，模型越好。NLL 的物理含义是：平均每个字符需要用多少"nats"（或 bits）来编码。

5. 从统计到神经网络

上面的方法是纯统计的——直接数频次，没有可学习的参数。下面把它改写成神经网络的形式。

一个神经元的视角

神经网络的 Bigram 本质上和一个神经元等效：

1
2
3


# 单个神经元：W 是 27x27 的权重矩阵
logits = x @ W # x 是 one-hot 向量 (27,)，W 是 (27, 27)
probs = F.softmax(logits, dim=0)

这里的 $W$ 相当于概率表的可参数化版本——不是直接存储概率，而是通过学习得到。

神经网络版本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import torch.nn as nn

class BigramLM(nn.Module):
 def __init__(self, vocab_size):
 super().__init__()
 self.W = nn.Parameter(torch.randn(vocab_size, vocab_size) * 0.1)

 def forward(self, x):
 # x: (batch,)，token indices
 logits = self.W[x] # (batch, vocab_size)
 return logits

 def generate(self, x):
 probs = F.softmax(self.W[x], dim=-1)
 return torch.multinomial(probs, num_samples=1)

训练循环：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


model = BigramLM(27)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)

for step in range(5000):
 optimizer.zero_grad()

 # 前向：计算负对数似然
 xb, yb = get_batch()
 logits = model(xb)
 loss = F.cross_entropy(logits, yb)

 # 反向传播
 loss.backward()
 optimizer.step()

这就是语言模型训练的标准范式：前向 → 计算损失 → 反向 → 更新参数。

正向传播、反向传播与梯度下降

训练一个神经网络，就是不断重复以下三步：

第一步：正向传播（Forward Pass）

数据从输入流向输出。对于 Bigram，输入是字符 id 序列，输出是每个位置对下一个字符的预测分数（logits）：

1
2
3


logits = W[xb] # (batch, 27)，每行是当前字符的 27 个分数
probs = F.softmax(logits, dim=-1) # (batch, 27)，归一化成概率
loss = F.cross_entropy(logits, yb) # 标量，loss 越大模型越差

第二步：反向传播（Backpropagation）

从 loss 出发，反向走一遍计算图，利用链式法则算出每个参数对 loss 的贡献——即梯度：

1
2
3


loss.backward() # PyTorch 自动维护计算图
 # 沿着 .grad 属性填充 W 的梯度
print(W.grad) # (27, 27)，形状同 W

梯度 $\frac{\partial \text{loss}}{\partial W}$ 的物理含义：如果把 $W$ 的某个元素稍微增大一点，loss 会变大多少。

梯度为正 → 该权重增加，loss 会变大（这个方向是"错的"）
梯度为负 → 该权重增加，loss 会变小（这个方向是"对的"，应该往这里走）

梯度是怎么算出来的——链式法则

反向传播的本质是从 loss 出发，沿着计算图倒着求偏导，利用链式法则把每一步的梯度乘起来。

以一个最简神经元为例：

1
2
3
4
5
6


x = 1.0
w = torch.tensor([3.0], requires_grad=True)
y_true = 5.0

z = w * x # 前向：z = 3
loss = (z - y_true) ** 2 # loss = (3-5)² = 4

反向传播（手算）：

1
2
3
4


loss 对 w 的梯度 = ∂loss/∂ŷ × ∂ŷ/∂z × ∂z/∂w
 = 2(ŷ - 5) × 1 × x
 = 2(3 - 5) × 1 × 1
 = -4

PyTorch 的 backward() 就是自动做了这件事——它维护了计算图（computation graph），知道每一步是怎么算的，链式法则一路传回去，w.grad 里就是 -4。

对应到 Bigram 的 W，计算图一样，只是更宽（27x27 的矩阵乘法），逻辑完全相同：

1
2
3
4
5
6
7
8
9


loss
 ↑
cross_entropy(logits, yb)
 ↑
softmax(logits)
 ↑
logits = W[xenc] ← W 是 (27, 27)，xenc 是 (batch, 27)
 ↑
W (requires_grad=True)

loss.backward() 触发后，梯度沿这条链反向流回 W，填充 W.grad。

第三步：梯度下降（Gradient Descent）

用梯度来更新参数，往 loss 下降的方向走：

1

W = W - learning_rate * W.grad

梯度指向 loss 增加最快的方向，所以减梯度是往下降方向走
学习率（lr）控制每一步迈多大：太大容易震荡，太小收敛慢

1
2
3
4
5
6
7
8
9


optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)

for step in range(5000):
 optimizer.zero_grad() # 清零上一步累积的梯度
 xb, yb = get_batch()
 logits = model(xb)
 loss = F.cross_entropy(logits, yb)
 loss.backward() # 反向传播
 optimizer.step() # 更新参数

学习率（learning rate）

1
2


W = W - learning_rate * W.grad # lr = 0.1 时，-0.1 * (-4) = +0.4
 # W 新值 = 3 + 0.4 = 3.4，loss 下降

-0.1 的符号是固定的（必须是负的，代表往梯度反方向走），但具体大小是人为设定的超参数。

学习率	效果
太大（e.g. 1.0）	容易跳过最优点，在最低点附近震荡，甚至发散
太小（e.g. 1e-6）	能收敛，但极慢
合适（e.g. 1e-3）	较快收敛到最优附近

实际训练中一般用 AdamW 优化器（自适应调整每个参数的有效学习率），不需要手动调 lr：

1
2


optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=1000) # 学习率先升后降

7. 统计方法 vs 神经网络：对比

维度	统计方法（Counting）	神经网络方法（Gradient）
参数来源	直接从数据中数频次	随机初始化，通过梯度下降学习
概率表示	$P(c’\|c) = \frac{N(c,c’)}{N(c)}$	$P = \text{softmax}(W[x])$，W 是可学习的
表达能力	受限于统计样本量，小样本有稀疏问题	可以泛化，没见过的 bigram 也能预测
更新方式	一次性计算，用新数据要重新统计	随时梯度更新，可以增量学习
参数量	固定 $27 \times 27 = 729$	也是 $27 \times 27 = 729$（Bigram 恰好同规模）
核心思想	最大化似然（Maximum Likelihood）	同样是最小化 NLL，但用梯度近似搜索

核心相同点：两者都在做同一件事——最小化负对数似然（NLL）。统计方法直接算解析解，神经网络用梯度迭代逼近。神经网络的 W 收敛后，和统计方法算出的概率表在数值上应该非常接近。

也正因为两者本质相同，当神经网络学习率过大时，最终 loss 也会停在一个和统计方法相近的位置（约 2.4~2.5），因为它们的表达能力上限是一样的。

关键差异：神经网络可以通过更深层的结构扩展上下文——从只看前 1 个字符，变成看前 N 个字符。这是二元统计方法无法做到的。

换个角度理解：二元方法的 W 是直接从数据中数出来的，神经网络的 W 是随机初始化后通过梯度优化"搜索"出来的。梯度下降的过程，本质上是把一个随机 W 不断调整，让它逐渐逼近 count 方法直接算出的概率分布。神经网络的代价更大（要迭代），但它的架构可以扩展到更长的上下文——这是统计方法永远做不到的。

8. 正则化

如果模型在训练集上的 loss 太低（接近 0），说明它开始"背诵"数据，泛化能力会变差。

正则化通过在损失函数中加入对模型参数的惩罚，防止模型过度拟合：

1
2


# L2 正则化：惩罚大的权重
reg_loss = loss + reg_lambda * (W ** 2).mean()

reg_lambda 是正则化强度（通常 1e-4 到 1e-2）。这让权重不要太大，使模型输出更"平滑"。

正则化的物理图像：两股力量同时拉 W

正则化项 λ * (W²).mean() 的效果是把 W 向 0 拉——这和给统计计数加伪计数（pseudo-count）本质相同。

1

总损失 = 数据损失（让 W 匹配真实统计） + 正则化损失（把 W 拉向 0）

当 λ 很大时，正则化项主导，W 被迫趋近 0，softmax 输出趋近均匀分布（每个字符 1/27）
当 λ 很小时，数据项主导，W 可以自由学习真实分布

Andrej 的原话：“这就像一个弹簧力，把 W 拉向 0，同时数据损失在拉 W 学真实分布。”

这和统计方法里"给计数表加一个常数"的效果相同——都是让分布更平滑，避免对少量样本过度置信。

为什么 W 大了不好

softmax 的公式：

$$P_i = \frac{e^{W_i}}{\sum_j e^{W_j}}$$

W 很大 → $e^{W_i}$ 巨大 → 某个概率接近 1 → 极度自信
W = 0 → 所有 $e^0 = 1$ → 概率完全均匀 → 完全不自信

根本问题：语料中有些 bigram 只出现 1-2 次，统计概率极端，但这只是采样噪声，不代表真实分布。正则化惩罚大 W，迫使分布平滑——等价于给计数加伪计数。

注：在 Bigram 这个简单模型里，正则化效果不明显。它的威力在更大更深的模型（MLP、Attention）里才真正显现。

9. 采样：从模型生成名字

训练好 W 之后，从模型生成名字的过程和统计方法完全一致，只是概率来源从计数表变成了神经网络的 softmax 输出：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


def generate(model, itos, stoi, max_len=20):
 """从神经网络模型生成一个名字"""
 model.eval() # 评估模式，关闭 dropout 等
 name = []
 ix = stoi['.'] # 从开始符 '.' 开始

 with torch.no_grad(): # 生成时不需梯度
 while len(name) < max_len:
 xenc = F.one_hot(torch.tensor([ix]), num_classes=27).float()
 logits = xenc @ model.W # (1, 27)
 probs = F.softmax(logits, dim=-1) # (1, 27)
 ix = torch.multinomial(probs[0], 1).item() # 采样下一个字符
 if ix == 0: # 遇到结束符，停止
 break
 name.append(itos[ix])

 return ''.join(name)

# 生成 5 个名字
for _ in range(5):
 print(generate(model, itos, stoi))

自回归生成的循环：

1
2
3
4
5
6
7
8
9


开始符 '.' (ix=0)
 ↓
one_hot([ix]) → (1, 27)
 ↓
@ W → logits → softmax → probs
 ↓
multinomial(probs) → 下一个字符 ix
 ↓
回到上一步，直到采样到 '.'（结束符）

两种方法殊途同归

Andrej 在视频最后演示了一件很有意思的事：神经网络训练收敛后，W 里的值和统计方法直接 count 出来的"对数计数"（log counts）完全相同。

这意味着：

统计方法：一步直接算出概率表
神经网络：随机初始化 W，通过梯度下降迭代逼近同一个概率表

两者生成的样本完全一样，因为它们本质上是同一个模型。神经网络的"代价"是绕了远路（迭代），但它的架构可以扩展——这是统计方法做不到的。

10. 几个关键概念的直观理解

概念	直观理解
Bigram	“今天吃了__"，填什么字只和"吃了"有关
One-hot + W 相乘	从权重表里"查"出当前字符对应的行
Softmax	把原始分数变成概率分布（所有概率加起来 = 1）
交叉熵损失	负对数似然的平均值，越小越好
正则化	惩罚大的权重，防止过拟合；等价于给计数加伪计数
torch.multinomial	按概率分布采样，概率高的字符更容易被选中
自回归生成	每一步的输出作为下一步的输入，循环直到采样到结束符

11. 总结

Bigram 是理解语言模型的最佳起点，因为它足够简单，能让我们看清楚整个框架：

从数据中统计字符转移概率
用概率分布生成新序列
用交叉熵衡量模型质量
把统计表参数化成神经网络，通过梯度下降学习

下一步就是把这个单字符模型扩展成更长的上下文——让模型不仅看前 1 个字符，而是看前 N 个字符。这就是 Attention 和 Transformer 要解决的问题。

PyTorch on Zewang's Blog

makemore Part 2：从 Bigram 到 MLP

makemore Part 2：从 Bigram 到 MLP

视频概览

一、数据集构造：滑动窗口

二、Embedding Lookup Table

深入理解 C[X]

C[X][i, j] 的含义

为什么用 embedding？

C 表 vs One-hot：本质等价

三、MLP 前向传播

W1 形状的拆解

关键操作：view(-1, 6)

四、损失函数：交叉熵

F.cross_entropy 的两个核心好处

五、训练循环

关于 p.grad = None

Mini-batch：真实工程的样子

六、学习率调度：LR Range Test

为什么指数而不是线性？

七、过拟合与 Train/Val/Test Split

什么时候用哪个 split？

Overfitting 信号

八、模型可视化

九、调优实验记录

Stage 1：识别瓶颈

Stage 2：可视化 embedding 验证假设

Stage 3：扩大 embedding 维度

Stage 4：阶梯式学习率衰减

Stage 5：从模型采样

十、与 Part 1 的对比

思考与延伸

总结

用 makemore 理解语言模型：Bigram 字符级生成

用 makemore 理解语言模型：Bigram 字符级生成

1. 什么是 makemore

2. Bigram 模型：最简语言模型

核心思想

从数据中学习概率

第一步：统计计数

第二步：转成概率

3. 生成名字：采样

4. 评估模型：交叉熵损失

似然（likelihood）

负对数似然（Negative Log Likelihood）

交叉熵（Cross Entropy）

5. 从统计到神经网络

一个神经元的视角

神经网络版本

正向传播、反向传播与梯度下降

7. 统计方法 vs 神经网络：对比

8. 正则化

正则化的物理图像：两股力量同时拉 W

为什么 W 大了不好

9. 采样：从模型生成名字

两种方法殊途同归

10. 几个关键概念的直观理解

11. 总结

深入理解 `C[X]`

`C[X][i, j]` 的含义

关键操作：`view(-1, 6)`

`F.cross_entropy` 的两个核心好处

关于 `p.grad = None`