← COMP5511 全部讲次
T03 · 第 3 周

T03 Tutorial 3:四份 PyTorch notebook,一套训练骨架

张量、autograd、nn.Module、训练循环——先把这四件事跑通,assignment 和 project 才动得了。

一句话版

这周的习题课是四份 PyTorch 代码笔记本,练张量、自动求导、nn.Module、训练循环这四件事,是后面作业和项目的动手基线。nn.Module 是 PyTorch 里所有网络的基类,自己写的模型都继承它,只写前向那一段。

先认识这几个词

词 全称 / 读法 一句人话
PyTorch 一个 Python 深度学习库 用来搭神经网络、自动算梯度
notebook Jupyter notebook,代码笔记本 代码和说明分成一格一格(cell),可以逐格运行
张量 tensor 多维数组,PyTorch 里一切数据都装在它里面
梯度 gradient 参数往哪个方向改、改多少能让误差变小
autograd automatic differentiation,自动求导 你写前向计算,PyTorch 自动替你算梯度
损失 loss 一个数,衡量预测和正确答案差多远
batch 批 一次喂给模型的一小组样本
shape 形状 张量每一维有多长,如 (1, 57) 是 1 行 57 列

题目地图

四份材料有重叠,按依赖关系读比按文件名读省事。只有时间序列那份最后生成一个可提交的预测文件,其余三份跑完即弃。

顺序 材料 学什么 主要失分点
1 张量基础 创建、属性、运算、与 NumPy 互通 以为 .to() 是原地操作
2 手写线性回归 自己写梯度下降的四步 忘了清零或忘了 no_grad()
3 autograd backward() 到底在算什么 对非标量调裸的 backward()
4 nn.Module 与 LeNet 层怎么声明、shape 怎么推 16*5*5 推不出来
5 图像分类完整流程 数据到测试的五步 在最后一层多加一个 softmax
6 字符级 RNN 变长序列、隐状态传递 训练函数有三行被注释掉
7 时间序列预测 滑窗、三个模型、外推 漏 batch_first、漏逆变换

表里的 NumPy 是 Python 最常用的数组库;LeNet 是一个经典的小型卷积网络;RNN(Recurrent Neural Network,循环神经网络)是一步一步读序列的网络。想先试水,从手写线性回归那份开始最省事。它的数据直接写死在代码里,不依赖任何外部文件。

概念卡

1. 五步训练骨架(Training Loop)

人话定义:训练就是反复「猜一次、看错多少、往对的方向改一点」,这副骨架把这件事固定成五步。四份笔记本的训练循环都是它:清梯度、前向、算损失、反向、更新,换模型只换中间那一段。

例子:写成代码就是 optimizer.zero_grad() → output = net(x) → loss = criterion(output, y) → loss.backward() → optimizer.step()。optimizer 是优化器,手里握着全部参数,调 step() 时按梯度改它们。手写版把最后一步拆成 w -= w.grad * lr,再手动 w.grad.zero_()。这里有两处细节必须懂。第一,更新参数本身也是张量运算,直接原地改需要梯度的参数而不包在 torch.no_grad() 里,通常会立即报错。第二,.grad 是累加的,不清零的话第二个 batch 的梯度会叠在第一个上,越滚越大。

常见误解

以为 optimizer.step() 会自己算梯度 → 它只做一件事:按 .grad 里已有的值更新参数。没有新梯度时不应调用 step();若 .grad 留着旧值,仍可能错误更新。梯度不是 backward() 的返回值,是它写进每个参数 .grad 属性的副作用。

回讲义:L04b-2 梯度下降:沿着坡度一步步走到碗底

2. shape 推导(Output Shape)

人话定义:层与层接不上时程序会报错,shape 推导让你提前算出每层输出多大。考卷上常给网络结构问某层输出形状,靠两条公式就能一路推到底。

例子:卷积(convolution)是拿一个小窗口(核)在图上滑动。无填充(padding)、步长(stride)为 1 时,输出边长 = 输入边长 − 核边长 + 1。本例的池化(pooling,把相邻格子合并成一格)让边长除以 2。LeNet 输入 1×32×32。conv1 的 5×5 核把 32 推到 28,池化到 14。conv2 再推到 10,池化到 5。于是拉平(flatten)之后是 16 × 5 × 5 = 400,正好对上 nn.Linear(16*5*5, 120) 的输入维。带填充 p 和步长 s 的通用公式是 ⌊(n + 2p − k)/s⌋ + 1(膨胀系数 dilation=1 时)。意思是输入边长 n 先两边各补 p 格,减去核边长 k,再按步长 s 数能放几次窗口。

常见误解

把 nn.Linear 的 weight 形状记成构造参数的顺序 → Linear(120, 84) 的 weight 是 (84, 120),也就是 (out, in),和写法相反。手写线性回归里 X @ w.t() + b 的那个 .t() 就是在补这个转置。另外,本例每个有参数的层都有 weight 和 bias 两个参数张量。池化层没有可学习参数,不计入。

回讲义:L07a-2 步长与补零:输出到底多大,数一数窗口能停几处

3. 最后一层与损失函数的配对(Loss Matching)

人话定义:损失函数要对网络输出的「格式」有正确预期,配错了不报错但会学不动。所以网络最后一层输出什么,就决定了该配哪个损失函数。

例子:图像分类那份的 forward 末尾是裸的 self.fc3(x),没有 softmax(把一串分数压成和为 1 的概率)。这是对的。nn.CrossEntropyLoss 内部已经包含 LogSoftmax + NLLLoss,再手动加一层等于做了两次,会把梯度压扁。字符级 RNN 那份走另一条路:网络里写了 nn.LogSoftmax,损失就用 NLLLoss。两条路数学上等价。补充:LogSoftmax 后再接交叉熵通常只是冗余。真正要避免的是把 Softmax 概率当成 logits 再输入交叉熵。

常见误解

看到分类网络输出的一串数就当成概率 → 没过 softmax 的原始分数叫 logits,既不在 [0,1] 也不和为 1。比较大小完全有效,当概率读就错了。LogSoftmax 的输出是对数概率,负值正常,越接近 0 表示概率越大:−0.47 对应 p ≈ 0.63。回归任务则配 MSELoss(均方误差)。

回讲义:L06d softmax、损失函数与梯度下降:训练在优化什么

4. 归一化与可用学习率(Normalization)

人话定义:输入数值太大时,学习率稍大一点训练就会爆掉,归一化是缓解这个问题的手段。它把输入缩放到统一的小范围,比如 [0, 1]。

例子:学习率(learning rate)是每次更新参数时迈的步子大小。手写线性回归那份的输入量级是 70–140,没做任何缩放。梯度里带着这个量级,学习率稍大一点 loss 就变 nan(算崩了),所以材料选用 1e-6,还要跑 300 个 epoch(把全部数据过一遍叫一个 epoch)。时间序列那份先用 MinMaxScaler 压到 [0, 1],学习率用 1e-3。两例模型与数据不同,不能把千倍差异全归因于缩放。若报告原单位的 MSE,预测值和真值两边都要逆变换回原单位。归一化后的 MSE 也可在同一缩放下比较模型,但要写明尺度。

常见误解

把 scaler 在训练集和验证集上一起 fit 当成无条件正确 → 这等于让预处理环节看到了验证集的分布,属于信息泄漏。用于评估泛化时,应只在训练集上 fit,再用同一个 scaler 去 transform 验证集。

回讲义:L04b-3 同时更新与学习率:两个参数怎么一起走,步子迈多大

逐题拆解

张量:内存共享与拼接

这一段最值钱的是内存共享。CPU 上的张量和 NumPy 数组用 numpy() 或 from_numpy() 互转之后,共享同一块内存,改一边动另一边。要真副本得 clone()。搬到 GPU 之后才是真拷贝。另外两条高频坑。一是 .to(device) 返回新张量,光写 tensor.to('cuda') 不报错,但张量根本没动。二是 cat 在已有维度上接长(三份 4×4 在 dim=1 上得到 4×12),stack 新开一个维度(同样三份得到 4×3×4)。

一步一步看

目标:对同样三份 (4, 4) 张量分别做 cat 和 stack,看一个把列接长、一个新插一根轴。

cat 和 stack 各自作用在同一组三份张量上。每帧青绿框是这一步算出的形状,虚线行是还没算到的。

  1. 起点:torch.ones(4, 4),再把第 1 列清零,形状仍是 (4, 4)。复制三份放进列表。

    第 1 帧:三行推导表,第一行 torch.ones(4, 4) 复制三份,形状 (4, 4) 乘 3,青绿框标出;cat 和 stack 两行是虚线,形状写问号;底部说明两个操作各自作用在这组三份张量上

  2. torch.cat(…, dim=1):沿列方向首尾接上,4 + 4 + 4 = 12,得 (4, 12)。维数还是 2。

    第 2 帧:第二行 torch.cat 沿 dim=1 得 (4, 12) 青绿框标出,旁注沿列接长 4 加 4 加 4 等于 12;stack 行仍是虚线;底部说明维数还是 2

  3. torch.stack(…, dim=1):在第 1 位新插一根长 3 的轴,得 (4, 3, 4)。维数从 2 变成 3。

    第 3 帧:第三行 torch.stack 沿 dim=1 得 (4, 3, 4) 青绿框标出,旁注在第 1 位新插一根长 3 的轴;底部写维数从 2 变成 3,cat 是串起来,stack 是摞起来

手写线性回归:训练骨架的一次迭代

这份材料不用优化器,每一步自己写。数据是 15 条样本、3 个特征(温度、降雨、湿度)、2 个输出(芒果、橙子的产量)。batch_size=3,一个 epoch 正好 5 个 batch。参数 w 形状 (2, 3)、b 形状 (2,),都带 requires_grad=True。意思是凡用到它们的运算,autograd 都记下来,backward() 沿这条记录往回算梯度。

下面只追一个 batch,看每一步之后张量是什么形状。手写版把清零放在最后。用优化器时 zero_grad() 挪到最前,效果一样,就是概念卡里那五步。

一步一步看

目标:逐行追一次训练迭代里各张量的形状,看前向、损失、反向、更新、清零各做了什么。

每帧一行代码,青绿框是这一步,上面的行已经执行过,虚线行还没执行。

  1. 取一个 batch:x 是 (3, 3),3 条样本各 3 个特征;y 是 (3, 2)。

    第 1 帧:六行推导表,第一行取一个 batch,x 形状 (3, 3)、y 形状 (3, 2) 青绿框标出,其余五行是虚线问号;底部说明 15 条样本 batch_size 为 3,一个 epoch 正好 5 个 batch

  2. 前向:x @ w.t() + b。(3, 3) 乘 (3, 2) 得 (3, 2)。b 长度 2,广播(自动复制到每一行)后加上去,仍是 (3, 2),和 y 对齐。

    第 2 帧:第二行前向 x @ w.t() + b 得 preds (3, 2) 青绿框标出,旁注 (3, 3) 乘 (3, 2),b 广播到每行;底部说明 w 是 (2, 3),转置成 (3, 2) 才能和 x 做矩阵乘

  3. 算损失:差值是 (3, 2),共 6 个元素。平方求和再除以 numel() 得到的 6,结果是一个标量。

    第 3 帧:第三行 mse_loss 得 loss 标量青绿框标出,旁注 6 个元素的平方差取平均;底部说明分母是元素数 6,与 nn.MSELoss 默认的按元素平均一致

  4. loss.backward():梯度写进 w.grad 和 b.grad,形状和参数一样,分别是 (2, 3) 和 (2,)。

    第 4 帧:第四行 loss.backward() 得 w.grad (2, 3) 青绿框标出,旁注梯度和参数同形,b.grad 是 (2,);底部说明 backward 没有返回值,梯度是写进 .grad 的副作用

  5. 更新:在 torch.no_grad() 里做 w -= w.grad * 1e-6,b 同理。形状不变,数值挪一小步。

    第 5 帧:第五行 w -= w.grad * 1e-6 之后 w 仍是 (2, 3) 青绿框标出,旁注形状不变数值挪一小步;底部说明更新要包在 no_grad 里,否则对叶子参数原地改通常会报错

  6. 清零:w.grad.zero_()、b.grad.zero_(),这次迭代结束。不清的话,下一个 batch 的梯度会叠在这次上面。

    第 6 帧:第六行 w.grad.zero_() 之后 w.grad 全 0 青绿框标出,六行全部执行完;底部说明不清零,下一次 backward 的梯度会叠在这次上面

autograd:一个能手算验证的梯度

这一段有一个能手算验证的例子,值得自己重做。Q = 3a³ − b²,a = [2, 3]、b = [6, 4]。那么 ∂Q/∂a = 9a² = [36, 81],∂Q/∂b = −2b = [−12, −8]。意思是 a 每变一点,Q 变化的倍数是 9a²。材料下一个 cell 正是用这两条恒等式自校验的。这里 backward() 必须传 gradient= 参数,因为 Q 是长度 2 的向量。backward() 算的是向量-雅可比乘积,需要一个同形状的权重向量。雅可比(Jacobian)指 Q 的每个分量对每个输入分量的偏导排成的表。平时不用传,是因为 loss 是标量(单个数),默认权重就是 1.0。看到 “grad can be implicitly created only for scalar outputs” 这个报错,就是对非标量调了裸的 backward()。多层网络上怎么一层层手算回去,见 L06e 反向传播。

一步一步看

目标:先手算 Q 对 a、b 的偏导,再看 backward 给出的 a.grad 和 b.grad 是否和手算一致。

每帧一行推导,青绿框是这一步新算的,虚线行还没算。

  1. 前向:代入 a = [2, 3]、b = [6, 4]。Q = [3×8 − 36, 3×27 − 16] = [−12, 65],有两个分量,是向量。

    第 1 帧:四行推导表,第一行 Q 等于 3a³ 减 b²,结果 [−12, 65] 青绿框标出,旁注 3×8 − 36 = −12,3×27 − 16 = 65;底部说明 Q 是向量,backward 需要同形状的权重

  2. 对 a 求偏导:∂Q/∂a = 9a²。a² = [4, 9],乘 9 得 [36, 81]。

    第 2 帧:第二行 ∂Q/∂a 等于 9a²,结果 [36, 81] 青绿框标出,旁注 a² = [4, 9] 再乘 9;底部说明 Q 的第 i 个分量只含 a 的第 i 个分量,逐元素求导即可

  3. 对 b 求偏导:∂Q/∂b = −2b = [−12, −8]。

    第 3 帧:第三行 ∂Q/∂b 等于 −2b,结果 [−12, −8] 青绿框标出,旁注 b = [6, 4] 乘 −2;底部说明 3a³ 与 b 无关

  4. Q.backward(gradient=[1., 1.]):两个分量各乘权重 1 再回传。a.grad 得 [36, 81],b.grad 得 [−12, −8],和手算一致。

    第 4 帧:第四行 Q.backward 传入全 1 权重,a.grad = [36, 81] 青绿框标出,旁注 b.grad = [−12, −8] 与手算一致;底部说明权重全 1 等价于 Q.sum().backward()

nn.Module 与 LeNet:16 × 5 × 5 怎么推

这份材料定义网络只写 forward,backward 由 autograd 自动生成。最容易卡住的是 nn.Linear(16 * 5 * 5, 120) 这一行,400 得从输入一层层推出来。通道数和边长分开算:通道数看核的个数,边长看核边长和池化。F.relu 逐元素作用,不改形状。参数清点见下面的完整例题,池化和数参数的讲解见 L07a-3 参数量与池化。

一步一步看

目标:逐层推 LeNet 各层输出的形状,看 16 × 5 × 5 怎样一步步得来,为什么正好接上 fc1 的 400。

每帧上排是各层输出的示意方块,方块边长和特征图边长成比例,叠层表示多通道。青绿是这一步算出的层,虚线是还没算到的层。

  1. 输入 1 × 32 × 32:1 个通道,高宽各 32。代码里还带 batch 维,写作 (1, 1, 32, 32)。

    LeNet 第 1 帧:一排九个位置依次是输入、conv1、pool、conv2、pool、flatten、fc1、fc2、fc3,只有输入的方块青绿标 1×32×32,其余八个是虚线问号;下方写 1 个通道,高宽各 32

  2. conv1 = Conv2d(1, 6, 5):边长 32 − 5 + 1 = 28,6 个核给出 6 个通道,得 6 × 28 × 28。

    LeNet 第 2 帧:输入方块变黑框,conv1 叠层方块青绿标 6×28×28,后面七层仍是虚线;下方写边长 32 − 5 + 1 = 28,通道 1 到 6

  3. 池化 2:28 ÷ 2 = 14,通道数不变,得 6 × 14 × 14。

    LeNet 第 3 帧:第一个 pool 的方块缩到一半边长,青绿标 6×14×14;下方写边长 28 除以 2 等于 14,通道仍是 6,池化没有可学习参数

  4. conv2 = Conv2d(6, 16, 5):14 − 5 + 1 = 10,通道 6 → 16,得 16 × 10 × 10。

    LeNet 第 4 帧:conv2 方块青绿标 16×10×10,前三层黑框,后五层虚线;下方写边长 14 − 5 + 1 = 10,通道 6 到 16,通道看核个数、边长看核边长

  5. 池化 2:10 ÷ 2 = 5,得 16 × 5 × 5。

    LeNet 第 5 帧:第二个 pool 的小方块青绿标 16×5×5;下方写边长 10 除以 2 等于 5,到这里是 16 张 5×5 的小图

  6. torch.flatten(x, 1):16 × 5 × 5 = 400,拉成一排,正好是 fc1 的输入维。

    LeNet 第 6 帧:flatten 位置的竖条青绿标 400,五个方块都是黑框,三个全连接层仍是虚线;下方写 16 × 5 × 5 = 400,正好是 nn.Linear(16 * 5 * 5, 120) 的输入维

  7. 三个全连接层:400 → 120 → 84 → 10。Linear 只改最后一维,网络最后输出 10 个数。

    LeNet 第 7 帧:fc1、fc2、fc3 三根竖条青绿标 120、84、10,前面六层全是黑框;下方写 400 到 120 到 84 到 10,Linear 只改最后一维

字符级 RNN:一步里的形状

这一段直接回答了「什么是循环神经网络」。把当前输入和上一步的隐状态(hidden state,网络对已读内容的记忆)拼起来,过一个线性层得到新隐状态,再映射到输出。「循环」在调用它的 for 循环里:同一组权重反复作用于序列的每一步。形状对账:输入 (1, 57)、隐状态 (1, 128),拼接得 (1, 185),所以 i2h 的输入维必须是 57 + 128。字母表 57 = 52 个英文字母 + 5 个标点。每个字符编成 57 维 one-hot(只有对应位置是 1、其余全 0 的向量),中间那个长度 1 的维度是 batch 维。序列怎么递推见 L07b-1 RNN。

一步一步看

目标:追字符级 RNN 读一个字符的一步,看输入和隐状态怎样拼成 185 维,再分出新隐状态和 18 类输出。

读一个字符算一步。名字 Jones 编成 (5, 1, 57),同一个单元要走 5 步,下面追其中一步。

  1. 当前字符编成 one-hot:input 形状 (1, 57)。

    RNN 第 1 帧:五行推导表,第一行 input 一个字符,形状 (1, 57) 青绿框标出,旁注 57 维 one-hot、中间的 1 是 batch;其余四行虚线;底部写字母表 57 等于 52 个英文字母加 5 个标点

  2. 拿出上一步的隐状态:hidden 形状 (1, 128)。读第一个字符时用 initHidden() 给的全 0。

    RNN 第 2 帧:第二行 hidden 上一步,形状 (1, 128) 青绿框标出,旁注第一个字符时用 initHidden() 的全 0;底部说明每个新名字都要重置隐状态

  3. torch.cat((input, hidden), 1):沿第 1 维拼接,57 + 128 = 185,得 (1, 185)。

    RNN 第 3 帧:第三行 cat 沿第 1 维拼接得 (1, 185) 青绿框标出,旁注 57 + 128 = 185;底部说明 i2h 的输入维必须是 input_size 加 hidden_size

  4. i2h = Linear(185, 128):得新隐状态 (1, 128),交给下一个字符用。

    RNN 第 4 帧:第四行 i2h 等于 Linear(185, 128) 得 hidden (1, 128) 青绿框标出,旁注新隐状态交给下一个字符;底部说明这一行没有 tanh,是这份实现和教科书公式的差别

  5. h2o = Linear(128, 18) 再过 LogSoftmax:得 (1, 18),18 个语言各一个对数概率。名字读完后,只用最后一步的输出算损失。

    RNN 第 5 帧:第五行 h2o 再过 LogSoftmax 得 output (1, 18) 青绿框标出,旁注 h2o 等于 Linear(128, 18);底部说明 18 个语言各一个对数概率,名字有几个字符就走几步,只用最后一步算损失

字符级 RNN 末尾的 Exercises是开放题,给两个方向。一是换一个「一行文本 → 类别」的数据集,比如名字 → 性别。二是把网络做大做好:加线性层,或换成 nn.LSTM、nn.GRU。第一个该试的改动是在隐状态后面加 torch.tanh()。

时间序列:滑窗与模型里的形状

这一段是前面所有东西的合流。骨架七步:归一化 → 滑窗 → Dataset/DataLoader → 模型 → 训练 → 逆变换评估 → 外推。滑窗是核心:用过去 8 个时刻预测第 9 个。长度 N 的序列切出 N − 8 个样本,X 形状 (N−8, 8, 1)。Dataset 是 PyTorch 的数据集接口,DataLoader 负责从里面切批、打乱。自定义 Dataset 只需要写 __len__ 和 __getitem__ 两个方法,这是项目里处理自己数据时唯一要写的接口。三个模型共用同一个接口,都靠 out[:, -1, :] 取最后时刻的隐状态做单步预测。

一步一步看

目标:先看滑窗怎样从序列切出样本、往后外推,再追模型里从 X 到预测值的形状变化。

前三帧用 10 个已知值 t0…t9 演示滑窗,后四帧追 RNN 模型里的形状,B 代表 batch 大小。

  1. 第一个样本:t0…t7 这 8 个值作输入,t8 作目标。

    滑窗第 1 帧:一排 11 格 t0 到 t10,t10 是虚线未来格;青绿框圈住 t0 到 t7 标 X 共 8 个值,t8 加粗标 y;底部说明输入是连续 8 个值,目标是紧接着的第 9 个

  2. 窗口右移一格:t1…t8 预测 t9。t9 之后没有已知值,长度 10 只切出 10 − 8 = 2 个样本。

    滑窗第 2 帧:青绿框右移一格圈住 t1 到 t8,t9 加粗标 y;底部写 t9 之后没有已知值,长度 10 只切出 10 − 8 = 2 个样本

  3. 外推未来:从最新 8 个已知值 t2…t9 起步,预测 t10。预测出的值接到窗口末尾,丢掉最旧一项,再预测 t11。

    滑窗第 3 帧:青绿框圈住 t2 到 t9,虚线未来格 t10 加粗标 y;底部说明预测出的 t10 接到窗口末尾、丢掉最旧一项,再预测 t11

  4. 一批窗口送进模型:X 是 (B, 8, 1),最后的 1 是特征数,对应 input_dim=1。

    模型第 4 帧:四行推导表,第一行一批窗口 X 形状 (B, 8, 1) 青绿框标出,旁注 8 个时刻每个时刻 1 个特征;其余三行虚线;底部说明 B 是 batch 大小,最后的 1 对应 input_dim=1

  5. nn.RNN(1, 32, batch_first=True):每个时刻都输出一个 32 维隐状态,得 (B, 8, 32)。

    模型第 5 帧:第二行 RNN(1, 32, batch_first=True) 得 out (B, 8, 32) 青绿框标出,旁注每个时刻输出 32 维隐状态;底部说明 batch_first 让第 0 维是 batch,漏了会把 B 当成时间维

  6. out[:, -1, :]:只取最后一个时刻,得 (B, 32)。

    模型第 6 帧:第三行 out[:, -1, :] 得 (B, 32) 青绿框标出,旁注只留最后一个时刻;底部说明最后一个时刻读过整个窗口,单步预测只要它

  7. fc = Linear(32, 1):得 (B, 1),每个窗口一个预测值,和 y 的形状对齐。

    模型第 7 帧:第四行 fc 等于 Linear(32, 1) 得 (B, 1) 青绿框标出,四行全部算完;底部说明 LSTMModel 把 nn.RNN 换成 nn.LSTM,这条形状链不变

课件里的坑

  • [课件有误] torch.randn 应为标准正态分布,不是说明文字中的 uniform。注意:Uniform(−√3, √3) 也有均值 0、标准差 1,因此这三个条件本身不矛盾,错误在函数对应的分布名称。
  • [课件有误] 字符级 RNN 那份的 train() 函数里,参数更新和 return 三行全被注释掉了。于是它算了梯度却从不更新参数,还返回 None,下一个 cell 对 None 解包直接抛 TypeError。照原样跑必崩,这不是环境问题;解开那三行即可,这大概是留给你补的练习。
  • [课件有误] 时间序列那份的说明文字写输出 submission.csv、列名 Predict Target,代码实际写出的是 future_forecast.csv、列名 Predicted Target(多了个 ed);读数据的列名同样对不上。提交前先 print(df.columns) 看真实列名,文件名和表头以课程给的样例文件为准。
  • [代码对齐问题] 时间序列 cell 18 从 X_val[-1] 外推,第一步仍对应最后一个已知目标。补充修正:从 val_scaled[-seq_len:](最新 8 个已知值)起步。例:已知 t0…t9,原窗口 t1…t8 预测的是 t9;未来 t10 应用 t2…t9。日期需从最后已知日期续排,原代码固定从 W02 开始也不可靠。
  • [课件留白] 那份的 TransformerModel 没有位置编码。无位置编码且无顺序掩码的自注意力是置换等变(permutation equivariant),不是不变。输出会随输入重排;取最后一项能区分末项,但不能完整表达其余历史的先后。想用它,补位置编码是第一个必须做的改动。
  • [补充] 字符级 RNN 的隐状态没过激活函数,而教科书公式是 h_t = tanh(W·[x_t, h_{t−1}])。两层线性叠加在数学上仍是线性的,所以它的表达能力比标准 RNN 弱。要改进,先在 hidden 后面加一个 torch.tanh()。
  • [补充] 累加损失一律写 loss.item()。loss 是挂在计算图上的张量,直接累加会把整个图留在内存里不释放,是经典的显存泄漏写法。同理,推理时 no_grad() 和 model.eval() 是两件事,前者管要不要记梯度,后者管 dropout 和 BatchNorm 用哪套行为,两个都要调。

课后 10 分钟:考点复习

这 10 分钟怎么用:合上页面,先默写三条——训练五步的顺序、卷积输出边长的公式、CrossEntropyLoss 该配什么样的最后一层;再把下面的「变式题」算一遍;最后回查两处最容易错的地方——忘了 zero_grad()、漏了 batch_first=True。三步做完再往下看答案。

必背

  1. 训练循环的五步顺序是 zero_grad → 前向 → 算损失 → backward → step,四份 notebook 的训练函数全是它的变体。
  2. 梯度是累加进 .grad 的不是覆盖的,不清零第二个 batch 的梯度会叠在第一个上;手写原地参数更新用 torch.no_grad();普通 optimizer.step() 已处理这一点。
  3. 无 padding、stride 为 1 时卷积输出边长等于输入边长减核边长加一,本例 2×2、stride=2 的池化边长减半;LeNet 里 16×5×5 = 400 要能自己推出来。
  4. nn.Linear 的 weight 形状是 (out_features, in_features),与构造函数的参数顺序相反,手写线性回归写 w.t() 就是为了补这个转置。
  5. CrossEntropyLoss 内部自带 LogSoftmax,网络最后一层应输出裸 logits;网络里已经有 LogSoftmax 就配 NLLLoss,推荐这两种配对,别把概率误当 logits。
  6. 材料两例分别用 1e-6 和 1e-3;归一化有助于优化,但不能据不同模型断言学习率必提高千倍。
  7. 循环层漏掉 batch_first=True 不会报错,模型会把时间维当成 batch 维处理,属于典型的不报错的错。
  8. 自回归外推把预测值滚回输入窗口,误差逐步累积,长程结果是题目要求的输出长度而不是模型的有效预测能力。

完整例题

把 LeNet 的 shape 链和参数清单一次推完。网络是 Conv2d(1, 6, 5) → 池化 2 → Conv2d(6, 16, 5) → 池化 2 → Linear(400, 120) → Linear(120, 84) → Linear(84, 10),输入 1×32×32。

步骤 运算 输出 shape 怎么来的
输入 — 1 × 32 × 32 给定
conv1 Conv2d(1, 6, 5) 6 × 28 × 28 32 − 5 + 1 = 28
pool 池化 2 6 × 14 × 14 28 ÷ 2
conv2 Conv2d(6, 16, 5) 16 × 10 × 10 14 − 5 + 1 = 10
pool 池化 2 16 × 5 × 5 10 ÷ 2
flatten torch.flatten(x, 1) 400 16 × 5 × 5

逐步说明:

  1. 通道数与边长分开算。卷积核个数决定输出通道(1→6→16),核边长决定输出边长。两条线互不干扰,一起算才容易乱。
  2. torch.flatten(x, 1) 里的 1 表示从第 1 维开始拉平,保留第 0 维的 batch。写成 x.view(-1, 400) 效果相同但更脆,换了输入尺寸就崩。
  3. 参数清点:list(net.parameters()) 的长度是 10 = 5 层 × 2,池化没有可学习参数所以不计入。conv1 的 weight 是 (6, 1, 5, 5),conv2 是 (16, 6, 5, 5),fc1 是 (120, 400)——注意 Linear 的 weight 是 (out, in),和构造参数顺序相反。
  4. 换彩色图不用重推。同样 32×32 的三通道输入,只把第一层改成 Conv2d(3, 6, 5),后面整条推导链原样复用,400 这个数不变。

变式题(先自己做)

自编情境。自己搭一个网络:输入 3 × 64 × 64,依次是 Conv2d(3, 8, 5) → 池化 2 → Conv2d(8, 16, 3) → 池化 2 → flatten → Linear(?, 100) → Linear(100, 10),卷积均无 padding、stride=1;两次池化均为 2×2、stride=2。

(1) 把每一层的输出 shape 推出来,Linear 第一个参数该填多少?(2) batch 取 32 时,输入张量和 flatten 之后的张量形状分别是什么?(3) list(net.parameters()) 的长度是多少,两个卷积层各有多少个可学习参数?(4) 这是个 10 类分类任务,最后一层要不要加 softmax,该配哪个损失函数?

提示

第 (1) 问两条公式交替用:卷积减核边长加一,本例 2×2、stride=2 的池化边长减半。第 (3) 问卷积 weight 的形状是 (输出通道, 输入通道, 核高, 核宽),别忘了 bias。第 (4) 问回想图像分类那份 forward 的最后一行长什么样。

参考答案与自检(非官方评分标准)

自检要点:① 通道数和边长分开推,不把两者乘混;② flatten 之后保留 batch 维;③ 参数个数按层数 × 2 数,池化不计入;④ 答「不加 softmax」并说出 CrossEntropyLoss 自带。

(1) 3×64×64 → conv1 得 8×60×60(64 − 5 + 1)→ 池化 8×30×30 → conv2 得 16×28×28(30 − 3 + 1)→ 池化 16×14×14。所以 flatten 之后是 16 × 14 × 14 = 3136,Linear 第一个参数填 3136。

(2) 输入是 (32, 3, 64, 64),flatten 之后是 (32, 3136)。torch.flatten(x, 1) 只拉平第 1 维往后的部分,batch 维始终保留。

(3) 长度是 8(两个卷积层、两个全连接层,各有 weight 和 bias;池化无参数)。conv1:weight 形状 (8, 3, 5, 5) 共 8 × 3 × 25 = 600 个,加 8 个 bias,合计 608。conv2:weight 形状 (16, 8, 3, 3) 共 16 × 8 × 9 = 1152 个,加 16 个 bias,合计 1168。顺带一提 fc1 的 weight 是 (100, 3136) = 313600 个,全连接层才是参数大户。

(4) 不加。nn.CrossEntropyLoss 内部已经包含 LogSoftmax,最后一层直接输出 10 个裸 logits 即可;先做 Softmax 会把概率再当 logits,改变目标函数。若网络输出 LogSoftmax,推荐配 NLLLoss;再接交叉熵通常冗余,并不等于训练必然失败。

闪卡自测

1. 训练循环的五步顺序是什么?

zero_grad → 前向 → 算损失 → backward → step。顺序不能乱,四份 notebook 的训练函数全是它的变体。

2. 去掉 no_grad() 和去掉 zero_() 的后果分别是什么?

去掉 no_grad():对需要梯度的叶子参数做原地更新,通常会报错;不是必然先出现显存爆掉。去掉 zero_():梯度累加不清,第二个 batch 的梯度叠在第一个上,越滚越大。两者后果不同。

3. Q = 3a³ − b²,a = [2, 3]、b = [6, 4],梯度分别是多少?

∂Q/∂a = 9a² = [36, 81],∂Q/∂b = −2b = [−12, −8]。因为 Q 是向量不是标量,backward() 必须传一个同形状的 gradient= 权重向量。

4. cat 和 stack 作用在三个 4×4 张量上,dim=1,各得到什么形状?

cat 在已有维度上接长,得 (4, 12);stack 新开一个维度,得 (4, 3, 4)。记法:cat 是串起来,stack 是摞起来。

5. t = torch.ones(5); n = t.numpy(); t.add_(1) 之后 n 是什么?

[2. 2. 2. 2. 2.]。CPU 张量和 ndarray 共享同一块内存,改一边动另一边。搬到 GPU 之后是真拷贝,不再关联;要真副本用 clone()。

6. 分类网络最后一层没有 softmax 是漏写吗?

不是漏写。CrossEntropyLoss 自带 LogSoftmax,最后一层输出裸 logits 才对。网络里已有 LogSoftmax 的话,损失要换成 NLLLoss。

7. 循环层漏掉 batch_first=True 会怎样?

多半不报错,但输入默认按 (seq_len, batch, feature) 解读,模型把时间维当成 batch 维处理,学出来的东西没有意义。这是最典型的不报错的错。

8. 用 seq_len=8 切一条长度 100 的序列,得到几个样本?形状呢?

92 个(100 − 8)。X 形状 (92, 8, 1),y 形状 (92, 1),最后那个 1 是特征维度,对应模型的 input_dim=1。

下一步

先从不依赖外部数据的那份开始,把手写梯度下降那段不看原文重写一遍——四步顺序和两处 no_grad() / zero_() 能一次写对,基础就过关了。字符级 RNN 那份务必先解开被注释掉的三行再跑,跑通之后按材料末尾的练习方向改一处:在隐状态后面加 torch.tanh(),或把 nn.RNN 换成 nn.LSTM,看混淆矩阵有没有变好。时间序列那份要真跑起来先解决数据来源,拿到数据第一件事是打印列名。行有余力就把三个模型在固定 epoch 数下各跑一遍、把验证 MSE 记成一张表——一次只改一个变量,这是 project 里必然要做的最小对比实验。

下一讲 →
T03a T03a Tutorial 3:爬山法、四皇后与 A* 手算,眼前最好不等于最后最好

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。