CNN 几何:到达下一层的是什么形状?
运行前推导 CNN 通道与空间几何,从第一性原理构建卷积与池化,跟踪感受野与展平边界,用形状台账找到预测与观测几何第一次分歧的层。
这里有一批 32 张 RGB 图像和普通的第一个卷积。
x = torch.randn(32, 224, 224, 3)
conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3)
conv(x)
RuntimeError: Given groups=1, weight of size [16, 3, 3, 3],
expected input[32, 224, 224, 3] to have 3 channels, but got 224 channels instead
图像有三通道。PyTorch 说有 224。信息点的数在模型定义里 nowhere 出现,所以 obvious 的读法是层声明错了,obvious 的修复是声明对:
conv = nn.Conv2d(in_channels=224, out_channels=16, kernel_size=3)
这个修复在最窄意义上 work:不抛,返回张量,训练能走:
in_channels=224 output shape: (32, 16, 222, 1)
weight shape: (16, 224, 3, 3)
params: 32272
看输出宽。是 1。层用尺寸 3 的核吃了尺寸 3 的空间轴,产出一列,为此建了 32272 参数的权重张量。正确的层 448 个。
那个张量没有不合法,下游某些层可能接受。但模型现在把 224 图像行当通道、原来三 RGB 值当空间宽。它可能训,损失可能降;两者都不说明输入几何对了。
异常准确。Conv2d 从 axis 1 读通道数,axis 1 里是 224,它精确报告了。它说不出的是 axis 1 本来就不是通道轴。这个 batch 是 [B, H, W, C] 而层期待 [B, C, H, W],正确修复根本不在层上:
x = x.permute(0, 3, 1, 2)
permuted shape: (32, 3, 224, 224) contiguous: False
output shape: (32, 16, 222, 222)
weight shape: (16, 3, 3, 3)
params: 448
同样报错信息,两种修复,只有一个关于真正的问题。这个 gap 就是本章。
没知道维度什么意思前别修维度。
我们在哪
第 6 章把输入供给变成可观测系统,问训练循环到底在等哪里。第 7 章拆开 batch,问模型实际看到了什么,止于能陈述可测试的契约的张量:
[B, C, H, W] float32, normalized under a known convention
两章止于同一位置:model(x) 被调的时刻。第 6 章拥有供给。第 7 章拥有表示。本章从可信张量跨过模型边界开始。
第 4 章建了吃扁平向量的网,第 5 章组织成模块树。两者都没用四轴里两轴是空间的事实——像素 (h, w) 与 (h, w+1) 相邻的方式,扁平向量里特征 300 与 301 相邻的方式不是。卷积网是认真对待相邻的结构。
认真对待意味着按完全机械、完全可推导、一不小心就差一的规则变换通道轴与空间轴。所以本章的问题窄而实用:
给定形状
[B, C, H, W]的张量与一层,输出形状应该是什么,为什么,观测形状不同时几何第一次分歧在哪?
这不是“CNN 是什么”。很多读者能用语言描述卷积,还会花一下午改 in_features 直到异常消失。目标是机械推理 CNN 张量几何的能力——没见过的卷积网读得了,预测它对形状做什么,不一致时诊断。
环境
例子在 PyTorch 2.13.0、TorchVision 0.28.0、Python 3.12.3、Linux CPU 跑出。报错措辞版本间会变,下面的信息当形状与契约的证据看,不当稳定 API 文本。
[B, C, H, W] 是四种不同的轴
第 7 章坚持形状不是四个整数。这个坚持是本章大半工作,值得按卷积需要的具体形式重述。
两空间轴是有相邻的轴。通道下标无空间相邻。通道一致置换、下一卷积对应输入通道权重跟着置换,计算不变;只置换激活通道一般改变结果。
这个区分值得一句话说,因为正是让卷积几何说得通的那句话:
高与宽说哪里。通道说那里测到什么。
第一层 C = 3 通常真是红绿蓝,这样想没事。麻烦紧接着开始。通道
C = 3 → 16 → 32 → 64 → 128
的网没有 128 种颜色。那是学到的特征坐标:每个空间位置 128 个数,128 个不同学到的滤波器产出。它们单个没有保证的意义。某通道可能响应人能命名的东西,也可能在邻居间分布携带几个那种东西的碎片。安全的陈述是结构性的——每通道是每位置可用的一 learned 测量——某通道检测什么的任何断言都是要自己证据的假设。
两后果立刻跟出,本章反复问的两问题:
C_out由层声明,进张量须满足层的C_in契约;H_out、W_out由H_in、W_in、核、步长、padding、dilation 推导。
一层顺手做了两个独立变换。心里分开是 CNN 调试 tractable 的大半,本章剩下分别推导。
一次卷积,手算
任何公式前,先看机制的最小情形。单输入通道,4×4 格,单 2×2 核,一偏置。
inp = torch.tensor([[[[ 1., 2., 3., 4.],
[ 5., 6., 7., 8.],
[ 9., 10., 11., 12.],
[13., 14., 15., 16.]]]]) # [1, 1, 4, 4]
k = torch.tensor([[[[1., 0.],
[0., 1.]]]]) # [1, 1, 2, 2]
b = torch.tensor([0.5])
out = F.conv2d(inp, k, b)
output shape: (1, 1, 3, 3)
output:
tensor([[ 7.5000, 9.5000, 11.5000],
[15.5000, 17.5000, 19.5000],
[23.5000, 25.5000, 27.5000]])
九个值里三个的算术,把核放输入上逐位置乘:
(0,0) patch=[1, 2, 5, 6] products=[1, 0, 0, 6] sum=7 +bias=7.5
(0,1) patch=[2, 3, 6, 7] products=[2, 0, 0, 7] sum=9 +bias=9.5
(1,0) patch=[5, 6, 9, 10] products=[5, 0, 0, 10] sum=15 +bias=15.5
整个算子就是:
take a local patch
multiply elementwise by the kernel
sum
add the bias
write one output value
move to the next position
4×4 格里放下九个位置,输出 3×3。九个手算完对比得 manual == pytorch: True。
算术在眼前时说个精度点。(0,0) patch 是 [1, 2, 5, 6],核按此顺序作用,没先翻转。不对称核下区别可见:
kernel [[1,2],[3,4]] out[0,0] = 44.0 (1*1 + 2*2 + 3*5 + 4*6)
flipped [[4,3],[2,1]] out[0,0] = 26.0
PyTorch 用 valid 二维互相关描述 Conv2d:学到的核不先翻转直接作用。深度学习库习惯叫卷积;区别主要在与信号处理约定的参考实现对比时重要。
每个输出值对所有输入通道求和
单通道例子藏了通道归约。三输入通道时核作用于全部,结果求和。
同样权重在每位置复用
卷积在每个空间位置复用同样核权重。这就是权重共享:不像扁平图像上的 Linear 层,它不给每个像素位置学不同权重集。
复用给普通卷积在恰当条件下平移等变结构:移动输入倾向移动特征图,而不是要新权重。不是 blanket 的平移不变断言。padding、有限边界、步长、池化、分类 head 都 complicate 这个关系。
共享局部计算有用否是数据的属性,不是 Conv2d 的。
偏置是一输出通道一个数
带偏置的卷积,bias.shape == [C_out]。PyTorch 把 bias[j] 加到 batch 每样本输出通道 j 的每个空间位置。正是第 2 章确立的广播机制、第 4 章偏置扮演的 learned 偏移角色;这里没新几何。
权重张量解释整层
Conv2d 层的大半结构契约直接在模块上可见:通道数、核、步长、padding、dilation、groups、权重形状、偏置形状。输入图像高宽不在那;运行时到来。
c = nn.Conv2d(16, 32, kernel_size=(5, 3), stride=(2, 1),
padding=(2, 1), dilation=(1, 2), groups=4)
Conv2d(16, 32, kernel_size=(5, 3), stride=(2, 1), padding=(2, 1), dilation=(1, 2), groups=4)
in_channels 16
out_channels 32
kernel_size (5, 3)
stride (2, 1)
padding (2, 1)
dilation (1, 2)
groups 4
weight (32, 4, 5, 3) = [C_out, C_in/groups, K_h, K_w]
bias (32,)
权重形状就是层,四个数写出:
[C_out, C_in/groups, K_h, K_w]
32 output feature channels
4 input channels combined per output channel (16 / 4 groups)
5 kernel height
3 kernel width
普通情形 groups=1,第二轴就是 C_in,读法是上一节那个:
nn.Conv2d(3, 16, kernel_size=3) -> weight [16, 3, 3, 3]
16 output feature channels
for each one: combine all 3 input channels over a 3x3 spatial neighborhood
普通 groups=1 下权重 [64, 32, 3, 3] 意思是 64 输出通道、32 输入通道、3×3 核。分组卷积可能时第二维只是 C_in / groups,权重张量自己露不出总输入通道数。推断前看 groups、模块定义或相邻激活形状。
注意权重形状没有什么:图像的高宽。核几何在里面,图像几何不在。这个缺席是后面一节的主题。
groups,简短说,因为它解释第二权重轴
groups 划分通道连接。in_channels 与 out_channels 都须被 groups 整除,权重形状变成:
两种变换,不是一种
卷积改两件独立的事,CNN 调试最大改进就是拒绝一起想它们。
CHANNEL QUESTION SPATIAL QUESTION
What is C_out? What are H_out and W_out?
determined by: determined by:
out_channels kernel_size
stride
padding
dilation
注意不对称。C_out 不是推导的——你声明的,层产出它。没有算术。C_in 那头是兼容要求而不是计算:进张量必须有层为之建的通道数。
空间那头反过来。H_out 没人声明。它是四参数与输入尺寸的后果,本章大多数形状错产自这里。
所以形状台账里每个卷积两行推理,不是一行:
[B, C_in, H_in, W_in]
↓ conv: channels C_in -> C_out (declared)
↓ conv: geometry H_in -> H_out, W_in -> W_out (derived)
[B, C_out, H_out, W_out]
推导 H_out 与 W_out
从最简单的问题开始,不用公式:宽 k 的核在长 n 的轴上能占几个不同位置?
input 8, kernel 3, stride 1, padding 0 -> 6 (8 - 3 + 1 = 6)
input 8, kernel 5, stride 1, padding 0 -> 4 (8 - 5 + 1 = 4)
input 8, kernel 1, stride 1, padding 0 -> 8 (8 - 1 + 1 = 8)
input 8, kernel 8, stride 1, padding 0 -> 1 (8 - 8 + 1 = 1)
核左沿可放位置 0,右沿不能过 n-1,valid 放置 n - k + 1 个。一般公式的其余项都是这个计数的修改。
Padding 两端各加 p 个位置再数,n 变成 n + 2p:
input 8, kernel 3, padding 0 -> 6 (8 + 2*0 - 3 + 1 = 6)
input 8, kernel 3, padding 1 -> 8 (8 + 2*1 - 3 + 1 = 8)
input 8, kernel 3, padding 2 -> 10 (8 + 2*2 - 3 + 1 = 10)
Stride 不改哪些位置 valid;改访问其中几个。从第一个起步长 s,n - k + 1 候选里访问数 floor((n - k)/s) + 1:
input 8, kernel 3, stride 1 -> 6 (floor((8-3)/1) + 1 = 6)
input 8, kernel 3, stride 2 -> 3 (floor((8-3)/2) + 1 = 3)
input 8, kernel 3, stride 3 -> 2 (floor((8-3)/3) + 1 = 2)
floor 是整数几何进来的地方,不是舍入方便。核在某位置要么放得下要么放不下;部分放置不是放置。
Dilation 拉开核采样位置的间距。3×3 核 dilation=2 仍九个权重,但从 5×5 footprint 读。要紧的是等效核尺寸:
effective = d * (k - 1) + 1
dilation 1: effective kernel 3, input 8 -> 6 (8 - 3 + 1 = 6)
dilation 2: effective kernel 5, input 8 -> 4 (8 - 5 + 1 = 4)
dilation 3: effective kernel 7, input 8 -> 2 (8 - 7 + 1 = 2)
步长版里 k 换等效尺寸得一般规则,每轴:
H_out = floor( (H_in + 2*P_h - D_h*(K_h - 1) - 1) / S_h + 1 )
W_out = floor( (W_in + 2*P_w - D_w*(K_w - 1) - 1) / S_w + 1 )
- 1 ... + 1 对就是上面 n - k 变 n - k + 1 的 off-by-one,重排让 floor 在除法后施加。
两轴独立。每个参数都可是 tuple,那时高宽走完全不同的规则——像本章前面那层:
Conv2d(16, 32, kernel_size=(5,3), stride=(2,1), padding=(2,1), dilation=(1,2))
input [8, 16, 100, 200]
derived [8, 32, 50, 198] observed (8, 32, 50, 198) match=True
写一次,代码:
import math
def conv_out(size, k, s=1, p=0, d=1):
return math.floor((size + 2*p - d*(k - 1) - 1) / s + 1)
值得验证而不是信。输入尺寸 4 到 33 sweep,核 {1,2,3,5,7},步长 {1,2,3},padding {0,1,2,3},dilation {1,2,3},跳过 padding 输入小于等效核的组合:
combinations tested: 5055, mismatches: 0
值得留的表
input kernel stride padding derived observed
8 3 1 0 6 6
8 3 1 1 8 8
8 3 2 1 4 4
7 3 2 1 4 4
8 5 1 0 4 4
8 5 1 2 8 8
8 2 2 0 4 4
31 2 2 0 15 15
31 3 2 1 16 16
三、四行值得坐一会儿。输入 8 与 7 都产出 4。floor 吃了区别,输出尺寸唯一定不了输入尺寸,上游差一能在一层消失、另一层再现。
padding=1 不保尺寸
它在一特定组合下保尺寸,folklore 丢了条件:
kernel=3 stride=1 padding=1: 32 -> 32 preserved=True
kernel=5 stride=1 padding=1: 32 -> 30 preserved=False
kernel=3 stride=2 padding=1: 32 -> 16 preserved=False
kernel=5 stride=1 padding=2: 32 -> 32 preserved=True
kernel=7 stride=1 padding=3: 32 -> 32 preserved=True
机制在公式里可见。stride=1、dilation=1 时输出 n + 2p - k + 1,2p = k - 1 时恰等于 n。这就是 3→padding 1、5→padding 2、7→padding 3 背后的奇核规则。
步长大于 1,半核规则不再保输入尺寸。别的 padding 值对特定输入能产出同样数值输出尺寸,那是不同关系,不是常用“same 卷积”菜谱。
padding="same"
PyTorch 2.13 在 stride=1 时支持 padding="same",选 padding 让空间输出尺寸对上输入尺寸。也处理偶核、dilation;某些偶核/奇 dilation 组合 PyTorch 警告内部可能要显式 padding 拷贝。
不支持步长卷积 padding="same"。保空间尺寸真是契约时用 "same",别拿它代替理解几何。
池化是参数更少的同样问题
池化是另一滑窗空间变换。MaxPool2d 用与卷积公式相同的输出尺寸几何,含 dilation;AvgPool2d 用对应核/步长/padding 几何,无 dilation 参数。都不改通道数。
(8, 32, 64, 64) -> (8, 32, 32, 32)
(8, 3, 31, 31) -> (8, 3, 15, 15)
(2, 128, 7, 7) -> (2, 128, 3, 3)
有个 API 陷阱值得内化,因为它是两层看起来像、确有不同的地方:
MaxPool2d(2) (8, 32, 64, 64) -> (8, 32, 32, 32)
MaxPool2d(2, stride=1) (8, 32, 64, 64) -> (8, 32, 63, 63)
nn.Conv2d(3,3,2).stride = (1, 1)
nn.MaxPool2d(2).stride = 2
Conv2d 默认 stride=1。MaxPool2d 默认步长等于核。所以 MaxPool2d(2) 空间减半而 Conv2d(..., 2) 不会,原因是默认不是概念。
奇尺寸与 floor 变物理处
默认 stride=kernel_size 下 MaxPool2d(2) 让整数规则可见:
技术:推导、跟踪、对比
本书每章加一种调查法。第 2 章要第一个错的张量而不是第一个不合法的。第 3 章问梯度通路第一次消失处。第 5 章问四套结构哪套对归属不一致。第 6 章问有用功在哪停止流动。第 7 章问样本在哪不再满足契约。
第 8 章加:
层跑之前推导形状。与观测形状对比。第一次不一致就是调查处。
顺序就是全部要点。失败后打印形状告诉你发生了什么。先写下再跑告诉你网的模型哪错了,这是不同且有用得多的信息。
这里有个小 CNN 与 64×64 上 8 张图的预测,只用前面两问题推导——声明的通道、推导的几何:
class SmallCNN(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.relu1 = nn.ReLU()
self.pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.relu2 = nn.ReLU()
self.pool2 = nn.MaxPool2d(2)
self.gap = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(32, num_classes)
def forward(self, x):
x = self.pool1(self.relu1(self.conv1(x)))
x = self.pool2(self.relu2(self.conv2(x)))
x = self.gap(x)
return self.fc(torch.flatten(x, 1))
expected = [(8,16,64,64), (8,16,64,64), (8,16,32,32),
(8,32,32,32), (8,32,32,32), (8,32,16,16),
(8,32,1,1), (8,10)]
然后跑并对比。
stage op observed in expected out observed out
conv1 Conv2d (8, 3, 64, 64) (8, 16, 64, 64) (8, 16, 64, 64)
relu1 ReLU (8, 16, 64, 64) (8, 16, 64, 64) (8, 16, 64, 64)
pool1 MaxPool2d (8, 16, 64, 64) (8, 16, 32, 32) (8, 16, 32, 32)
conv2 Conv2d (8, 16, 32, 32) (8, 32, 32, 32) (8, 32, 32, 32)
relu2 ReLU (8, 32, 32, 32) (8, 32, 32, 32) (8, 32, 32, 32)
pool2 MaxPool2d (8, 32, 32, 32) (8, 32, 16, 16) (8, 32, 16, 16)
gap AdaptiveAvgPool2d (8, 32, 16, 16) (8, 32, 1, 1) (8, 32, 1, 1)
fc Linear (8, 32) (8, 10) (8, 10)
first divergence: none
parameters: 5,418
跟踪器
产出这张表约二十行,不改模型。register_forward_hook 在模块 forward 返回后跑回调,收到模块、输入与输出。
from contextlib import contextmanager
@contextmanager
def trace_shapes(model):
"""Record the output shape of every leaf module during one forward pass."""
rows, handles = [], []
def make_hook(name):
def hook(module, inputs, output):
ins = [tuple(t.shape) for t in inputs if torch.is_tensor(t)]
out = tuple(output.shape) if torch.is_tensor(output) else type(output).__name__
rows.append((name, type(module).__name__, ins[0] if ins else None, out))
return hook
for name, module in model.named_modules():
if name and not list(module.children()): # leaves only
handles.append(module.register_forward_hook(make_hook(name)))
try:
yield rows
finally:
for h in handles:
h.remove()
def report(rows, expected):
first = None
for i, (name, kind, oin, oout) in enumerate(rows):
exp = tuple(expected[i]) if i < len(expected) else None
agree = exp is None or exp == tuple(oout)
if not agree and first is None:
first, mark = name, " <-- FIRST DIVERGENCE"
elif not agree:
mark = " (downstream)"
else:
mark = ""
print(f" {name:<8}{kind:<12}{str(exp):<20}{str(oout):<20}{mark}")
print(" first divergence:", first or "none")
三细节 load-bearing。named_modules() walk 是第 5 章的已注册模块树——跟踪器看到的正好 PyTorch 注册的,普通 Python 列表里的未注册层这里也看不见。只留叶,避免容器输出与其最后孩子重复打印。finally 重要:hook 忘摘活过调试,在训练时悄悄打印。
重要局限:hook 观测模块边界。forward 里 torch.flatten 或 F.relu 不是模块,不出现。前向里函数式调几何,要么那些行直接打点,要么用 nn.Flatten 与 nn.ReLU 模块让跟踪器看得见。
出错时长什么样
上面 SmallCNN 用自适应池化,去掉 conv2 padding 只改变中间形状但不产出 Linear mismatch:AdaptiveAvgPool2d((1, 1)) 仍交 [B, 32] 给 fc。要暴露经典下游症状,用固定空间 head 变体:去掉 gap,pool2 后展平,fc = nn.Linear(32 * 16 * 16, 10),去掉 conv2 padding 而保留原形状预测:
RuntimeError: mat1 and mat2 shapes cannot be multiplied (8x7200 and 8192x10)
stage op expected out observed out
conv1 Conv2d (8, 16, 64, 64) (8, 16, 64, 64)
pool1 MaxPool2d (8, 16, 32, 32) (8, 16, 32, 32)
conv2 Conv2d (8, 32, 32, 32) (8, 32, 30, 30) <-- FIRST DIVERGENCE
pool2 MaxPool2d (8, 32, 16, 16) (8, 32, 15, 15) (downstream)
first divergence: conv2
异常点名 Linear 层。跟踪点名 conv2。两答案的 gap 就是本章。
也注意跟踪在故障点后还有行,因为 hook 随每模块完成触发,异常在后面才来。末行是 pool2 不是 fc——run 死在 fc 里,它的 hook 没触发。部分跟踪仍是证据。
展平边界
大多数分类器在某处不再把张量当网格,当特征向量。这个转换值得注意,因为它改变轴的含义。
before (8, 32, 16, 16)
flatten(x, 1) (8, 8192) 32*16*16 = 8192
flatten(x) (65536,) 8*32*16*16 = 65536
x.mean((2,3)) (8, 32)
torch.flatten(x, 1) 的 1 是起始维:axis 1 往后塌成一轴,axis 0 不动。丢了它 batch 轴也塌,产出 65536 元单向量,八个样本 concat 一起。那个张量不再是八个样本,恰好碰上 in_features 对上的 Linear 层不抱怨地为八张图产出一行 logits。
所以这个边界的问题永远同一个:
8192 从哪来?
它来自 32 * 16 * 16,来自声明的通道数与推导的空间尺寸。三独立决定乘成一个数,再硬编码进下一层:
nn.Linear(32 * 16 * 16, 10)
这样写而不是 nn.Linear(8192, 10),至少因子可见。这是可读性真改进,不是解——数字仍是对上面几何的断言,乘法失败前没东西检查断言。
两相关机制归第 2 章不归这里,这里是指针而不是重教。flatten 与 reshape 处理非连续张量;view 不会,permute 后可能见 view size is not compatible with input tensor's size and stride。修复是 reshape 或 contiguous().view(...),诊断是第 2 章讲的步长检查。
上游导致的 Linear 错
这里是失败的普通形态。网为 64×64 输入写,有人给第二卷积加了步长,出现这个:
RuntimeError: mat1 and mat2 shapes cannot be multiplied (8x2048 and 8192x10)
报错是关于矩阵乘法的事实:[8, 2048] 激活碰上 [8192, 10] 权重。建议的修复自己写出来,助手一行给出:
nn.Linear(2048, 10) # was 32 * 16 * 16
这个修复可能对。恰在产出 2048 的几何变化是故意的时对。步长 deliberate——故意做的下采样决定——2048 就是对的特征数,分类器该跟着改。
步长不是故意的,改 in_features 是把 accidental 结构改永久,还是在没人会找的地方。模型会训。什么都不抛。结构变成没人选过的东西。
这就是报错信息回答的问题与你手里问题不同的原因:
维度错告诉你哪个契约坏了。它不告诉你契约哪边错了。
调查按顺序:
1. derive the expected shape after every spatial layer
2. trace the actual shapes
3. find the FIRST divergence
4. decide whether that divergence was intended
5. only then update anything downstream
步骤 4 是关于结构的决定,唯一不能自动化的步骤。
逐步 sequential 诊断
这里有个几 fault 同时的网,现实情形。它带着产出 [B, H, W, C] 的流水线的 batch 到来。
class BrokenCNN(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(32, 32, 3)
self.pool2 = nn.MaxPool2d(2)
self.fc = nn.Linear(32 * 16 * 16, num_classes)
def forward(self, x):
x = self.pool1(F.relu(self.conv1(x)))
x = self.pool2(F.relu(self.conv2(x)))
return self.fc(torch.flatten(x, 1))
意图结构,动任何东西前写下,8 张 64×64 的 batch:
input [8, 3, 64, 64]
conv1 [8, 16, 64, 64] 16 channels, padding=1 preserves 64
pool1 [8, 16, 32, 32] halved
conv2 [8, 32, 32, 32] 32 channels, spatial preserved
pool2 [8, 32, 16, 16] halved
flatten [8, 8192] 32 * 16 * 16
fc [8, 10]
Run 1.
RuntimeError: Given groups=1, weight of size [16, 3, 3, 3],
expected input[8, 64, 64, 3] to have 3 channels, but got 64 channels instead
收到的形状就印在那:[8, 64, 64, 3]。四轴,唯一 plausibly 通道数的是末尾。这是开篇失败,修复在输入边界,不在层:
x = batch.permute(0, 3, 1, 2).contiguous()
只修那个。重跑。
Run 2.
RuntimeError: Given groups=1, weight of size [32, 32, 3, 3],
expected input[8, 16, 32, 32] to have 32 channels, but got 16 channels instead
同样形状的不同信息。现在收到的张量真是 [B, C, H, W]——32×32 格上 16 通道,正是 pool1 预测产出的。所以张量对,层错:conv1 产出 16 通道而 conv2 为 32 建。这是组合契约:
conv1.out_channels == conv2.in_channels
除非中间有东西故意改通道数。没有。conv2 stale——第一层产出 32 通道时建的,从没更新。
self.conv2 = nn.Conv2d(16, 32, 3)
只修那个。重跑。
Run 3.
RuntimeError: mat1 and mat2 shapes cannot be multiplied (8x7200 and 8192x10)
decoy 是 nn.Linear(7200, 10)。推导:
conv1: H -> 64
pool1: H -> 32
conv2: H -> 30 <-- expected 32
pool2: H -> 15
conv2 无 padding。3×3 核 padding=0 在 32×32 输入上给 30,7200 = 32 * 15 * 15。意图结构要 conv2 保空间尺寸,即 padding=1。Linear 层从没错;它是唯一诚实抱怨的层。
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
Run 4.
stage op expected out observed out
conv1 Conv2d (8, 16, 64, 64) (8, 16, 64, 64)
pool1 MaxPool2d (8, 16, 32, 32) (8, 16, 32, 32)
conv2 Conv2d (8, 32, 32, 32) (8, 32, 32, 32)
pool2 MaxPool2d (8, 32, 16, 16) (8, 32, 16, 16)
fc Linear (8, 10) (8, 10)
first divergence: none
三 fault,三跑,一次一修,全程没猜。每条报错信息点了真违反的契约,没有一条点了病因。纪律是一次修一处,重跑,让下个分歧自己 present,因为三问题在途时做的修复是没有证据的修复。
自适应池化声明输出契约
Linear(32 * 16 * 16, 10) 脆的原因是它把中间空间尺寸编码进分类器。输入分辨率一换、步长一加、池化一插,数就错。
AdaptiveAvgPool2d 反转关系。不从输入尺寸算输出尺寸,你声明输出尺寸,层安排池化区产出它:
self.gap = nn.AdaptiveAvgPool2d((1, 1))
input (32, 32) features (2, 32, 8, 8) gap (2, 32, 1, 1) flatten (2, 32)
input (64, 64) features (2, 32, 16, 16) gap (2, 32, 1, 1) flatten (2, 32)
input (31, 31) features (2, 32, 7, 7) gap (2, 32, 1, 1) flatten (2, 32)
input (97, 53) features (2, 32, 24, 13) gap (2, 32, 1, 1) flatten (2, 32)
input (224, 224) features (2, 32, 56, 56) gap (2, 32, 1, 1) flatten (2, 32)
卷积 body 产出不同空间特征图,自适应层每次给分类器同样 [B, 32, 1, 1] 契约。(1, 1) 时自适应平均池化等于两空间轴求平均。
这去掉一个依赖;没让 body 几何 free。body 仍须产得出特征图,接受新分辨率不证明模型在该分辨率行为好。
AdaptiveAvgPool2d((1, 1)) 还按通道在格上平均丢空间位置。分类合适,位置是目标一部分时不合适。先理解固定 C*H*W 依赖;自适应池化再成 deliberate 契约,而不是避开推导形状的办法。
参数数揭示什么
卷积参数数依赖通道与核几何,不依赖输入高宽:
感受野是累积几何
形状说特征图多大。感受野问原输入多少能影响图中一位置。
步长 1、dilation 1 的 3×3 卷积 plain 堆叠,结构范围随层加 3 → 5 → 7 → 9 长。步长 dilation 让它长得更快。
梯度探针能让选定模型输入的 active 数值依赖可见,但零梯度本身不证明结构依赖不可能:权重、非线性、抵消也能产出零。
局部算子复合成更大的空间依赖。
形状复合并证明含义
第 7 章的警告模型里仍适用:正确的形状台账证明维度复合成,不证明轴是你想要的意思。
非方输入,高宽互换能保展平特征数因为 C * H * W == C * W * H。每层能跑,分类器能接受,图像几何错了。
| A verified shape ledger supports | It does not establish |
|---|---|
| layer dimensions compose | axis semantics are correct |
| channel contracts match | the architecture suits the task |
| derived and observed geometry agree | preprocessing preserved meaning |
in_features matches flatten |
predictions are correct |
台账诊断几何。第 7 章的已知样本与语义检查诊断含义。
结构化读维度错
把维度错当违反的契约看,不当指令:
| Symptom | First questions |
|---|---|
expected ... 3 channels, got 224 |
什么形状到了?batch 张量里 axis 1 什么意思?224 真的是高或宽吗? |
expected ... 32 channels, got 64 |
输入哪层产的?它的 out_channels 对这层的 in_channels 吗? |
mat1 and mat2 shapes cannot be multiplied |
什么 C*H*W 到了展平?前面哪个几何变化产出它?那个变化是故意的吗? |
本章通篇 batch [B,C,H,W] 张量,Conv2d 从 axis 1 读通道。PyTorch 也接受无 batch [C,H,W] 输入,那时通道轴是 0。
报错标识契约在哪变不合法。上游错误本身合法时,根因能早好几层。
哪些算子可能是凶手
有用的 narrowing,因为大多数网立刻排除:
| Operation | Channels | Spatial | Feature dim |
|---|---|---|---|
Conv2d |
C_in → C_out |
may change | — |
MaxPool2d / AvgPool2d |
unchanged | may change | — |
AdaptiveAvgPool2d |
unchanged | set to declared size | — |
ReLU, Sigmoid, Dropout, BatchNorm2d |
unchanged | unchanged | — |
flatten(x, 1) |
— | — | C*H*W |
Linear |
— | — | in_features → out_features |
验证过:
ReLU (4, 16, 31, 31) -> (4, 16, 31, 31)
BatchNorm2d (4, 16, 31, 31) -> (4, 16, 31, 31)
Dropout (4, 16, 31, 31) -> (4, 16, 31, 31)
Sigmoid (4, 16, 31, 31) -> (4, 16, 31, 31)
Conv2d(16,16,1) (4, 16, 31, 31) -> (4, 16, 31, 31)
Conv2d(16,32,3) (4, 16, 31, 31) -> (4, 32, 29, 29)
MaxPool2d(2) (4, 16, 31, 31) -> (4, 16, 15, 15)
H 16 变 15,激活函数没干。只有 Conv2d、池化层或改输入分辨率的东西可能是凶手,通常两三个候选而不是二十个。
BatchNorm2d 在这张表只有一个原因:它在几乎每个真 CNN 里出现,几何上 inert。它的统计行为——运行统计、train vs eval、batch 1 发生什么——真有意思,归训练行为材料,不归这里。形状推理里它是 no-op,当 no-op 让本章 scope 完整。
不跑读结构
终态是看四行跑前回答问题。
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.pool = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.fc = nn.Linear(32 * 8 * 8, 10)
input 32x32: input 32 -> conv1 32 -> pool 16 -> conv2 16 -> pool 8
flatten 2048 fc wants 2048 composes=True
input 64x64: input 64 -> conv1 64 -> pool 32 -> conv2 32 -> pool 16
flatten 8192 fc wants 2048 composes=False
模型没坏。分类器真正声明的是内部契约:卷积 body 展平前必须产出 8×8 空间格。32×32 输入是满足契约的一条路,floor 算子能把附近几个输入尺寸映到同样 8×8 结果。8 * 8 倒读恢复要求的内部几何,再测哪些输入尺寸真满足。
把契约写下来
第 7 章把预处理期待变成断言。同样动作在部件边界有用:
在 CNN 几何上用 AI
stack trace 让局部 plausible 的修复容易 propose:
CNN 几何调试序列
练习
- 开篇失败,两种修法。 触发 NHWC 错。一次改
in_channels修,一次置换张量修。比输出形状、权重形状、参数数。 - 手算一次卷积。 4×4 输入上算 2×2 核,再三输入通道重复,与
F.conv2d对。 - 推导并验证。 实现
conv_out,sweep 核/步长/padding/dilation 组合,断言预测空间尺寸与 PyTorch 一致。 - 先预测再跟踪。 选没写过的 CNN。跑前记每期待形状,挂跟踪器,找第一次不一致。
- 三 fault,三跑。 复现
BrokenCNN序列:NHWC 输入、stalein_channels、缺 padding。每次恰修一分歧。 - 自适应池化。 一卷积 body 几个输入分辨率跑,有无
AdaptiveAvgPool2d各一遍。记自适应层去掉什么依赖、没去掉什么。 - 证明不了的台账。 非方输入,高宽互换,构造形状仍全复合成的情形。加抓住错误的语义检查。
下一步:无格的特征
模型边界不再 opaque。卷积做两独立变换——声明的通道变换与推导的空间几何变换——层跑前都写得下。池化做后者不做前者。展平把格变成长度 C * H * W 的特征向量。Linear 把一特征维映到另一维。每样都机械,观测跟踪与推导不一致时,第一次不一致就是诊断。
本章中心的两失败值得成对带走。NHWC batch 产出点名错问题的错,修层而不是修张量会从误读建出模型。缺 padding 的错在下游好几层报,修报的层会把 unintended 结构永久化。两是同样形状的错误:
CNN 是一串张量几何契约。每个改形状的算子后写下期待的
[B, C, H, W],跑模型,调查现实与推导第一次不一致处。报错信息告诉你哪个契约坏了。它不告诉你契约哪边错了。
注意本章止于哪。卷积 body、池化、展平后张量是:
[B, 32]
空间格没了。剩下每样本一向量,32 个条目是无相邻、无顺序、无图的 learned 特征坐标。分类器实际看到的就是它,nn.Linear(32, num_classes) 把它当 32 维空间的点,问落边界哪边。
三十二已是画不出的维数。真实特征向量 128、512、768、4096。下一章认真对待,问画不出的空间里坐标、方向、边界到底什么意思——从零建分类器说明直觉停了几何还 work。
进特征空间。