模块 3: 卷积神经网络

一幅 224 × 224 像素的彩色图像有 224 × 224 × 3 = 150,528 个数。把它展平后，可以送入模块 02的多层感知机（multilayer perceptron），但在这个规模下会在两方面失败：计算成本和统计效率。

统计上的问题更严重。每个权重只属于一个输入位置，所以该层必须分别学会：左上角的边缘和右下角的同一条边缘是同一种东西，而且要靠在每个位置都出现过边缘的样本来学。图像的两个性质可以同时消除这两个问题。

局部性

一个像素的含义，取决于它的邻域远多于取决于远处的像素：边缘、笔画和纹理都是相距几个位置的像素之间的关系。这一点可以测量。

import numpy as np
from sklearn.datasets import load_digits

X = load_digits().data                       # (1797, 64), grey levels 0..16
keep = np.flatnonzero(X.std(axis=0) > 0.5)   # skip pixels that are almost always blank
R = np.corrcoef(X[:, keep], rowvar=False)    # correlation of every pair of pixels
row, col = np.divmod(keep, 8)                # position of each kept pixel on the grid
dist = np.hypot(row[:, None] - row, col[:, None] - col)
iu = np.triu_indices(len(keep), k=1)         # each pair once
r, d = R[iu], dist[iu]
for lo, hi in [(0, 1), (1, 1.5), (1.5, 2), (2, 3), (3, 4.5), (4.5, 12)]:
    sel = (d > lo) & (d <= hi)
    print(f"distance ({lo}, {hi}]: mean r = {r[sel].mean():+.2f}  ({sel.sum()} pairs)")

distance (0, 1]: mean r = +0.42  (88 pairs)
distance (1, 1.5]: mean r = +0.17  (76 pairs)
distance (1.5, 2]: mean r = -0.04  (72 pairs)
distance (2, 3]: mean r = -0.06  (236 pairs)
distance (3, 4.5]: mean r = -0.04  (406 pairs)
distance (4.5, 12]: mean r = -0.03  (448 pairs)

平稳性

第二个性质是平稳性（stationarity）：小图像块的统计特性在图像的各处相同。左上角的边缘和右下角的边缘看起来一样，所以在某个位置有用的检测器，在每个位置都有用。这就允许权值共享（weight sharing）：一小组权重，在所有位置上使用。

同一层，三种参数量

考虑一个从 224 × 224 × 3 的图像到 224 × 224 × 64 输出的层（3,211,264 个单元，即 50,176 个位置上各 64 个），并逐一施加这两个假设；图 3.1 画出了一个输出单元在三种情形下的连接。

权值共享还汇聚了统计强度。一个共享权重在每个位置上都起作用，所以由链式法则，它的梯度要对每幅训练图像的全部 50,176 个位置求和，而不共享的权重只能听到自己所在位置的信号。相邻位置是相关的，所以一幅图像并不相当于 50,176 个独立样本，但它的价值远高于一个样本。

等变性与不变性

记 T_{\boldsymbol{\tau}} 为把图像平移 \boldsymbol{\tau} = (\tau_1, \tau_2) 个像素的平移算子， (T_{\boldsymbol{\tau}} X)_{i,j} = X_{i-\tau_1,\, j-\tau_2}。图像的函数 f 称为

• 平移等变（translation equivariant），若 f(T_{\boldsymbol{\tau}} X) = T_{\boldsymbol{\tau}} f(X)： 输入平移，输出也平移相同的量；
• 平移不变（translation invariant），若 f(T_{\boldsymbol{\tau}} X) = f(X)：输入平移，输出不变。

卷积是等变的（第 2 节给出证明）；池化和全局平均给出近似的不变性（第 5 节）。需要哪一种由任务决定。“含有裂纹”这样的标签不会因为裂纹移动而改变，所以分类器应当是不变的；分割掩码或检测框必须随目标移动，所以这类网络应当是等变的。

归纳偏置，以及它不成立的地方

卷积是一个权重矩阵受到约束的全连接层：大多数元素为零（局部性），其余的元素被绑定在一起（权值共享），第 2 节会说明这一点。它能表示的函数比同样输入输出的全连接层少，而这正是关键所在：它放弃的函数是图像用不到的，而它所缺少的每个参数都不必从数据中估计。像这样内置于架构的假设称为归纳偏置（inductive bias）。实验 2 从两个方面检验它：用同一个固定的排列打乱每个数字图像的 64 个像素，MLP 的准确率不变，因为它本来就不知道哪些像素相邻；而 CNN 的准确率则从约 98.4% 降到约 96%。

这种偏置在具有局部、平稳统计特性的网格数据上有回报：图像、音频和传感器信号、光谱、CT 和显微镜体数据（第 13 节）。它对表格数据没有帮助，因为表格的列（年龄、压力、合金牌号）没有邻居，顺序也是任意的。

对单通道图像 X \in \R^{H \times W}、卷积核（kernel）K \in \R^{k \times k} 和偏置 b，卷积层计算

下标从 0 开始，(i, j) 是卷积核所覆盖窗口的左上角：把卷积核盖在窗口上，把重叠的数对应相乘，把乘积与偏置相加，然后滑动一格，重复这一过程。窗口在每个轴上有 H - k + 1 个位置，所以不填充时，3 × 3 的卷积核把 5 × 5 的图像变成 3 × 3 的输出；边界的处理见第 3 节。

互相关还是卷积

严格地说，上面的运算是互相关（cross-correlation），在本模块需要区分时写作 K \star X。数学和信号处理中的卷积要把卷积核翻转：

这里输出的下标位于窗口的右下角。把它移到左上角（i \to i + k - 1，j \to j + k - 1），并代入 u' = k - 1 - u，v' = k - 1 - v：和式变成 \sum_{u',v'} K_{k-1-u',\,k-1-v'}\, X_{i+u',\, j+v'}，即卷积核旋转 180° 之后的互相关。二者只差一次翻转 K_{u,v} \to K_{k-1-u,\,k-1-v}。对学出来的卷积核，这无关紧要，因为网络学到的就是翻转后的卷积核，所以每个深度学习框架计算的都是互相关，却称之为卷积。由此有三个推论：

• scipy.signal.convolve2d 会翻转卷积核，所以它与 torch.nn.functional.conv2d 不一致，而 correlate2d 与之一致，给 convolve2d 传入 K[::-1, ::-1] 也一致（实验 1）。
• 旋转后不变的卷积核，例如模糊核，两种算法给出相同的结果。
• 反对称的卷积核会变号。把上面的边缘核旋转后取负，所以该例子的真正卷积是 -Y，各行为 (1, 4, 0)、(3, 2, −4) 和 (1, 2, −1)。

手工设计的卷积核

在卷积核由学习得到之前，它们是人工设计的，这些经典设计展示了 3 × 3 卷积核能做什么。有一条规律把它们组织起来。在常数区域 X_{i,j} = c 上，输出为 b + c \sum_{u,v} K_{u,v}：权重之和为 1 的卷积核保持平坦区域不变，只改变其上的结构；权重之和为 0 的卷积核在平坦区域输出零，只对变化有响应。

网络第一层学到的滤波器与这些很像，是有方向的边缘检测器和斑点（实验 2 第 7 步画出了它的数字 CNN 学到的八个滤波器，第 14 节会讨论）；更深的层把它们组合成没人会手工设计的检测器。

平移等变性的证明

第 1 节声称卷积是平移等变的。取 (T_{\boldsymbol{\tau}} X)_{i,j} = X_{i-\tau_1,\, j-\tau_2}，证明只需两行：

第一行代入平移后的图像；第二行把同一个和式读作输出在 (i - \tau_1, j - \tau_2) 处的值。偏置在各处相同，直接通过。证明假设每个 X_{i+u-\tau_1,\, j+v-\tau_2} 都存在，这在无限网格上和循环填充下成立，循环填充时图像像环面一样首尾相接。对零填充，平移在一侧边界推入的像素是零，而不是从另一侧推出的像素，所以等变性在远离边界处严格成立，在边界附近不成立；实验 1 测量了这两种情形。

作为矩阵的卷积

卷积对 X 是线性的，所以它是一个矩阵乘积。在一维情形，长度为 5 的输入和卷积核 (1, 2, 3) 给出三个输出，把每个窗口的权重写成一行，得到

每一行都是上一行向右移一位：\mathbf{M} 是带状的 Toeplitz 矩阵，沿对角线为常数。在二维情形，图像按行展平后，矩阵是双重分块 Toeplitz 矩阵：每个卷积核行对应一个 Toeplitz 块，这些块再按 Toeplitz 的方式排列。这就是第 1 节那个论断的准确含义：卷积层是一个全连接层，它的矩阵每行有 k^2 个非零元素，且每行是同样的 k^2 个值。

反向传播与转置卷积

若 \mathbf{y} = \mathbf{M}\mathbf{x}，上一层传来梯度 \mathbf{g} = \partial \mathcal{L}/\partial \mathbf{y}，则由链式法则（模块 02，第 3 节）得

\mathbf{M} 的第 m 列保存了 x_m 进入各个输出时的权重，所以 \mathbf{M}^\top 把每个 g_i 经由卷积核散射回它的窗口读过的那些输入。结果是 \mathbf{g} 与卷积核的“完全”（full）卷积，包含每一处重叠，包括伸出两端的部分。对卷积矩阵取转置的运算称为转置卷积（transposed convolution）；第 12 节把它正向运行以做上采样。权重梯度随之得到，因为 K_{u,v} 只通过 K_{u,v} X_{i+u,j+v} 这一项进入 Y_{i,j}：

这是输入与输出梯度的互相关。因此反向传播是另外两个卷积，每个的乘加运算次数与前向相同：约为前向代价的两倍，和模块 02 的全连接层一样。

import numpy as np

w = np.array([1.0, 2.0, 3.0])                # kernel
x = np.array([1.0, 0.0, 2.0, 1.0, 3.0])      # input of length 5
M = np.zeros((3, 5))
for i in range(3):
    M[i, i:i + 3] = w                        # row i: the kernel shifted i places
print(M @ x, np.correlate(x, w, "valid"))    # forward pass, two ways
g = np.array([1.0, -1.0, 2.0])               # dL/dy arriving from above
print(M.T @ g, np.convolve(g, w, "full"))    # dL/dx: the transposed convolution
print(np.correlate(x, g, "valid"))           # dL/dw: input correlated with dL/dy

[ 7.  7. 13.] [ 7.  7. 13.]
[1. 1. 3. 1. 6.] [1. 1. 3. 1. 6.]
[5. 0. 7.]

每张架构图都是一串形状的列表，每个形状都由一个公式得出，而一个递推式说明每个单元能看到图像的多少。两者都建立在三个设置之上。填充（padding）p 在某个轴的两端各加 p 个格子；步长（stride）s 是相邻窗口之间的步幅；空洞（dilation）d 使卷积核的各个抽头彼此相隔 d，所以 d = 2 的 3 × 3 卷积核读取 5 × 5 区域中每隔一个的像素。空洞保持 k^2 个权重不变，而跨度增长为 d(k-1) + 1。

输出尺寸

沿一个轴数窗口的位置。填充后有 H + 2p 个位置，编号为 0 到 H + 2p - 1。从 t 开始的窗口读取 t, t + d, \dots, t + (k-1)d，所以当 t + d(k-1) \le H + 2p - 1 时它放得下。窗口从 t = 0, s, 2s, \dots 开始，而 [0,\, H + 2p - d(k-1) - 1] 中 s 的倍数的个数是

当 d = 1 时，它是 \lfloor (H + 2p - k)/s \rfloor + 1，当 p = 0、s = 1 时，它就是第 2 节的 H - k + 1。宽度遵循同样的公式。

“Same”填充。当 s = 1 且 p = d(k-1)/2 时，分子是 H - 1，所以 H_{\text{out}} = H。这要求 d(k-1) 为偶数，在 d = 1 时意味着卷积核为奇数（3 × 3 配 p = 1，5 × 5 配 p = 2）。偶数大小的卷积核无法对称填充；这时 PyTorch 的 padding="same" 把多出的零放在右侧和下侧，并拒绝大于 1 的步长。

步长为 2。当 k = 3、p = 1、s = 2 时，公式给出 \lfloor (H - 1)/2 \rfloor + 1：H 为偶数时是 H/2，为奇数时是 (H + 1)/2。“步长为 2 则尺寸减半”只对偶数尺寸精确成立；7 变成 4。

填充模式。零填充是默认的；反射（镜像）、复制（重复边缘像素）和循环（环绕）则改用图像本身的内容填充边界。这个选择很重要：用零填充时，靠近边界的卷积核会看到一圈人为的暗框，于是网络可以学到边界在哪里，进而学到特征的绝对位置，而等变的层本来不该知道这一点。

感受野

一个单元的感受野（receptive field）是能影响它的输入位置的集合；沿一个轴，它的大小记为 r。在各层之间跟踪两个量：r_l，即第 l 层一个单元的感受野；以及跳距（jump）\Delta_l，即第 l 层相邻单元之间以输入像素计的距离，从 r_0 = 1 和 \Delta_0 = 1 出发。第 l 层的一个单元读取第 l - 1 层的 k_l 个相隔 d_l 的单元，所以它最外侧的输入相距 (k_l - 1)\,d_l\,\Delta_{l-1} 个输入像素，每个都带来大小为 r_{l-1} 的感受野；它自己的步长则使各单元之间的间距相乘：

池化层以同样的方式进入，其窗口作为 k_l，步长作为 s_l，且 d_l = 1。填充不改变 r；它只决定感受野伸出边界多远。

小卷积核，堆叠。每个步长为 1 的 3 × 3 层增加 2，所以 n 个这样的层达到 r = 2n + 1。设输入输出都有 C 个通道，两个堆叠的 3 × 3 层看到的范围与一个 5 × 5 层相同，但权重是 18C^2 而不是 25C^2（少 28%），三个堆叠的层与一个 7 × 7 层看到的范围相同，权重是 27C^2 而不是 49C^2（少 45%），而且每层之间还有非线性。这就是 VGG（第 7 节）的全部设计思路。

下采样使跳距成倍增长。经过一个步长为 2 的层之后，每个后续的 3 × 3 层增加 4 个像素而不是 2；经过五个之后，增加 64。网络正是这样在几十层之内获得整幅图像的上下文。

空洞使感受野指数增长。d = 1, 2, 4, 8 的 3 × 3 堆叠每层增加 2d，得到 r = 3, 7, 15, 31，而不带空洞的堆叠要 15 层才能达到 31，并且不损失任何分辨率。有公因数的空洞会留下空隙：三个 d = 2 的层只读取每隔一个的输入，这种模式称为网格效应（gridding），从 d = 1 开始可以避免它。图 3.4 并排比较了扩大感受野的三种方式：堆叠、跨步和空洞。

有效感受野

理论感受野说明哪些像素能影响一个单元，却没说影响多大。数一数路径：在三个堆叠的 3 抽头层中，中心输入沿 7 条路径到达顶层单元，最外侧的输入各沿 1 条，每个轴上的计数 1, 3, 6, 7, 6, 3, 1 是 (1, 1, 1) 的三重自卷积。有 n 层时，计数是卷积核的 n 重自卷积，由中心极限定理，它趋于一个宽度按 \sqrt{n} 增长的高斯分布，而感受野按 n 增长。Luo 等人（2016）测量了这个有效感受野（effective receptive field），即一个输出单元的梯度实际落在的位置，发现它大致呈高斯形，并且比理论感受野小得多。对 SmallResNet 的最后一个阶段（第 8 节），理论感受野为 49 × 49，实验 3 测得约 44% 的输入梯度质量落在中央 9 × 9 之内，89% 落在 25 × 25 之内；一半位于约 11 × 11 之内，是理论面积的二十分之一。该实验的第 5 步画出梯度图，同时画出理论窗口以及包含 50% 和 90% 质量的等值线。

目标很大时，这一点很重要。如果网络的有效感受野比目标小，它就只能依据局部纹理来判断，而在 ImageNet 上训练的 CNN 确实表现出这种偏向：给它们形状指向一个类别、纹理指向另一个类别的图像，它们多半按纹理回答（Geirhos 等人，2019）。有了这个递推式，计算感受野只是五分钟的事；实验 3 展示如何观察有效感受野。

真实的输入有多个通道（红、绿、蓝，或者模拟中的各个场），而第一层之后的每一层都会产生许多通道。单通道的层通过对输入通道求和来推广：

权重张量的形状是 (C_{\text{out}}, C_{\text{in}}, k, k)，PyTorch 把激活存为 (B, C, H, W)，即通道在前；TensorFlow 默认通道在后，即 (B, H, W, C)。每个输出通道 c 有一个滤波器（filter）K_{c,\cdot,\cdot,\cdot}，形状为 C_{\text{in}} \times k \times k，它同时通过所有输入通道观察一个 k \times k 的图像块，并把结果求和成一个数。滤波器滑动时产生的映射是一张特征图（feature map）；一个层就是 C_{\text{out}} 个滤波器产生 C_{\text{out}} 张特征图，即下一层的通道（图 3.5）。

把整个层写成一次矩阵乘法

固定一个输出位置，对 (c', u, v) 的求和是滤波器（展平为长度 C_{\text{in}}k^2）与窗口（以同样方式展平）之间的点积。把每个窗口收集为矩阵 \mathbf{X}_{\text{col}} 的一列，其形状为 C_{\text{in}}k^2 \times H_{\text{out}}W_{\text{out}}，这一步称为 im2col（“image to columns”，图像到列），再把 C_{\text{out}} 个展平的滤波器堆成 \mathbf{W} 的各行。整个层就成为一个矩阵乘积，

再加上偏置，并重塑为 (C_{\text{out}}, H_{\text{out}}, W_{\text{out}})。CPU 库和许多 GPU kernel 都是这样计算卷积的，因为矩阵乘法是数值计算中优化得最充分的例程；对某些形状还有基于 FFT 和 Winograd 的算法。代价是内存：步长为 1 时，每个输入值最多被复制到 k^2 列中，所以 3 × 3 层的列矩阵约为其输入的九倍。PyTorch 把 im2col 暴露为 F.unfold：

import torch
import torch.nn.functional as F

torch.manual_seed(0)
x = torch.randn(1, 64, 56, 56)                  # one image with 64 channels
w = torch.randn(128, 64, 3, 3)                  # 128 filters, each 64 x 3 x 3
cols = F.unfold(x, kernel_size=3, padding=1)    # im2col: one column per position
y = (w.reshape(128, -1) @ cols).reshape(1, 128, 56, 56)
print(tuple(cols.shape), cols.numel() / x.numel())
print(torch.allclose(y, F.conv2d(x, w, padding=1), atol=1e-3))

(1, 576, 3136) 9.0
True

统计参数、MAC 和 FLOPs

计数可以直接从公式读出。每个输出通道有 k^2 C_{\text{in}} 个权重和一个偏置，所以一个层有 k^2 C_{\text{in}} C_{\text{out}} + C_{\text{out}} 个参数。每个输出值需要 k^2 C_{\text{in}} 次乘加运算（multiply-accumulate，MAC），每次包含一次乘法和一次加法，而输出值共有 C_{\text{out}} H_{\text{out}} W_{\text{out}} 个：

因子 2 就是模块 02，第 2 节“每次前向传播 2N FLOPs”背后的计数方式。

参数和计算量分别集中在哪里

参数 k^2 C_{\text{in}}C_{\text{out}} + C_{\text{out}} 与 H 和 W 无关；计算量与 H_{\text{out}}W_{\text{out}} 成正比。早期的层分辨率高而通道少，主导计算量。后期的层通道多而分辨率低，尤其是全连接的头部，主导参数量。

# VGG-16 on a 224x224 image, counted from its layer list
cfg = [64, 64, "M", 128, 128, "M", 256, 256, 256, "M",
       512, 512, 512, "M", 512, 512, 512, "M"]       # "M" is a 2x2 max pool
H, C, params, macs = 224, 3, 0, 0
for v in cfg:
    if v == "M":
        H //= 2                                    # pooling halves the map
        continue
    params += 3 * 3 * C * v + v                    # weights + biases
    macs += 3 * 3 * C * v * H * H                  # padding 1: output is H x H
    C = v
conv_params, conv_macs = params, macs
for n_in, n_out in [(512 * 7 * 7, 4096), (4096, 4096), (4096, 1000)]:
    params += n_in * n_out + n_out                 # fc6, fc7, fc8
    macs += n_in * n_out
print(f"parameters {params:,}, of which dense {params - conv_params:,}")
print(f"MACs: convolutions {conv_macs / 1e9:.2f} G, dense {(macs - conv_macs) / 1e9:.2f} G")

parameters 138,357,544, of which dense 123,642,856
MACs: convolutions 15.35 G, dense 0.12 G

内存、反向传播与偏置

激活内存。形状为 (C, H, W) 的输出在 float32 下每幅图像占 4CHW 字节，训练时要一直保留到反向传播用过它之后，这就是训练内存随深度乘以 batch 增长的原因（模块 02，第 3 节）。64 → 128 层的输出是 128 \times 56 \times 56 \times 4 = 1{,}605{,}632 字节，每幅图像 1.53 MiB，batch 为 256 时是 392 MiB（411 MB），而该层的参数只有 0.28 MiB。

反向代价。反向传播计算两个卷积，它们的 MAC 次数与前向相同（第 2 节），即输入梯度和权重梯度，所以一个训练步的代价约为前向 FLOPs 的三倍：上述层每幅图像约为 1.39 GFLOPs，对第一层则略少一些，因为它不需要输入梯度。

偏置与批归一化。卷积后面直接跟批归一化时不需要偏置：批归一化减去每个通道在 batch 上的均值，这会消去之前加上的任何常数 b_c，然后再加上它自己学习的平移。因此第 8 节的代码中卷积使用 bias=False；归一化本身见模块 02，第 10 节。

分类器必须把 224 × 224 的特征图变成一个标签，而且不应当一路都付出全分辨率的代价。随着网络加深而降低分辨率，可以同时满足这两个需求。

最大池化（max pooling）在每个 2 × 2 窗口上取最大值，步长为 2：它把 H 和 W 减半，保留每个窗口中最强的响应，并且没有参数。由于 \max(x_1, \dots, x_4) 对其最大的输入的导数为 1，对其余输入的导数为 0，所以反向传播把每个窗口的梯度完全送到持有最大值的位置（有并列时 PyTorch 取第一个）。平均池化（average pooling）对每个窗口取平均，并把四分之一的梯度传给每个位置。

全局平均池化（global average pooling，GAP）把每个通道的整张图平均成一个数，把 C \times H \times W 变成 C。它取代了早期网络末端那些巨大的全连接层，并使网络能够接受任意大小的输入。

步长卷积（strided convolution）同样使特征图减半，但由它的权重决定保留什么，而最大池化总是保留最大值，现代网络常常用这种方式下采样。ResNet 在各阶段之间用步长为 2 的卷积过渡，并在捷径上使用步长为 2 的 1 × 1 卷积（第 8 节）；ConvNeXt 使用单独的下采样层，即一个归一化加一个步长为 2 的 2 × 2 卷积（第 9 节）。

不变性只是近似的

人们常说池化使网络具有平移不变性。它只给出一点点不变性，而且只对某些平移成立。步长为 2 的运算只对 2 的倍数的平移是等变的：输入平移两个像素，输出移动一格，但平移一个像素则会改变哪些像素共用一个窗口。

这就是混叠（aliasing），与信号处理中的情形一样：对包含高于新采样率一半的频率的信号做子采样，会把这些频率折叠成虚假的低频，因此结果取决于采样点落在哪里。经典的补救办法是在子采样之前做低通滤波。Zhang（2019）在每个步长运算之前做模糊（“抗混叠”池化），并报告输出对平移更稳定；Azulay 和 Weiss（2019）记录了现代 CNN 的预测会在一个像素的平移下发生变化。

实验 2 在 8 × 8 的数字上测量了这一效应。带有两个 2 × 2 最大池化和展平加全连接头部的 CNN，在居中的测试图像上得分约为 98.4%，在它们向右移动一个像素后约为 66%；同样大小的 MLP 则从约 97% 降到 44%。在随机放置于 16 × 16 画布上的数字上，同样的卷积加上第三层，用 GAP 时达到约 93%，用展平头部时为 89%（图 3.6 对比了这两种头部）。等变的层本身并不能造出不变的分类器：由头部和训练数据决定。

为什么要下采样

每次把 H 和 W 减半，之后每一层的 FLOPs 都减少为 1/4（第 4 节）。它使跳距加倍，所以后面的层让感受野增长得快一倍（第 3 节）。此外，通常的做法是在 H 和 W 减半的同时把 C 加倍，这使各阶段每层的计算量大致保持不变，因为 C 加倍使 C_{\text{in}} C_{\text{out}} 乘以 4，而特征图减半使 H_{\text{out}} W_{\text{out}} 除以 4。

标准的 k \times k 卷积同时做两件事。它在空间上滤波，窗口为 k \times k；它还混合通道，因为每个输出通道都读取全部输入通道。它在每个输出位置上的开销是 k^2 C_{\text{in}} C_{\text{out}} 次乘加运算（第 4 节），正是这两件事的乘积。第 7 至 9 节的高效架构，要么把这两件事分开做，要么让昂贵的那一件在更少的通道上做。本节推导每种组件的开销，以及它放弃了什么。

1 × 1 卷积

取 k = 1，窗口就是单个像素，第 4 节的多通道公式变为

在每个位置上，长度为 C_{\text{in}} 的通道向量都乘以同一个 C_{\text{out}} \times C_{\text{in}} 矩阵 \mathbf{W}。1 × 1 卷积（1 × 1 convolution）就是在每个像素上独立应用的全连接层，有 C_{\text{in}} C_{\text{out}} + C_{\text{out}} 个参数，而且从不看邻居。它有两个用处：以很低的代价改变通道数；后接 ReLU 时，再给每个像素增加一次非线性。Lin 等人（2014）在每个空间卷积之后接一叠这样的层，也就是每个像素上的一个小 MLP（“Network in Network”）；同一篇论文还提出了全局平均池化。

瓶颈结构

在输出尺寸固定时，k \times k 卷积的开销为 k^2 C_{\text{in}} C_{\text{out}} H_{\text{out}} W_{\text{out}} 次 MAC，与两个通道数的乘积成正比。把两个通道数都除以 r，开销就降为原来的 1/r^2。瓶颈结构（bottleneck）正是利用了这一点：先用 1 × 1 卷积减少通道，再做昂贵的 k \times k 卷积；如果需要恢复宽度，再用第二个 1 × 1 卷积在其后扩张通道。Inception 用瓶颈结构来负担 5 × 5 分支；ResNet-50 及更深的变体在每个块中都用了一个（第 8 节）。

分组卷积与逐通道卷积

分组卷积（grouped convolution）把 C_{\text{in}} 个输入通道分成 g 组，给每组配备各自的 C_{\text{out}}/g 个滤波器，这些滤波器只读取本组的通道。每个滤波器现在只跨越 C_{\text{in}}/g 个通道，所以该层有 k^2 C_{\text{in}} C_{\text{out}}/g 个权重，开销是完整层的 1/g。AlexNet 的分组层其实是硬件上的拆分：一半滤波器放在两块 GPU 的一块上，只读取同一块 GPU 上的特征图（第 7 节）。ResNeXt（Xie 等人，2017）则把分组数本身作为一个设计维度。

在极端情形 g = C_{\text{in}} = C_{\text{out}} = C 下，每组只有一个通道。这就是逐通道卷积（depthwise convolution）：每个通道一个 k \times k 滤波器，共 k^2 C 个权重，完全不混合通道。

深度可分离卷积

深度可分离卷积（depthwise-separable convolution）把两件事依次完成：先用逐通道 k \times k 卷积在空间上对每个通道滤波，再用逐点（1 × 1）卷积混合通道（图 3.8）。把步长放在逐通道层，使两种版本产生相同的输出尺寸，然后数每个输出位置的 MAC：

权重数遵循同样的比值，因为不含偏置时，每层的权重数等于它每个位置的 MAC 数。在较宽的层上，第一项可以忽略，3 × 3 的可分离层开销约为标准层的九分之一：节省的倍数大致是 k^2。

分解放弃了什么

把两层复合起来。逐通道滤波器 D_{c'} 把通道 c' 变成一张滤波后的图，逐点权重 P_{c,c'} 把这些图加成输出通道 c（省略偏置）：

因此可分离层就是一个卷积核被强制写成 K_{c,c',u,v} = P_{c,c'} D_{c',u,v} 形式的标准卷积。对输入通道 c'，每个输出通道应用的都是同一个空间滤波器 D_{c'} 的缩放副本；而标准层可以让它的 C_{\text{in}} C_{\text{out}} 个通道对各有自己的空间模式。MobileNet 的表 4（Howard 等人，2017）给这一限制标了价。在 ImageNet 上，深度可分离网络达到 70.6% 的 top-1，用了 5.69 亿次乘加和 420 万个参数；同样的网络换成完整卷积，达到 71.7%，用了 48.66 亿次乘加和 2,930 万个参数。损失约一个点的精度，换来 8.5 倍的计算量减少。

FLOPs 不等于运行时间

FLOPs 衡量的是算术量，而逐通道层每搬运一个字节只做很少的算术。以上面 64 通道、56 × 56 的特征图为例，逐通道 3 × 3 执行 9 \times 64 \times 3{,}136 = 1.8 百万次 MAC，同时读写 1.53 MiB 的激活，约每字节 1.1 次 MAC。标准 3 × 3 层在 2.58 MiB 的激活与权重上执行 2.31 亿次 MAC，约每字节 85 次。GPU 需要每字节几十次甚至更多运算才能让算术单元保持繁忙（模块 10 第 2 节的屋顶线模型），所以逐通道层远低于峰值运行，可分离网络的实测加速比小于它的 FLOP 比值。请在你将要部署的硬件上实测；实验 3 的扩展要问的是，为什么它的可分离网络训练起来并没有快 6.6 倍。

卷积架构的历史，最好看作一串单点的想法，每一个都加在前一个网络之上。它们论文中的每个数字都可以用第 3 至 6 节的工具验证，而验证正是理解一种设计的最快办法。

读一张架构表

架构表逐层列出输出形状、卷积核和步长，常常还有参数量和乘加次数。逐行检查：输出尺寸用第 3 节的公式，参数量和 MAC 用第 4 节的公式。某一行如果不符合公式，要么是印刷错误，要么藏着值得知道的东西：部分连接、偏置的约定，或者把乘加当成了 FLOPs 报告。

LeNet-5：基本模式

LeNet-5（LeCun 等人，1998）确立了此后每个网络都在其上展开的模式：卷积、子采样、卷积、子采样、全连接层。它读取 32 × 32 的图像，其中数字至多占据中央的 20 × 20，这样靠近数字边缘的笔画仍然落在顶层检测器感受野的中部。C1 应用 6 个 5 × 5 滤波器（6 张 28 × 28 的图）。S2 把每张图子采样到 14 × 14：一个单元把 2 × 2 窗口的四个值相加，乘以每张图一个的可训练系数，加上每张图一个的可训练偏置，再应用 sigmoid。C3 应用 5 × 5 滤波器得到 16 张 10 × 10 的图，但每张图只读取 S2 六张图中的 3、4 或 6 张，依照一张连接表；作者给出了两个理由：把连接数控制在范围内，以及打破各特征图之间的对称性（symmetry breaking）。S4 子采样为 16 张 5 × 5 的图。C5 是在 5 × 5 输入上用 120 个滤波器的 5 × 5 卷积，所以它的每张图都是 1 × 1：实质上是一个全连接层。F6 是 84 个单元的全连接层，后面是 10 个输出单元。20 世纪 90 年代中期，一套基于该网络的支票识别系统投入了商业使用。

现代的“LeNet-5”把 C3 全连接，用无权重的池化，并以一个线性的 10 路层收尾。它有 156 + 2{,}416 + 48{,}120 + 10{,}164 + 850 = 61{,}706 个参数，这是大多数教程打印出来的数字：

import torch, torch.nn as nn

lenet5 = nn.Sequential(                               # full C3, pooling without weights
    nn.Conv2d(1, 6, 5), nn.Tanh(), nn.AvgPool2d(2),    # C1, S2 -> 6 x 14 x 14
    nn.Conv2d(6, 16, 5), nn.Tanh(), nn.AvgPool2d(2),   # C3, S4 -> 16 x 5 x 5
    nn.Conv2d(16, 120, 5), nn.Tanh(), nn.Flatten(),    # C5 -> 120
    nn.Linear(120, 84), nn.Tanh(), nn.Linear(84, 10))  # F6, output
sizes = [sum(p.numel() for p in m.parameters()) for m in lenet5]
print([n for n in sizes if n > 0], sum(sizes))
print(lenet5(torch.zeros(1, 1, 32, 32)).shape)

[156, 2416, 48120, 10164, 850] 61706
torch.Size([1, 10])

AlexNet：规模、ReLU 与正则化

AlexNet（Krizhevsky 等人，2012）保留了这一模式，并把它放大到 ImageNet 的规模：五个卷积层加三个全连接层，约 6,000 万个参数，在两块 GPU 上训练，这种拆分以分组卷积的形式保留了下来（第 6 节）。大部分参数在全连接层里：第一个全连接层把最后一张池化图的 6 \times 6 \times 256 = 9{,}216 个特征映射到 4,096 个单元，有 3,770 万个权重。四个要素使它得以训练并泛化：

• 用 ReLU 代替 tanh。他们的图 1 显示，一个四层 CNN 在 CIFAR-10 上达到 25% 的训练误差，用 ReLU 比用 tanh 单元快六倍。
• 前两个全连接层使用概率为 0.5 的 dropout （模块 02 第 11 节）。
• 数据增强：对 256 × 256 的图像做随机 224 × 224 裁剪、水平翻转，以及沿 RGB 值主成分方向的颜色抖动。
• 重叠最大池化：3 × 3 窗口，步长 2。

在 ILSVRC-2012 竞赛中，它的 top-5 测试误差为 15.3%，而第二名为 26.2%。它开启了整个领域向深度网络的转变。

VGG：只用 3 × 3

VGG（Simonyan 和 Zisserman，2015）要问的是，单靠深度能换来什么。它只用步长为 1、填充为 1 的 3 × 3 卷积（保持特征图尺寸），以及步长为 2 的 2 × 2 最大池化（使尺寸减半）；通道数在各次池化之间从 64 翻倍到 512，它所比较的网络有 11 到 19 个权重层，其中 VGG-16 和 VGG-19 至今仍在使用。第 3 节给出过论证：两个叠起来的 3 × 3 层看到 5 × 5 的窗口，每个通道对只有 18 个权重而不是 25 个，而且两层之间还有一次非线性。VGG-16 有 1.38 亿个参数，其中 89% 在三个全连接层里，每张 224 × 224 的图像约需 155 亿次乘加（第 4 节）。它在 2014 年的分类任务中位列第二，仅次于 GoogLeNet，而且因为简单，它至今仍是常用的骨干网络和特征提取器。

Inception：并行分支

GoogLeNet（Szegedy 等人，2015）问的是该用多大的卷积核，答案是“全都用”。一个 inception 模块并行运行 1 × 1、3 × 3 和 5 × 5 卷积以及一个 3 × 3 最大池化，并把输出沿通道轴拼接起来（图 3.7）。第 6 节的 1 × 1 瓶颈结构使它的开销可以承受：模块（3a）整体有 163,328 个权重，开销为 1.28 亿次 MAC，其中降维后的 5 × 5 分支占 12.4 M。网络深 22 层（只计带参数的层），论文声称它使用的参数比 AlexNet 少 12 倍。它以 6.67% 的 top-5 误差赢得了 ILSVRC-2014 分类任务。两个辅助分类器是接在中间层上的小分类头，训练时它们的损失以 0.3 的权重相加，目的是把梯度推进早期的层：这是残差连接出现之前对深度问题的一种补救。

头条数字是怎么定义的

本模块中的 ImageNet 数字来自 ILSVRC 分类任务（Russakovsky 等人，2015）：1,000 个类别的 120 万张训练图像、5 万张验证图像和 10 万张测试图像。top-5 误差（top-5 error）在真实类别位于得分最高的五个类别之中时，就把预测算作正确；top-1 则要求它是得分最高的那个。这两者不能互相比较。竞赛的参赛作品常常是多个网络的集成，并在许多裁剪上评估，所以竞赛成绩并不是单个网络在单个视图上的精度。

一条主线

每个网络都是前一个加上一个想法：LeNet 的模式，AlexNet 的规模与正则化，VGG 统一的小卷积核，Inception 的廉价宽度。top-5 误差从 2012 年的 15.3% 降到 2014 年的 6.67%，参数量却不必因此上升：VGG-16 有 1.38 亿，GoogLeNet 只有几百万。剩下的障碍是深度，第 8 节会把它消除。

到 2014 年，深度已经见效：VGG 达到 19 层，GoogLeNet 达到 22 层，并靠辅助分类器把梯度传下去。再往深走，网络反而变差，而且不是因为过拟合。

退化问题

He 等人（2016）在 CIFAR-10 上训练了 20 层和 56 层的朴素网络，即由 3 × 3 卷积、批归一化和 ReLU 堆成的网络。他们的图 1 显示 56 层网络的误差更高，在测试集上如此，在训练集上也是如此。更高的训练误差排除了过拟合：更深的网络连它见过的数据都拟合不好。它也并非容量不足。把训练好的 20 层网络复制到更深网络的前 20 层，并让其余 36 层计算恒等映射，结果的训练误差与较浅的网络完全相同。至少同样好的解是存在的，而优化器没有找到它。这就是退化问题（degradation problem），一种优化上的失败。实验 3 在 8 × 8 的数字上复现了它，并绘制了训练曲线。

残差块

解决办法是让恒等映射成为默认。残差块（residual block）计算

其中分支 F 是几层卷积。块只学习输入的变化量；如果什么都不需要改变，F = 0，输入就直接通过。在基本块中，F 是 conv 3 × 3、批归一化、ReLU、conv 3 × 3、批归一化，原始设计在加法之后再应用一个 ReLU。当块改变形状时（通过步长或新的通道数），捷径变成带批归一化的步长 1 × 1 卷积（即投影），使两项可以相加（图 3.9，左）。下面的代码就是这个块，以及用它搭成的四阶段网络，并打印了相关的算术。

import torch, torch.nn as nn, torch.nn.functional as F

class Block(nn.Module):                      # conv-BN-ReLU twice, with a residual path
    def __init__(self, cin, cout, stride=1):
        super().__init__()
        self.c1 = nn.Conv2d(cin, cout, 3, stride, 1, bias=False)
        self.b1 = nn.BatchNorm2d(cout)
        self.c2 = nn.Conv2d(cout, cout, 3, 1, 1, bias=False)
        self.b2 = nn.BatchNorm2d(cout)
        self.skip = nn.Identity() if stride == 1 and cin == cout else nn.Sequential(
            nn.Conv2d(cin, cout, 1, stride, bias=False), nn.BatchNorm2d(cout))
    def forward(self, x):
        y = F.relu(self.b1(self.c1(x)))
        y = self.b2(self.c2(y))
        return F.relu(y + self.skip(x))

class SmallResNet(nn.Module):
    def __init__(self, classes=10):
        super().__init__()
        self.stem = nn.Sequential(
            nn.Conv2d(3, 32, 3, 1, 1, bias=False), nn.BatchNorm2d(32), nn.ReLU())
        self.stages = nn.Sequential(
            Block(32, 32), Block(32, 64, 2), Block(64, 128, 2), Block(128, 256, 2))
        self.head = nn.Linear(256, classes)
    def forward(self, x):
        x = self.stages(self.stem(x))
        return self.head(x.mean(dim=(2, 3)))   # global average pooling

net = SmallResNet()
print(sum(p.numel() for p in net.parameters()))          # 1,228,970 parameters
x = torch.zeros(1, 3, 32, 32)
print(net(x).shape)                                       # torch.Size([1, 10])

# output-size arithmetic for one layer
H, k, p, s = 32, 3, 1, 2
print((H + 2 * p - k) // s + 1)                           # 16

count = lambda m: sum(p.numel() for p in m.parameters())
print(count(net.stem), [count(b) for b in net.stages], count(net.head))

1228970
torch.Size([1, 10])
16
928 [18560, 57728, 230144, 919040] 2570

让恒等映射容易找到

朴素的层只有在权重学到恒等映射时才计算恒等映射，而在批归一化和 ReLU 夹在中间的情况下，这是个很难的目标。残差块通过让 F 变小来达到恒等映射。把每个分支最后一层初始化为接近零（实践中是把分支最后一个批归一化的缩放因子 \gamma 设为 0，Goyal 等人 2017 就是这样做的），每个块一开始就是恒等映射：深层 ResNet 起步时是一个浅层网络，随着分支的学习再逐步长进它的深度。

梯度为什么能保留下来

取 He 等人第二篇论文（2016b）的预激活块，其中 F 是两次“BN、ReLU、卷积”，加法之后没有任何操作（图 3.9，右）。对 i = l, \dots, L-1 写出块的方程并把它们相加，中间项两两抵消：

之后的每个表示，都是更早的某个表示加上一串分支输出之和。用链式法则求导，把梯度写成行向量，使它们从左边乘雅可比矩阵：

无论网络多深，恒等项都把顶层梯度原封不动地送到第 l 个块。要让总和消失，第二项必须对每个样本都恰好抵消恒等项。相比之下，朴素网络 \mathbf{h}_{i+1} = G_i(\mathbf{h}_i) 得到的是雅可比矩阵的连乘， \partial \mathbf{h}_L / \partial \mathbf{h}_l = \mathbf{J}_{L-1} \cdots \mathbf{J}_l （模块 02 第 3 节），当各因子略小于或略大于 1 时，它会按几何级数缩小或增长。逐块看，残差的雅可比矩阵是 \mathbf{I} + \partial F_i/\partial \mathbf{h}_i；把 L - l 个因子展开，得到对分支所有 2^{L-l} 个子集的求和，所以梯度沿着每一条路径传播，而最短的那条路径完全不经过任何分支（图 3.10）。

原始块中加法之后的 ReLU，会把每个块的雅可比矩阵乘上该 ReLU 的 0/1 导数，所以任何一个块里被关掉的单元，都会关闭它自己的高速通道（练习 6 会推导这一点）。这道门正是 He 等人转向预激活形式的原因。

实验 3 在 8 × 8 数字上，用 16 通道 3 × 3 层构成的网络测量了这一点。在初始化时且不做归一化，朴素网络中到达 stem 的梯度在 9 层时为 1.4 \times 10^{-5}，19 层时为 9 \times 10^{-10}，55 层时在 float32 中下溢为 0；残差网络的梯度在每个深度上都保持在 0.02 到 0.09 之间。朴素网络每层损失约 0.4 倍的梯度，接近 PyTorch 默认初始化所预测的 1/\sqrt{6} = 0.41，其权重方差是 He 初始化的六分之一（模块 02 第 6 节）。批归一化并不能治好朴素网络：加上它之后，55 层 stem 的梯度约为 190，变成了爆炸，而有捷径时为 0.8。带批归一化训练 12 个轮次（epoch）后，朴素 55 层网络的训练损失仍约为 2.1，仅略低于随机猜测，而残差网络约为 0.3；在 19 层时，朴素网络就已落后，约 0.4 对有捷径时的 0.04。深层残差网络受限的是学习率，而不是架构：把峰值学习率从 0.05 改为 0.03 或 0.02，它的损失在三个随机种子上降到 0.04 到 0.08，而朴素网络在所试的每个学习率下都远远落后。

瓶颈块

对 ResNet-50、101 和 152，分支是 1 × 1、3 × 3、1 × 1：256 通道的输入先降到 64 个通道，在 64 通道上用 3 × 3 滤波，再扩张回 256（第 6 节的瓶颈结构）。

结果

He 等人在 ImageNet 上训练了最深 152 层的 ResNet，它们的集成以 3.57% 的 top-5 误差赢得了 ILSVRC-2015 分类任务。在 CIFAR-10 上，有 170 万个参数的 ResNet-110 达到 6.43% 的测试误差（ResNet-20，27 万个参数：8.75%）。一个 1,202 层的网络达到了与 110 层网络相近的训练误差，但测试结果更差，为 7.93%：这是过拟合（5 万张训练图像上有 1,940 万个参数），而不是退化。深度已不再是障碍。

DenseNet：拼接而非相加

DenseNet（Huang 等人，2017）把一个块中的每一层与之前的每一层相连：第 \ell 层接收此前所有输出沿通道轴的拼接，并新增 k 个通道，即增长率（growth rate）。在 DenseNet-121 中，k = 32，进入第一个块的有 64 个通道，该块的第六层读取 64 + 5 \cdot 32 = 224 个通道，块的输出为 64 + 6 \cdot 32 = 256 个。DenseNet-121 约有 800 万个参数，每个参数的精度很强；代价是激活内存，因为每个拼接而成的特征图都要保留到反向传播。拼接（DenseNet，以及第 12 节的 U-Net）让特征保持分离并增加宽度；相加（ResNet）让宽度不变并把它们合并。

同样的形式 \mathbf{x} + F(\mathbf{x}) 包裹着 Transformer 的每个注意力和前馈子层（模块 06 第 5 节），上面的推导正是 Transformer 能够堆叠几十层深的原因。

ResNet 使深度变得可训练之后，工作转向了开销：一个网络每次乘加能给出多少精度，以及报告的提升中有多少真正来自架构。

MobileNet

MobileNet（Howard 等人，2017）通篇使用深度可分离块（第 6 节），并增加了两个用来在精度与开销之间折中的旋钮。宽度乘子（width multiplier）\alpha 把每个通道数缩放为 \alpha 倍；逐点层的开销与 C_{\text{in}} C_{\text{out}} 成正比，所以约降为 \alpha^2。分辨率乘子（resolution multiplier）\rho 缩放输入，从而缩放每张特征图的高和宽，所以开销降为 \rho^2。基线 MobileNet-224 有 420 万个参数，开销为 5.69 亿次乘加，ImageNet top-1 为 70.6%。它能在手机上运行。

MobileNetV2：倒残差

MobileNetV2（Sandler 等人，2018）加入了捷径，其安排与 ResNet 的瓶颈结构恰好相反。它的倒残差（inverted residual）块先用 1 × 1 卷积把窄的输入扩张（扩张因子为 6），在宽的宽度上用逐通道 3 × 3 滤波，再用后面不带 ReLU 的 1 × 1 卷积投影回窄的宽度；捷径连接的是两个窄端。中间很宽却负担得起，因为它是逐通道的。投影之所以保持线性，是因为在窄的表示上用 ReLU 会把一部分置零，而在那里被置零的信息就丢失了：论文称之为线性瓶颈。

EfficientNet：复合缩放

网络可以用三种方式放大：更深、更宽，或更高的分辨率。EfficientNet（Tan 和 Le，2019）按固定比例同时缩放这三者。一个卷积的开销是 k^2 C_{\text{in}} C_{\text{out}} H W 次 MAC。把宽度乘以 w，两个通道数都乘上，开销乘以 w^2；把分辨率乘以 r，H 和 W 都乘上，开销乘以 r^2；把深度乘以 d，层数乘上，开销乘以 d。所以 FLOPs 按 d\,w^2 r^2 缩放。复合缩放令

约束 \alpha\beta^2\gamma^2 \approx 2 使 \phi 每增加一个单位，FLOPs 就翻倍。在小的基线 B0 上、\phi = 1 时做网格搜索，选定 \alpha = 1.2、\beta = 1.1、\gamma = 1.15；B1 到 B7 以更大的 \phi 缩放 B0。EfficientNet-B0 有 530 万个参数，开销 3.9 亿次 FLOPs（在这篇论文中指乘加），它在 ICML 论文的表 2 中达到 76.3% 的 top-1。后来的 arXiv 修订版报告为 77.1%，所以请引用你所引的那个版本的数字。

ConvNeXt：把训练配方与架构分开

ConvNeXt（Liu 等人，2022）想要衡量的是，视觉 Transformer 的优势有多少在于它的训练配方，而不是架构。作者取 ResNet-50，先用 Transformer 时代的配方训练它：AdamW、300 个轮次、mixup、CutMix、RandAugment、随机擦除、随机深度和标签平滑。然后他们一步一步地改变架构，每一步之后都测量 ImageNet-1k 的 top-1。论文附录 C 的表 10 列出了每一步（图 2 绘制的是同样的数值）；四舍五入到 0.1：

最后一个值是 81.97 \pm 0.06。有两步损失了精度，而紧接其后的一步把它补了回来：逐通道卷积削减了计算量，随后的加宽把它花掉了；把逐通道层上移，为它更大的卷积核腾出了空间。最终的 ConvNeXt-T（表 1）以 2,860 万个参数（印作 29M）和 45 亿次乘加达到 82.1%，而 Swin-T Transformer 在 2,800 万个参数和 45 亿次乘加下为 81.3%。

读论文的教训是：只在相同的训练配方下比较架构。相对于用旧配方训练的基线所得的提升，可能大半是配方的功劳。

视觉 Transformer 的位置

视觉 Transformer（Dosovitskiy 等人，2021）把图像切成 16 × 16 的图像块，把每个图像块嵌入为一个 token（其实质是步长为 16 的 16 × 16 卷积），然后在这些 token 上运行 Transformer，不再使用其他卷积。由于内置的东西比 CNN 少，在只用 ImageNet-1k 训练时，它落后于同等规模的 ResNet；而在更大规模的数据集上预训练之后，它与 ResNet 持平或更好：这是实验 2 的归纳偏置（inductive bias）一课在大规模下的体现，模块 06 第 8 节会全面展开。

CNN 仍是默认选择的地方

截至 2026 年，在带标签数据稀缺、输入很大（高分辨率图像、三维体数据）、时延或功耗受限，以及输出是稠密的（每个像素或体素一个值）的场合，卷积网络仍然是默认选择。把卷积与注意力相结合的混合模型很常见。

工程图像数据集通常很小：几百张带标签的显微图像，几千张检测照片。本节给出在这类数据上训练 CNN 的实用配方，并用测量说明每个要素何时有帮助、何时没有。优化器、学习率调度和过拟合单个 batch 的测试属于模块 02；对 CNN 来说，训练时用随机裁剪、在有效处用翻转，并用余弦调度。

数据增强

数据增强（augmentation）每次使用训练图像时，都对它施加随机变换。它是图像上最有效的正则化手段，但有一条规则：每个变换都必须让标签仍然成立。把 6 垂直翻转就成了 9，而镜像的 2 根本不是数字。

• 几何类：随机裁剪（填充后裁回，或裁取随机区域再缩放）、翻转、小幅旋转和缩放，以及弹性形变；U-Net 论文特别指出，弹性形变是标注很少的显微图像中的关键增强。只在标签具有旋转不变性的地方才旋转。
• 光度类：亮度、对比度、颜色抖动、噪声和模糊。
• 对分割任务，掩码与图像接受同样的几何变换，并用最近邻插值重采样，使其仍是一组标签；光度变换只作用于图像。

混合方法把两个训练样本混合起来。Mixup（Zhang 等人，2018）构造

其中 \mathbf{y} 为独热标签，a 约为 0.2，这使大多数 \lambda 接近 0 或 1。CutMix（Yun 等人，2019）把 \mathbf{x}_j 的一个随机矩形粘贴到 \mathbf{x}_i 中，并按粘贴面积的比例混合标签。两者都使目标变软。

数据增强必须与部署相匹配

一个变换可以保持每个标签不变，却依然有害。数据增强告诉网络该忽略哪种变化；如果测试数据从不含这种变化，网络就白白把容量花在它上面。实验 2 的“动手试试”第 2、3 项在数字数据上测量了这两面；本模块编写时做的运行给出了这些数字：

• 在居中的 8 × 8 数字上，每类 20 张训练图像时，±1 像素的随机平移和 ±10° 的旋转，使验证精度从约 0.90 降到约 0.83。一个像素的平移是图像的八分之一，居中的测试集不含这样的平移，而 1,898 个参数的网络无法吸收这些额外的变化。
• 在 16 × 16 的画布上，数字确实出现在不同位置，每个轮次都把每个训练数字重新放到新的随机位置，使每类 5 张图像时的测试精度从 0.36 升到 0.66，每类 20 张时从 0.76 升到 0.90。

要用部署数据中确实存在的变化来做增强，并在与这些数据同样抽取的验证集上检查这一选择。

输入归一化

减去训练集每个通道的均值，再除以每个通道的标准差，使第一层看到量级为 1 的输入。使用预训练的骨干网络时，要用它的统计量，而不是你的数据集的：对 torchvision 的 ImageNet 模型，RGB 值缩放到 [0, 1]，然后均值取 (0.485, 0.456, 0.406)，标准差取 (0.229, 0.224, 0.225)。通道顺序、取值范围和缩放约定都是同一份契约的一部分。

CNN 中的批归一化

在 CNN 中，批归一化对每个通道，在 batch 和两个空间轴 (B, H, W) 上计算统计量；conv、BN、ReLU 是 ResNet 的配方，至今仍很常见。其机制见模块 02 第 10 节。当每个 batch 少于约 16 个样本时，统计量变得不可靠，此时用组归一化（group normalisation，Wu 和 He，2018）代替，它在通道组上对每个样本分别归一化；也可以用层归一化。起作用的是相互独立的样本数，而不是数值的个数：两张 64 × 64 的图像每个通道有 8,192 个值，但只来自两个样本。用小 batch 微调时，要让预训练骨干网络的批归一化层保持在 eval 模式。requires_grad=False 只能阻止它们的权重变化，却阻止不了它们的滑动均值和方差，只要该层处于 train 模式，这些统计量就会随你的 batch 更新。

迁移学习

在大型通用数据集上预训练的骨干网络，已经学到了可迁移的边缘、纹理和形状检测器。把它的最后一层换成适合你标签的一层再微调：先以正常学习率单独训练新层，再以约十分之一的学习率训练整个网络。选项按训练参数从少到多排列（图 3.11 连同实验 4 的精度一起画出了它们）：

1. 线性探测：冻结整个骨干网络，只在它的特征上训练一个新的线性头。
2. 保留早期层：复制最前面的块并冻结，其余部分从随机权重开始训练。
3. 微调：每一层都从预训练权重出发并全部训练，可以再改进为判别式学习率（discriminative learning rates，越早的层学习率越小）。
4. 从头训练。

选择取决于两点：有多少带标签的图像，以及源数据与目标数据有多接近。线性探测需要的数据最少，但只有当骨干网络最后的特征适合新任务时才有效。Yosinski 等人（2014）发现早期层是通用的，后期层则专属于源任务，所以差异大或范围窄的源任务应当只贡献它的早期层。

目标数据集很大时，预训练的帮助较小。He、Girshick 和 Dollár（2019）在 COCO 上从头训练检测器，在更长的训练计划下与 ImageNet 预训练的检测器持平；Raghu 等人（2019）发现，在大型医学影像数据集上，ImageNet 预训练带来的精度提升很小，但收敛更快。只有几百张带标签图像时，预训练仍是默认的起点，对看上去与预训练集毫无相似之处的科学图像也是如此。

小数据清单

• 从预训练的骨干网络出发，或者至少从预训练的早期层出发。
• 使用保持标签不变、并与部署相匹配的强数据增强。
• 让分类头保持小。
• 在按样品而不是按图像划分的验证集上早停 （模块 01 第 10 节）。
• 报告多个随机种子和多个折上的结果。

检测系统必须说出在哪里、有多少：焊缝射线照片上的每一个气孔。目标检测（object detection）输出一组三元组（框，类别，得分），数目任意，也可以为空。一个框可以用它的两个角点 (x_1, y_1, x_2, y_2) 表示，也可以用中心和尺寸 (x, y, w, h) 表示。骨干网络就是前几节的 CNN；新的东西是框的几何、把稠密预测变成一个列表，以及给这个列表打分。

交并比

两个框用它们的交并比（intersection over union，IoU）来比较：

两个与坐标轴对齐的框，其交集仍是一个框：它的下角取两个下角中较大的那个，上角取两个上角中较小的那个；宽度为 \max\big(0, \min(x_2^A, x_2^B) - \max(x_1^A, x_1^B)\big)，高度同理。PASCAL VOC 规定，如果一个检测与同类别中某个尚未被匹配的真实框的 IoU 超过 0.5，它就算真阳性；COCO 在 0.50, 0.55, \dots, 0.95 这十个阈值上分别评估再取平均，从而奖励贴合得紧的框。

锚框与框的参数化

网络无法直接回归数目未知的框。Faster R-CNN（Ren 等人，2015）在每个特征图位置放置 k 个锚框（anchor box），即若干种尺度和长宽比的参考框：3 种尺度 × 3 种长宽比，k = 9（图 3.12，左）。对每个锚框，网络预测类别得分和四个偏移量：

解码时把这一过程反过来：x = x_a + t_x w_a，w = w_a e^{t_w}。除以锚框的尺寸使平移与尺度无关，对数则保证解码出的宽度总是正的，并使尺寸误差成为相对误差。一张 1000 × 600 的图像在步长 16 下约有 60 × 40 = 2,400 个位置，因而约有 20,000 个锚框，这正是 Ren 等人给出的数字。

损失

损失由两项组成：在采样的锚框上的分类项，加上在与目标匹配的锚框上的框回归项：

其中目标 t^* 按上面的方式计算；当 |e| < 1 时 \operatorname{smooth}_{L_1}(e) = 0.5e^2，否则为 |e| - 0.5：在零附近是二次的，对离群值是线性的。后来的检测器使用基于 IoU 的框损失，直接优化评估所衡量的量。

两阶段还是单阶段

两阶段检测器（two-stage detector）先提出候选，再分类。在 Faster R-CNN 中，区域提议网络（region proposal network）给每个锚框打出“目标或背景”的分数，保留几百到大约两千个候选区域。RoI 池化（RoI pooling）把每个候选区域在特征图上对应的部分最大池化成固定的 7 × 7 网格，第二个头对该区域分类并修正它的框。Mask R-CNN（He 等人，2017）用 RoI 对齐（RoI align）取代了它，后者用双线性插值采样，而不是对区域边界取整。两阶段方法精确，但较慢。图 3.13 把这两种流程，连同下文介绍的集合预测检测器，并排画了出来。

单阶段检测器（one-stage detector）一次前向传播就在每个单元或锚框上预测类别和框。YOLO（Redmon 等人，2016）把图像分成 7 × 7 的网格；每个单元预测 2 个框，每个框 5 个数（四个坐标和一个置信度），外加 20 个类别概率，输出为 7 \times 7 \times (2 \cdot 5 + 20) = 7 \times 7 \times 30。SSD（Liu 等人，2016）在多张特征图上放置锚框。在约 20,000 个锚框中，几乎全是容易判断的背景，它们的交叉熵加起来会淹没少数几个目标。RetinaNet（Lin 等人，2017）为此提出了焦点损失（focal loss）；记 p_t 为预测的真实类别概率，

即乘以 (1 - p_t)^\gamma 的交叉熵，论文中取 \gamma = 2，目标类别的 \alpha = 0.25。

非极大值抑制

检测器会在每个目标周围的许多锚框上触发。非极大值抑制（non-maximum suppression，NMS）只保留一个（图 3.12，右）：把框按得分排序；保留得分最高的；删除其余与它同类别且 IoU 超过阈值（常用 0.5）的所有框；再对剩下的最佳框重复这一过程。

NMS 在拥挤场景中会失效：如果两个真实框的重叠超过阈值，得分较低的那个会被删掉。Soft-NMS（Bodla 等人，2017）不删除重叠的框，而是把它们的得分乘以一个随 IoU 增大而减小的因子。

平均精度

把一个类别的检测按得分排序；在每个名次上，精确率是到目前为止的检测中真阳性所占的比例，召回率是已找到的真实目标所占的比例。召回率 r 处的插值精确率，是召回率 \ge r 的所有位置上的最高精确率；平均精度（average precision，AP）是这条曲线下的面积。mAP 对各类别的 AP 取平均，COCO 的 AP 还对十个 IoU 阈值取平均。

集合预测

DETR（Carion 等人，2020）在 CNN 骨干网络上接一个 Transformer（模块 06），输出固定数目的（框，类别）预测，其中大多数是“无目标”。在损失内部，匈牙利算法以最低总代价把预测与真实框一一匹配，于是每个目标恰好被一个预测认领，重复的预测在训练中被消除：不需要锚框，也不需要 NMS。Mask R-CNN 的掩码分支把检测扩展到实例分割（第 12 节）。

语义分割（semantic segmentation）给每个像素标上一个类别；实例分割（instance segmentation）还要区分同一类别的不同目标，所以两个相接触的细胞会得到两个标签（Mask R-CNN 给每个检测到的框加了一个掩码头）。对语义分割，网络输出一张 logits 图 \mathbf{Z} \in \R^{C \times H \times W}，每个像素每个类别一个得分，基本的损失是模块 01的交叉熵在像素上的平均：

全卷积网络

Long 等人（2015）注意到，分类器的全连接层就是卷积：作用在 1 \times 1 特征图上、从 C 个输入到 C' 个输出的全连接层，就是权重同为 C' \times C 的 1 \times 1 卷积；读取 7 \times 7 \times 512 特征图的全连接层，就是一个 7 \times 7 卷积。这样改写之后，分类器就能在更大输入的每个位置上运行，这就是全卷积网络（fully convolutional network，FCN）。它的得分图很粗：经过五次池化，步长为 32，所以 512 × 512 的图像只给出 16 × 16 的得分。FCN 把它们上采样到原尺寸，并融合来自更精细特征图（步长 16 和 8）的预测。此后的每个分割网络都先下采样以汇集上下文，再上采样以恢复位置。

上采样与转置卷积

解码器上采样的方式有两种：插值后接一个卷积，或者用转置卷积（transposed convolution）。后者把每个输入值通过卷积核散布出去：对每个抽头 t，输入 i 把 K_t \, x_i 加到输出位置 i s + t - p 上。它就是带步长的卷积对其输入的梯度（第 2 节），只不过作为一个权重可学习的层正向运行。它的输出尺寸是卷积输出尺寸的反算：

其中 output_padding 用来在多个输入尺寸中挑出一个，因为带步长的卷积会把这几个尺寸映射到同一个输出尺寸。

输出位置 o 从每个满足 t \equiv o + p \pmod s 的抽头 t 各得到一份贡献。如果 s 整除 k，每个剩余类都含 k/s 个抽头，每个内部输出得到的贡献数相同。如果不整除，有些位置得到 \lceil k/s \rceil 份，另一些得到 \lfloor k/s \rfloor 份，在二维中两个这样的模式相乘就是棋盘格（图 3.14）。训练可能把它掩盖掉，但这种伪影很容易产生，却很难去除（Odena 等人，2016）。让卷积核尺寸能被步长整除（s = 2 时取 k = 2 或 4），或者先缩放再卷积，都能避免它。

U-Net

U-Net（Ronneberger 等人，2015）是一个对称的编码器-解码器（encoder-decoder）。收缩路径重复两个带 ReLU 的 3 × 3 卷积和一个 2 × 2 最大池化，通道数从 64 翻倍到 1,024。扩张路径重复一个把通道数减半的 2 × 2 上卷积、与同一分辨率的编码器特征图的拼接（concatenation），以及两个 3 × 3 卷积。最后一个 1 × 1 卷积把 64 个通道映射为类别得分（图 3.15）。瓶颈处以十六分之一的分辨率看到宽广的上下文；跳跃连接把它丢掉的细节直接送过去，所以精细的边界得以保留。

实验 5 在合成图像上测量了跳跃连接带来的收益：分割出圆形，而不是同样亮度的矩形（Dice 和 IoU 的定义见下文，在全部验证像素上合并计算）。调好的全局阈值达到 Dice 0.64（IoU 0.47），因为亮度无法区分形状。在完整模式下，U-Net 达到 Dice 0.965（IoU 0.933），去掉跳跃连接的同一网络为 0.952（0.908）。差异更大的是边界：在距真实边缘 2 个像素以内，有跳跃连接时像素精度为 0.950，没有时为 0.920，实验的预测图显示，无跳跃连接模型的错误都沿着目标轮廓分布。

Dice、IoU 与软 Dice 损失

记 P 为预测的前景，G 为真实的前景，Dice 系数（Dice coefficient）和 IoU（Jaccard 指数）为

二者是绑定在一起的。由第二式，\mathrm{TP} + \mathrm{FP} + \mathrm{FN} = \mathrm{TP}/J，所以 2\mathrm{TP} + \mathrm{FP} + \mathrm{FN} = \mathrm{TP}(1 + J)/J，于是

D \ge J，而且由于 D 随 J 单调递增，二者对模型的排序完全相同。只报告其中一个，并说明是哪一个。

要直接以 Dice 为目标训练，把集合换成概率 p_i \in [0, 1] 和二值目标 g_i。记 I = \sum_i p_i g_i，P = \sum_i p_i，G = \sum_i g_i，软 Dice 损失（soft Dice loss）为

（Milletari 等人 2016 把分母中的各项取了平方。）由商的求导法则，利用 \partial I/\partial p_i = g_i 和 \partial P/\partial p_i = 1，

在前景像素上为正，在背景像素上为负。每个梯度都依赖全局的总和，所以这个损失按目标大小做了归一化。Dice 加交叉熵是常用的组合。

背景通常占绝大多数。256 × 256 图像中一个 20 × 20 的目标只占像素的 400/65{,}536 = 0.61\%，所以全部预测为背景能得到 99.4% 的像素精度，而 Dice 为 0。应当按类别报告 Dice 或 IoU。空掩码带来相反的问题：预测和真值中都没有前景时，Dice 为 0/0。\epsilon 项把它定义为 1，在整个 batch 上计算 Dice 则能避开它；无论哪种做法，都要说明没有目标的图像是如何计分的。

U-Net 是生物医学分割的标准架构。它的输出是一张标签掩码，正是网格化步骤所需要的输入：等值面算法把它变成一个曲面，就可以测量体积和面积，第 13 节就是这样做的，并给出了它的误差预算。

传感器数据流、数字孪生的观测序列和光谱都是一维信号；CT 扫描和共聚焦显微镜的图像栈是三维体数据。卷积原封不动地推广到这两者；变化的是一维中的因果性和三维中的开销。

一维卷积与因果性

带空洞率 d 的一维卷积计算 y_t = \sum_{u=0}^{k-1} w_u\, x_{t - u d}，这样写使窗口终止于 t。第 3 节的感受野算术不变：步长为 1 的堆叠有 r = 1 + \sum_l (k_l - 1) d_l。新的是方向。预测器不能看到未来，所以因果卷积（causal convolution）只在左侧填充 (k - 1)d 个零：输出保持与输入同样的长度，且时刻 t 的输出只依赖 t 及之前的输入。对称填充会让每个输出读到 (k - 1)d/2 个未来样本，这种泄漏会让预测器在离线评估时显得比实际更好。

空洞能获得很长的历史，而不会像步长那样损失时间分辨率。WaveNet（van den Oord 等人，2016）堆叠了卷积核为 2 的因果卷积，空洞率逐层翻倍；图 3.16 画出了这种堆叠的前三层。

这样的残差堆叠，即时间卷积网络（temporal convolutional network，Bai 等人，2018），在序列任务上是能与循环神经网络抗衡的强基线。模块 04 练习 15 用空洞因果堆叠替换 LSTM 预测器，并比较两者。

三维卷积及其开销

一个三维层有 k^3 C_{\text{in}} C_{\text{out}} + C_{\text{out}} 个参数，开销为 k^3 C_{\text{in}} C_{\text{out}} D_{\text{out}} H_{\text{out}} W_{\text{out}} 次 MAC：比二维多一个因子 k。3D U-Net（Çiçek 等人，2016）就是第 12 节的 U-Net 换成 3 × 3 × 3 卷积，用稀疏标注的切片训练。

import torch.nn as nn
import torch.nn.functional as F

class Down3D(nn.Module):
    def __init__(self, cin, cout):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv3d(cin, cout, 3, padding=1), nn.GroupNorm(8, cout), nn.ReLU(),
            nn.Conv3d(cout, cout, 3, padding=1), nn.GroupNorm(8, cout), nn.ReLU())

    def forward(self, x):
        skip = self.conv(x)                  # kept for the decoder's skip connection
        return F.max_pool3d(skip, 2), skip

print(sum(p.numel() for p in Down3D(1, 32).parameters()))

28704

之所以用组归一化，是因为体数据的一个 batch 通常只有一两个图像栈，在这种情况下批归一化的统计量（模块 02 第 10 节）毫无意义；组归一化对每个样本在通道组和全部体素上归一化，与 batch 无关。

内存决定图像块大小

在三维中，起决定作用的约束是为反向传播保存的激活。

所以体数据以图像块为单位训练，batch 为一或二。滑动窗口推理（sliding-window inference）用相互重叠的图像块铺满整个体数据，并对重叠部分做融合，取平均或用高斯权重（对图像块中心的信任高于其填充过的边缘），使拼接处不留接缝。U-Net 论文的重叠分块策略就是它的二维版本。

各向异性体素与更廉价的三维卷积

共聚焦图像栈常常在平面内以 0.5 × 0.5 µm 采样，切片之间相距 2 µm：一个 3 × 3 × 3 卷积核在横向上跨越 1.5 µm，在深度上却跨越 6 µm。补救办法有：重采样为各向同性的体素，使用各向异性的卷积核（早期层用 1 × 3 × 3），或者用二维方法逐片分割。无论选哪一种，体素间距都必须随数据一起传递。

(2+1)D 分解把一个 3 × 3 × 3 卷积替换为一个 1 × 3 × 3 的空间卷积和一个 3 × 1 × 1 的轴向卷积：宽度为 C 时，权重为 9C^2 + 3C^2 = 12C^2，而不是 27C^2。三维逐通道卷积同第 6 节。

从掩码到曲面

在标注好的显微图像或 CT 上训练的 U-Net 产生一个概率体，阈值化后得到掩码。体积等于体素数乘以单个体素的体积。曲面是用移动立方体算法（marching cubes，Lorensen 和 Cline，1987）提取的等值面：遍历由 8 个相邻体素中心构成的每个立方体；把它的各个角点分为内或外（2^8 = 256 种情形，在旋转和取补意义下为 15 种）；在两端角点归属不同的每条棱上，按概率在 0.5 水平处做线性插值放置一个顶点；再按查找表把这些顶点连成三角形。按体素间距缩放后，网格给出面积和所围的体积。

数暴露的体素面，无论在什么分辨率下都是有偏的。对凸物体，朝 +x 方向的面加起来等于它在 yz 平面上的投影面积，所以一个球呈现出 6\pi r^2 的面，而真实面积是 4\pi r^2，无论体素多大，都差 1.5 倍。在二维中，圆盘的像素边周长为 8r，而真实周长为 2\pi r，差 4/\pi = 1.27 倍。图 3.17 在两种维度下把阶梯与等值面并排画出。

误差预算

模块 01 第 8 节中偏差与方差的拆分，可以用来组织一次测量。偏差来自离散化（阶梯）、阈值水平和系统性的分割误差；方差来自噪声，以及物体落在体素网格上的位置。

同一体数据的各个切片几乎是重复的，所以评估数据要按样品划分，而不是按切片划分（模块 01 第 10 节）。