CNN卷积神经网络

前面几篇我一直在讲语言这边——RNN、Attention、Transformer.但深度学习最早真正炸出圈的应用不是翻译,是看图.2012年AlexNet拿下ImageNet冠军,才是这一轮深度学习浪潮的起点,比ChatGPT早了整整十年.

这篇讲 CNN(Convolutional Neural Network,卷积神经网络):它要解决什么问题、卷积到底在算什么、那些核大小/步长/填充/通道的参数怎么配对、形状怎么一步步变、为什么它能成,以及它和今天统治一切的Transformer到底是什么关系.

我默认你有神经网络基础(知道全连接层、损失函数、反向传播大致怎么回事),但没碰过卷积.所有公式我都会配一张符号表.

先看图片为什么不能直接喂全连接

一张RGB图片在计算机里就是一个三维数组:H×W×3H \times W \times 3(高 × 宽 × 通道).比如 224×224×3224\times224\times3,把它拉平就是一个长度 224×224×3=150,528224\times224\times3 = 150{,}528 的向量.

理论上它可以喂进全连接网络(MLP),但实际上做不了,两个原因:

第一,参数量爆炸. 接一个只有1024个神经元的隐藏层,参数量是 150528×1024≈1.5150528 \times 1024 \approx 1.5 亿.这还只是输入层到第一层,而且1024个神经元对图像来说少得可怜.后面每接一层,参数量都在百万级往上叠,根本训不动.

第二,拉平就把空间结构扔了. 相邻像素之间的关系、物体的轮廓和纹理,全在”谁挨着谁”这件事里.拉成一个长向量之后,第1个元素和第150528个元素在图上的位置关系彻底丢失,模型得从零开始学”这两个像素是邻居”.这就是**没有归纳偏置(inductive bias)**的代价——不是学不会,是需要多得离谱的数据才学得会.

CNN的全部设计,都是在回应这两条:

这两条要分清楚,它们是彼此独立的两件事:局部连接管的是”每个输出点看多大范围”,参数共享管的是”这些连接上用不用同一套权重”.两者各自都能独立地省参数——但省的那部分不一样:局部连接不能让参数摆脱图片尺寸(位置变多,连接跟着变多);参数共享能,因为不管多少个位置,都只有一套权重.只有共享而不局部(每个输出点都连着整张图,但共用一套权重)则过头了:参数量是极小的,但”图上任何位置都按同一方式汇总全图”这个假设对图像基本不成立,表达能力被压得太死.所以卷积是两个一起上:局部连接保证看得合理,参数共享保证记得省.

注:同一个卷积有两种等价的画法,别被绕进去.画法A:一个核在图上滑,每滑到一个位置产出一个数;画法B:输出特征图上每个位置各站一个神经元,固定只接收输入图对应位置那个 k×kk\times k 窗口,做加权求和.两种画法算出来的是同一批数——B里那个”神经元”就是A里某个滑动位置输出的那个点,它接收的窗口就是那一刻核罩住的区域.所以后面我再写”某个神经元看到多大的窗口”,说的都是输出特征图上的点及其感受野,不是输入图上的像素,也不是真有谁在扫描.

顺手算一笔账,最能说明问题.单通道输入 5×55\times5、核 3×33\times3、步长1、不填充,输出是 3×33\times3 共9个位置,每个位置连9个输入:

方案连接数参数量
全连接225225
局部连接,但不共享权重8181
局部连接 + 参数共享(卷积)819

这两列要分别数:

于是能看清两件事各自的贡献:局部连接把”每个输出点连几个输入”从25砍到9(225→81);参数共享再把”这些边是否各配一套权重”合并成一套(81→9).注意最后那9个参数是独立于输入尺寸的:输入换成 500×500500\times500,输出的位置多到几万个,但每个位置共用那9个权重,参数量还是9.

81 是怎么冒出来的:9个输出点对着9个不同的窗口

这一步最容易想歪——9个输出位置,对应的不是同一个 3×33\times3 窗口,而是9个位置错开的窗口.

输出位置 (i,j) ← 连输入的行 {i,i+1,i+2} × 列 {j,j+1,j+2}

输出(0,0) ← 行{0,1,2} × 列{0,1,2}    ← 9条边
输出(0,1) ← 行{0,1,2} × 列{1,2,3}    ← 9条边
输出(0,2) ← 行{0,1,2} × 列{2,3,4}    ← 9条边
输出(1,0) ← 行{1,2,3} × 列{0,1,2}    ← 9条边
   ⋮               ⋮                     ⋮
输出(2,2) ← 行{2,3,4} × 列{2,3,4}    ← 9条边

9个窗口(互相重叠,但位置各不相同) × 每个9条边 = 81条边

所以”每个输出位置只连一个 3×33\times3 窗口”和”总边数81”不矛盾:窗口是9个,不是一个;每个窗口各自占9条边.

“81个参数”则是不共享时的数法:81条边各配一个独立权重,自然是81个.一旦共享,这81条边上的权重只从那个 3×33\times3 的核里取值——处在窗口内同一个相对位置的边,用同一个权重:

核(就这9个数):        w₀₀ w₀₁ w₀₂
                      w₁₀ w₁₁ w₁₂
                      w₂₀ w₂₁ w₂₂

输出(0,0)的9条边 → w₀₀ w₀₁ w₀₂ / w₁₀ w₁₁ w₁₂ / w₂₀ w₂₁ w₂₂
输出(0,1)的9条边 → w₀₀ w₀₁ w₀₂ / w₁₀ w₁₁ w₁₂ / w₂₀ w₂₁ w₂₂
   ⋮                        ⋮
输出(2,2)的9条边 → w₀₀ w₀₁ w₀₂ / w₁₀ w₁₁ w₁₂ / w₂₀ w₂₁ w₂₂

每个 w 都出现在9条边上   →   9 × 9 = 81 条边 ✓
独立参数只有 9 个         →   参数量 = 9

一句话:核整块搬到9个位置,搬的时候参数不变.换言之,核是一个模板,在81条边上被引用了9遍.

数值怎么来的
输出位置数9输出 3×33\times3
每个位置的边数(核里几个数)93×33\times3
连接数(边数)819×99\times9
参数量(共享后)9独立权重只有核里那9个

注:一个判据——参数量不可能超过”核里有几个数”.3×33\times3 的核就是9个数,所以参数量是9;81 是”这个核被用了多少次”,不是”这个核有多少参数”.这两列在单通道小例子里恰好是81和9,最容易串行.

同样的算法放到真实尺寸上,差距就非常直观了——输入 224×224224\times224、单通道、还是 3×33\times3 核、步长1、不填充:

方案连接数 / 参数量量级
全连接2242×2222≈2.5×109224^2 \times 222^2 \approx 2.5\times10^{9}25亿
局部连接,不共享9×2222≈4.4×1059 \times 222^2 \approx 4.4\times10^{5}44万
局部连接 + 共享999

注:上面”参数量 = 连接数”是跟全连接/MLP 对照时的简化数法(每个连接各配一个权重),放在单通道小例子里最干净.真实卷积层的参数量按通道算:Cin×Cout×kh×kw+CoutC_{in}\times C_{out}\times k_h\times k_w + C_{out},和输出位置数无关.两套算法在单通道例子里数值都落在 k2k^2 上,一到多通道就分道扬镳了,别混着用.

注:这和语言那边的思路可以对照看.RNN假设”顺序即信息”,Transformer假设”任意两个位置都可能相关,距离不重要”.CNN假设的是”相邻的像素相关,而且同一个模式出现在图片任何位置都是同一个东西”.三种假设对应三种架构,架构就是先验.

卷积:一个滑动的窗口

卷积操作说人话就是:拿一个小窗口在图上从左到右、从上到下滑动,每滑到一个位置,就把窗口罩住的那一小块和一组对应的权重做逐元素相乘再求和,得到一个数.

那组权重就是卷积核(kernel / filter),大小通常是 3×33\times3 或 5×55\times5——比整张图小得多,这就是局部连接.

注:这里有两个东西,别混.一个是窗口——它在输入图上占哪块区域(数据),滑到不同位置就是不同的窗口;另一个是核——那 k×kk\times k 个可学习的权重(参数),每个位置用的都是同一套.工程上说”滑动窗口”时,动的其实是窗口的位置,而真正被学习、被复用的是核.所以”一个核扫全图”这句话的准确含义是:核不变,窗口在变.

输入(单通道 5×5)            卷积核 3×3            输出特征图 3×3
1  0  1  0  0              1  0  1
0  1  0  1  0              0  1  0        19   8   6
1  0  1  0  1      ⊛       1  0  1   =     8  13   8
0  1  0  1  0                               6   8  10
1  0  1  0  1

窗口从左上角开始逐格滑动,每滑一格产出一个数

为什么这个操作有用?看一个具体的核——竖直边缘检测器:

-1  0  1
-1  0  1
-1  0  1

把它罩在”左边暗、右边亮”的地方,右边一列(+1+1)加起来的和大,左边一列(−1-1)加起来的和小,结果是一个大正数;罩在纯色区域上,左右抵消,结果是0.所以同一个核在”有竖直边”的地方输出大、在”没边”的地方输出小——它输出的那张图,标记的就是”原图哪些位置有竖直边”.

注:核里的数是学出来的,不是人手工设计的.上面那个边缘检测器只是一个便于理解的例子.真实网络第一层学出来的核,往往确实长得像各种方向的边缘/颜色对比检测器,越往深层越像纹理和局部形状——这是CNN可视化的经典结论.

严格的数学定义里,卷积是带翻转的:

(I∗K)(i,j)=∑m∑nI(i−m, j−n) K(m,n)(I * K)(i,j) = \sum_{m}\sum_{n} I(i-m,\ j-n)\,K(m,n)

而深度学习里用的其实是互相关(cross-correlation),没有翻转:

(I⋆K)(i,j)=∑m∑nI(i+m, j+n) K(m,n)(I \star K)(i,j) = \sum_{m}\sum_{n} I(i+m,\ j+n)\,K(m,n)

符号含义
II输入特征图
KK卷积核,kh×kwk_h \times k_w
∗*严格卷积(带翻转)
⋆\star互相关(不翻转,深度学习实际用的)
(i,j)(i,j)输出特征图上的位置
m,nm,n核内的偏移量,m∈[0,kh),n∈[0,kw)m\in[0,k_h),n\in[0,k_w)

“翻转”到底翻了什么

翻转就是把核旋转180°——先左右镜面,再上下镜面,两次 flip 合起来等价于绕中心转一圈:

原核 K                左右镜像              再上下镜像
1  2  3               3  2  1               9  8  7
4  5  6      ──→      6  5  4      ──→      6  5  4
7  8  9               9  8  7               3  2  1

即 K_flip(i,j) = K(k-1-i, k-1-j)

**注意只有核翻转,输入始终不动.**两个定义唯一的差别是输入下标里的符号:严格卷积是 i−mi-m(减号),互相关是 i+mi+m(加号).而”减号”这个写法等价于”先把核翻180°、再和窗口逐元素相乘求和”:

(I∗K)(i,j)=∑m∑nI(i+m, j+n) Kflip(m,n)(I * K)(i,j) = \sum_{m}\sum_{n} I(i+m,\ j+n)\,K_{\text{flip}}(m,n)

同一组权重下,两种算法给出的数完全不同,看一个算例(3×33\times3 输入、3×33\times3 核):

输入: 1 2 3      核: 1 2 3
      4 5 6          4 5 6
      7 8 9          7 8 9

互相关(左上角一个位置):
  1×1 + 2×2 + 3×3 + 4×4 + 5×5 + 6×6 + 7×7 + 8×8 + 9×9 = 285

严格卷积(同一位置,核先翻转成 9 8 7 / 6 5 4 / 3 2 1):
  1×9 + 2×8 + 3×7 + 4×6 + 5×5 + 6×4 + 7×3 + 8×2 + 9×1 = 165

**285 和 165 是两个不同的数.**所以”带不带翻转”不是命名之争,是真的换了一个运算.

那为什么深度学习可以不管它?因为核是训练出来的:翻转是个固定变换,而训练会把权重放到该去的位置.如果某个严格卷积的最优核是 KK 的翻转版,那在互相关框架下直接学出 KK 就行——参数空间覆盖得到,表达能力一模一样.所以 PyTorch 的 nn.Conv2d 实现的是互相关,名字却叫 Conv——这是历史叫法,不是bug.

注:术语上还有个坑.信号处理里说的”卷积”是带翻转的那个;而CNN论文和PyTorch文档里说的”卷积”一律是互相关.你在读公式时只要盯住输入下标是 i−mi-m 还是 i+mi+m,就能判断这段话用的是哪一套.

注:**上面这套”等价”有个前提——核必须是可学的.**换成固定权重就不成立了:假如你手写一个竖直边缘检测器、核的九个数是 -1 0 1 / -1 0 1 / -1 0 1,塞进 nn.Conv2d 并冻结,互相关检测的是”左暗右亮”的竖直边,而严格卷积(核翻过来变成 1 0 -1 / 1 0 -1 / 1 0 -1)检测的是”左亮右暗”——方向正好相反.所以”拿经典滤波器初始化""冻结某些层""分析预训练模型到底学到了什么”这几类场景下,翻不翻转会真的改变结论.

核必须是正方形吗

不必须.核的高和宽是彼此独立的两个超参数,3×53\times5、1×71\times7、5×35\times3 都合法,PyTorch 里写成元组就行:

nn.Conv2d(3, 64, kernel_size=3)          # 3×3,最常见的写法
nn.Conv2d(3, 64, kernel_size=(1, 3))     # 1×3,只看水平方向三个像素
nn.Conv2d(3, 64, kernel_size=(3, 1))     # 3×1,只看垂直方向三个像素
nn.Conv2d(3, 64, kernel_size=(3, 5))     # 3×5 矩形核

形状公式也要相应拆开(高用 khk_h、宽用 kwk_w):

Hout=⌊Hin+2Ph−D(kh−1)−1Sh⌋+1,Wout=⌊Win+2Pw−D(kw−1)−1Sw⌋+1H_{out} = \left\lfloor \frac{H_{in} + 2P_h - D(k_h-1) - 1}{S_h} \right\rfloor + 1,\qquad W_{out} = \left\lfloor \frac{W_{in} + 2P_w - D(k_w-1) - 1}{S_w} \right\rfloor + 1

注意参数量的算法跟方形完全一样,只是把 k2k^2 换成 khkwk_h k_w:

Params=kh×kw×Cin×Cout+Cout\text{Params} = k_h \times k_w \times C_{in} \times C_{out} + C_{out}

所以 3×53\times5 核是15个权重,1×71\times7 核只有7个——矩形核往往是省参数的手段,不只是”形状选择”.

什么时候真的会用非方核:

核形状用在哪为什么
1×k1\times k / k×1k\times1Inception 系列、MobileNet 的分解卷积把 n×nn\times n 拆成 1×n1\times n 和 n×1n\times1,参数量从 n2n^2 降到 2n2n
k×dk\times d (dd = 词向量维度)文本分类(Kim CNN,即 TextCNN)文本只有一个”宽度”,所以核宽固定为词向量维度,核高=窗口里几个词
k×1k\times 1一维时序、音频、心电图只有时间一个方向要卷
大而瘦,如 1×151\times 15语音识别频率轴上变化快、时间轴上变化慢,用不对称的核匹配这种结构

非方核最有名的用法是分解:一个 n×nn\times n 卷积可以拆成 1×n1\times n 接 n×1n\times1,串联起来感受野仍是 n×nn\times n,但参数量从 n2n^2 变成 2n2n——n=7n=7 时是 49→1449 \to 14.代价是有损的:n2n^2 个自由度压成了 2n2n 个,模型只能表达那些”可以拆成行列两步”的核.

注:**别把”1×31\times3 接 3×13\times1“和”两个 3×33\times3 串联”搞混.**前者合起来感受野 3×33\times3,后者是 5×55\times5;前者省参数(6 个权重 vs 18 个),后者表达力更强.前面 VGG 那节讲的”小核堆深”是后者,Inception 讲的”分解”是前者,两件事.

注:还有个容易踩的坑——只有空间上的两维可以不对称. 核的形状其实是四维的 (kh, kw, Cin, Cout)(k_h,\,k_w,\,C_{in},\,C_{out}),后面两维是输入输出通道,必须和你想连的通道数匹配;能自由选方不方的,只有前面那两维.所以”核是不是方的”这个问题,问的永远是空间维度,和通道没关系.

把它摞成网络:特征图、通道和”越深看得越抽象”

单个核只检测一种模式.所以一层里我们会放很多个核,每个核输出一张特征图(feature map),这些图叠起来就是一个新的”图片”,它的通道数 = 核的个数.

于是”图片”这个概念在网络里一路演化下去:

输入图            第1层(边缘)          第2层(纹理)         第3层(部件)         第4层(物体)
H×W×3     ──→    H×W×32       ──→     H/2×W/2×64  ──→   H/4×W/4×128  ──→   H/8×W/8×256
  像素            各种方向的边          边拼成的纹理        眼睛、轮子          猫脸、车身

这里有两件事同时发生:

  1. 空间尺寸在变小(H,WH,W 减半),因为每过几层就下采样一次——远处一个像素不需要那么高的分辨率;
  2. 通道数在变大(32 → 64 → 128 → 256),因为”高层语义的种类”比”像素的种类”多得多.

这就是CNN的层级特征(hierarchical features):浅层看细节,深层看语义. 而且这不是设计者手工规定的,是训练自己学出来的——你只规定了每层有几个核、多大,至于核里学成什么,网络自己决定.

到最后的分类头,空间上的 7×77\times7 会被压成 1×11\times1,通道数就是特征维度,再接一个线性层出类别分数.

六个参数:大小、步长、填充、通道、组、空洞

看 nn.Conv2d 的签名,最常见的六个参数:

nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3,
          stride=1, padding=1, groups=1, dilation=1, bias=True)
参数含义直觉
in_channels输入通道数每个核的”厚度”,必须和输入对齐
out_channels输出通道数 = 核的个数这一层想检测多少种模式
kernel_size核的空间大小 kh×kwk_h \times k_w每次看多大范围
stride滑动步长步长2 = 输出尺寸减半,顺手降采样
padding四周补几圈0补1且 k=3k=3 时输出尺寸不变
groups分组数组卷积,深度可分离卷积的基础
dilation核内元素间隔不增加参数就扩大感受野(空洞卷积)

最关键的一条记忆:参数量完全不含输入尺寸.

Params=kh×kw×Cin×Cout+Cout\text{Params} = k_h \times k_w \times C_{in} \times C_{out} + C_{out}

一个 3×33\times3、输入3通道、输出64通道的卷积层,参数量是 3×3×3×64+64=17923\times3\times3\times64 + 64 = 1792 个.换成 224×224224\times224 的图还是1792个,换成 1024×10241024\times1024 的图也还是1792个——这就是参数共享的威力.

而如果要用全连接层处理这个 1024×1024×31024\times1024\times3 的输入,第一层就是十亿级参数.CNN把”图像大小”从参数量里彻底移除了.

输出形状怎么算

这是写代码时最容易报错的地方,公式其实只有一个:

Hout=⌊Hin+2P−D(k−1)−1S⌋+1H_{out} = \left\lfloor \frac{H_{in} + 2P - D(k-1) - 1}{S} \right\rfloor + 1

符号含义
HinH_{in}输入的高(宽同理)
PPpadding
kkkernel_size
SSstride
DDdilation
⌊⋅⌋\lfloor \cdot \rfloor向下取整——除不尽就丢掉右边/下边多出来的那部分

工程上你只需要记住三个常用组合:

组合效果
k=3, P=1, S=1k=3,\ P=1,\ S=1尺寸不变(最常用的”卷积+BN+ReLU”块)
k=3, P=1, S=2k=3,\ P=1,\ S=2尺寸减半并升通道(经典下采样)
k=1, P=0, S=1k=1,\ P=0,\ S=1尺寸不变,只做跨通道变换

核是怎么”换行”的:上下也走 stride

公式里高和宽为什么能共用一个 SS?因为上下移动和左右移动用的是同一个规则:核是一个整体,在二维平面上平移.

具体走位是:

  1. 左上角放下第一个窗口,产出输出图的 (0,0)(0,0);
  2. 右移 SS 列,直到再右移就会超出输入右边界(含 padding);
  3. 这一行结束,列起点归零,同时下移 SS 行;
  4. 重复,直到再下移会超出下边界.

注意第3步:**下移的是 SS 行,不是”核的高度”kk 行.**输入 7×77\times7、k=3k=3、S=2S=2 时:

行起点 = 0, 2, 4    (再 +2 = 6,而 6+3 = 9 > 7,越界,停)
列起点 = 0, 2, 4    (同理)
输出 = 3 × 3

   c=0     c=2     c=4
r=0 ┌───┐
    │▣▣▣│ .  .  .  .        ▣ = 3×3 的窗口
    │▣▣▣│ .  .  .  .
r=2 │▣▣▣│
    .  ┌───┐ .  .          第0行滑完 → 列归零、行 +2
    .  │▣▣▣│ .  .
    .  │▣▣▣│ .
r=4 .  .  ┌───┐
    .  .  │▣▣▣│ .
    .  .  │▣▣▣│ .

如果改成”下移一整个核的高度”,那 7×77\times7 只能放下 0..20..2、3..53..5 两行窗口,最后一行白白浪费,而且输出尺寸就跟 SS 脱钩了.所以高和宽必须同规则,形状公式才能一个式子管两个方向:

Hout=⌊Hin+2P−D(k−1)−1S⌋+1,Wout=⌊Win+2P−D(k−1)−1S⌋+1H_{out} = \left\lfloor \frac{H_{in} + 2P - D(k-1) - 1}{S} \right\rfloor + 1,\qquad W_{out} = \left\lfloor \frac{W_{in} + 2P - D(k-1) - 1}{S} \right\rfloor + 1

两个式子一模一样,只是把 HH 换成了 WW.

注:nn.Conv2d 的 stride 其实接收一个二元组 (s_h, s_w),所以水平和垂直方向是可以不一样的:写 stride=2 表示两个方向都是2,写 stride=(2, 1) 就是高减半、宽不变(处理宽高比悬殊的输入时偶尔用).但绝大多数网络用的是对称 stride,所以平时用一个 SS 讲就够了.

注:别把 stride 和 dilation 搞混——你问的”窗口整体挪多远”是 stride,“一个核内部采样点之间隔多远”是 dilation.两者都进形状公式,但位置不同:stride 在分母,dilation 在 D(k−1)D(k-1) 里.

注:向下取整就是上面那个 7×77\times7 例子的另一面——S=2S=2 时 77 是奇数,第6行落不进任何窗口,最后一行一列被直接丢掉.如果不希望丢信息,要么把 PP 调大凑成能整除的尺寸,要么接受它(主干网络里尺寸多数取2的幂次,就是为了少碰上这种奇数).

groups:把通道分组,组内各卷各的

默认 groups=1,意思是所有输入通道和所有输出通道全连在一起:每个输出通道都要看全部输入通道.groups=g 就是把两边都平均切成 g 份,第 ii 组只负责自己那 Cin/gC_{in}/g 个输入通道和 Cout/gC_{out}/g 个输出通道,组与组之间完全不通信:

groups=1(默认)              groups=2
C_in ──┬──┬──┬──┐           C_in ──┬──┬──┬──┐
       │  │  │  │                  │  └──┘  │
       └──┴──┴──┴──→ C_out        组1 → C_out前一半
  每个输出通道连全部输入           组2 → C_out后一半
                              组1和组2之间没有任何连接

参数量随组数成比例下降(因为每组各有一套核):

Params=g×(khkw×Cing×Coutg)+Cout=khkwCinCoutg+Cout\text{Params} = g \times \left(k_h k_w \times \frac{C_{in}}{g} \times \frac{C_{out}}{g}\right) + C_{out} = \frac{k_h k_w C_{in} C_{out}}{g} + C_{out}

三个必须记住的约束和特例:

点说明
整除约束CinC_{in} 和 CoutC_{out} 都必须能被 gg 整除,否则报错
计算量也降到 1/g1/g——不只是参数量省,FLOPs 也省
特例 g=Cing = C_{in}就是深度卷积(depthwise convolution),每个通道独立卷,再配一个 1×11\times1 做跨通道混合,合起来就是深度可分离卷积(省多少计算量后面”今天还用什么”那节单独算)

用真实的数看一眼省多少:

import torch, torch.nn as nn

# 普通卷积:3×3, 32→64, C_out 个偏置
m1 = nn.Conv2d(32, 64, 3, padding=1, groups=1)
print(sum(p.numel() for p in m1.parameters()))   # 18496 = 3*3*32*64 + 64

# 分组卷积:分成2组,每组16进32出
m2 = nn.Conv2d(32, 64, 3, padding=1, groups=2)
print(sum(p.numel() for p in m2.parameters()))   # 9280 = 3*3*16*32*2 + 64

# 深度卷积:每个通道自己卷自己
m3 = nn.Conv2d(32, 32, 3, padding=1, groups=32)
print(sum(p.numel() for p in m3.parameters()))   # 320 = 3*3*1*1*32 + 32

注:groups=32 那行共 320 个参数,其中权重 288 个、偏置 32 个.288 个权重意味着32 个通道各拿一套只属于自己的 3×33\times3(各自9个),合计 32×9=28832\times9=288——通道之间一个参数都不共享,这就是深度卷积的全部含义.

dilation:把核”撑开”,不花参数就扩大感受野

dilation 是核内部相邻采样点之间隔多少格.默认 dilation=1,就是挨着的;dilation=2 就是隔一格取一个:

dilation=1 的 3×3(9个采样点)      dilation=2 的 3×3(还是9个采样点)
■ □ □ □ □                        ■ □ □ □ □
□ ■ □ □ □          覆盖 3×3      □ □ ■ □ □          覆盖 5×5
□ □ ■ □ □                        □ □ □ □ ■
                                 ↑ 采样点之间空了一格

**关键:核还是 3×33\times3 九个权重,但罩住的范围变成了 5×55\times5.**这就是它被称为”空洞卷积”(atrous convolution)的原因——核被撑出了空洞.

有效感受野的公式:

keff=(k−1)⋅D+1k_{\text{eff}} = (k-1)\cdot D + 1

kkDD采样点个数(参数量)有效感受野 keffk_{\text{eff}}
3193
3295
3397
36913

参数量一列永远不变,感受野那一列随便涨——这就是”不增加参数就扩大感受野”.它解决的是一个很实际的问题:想要大感受野,通常得靠池化或步长卷积,但那样会丢分辨率;而分割、检测这类任务恰恰不能丢分辨率.空洞卷积让主干网络保持原分辨率的同时把感受野撑大,keffk_{\text{eff}} 那栏随 DD 线性增长,和”堆层数”相比非常划算.

注:空洞卷积的代价是网格效应(gridding)——采样点太稀疏时,相邻输出之间会漏掉一部分输入像素,特征图上可能出现棋盘状的伪影.所以实践中很少一路用同一个 DD,而是混合不同的 dilation(比如 DeepLab 的 ASPP 用 D=6,12,18D=6,12,18 并行几路再拼接),让采样点互相补位.这个多尺度并行 + 拼接的玩法,和 Inception 的多分支是同一个思路.

dilation 开了之后,边缘怎么办

你的直觉是对的:D=2D=2 时,窗口最外圈的采样点会伸到输入外面去——”3×33\times3 的格子”罩不住 5×55\times5 的范围,输出点越靠近边界,越容易有采样点落在外面.

      输入 7×7,D=2 的 3×3 核,左上角输出点 (0,0)

        采样点(行,列):(0,0) (0,2) (0,4)
                       (2,0) (2,2) (2,4)
                       (4,0) (4,2) (4,4)

      这里一个都没越界.但看下边界的输出点 (6,6):

        采样点:(6,6) (6,8) (6,10)
                (8,6) (8,8) (8,10)   ← 行列都到 8、10 了,输入只有 0..6
                (10,6)(10,8)(10,10)  ← 9 个采样点里 8 个落在外面

处理方式和普通卷积完全一样:越界的采样点按 padding 填值(默认填0). 变的不是机制,而是需要多少 padding——因为窗口的”实际跨度”从 kk 变成了 keff=(k−1)D+1k_{\text{eff}}=(k-1)D+1.

要保持输出尺寸和输入一样,必须满足 P=keff−12=(k−1)D2P = \dfrac{k_{\text{eff}}-1}{2} = \dfrac{(k-1)D}{2}:

kkDDkeffk_{\text{eff}}保持尺寸所需的 PP常见写法
3131padding=1
3252padding=2, dilation=2
3373padding=3, dilation=3
36136padding=6, dilation=6
5294padding=4, dilation=2

规律很干净:PP 就得跟着 (k−1)D/2(k-1)D/2 走.如果照旧只写 padding=1,输入 7×77\times7、k=3k=3、D=2D=2 就会得到 ⌊(7+2−5)/1⌋+1=5\lfloor(7+2-5)/1\rfloor+1=5——输出缩成 5×55\times5,而且每边少了1圈,越往深层缩得越快.这也是”为什么 DeepLab 里 dilation 从2涨到6、padding 也从2涨到6”的原因,它们是绑在一起设的:

# 保持空间尺寸不变的两种典型写法
nn.Conv2d(64, 64, 3, padding=1, dilation=1)   # 普通卷积, 感受野 3×3
nn.Conv2d(64, 64, 3, padding=2, dilation=2)   # 空洞卷积, 感受野 5×5, 尺寸不变

**这里有个关键理解:要对齐的是 5×55\times5 那条”实际覆盖边界”,不是 3×33\times3 的核框.**看几何:

D=1:  k_eff = 3, P = 1        外面那圈0的边界 = 3×3 的覆盖边界
      ┌─────────┐
      │ 0 0 0   │ ← padding 圈(1圈)
      │ 0 ■■■   │
      │ 0 ■■■   │  3×3 的覆盖范围恰好贴上0圈内沿
      │ 0 ■■■   │
      └─────────┘

D=2:  k_eff = 5, P = 2        外面那圈0的边界 = 5×5 的覆盖边界(3×3的框够不着)
      ┌───────────┐
      │ 0 0 0 0 0 │ ← padding 圈(2圈)
      │ 0 0 0 0 0 │
      │ 0 0 ■ □ ■ │   采样点最外两个落在第2圈上,
      │ 0 0 □ □ □ │   但"覆盖范围"是5×5,
      │ 0 0 ■ □ ■ │   所以要和5×5的边界对齐
      └───────────┘
              ↑ 采样点之间的空档里没有任何采样,
                但它仍算在覆盖范围内

也就是说:5×55\times5 是”物理覆盖范围”,3×33\times3 只是”有参数的位置”.padding 的作用是让那个物理覆盖范围的最外沿刚好贴住输入边界(含padding部分),这样输出尺寸才不变.直观校验:5×55\times5 要完整盖住 7×77\times7 并把中心对准原图中心,每边就得留2格,P=2P=2;留1格的话 5×55\times5 盖不满,输出自然小一圈.

换个更好记的说法:把空洞卷积当成”普通卷积,但核大小换成 keffk_{\text{eff}}“,那么普通卷积的一切结论(包括 P=(k−1)/2P=(k-1)/2 的直觉)照搬即可,只是那个”核”里有些位置权重恒定为0(那些被撑开的空档)——它们不占参数,但在几何上照样占位置.

注:这个”占位置但不占参数”的区分能解释一个常见困惑——**为什么 DD 变大时”参数量不变”却”要更多 padding”?**因为参数量数的是那些 ■,padding 数的是整个框的跨度,后者的空档也是要地方站的.

注:补零padding 的副作用在空洞卷积里会更明显——边界附近有更多采样点落在补零区,那些位置的输出是”半真半假”算出来的.如果是分割、超分这类对边界敏感的任务,常把 padding_mode 换成 'reflect' 或 'replicate',用镜像/复制的真实像素代替0.不过它们有个限制:padding 不能超过输入尺寸,而 dilation 越大需要的 padding 越大,所以深层高 dilation 的层往往还是只能用补零.这是一组真实的取舍.

groups 和 dilation 的定位对比

维度groupsdilation
改的是什么通道怎么连(分组、断连)空间采样点的疏密
主要收益省参数、省计算量(1/g1/g)扩大感受野,参数不增
主要代价跨通道信息交流变少网格效应,需要混合多个 DD
典型用途MobileNet 等端侧模型、ResNeXt语义分割(DeepLab)、语音/音频生成(WaveNet)
和输出尺寸的关系不影响影响(进了 (k−1)D(k-1)D 那一项)
提参数量吗降参数量参数量不变

一句话区分:**groups 是在”通道维度”上做减法,dilation 是在”空间维度”上做加法(不加参数).**两者都是”用更少的参数换更大的建模范围”这个思路下的不同招法.

池化:把图缩小,把最强的信号留下

卷积层通常成对搭配池化层(pooling),最常见的是最大池化:

2×2 最大池化,stride=2        输入 4×4              输出 2×2
1  3 | 2  4                每 2×2 的小块取最大值
5  6 | 7  8       ──→      6   8
─────────────────          9  10
2  4 | 9 10
1  0 | 3  2

池化有三个作用:

  1. 降维:空间尺寸减半,后面的计算量和显存都降下来;
  2. 扩大感受野:同样一个 3×33\times3 的核,在池化后的图上一动,对应原图的覆盖范围就翻倍了;
  3. 带来一点平移不变性:4个像素里的最大值在哪个位置被移动一两格,输出基本不变,所以物体稍微移动一点,结果还是同一个.

注:池化没有参数,它是固定的取最大值/平均值操作,不参与学习.而且梯度能回传——最大值池化把梯度只给那个被选中的位置,其余位置梯度为零.

不过在现代网络里,池化正在被两样东西替代:

完整走一遍:一个CNN的形状流水线

光看公式容易飘,直接把形状一步步算出来.输入 224×224224\times224 的RGB图:

层配置输出形状参数量
输入—3×224×2243\times224\times224—
Conv13×33\times3, 32, P=1P=132×224×22432\times224\times224896
MaxPool2×22\times2, S=2S=232×112×11232\times112\times1120
Conv23×33\times3, 64, P=1P=164×112×11264\times112\times11218,496
MaxPool2×22\times2, S=2S=264×56×5664\times56\times560
Conv33×33\times3, 128, P=1P=1128×56×56128\times56\times5673,856
MaxPool2×22\times2, S=2S=2128×28×28128\times28\times280
Conv43×33\times3, 256, P=1P=1256×28×28256\times28\times28295,168
MaxPool2×22\times2, S=2S=2256×14×14256\times14\times140
Conv53×33\times3, 512, P=1P=1512×14×14512\times14\times141,180,160
GlobalAvgPool—512×1×1512\times1\times10
Flatten + Linear512→1000512 \to 100010001000513,000

整网约200万参数,处理的是5万维的输入. 对比一下:如果第一层就用全连接,光第一层就是1.5亿参数.这就是CNN存在的意义.

注意空间尺寸从 224224 一路减到 11,通道数从 33 一路涨到 512512——整条流水线就是”空间换语义”:分辨率不断被丢弃,语义不断被提炼,最后剩下一个”这张图是什么”的向量.

它凭什么能work:四条归纳偏置

前面零散提过,这里集中收一下.总结就是CNN把四条关于图像的先验硬编码进了架构:

① 局部性(locality). 图像里一个像素的邻居才有意义,隔着一百个像素的两个点基本无关.所以输出特征图上的每个点,只接收输入图上一个 k×kk\times k 窗口的信息,不用看全图——这就是它的感受野.

② 参数共享(weight sharing). 同一个”竖直边缘检测器”在图片左上角有用,在右下角也有用——同一个特征可以出现在任何位置.所以同一个核扫遍全图,而不是每个位置各配一套权重.

③ 平移等变(translation equivariance). 输入里的物体平移 dd 个像素,输出的特征图也整体平移 dd 个像素,数值不变.这是②的直接数学结论,也是”猫挪个位置不会变成狗”的结构保证.再叠上池化和全局平均池化,就变成平移不变(translation invariance)——输出与位置无关.

注:严格区分这两个词.卷积本身是等变(位置跟着变),池化之后才是不变(位置无关).很多资料混着说,但公式上它们不是一回事.

④ 层级组合(hierarchy). 复杂视觉模式是简单模式的组合:边缘 → 纹理 → 部件 → 物体.所以网络逐层加深、逐层组合.

这四条合起来的效果是:CNN用极少的数据就能学好视觉任务. 同样的图像分类任务,MLP需要多得多的样本才能学出”像素要和邻居一起看”这件事,而CNN一开始就知道.

PyTorch 实操:形状排查和三个高频坑

import torch
import torch.nn as nn

class SmallCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            # 每个 block: 卷积 → BN → ReLU,下采样放到下一层用 stride=2 做
            nn.Conv2d(3, 32, kernel_size=3, padding=1),   # [B, 3, 32, 32]  → [B, 32, 32, 32]
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 32, 3, padding=1),              # → [B, 32, 32, 32]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),                              # → [B, 32, 16, 16]

            nn.Conv2d(32, 64, 3, padding=1),              # → [B, 64, 16, 16]
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),                              # → [B, 64, 8, 8]

            nn.Conv2d(64, 128, 3, padding=1),             # → [B, 128, 8, 8]
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool2d(1),                      # → [B, 128, 1, 1]  任意输入尺寸都行
        )
        self.classifier = nn.Linear(128, num_classes)      # → [B, num_classes]

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)          # [B, 128, 1, 1] → [B, 128]
        return self.classifier(x)

model = SmallCNN()
x = torch.randn(16, 3, 32, 32)          # B=16
print(model(x).shape)                    # torch.Size([16, 10])   和输入空间尺寸无关

AdaptiveAvgPool2d(1) 是排查形状问题的神器:它不管你前面输出的是 8×88\times8 还是 7×77\times7,一律压成 1×11\times1,这样分类头的输入维度就永远是 channels.这也是为什么现代网络能接受任意尺寸输入.

坑1:形状对不上,先看通道

卷积报错十有八九是 in_channels 和实际输入通道没对齐.排查方法就一句:

# 用 hook 或直接 print,顺着看每一层的输出形状
x = torch.randn(1, 3, 224, 224)
for layer in model.features:
    x = layer(x)
    print(f"{layer.__class__.__name__:15s} → {tuple(x.shape)}")

坑2:参数量算错,忘了输入通道

新手常把 3×33\times3 核的参数量算成 99.记得乘上输入通道:

conv = nn.Conv2d(3, 64, 3, padding=1)
print(sum(p.numel() for p in conv.parameters()))   # 1792 = 3*3*3*64 + 64

坑3:padding 的默认值和 padding_mode

padding 默认是 0(补零),不是 1.写 3×33\times3 卷积时忘了 padding=1,每层尺寸少2,几层之后就缩没了.另外 padding_mode='zeros' 是默认值,还有 'reflect' / 'replicate',在生成任务里用得多——补零会在边缘造出假的强边缘响应.

经典架构:六个”一次解决一个问题”的节点

CNN的演进史特别干净,每个经典网络都是为了解决上一个的具体缺陷而出现的.

年份网络层数核心贡献治的什么病
1998LeNet-57卷积 + 池化 + 全连接的完整范式证明CNN能端到端训练(手写数字识别)
2012AlexNet8ReLU、Dropout、GPU训练、数据增强深层网络能训起来了,ImageNet夺冠拉开序幕
2014VGG16/19全用 3×33\times3 小核堆深,结构极规整小核堆叠比大核更省参数、表达力更强
2014GoogLeNet22Inception模块 + 1×11\times1 瓶颈同一层用多种核尺度,同时压参数量
2015ResNet152残差连接深层网络的退化问题
2017DenseNet121+每层都连到后面所有层特征复用,梯度通路更多

VGG:为什么两个 3×33\times3 顶一个 5×55\times5

这是个很值得算一遍的结论.两个 3×33\times3 卷积串联,感受野等于一个 5×55\times5——第一个核的输出图上每个点覆盖原图 3×33\times3,第二个核罩住3个这样的点,合起来 5×55\times5.

但参数量差很多(输入输出都是 CC 通道):

2×(3×3×C×C)=18C2vs5×5×C×C=25C22 \times (3\times3\times C\times C) = 18C^2 \quad\text{vs}\quad 5\times5\times C\times C = 25C^2

而且两个 3×33\times3 之间多了一层 ReLU,非线性更强.所以”小核堆深”同时赢了参数和非线性——这就是VGG的核心洞察.

ResNet:残差连接为什么能堆到152层

VGG到19层就差不多到顶了,再加深训练误差反而上升.这不是过拟合(训练误差也涨),而是退化(degradation)问题:深层网络的梯度在逐层回传中衰减,前面的层几乎学不动.

ResNet 的解法简单到粗暴——给每个卷积块加一条恒等捷径(identity shortcut):

y=F(x)+xy = \mathcal{F}(x) + x

符号含义
xx残差块输入
F\mathcal{F}块内的卷积堆叠(通常两个 3×33\times3 卷积 + BN)
yy块输出,F(x)+x\mathcal{F}(x)+x 后再过 ReLU

为什么它管用: 反向传播时,∂y∂x=∂F∂x+1\frac{\partial y}{\partial x} = \frac{\partial \mathcal{F}}{\partial x} + 1 里那个 +1 保证了梯度至少原样传回前一层,不会被连乘衰减掉.这相当于给梯度开了一条高速公路,和LSTM里门的思路是同一种直觉.

注:还有个更漂亮的解释——让网络学”残差”比学”完整映射”更容易.如果某一层的最优解就是”什么都不做”(恒等映射),普通网络要费劲地把卷积核学成接近0、再靠 BN 和 ReLU 才能近似出恒等;而残差块只要把 F\mathcal{F} 学成0就完事了,恒等映射是它的默认起点.

而且 1×11\times1 卷积在这里用得很妙:ResNet 的瓶颈块是 1×1→3×3→1×11\times1 \to 3\times3 \to 1\times1,先降维(256→64)、再在低维上做 3×33\times3、最后升回去(64→256).参数量比直接两个 3×33\times3 的256通道版本少了近一个数量级.

注:1×11\times1 卷积k=1,P=0,S=1k=1,P=0,S=1 空间上什么都不做,它做的是跨通道的线性组合——本质就是”在每个像素位置上,对一个长度 CinC_{in} 的向量做全连接”.所以它也叫”逐点卷积”,是控制通道数的旋钮.

今天还用什么:三个值得记住的变体

变体核心思路主要场景
深度可分离卷积把普通卷积拆成”逐通道空间卷积 + 1×11\times1 跨通道卷积”移动端/端侧(MobileNet),参数和计算量降到约 1/81/8~1/91/9
空洞卷积核内插空(D>1D>1),不增参数就扩大感受野语义分割(DeepLab)、语音,需要大感受野又不想降分辨率
可变形卷积采样位置本身也是学出来的偏移量目标检测,处理不规则形状目标

深度可分离卷积值得多说一句,因为它就是分组卷积的极端情形:设 groups = in_channels,每个通道用自己的一套核单独卷(深度卷积,管空间),再补一个 1×11\times1 把通道信息混起来(管通道).普通 3×33\times3 卷积的计算量是 9×Cin×Cout9\times C_{in}\times C_{out},可分离版本是 9×Cin+Cin×Cout9\times C_{in} + C_{in}\times C_{out},CoutC_{out} 大时能省到十分之一左右.代价是空间和通道的混合被拆成了两步,中间少了一次联合建模,表达能力略降——但移动端没得选.

注:卷积核权重还有个参数共享的隐藏维度:在通道维度上,输出通道 jj 用的是自己完整的 k×k×Cink\times k\times C_{in} 核,所以跨通道不共享参数;真正的共享发生在空间维度上.别把这两件事说混.

和Transformer的关系:不是取代,是先验之争

2020年ViT(Vision Transformer)把图片切成 16×1616\times16 的patch,当成token喂给标准Transformer,在超大数据集上超过了CNN.这引出一个反复被问的问题:CNN是不是也该像RNN一样退场了?

我的看法是:这里的关系和”RNN vs Transformer”完全不同.

RNN被取代是因为它有两个结构性的硬伤——时间步必须串行(GPU喂不满)和长距离依赖要靠隐藏状态连乘(梯度衰减).这两条补不掉.

CNN没有这两个问题:卷积是全图并行的,而且任意远的位置经过几层就能建立起联系. 它唯一”吃亏”的地方是局部性这个先验可能不够灵活——如果任务需要一上来就让两个隔很远的区域直接交互,卷积得堆好几层才够.

所以真正的差别是归纳偏置的强弱:

对比项CNNTransformer(ViT)
建模方式局部窗口加权求和,权重共享全局自注意力,权重由输入动态生成
归纳偏置强(局部性 + 平移等变)弱(位置关系靠位置编码学)
数据需求小数据也能学好需要大数据或强增强(如 DeiT 蒸馏)
计算复杂度与像素数线性相关与patch数的平方相关
长距离建模靠层数堆叠逐步扩大感受野一层直达
擅长任务图像分类、检测、分割、医学影像大规模预训练、多模态、图文对齐

用一句更本质的话概括:卷积是”局部加权求和,权重共享”;自注意力是”全局加权求和,权重随输入动态生成”. 两者都是”加权求和”,区别只在范围和权重从哪来.

也正因为这个统一视角,现在的路线是融合:ConvNeXt 用Transformer的训练技巧反过来改造纯卷积网络,依然能打平ViT;混合架构里常见”浅层用卷积提局部特征、深层用注意力建全局关系”.CNN没有死,它只是从”唯一的答案”变成了”一种需要按任务选的归纳偏置”.

小结

把全文串成一张图:

图片(H×W×3)
   │  拉平 → 参数量爆炸 + 丢空间结构   ✗
   ▼
卷积层:小窗口滑动,局部连接 + 参数共享   ← 参数量与输入尺寸无关
   │   k=3,P=1,S=1 尺寸不变;S=2 尺寸减半
   ▼
池化层:降维 + 扩大感受野 + 一点平移不变
   │
   ▼
重复"卷积→激活→下采样":空间 H,W 变小,通道 C 变大
   │   浅层=边缘/颜色 → 中层=纹理/部件 → 深层=物体语义
   ▼
全局平均池化 → 全连接 → 类别分数

← 返回博客列表