网络:没有 nn.Module 时它是什么?
完全用张量构建双层神经网络——权重、非线性、logits、交叉熵、初始化、梯度与手工更新,再用六断言审计区分表示、计算、目标、微分、更新与评估失败。
这里有个双层神经网络,只用前三章的机器写。四可训练张量,一次前向,一个损失,backward(),一次更新。跑起来没警告,损失降了三分之一。
import math
import torch
torch.manual_seed(0)
n = 2000
X = torch.randn(n, 2)
y = ((X[:, 0] > 0) ^ (X[:, 1] > 0)).long()
perm = torch.randperm(n)
n_train = int(0.8 * n)
X_train, y_train = X[perm[:n_train]], y[perm[:n_train]]
X_val, y_val = X[perm[n_train:]], y[perm[n_train:]]
D_in, H, C = 2, 16, 2
torch.manual_seed(1)
W1 = (torch.randn(D_in, H) / math.sqrt(D_in)).requires_grad_()
b1 = torch.zeros(H, requires_grad=True)
W2 = (torch.randn(H, C) / math.sqrt(H)).requires_grad_()
b2 = torch.zeros(C, requires_grad=True)
parameters = [W1, b1, W2, b2]
def forward(x):
z1 = x @ W1 + b1
return z1 @ W2 + b2
def cross_entropy(logits, targets):
log_probs = torch.log_softmax(logits, dim=1)
return -log_probs[torch.arange(targets.shape[0]), targets].mean()
def accuracy(logits, targets):
return (logits.argmax(dim=1) == targets).float().mean().item()
learning_rate = 0.5
# First verify that one training step is mechanically healthy.
names = ["W1", "b1", "W2", "b2"]
initial_values = [p.detach().clone() for p in parameters]
loss = cross_entropy(forward(X_train), y_train)
before = [p.detach().clone() for p in parameters]
loss.backward()
with torch.no_grad():
for p in parameters:
p -= learning_rate * p.grad
for name, p, old in zip(names, parameters, before):
print(f"{name:3s} leaf={p.is_leaf} grad_none={p.grad is None} "
f"grad_norm={p.grad.norm().item():8.4f} "
f"finite={torch.isfinite(p.grad).all().item()} "
f"moved={(p.detach() - old).abs().max().item():.4f}")
W1 leaf=True grad_none=False grad_norm= 0.4516 finite=True moved=0.1048
b1 leaf=True grad_none=False grad_norm= 0.0192 finite=True moved=0.0053
W2 leaf=True grad_none=False grad_norm= 1.1058 finite=True moved=0.1918
b2 leaf=True grad_none=False grad_norm= 0.0175 finite=True moved=0.0062
每个参数都是叶。每个都需要梯度。每个都收到有限梯度,更新运行时每个都动了可测的量。基本训练机器在工作。
现在恢复精确初始状态,让诊断步骤不改变实验:
with torch.no_grad():
for p, initial in zip(parameters, initial_values):
p.copy_(initial)
for p in parameters:
p.grad = None
然后跑完整训练实验:
for step in range(2001):
logits = forward(X_train)
loss = cross_entropy(logits, y_train)
if step % 500 == 0:
with torch.no_grad():
print(f"step={step:4d} loss={loss.item():.4f} "
f"train_acc={accuracy(logits, y_train):.3f} "
f"val_acc={accuracy(forward(X_val), y_val):.3f}")
for p in parameters:
if p.grad is not None:
p.grad.zero_()
loss.backward()
with torch.no_grad():
for p in parameters:
p -= learning_rate * p.grad
step= 0 loss=1.0665 train_acc=0.506 val_acc=0.502
step= 500 loss=0.6928 train_acc=0.596 val_acc=0.592
step=1000 loss=0.6928 train_acc=0.596 val_acc=0.592
step=1500 loss=0.6928 train_acc=0.596 val_acc=0.592
step=2000 loss=0.6928 train_acc=0.596 val_acc=0.592
损失从 1.0665 降到 0.6928 然后永久停住,离 log 2 近得可疑。两分类上精度停在六成弱。
单步诊断已确立训练机器工作:张量形状合法,autograd 通路存在,梯度有限,参数更新。而完整运行仍解不出问题。
所以缺的问题不是实现跑得对不对。而是这组张量排布能算什么函数——结构能不能表示任务。
去掉
nn.Module、nn.Linear与优化器,神经网络是什么?哪部分真正在干活,怎么区分坏的实现与不能表示任务的结构?
读完本章,你会从原始张量建出这个网,理解每部分贡献,手写损失在数值与梯度上与 PyTorch 自带对过,并收集证据,把上面的失败与表面相似的另四种区分开。
数据集是测量仪器
看数据到底是什么。
y = ((X[:, 0] > 0) ^ (X[:, 1] > 0)).long()
两坐标异号标签 1,同号 0。即输入符号的异或:类别 1 住二、四象限,类别 0 住一、三象限。
选这个数据集不是因为真实,而是因为它有当仪器有用的性质:没有一条直线分开两类。 任取半平面都装着两类点,因为两类区域在原点从对侧相接。这是问题几何的事实,无论实现、优化器、训练多久都成立。
这让我们能测平时看不见的东西。不用含糊争线性模型能不能更好,我们在稠密线性决策边界网格上搜,得到这个有限数据集上该模型类能做到的经验参照。
def best_linear_accuracy(Xs, ys, n_angles=720, n_offsets=601):
"""Search a dense grid of half-plane classifiers and return the best accuracy found."""
angles = torch.linspace(0, math.pi, n_angles + 1)[:-1]
offsets = torch.linspace(-3, 3, n_offsets)
best = 0.0
for a in angles:
w = torch.tensor([a.cos(), a.sin()])
scores = Xs @ w # (N,)
preds = scores.unsqueeze(1) > offsets.unsqueeze(0) # (N, n_offsets)
acc = (preds.long() == ys.unsqueeze(1)).float().mean(0)
best = max(best, acc.max().item(), (1 - acc).max().item())
return best
print("best grid-search linear train accuracy:", round(best_linear_accuracy(X_train, y_train), 4))
best grid-search linear train accuracy: 0.6431
稠密搜在这个训练样本上找到线性分类器约 64% 精度。我们训出的网 59.6%,优化与网格参照之间还有 gap。
这不削弱结构结论。gap 补上,仿射分类器也表示不了异或规则。更好的优化能在仿射模型类里移动,移不出它。
这个数值得当证据认真对待,因为它属于前面章节从没产出过的类别:
模型类的独立参照帮你分开优化与表示。稠密搜在这个数据集上找到仿射分类器约 64%,你训出的仿射模型 59%,优化 gap 可能还补得上。但再多优化也让仿射模型精确表示不了异或规则。
但网有两层,十六个隐单元。为什么行为像直线?
两层仿射就是一层仿射
把前向符号展开,X 形状 (B, 2):
z1 = X @ W1 + b1
logits = z1 @ W2 + b2
第一行代入第二行展开:
logits = (X @ W1 + b1) @ W2 + b2
= X @ W1 @ W2 + b1 @ W2 + b2
= X @ (W1 @ W2) + (b1 @ W2 + b2)
矩阵乘法结合,X @ W1 @ W2 自由重组,W1 @ W2 是单个 (2, 2) 矩阵。偏置塌成单个 (2,) 向量。整个双层网精确等于单层网:
logits = X @ W_eq + b_eq W_eq = W1 @ W2 b_eq = b1 @ W2 + b2
这是精确相等的主张,不是近似,当精确相等检查。
with torch.no_grad():
W_eq = W1 @ W2
b_eq = b1 @ W2 + b2
two_layer = forward(X_train)
one_layer = X_train @ W_eq + b_eq
print("W_eq shape:", tuple(W_eq.shape), " b_eq shape:", tuple(b_eq.shape))
print("max abs difference:", (two_layer - one_layer).abs().max().item())
print("parameters in the two-layer form:", sum(p.numel() for p in parameters))
print("parameters in the collapsed form:", W_eq.numel() + b_eq.numel())
在上面两千步训练后的网上跑:
W_eq shape: (2, 2) b_eq shape: (2,)
max abs difference: 7.152557373046875e-07
parameters in the two-layer form: 82
parameters in the collapsed form: 6
差在 float32 噪声层。八十二个可训练数表达了六个数精确描述的 logits。多出的七十六个数没扩大函数类;它们重参数化了同一个仿射映射。
这证明表示局限,不是优化找到最优仿射解。59.6% 属于梯度下降到达的特定解;稠密线性搜已说明这个样本上存在略好的仿射分类器。
没训练的网上同样检查给出 1.43e-06,所以这不是训练产出的。参数创建那刻就真。
不用读源码的测试
上面的塌缩要碰 W1、W2。常常你手里只有模型对象、一堆生成代码、不想逐行读的 forward。有办法从外面问同样问题。
仿射函数满足加性恒等式。若 f(x) = x @ W + b,对任意两输入:
f(x1 + x2) - f(0) = (f(x1) - f(0)) + (f(x2) - f(0))
减 f(0) 去偏置,剩线性部分,线性映射对加法分配。不满足此恒等式的函数不是仿射。在有限探针上通过是弱证据:与仿射一致,不证明处处仿射。非线性函数在你恰好探的区域可能表现仿射。
def affine_residual(f, x1, x2):
"""Measure affine-identity violation on these probes. A non-zero residual falsifies affinity."""
with torch.no_grad():
zero = torch.zeros_like(x1)
lhs = f(x1 + x2) - f(zero)
rhs = (f(x1) - f(zero)) + (f(x2) - f(zero))
return (lhs - rhs).abs().max().item()
a = torch.randn(64, 2) # random probe inputs; any two batches will do
b = torch.randn(64, 2)
print("no activation:", affine_residual(lambda x: (x @ W1 + b1) @ W2 + b2, a, b))
print("with ReLU: ", affine_residual(lambda x: torch.relu(x @ W1 + b1) @ W2 + b2, a, b))
no activation: 9.5367431640625e-07
with ReLU: 2.2889842987060547
第二个数的确切大小依赖抽到的探针与当前参数,别读它。要紧的对比是 1e-6 对量级一:一个函数仿射到浮点精度,另一个不是。
两行算术能快速证伪可调用对象仿射。若残差在很多选好的探针上接近零,是仿射行为的有用证据,但实现可见时上面的代数塌缩才是证明。留着它。当有人递来架构图漂亮、打不过线性基线的模型,大残差能排除“可调用对象仿射”的解释。近零残差让该解释保持可能并告诉你接下来查哪;它本身不证明仿射。
修复与证据
原程序改一处。第一层输出进第二层前包 torch.relu:
def forward(x):
z1 = x @ W1 + b1
h = torch.relu(z1)
return h @ W2 + b2
同样数据、同样种子、同样初始参数、同样学习率、同样步数。
step= 0 loss=0.8268 train_acc=0.281 val_acc=0.278
step= 500 loss=0.0589 train_acc=0.994 val_acc=0.995
step=1000 loss=0.0408 train_acc=0.996 val_acc=0.995
step=1500 loss=0.0327 train_acc=0.997 val_acc=0.995
step=2000 loss=0.0279 train_acc=0.998 val_acc=0.995
留出数据 99.5%。仿射前任完全表示不了异或规则,非线性模型能。稠密线性搜给出这个训练样本上约 64% 的经验参照;重要区别不是 64% 是精确天花板,而是仿射函数类表达不了要的边界。
精确说这证明了什么,因为这种结果最招草率总结。它没说明 ReLU 是最好的激活,没说明非线性让优化更容易,没说明越深越好。它说明的更窄更有用:
不加非线性堆仿射变换不扩大函数类:复合塌成另一个仿射变换。非线性激活阻止代数塌缩,让更多层表示单仿射映射表示不了的函数。
torch.relu(z) 是逐元素 max(z, 0)。它不是仿射,不与矩阵乘法交换,所以 relu(X @ W1 + b1) @ W2 + b2 化简不了。每个隐 ReLU 单元沿其预激活过零的边界引入潜在折线。十六个隐单元最多十六条这种边界,虽然有的重合、有的落在数据区外、有的经第二层后无贡献。这个组合是分段线性,分段够多的分段线性能描出对角象限的边界。
上面运行还有一处值得注意,关乎本章剩下部分。失败模型的损失也降了。降了三分之一,单调,和能跑的模型一模一样。损失曲线没区分两种情形。留出精度说明模型表现差,稠密线性搜帮我们说这个差与仿射模型的局限一致。
参数就是模型
开篇程序修好了。还没建出来。现在从底故意建一遍,每行连回解释它的章节。
从系统里训练循环唯一允许改的东西开始。
D_in, H, C = 2, 16, 2
torch.manual_seed(1)
W1 = (torch.randn(D_in, H) / math.sqrt(D_in)).requires_grad_()
b1 = torch.zeros(H, requires_grad=True)
W2 = (torch.randn(H, C) / math.sqrt(H)).requires_grad_()
b2 = torch.zeros(C, requires_grad=True)
parameters = [W1, b1, W2, b2]
for name, p in zip(["W1", "b1", "W2", "b2"], parameters):
print(f"{name:3s} shape={str(tuple(p.shape)):9s} numel={p.numel():3d} "
f"requires_grad={p.requires_grad} is_leaf={p.is_leaf} grad_fn={p.grad_fn}")
print("total trainable numbers:", sum(p.numel() for p in parameters))
W1 shape=(2, 16) numel= 32 requires_grad=True is_leaf=True grad_fn=None
b1 shape=(16,) numel= 16 requires_grad=True is_leaf=True grad_fn=None
W2 shape=(16, 2) numel= 32 requires_grad=True is_leaf=True grad_fn=None
b2 shape=(2,) numel= 2 requires_grad=True is_leaf=True grad_fn=None
total trainable numbers: 82
这四个张量就是模型。没有别的对象。章标题问没有 nn.Module 时神经网络是什么,答案就是这个:排成四个张量的八十二个数,外加一个说如何与输入组合的函数。
第 2 章的纪律直接用。每轴有意思,PyTorch 不强制:
W1 (D_in, H) axis 0 indexes input features, axis 1 indexes hidden units
b1 (H,) one offset per hidden unit
W2 (H, C) axis 0 indexes hidden units, axis 1 indexes output classes
b2 (C,) one offset per class
W1[i, j] 读成输入特征 i 驱动隐单元 j 的强度。列 W1[:, j] 读成隐单元 j 的全部入权重向量。问同初始化单元为何保持相同就要这两种读法。
第 3 章的纪律也用,它是两行权重写法略别扭的原因。
悄悄不再是参数的初始化
这两行看起来是同样事的两种说法:
W1 = torch.randn(2, 16, requires_grad=True) / math.sqrt(2) # A
W1 = (torch.randn(2, 16) / math.sqrt(2)).requires_grad_() # B
不是。A 在 randn 输出上置 requires_grad=True,再除常量。除法是记录的算子,名字 W1 最终绑到记录算子的结果。B 先在普通张量上除完,再给成品 flag。
别信。第 3 章给过三个字段定案:
A = torch.randn(2, 16, requires_grad=True) / math.sqrt(2)
B = (torch.randn(2, 16) / math.sqrt(2)).requires_grad_()
for name, t in (("A", A), ("B", B)):
print(f"{name}: requires_grad={t.requires_grad} is_leaf={t.is_leaf} "
f"grad_fn={type(t.grad_fn).__name__ if t.grad_fn is not None else None}")
A: requires_grad=True is_leaf=False grad_fn=DivBackward0
B: requires_grad=True is_leaf=True grad_fn=None
A 需要梯度,这是人们检查的属性,不叶,这是手工管理参数要紧的属性。先预测后果再往下读。A 非叶,backward() 不填 A.grad——这是文档行为,不是 bug。A 带活的 grad_fn,每次前向的图里都有除法节点。
用错的 W1 建网跑起来:
torch.manual_seed(1)
W1 = torch.randn(D_in, H, requires_grad=True) / math.sqrt(D_in) # not a leaf
b1 = torch.zeros(H, requires_grad=True)
W2 = (torch.randn(H, C) / math.sqrt(H)).requires_grad_()
b2 = torch.zeros(C, requires_grad=True)
step= 0 loss=0.8268 train_acc=0.281 val_acc=0.278
RuntimeError: Trying to backward through the graph a second time (or directly
access saved tensors after they have already been freed). Saved intermediate
values of the graph are freed when you call .backward() or autograd.grad().
Specify retain_graph=True if you need to backward through the graph a second
time or ...
step 0 走完。step 1 抛,异常点的行与错误无关。这是第 3 章图生命周期的机制换了伪装:W1 是非叶,它的 DivBackward0 节点在循环外建了一次,每轮建的新图都终止在同一个复用节点。第一次 backward() 释放它。第二次发现没了。
报错信息里有建议,建议管用,指异常消失:
loss.backward(retain_graph=True)
step= 0 loss=0.8268 train_acc=0.281 val_acc=0.278
step= 100 loss=0.2695 train_acc=0.936 val_acc=0.950
step= 500 loss=0.3011 train_acc=0.836 val_acc=0.837
step=1000 loss=0.2988 train_acc=0.837 val_acc=0.850
step=2000 loss=0.2879 train_acc=0.842 val_acc=0.858
print("W1.grad is None:", W1.grad is None)
print("W1 unchanged after 2000 steps:", torch.equal(W1_before, W1.detach()))
W1.grad is None: True
W1 unchanged after 2000 steps: True
程序跑完,验证精度 86%,远超线性天花板到看起来像成功。W1 从没被训练。两千步保持随机初值,守卫更新循环每次因 p.grad is not None 为假悄悄跳过。真正在训的是 b1、W2、b2 搭在十六个冻结随机特征上,是真模型,只是不是想要的那个。
PyTorch 第一次读非叶 .grad 会发 UserWarning,那是这里诚实的信号。也容易淹没在训练输出里,且在检查处而不在创建处触发。
三点值得提炼,超出这行代码都成立。
第一是诊断动作:异常在 step 1 的 loss.backward() 抛,错误在循环前的参数创建行。第 2 章教找第一个错的张量而不是第一个不合法的算子;第 3 章教找通路断处而不是 .grad 缺失处。这里两者同时用。
第二是关于建议的修复。retain_graph=True 是真功能真有用,也完整消了症状。它还把响亮失败变成静默失败。报错信息的 remedy 治异常,不一定治意图。
第三是关于检查什么。requires_grad 全程 True。只有 is_leaf 区分两种情形,只有快照对比证明参数停了。
手工管理可训练状态,
requires_grad=True与is_leaf=True是两个独立要求。先建张量,再 flag。
nn.Parameter 的存在部分就是让这类错误难犯,第 5 章归它。现在我们自己管叶,所以必须知道叶是什么。
层是什么
参数到手,前向是三行张量算术。
def forward(x):
z1 = x @ W1 + b1 # (B, D_in) @ (D_in, H) -> (B, H)
h = torch.relu(z1) # (B, H)
return h @ W2 + b2 # (B, H) @ (H, C) -> (B, C)
全连接线性变换里没神秘东西:就是仿射算子 x @ W + b。PyTorch 稍后把它包成 nn.Linear。
不是每种神经网络层都仿射——ReLU、归一化、卷积、注意力与很多别的算子也叫层——这里有用的点更窄:这个线性层就是张量算术加可训练状态。在小 batch 上跟踪形状,与预测对照确认每步:
xb = X_train[:8]
z1 = xb @ W1
h = torch.relu(z1 + b1)
print("x ", tuple(xb.shape))
print("x @ W1 ", tuple(z1.shape))
print("+ b1 ", tuple((z1 + b1).shape), " b1 is", tuple(b1.shape))
print("relu ", tuple(h.shape))
print("h @ W2 ", tuple((h @ W2).shape))
print("+ b2 ", tuple((h @ W2 + b2).shape))
x (8, 2)
x @ W1 (8, 16)
+ b1 (8, 16) b1 is (16,)
relu (8, 16)
h @ W2 (8, 2)
+ b2 (8, 2)
两细节值得点名而不是悄悄吸收。
偏置广播。 z1 是 (8, 16) 而 b1 是 (16,)。第 2 章规则从右对齐并补前导 1,所以 b1 当 (1, 16) 沿 batch 扩展。每个样本收到同样十六个偏移,一隐单元一个。这就是想要的语义:偏置属于单元,不属于样本。
值得防的失败不是形状错,形状错会宣告。是形状合法含义错的偏置。按样本而不是按单元建偏移得到 (B, 1) 偏置,广播得一样欢:
print(tuple((torch.zeros(8, 16) + torch.zeros(8, 1)).shape))
(8, 16)
同样输出形状,完全不同的模型。两行断言不花钱,把含义钉住:
assert b1.shape == (H,)
assert z1.shape == (xb.shape[0], H)
batch 轴从不参与矩阵乘。 (B, D_in) @ (D_in, H) 在 D_in 上收缩,B 不动。输出每行只由输入对应行算出。batch 里样本在线性层不交互,这就是同样参数对 batch 8 与 batch 1600 都管用的原因。
一个方向,显式说出
我们写 W1 为 (in, out),用 x @ W1。PyTorch 的 nn.Linear 反过来存权重,为 (out, in),用 x @ weight.T。两种约定都对;没注意混用就是 (2, 16) 张量跑到期待 (16, 2) 的地方的原因。
等价性本章末尾数值验证,现在不断言。平时在不熟悉代码里读线性计算,值得问的永远同样五个:
权重的哪维是输入宽?
哪维是输出宽?
输入在左乘还是右乘?
有没有转置,转的是权重还是输入?
偏置什么形状,沿哪轴广播?
答出五个,任何代码库的线性层都读得了,包括助手凌晨三点方向写反产出的那种。
初始化决定哪些单元允许不同
torch.randn(D_in, H) / math.sqrt(D_in) 写了没证。本章模型第一次不止两三个参数,选择开始有值得推导的后果。
尺度为何是这个
隐单元 j 的预激活是输入特征求和:
z1[b, j] = sum over i of x[b, i] * W1[i, j] + b1[j]
输入大致单位方差、权重独立方差 s²,D_in 项求和方差约 D_in * s²。取 s = 1 / sqrt(D_in) 让乘积为一,预激活与输入同尺度到达,不会逐层变大变小。测一下:
with torch.no_grad():
z1 = X_train @ W1 + b1
h = torch.relu(z1)
logits = h @ W2 + b2
print("z1 std", round(z1.std().item(), 4), " mean", round(z1.mean().item(), 4))
print("h std", round(h.std().item(), 4),
" fraction exactly zero", round((h == 0).float().mean().item(), 4))
print("logits std", round(logits.std().item(), 4))
z1 std 0.9377 mean 0.0047
h std 0.5687 fraction exactly zero 0.4946
logits std 0.9424
第一层预测几乎正中:预测 1.0,观测 0.938。约一半 ReLU 输出精确零,预激活零附近居中、负的全砍掉就该这样。
第二层提醒这些是靠假设的近似。方差论证假设求和项大致独立,这里十六个隐单元都是同样两输入的函数,强相关。规则仍把 logits 放到 sane 尺度,但前提不成立时别指望算术精确。
尺度大错的后果现在好预期。第一层权重放得巨大,预激活与活下来的 ReLU 输出跟着大;后面层权重也 oversize,logits 巨大,模型以极端武断自信开局。log_softmax 本身为数值稳定设计,优化问题仍可能开在差的 regime。
权重压得过小,logits 挤在零附近,预测接近均匀。小网优化可能从两种选择恢复。层加深,坏尺度逐层复合,训练越来越难甚至失败。
PyTorch 自带层用同族的 fan-in 规则。nn.Linear 权重均匀取 ±1/sqrt(fan_in):
import torch.nn as nn
layer = nn.Linear(2, 16)
print("1/sqrt(fan_in) =", 1 / math.sqrt(2))
print("observed range:", layer.weight.min().item(), "to", layer.weight.max().item())
1/sqrt(fan_in) = 0.7071067811865475
observed range: -0.7010772228240967 to 0.6354132294654846
两规则都按 fan-in 缩放,但数值不等价。我们的正态初始化标准差 1/sqrt(fan_in),默认 nn.Linear 均匀界方差更小。共同思想是尺度取决于每单元多少输入,不在于两分布方差精确相等。
所以思想比菜谱重要。以后遇到 kaiming_normal_、xavier_uniform_ 之类的初始化器,是已见过的推理的变体,不是背的名字。
随机为何在那
尺度是容易的一半。决定隐层有十六个单元还是 effectively 一个的是这一半。
十六个隐单元全同初始化。入权重相同,出权重相同,两输出类保持可区分让梯度不平凡为零:
W1 = torch.full((D_in, H), 0.5, requires_grad=True)
b1 = torch.zeros(H, requires_grad=True)
W2 = torch.tensor([[0.25, -0.25]]).repeat(H, 1).requires_grad_()
b2 = torch.zeros(C, requires_grad=True)
训练前先反向一次,看梯度的结构而不是大小:
loss = cross_entropy(forward(X_train), y_train)
loss.backward()
print("W1.grad columns all identical:", bool((W1.grad == W1.grad[:, :1]).all()))
print("W1.grad[:, :3] =", W1.grad[:, :3].tolist())
print("b1.grad[:3] =", b1.grad[:3].tolist())
print("W2.grad rows all identical: ", bool((W2.grad == W2.grad[:1]).all()))
W1.grad columns all identical: True
W1.grad[:, :3] = [[0.04355235, 0.04355235, 0.04355235],
[0.03529285, 0.03529285, 0.03529285]]
b1.grad[:3] = [0.10046272, 0.10046272, 0.10046272]
W2.grad rows all identical: True
这由链式法则跟出,不跑也能预测。到达隐单元 j 的梯度依赖出权重 W2[j, :],跨 j 相同。流入 W1[:, j] 的梯度依赖该入信号与共享的输入。所以每单元收到完全相同的梯度。相同初值加相同梯度加相同更新规则意味着步后值相同,每步重复。
训两千步看预测成立否:
step= 0 loss=1.0926 train_acc=0.493 val_acc=0.512
step= 100 loss=0.6447 train_acc=0.606 val_acc=0.610
step= 500 loss=0.6436 train_acc=0.609 val_acc=0.600
step=2000 loss=0.6436 train_acc=0.611 val_acc=0.603
print("distinct columns of W1:", torch.unique(W1.detach(), dim=1).shape[1])
print("W1[:, :3] =", W1.detach()[:, :3].tolist())
with torch.no_grad():
h = torch.relu(X_train @ W1 + b1)
print("distinct hidden activation columns:", torch.unique(h, dim=1).shape[1])
distinct columns of W1: 1
W1[:, :3] = [[0.38603309, 0.38603309, 0.38603309],
[0.39404541, 0.39404541, 0.39404541]]
distinct hidden activation columns: 1
十六个隐单元,两千更新后逐比特相同的单一隐函数。参数动了,梯度全程有限非零,损失降了——但名义十六单元层塌到单个隐 ReLU 单元的表达多样性。
它约 60% 精度恰好落在该数据集仿射参照附近,但模型本身不是仿射。诊断证据是对称:十六个名义单元仍在算一个隐特征。
两限定让这不成口号。
对称要两边都成立才持久。W1 随机而 W2 常数,单元立刻算不同函数,收到不同梯度,网正常训到 99.5%。一处不对称就够。
零也不是自动致命,看在哪。我们能跑的版本偏置全零起步。坏的是把权重置常数。网里所有权重偏置全零,失败彻底但完全可解释:
step= 0 loss=0.6931 train_acc=0.493 val_acc=0.512
step= 100 loss=0.6931 train_acc=0.507 val_acc=0.488
step=2000 loss=0.6931 train_acc=0.507 val_acc=0.488
for name, p in zip(["W1", "b1", "W2", "b2"], parameters):
print(f"{name}.grad norm = {p.grad.norm().item():.6f}")
print("b2.grad =", b2.grad.tolist())
print("class 1 fraction in train:", y_train.float().mean().item())
W1.grad norm = 0.000000
b1.grad norm = 0.000000
W2.grad norm = 0.000000
b2.grad norm = 0.009723
b2.grad = [0.00687499949708581, -0.00687499949708581]
class 1 fraction in train: 0.5068749785423279
W2 为零,隐层下游传不回信号,W1、b1、W2 梯度精确零。只有 b2 有东西,梯度 0.5 − 0.50687 = −0.00687,正是均匀预测与类别频率之差。模型只训一样:base rate。训练精度 0.507、验证 0.488 就是两类频率。实现没坏。初始化把隐部分放在梯度信号精确零的对称态。梯度下降还能调 b2,全参数向量初始不停;它学类别 base rate,隐表示冻住。
b2 到最优常数预测后,从这个对称态出发剩下的可训练方向没有能把隐单元拆开的梯度信号。
初始化不只选起始数。它能决定有用梯度信号到不到得了特定参数,名义不同的单元起步有没有变不同的机会。
目标:logits、log-softmax 与交叉熵算什么
前向止于 (B, C)。每行两个未归一化分数。那是 logits:任意尺度的实数,只有同行条目之差有意义,整行加常数 softmax 不变。
logits 到类别下标目标的损失走四步:
logits (B, C) arbitrary real scores
↓ log_softmax over dim=1
log probabilities (B, C) each row sums to 1 after exponentiation
↓ select the entry at the target index
per-example score (B,) log probability assigned to the correct class
↓ negate and mean
loss scalar
展开写,每行注释:
def cross_entropy(logits, targets):
log_probs = torch.log_softmax(logits, dim=1) # (B, C)
rows = torch.arange(targets.shape[0], device=logits.device)
picked = log_probs[rows, targets]
return -picked.mean() # scalar
索引行值得慢读。torch.arange(B) 是 [0, 1, 2, ...],targets 是 (B,) 类别下标,两者配对从第 b 行取 targets[b] 元:两轴同时高级索引。这个手写版假设类别下标目标,targets 须是形状 (B,) 的整数类别下标。PyTorch 完整 cross_entropy API 还支持不同形状 dtype 的概率目标,那是与这里实现的不同的契约。
与可信实现对过
手写机制的目的不是用自己的版本。是为了有东西可比。
import torch.nn.functional as F
logits = forward(X_train)
mine = cross_entropy(logits, y_train)
theirs = F.cross_entropy(logits, y_train)
print("manual:", mine.item())
print("F.cross_entropy:", theirs.item())
print("allclose:", torch.allclose(mine, theirs))
manual: 0.8267903327941895
F.cross_entropy: 0.8267903327941895
allclose: True
值相等是好证据、不完全证据。训练真正吃的是梯度,两公式值同意、求导方式可能不同。梯度也比:
g_mine = torch.autograd.grad(cross_entropy(forward(X_train), y_train), parameters)
g_theirs = torch.autograd.grad(F.cross_entropy(forward(X_train), y_train), parameters)
for name, a, b in zip(["W1", "b1", "W2", "b2"], g_mine, g_theirs):
print(f"{name}: max abs difference = {(a - b).abs().max().item():.3e} "
f"allclose = {torch.allclose(a, b)}")
W1: max abs difference = 0.000e+00 allclose = True
b1: max abs difference = 0.000e+00 allclose = True
W2: max abs difference = 0.000e+00 allclose = True
b2: max abs difference = 0.000e+00 allclose = True
这次运行值与梯度精确同意。重要主张是数值等价,不是跨设备、核与 PyTorch 版本保证逐比特相同,这就是 allclose 才是通用对检查的原因。这个习惯值得养成:
为理解重实现框架机制时,两边推导同一量并比数字。值与梯度都比,因为那是两个独立断言。
为什么用 log_softmax 而不是定义
教科书公式是 -log(p[target]),p = exp(logits) / exp(logits).sum()。照字面实现:
def naive_cross_entropy(logits, targets):
probs = logits.exp() / logits.exp().sum(dim=1, keepdim=True)
return -probs[torch.arange(targets.shape[0]), targets].log().mean()
big = torch.tensor([[100.0, 200.0], [1.0, 2.0]])
t = torch.tensor([1, 0])
print("naive: ", naive_cross_entropy(big, t).item())
print("stable:", cross_entropy(big, t).item())
print("torch: ", F.cross_entropy(big, t).item())
naive: nan
stable: 0.65663081407547
torch: 0.65663081407547
exp(200) 上溢 float32 到 inf,无穷比无穷得 nan。同样量可用 log-sum-exp 恒等式稳定算:先按行最大平移 logits 再指数,代数补回平移。torch.log_softmax 提供稳定 fused 算子,避免天真实现里 exp(200) 炸掉。logits 到 200 不 exotic;稍大的初始化或 briefly overshoot 的学习率就产出它们。第 11 章系统处理非有限值。这里知道稳定写法不是风格偏好就够。
把概率传到 logits 的位置
这是生成分类器代码最常见的错之一:
probs = torch.softmax(logits, dim=1)
loss = F.cross_entropy(probs, targets)
合法。形状对,dtype 对,不警告。接下来发生的事比“坏了”有意思。
F.cross_entropy 对交到手的东西施 log_softmax。给概率,它再 softmax 一次。看一个样本:
logits = torch.tensor([[2.0, -1.0]])
t = torch.tensor([0])
probs = torch.softmax(logits, dim=1)
print("logits:", logits.tolist(), " probs:", [round(v, 4) for v in probs[0].tolist()])
print("cross_entropy(logits, t) =", F.cross_entropy(logits, t).item())
print("cross_entropy(probs, t) =", F.cross_entropy(probs, t).item())
logits: [[2.0, -1.0]] probs: [0.9526, 0.0474]
cross_entropy(logits, t) = 0.04858732968568802
cross_entropy(probs, t) = 0.33966848254203796
模型很自信且对,proper 损失报 0.049。错的版本报 0.340。原因结构性:概率住 [0, 1],一行两条目之差永远超不过 1,模型再确定也一样。当 logits 用,最大差 1 给出最小可达损失
-log(sigmoid(1)) = log(1 + e⁻¹) ≈ 0.3133
用概率自信到顶验证 floor 真实:
perfect = torch.tensor([[0.0, 1.0], [1.0, 0.0]])
print("CE of perfectly confident probabilities:", F.cross_entropy(perfect, torch.tensor([1, 0])).item())
print("CE of perfectly confident logits: ",
F.cross_entropy(torch.tensor([[-20., 20.], [20., -20.]]), torch.tensor([1, 0])).item())
CE of perfectly confident probabilities: 0.31326165795326233
CE of perfectly confident logits: 0.0
现在带着这个错误训能跑的网,同时记报告损失与本该报告的损失:
step= 0 reported_loss=0.7157 loss_on_logits=0.8268 train_acc=0.281 val_acc=0.278
step= 100 reported_loss=0.4406 loss_on_logits=0.2341 train_acc=0.931 val_acc=0.942
step= 500 reported_loss=0.3582 loss_on_logits=0.0811 train_acc=0.993 val_acc=0.995
step=1000 reported_loss=0.3443 loss_on_logits=0.0561 train_acc=0.995 val_acc=0.995
step=2000 reported_loss=0.3347 loss_on_logits=0.0386 train_acc=0.996 val_acc=0.995
step=4000 reported_loss=0.3278 loss_on_logits=0.0263 train_acc=0.998 val_acc=0.995
这个模型还学。softmax 保 logits 排序,argmax 预测类不变。新目标仍奖励目标类相对别的类升高,优化能提高分类精度。
但多余 softmax 改了梯度的尺度与几何。这个实验收敛变慢:step 100 正确目标已到 0.1395,错跑里 logits 上的对应损失还在 0.2341。
被明确毁掉的是损失作为测量。它单调降向 0.3278,模型再好也过不了 0.3133。读这条曲线说模型不进步了,是在读错误的 artifact。拿这个数与发表的交叉熵基线比,是在比不可比的量。
所以诚实的陈述比常用警告更窄更有用:
F.cross_entropy期待 logits,因为它内部施log_softmax。传概率不一定阻止学习;它悄悄换了目标,让报告损失不可比且有 floor。“损失降了”不是损失 formulations 对的证据。
要概率就在损失外为观察算:
with torch.no_grad():
probabilities = torch.softmax(forward(X_val), dim=1)
反向,然后是更新,更新不是反向
梯度步是第 1 章已教的部分,要的解释少,一处专门警告。
loss.backward()
这一调从标量损失经第二矩阵乘、ReLU、第一矩阵乘与两偏置加走回图,在四叶累积。我们写了前向算;PyTorch 推了反向算。每个参数的梯度与参数同形状,值得确认一次,因为这是最快的 sanity 检查:
W1.grad (2, 16) b1.grad (16,) W2.grad (16, 2) b2.grad (2,)
然后更新,原地,在图外:
with torch.no_grad():
for p in parameters:
p -= learning_rate * p.grad
torch.no_grad() 在那是因为优化器参数更新不是我们要 autograd 微分的函数的一部分。普通 grad 模式里,PyTorch 拒绝这个对需要梯度叶张量的特定原地更新。
no_grad() 里减法没进 autograd 图,已有叶张量可原地更新,同时仍是以后前向用的可训练对象。
跑了却什么都没改的更新
第 1 章在双参数模型见过重绑定更新,答应真正危险处回来。就是这里。参数放列表里循环更新,写 p = p - lr * p.grad 而不是 p -= lr * p.grad:
with torch.no_grad():
for p in parameters:
p = p - learning_rate * p.grad # rebinding, not in-place
step= 0 loss=0.8268 train_acc=0.281 val_acc=0.278
step= 100 loss=0.8268 train_acc=0.281 val_acc=0.278
step= 500 loss=0.8268 train_acc=0.281 val_acc=0.278
永远不异常。第 1 章单变量版重绑定至少下轮 RuntimeError,因为名字 w 被重绑到不再要梯度的张量。这里不能。p 是循环变量;重绑它只改变这轮剩下时间 p 指向什么,别无其他。列表仍握着原来四个张量,下次前向读它们,从没被碰。新张量立刻丢掉。
损失逐 step 逐比特相同,是状态可能没变的强证据,值得立刻检查。不是证明:真更新可以为零、走平坦方向、小到显示精度看不出。
决定性测量是参数快照。显式收集证据:
before = [p.detach().clone() for p in parameters]
# ... run the loop with the rebinding update ...
print("grad norms:", [round(p.grad.norm().item(), 4) for p in parameters])
print("max movement:", [(p.detach() - old).abs().max().item()
for p, old in zip(parameters, before)])
grad norms: [0.2437, 0.1834, 0.623, 0.231]
max movement: [0.0, 0.0, 0.0, 0.0]
四参数梯度健康非零。四参数移动全零。这就是本书反复回来的区分,最锋利的形式:
填满的
.grad是关于反向的证据。变了的参数是关于更新的证据。不同断言,确立一个不确立另一个。
分开它们的检查两行,该进反射:
before = [p.detach().clone() for p in parameters]
with torch.no_grad():
for p in parameters:
p -= learning_rate * p.grad
for name, p, old in zip(["W1", "b1", "W2", "b2"], parameters, before):
observed = p.detach() - old
predicted = -learning_rate * p.grad
print(f"{name}: max|observed - predicted| = {(observed - predicted).abs().max().item():.3e} "
f"max|movement| = {observed.abs().max().item():.4f}")
W1: max|observed - predicted| = 5.751e-08 max|movement| = 0.0657
b1: max|observed - predicted| = 0.000e+00 max|movement| = 0.0637
W2: max|observed - predicted| = 2.608e-08 max|movement| = 0.1159
b2: max|observed - predicted| = 0.000e+00 max|movement| = 0.0817
这不只确认动了。它确认每个参数按更新规则说的量动,float32 精度。朴素梯度下降预测移动 -lr * grad;带动量或逐参数缩放的优化器不是,检查时知道对照的是哪条规则是检查的一部分。
最后梯度清零。第 1 章机制细讲过——backward() 加到 .grad 而不是赋值——这里只要放哪一句。我们在 backward() 前清:
for p in parameters:
if p.grad is not None:
p.grad.zero_()
loss.backward()
梯度须在下一次要独立解释结果的 backward() 前清。常见两放法:backward() 紧前,如这里;或参数更新紧后。backward() 后更新前清会擦掉更新要的梯度。
is not None 守卫存在因为新叶第一次反向前没有 .grad。守卫也如非叶初始化所见,能藏住从没收到梯度的参数。是方便,不是检查。
完整程序
全装起来,带留出评估:
import math
import torch
torch.manual_seed(0)
n = 2000
X = torch.randn(n, 2)
y = ((X[:, 0] > 0) ^ (X[:, 1] > 0)).long()
perm = torch.randperm(n)
n_train = int(0.8 * n)
X_train, y_train = X[perm[:n_train]], y[perm[:n_train]]
X_val, y_val = X[perm[n_train:]], y[perm[n_train:]]
D_in, H, C = 2, 16, 2
torch.manual_seed(1)
W1 = (torch.randn(D_in, H) / math.sqrt(D_in)).requires_grad_()
b1 = torch.zeros(H, requires_grad=True)
W2 = (torch.randn(H, C) / math.sqrt(H)).requires_grad_()
b2 = torch.zeros(C, requires_grad=True)
parameters = [W1, b1, W2, b2]
def forward(x):
z1 = x @ W1 + b1
h = torch.relu(z1)
return h @ W2 + b2
def cross_entropy(logits, targets):
log_probs = torch.log_softmax(logits, dim=1)
picked = log_probs[torch.arange(targets.shape[0]), targets]
return -picked.mean()
def accuracy(logits, targets):
return (logits.argmax(dim=1) == targets).float().mean().item()
learning_rate = 0.5
for step in range(2001):
logits = forward(X_train)
loss = cross_entropy(logits, y_train)
if step % 500 == 0:
with torch.no_grad():
val_logits = forward(X_val)
print(f"step={step:4d} loss={loss.item():.4f} "
f"train_acc={accuracy(logits, y_train):.3f} "
f"val_loss={cross_entropy(val_logits, y_val).item():.4f} "
f"val_acc={accuracy(val_logits, y_val):.3f}")
for p in parameters:
if p.grad is not None:
p.grad.zero_()
loss.backward()
with torch.no_grad():
for p in parameters:
p -= learning_rate * p.grad
step= 0 loss=0.8268 train_acc=0.281 val_loss=0.8097 val_acc=0.278
step= 500 loss=0.0589 train_acc=0.994 val_loss=0.0511 val_acc=0.995
step=1000 loss=0.0408 train_acc=0.996 val_loss=0.0335 val_acc=0.995
step=1500 loss=0.0327 train_acc=0.997 val_loss=0.0262 val_acc=0.995
step=2000 loss=0.0279 train_acc=0.998 val_loss=0.0221 val_acc=0.995
四十行,无框架抽象,四百个更新步从没碰的样本上 99.5%。
验证划分在做真活,干的活与训练损失不同。第 1 章展示模型把训练损失干到精确零而没见过的地方全错。两列答两个问题:
falling training loss → the optimizer is reducing the objective it was given
held-out accuracy → the model behaves correctly on data it was not fitted to
这次两边同意,是无聊情形。有意思的是分歧的情形,不测的分歧注意不到。第 14 章把留出评估变成正经纪律;眼下单个精度数够用。
一处故意省略:这里每步全批量训练,梯度是训练集目标的精确梯度。真实训练用 mini-batch,每步是噪声估计,优化性格改变。机制不变——同样前向、同样反向、同样更新——第 6 章建供给这些 batch 的数据流水线。
六个问题与回答它们的证据
本章产出五个不同失败。排起来看,除了程序能跑几乎没共同点。
| 什么错了 | 损失行为 | 张量说什么 |
|---|---|---|
| 无激活 | 降了,然后 plateau 在 0.6928 | 全叶,梯度有限,参数在动 |
非叶 W1 |
降到 0.29,精度看似合理 | W1.grad is None,W1 从没变 |
| 对称初始化 | 降了,plateau 在 0.6436 | 隐单元梯度全同 |
| 零初始化 | 平在 0.6931 | 除 b2 全梯度零 |
| 重绑定更新 | 每步逐比特相同 | 梯度健康,移动精确零 |
没有单检查抓住五个,所以“检查梯度”不是调试策略。能推广的是知道某份证据回答哪个问题。六个问题,前三章的工具只给其中三个。
表示(Representation)。 结构能不能表达该函数?证据可来自模型类的代数论证、已知表示界、仿射可加残差之类的证伪探针、与故意更简单的基线对比。开篇失败正栽在这问:健康的张量梯度本身不确立结构能表示要的函数。
计算(Computation)。 前向算的是你以为的结构吗?证据:形状跟踪、中间张量断言、与同一函数的独立实现对比。
目标(Objective)。 损失编码了想要的吗,吃的是它期待的那种值吗?证据:与可信实现在值与梯度上对比,检查传进去的东西的范围与含义。logits 还是概率,类别下标还是 one-hot,sum 还是 mean。
微分(Differentiation)。 想训的每参数到损失有通路吗?证据:第 3 章的 requires_grad、is_leaf、grad_fn、.grad 与可达检查。
更新(Update)。 那些参数真变了吗?证据:改前快照改后比,按更新规则预测移动来核对。
评估(Evaluation)。 测的是在乎的行为吗?证据:留出表现与行为局限都理解的恰当基线。
这个小问题上表示与目标出奇便宜查,所以是 sensible 起点。大系统里每检查代价不同。比通用顺序重要的是知道某份证据到底支撑六断言里哪个、哪几个完全没碰。但真正价值不是顺序。是看到一份证据能说出它支撑六个里哪个、哪几个完全悬空。
“梯度看起来没问题”只回答这六问之一。
同样的网,用 PyTorch 拼写
现在揭晓。这是我们模型的 idiomatic PyTorch:
import torch.nn as nn
model = nn.Sequential(
nn.Linear(2, 16),
nn.ReLU(),
nn.Linear(16, 2),
)
大多数教程从这里开始,正是我们已建的东西。证明而不是断言。把我们的参数拷进模块,记住方向差,输出与梯度都比:
model = nn.Sequential(nn.Linear(2, H), nn.ReLU(), nn.Linear(H, C))
with torch.no_grad():
model[0].weight.copy_(W1.T)
model[0].bias.copy_(b1)
model[2].weight.copy_(W2.T)
model[2].bias.copy_(b2)
manual_logits = torch.relu(X_train @ W1 + b1) @ W2 + b2
module_logits = model(X_train)
print("logits max abs difference:", (manual_logits - module_logits).abs().max().item())
loss_manual = F.cross_entropy(manual_logits, y_train)
loss_module = F.cross_entropy(module_logits, y_train)
g_manual = torch.autograd.grad(loss_manual, [W1, b1, W2, b2])
g_module = torch.autograd.grad(
loss_module,
[model[0].weight, model[0].bias, model[2].weight, model[2].bias],
)
print("dL/dW1 vs dL/d(fc1.weight).T:", (g_manual[0] - g_module[0].T).abs().max().item())
print("dL/db1 vs dL/d(fc1.bias) :", (g_manual[1] - g_module[1]).abs().max().item())
print("dL/dW2 vs dL/d(fc2.weight).T:", (g_manual[2] - g_module[2].T).abs().max().item())
print("dL/db2 vs dL/d(fc2.bias) :", (g_manual[3] - g_module[3]).abs().max().item())
logits max abs difference: 0.0
dL/dW1 vs dL/d(fc1.weight).T: 0.0
dL/db1 vs dL/d(fc1.bias) : 0.0
dL/dW2 vs dL/d(fc2.weight).T: 0.0
dL/db2 vs dL/d(fc2.bias) : 0.0
不是接近。输出与四梯度逐元相同。nn.Linear 与 nn.Sequential 算的东西我们没算过的没有。
唯一实质区别是转置,现在直接确认:
layer = nn.Linear(2, 16)
xb = torch.randn(8, 2)
print("weight shape:", tuple(layer.weight.shape))
print("layer(x) == x @ weight.T + bias:",
torch.allclose(layer(xb), xb @ layer.weight.T + layer.bias))
weight shape: (16, 2)
layer(x) == x @ weight.T + bias: True
nn.Linear(in, out) 权重存 (out, in),算 x @ weight.T + bias。我们存 (in, out) 算 x @ W + b。同样函数,不同存储约定,形状对不上时现在知道在看哪个。
优化器是第二块包装:
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)
optimizer.zero_grad()
logits = model(X_train)
loss = F.cross_entropy(logits, y_train)
loss.backward()
optimizer.step()
loss.backward() 不变,仍做微分。optimizer.step() 读 backward() 填的 .grad 字段,对构造时给的参数施更新规则。正是我们手写的两个独立操作,这就是“梯度存在”与“参数动了”的区分搬进框架后还在。甚至更容易错,因为构造时参数列表给错,backward() 照常填梯度而优化器悄悄什么都不更新。
两拼写对齐:
MANUAL PYTORCH
W1, b1 nn.Linear(2, 16) weight stored as (out, in)
torch.relu(...) nn.ReLU() / F.relu
W2, b2 nn.Linear(16, 2)
def forward(x): ... Module.forward(self, x)
parameters = [W1, b1, W2, b2] model.parameters()
p -= lr * p.grad optimizer.step()
clear/reset parameter gradients optimizer.zero_grad()
manual cross_entropy(...) F.cross_entropy(...)
右边每项都是左边机制的名字。右列算的东西左列没算过的没有。
右列买的是箭头另一边:左列名单手维护。加第三层就多写两张量,加进 parameters,加进更新循环,加进设备移动,加进存档字典,每处都是忘一处的地方。model.parameters() 省掉手工维护名单——前提是参数与子模块被正确注册。框架能可靠走已注册结构;第 5 章讲什么算已注册结构,普通 Python 容器怎么掉出去。
怎么知道是第 5 章,听起来比实际好。self.something 赋值不让它成参数。模块放普通 Python 列表不注册。parameters()、state_dict()、.to(device)、.eval() 发现什么的规则都从一个组织思想跟出,PyTorch bug 里特别 nasty 的一类是参数存在、参与计算、收到梯度,同时对期待管理它的某框架机器不可见。
现在理解那个失败位置正好,因为被注册的东西我们手建过。
在没写过的网上用 AI
本章失败助手也容易产出或漏掉,原因与人漏掉一样:代码看起来 plausible。两 nn.Linear 间漏 nn.ReLU() 读成普通双层网。F.cross_entropy 前 torch.softmax 读成仔细。问“对吗”,常常得到流利的论证说它对。
管用的动作是前三章那个:先让它对具体程序做出可检查的断言,再允许它改任何东西。
Here is a small PyTorch network built from raw tensors. Do not rewrite it and
do not propose a fix yet.
First, for every trainable tensor:
- its symbolic shape, and what each axis indexes;
- the path from that tensor to the loss;
- whether .grad should be populated after backward(), and why;
- which statement in the update should change it.
Then answer these four separately:
1. What is the set of functions this architecture can express? Specifically,
is the composed forward pass affine in the input, and how would I test that
empirically without reading the source?
2. Does the forward computation match the architecture the code appears to
intend?
3. What does the loss expect as input — logits, probabilities, class indices,
one-hot targets — and what is it actually being given?
4. Give me three measurements that would distinguish "this architecture cannot
represent the task" from "the training loop is broken". For each, say what
result would support which conclusion.
Give me the code for those measurements. I will run them and tell you what I see.
最后一行改变交互。让助手修代码,它产出修复;让它产出判别实验,它产出能跑的东西,跑了要么确认它对程序的模型,要么精确暴露它的模型错在哪。两种结局都比重写值钱。
问题 1 故意放第一。它是第 1–3 章工具回答不了的问题,两行算术答得了,在碰超参数前排除或确认整个解释分支。
让助手先刻画系统,再让它替换系统。
你现在应该能回答什么
这里有会被递到手里的网。它能跑。先自己走一遍再看答案。
import torch
import torch.nn.functional as F
W1 = torch.randn(4, 32, requires_grad=True) * 0.05
b1 = torch.zeros(32, requires_grad=True)
W2 = (torch.randn(32, 3) * 0.05).requires_grad_()
b2 = torch.zeros(3, requires_grad=True)
params = [W1, b1, W2, b2]
def forward(x):
h = torch.relu(x @ W1 + b1)
return h @ W2 + b2
def loss_fn(logits, targets):
return F.cross_entropy(torch.softmax(logits, dim=1), targets)
for step in range(1000):
loss = loss_fn(forward(X), y)
for p in params:
if p.grad is not None:
p.grad.zero_()
loss.backward(retain_graph=True)
with torch.no_grad():
for p in params:
if p.grad is not None:
p -= 0.01 * p.grad
模型的可训练值是什么,多少个数? W1、b1、W2、b2:4×32 + 32 + 32×3 + 3 = 259 个数。输入四特征,隐层三十二单元,三类。
每张量为何是这个形状? W1 是 (in, out) 因为代码 x @ W1,axis 0 必须对输入宽,axis 1 定义隐宽。b1 是 (32,),一隐单元一偏移,跨 batch 广播。W2 把三十二隐单元映到三类。b2 一类一偏移。注意 nn.Linear 会转置存这些。
哪些张量是叶? b1、W2、b2。W1 不是:requires_grad=True 施在乘 0.05 之前,所以 W1 是记录的 MulBackward0 的输出。用 W1.is_leaf 查。
哪些 .grad 字段会被填? b1.grad、W2.grad、b2.grad。W1.grad 保持 None,非叶不留梯度。读它发 UserWarning。
哪些参数真会变? 只那三个。W1 一千步保持初始随机值,if p.grad is not None 守卫悄悄跳过它。模型在三十二个冻结随机特征上训分类器。
retain_graph=True 在那干什么? 盖住上一个答案。因为 W1 是循环外建的非叶,它的 MulBackward0 节点被每轮图共享,不带 retain_graph 第二次 backward() 就抛。flag 消了异常;没让 W1 可训练。
这结构能表示非线性边界吗? 能。两仿射映射间有 ReLU,复合不是仿射。用可加残差确认而不是读代码。
损失收到期待的东西吗? 没有。F.cross_entropy 内部施 log_softmax,传 torch.softmax(logits, dim=1) 就是 softmax 两次。训练可能还走,但报告损失有 floor、和别的交叉熵数不可比。floor 依赖类别数。C 类时,预测概率向量逼 one-hot 的极限给出 floor log(1 + (C-1)/e),两类约 0.313,三类约 0.551。
先检查什么? 不是学习率。按顺序:复合前向仿射吗(表示),损失吃 logits 吗(目标),每预期参数 .grad 填了吗(微分),每预期参数动了吗(更新)。这里四个错三个,没一个是超参数。
怎么验证修复? 说出量并观察。把 W1 建成 (torch.randn(4, 32) * 0.05).requires_grad_() 后:W1.is_leaf 是 True,backward() 后 W1.grad 被填,快照显示 W1 按 -lr * W1.grad 移动,retain_graph=True 去掉不抛。去掉 softmax 后,报告损失不再受概率当 logits 的 floor 限制。这个三类例子极限 floor 约 0.551,不是 0.313。再把修好的目标与手写 log_softmax 实现在值与梯度上都对过。
练习
这些是用来跑的,对应本章配套 notebook。
-
两边证明塌缩。 对无激活的网,算
W_eq = W1 @ W2与b_eq = b1 @ W2 + b2并确认 logits 一致。再扩到三线性层,先推导等价单仿射映射再检查。最后对三个网与带 ReLU 版都跑affine_residual,解释看不到参数时更想要哪个测试。 -
建独立线性参照。 用稠密网格搜在异或训练数据上找它发现的最优线性边界,再训单层模型(只
X @ W + b)看优化逼参照多近。 -
数折线。 用
H = 1, 2, 3, 4, 8, 16训 ReLU 网,记每种验证精度。跑之前预测原则上分开四象限最小隐尺寸。再每尺寸跑五种子,报告 spread 而不是单数——固定种子结果对H不单调,弄清为什么这不矛盾才是真练习。最后画最优模型的决策区,数线性块。 -
让手工损失不一致。 写用
sum()代替mean()的cross_entropy版,和用 one-hot 乘代替高级索引的版。每个与F.cross_entropy比值与梯度并解释差异。再用sum()版同样学习率训练并解释发生的事。 -
定位 floor。 推导
C = 2、C = 3、C = 10类时F.cross_entropy(probs, targets)的最小可达值,再用最大自信概率向量逐个实证确认。解释 floor 为什么依赖类别数。 -
用一个数打破对称。 从全对称初始化出发,只扰动隐单元 0 相关的一个元。
W1里做一次,W2里做一次。 -
两种失败,几乎同样症状。 对比无激活网与全零初始化非线性网。都落在
log 2附近,原因完全不同。 -
验证没用过的层。 挑没用过的层——
nn.Bilinear、nn.Embedding或nn.Conv1d——读它的文档形状契约,用原始张量算子实现前向,与真层在随机输入上比输出与梯度。报告最大差异并解释。 -
审计生成的网。 让助手要一个原始张量写的小分类器,跑代码前对它做完整六问审计:表示、计算、目标、微分、更新、评估。记下哪些问题靠读答得了,哪些要测量。
下一步:框架在组织什么
现在有了无框架抽象的完整学习系统。四张量是模型。函数把它们与输入组合。损失把输出缩成标量。backward() 对记录的计算求导。原地更新改叶。那张表的每项都是第 1–3 章的机制,规模稍大。
还有前几章给不了的东西:区分坏的实现与正确但不能的实现。这个区分把有用调试与一下午学习率轮盘分开,模型越大越值钱,因为大模型给两种问题藏身的地方都多。
还没有的是规模化管理办法。四参数的手维护列表还行。四百不行,失败模式也不 interesting:更新循环漏一张量,设备移动漏一个,存档存了四权重之三。那些是记账错,记账正该框架吸收。
下一章引入 nn.Module,它不是新机器。它是组织张量、叶与梯度的方式,我们已经手建过, resting 在一个思想上:对象包含对象,PyTorch 会走这个结构。它回答的每个问题都是我们刚以手工形式见过的。为什么 model.parameters() 找到埋四层深的权重?为什么 model.to("cuda") 搬了没点名的张量?为什么放普通 Python 列表的模块从 state_dict() 悄悄消失?
你已经知道网是什么。接下来看框架对它做了什么。
递归组合。