L07c-2 课堂代码:LSTM 把一张手写数字读成 28 步序列
逐段读 L07 课堂演示代码:一张 28×28 的 MNIST 图怎么变成 28 步序列,nn.LSTM 每一步的张量是什么形状,为什么只取最后一步接全连接层,训练和评估各做了什么,最后按 PyTorch 的写法把 187 万多个参数一项项数出来。
一句话版
这一页读 L07 课堂演示的那份 PyTorch 代码。它把一张手写数字图片一行一行喂给 4 层 LSTM,读完 28 行后只看最后一步的输出,判断这是 0 到 9 中的哪个数字。
上一页 L07c 讲了 LSTM 单元里面怎么算。这一页看它在代码里长什么样:数据怎么摆、形状怎么变、参数有多少。页面里所有形状和参数量都是按代码推算的,没有运行过这份代码,也不写任何训练结果。
先认识这几个词
读之前最好记得 L07c 的四个门控量 f、i、g、o,以及 L07a 的五种输入输出结构。
| 词 | 全称 / 读法 | 一句人话 |
|---|---|---|
| MNIST | 读 em-nist | 一个手写数字图片数据集,每张图 28×28 像素 |
| 张量形状 | tensor shape | 一个多维数组每一维有多长,写成 (64, 28, 28) 这样 |
| batch | 批 | 一次一起送进网络的一组样本,这份代码一批 64 张 |
| nn.LSTM | PyTorch 的 LSTM 层 | 把 L07c 的单元按步数和层数串起来的现成模块 |
| batch_first | 批在前 | 打开后,输入的第 0 维是样本序号,第 1 维才是步数 |
| many-to-one | 多对一 | 读进一串输入,最后只给一个输出 |
| epoch | 轮 | 把整个训练集完整过一遍 |
一个类比:一行一行扫描的读卡员
想象一个读卡员看一张数字卡片。他不能一眼看完整张,只能用一条窄窄的缝从上往下扫,每次看到一行 28 个格子。
他边扫边在笔记本上记要点,扫完第 28 行,再看一眼笔记,说出「这是 7」。中途看到的每一行都只影响笔记,不直接报答案。
类比在哪里失效:
- 真实的 LSTM 叠了 4 层,相当于四个读卡员排成一列,后一个只看前一个的笔记。
- 读卡员靠常识认字,LSTM 的「怎么记笔记」全靠训练学出来,代码里只训练了 100 批。
从零讲起
1. 图片怎么变成序列
它解决什么问题
LSTM 吃的是一串按顺序排好的输入,每一步一个向量。可 MNIST 给的是一张二维图片,没有天然的先后顺序。要用 LSTM 做图片分类,先得规定「按什么顺序把图片拆成一串」。
从哪来(补充)
MNIST 由美国国家标准与技术研究院(NIST)原有的手写数据重新混编而成,引用时署名 LeCun、Cortez、Burges。训练集 60000 张,测试集 10000 张,1994 年夏天之前就已建成。它是入门图像分类最常用的数据集。
直觉
一张图有 28 行。把每一行当成一个时间步,这一行的 28 个像素值就是这一步的输入向量。从第 1 行读到第 28 行,正好是一条长 28 的序列。
读完整张图只要一个答案(是哪个数字),所以这是 L07a 讲的多对一结构。
一步一步看
目标:把一张 28×28 的手写 7 按行拆成 28 步,看图片张量怎样整理成 LSTM 要的批 × 步 × 特征。
拿一张写着 7 的图来看,它的形状是 28 行 × 28 列。
-
先认出图片里的行:整张图有 784 个像素,排成 28 行,每行 28 个。
-
第 1 行的 28 个数作为第 1 步的输入 x_1,第 2 行作为 x_2,一直到第 28 行作为 x_28。
-
所以步数 sequence_length = 28,每步的向量长度 input_size = 28。
-
读进来的图片张量多一个「通道」维:ToTensor 把灰度图变成 (1, 28, 28),一批 64 张就是 (64, 1, 28, 28)。
-
灰度图只有 1 个通道,用 squeeze(1) 把这个长度为 1 的维去掉,变成 (64, 28, 28),正好是 LSTM 要的「批 × 步 × 特征」。
怎么算
步数 × 每步长度 = 像素总数:28 × 28 = 784。
意思是:按行切的时候,行数决定序列有多长,列数决定每一步的向量有多长,两者相乘必须等于一张图的像素总数,一个像素都不多也不少。
代码里对应的两行超参数和一行变形:
input_size = 28
sequence_length = 28
data = data.to(device=device).squeeze(1)
意思是:前两行把「每步 28 个数、一共 28 步」写死;第三行在送进模型前去掉通道维。
常见误解
以为 LSTM 能直接吃二维图片
LSTM 每一步只吃一个向量。图片要先规定一个读的顺序,这份代码选的是按行从上往下读。按列读也可以,形状一样是 28 步、每步 28 个数。
以为 squeeze(1) 会改变图片内容
squeeze(1) 只去掉第 1 维那个长度为 1 的通道维,像素值和排列都不变,元素个数还是 64 × 784。
试一下
如果改成每一步读两行,sequence_length 和 input_size 各是多少?
28 行两行一步,共 14 步;每步是两行拼起来的 56 个数。14 × 56 = 784,像素总数不变。
2. nn.LSTM 的输入输出形状
它解决什么问题
L07c 里一个 LSTM 单元一次只处理一步、一个样本。实际训练时要一次算 64 个样本、28 步、4 层。nn.LSTM 把这些全部打包,读代码时最容易卡住的就是每个张量各有几维、每维是什么意思。
直觉
把一批数据想成一摞卡片:64 张卡片,每张有 28 行,每行 28 个数。batch_first=True 规定「卡片序号」放在最前面。
LSTM 读完后,每张卡片的每一行都换成一个 256 维的笔记向量,于是得到 64 × 28 个笔记。初始笔记 h0、c0 要给每一层、每张卡片各准备一份。
一步一步看
目标:跟着一批 64 张图走进 4 层 LSTM,看 x、h0、c0 和 out 各是什么形状,out 只装最后一层。
一批 64 张图,模型是 4 层 LSTM,每层隐状态 256 维。
-
送进 LSTM 的 x 是 (64, 28, 28):64 张图、28 步、每步 28 个数。
-
初始状态 h0、c0 各是 (4, 64, 256):4 层,每层给 64 个样本各准备一个 256 维的零向量。
-
第 1 层每步吃 28 个数,吐出 256 个数;第 2 到 4 层每步吃下一层的 256 个数,也吐出 256 个数。
-
输出 out 是 (64, 28, 256):只装第 4 层(最后一层)在 28 步上各自的隐状态 h_t。
-
另一个返回值是最后一步各层的 (h, c),代码用下划线丢掉了。
怎么算
h0 的形状 = (num_layers, batch, hidden_size) = (4, 64, 256)
意思是:每一层都有自己的一份隐状态,每个样本也各有一份,所以层数和批大小都要出现在形状里。batch_first 只管输入和输出 out,不管 h0、c0,所以它们的批维仍在第 1 维。
out 的形状 = (batch, sequence_length, hidden_size) = (64, 28, 256)
意思是:每个样本、每一步都给一个 hidden_size 长的向量;层数不出现在 out 里,因为它只装最后一层。
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
意思是:第一行建 4 层、每层 256 维的 LSTM;第二行按 x.size(0)(这一批有几个样本)建全零初始状态。
常见误解
以为 batch_first=True 时 h0 的形状也要把 batch 放前面
PyTorch 文档写明 batch_first 不作用于 hidden 和 cell state。h0、c0 始终是 (层数, 批, 隐维),代码也是这么建的。
以为 out 里装了 4 层的结果
out 只装最后一层每一步的 h_t。前 3 层的输出只在 LSTM 内部往上传,不出现在 out 里。
试一下
最后一批只有 32 张图时,h0 和 out 各是什么形状?
h0 用 x.size(0) 建,跟着变成 (4, 32, 256);out 是 (32, 28, 256)。所以代码不能把 64 写死在 h0 里。
3. 取最后一步,再接全连接层
它解决什么问题
LSTM 给了 28 步的输出,可分类只要一个答案。要从 (64, 28, 256) 里挑出一部分,交给全连接层(fully connected layer,代码里叫 fc)变成 10 个类别的分数。代码里写了三种挑法,两种被注释掉了。
直觉
LSTM 一步一步往下读,最后一步的隐状态已经「看过」全部 28 行。只拿最后一步,就是拿读卡员读完整张卡片后的笔记。
只拿第一步,相当于读卡员只看了第一行就要回答,几乎没有信息。把 28 步全部拼起来,信息最全,但全连接层的输入要变成 28 倍长。
一步一步看
目标:比较取最后一步、拼接全部步、只取第 1 步三种写法,看形状和 fc 怎么配,为什么用最后一步。
out 是 (64, 28, 256),下面比较代码里的三行。
-
现在生效的写法:out[:, -1, :] 在第 1 维取下标 −1,也就是最后一步,得到 (64, 256),接 Linear(256, 10)。
-
注释掉的 reshape 写法:把 28 步拼成一长条,每个样本 256 × 28 = 7168 个数,fc 必须同时换成 Linear(7168, 10)。代码里那行 fc 也确实有一个注释掉的版本。
-
注释掉的 out[:, 0, :]:只取第 1 步。那时 LSTM 只读过第 1 行,图片顶部多半是空白,几乎看不出是哪个数字。
-
不管哪种写法,fc 输出都是 (64, 10):每张图 10 个分数,分数最大的那个类别就是预测。
怎么算
scores = fc(out[:, -1, :]),形状 (64, 256) → (64, 10)
意思是:全连接层把每个样本的 256 个数线性组合成 10 个数,每个数对应一个数字类别的分数。
预测 = scores.max(1) 返回的下标
意思是:在第 1 维(10 个类别)上找最大值,max 同时返回最大值和它的位置,代码只要位置,也就是类别编号。
#out = out.reshape(out.shape[0], -1)
#out = out[:,0,:]
out = out[:,-1,:]
意思是:三行里只有最后一行生效;要换写法,就把它注释掉、放开另一行。
常见误解
以为 out[:, 0, :] 和 out[:, -1, :] 差不多
LSTM 从第 1 行往下读,第 1 步的输出只看过第 1 行。最后一步的输出才包含整张图的信息。两者差的是读了 1 行还是 28 行。
以为只改 reshape 那一行就能跑
reshape 后每个样本是 7168 个数,原来的 Linear(256, 10) 接不上,会报形状不匹配。要同时把 fc 换成注释里的 Linear(hidden_size * sequence_length, num_classes)。
试一下
如果按行从下往上读,取最后一步还合理吗?
合理。最后一步仍然读完了全部 28 行,只是顺序反过来。不合理的是只取第一步,那时只读了一行。
4. 训练与评估:一个 epoch 里发生了什么
它解决什么问题
模型搭好以后,要用训练集调参数,再在测试集上看准确率。这一节按 demo() 的顺序,看代码训练了多少数据、评估时又做了什么。
直觉
训练像做练习册:每做一组题(一个 batch),对一下答案(算损失),按错的地方改改思路(反向传播、更新参数)。
评估像考试:只做题、只计分,不再改思路,所以不需要记录怎么改(关掉梯度)。
一步一步看
目标:跟着一个 epoch 的 938 个 batch 走,看 count 限制下只有 6400 张图真正参与训练,再看评估怎么做。
训练集 60000 张,一批 64 张,最后一批不满也照样保留,所以一个 epoch 有 938 个 batch。
-
每取一个 batch,count 加 1。count 不超过 100 时,做完整的一步:前向、算损失、清梯度、反向、更新。
-
count 超过 100 以后,continue 直接进入下一轮循环。第 101 到 938 个 batch 照样被读出来,只是什么都不算。
-
所以真正参与训练的只有 100 × 64 = 6400 张图,大约是训练集的十分之一。
-
训练完先评估训练集,再评估测试集。两次都先 model.eval(),在 torch.no_grad() 里只做前向。
-
每批用 scores.max(1) 取预测,和标签比较,累加对的个数,最后打印准确率,再用 model.train() 切回训练模式。
怎么算
损失 = CrossEntropyLoss(scores, targets)
意思是:scores 是 10 个类别的原始分数,不用先过 softmax;CrossEntropyLoss 内部会把它变成概率,再算交叉熵。交叉熵是什么见 L03a-3。
参数更新交给 Adam,学习率 0.005
意思是:optimizer.step() 按梯度把每个参数挪一小步。Adam 是梯度下降的一种改进,会给每个参数自动调步长。
count +=1
if count>100: continue
意思是:前 100 个 batch 往下执行训练;之后每个 batch 一进循环就跳回开头,取下一批。
常见误解
以为 continue 会让训练提前结束
continue 只跳过这一轮剩下的语句,循环本身照常走完 938 轮,DataLoader 照样读数据。想在第 100 批后停下要用 break。
以为 model.eval() 和 torch.no_grad() 是一回事
no_grad 关掉梯度记录,省内存、省时间。eval 切换 Dropout、BatchNorm 这类层的行为。这个模型没有这类层,eval 对它的输出没有影响,写上是好习惯。
试一下
测试集 10000 张、一批 64 张,评估时要跑几个 batch?最后一批几张?
10000 ÷ 64 = 156 余 16,所以 157 个 batch,最后一批 16 张。
5. 数一数参数量
它解决什么问题
L07c 数过「不计偏置」的 LSTM 参数。真写代码时 PyTorch 会加偏置,而且一层加两组。这一节按代码的超参数,把 4 层 LSTM 和最后的全连接层一项项数清楚。
直觉
每层 LSTM 还是 L07c 那四份:f、i、g、o 各有一个「乘输入」的矩阵和一个「乘上一步隐状态」的矩阵。
PyTorch 给这两类矩阵各配一组偏置,每组 4 × 256 个数。第 1 层的输入是 28 维,后 3 层的输入是下一层的 256 维,所以第 1 层参数少一些。
一步一步看
目标:按层数出 4 层 LSTM 和 fc 的权重与偏置,看整个模型怎样合计出约 187 万个参数。
hidden = 256,第 1 层输入 28 维,第 2 到 4 层输入 256 维,fc 是 256 进 10 出。
-
第 1 层:权重 4 × 256 × (28 + 256) = 290816,偏置 8 × 256 = 2048,合计 292864。
-
第 2 层:权重 4 × 256 × (256 + 256) = 524288,偏置 2048,合计 526336。第 3、4 层一样。
-
后三层合计 3 × 526336 = 1579008,LSTM 四层合计 292864 + 1579008 = 1871872。
-
fc:256 × 10 个权重加 10 个偏置,共 2570。
-
全模型 1871872 + 2570 = 1874442,约 187 万个参数。
部分 权重 偏置 合计 LSTM 第 1 层 290816 2048 292864 LSTM 第 2–4 层(每层) 524288 2048 526336 fc 2560 10 2570 全模型 1874442
怎么算
一层 LSTM 参数 = 4 × hidden × (该层输入 + hidden) + 8 × hidden
意思是:4 个门控量各有一个 hidden × 输入的矩阵和一个 hidden × hidden 的矩阵,合起来是 4 × hidden × (输入 + hidden);两组偏置各 4 × hidden 个,合起来 8 × hidden。
fc 参数 = 输入长度 × 类别数 + 类别数
意思是:每个类别对每个输入各有一个权重,再加一个偏置。
常见误解
以为每层只有一组偏置,写成 4 × hidden
PyTorch 的 nn.LSTM 每层有 bias_ih 和 bias_hh 两组,各 4 × hidden,所以是 8 × hidden。很多教材只写一组,按教材算会比代码少 4 × 256 = 1024 个一层。
以为 4 层的参数都一样
只有第 1 层吃 28 维的原始像素,后 3 层吃下一层的 256 维输出。第 1 层的输入矩阵小得多。
试一下
换成 reshape 写法,fc 有多少参数?全模型呢?
fc 是 7168 × 10 + 10 = 71690。全模型 1871872 + 71690 = 1943562,比原来多了 6 万多。
把它们串起来
代码先把每张 28×28 的图按行切成 28 步,每步 28 个像素,squeeze(1) 去掉通道维,一批就是 (64, 28, 28)。
nn.LSTM 打开 batch_first,从全零的 h0、c0 出发,4 层叠着读完 28 步,输出最后一层每一步的隐状态 (64, 28, 256)。代码只取最后一步,因为只有它读完了整张图;再用 Linear(256, 10) 变成 10 个类别的分数。
训练用 CrossEntropyLoss 和 Adam,但 continue 让 938 个 batch 里只有前 100 个真正更新参数。评估时关掉梯度,用 scores.max(1) 取预测。
整个模型约 187 万个参数,绝大部分在后三层 LSTM。参数量能从超参数直接推出来,不用运行代码。下一页 L07d 换一个方向,看两个 RNN 首尾相接怎么做翻译。
课件里的坑
课件 p.28 只有一张 Demo 海报,下面几条都是这份课堂代码 demo_LSTM.py 里能直接看出的问题。
- [循环] 训练循环用
if count>100: continue限制只训练前 100 个 batch,但 continue 不会结束循环:938 个 batch 仍全部从 DataLoader 读出来。要提前停下应该用 break。 - [状态] forward 里每次都用 torch.zeros 新建 h0、c0,每张图都从零状态开始读,状态不跨样本传。对 MNIST 一张图一个独立序列是对的;nn.LSTM 不传初始状态时默认也是全零。
- [耗时] demo() 先在训练集 60000 张上评估一遍,再评估测试集 10000 张。训练只用了 6400 张,训练集评估反而比训练本身多跑很多前向。
- [输出] 每个训练步都 print 一行 loss,100 步就是 100 行,还要每次把 loss 拷回 CPU。
- [成对修改] 想试 reshape 写法,要同时放开 fc 那行注释掉的 Linear(hidden_size * sequence_length, num_classes),只改一处会报形状不匹配。
课后 10 分钟:考点复习
这 10 分钟怎么用:先合上页面,从 (64, 1, 28, 28) 开始把形状一路写到 (64, 10);再说出 h0 为什么是 (4, 64, 256);然后按公式把四层 LSTM 加 fc 的参数数一遍;最后说出 continue 和 break 的区别。
必背
- MNIST 一张图 28×28,按行切成 28 步、每步 28 个像素:sequence_length = 28,input_size = 28,是 many-to-one。
- batch_first=True 时 LSTM 的输入是 (batch, seq, feature) = (64, 28, 28),输出 out 是 (64, 28, 256)。
- h0、c0 的形状是 (num_layers, batch, hidden) = (4, 64, 256),batch_first 不管隐状态。
- out[:, -1, :] 取最后一步的 256 维,再接 Linear(256, 10) 得到 10 个类别分数;scores.max(1) 取分数最大的类别。
- PyTorch 的 LSTM 每层有两组偏置:一层参数 = 4×hidden×(该层输入 + hidden) + 8×hidden。
- 本代码共 1874442 个参数:LSTM 四层 1871872,fc 2570。
- count > 100 时 continue 只跳过计算:只训练前 100 个 batch(6400 张),938 个 batch 仍全部取一遍。
课件例题
本讲课件没有例题。这一页对应的课件 p.28 只有一张 Demo 海报,代码在课堂另发的代码包里,课件上没有代码,也没有和代码相关的题。下面的完整例题和变式题都是按这份代码自编的。
完整例题
自编情境。把代码改成每一步读两行:sequence_length = 14,input_size = 56,其余超参数不变(hidden 256、4 层、batch 64、10 类,取最后一步)。(a) 送进 LSTM 的 x、h0、out 各是什么形状?(b) 全模型多少参数?
- 每步两行,共 28 ÷ 2 = 14 步,每步 2 × 28 = 56 个数。x 是 (64, 14, 56)。这时光 squeeze(1) 不够,要 reshape 成 (64, 14, 56)。
- h0 只和层数、批大小、隐维有关:仍是 (4, 64, 256)。
- out 是 (批, 步数, 隐维) = (64, 14, 256);取最后一步后还是 (64, 256),fc 不用改。
- 第 1 层:4 × 256 × (56 + 256) + 8 × 256 = 4 × 256 × 312 + 2048 = 319488 + 2048 = 321536。
- 第 2–4 层不变:3 × 526336 = 1579008。LSTM 合计 321536 + 1579008 = 1900544。
- fc 不变 2570,全模型 1900544 + 2570 = 1903114。
答案:x (64, 14, 56),h0 (4, 64, 256),out (64, 14, 256);全模型 1903114 个参数。
要点:步数只影响 out 的第 1 维,不影响参数量;参数量只随第 1 层的输入长度变。
答题格式:形状题按「批, 步, 特征」三维写全;参数题逐层写出 4 × hidden × (输入 + hidden) + 8 × hidden,再加 fc。
变式题(先自己做)
(1) 自编情境:其余不变,把 hidden_size 改成 128,全模型多少参数? (2) 自编情境:把读出换成 out[:, 0, :],fc 要不要改?为什么分类效果通常会变差? (3) 自编情境:只训练前 100 个 batch,但想让程序在第 100 个 batch 之后立刻离开训练循环,代码怎么改?
提示
(1) 第 1 层输入 28,后三层输入 128,偏置是 8 × 128;fc 是 128 × 10 + 10。(2) 看取出来的形状,再想第 1 步读过几行。(3) continue 和 break 哪个会结束循环。
判分点与答案(非官方评分标准)
判分点:① 每层两组偏置;② 第 1 层和后三层分开算;③ 说出第 1 步只看过第 1 行;④ 用 break 而非 continue。
- (1) 第 1 层 4 × 128 × (28 + 128) + 8 × 128 = 79872 + 1024 = 80896;后三层每层 4 × 128 × 256 + 1024 = 132096,三层 396288;LSTM 477184;fc 128 × 10 + 10 = 1290;全模型 478474。
- (2) out[:, 0, :] 仍是 (64, 256),fc 不用改。但第 1 步的隐状态只读过图片第 1 行,顶部多半是空白,几乎不含数字的信息,所以效果通常会变差。
- (3) 把
if count>100: continue改成if count>100: break,第 101 个 batch 一取出就退出循环,不再读后面的数据。
闪卡自测
1. 代码里 sequence_length 和 input_size 各是多少?分别对应图片的什么?
都是 28。sequence_length 是行数(步数),input_size 是每行的像素数。
2. 为什么要 squeeze(1)?
ToTensor 后一批是 (64, 1, 28, 28),第 1 维是长度为 1 的通道维;去掉它才是 LSTM 要的 (64, 28, 28)。
3. h0 的形状是什么?batch_first 会改它吗?
(4, 64, 256),即 (层数, 批, 隐维)。batch_first 不作用于隐状态。
4. out 的形状是什么?里面装的是哪一层?
(64, 28, 256),装的是最后一层(第 4 层)每一步的隐状态。
5. 为什么取 out[:, -1, :] 而不是 out[:, 0, :]?
最后一步读完了全部 28 行,第一步只读过第 1 行。
6. 换成 reshape 写法,fc 要改成什么?
Linear(256 × 28, 10),即 Linear(7168, 10)。
7. PyTorch 一层 LSTM 的参数公式?
4 × hidden × (该层输入 + hidden) + 8 × hidden,8 × hidden 是两组偏置。
8. 这份代码全模型多少参数?
1874442:LSTM 1871872,fc 2570。
9. 一个 epoch 真正训练了多少张图?
前 100 个 batch,100 × 64 = 6400 张;938 个 batch 仍全部被读出。
10. 评估时为什么要 torch.no_grad()?
评估不更新参数,不需要记录梯度,关掉能省内存和时间。
下一讲
下一页 L07d 把两个 RNN 首尾相接做翻译(seq2seq),再看 attention 怎么让解码器每一步都回头看整句。这一页的「只取最后一步当整串的总结」在那里会再出现:编码器同样把整句压成最后一个隐状态,attention 正是为了不只靠这一个向量。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。