张量:循环里真正流动的是什么?
让张量行为可检查:运行前先推导形状,说清每个轴的语义,跟踪广播、归约、重塑、步长、dtype 与设备,找到观测结构第一次偏离契约的张量。
第 1 章最后一个程序在四个样本上训练了双参数模型。它能跑,我们把它读成关于梯度的故事:预测,度量,求导,走步。但其中有东西没被检查。w 是一个数,x 装着四个数,w * x + b 在没人说明标量与四元向量该如何结合的情况下产出四个预测。PyTorch 有规则,我们从没说出它。
这为什么重要。把同一个循环改一处。目标现在以列而不是行的形式到来,这正是它们从表格列、DataLoader 或每个样本输出一个值的模型里出来时的样子:
import torch
x = torch.tensor([1.0, 2.0, 3.0, 4.0])
target = torch.tensor([[3.0], [6.0], [9.0], [12.0]]) # was [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_()
if step in (0, 9, 99, 499):
print(f"step={step:3d} loss={loss.item():.6f} w={w.item():.4f} b={b.item():.4f}")
step= 0 loss=37.500000 w=2.1250 b=0.5000
step= 9 loss=17.536465 w=2.0555 b=1.4566
step= 99 loss=11.666244 w=0.5289 b=5.9449
step=499 loss=11.250002 w=0.0013 b=7.4963
没有任何报错。损失降了三分之二然后稳定,看起来大致像收敛。而模型毫无用处:w 归零而不是到三,答案变成与输入无关的 y = 7.5。
第 1 章教我们在模型不学时检查三个阶段。这里每个阶段都没问题。前向算了它被要求算的东西,backward() 填了两个梯度,更新移动了两个参数。bug 不在循环里,而在流经循环的某个对象形状与假设不同,而算子把差异消化了而不是抱怨。
本章讲的就是这些对象。目标是一个具体可检查的技能:给定张量算子,运行前算出它会产出什么;当现实不符时,找到第一次分歧的位置。这个技能是全书后面的基础。卷积、嵌入、注意力与 Transformer 在机械层面就是一串形状变换,调试它们的大量工作就是判定哪个变换第一次产出了你没想要的东西。
稍后我们会回来,精确解释 7.5 这个数。
张量是描述,而不只是容器
torch.tensor(2.0) 看起来像装数字的盒子,在一切都是标量时这样读没代价。现在不够了。张量带着一块数值,外加一份如何解释它们的描述,而这份描述的每一部分都对应一类你迟早会遇到的失败。
import torch
def describe(name, t):
print(f"{name:<8} shape={tuple(t.shape)!s:<16} dtype={str(t.dtype):<14}"
f" device={t.device} stride={t.stride()} contiguous={t.is_contiguous()}")
x = torch.randn(8, 16, 64)
describe("x", x)
describe("x.T2", x.transpose(1, 2))
x shape=(8, 16, 64) dtype=torch.float32 device=cpu stride=(1024, 64, 1) contiguous=True
x.T2 shape=(8, 64, 16) dtype=torch.float32 device=cpu stride=(1024, 1, 64) contiguous=False
五个属性,五类问题:
shape 是每轴逻辑长度,ndim 是轴数。大多数算子校验的就是它,大多数 traceback 报告的也是它。
dtype 是元素类型。它决定算子是否有定义、精度剩多少、两个操作数如何结合。
device 是内存所在位置。算子一般要求操作数在同一位置。
stride 说明沿每轴走一步要在存储里跨多少元素。它是 PyTorch 把逻辑下标变成偏移的方式,也解释了上面转置张量为何内存相同而形状不同。
is_contiguous() 报告当前步长是否对应当前形状的标准行主序布局。
形状与 dtype 描述数值的逻辑解释;设备说明数值住在哪里;步长与连续性描述逻辑位置如何映射到存储。
把这些层次分开。形状问题、dtype 问题、设备问题与布局问题的症状很不同,修复也很不同。
describe 这个 helper 值得留着。本章大多数诊断工作,就是在形成观点之前先看过这些值。
形状带着 PyTorch 无法强制的语义契约
看两个张量:
a = torch.randn(32, 128)
b = torch.randn(128, 32)
它们装着同样多的数值,在 Python 类型系统里都是 torch.Tensor。很多算子对两者都合法。但如果前者表示 32 个样本各 128 维特征,后者把轴反过来,同样的合法算子含义完全不同。PyTorch 无从知道。它只存整数 32 与 128。批次(batch) 与特征(features) 只存在于你的脑子与周围代码里。
所以写下来。本书全程用的约定是每轴一个短符号名:
(B, F) batch, features
(B, T, D) batch, sequence position, embedding dimension
(B, C, H, W) batch, channel, image height, image width
(B, H, T, Dh) batch, attention head, sequence position, per-head dimension
这些字母不是 PyTorch 语法,没有运行时效果。它们是阅读纪律。当你看到 torch.randn(32, 100, 768),有用的反射不是记下它有三维,而是问三个问题:32 个什么?100 个什么?768 个什么? 答不上来,你还不知道代码在干什么,你问的助手也不知道。
由此得到贯穿全书的区分。同一个算子可能以两种很不同的方式失败。
结构上不合法。 PyTorch 做不了你要的算子,并说出来。你得到 traceback。
结构上合法但语义错误。 PyTorch 精确执行了你要的算子。你要错了。没有 traceback,程序产出数字。
第一种通常更容易,因为执行停下并给出证据。第二种能活得足够久,看起来像训练问题而不是张量问题。
有个特例现在值得命名,因为调试时会咬你。当两轴尺寸恰好相等,形状完全携带不了哪个是哪个的信息:
h = torch.randn(32, 32)
这是 (batch, hidden) 还是 (hidden, batch)?都是,也都不是。张量里没有任何东西区分它们,对 h.shape 的断言也区分不了,上游某处转置会让这个张量看起来完全正确。所以复现疑似形状 bug 时,要选彼此都不同的尺寸。batch 32 流进 hidden 32,是专门藏 bug 的调试环境。本章后面会故意用它。
算子能对形状做什么
推导输出形状不需要背下 PyTorch 每个函数签名。日常张量算子里惊人的一大部分,可以用一小组形状变换理解,每条规则都能纸上应用。
保持。 逐元素一元算子返回同样形状。torch.relu(x)、x.exp()、x * 2、x.float()。如果形状变了,凶手不是它们。
对齐两形状并扩展。 逐元素二元算子做广播。从右往左对齐形状;每对维度必须相等,或其中之一为 1;缺失的前导维当 1。输出每位置取较大尺寸。
(32, 10, 128) (32, 10, 128) (32, 10, 128)
(128) -> ok (10, 128) -> ok (1, 1, 128) -> ok
(32, 10, 128)
(32, 128) -> 128 matches 128, but 10 and 32 do not: error
可以让 PyTorch 不分配内存替你算这个:
print(torch.broadcast_shapes((32, 1), (32,)))
torch.Size([32, 32])
收缩一轴。 归约吃掉一轴或多轴。sum、mean、max、norm 等去掉 dim 指名的轴,除非 keepdim=True 把它们以尺寸 1 留下。不给 dim,一切缩成 ndim == 0 的标量。
x = torch.randn(4, 6, 8)
print(x.sum(dim=1).shape)
print(x.sum(dim=1, keepdim=True).shape)
print(x.sum(dim=(0, 2)).shape)
print(x.sum().shape, x.sum().ndim)
torch.Size([4, 8])
torch.Size([4, 1, 8])
torch.Size([6])
torch.Size([]) 0
矩阵乘法也是收缩:吃掉匹配的内维。
(..., M, K) @ (..., K, N) -> (..., M, N)
前导维按同样广播规则对齐。一维操作数的两个特例值得记住,因为它们是常见意外形状的来源:
print((torch.randn(3) @ torch.randn(3)).shape) # both 1-D: inner product
print((torch.randn(5, 3) @ torch.randn(3)).shape) # 1-D on the right
print((torch.randn(3) @ torch.randn(3, 5)).shape) # 1-D on the left
print((torch.randn(2, 5, 3) @ torch.randn(3, 4)).shape) # batched against a matrix
print((torch.randn(2, 1, 5, 3) @ torch.randn(3, 3, 4)).shape)
torch.Size([])
torch.Size([5])
torch.Size([3, 5])
torch.Size([2, 5, 4])
torch.Size([2, 3, 5, 4])
对 matmul,左侧一维操作数被当作加了前导 1,右侧一维被当作加了尾随 1。乘完后那个临时维从结果去掉。所以 (5, 3) @ (3,) 给出 (5,),不是 (5, 1)。如果你期待一列,你已经悄悄丢了一轴。
插入或删除一轴。 整数索引删掉它索引的那轴;切片保留。unsqueeze(d) 插入尺寸 1 的轴;squeeze(d) 在尺寸为 1 时删掉,否则不动。
im = torch.randn(4, 3, 32, 32)
print(im[0].shape) # integer index: axis removed
print(im[0:1].shape) # slice: axis kept
print(im[:, 0].shape)
print(im[..., 0].shape)
torch.Size([3, 32, 32])
torch.Size([1, 3, 32, 32])
torch.Size([4, 32, 32])
torch.Size([4, 3, 32])
这是一种一眼该认出的失败:batch 8 能跑、单个样本就挂的代码。传 batch[0] 是把 (C, H, W) 交给期待 (B, C, H, W) 的函数。传 batch[0:1] 保留契约。
不带参数的 squeeze() 尤其可疑,因为它删掉所有尺寸为一的轴,包括你需要的:
s = torch.randn(1, 10, 1)
print(s.squeeze().shape)
print(s.squeeze(-1).shape)
print(s.squeeze(0).shape)
torch.Size([10])
torch.Size([1, 10])
torch.Size([10, 1])
第一行毁了 batch 轴。在 batch 通常大于一的流水线里,这是只在最后一个不完整 batch 或单样本推理才出现的 bug。说出你要的轴。
重解释同样元素。 reshape、view 与 flatten 保留所有值,改变轴的划分。元素总数守恒,这是它们强制的唯一约束,-1 让 PyTorch 解出唯一未知轴。
x = torch.randn(32, 3, 28, 28)
print(x.reshape(x.shape[0], -1).shape)
print(torch.flatten(x, start_dim=1).shape)
torch.Size([32, 2352])
torch.Size([32, 2352])
这里两者结果相同,flatten(x, start_dim=1) 说出了意思:保留 batch 轴,塌掉后面的。用 x.shape[0] 而不用硬编码 32,代码就不会悄悄依赖迟早会变的 batch。
重排轴。 transpose(a, b) 交换两轴;permute(...) 指定完整新顺序。数值与总数不变,只变哪个轴是哪个。
images = torch.randn(32, 224, 224, 3) # (B, H, W, C)
images = images.permute(0, 3, 1, 2) # (B, C, H, W)
print(images.shape)
torch.Size([32, 3, 224, 224])
这张表是工作清单,不是封闭分类。cat、stack 之类的拼接扩展或新增一轴,padding 撑大一轴,卷积按核与步长算新空间尺寸,第 8 章会拆开。但遇到不熟悉的算子,先问它属于哪一种,通常就能得到预测,而预测就是可检查的东西。
其中两类对调试尤其重要,因为两者都能在做的不是你想的事的情况下成功。逐个讲。
广播精确执行了你要的东西
广播让我们在第 1 章不假思索写下 w * x + b,也让偏置向量能加到一批激活上而不必每行物化一份。它不是危险特性。它是愿意对你无意写出的形状组合给出合理意义的特性。
看典型版本:
torch.manual_seed(0)
predictions = torch.randn(32, 1) # one output per example
targets = torch.randn(32) # one target per example
diff = predictions - targets
print(diff.shape, diff.numel())
torch.Size([32, 32]) 1024
三十二个预测,三十二个目标,一千零二十四个差。
走一遍 PyTorch 为何认为这合理。从右对齐:
predictions (32, 1)
targets (32)
最右一对是 1 对 32。1 允许扩展,变成 32。往左,predictions 有 32 而 targets 缺维,缺维当 1 再扩展。结果 (32, 32),元素 [i, j] 是 predictions[i] - targets[j]。每个预测与每个目标都比了一次。算子精确符合规则,规则被用在了含义与假设不同的形状上。
看这个 bug 多会藏:
wrong = (diff ** 2).mean()
right = ((predictions.squeeze(1) - targets) ** 2).mean()
print(f"wrong={wrong.item():.4f} right={right.item():.4f}")
wrong=2.1872 right=2.3178
错的损失是个看似合理的数。不是 NaN,不大,不为零,这里甚至比正确损失略小,用它的运行看起来略好而不是明显坏掉。它是标量,backward() 能跑,梯度以正确形状流向 predictions。随手做的下游检查全过。
暴露它的证据是形状本身,具体是元素数。三十二个样本应该产出三十二个误差。numel() 报 1024 是与任何正确故事都不符的事实。
回到循环
现在可以完整解释 7.5。开篇程序里 prediction 形状 (4,),target 形状 (4, 1)。对齐:
prediction (4)
target (4, 1)
最右 4 对 1,1 扩展。prediction 缺失的前导维也扩展。差是 (4, 4),.mean() 平均了十六个数而不是四个。被最小化的目标不是“每个预测对其自己目标的平均平方误差”,而是“每个预测对每个目标的平均平方误差”。
这个目标有可解析的最小值,我们可以预测训练收敛到哪,而不用猜。对固定目标集,使所有目标 t_j 上 (p - t_j)² 平均最小的单个预测 p 是目标均值。配对被毁了,任何预测都没有理由彼此不同,各自最优就是坐在目标均值上。我们的目标是 3, 6, 9, 12,均值 7.5。该点残差损失是目标对其均值的均方离差,即 11.25。
输出里两个数都出现了:b 收敛到 7.4963,w 在 0.0013,损失停在 11.250002。一致就是要点。我们不是靠试修复直到运行变好来诊断的。我们假设某算子形状错了,推导出只有假设为真才成立的后果,并检查它。这和第 1 章的 -19.2 = -3.2 + (-16.0) 是同一动作。
修复是写下契约,而不是 reshape 到数字变化为止:
assert prediction.shape == target.shape, (
f"prediction {tuple(prediction.shape)} vs target {tuple(target.shape)}"
)
放在损失之前,断言立刻在循环体内失败,报出两形状。之后是 squeeze 目标还是给预测加尾轴,取决于程序其余部分期待哪个形状。重要的是你做了决定,而不是让广播规则替你决定。
并用独立的东西验证修复。损失下降不是检查;坏版本的损失也会降。检查是 w 收敛到 3.0,b 到 0.0,x = 10 的留出预测逼近 30.0,和第 1 章一样。
广播失败不会自我宣告,因为在 PyTorch 看来什么都没失败。信号是大于你以为在算的量的形状或元素数。
归约与你没想的那轴
第二类“成功但做错事”是归约,把一批特征标准化是最清楚的例子。
x = torch.randn(32, 64) # (B, F)
a = (x - x.mean(dim=0)) / x.std(dim=0)
b = (x - x.mean(dim=1, keepdim=True)) / x.std(dim=1, keepdim=True)
print(a.shape, b.shape)
torch.Size([32, 64]) torch.Size([32, 64])
两行,同样输入,同样输出形状,都不报错。算的东西不同。第一个按跨 batch 收集的统计标准化每个特征,这通常是“归一化输入”的意思。第二个按各自特征收集的统计标准化每个样本,是不同变换,后果不同。
形状相同,形状断言分不开它们。区分证据是结果的性质而不是形状:问现在哪轴均值为零。
print(f"a: max |mean| over dim 0 = {a.mean(dim=0).abs().max():.2e}")
print(f"b: max |mean| over dim 0 = {b.mean(dim=0).abs().max():.2e}")
print(f"b: max |mean| over dim 1 = {b.mean(dim=1).abs().max():.2e}")
a: max |mean| over dim 0 = 4.47e-08
b: max |mean| over dim 0 = 5.04e-01
b: max |mean| over dim 1 = 5.40e-08
这是通用技术,值得从例子里提炼。当两个候选实现形状相同,找一个两种假设预测不同的标量摘要,算出来。这里“特征被标准化”与“样本被标准化”对哪个边际均值为零做出不兼容预测,一次测量定案。
keepdim 值得单独说,因为它与广播的交互按尺寸不同产出两种失败。不带它,(32, 64) 上 x.mean(dim=1) 给出 (32,),从 (32, 64) 减去它会把 32 对 64,抛错。有帮助。但在方阵上:
sq = torch.randn(32, 32)
print((sq - sq.mean(dim=1)).shape)
print(torch.equal(sq - sq.mean(dim=1), sq - sq.mean(dim=1, keepdim=True)))
torch.Size([32, 32])
False
合法,形状正确,结果不同。不带 keepdim,行均值变成 (32,) 向量沿末轴广播,于是每列被对应下标行的均值中心化。这就是前面的方阵盲区,在真实代码里到来。
找第一个错的张量,而不是第一个不合法的
前面都讲单个算子。真实代码是一串算子,实际困难是抛错的算子常常不是错的算子。
这里有一段手写前向。它沿用 nn.Linear 内部约定,权重存为 (out_features, in_features);第 4 章会这样从零建网。
torch.manual_seed(0)
in_features, hidden, classes = 64, 32, 10
W1 = torch.randn(hidden, in_features) # (32, 64)
W2 = torch.randn(classes, hidden) # (10, 32)
def forward(x): # x: (B, in_features)
h = W1 @ x.T
h = torch.relu(h)
logits = h @ W2.T
return logits
x = torch.randn(32, in_features)
print(forward(x).shape)
torch.Size([32, 10])
三十二个样本进,三十二行十类分数出。看起来对。
如果 W1、W2 是模型里可训练参数,这个维度错误在这个 batch 下能活进训练,因为每个算子都结构合法。这里重点不是优化最终会拿它怎样,而是形状跟踪目前看起来正确。
然后有人跑到 epoch 最后一个不完整 batch,或把 batch 减半塞进内存:
forward(torch.randn(16, in_features))
RuntimeError: mat1 and mat2 shapes cannot be multiplied (32x16 and 32x10)
traceback 指向函数最后一行 h @ W2.T。本能是让这行跑起来:转置 W2,或插 reshape,或 flatten。都能让异常消失。都不触及发生了什么。
相反,写下契约,找到它断裂处。函数里每个张量都有预期符号形状,我们写函数时知道:
x (B, in_features)
h (B, hidden)
relu (B, hidden)
logits (B, classes)
打点。不需要 clever:
def check(name, t, expected):
actual = tuple(t.shape)
mark = "ok " if actual == expected else "DIVERGES"
print(f"{mark} {name:<7} expected={str(expected):<12} actual={actual}")
return t
def forward(x, B):
check("x", x, (B, in_features))
h = W1 @ x.T
check("h", h, (B, hidden))
h = torch.relu(h)
check("relu", h, (B, hidden))
logits = h @ W2.T
check("logits", logits, (B, classes))
return logits
在失败的 batch 下跑:
forward(torch.randn(16, in_features), 16)
ok x expected=(16, 64) actual=(16, 64)
DIVERGES h expected=(16, 32) actual=(32, 16)
DIVERGES relu expected=(16, 32) actual=(32, 16)
RuntimeError: mat1 and mat2 shapes cannot be multiplied (32x16 and 32x10)
第一次分歧在 h,比异常早两个算子。relu 是下游损伤:逐元素算子保持形状,只能传播给它的东西。而它报告的 (32, 16) 是 (hidden, B)。轴是要的轴,顺序错了。
这就精确指认了机制。W1 @ x.T 是 (hidden, in_features) @ (in_features, B),给出 (hidden, B)。想要的是 batch 在前:x @ W1.T,即 (B, in_features) @ (in_features, hidden),给出 (B, hidden)。有人知道权重存为 (out, in),知道要转置,转错了操作数。
def forward(x):
h = x @ W1.T
h = torch.relu(h)
return h @ W2.T
在不止一个 batch 下验证,这就是要点:
print(forward(torch.randn(32, in_features)).shape)
print(forward(torch.randn(16, in_features)).shape)
torch.Size([32, 10])
torch.Size([16, 10])
最重要的是这个。把原来的打点函数在 batch 32 下跑:
ok x expected=(32, 64) actual=(32, 64)
ok h expected=(32, 32) actual=(32, 32)
ok relu expected=(32, 32) actual=(32, 32)
ok logits expected=(32, 10) actual=(32, 10)
全过。输出形状 (32, 10),完全符合规定。而数值是错的,因为 hidden 与 B 都是 32 时 (hidden, B) 与 (B, hidden) 不可区分。直接确认:
def broken(x):
return torch.relu(W1 @ x.T) @ W2.T
def fixed(x):
return torch.relu(x @ W1.T) @ W2.T
x = torch.randn(32, in_features)
print(torch.allclose(broken(x), fixed(x)))
False
batch 16 的异常不是 bug 出现,而是 bug 可见,因为两轴尺寸的巧合不再成立。bug 一直在,悄悄转置一批激活,只要 batch 恰好等于 hidden。
带走两样。第一是流程:
写下每个张量的预期符号形状。与观测形状对比。找到最早的不一致。检查它紧前的算子。到那时再决定改什么。
第二是让流程生效的习惯。测试张量代码时选彼此不同的尺寸。 batch 32 进 hidden 32,是让整类 bug 不可检测的配置。用 16 与 32,或 7 与 13。能活过这个的形状 bug,才是真 bug 而不是算术巧合。
形状断言值得写,本章稍后会形式化,但这个例子限定了它们能做什么。断言比较整数,它说不出整数含义错了。
形状描述解释;步长描述存储
到此问的都是逻辑形状。底下还有第二层,它解释一族否则看似随意的错误,特别是 transpose() 之后 view() 拒绝的那种。
张量数值住在一维扁平存储区。形状说明每轴多少位置。步长(strides) 说明沿每轴走一步在存储里跨多远。两者一起把逻辑下标变成偏移。
x = torch.arange(12).reshape(3, 4)
print(x.stride(), x.is_contiguous())
(4, 1) True
沿 axis 1 走一步在存储里走一格;沿 axis 0 走一步跨四格。正是四列行主序矩阵的样子,is_contiguous() 报告的就是这个:步长符合该形状的标准布局。
转置它:
y = x.t()
print(y.shape, y.stride(), y.is_contiguous())
print("same storage:", y.data_ptr() == x.data_ptr())
torch.Size([4, 3]) (1, 4) False
same storage: True
没拷贝。data_ptr() 确认两张量起始地址相同;PyTorch 只是交换步长,对同一存储产生新视图。
产生转置视图很便宜,因为没搬数据。所得非连续布局会影响后面消费它的算子。这也是结果不连续的原因:(4, 3) 的标准步长应是 (3, 1),这里是 (1, 4)。
机制就这些,view() 报错直接跟出来:
y.view(-1)
RuntimeError: view size is not compatible with input tensor's size and stride
(at least one dimension spans across two contiguous subspaces). Use .reshape(...) instead.
view() 承诺返回共享原存储的张量。按行主序展平 y 要读 0, 4, 8, 1, 5, 9, ...,没有单一步长能表达这个走法。PyTorch 做不到这个承诺,所以拒绝而不是悄悄拷贝。
reshape() 承诺更弱:给我这个形状,能共享就共享,不行就拷贝。
print(y.reshape(-1).tolist())
print("copied:", y.reshape(-1).data_ptr() != x.data_ptr())
print("copied:", x.reshape(-1).data_ptr() != x.data_ptr())
[0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11]
copied: True
copied: False
同样调用,两种行为,由布局决定。转置张量上的 reshape 必须分配;原连续张量上返回视图。
人们口口相传的规则在这里出错,所以精确说机制,不说口号。
不是 view() 要求张量连续。它要求请求的形状能用已有存储上的步长表达:
g = torch.randn(4, 6)
h = g[:, :3] # a slice: non-contiguous
print(h.stride(), h.is_contiguous())
print(h.view(4, 3, 1).shape) # works, on a non-contiguous tensor
(6, 1) False
torch.Size([4, 3, 1])
不是 view() 在 permute() 后一定不行。置换恰好留下与请求兼容的布局时,它行:
c = torch.randn(1, 6)
d = c.permute(1, 0)
print(d.shape, d.stride(), d.is_contiguous())
print(d.view(6).shape)
torch.Size([6, 1]) (1, 6) True
torch.Size([6])
尺寸为一的轴做置换只重排描述,不扰动存储走法,结果仍连续。
也不是 reshape() 总拷贝,上面的 data_ptr() 对比已说明。真正成立的更窄、更有用:
view()要么返回共享存储的张量,要么抛错。reshape()给出请求的形状,布局允许就共享,否则拷贝。某次调用拷不拷贝取决于张量步长,所以不要写正确性依赖它到底是哪种的代码。
后半句是真约束,因为共享存储意味着别名:
a = torch.zeros(2, 3)
v = a.view(6)
v[0] = 99
print(a)
tensor([[99., 0., 0.],
[ 0., 0., 0.]])
经视图写改了原件。如果同一代码路径产出的是拷贝,因为上游某算子留下非连续张量,写就去了无处可见的地方,原件还是零。这是真难追的 bug,避免办法是不要把原地写与没确定返回类型的重塑合用。
最后,contiguous() 保证连续布局。已连续可能原样返回;不连续要连续结果必须拷贝数据:
y = x.t().contiguous()
print(y.is_contiguous(), y.view(-1).shape)
True torch.Size([12])
view() 一抱怨就 .contiguous(),错会消失。动手前值得知道是前面哪个算子让张量不连续,因为偶尔答案是那个算子本身就是错的,而你正要花一次拷贝去保它。
形状相同,张量不同
现在把两层放在本章最锋利的例子里。取一批词元嵌入,把嵌入维拆到注意力头。第 10 章讲它何用,这里是形状练习。
(B, T, D) -> (B, H, T, Dh) where D = H * Dh
两种实现。都产出目标形状,都能跑。
B, T, H, Dh = 1, 4, 2, 3
D = H * Dh
x = torch.arange(B * T * D).reshape(B, T, D)
good = x.reshape(B, T, H, Dh).transpose(1, 2)
bad = x.reshape(B, H, T, Dh)
print(good.shape, bad.shape, torch.equal(good, bad))
torch.Size([1, 2, 4, 3]) torch.Size([1, 2, 4, 3]) False
形状相同,内容不同。把各自第一个头与 x 并排打印,看值从哪来:
print(x[0])
print(good[0, 0])
print(bad[0, 0])
tensor([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])
tensor([[ 0, 1, 2],
[ 6, 7, 8],
[12, 13, 14],
[18, 19, 20]])
tensor([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
x 每行一个词元,每列一维嵌入。头 0 应该拥有每个词元前三维嵌入,good 正是:四行 0 到 2 列。
bad 装着同样的值,但按错的轴分组。它没有把每个词元的嵌入维拆到头,而是把展平的序列-嵌入区按连续块切分。
在这个小例子里,头 0 吃了前两个词元的所有值,重排成四行三列。下游算子可以保持完全合法,因为终形状仍是 (B, H, T, Dh)。它们只是在与我们意图不同的数据解释上运算。
原因是 reshape 按元素扁平顺序操作,而 (B, T, D) 里嵌入变化最快。把末轴拆成 (H, Dh) 尊重这个顺序,所以 reshape(B, T, H, Dh) 对,随后需要 transpose(1, 2) 把 H 前移。写 reshape(B, H, T, Dh) 是对同一扁平序列要了另一种切分,并得到了它。
布局后果紧跟而来。transpose 产出非连续张量,所以:
good.view(B, H, T * Dh)
RuntimeError: view size is not compatible with input tensor's size and stride ...
而 good.reshape(B, H, T * Dh) 靠拷贝成功。这个错不是头拆错的信号。它是正确转置的预期后果,修复是 reshape 或显式 contiguous(),要知道发生了拷贝。
产出同样形状的两个算子不因此是同一个算子。当重塑与置换都能到达目标形状时,弄清元素到底去了哪,最好在能把答案读出来的小
arange张量上做。
后半建议是本章最便携的调试技术。随机数据说不出值去了哪。连续整数全说得出来,小到能打印的张量十秒钟解决你能争一小时的问题。
dtype 与设备也是契约的一部分
形状是结构意外的一大来源,但不是算子关心的唯一属性。dtype 与设备有各自特征的失败。
整数张量先看,因为 Python 字面量与 PyTorch 默认不总合你意:
i = torch.tensor([1, 2, 3])
print(i.dtype)
i.mean()
torch.int64
RuntimeError: mean(): could not infer output dtype. Input dtype must be either
a floating point or complex dtype. Got: Long
这个响亮,是好情况。这个不响:
a = torch.tensor([200], dtype=torch.uint8)
b = torch.tensor([100], dtype=torch.uint8)
print((a + b).item(), (a + b).dtype)
44 torch.uint8
三百装不进无符号字节,回绕了。图像数据以 uint8 读入、转浮点前先做算术,是到这里的现实路径,输出里没有任何宣告。
dtype 间提升遵循通常合意、偶尔昂贵的规则:
print((torch.ones(3) + torch.ones(3, dtype=torch.float64)).dtype)
print((torch.ones(3) + torch.ones(3, dtype=torch.long)).dtype)
print((torch.ones(3, dtype=torch.float16) + torch.ones(3)).dtype)
torch.float64
torch.float32
torch.float32
第一行值得记住。普通浮点字面量建的 NumPy 数组通常 float64,torch.from_numpy() 保留 dtype。
这个张量进入 float32 程序会怎样,取决于算子。有些算术算子用 PyTorch 类型提升产出更高精度结果;有些算子要求 dtype 兼容,否则抛错。无论哪种,意外 float64 值得在它进入流水线的边界找到,而不是几个算子后才发现。
import numpy as np
print(torch.from_numpy(np.array([1.0, 2.0, 3.0])).dtype)
torch.float64
降精度是反向失败:dtype 小到普通值超出范围:
print(torch.full((4096,), 1.0, dtype=torch.float16).sum().item())
print(torch.full((65536,), 1.0, dtype=torch.float16).sum().item())
print(torch.finfo(torch.float16).max)
4096.0
inf
65504.0
求和 ones 溢出,因为 float16 表示不了 65536。本书后面出现混合精度时,背后的机制就是这套,相关机器正是为防它而存在。
有些算子有专门 dtype 契约。常见的是 cross_entropy 做分类:目标表示类别下标时,下标必须整数 dtype:
logits = torch.randn(4, 10)
torch.nn.functional.cross_entropy(logits, torch.tensor([1.0, 5.0, 3.0, 0.0]))
RuntimeError: expected target dtype to be Long or Byte, but got Float
所以“全转浮点”不是安全规则。这里目标表示类别下标,整数 dtype 是算子契约的一部分。别的损失用浮点目标。dtype 和形状一样,能编码张量对消费它的算子的含义。
设备是同样模式,规则更窄:操作数一般必须在同一位置。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(32, 128, device=device)
w = torch.randn(128, 64, device=device)
out = x @ w
不在一处时,信息很明确:
RuntimeError: Expected all tensors to be on the same device,
but found at least two devices, cuda:0 and cpu!
有趣的版本不是你忘了搬输入,而是函数里凭空建的张量没参照已在流的张量。
torch.arange、torch.ones、torch.eye 等工厂函数用 PyTorch 配置的默认设备,除非你指定;不会因为附近有个 x 就自动继承 x.device。默认设备初始是 CPU,这常出现在周围模型已搬上加速器时。避开的习惯是从手头张量派生设备:
positions = torch.arange(x.shape[1], device=x.device)
第 5 章讲 model.to(device) 如何搬运已注册参数与缓冲,以及为什么前向里新建的张量不在此列。
把契约写下来
形状断言值得写,理由和任何前置条件一样。嫌它 clutter 的回答是放在边界而不是到处放。被别的代码用非自建张量调用的函数是边界。已经理解的代码块中间某行不是。
好的形状检查的要点是信息里带证据:
def mse(predictions, targets):
if predictions.shape != targets.shape:
raise ValueError(
f"predictions {tuple(predictions.shape)} and "
f"targets {tuple(targets.shape)} must match"
)
return ((predictions - targets) ** 2).mean()
这把开篇静默广播 bug 变成违反假设处的立即失败,并打印两形状,不用你再加 print 才知道发生了什么。
对只有部分轴固定的张量,helper 省掉重复四行:
def require_shape(name, t, *expected):
"""Each entry is an int, or None for 'any size'."""
if t.ndim != len(expected):
raise ValueError(
f"{name}: expected {len(expected)} dims, got {t.ndim} "
f"with shape {tuple(t.shape)}"
)
for axis, (actual, want) in enumerate(zip(t.shape, expected)):
if want is not None and actual != want:
raise ValueError(
f"{name}: axis {axis} expected {want}, got {actual}; "
f"full shape {tuple(t.shape)}"
)
require_shape("hidden", torch.randn(32, 100, 768), None, None, 768)
这对任意 batch 与序列长都过,只钉住嵌入宽,通常这才是你在乎的轴。
更轻的替代,也是真实模型代码里最常见的,是记录每步形状的注释:
# x: (B, T, D)
q = x.reshape(B, T, H, Dh)
# q: (B, T, H, Dh)
q = q.transpose(1, 2)
# q: (B, H, T, Dh)
这些注释没有运行时效果,不能代替边界检查。它们的价值在于张量代码把几个轴操作压进一两行,注释记下否则要重建的推理。它们是程序最接近自述类型系统的东西,写它们的过程常常就是 bug 浮现的过程。
一句警告,来自前面的流水线:形状检查比较整数,所以交换两等长轴的错误查不出。测试尺寸保持不同。
在张量代码上用 AI
本章失败正是助手容易粉饰的那种,因为很多形状异常用 reshape、squeeze、转置或其他局部调整就能消失。让算子合法远比证明所得轴符合周围模型期待容易。是否恢复了预期的含义是另一个问题,报错信息回答不了。
所以别从报错开场。从索取可检查的跟踪开场。对前面坏的前向这样试:
Here is a PyTorch function and the shapes of the tensors it closes over.
Do not rewrite it and do not propose a fix yet.
Walk through it operation by operation. For each intermediate tensor, give
the symbolic shape you predict, using B for batch and named symbols for the
other axes, and say which rule produced it: broadcasting, matmul contraction,
reduction, axis insertion or removal, reinterpretation, or reordering.
Then tell me, for each axis of each intermediate, what it means in terms of
the model: which one indexes examples, which indexes features, and so on.
Finally, identify the first operation where the shape you predicted disagrees
with the contract implied by the surrounding code, and say what evidence in
the code makes you confident that this is a disagreement rather than a
convention I have chosen deliberately.
价值在答案的形状。符号跟踪对每个 batch 都做预测,不只你跑的那个,这才能在方张量掩护下暴露 (hidden, B) 转置。命名轴迫使助手说出它假定的解释,你通常在那里发现分歧,因为它的假设与你的假设并排可见。问什么证据支撑断言,区分有理由的答案与看似合理的答案。
然后检查。跑代码,打印形状,与预测跟踪对比。一致处 gain confidence;不一致处就是要调查的边界。无论哪种,你都知道了足够具体的东西,可以问具体的后续问题,这比“为什么不行”强得多。
知道坏在哪之后再要修复。第 1 章规则没变:无法检查的拟议修复,只是语法比你好的猜测。
当张量出乎意料
下面问题就是本章一直在准备装备回答的。顺序大致按最快解决问题的顺序:先事实,再意图,再机制。
我期待什么,得到了什么? 打印 tuple(t.shape),与你会写下的形状对比。如果写不出期待形状,先解决这个问题,而不是代码。
每轴是什么意思? 给每个操作数的每轴一个符号。大多数形状 bug 在这步跑之前就明显了。
元素数是我期待的吗? 形状看起来不吓人时 numel() 抓住意外广播。三十二个样本不该产出一千个数。
哪个算子改了形状,改得显式吗? 逐元素一元算子改不了形状。广播、归约、索引与重解释能,只有部分是你点名要的。
有两轴同尺寸吗? 有,形状检查分不开它们。信任何结论前先用不同尺寸重跑。
有轴悄悄消失吗? 整数索引、不带参数的 squeeze()、不带 keepdim 的归约、一维 matmul 操作数都删轴。缺轴常常是后面广播做错事的原因。
期待与实际第一次分歧在哪? 从输入往前跟踪,而不是从 traceback 往回。失败行是第一个不合法的算子,不一定是第一个错的。
这是形状问题还是布局问题? 如果 view() 报错提到 size 与 stride,先确认请求的元素数合法。如果合法,直接失败通常是当前步长表达不了请求的视图而不拷贝。查 stride() 与 is_contiguous(),先找到产出该布局的算子,再决定要不要 .contiguous()。
两种不同算子能到这个形状吗? 如果重塑与置换都到目标,用小 arange 实验判定你要的是哪个,看值去了哪。
dtype 或设备参与了吗? 该浮点处整数、NumPy 带来的 float64、降精度类型的溢出、加速器函数里建在 CPU 的常量。
修复恢复了契约,还是只消了异常? 说出错的量是什么,应该是什么,观察到现在是什么。开篇广播 bug 那里,这意味着 w 到 3.0,而不是损失下降。
你现在应该能回答什么
这段片段以某种形式出现在你读到的每个 Transformer 实现里。它应该不再 opaque。
B, T, D = 32, 128, 768
H = 12
Dh = D // H
x = torch.randn(B, T, D)
q = x.reshape(B, T, H, Dh)
q = q.transpose(1, 2)
scores = q @ q.transpose(-2, -1)
x 是什么? 32 个序列的 batch,每序列 128 位置,每位置 768 个数。(B, T, D)。
reshape 做了什么? 把 768 宽嵌入分成 12 组 64,得到 (B, T, H, Dh)。它是重解释:没搬值,32 × 128 × 12 × 64 等于 32 × 128 × 768。
为什么是这个 reshape 而不是 reshape(B, H, T, Dh)? 因为 reshape 沿元素扁平顺序,而 (B, T, D) 里嵌入变化最快。拆末轴是给每头属于自己的嵌入切片。另一种写法是给每头切序列。
transpose 做了什么? 交换 axis 1 与 2,产出 (B, H, T, Dh),让头轴与 batch 轴并排,后面的矩阵乘在 (T, Dh) 矩阵上做。它没搬数据,只改步长。
之后 q 连续吗? 不连续。它与 x 共享存储,转置步长不符合该形状标准布局。后面的 view() 可能拒绝;reshape() 会成功,必要时拷贝。
scores 什么形状? q 是 (B, H, T, Dh),q.transpose(-2, -1) 是 (B, H, Dh, T)。matmul 收缩内层 Dh 并广播前导 (B, H),给出 (B, H, T, T),即 (32, 12, 128, 128)。每个样本、每头、每位置对每位置打分。
H 与 Dh 换了怎么知道? 形状看不出,如果它们相等,这就是测试尺寸要不等的原因。H = 12 与 Dh = 64 不等,所以 reshape(B, T, Dh, H) 会产出 (32, 128, 64, 12),转置后 (32, 64, 128, 12),matmul 仍接受,给出 (32, 64, 128, 128)。合法,错,可用第二轴对 H 的检查发现。
我会断言什么? 转置后:q.shape == (B, H, T, Dh)。matmul 后:scores.shape == (B, H, T, T)。都在边界,都点名有含义的轴。
这些你应该不用跑代码全推出来,这就是本章的能力。它比知道多少张量方法重要得多。
练习
这些是用来跑的,对应本章配套 notebook。
-
先预测再执行。 下面每个先写下输出形状再跑:
torch.randn(8, 1, 6) * torch.randn(4, 6);torch.randn(5, 3) @ torch.randn(3);torch.randn(4, 6, 8).sum(dim=1, keepdim=True);torch.randn(1, 10, 1).squeeze();torch.randn(2, 3, 4).permute(2, 0, 1)。错的每个,指出用错了哪条规则。 -
复现开篇 bug 并预测不动点。 用形状
(4, 1)的目标[2, 4, 6, 8]跑开篇循环。跑之前从目标均值与方差预测b的收敛值与平台损失。然后修复并确认w到2.0。 -
让意外广播可见。 构造一对广播到比任一操作数都大的形状,用
numel()写一行能抓住它的检查。再找一对会抛错的,解释区分两种情况的是什么。 -
定位第一次分歧。 给本章坏
forward加check打点。在 batch 32、16、33 下跑。解释为什么其中一个什么都报不出,以及这告诉你单靠形状断言的什么局限。 -
映射存储。 对
x = torch.arange(24).reshape(2, 3, 4),打印x、x.transpose(0, 1)、x.permute(2, 0, 1)、x[:, :, ::2]的stride()与is_contiguous()。每个先预测view(-1)成不成再试,用步长而不是连续性解释结果。 -
证明
reshape有时拷贝。 构造一个reshape共享原存储、一个必须分配新存储的例子。检查存储关系,再改重塑结果看原件变不变。解释生产代码为什么不该依赖reshape()恰好返回视图还是拷贝。 -
拆两次头。 用
torch.arange与小到能打印的张量,实现本章正确与错误的头拆分各一遍。写一个断言对正确的过、对错误的挂,用的性质不是形状。 -
两种归一化。 把
(32, 64)张量按 batch 与按特征各标准化一遍。确认两者形状相同,再找区分它们的测量。在(32, 32)上重复并解释变化。 -
看 dtype 提升。 建一条从 NumPy 数组开始、止于矩阵乘法的小流水线,找到张量在哪变成
float64。在源头修而不是末尾 cast,说清两种修法为什么不等价。
下一步:让一切可微的记录
对象齐了。张量有形状,它是没人强制的契约;有 dtype 与设备,决定算子是否合法;有一组步长,决定哪些重解释免费、哪些要拷贝。给定算子与操作数,你能推导出产出;推导与现实分歧时,你有流程找到第一次分手的位置。
还没看的是 PyTorch 在执行时同时做的另一件事。第 1 章里 loss.backward() 沿着产出 loss 的算子记录走,我们把这份记录的存在当作信任。当参与 autograd 的张量流过这些算子,PyTorch 也记录了反向所需的微分关系:广播、归约、重塑、转置与其周围算术。广播的反向尤其要把梯度加总回被扩展前操作数的形状,这个事实以后能当证据,判断哪个张量被扩展了。
下一章打开这份记录。里面有什么,requires_grad、grad_fn 与叶状态如何决定其结构,它能在哪被无声切断,梯度缺失、陈旧或 NaN 时看什么。
Autograd。