我们到底在做什么?
从一个标量参数构建最小的 PyTorch 训练循环,手算梯度,区分前向、反向与更新,然后破坏梯度清零与参数同一性,学会从证据而不是损失曲线诊断训练。
获得能跑的 PyTorch 代码,从未像今天这么容易。向助手描述一个模型,把结果粘进文件,训练循环通常就会出现,而且通常能跑。对日常大量工作来说,这样做没问题,本书也不要求你假装不是这样。
困难在后面。
代码能跑,但损失两百步纹丝不动。或者某个张量是 [32, 128],而下一个算子想要 [128, 32]。或者某个权重的梯度是 None,却没有任何解释。或者模型昨天能训练,今天就不行,而你指不出任何变化。这些都不是语法错误。它们不会给出有用的 traceback,很多时候甚至没有任何 traceback。它们是关于程序在做什么的问题,要回答它们,你需要知道该往哪里看。
本书就是为了填上这个缺口。目标不是背下 PyTorch 的 API 表面,也不是凭记忆复现教程,而是足够理解这套机制,让没见过的 PyTorch 代码变成你可以盘问的东西:读它,对它应该做什么形成假设,找到证实或证伪假设的证据,修复真正的原因,而不是可见的症状。
在这个过程中你会一直用 AI,也应该用。助手擅长给出候选解释、跟踪记录、对比或实验。它弱在不知道自己的哪种解释在你的具体程序里为真。做判断仍然是你的工作,而只有当你知道框架实际在做什么时,你才能做这份工作。
全书都建立在一个循环上,本章只讲这个循环。在 PyTorch 的抽象把它变复杂之前:
训练模型时,我们到底在做什么?
仍然算训练的最小问题
先把神经网络放在一边。假设世界服从一条规则:
y = 3x
如果 x 是 2,那么 y 是 6。我们假装不知道这个乘数。我们只知道规则的形式:
y = wx
数值 w 是程序唯一允许改动的数字。这使它成为一个参数(parameter):不是输入,不是输出,而是允许训练调整的内部值。本节其余一切都是固定的。
从一个故意很差的猜测开始,w = 1。输入 x = 2:
prediction = 2 × 1 = 2
正确答案,即目标(target),是 6。模型错了,我们现在需要用计算机能处理的方式说出错得多厉害。一个预测越差数值越大的数字就够了。平方误差是通常的首选:
loss = (prediction - target)²
= (2 - 6)²
= 16
平方有两个好处。它去掉符号,低四与高四同样糟;它比误差本身增长更快,大错主导小错。它还有一个更重要的性质:它是光滑的,可以求导。
这很重要,因为我们接下来需要一个方向。我们可以随机试 w 的值直到损失变小,只有一个参数时这样做甚至管用。但参数稍多就失效了:小模型有几千个参数,大模型有几十亿,在这个空间里靠试错搜索毫无希望。我们想要的是一个局部问题。
如果把
w往上轻推一点,损失是上升还是下降?幅度是多少?
这就是梯度(gradient):损失对参数的导数。把损失写成 w 的函数:
loss(w) = (wx - y)²
并求导:
dloss/dw = 2(wx - y) · x
代入 w = 1、x = 2、y = 6:
dloss/dw = 2(1·2 - 6) · 2
= 2(-4) · 2
= -16
梯度是 -16。仔细读这个符号,因为符号就是全部要点。负梯度意味着增大 w 会减小损失。所以我们应该把 w 往上移。幅值 16 说明这里斜率很陡,但它没告诉我们该走多远;导数只描述当前值附近极小邻域内的损失曲面。要把方向变成步长,需要引入一个缩放因子,即学习率(learning rate):
w_new = w - learning_rate × gradient
取学习率为 0.1:
w_new = 1 - 0.1 × (-16)
= 1 + 1.6
= 2.6
猜测从 1 移向 3。看看这带来了什么:
prediction = 2 × 2.6 = 5.2
loss = (5.2 - 6)² = 0.64
一步之内损失从 16 降到 0.64。这就是整个算法:预测,度量误差,计算误差对每个参数的斜率,逆着斜率走一小步,重复。
flowchart LR
A[输入 x] --> B[模型: 预测 = f_w of x]
B --> C[损失: 比较预测与目标 y]
C --> D[梯度: d loss / d w]
D --> E[更新: w = w - lr * gradient]
E --> B
本书其余部分加的只是规模与组织。w 变成几百万个数字。x * w 变成矩阵乘法、激活、卷积、注意力。手写更新变成带动量与逐参数缩放的优化器。循环的形状不变。
同样的计算,用 PyTorch 写
先从官网按你的操作系统与硬件装好 PyTorch,然后运行:
import torch
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
prediction = x * w
loss = (prediction - target) ** 2
print("prediction:", prediction.item())
print("loss:", loss.item())
print("w.grad before backward:", w.grad)
loss.backward()
print("w.grad after backward:", w.grad.item())
输出:
prediction: 2.0
loss: 16.0
w.grad before backward: None
w.grad after backward: -16.0
PyTorch 算出 -16.0。我们刚才手算出 -16。这个一致不是形式,而是本书第一份证据,它所代表的习惯比结果更重要。每当 PyTorch 做了看似魔法的事,底下都有一个机制,你可以用自己算出的结果去核对它。
其中三行值得逐行看。
w = torch.tensor(1.0, requires_grad=True)。 在数学意义上,w 是模型参数,因为它是训练允许改动的值。在 PyTorch 语义里,它目前是一个带 requires_grad=True 的叶张量。以后用 nn.Module 建模时,会遇到 nn.Parameter,那是一种被 PyTorch 注册为模型状态的特殊张量。现在,requires_grad=True 的意思是:跟踪涉及这个张量的算子,因为后面会想要对它求导。
x 和 target 也是张量,但它们带 requires_grad=False,这是默认值。
prediction = x * w。 因为其中一个操作数需要梯度,PyTorch 不只是算出数字然后丢掉一切。它还记录了这个结果是由这两个张量相乘得到的。减法与平方也一样。到 loss 存在时,PyTorch 手里已经有一份产生它的算子链记录。
loss.backward()。 它沿着这份记录反向走,每一步应用链式法则。默认情况下,所得梯度累积进需要梯度的叶张量的 .grad 属性,比如 w。PyTorch 也会算出继续反向所需的中间梯度,但除非你显式要求,它不会把那些中间 .grad 留下来。
可以直接看到可训练叶张量 w 与计算产生的张量的区别:
print("w: value=%s requires_grad=%s is_leaf=%s grad_fn=%s"
% (w.item(), w.requires_grad, w.is_leaf, w.grad_fn))
print("x: value=%s requires_grad=%s is_leaf=%s grad_fn=%s"
% (x.item(), x.requires_grad, x.is_leaf, x.grad_fn))
print("loss: value=%s requires_grad=%s is_leaf=%s grad_fn=%s"
% (loss.item(), loss.requires_grad, loss.is_leaf, loss.grad_fn))
w: value=1.0 requires_grad=True is_leaf=True grad_fn=None
x: value=2.0 requires_grad=False is_leaf=True grad_fn=None
loss: value=16.0 requires_grad=True is_leaf=False grad_fn=<PowBackward0 object at ...>
w 需要梯度,且是直接创建而非算出来的,这就是*叶(leaf)*的意思;它是记录的一个端点,正是那种会被填入 .grad 的张量。loss 也需要梯度,但它是算出来的,所以它带 grad_fn,指向产生它的那个算子。backward() 拽的就是这根线。第 3 章会正式拆开它。现在记住一个区分就够了:
张量的值与张量的梯度是两回事,放在两个地方。
w存着1.0。w.grad存着-16.0。把两者搞混是大量训练 bug 的来源。
backward() 只算梯度,它不训练任何东西
很容易把 loss.backward() 读成真正做学习的那一行。它不是。看 w 会发生什么:
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
before = w.item()
loss = (x * w - target) ** 2
loss.backward()
print("w before backward:", before)
print("w after backward: ", w.item())
print("w.grad: ", w.grad.item())
w before backward: 1.0
w after backward: 1.0
w.grad: -16.0
参数没动。backward() 填了一个导数就停了。改参数是另一个还没写的独立操作。
那就写出来。最直接的尝试会失败:
w -= 0.1 * w.grad
RuntimeError: a leaf Variable that requires grad is being used in an in-place operation.
这个报错说的是真事。w 是需要梯度的叶张量。如果 PyTorch 像记录乘法那样记录这次减法,w 会变成一个带自己 grad_fn 的计算张量,不再是梯度累积终点的端点。但这次减法根本不是模型的一部分;是我们在迭代之间从外面伸手改参数。PyTorch 不会悄悄破坏结构,而是拒绝,并要求我们显式声明这次编辑不属于计算:
learning_rate = 0.1
with torch.no_grad():
w -= learning_rate * w.grad
print("w after update:", w.item())
print("still a parameter:", w.requires_grad, w.is_leaf)
new_prediction = x * w
print("new prediction:", new_prediction.item())
print("new loss:", ((new_prediction - target) ** 2).item())
w after update: 2.5999999046325684
still a parameter: True True
new prediction: 5.199999809265137
new loss: 0.6400002837181091
2.6、5.2、0.64。就是纸上算出的数字,差的是 float32 舍入。在 torch.no_grad() 里,PyTorch 只做算术而不记录,w 被原地修改,仍是原来的那个参数对象:依然需要梯度,依然是叶张量。
现在有了三个不同阶段,值得命名,因为全书会反复回到这个分解:
forward 计算预测与损失;建立记录
backward 遍历记录;填入 .grad
update 修改参数;记录不参与
以后你会用 optimizer.step() 代替更新,用 optimizer.zero_grad() 代替手工清梯度。在当前 PyTorch 里,optimizer.zero_grad() 默认把梯度设为 None 而不是填零,所以下一次 backward() 之前你看到的确切状态可能与这个手写循环不同。三阶段结构不变。当模型拒绝学习时,有用的第一个问题几乎总是这三个阶段中哪一个没干活,而只有当你在心里把它们分开时,你才能问出这个问题。
重复这一步
一步不是训练。把它放进循环:
import torch
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
learning_rate = 0.1
for step in range(8):
prediction = x * w
loss = (prediction - target) ** 2
loss.backward()
print(f"step={step} w={w.item():+.4f} loss={loss.item():9.4f} "
f"w.grad={w.grad.item():+.4f}")
with torch.no_grad():
w -= learning_rate * w.grad
w.grad.zero_()
step=0 w=+1.0000 loss= 16.0000 w.grad=-16.0000
step=1 w=+2.6000 loss= 0.6400 w.grad=-3.2000
step=2 w=+2.9200 loss= 0.0256 w.grad=-0.6400
step=3 w=+2.9840 loss= 0.0010 w.grad=-0.1280
step=4 w=+2.9968 loss= 0.0000 w.grad=-0.0256
step=5 w=+2.9994 loss= 0.0000 w.grad=-0.0051
step=6 w=+2.9999 loss= 0.0000 w.grad=-0.0010
step=7 w=+3.0000 loss= 0.0000 w.grad=-0.0002
每一行描述一个连贯状态,因为打印发生在 backward() 之后、更新之前:这次预测用的 w 值、这个值产生的损失、由这个损失算出的梯度。三列,三件不同的事。
要合在一起读,而不是分开读。w 爬向 3。损失塌向零。梯度也缩向零,说明我们到达了损失曲面的平坦区;对这个问题,平坦区就是正确答案。每一列都告诉你别的列没说的事,本书后面会遇到损失看起来健康而梯度不健康、或反过来的失败。
这个循环里有一行还没解释。
弄坏它:去掉 w.grad.zero_()
删掉循环体最后一行再跑。不会抛异常。
step=0 w=+1.0000 loss= 16.0000 w.grad=-16.0000
step=1 w=+2.6000 loss= 0.6400 w.grad=-19.2000
step=2 w=+4.5200 loss= 9.2416 w.grad=-7.0400
step=3 w=+5.2240 loss= 19.7847 w.grad=+10.7520
step=4 w=+4.1488 loss= 5.2790 w.grad=+19.9424
step=5 w=+2.1546 loss= 2.8591 w.grad=+13.1789
step=6 w=+0.8367 loss= 18.7199 w.grad=-4.1277
step=7 w=+1.2494 loss= 12.2578 w.grad=-18.1322
这就是一类特别难的训练失败的样子。没有报错。第一步甚至管用:损失从 16 降到 0.64,和以前一模一样。然后运行开始游荡,八步之后 w 比初始猜测离答案更远。
先忍住别改东西。这时本能是去调学习率,因为运行看起来不稳定,不稳定看起来像步长问题。相反,找一个你能预测的数字并检查它。
我们会手算梯度。在 step 1,w 是 2.6:
dloss/dw = 2(wx - y) · x
= 2(2.6 × 2 - 6) × 2
= 2(-0.8) × 2
= -3.2
正确的循环在 step 1 打印 -3.2。这个循环打印 -19.2。所以前向没问题,损失没问题,更新规则没问题。重要线索是 .grad 里现在存的值不只是这一步损失的导数。
这把问题缩到一个位置:backward() 加上新导数之前,.grad 里原来有什么。
而且偏差不是随机的:
-19.2 = -3.2 + (-16.0)
它是这一步梯度加上上一步。backward() 不是向 .grad 赋值,而是累加。单独确认这个机制:
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
for i in range(3):
loss = (x * w - target) ** 2
loss.backward()
print(f"backward {i+1}: w.grad = {w.grad.item()}")
backward 1: w.grad = -16.0
backward 2: w.grad = -32.0
backward 3: w.grad = -48.0
同样的 w,同样的损失,三个相同的 -16 梯度,累积成 -48。这是 PyTorch 故意的,不是疏忽。累积让你可以在更新前有意合并多次反向的梯度,比如跨 micro-batch 的梯度累积,或其他需要多次反向的工作流。
这种灵活性的代价是:你必须决定何时清除旧梯度。
修复就是删掉的那一行:
w.grad.zero_()
去验证它,而不是假定它。检查不是“损失又降了吗”,而是“step 1 的 w.grad 是否等于 -3.2”。确实等于。这就是修复与巧合的区别:我们从独立计算预测了一个具体数字,并观察到了它。
值得说清为什么调小学习率是错误回应。它可能让运行看起来平静些,因为每个被污染的更新都变小了,但陈旧梯度还在。更新仍然被累积梯度驱动,而不是被当前这一步损失的梯度驱动。
症状可以变轻,而病因没被纠正。在接受一个修复之前,你应该能说出它纠正了哪个量,以及你如何观察到这次纠正。
这也是那种能活过代码评审的 bug:漏掉 zero_grad() 的生成训练循环能跑,前一两步损失下降,看起来完全正常。
换种弄坏法:不再是参数的参数
同一家族的第二个失败。更新写成了重绑定,而不是原地编辑:
with torch.no_grad():
w = w - learning_rate * w.grad # note: w = w - ..., not w -= ...
这两种形式看起来可互换,在普通 Python 算术里通常也确实可互换。跑循环并在每轮打印参数状态:
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
learning_rate = 0.1
for step in range(3):
prediction = x * w
loss = (prediction - target) ** 2
print(f"step={step} w={w.item():.4f} loss={loss.item():.4f} "
f"requires_grad={w.requires_grad} is_leaf={w.is_leaf}")
loss.backward()
with torch.no_grad():
w = w - learning_rate * w.grad
step=0 w=1.0000 loss=16.0000 requires_grad=True is_leaf=True
step=1 w=2.6000 loss=0.6400 requires_grad=False is_leaf=True
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
异常出现在第二次 backward(),比真正的错误晚了一轮。这种延迟很典型,这也是只读 traceback 容易把人带到错行去的原因。
证据在打印的状态里。step 0 的 w 需要梯度,step 1 不需要。没人显式改过原张量的 flag,所以一定有东西替换了 w 所指的对象。
正是如此。在 torch.no_grad() 里,表达式 w - learning_rate * w.grad 创建了一个新的不需要梯度的张量,赋值让名字 w 指向这个新张量。从 step 1 起,计算不再依赖需要梯度的张量,backward() 没有可微分的对象。
修复是原地形式 w -= learning_rate * w.grad,它修改已有张量,保持其同一性。
有个诱人的替代方案你会经常看到:保留重绑定,事后加 w.requires_grad_(True)。异常消失,这个小循环也能训练。但心智模型仍然错了,因为每次更新都把 w 换成一个新的可训练叶张量。
只有一个手写变量时你可能永远注意不到。一旦优化器持有张量引用,或 nn.Module 注册了 nn.Parameter 对象,替换对象与更新被注册对象就不再等价:参与计算的对象与系统其余部分跟踪的对象会脱节。第 5 章会给这个区分一个具体的归属机制,并回到它真正危险时的失败形态。
眼下记住这个形状:
在训练系统里,更新的是哪个张量对象很重要,不只是它当前存着什么数值。一旦优化器与模块开始跟踪可训练状态,替换对象与修改被跟踪对象不再是等价操作。
损失下降不等于学会了
再做两个实验,讲同一个误解。
先在原来单参数问题上变动学习率,看前六步:
def train(lr, steps=6):
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
for step in range(steps):
loss = (x * w - target) ** 2
loss.backward()
print(f" step={step} w={w.item():+.4f} loss={loss.item():.4f}")
with torch.no_grad():
w -= lr * w.grad
w.grad.zero_()
for lr in (0.01, 0.1, 0.25, 0.3):
print(f"lr={lr}")
train(lr)
同样的代码、同样的数据,出现四种状态:
lr=0.01 lr=0.1
step=0 w=+1.0000 loss=16.0000 step=0 w=+1.0000 loss=16.0000
step=1 w=+1.1600 loss=13.5424 step=1 w=+2.6000 loss=0.6400
step=2 w=+1.3072 loss=11.4623 step=2 w=+2.9200 loss=0.0256
step=3 w=+1.4426 loss=9.7017 step=3 w=+2.9840 loss=0.0010
step=4 w=+1.5672 loss=8.2115 step=4 w=+2.9968 loss=0.0000
step=5 w=+1.6818 loss=6.9502 step=5 w=+2.9994 loss=0.0000
lr=0.25 lr=0.3
step=0 w=+1.0000 loss=16.0000 step=0 w=+1.0000 loss=16.0000
step=1 w=+5.0000 loss=16.0000 step=1 w=+5.8000 loss=31.3600
step=2 w=+1.0000 loss=16.0000 step=2 w=-0.9200 loss=61.4656
step=3 w=+5.0000 loss=16.0000 step=3 w=+8.4880 loss=120.4726
step=4 w=+1.0000 loss=16.0000 step=4 w=-4.6832 loss=236.1264
step=5 w=+5.0000 loss=16.0000 step=5 w=+13.7565 loss=462.8078
0.01 方向对,模型在学,只是慢;给够步数能到。0.1 收敛。0.25 一步跨过最小值,落到另一侧同样远的地方,再跨回来,永远如此:损失完美稳定,完美无用。0.3 超调得比起点还远,发散。这里没有任何 bug。同一份正确代码产生四种行为,只有打印的数字能区分它们。
这是第一层意思。还有更锋利的一层。
给模型第二个参数,即偏置,只用一个样本训练:
x = torch.tensor(2.0)
target = torch.tensor(6.0)
w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)
learning_rate = 0.05
for step in range(60):
prediction = w * x + b
loss = (prediction - target) ** 2
loss.backward()
with torch.no_grad():
w -= learning_rate * w.grad
b -= learning_rate * b.grad
w.grad.zero_()
b.grad.zero_()
print("final training loss:", ((w * x + b - target) ** 2).item())
print("w =", round(w.item(), 4), " b =", round(b.item(), 4))
for value in (1.0, 3.0, 5.0):
xt = torch.tensor(value)
print(f"x={value}: prediction={(w * xt + b).item():.4f} truth={3 * value}")
final training loss: 0.0
w = 2.6 b = 0.8
x=1.0: prediction=3.4000 truth=3.0
x=3.0: prediction=8.6000 truth=9.0
x=5.0: prediction=13.8000 truth=15.0
训练损失是零。不是很小,是零。而模型除了见过的那一个点,其他地方全错。它没找到 y = 3x;它找到 y = 2.6x + 0.8,恰好穿过 (2, 6)。y = x + 4 也穿过,过该点的每条直线都穿过。两个参数、一个样本,问题欠定,梯度下降没有理由偏爱我们心里的答案。它解决了我们实际提出的问题。
这值得直说,因为它是大量被浪费的调试时间底下悄悄的假设:
训练损失下降,只能证明优化过程在减小你给它的目标。它不能证明模型学会了你真正关心的行为。这是两个不同的断言,需要不同的证据。
修复不在循环里,在问题里。给模型不止一个样本,对损失取平均:
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
target = torch.tensor([3.0, 6.0, 9.0, 12.0])
w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)
learning_rate = 0.05
for step in range(500):
prediction = w * x + b
loss = ((prediction - target) ** 2).mean()
loss.backward()
with torch.no_grad():
w -= learning_rate * w.grad
b -= learning_rate * b.grad
w.grad.zero_()
b.grad.zero_()
if step in (0, 9, 99, 499):
print(f"step={step:3d} loss={loss.item():.6f} "
f"w={w.item():.4f} b={b.item():.4f}")
held_out = torch.tensor(10.0)
print(f"held-out x=10 -> prediction {(w * held_out + b).item():.4f}, truth 30.0")
step= 0 loss=30.000000 w=2.5000 b=0.5000
step= 9 loss=0.047325 w=2.8217 b=0.5243
step= 99 loss=0.003134 w=2.9541 b=0.1349
step=499 loss=0.000000 w=2.9999 b=0.0003
held-out x=10 -> prediction 29.9992, truth 30.0
四个点而不是一个,w 收敛到 3,b 到 0。更重要的是,模型在从未见过的外推点 x = 10 也给出预期结果。
这比单独的训练损失是更强的证据,尽管一次未见预测成功还不足以确立泛化。在真实实验里,我们会在留出数据上评估,并与恰当基线对比。第 14 章会把这个想法变成一门纪律。
这个循环里有两个机械细节指向未来。prediction 现在是四个值的张量而不是一个,因为标量参数乘四元素输入产生四个结果;第 2 章讲的正是支配它的规则。
而 .mean() 把四个逐样本损失塌成我们要优化的单个标量目标。这个标量很重要,因为裸 loss.backward() 能对标量输出自动推断起始梯度。PyTorch 也能从非标量张量反向,但那时你必须显式给出定义雅可比-向量积的梯度向量。第 3 章会拆开这个区分。
PyTorch 到底贡献了什么
回头看我们写了什么。模型是我们选的,损失是我们选的,更新规则是我们选的,何时停也是我们定的。我们自己推了一次梯度,手里有了独立结果可核对;然后 PyTorch 替我们把求导自动化了。
它提供的是记账,而记账正是手算无法扩展的部分:
- 数值容器张量(tensor),不仅带数值,还带形状、dtype、设备与内存布局;
- 记录,前向执行时自动建成,记下哪些算子产生了哪些值;
- 对这份记录求导,链有多长都替你应用链式法则;
- 以及以后要讲的参数状态组织、把工作搬上加速器、喂数据的机器。
只有一个参数时,手算求导是两行练习。有了 Transformer,它根本不是练习。这是框架提供的交易,而且是划算的交易,只要你记得交易的是什么。框架自动化了计算,没有自动化理解,当计算给出意外结果时,只有理解能帮你。
这就是为什么当你以后遇到:
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(784, 128)
self.fc2 = nn.Linear(128, 10)
它不应该读成神经网络咒语。nn.Linear(784, 128) 里的权重与偏置,扮演的 autograd 角色和本章 w 一样:它们是可训练的叶张量,其梯度可以在 backward() 中累积。
还有一个重要的额外机制。在 nn.Module 里,那些值是 nn.Parameter 对象,意味着 PyTorch 把它们注册为模型参数,parameters() 与 state_dict() 之类的操作才能发现它们。第 5 章会拆开这套机器。
在这个循环上用 AI
你会让助手写训练循环,它通常写得对。本章的失败正是那种能活过粗看的类型:漏掉梯度清零,更新替换了正在训练的张量,或循环成功最小化了错误的目标。
有些静默失败。有些在真正犯错的行已经执行之后才抛异常。两种情况下,可见症状都可能指向病因之外。
在这里从助手身上拿到真正价值的办法,是先让它对可检查的预测做出承诺,再让它改任何东西。对前面那个删掉 w.grad.zero_() 的坏循环,可以这样试:
这是一段 PyTorch 训练循环。先不要改它,也先不要告诉我怎么修。
跟踪一次完整迭代。列出训练循环里每个具名张量,以及从
w到loss路径上参与的重要中间张量。对每个张量,说明它是否需要梯度,是否为叶张量,backward()返回后它的.grad字段应不应该被填入。然后预测
w.grad在 step 0 与 step 1 的确切数值,并给出计算过程。最后,列出我可以加哪些打印来检查你的每个预测。
然后运行并对比。如果预测与观察一致,你就有了证据,说明你对这部分程序的模型是对的。如果不一致,分歧也有价值,它告诉你哪个假设接下来需要调查。无论哪种,你都得到了“直接修一下”给不了的东西。
要跟踪记录、预测、对比与实验。知道坏在哪里之后再要修复。一个无法检查的拟议修复,只是语法比你好的猜测。
你现在应该能回答什么
这里有一份完整训练程序,小到能装进脑子:
import torch
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
target = torch.tensor([3.0, 6.0, 9.0, 12.0])
w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)
for step in range(500):
prediction = w * x + b
loss = ((prediction - target) ** 2).mean()
loss.backward()
with torch.no_grad():
w -= 0.05 * w.grad
b -= 0.05 * b.grad
w.grad.zero_()
b.grad.zero_()
下面每个问题,你应该不用运行就能回答。
可学习的值是什么? w 与 b。它们是带 requires_grad=True 创建的张量,也是更新语句唯一修改的东西。
预测由什么产生? w * x + b,一次乘法一次加法,都被记录,因为 w 与 b 需要梯度。
损失由什么产生? 一次减法、一次平方、一次 mean,把四个逐样本误差缩成一个标量。
哪些算子应该可微? 从 w、b 到 loss 路径上的每个算子。torch.no_grad() 块里没有。
backward() 到底做了什么? 从 loss 出发沿记录反向遍历,应用链式法则,把结果累积进 w.grad 与 b.grad。它不改任何参数值。
哪些 .grad 字段应该被填入? w.grad 与 b.grad。x.grad 与 target.grad 保持 None,因为那些张量不需要梯度。反向过程中按需算出中间梯度,但 PyTorch 默认不把它们留在 .grad 里。
真正改参数的操作是什么? no_grad 块里的两处原地减法。删掉它们,backward() 跑五百次也训练不出任何东西。
什么证据说明学习在发生? 在这个玩具问题里,w 应该移向 3,b 移向 0,训练目标应该下降,未见输入上的预测应该逼近我们想学的规则。梯度缩小在这里是有用证据,因为我们知道这个损失曲面的形状;以后小梯度可能意味着好几种完全不同的事。
如果参数不动,先检查什么? 按顺序:loss.requires_grad 是否仍为 True?backward() 紧后 w.grad 是 None 还是零?w 是否仍报告 requires_grad=True 与 is_leaf=True,还是有东西替换了它?更新语句到底在不在循环里?
最后一个问题就是本书真正要讲的。答案是一串要看的东西,每样都产生证据,每样都排除一些可能。系统变大后清单变长,证据更难拿,但方法不变。
在猜测之前,先让隐藏的结构可见。
练习
这些值得跑,而不是读,它们对应本章配套 notebook。
-
手算复现梯度。 取
w = 1.5、x = 2、target = 6,纸上算dloss/dw,再与w.grad对照。对带偏置的双参数模型,同样推导dloss/db。 -
直接看累积。 同一个损失不清零连调三次
backward(),每次打印w.grad。然后把w.grad.zero_()换成w.grad = None,确认循环仍能训练。解释为什么两种都管用。 -
确认参数动了。 每次更新前存
before = w.detach().clone()。更新后打印(w.detach() - before).item(),与-learning_rate * gradient对比。这行检查是真实代码里回答“优化器干活了吗”最快的方式。 -
故意断掉梯度跟踪,两次。 先创建不带
requires_grad=True的w。恢复它,再在损失之前插入prediction = prediction.detach()。跑之前先预测两种情况的报错。你会发现两者产生完全相同的RuntimeError,尽管原因不同,这是个小而有用的教训:症状不总能指认病因,区分它们的是你去收集的证据。 -
找到边界。 对单参数问题,不收敛而振荡的学习率是
0.25。从更新规则推导这个数,再用实验确认。弄清刚好在它之下与之上分别发生什么。 -
让模型可辨识。 从单点训练的
w-b模型出发,加第二个不同x值的样本。解释为什么两个不同点决定唯一一条直线,而一个点不行。然后试试复制原样本而不是加新x值。为什么数据行数变多不一定带来更多信息?
下一步:张量
我们一直把 torch.tensor(2.0) 当数字容器,这在每个值都是标量时够用。几乎立刻就不够了。上个实验里 x 装着四个值,prediction 也是四个,产生它的乘法悄悄遵循着从没说过的规则。
这些规则占了实际 PyTorch 调试时间里惊人的一大块。张量带着形状、dtype、设备与内存布局,每样都能产生症状各异的失败:拒绝运行的算子;跑了却悄悄产出尺寸不对的东西的算子;permute() 之后失败的 view();把 [32, 1] 与 [1, 32] 变成没人想要的 [32, 32] 的广播。
下一章让形状推理可操作:如何读形状,如何推导算子应该产生的形状,如何在代码里写下你的假设,以及如何找到维度第一次变错的行。
张量。