---
tags: [AI, 深度学习, CNN, 计算机视觉]
阶段: 04-深度学习核心
难度: ★★★
created: 2026-10-18
related: "[[神经网络与前向传播]], [[反向传播详解]], [[PyTorch实战入门]]"
---

# 卷积神经网络CNN

## 定义

**卷积神经网络**（convolutional neural network, CNN）是以互相关运算替代全连接层中的稠密矩阵乘法、并在同一层内对全部空间位置共享同一组权值的神经网络；其每一层的输出是输入张量与一组可学习卷积核的局部加权和，因而参数数量与输入的空间尺寸无关。

逐项定义本篇使用的符号：

- $\mathbf{X}\in\mathbb{R}^{N\times C_{in}\times H\times W}$：一个批的输入张量。$N$ 为批大小，$C_{in}$ 为输入通道数，$H,W$ 为空间高与宽。PyTorch 采用 NCHW 顺序，即通道维在空间维之前。
- $\mathbf{W}\in\mathbb{R}^{C_{out}\times C_{in}\times k_h\times k_w}$：卷积核张量。$C_{out}$ 为输出通道数，也等于卷积核的个数；$k_h,k_w$ 为核的高与宽。
- $\mathbf{b}\in\mathbb{R}^{C_{out}}$：每个输出通道一个偏置标量。
- $s_h,s_w$：步幅（stride），相邻两个输出位置在输入上对应的窗口起点之间的距离。
- $p_h,p_w$：填充（padding），在输入的每一边补零的行数与列数。
- $d_h,d_w$：空洞率（dilation），核元素之间插入的间隔数；$d=1$ 时为标准卷积。
- $\mathbf{Y}\in\mathbb{R}^{N\times C_{out}\times H_{out}\times W_{out}}$：输出张量，也称特征图（feature map）。
- $H_{out},W_{out}$：输出空间尺寸，由 $H,W,k,p,s,d$ 共同决定。
- $\lfloor\cdot\rfloor$：向下取整，返回不超过自变量的最大整数。

逐项定义术语：

- 互相关（cross-correlation）：两个离散序列的滑动内积，不翻转其中一个序列。深度学习文献与框架（含 PyTorch 的 `Conv2d`）实现的都是互相关。
- 卷积（convolution）：与互相关只差一次核翻转，即 $\mathbf{Y}=\mathbf{X}*\mathbf{W}$ 对应互相关使用 $\mathrm{flip}(\mathbf{W})$。由于核是可学习参数，翻转不改变模型表达能力，故二者在实现层面等价。
- 通道（channel）：张量中与空间维并列的一维，表示同一空间位置上并列的多个特征或测量值。
- 步幅（stride）：卷积窗口每次滑动的像素数，$s>1$ 使输出分辨率按比例下降。
- 填充（padding）：在输入边界外补零，用于控制输出尺寸与保留边界信息。
- 空洞卷积（dilated convolution）：在核元素间插入零，使等效核尺寸变为 $d(k-1)+1$，从而在不增加参数的前提下扩大感受野。
- 感受野（receptive field）：输出特征图上一个单元在原始输入上所依赖的区域边长。
- 权值共享（weight sharing）：同一层在不同空间位置使用同一组权值。
- 平移等变性（translation equivariance）：输入平移 $\delta$ 时输出随之平移相同的 $\delta$；平移不变性（invariance）指输出不随平移改变。
- 池化（pooling）：在一个局部窗口内做最大值或均值聚合、从而降低空间分辨率的确定性运算。
- 残差连接（residual connection）：把某一层的输入直接加到其输出上的结构，形式为 $\mathbf{y}=\mathbf{x}+F(\mathbf{x})$。

## 为什么重要

- 参数规模决定可行性。若用全连接层处理 $224\times224\times3$ 的输入并输出 $4096$ 维特征，权值矩阵为 $4096\times150528$，参数量 $616{,}562{,}688$。以 float32 存储需 $2.30$ GiB，仅一层即超出多数训练卡的容量；对应的前向计算为 $6.2\times10^{8}$ 次乘加。同样提取 $64$ 个 $3\times3$ 局部模式的卷积层只有 $3\times3\times3\times64=1728$ 个权值，另有 $64$ 个偏置。
- 结构先验降低样本复杂度。图像具有两个稳定的统计性质：相邻像素强相关、同一局部模式可出现在任意位置。全连接层对输入像素的任意置换都能拟合，等于不使用这两个性质；卷积把局部性与平移平稳性写进参数共享约束，缩小假设空间，使相同样本量下泛化误差更小。
- 没有卷积时，视觉与语音任务只能依赖全连接网络或手工特征，深层网络的参数与显存开销使训练不可行；图像分类、检测、分割的进展都以卷积为起点。
- 在本库中的位置：前置为 [[神经网络与前向传播]]（张量形状与线性层）与 [[反向传播详解]]（参数共享下的梯度累加）；本篇的池化与步幅承担下采样，与 [[正则化与调参]] 中的批归一化、[[数据增广]] 共同构成训练配方；后续 [[从RNN到注意力机制]] 讨论把局部权重推广为按内容计算的全局权重，注意力层的参数与序列长度无关，与卷积层的参数与空间尺寸无关属于同一类设计取舍。
- 对应能力目标：懂原理对应「推导输出尺寸公式与感受野递推」；能复现对应「用 PyTorch 定义 CNN 并在 MNIST 上完成一个 epoch」；会评估对应「由参数量与计算量判断架构是否可行、由形状错误定位实现问题」。

## 原理与推导

### 1. 全连接层处理图像的参数量与结构问题

设输入图像展平为 $\mathbf{x}\in\mathbb{R}^{C_{in}HW}$，全连接层输出 $\mathbf{y}\in\mathbb{R}^{m}$：

$$\mathbf{y}=\mathbf{W}\mathbf{x}+\mathbf{b},\qquad \mathbf{W}\in\mathbb{R}^{m\times C_{in}HW}$$

参数量为 $mC_{in}HW+m$。取 $C_{in}=3$，$H=W=224$，$m=4096$，得 $4096\times150528=616{,}562{,}688$ 个权值。上式中每个输出单元与全部输入像素相连，权值矩阵的第 $j$ 列只对第 $j$ 个像素位置有效，因此同一模式出现在不同位置时必须由不同的权值分别表示。

由此产生两项代价：

1. 参数随空间尺寸平方增长。输入从 $224$ 增至 $448$ 时，第一层参数量变为 $4$ 倍。
2. 平移等变性只能通过数据增广间接获得，需要大量样本覆盖同一模式在不同位置的组合。

图像的统计性质给出两条可用的结构约束：

- 局部性：单个输出单元只需要 $k\times k$ 邻域内的输入，因为远距离像素与中心像素的联合统计量在自然图像中迅速衰减。
- 平移平稳性：同一局部模式在不同位置的统计规律相同，因此可以共用同一组权值。

把这两条约束写成结构，就得到局部连接加权值共享，即卷积层。局部连接把每个输出的连接数从 $C_{in}HW$ 降到 $C_{in}k_hk_w$；权值共享让 $C_{out}$ 个核在所有 $H_{out}W_{out}$ 个位置上复用，使参数量不再含 $H_{out}W_{out}$。

### 2. 互相关的定义与公式

单通道二维离散互相关，核不翻转：

$$Y[i,j]=\sum_{u=0}^{k_h-1}\sum_{v=0}^{k_w-1}W[u,v]\,X[i+u,\,j+v]$$

数学卷积把核翻转后再滑动：

$$Y[i,j]=\sum_{u}\sum_{v}W[u,v]\,X[i-u,\,j-v]$$

两者满足 $X\ast W=X\star\mathrm{flip}(W)$，其中 $\star$ 表示互相关。由于 $\mathbf{W}$ 由训练得到，使用 $\mathbf{W}$ 还是 $\mathrm{flip}(\mathbf{W})$ 只改变参数记号，不改变可达函数集合，因此框架统一实现互相关并把该运算称为卷积。本篇后续公式均按互相关书写。

带通道、步幅、填充与空洞的完整形式：

$$Y[n,o,i,j]=b[o]+\sum_{c=0}^{C_{in}-1}\sum_{u=0}^{k_h-1}\sum_{v=0}^{k_w-1}W[o,c,u,v]\;X\!\left[n,c,\;is_h+ud_h-p_h,\;js_w+vd_w-p_w\right]$$

其中下标落在 $[0,H)$ 与 $[0,W)$ 之外的 $X$ 项取 $0$，这正是填充的实现方式。$o$ 遍历 $0$ 到 $C_{out}-1$，每个 $o$ 对应一个独立的核，因此 $C_{out}$ 既是输出通道数也是核的个数。求和号内共有 $C_{in}k_hk_w$ 次乘法，这一数量决定了单个输出元素的乘加数。

### 3. 通道、卷积核、步幅、填充、空洞

| 超参数 | 含义 | 对输出尺寸的影响 | PyTorch 默认值 |
| --- | --- | --- | --- |
| $C_{in}$ | 输入通道数，必须与上一层输出一致 | 不改变空间尺寸 | 由 `in_channels` 指定 |
| $C_{out}$ | 输出通道数，等于核的个数 | 不改变空间尺寸 | 由 `out_channels` 指定 |
| $k_h,k_w$ | 核尺寸，决定单个输出的连接范围 | $k$ 增大则输出减小 | 无默认值，必须给出 |
| $s_h,s_w$ | 滑动步长 | $s$ 增大则输出近似按 $1/s$ 缩小 | 1 |
| $p_h,p_w$ | 每边补零数 | $p$ 增大则输出增大 | 0 |
| $d_h,d_w$ | 核元素间隔，有效核尺寸 $d(k-1)+1$ | $d$ 增大则输出减小 | 1 |

通道维的语义需要单独说明：$C_{in}$ 个通道在同一空间位置上被同一个输出元素的求和号合并，因此卷积核在通道维上是全连接的，在空间维上是局部连接的。这与全连接层的区别只在空间维，与 1×1 卷积的区别只在空间核尺寸。

### 4. 输出尺寸公式推导

只推导高方向，宽方向同理。输出位置 $i$ 对应的输入窗口起点为

$$\text{start}(i)=is-p$$

窗口覆盖的输入下标为 $\text{start}(i)+ud$，$u=0,\dots,k-1$，最右端下标为 $\text{start}(i)+d(k-1)$。有效核尺寸记为 $\tilde{k}=d(k-1)+1$，则最右端为 $\text{start}(i)+\tilde{k}-1$。

输出必须完全落在补零后的输入 $[0,\,H+2p)$ 内，因此需要

$$is-p\ \ge\ 0\quad\Longleftrightarrow\quad i\ \ge\ 0$$

$$is-p+\tilde{k}-1\ \le\ H+2p-1\quad\Longleftrightarrow\quad is\ \le\ H+2p-\tilde{k}\quad\Longleftrightarrow\quad i\ \le\ \frac{H+2p-\tilde{k}}{s}$$

满足条件的 $i$ 为非负整数，故

$$i_{\max}=\left\lfloor\frac{H+2p-\tilde{k}}{s}\right\rfloor=\left\lfloor\frac{H+2p-d(k-1)-1}{s}\right\rfloor$$

输出个数为 $i_{\max}+1$，即

$$H_{out}=\left\lfloor\frac{H+2p_h-d_h(k_h-1)-1}{s_h}\right\rfloor+1$$

向下取整的来源是整除：当 $H+2p-\tilde{k}$ 不能被 $s$ 整除时，最右侧剩余 $r=(H+2p-\tilde{k})\bmod s$ 个输入列不构成完整窗口，被直接丢弃，不参与任何输出。这是卷积不要求输入尺寸整除步幅的原因，也是「输出尺寸比手算少 1」的常见来源。

常见配置的数值：

| $H$ | $k$ | $p$ | $s$ | $H_{out}$ | 说明 |
| --- | --- | --- | --- | --- | --- |
| 28 | 3 | 1 | 1 | 28 | 核 3、填充 1 保持尺寸 |
| 28 | 5 | 0 | 1 | 24 | 无填充，尺寸减少 $k-1$ |
| 28 | 3 | 1 | 2 | 14 | 步幅 2 使尺寸减半 |
| 28 | 2 | 0 | 2 | 14 | 2×2 池化等价配置 |
| 28 | 3 | 0 | 2 | 13 | 余数 1 被丢弃 |
| 32 | 7 | 2 | 2 | 15 | 余数 1 被丢弃 |

「尺寸不变卷积」（same convolution）的条件可由公式反解：要求 $H_{out}=H$ 且 $s=1$，则 $2p-\tilde{k}+1=1$，即 $p=(\tilde{k}-1)/2$。对奇数 $k$ 且 $d=1$ 有 $p=(k-1)/2$；对偶数 $k$ 该式给出半整数，只能采用不对称填充或接受尺寸变化。$s>1$ 时任何填充都无法保持尺寸。

### 5. 参数量与计算量

参数量只与核尺寸、通道数、是否带偏置有关，与输入空间尺寸无关：

$$\text{Params}_{\text{conv}}=C_{out}\left(C_{in}k_hk_w+1\right)$$

乘加数（MAC）与输入尺寸有关：

$$\text{MAC}_{\text{conv}}=N\,H_{out}W_{out}\,C_{out}\,C_{in}k_hk_w$$

通用约定把一次乘加记为 2 次浮点运算，故 $\text{FLOPs}\approx2\,\text{MAC}$，该计数不含偏置加法与激活函数。

以本篇第 6 节的小型网络为例，逐层数值：

| 层 | 配置 | 输出形状 | 参数量 | MAC |
| --- | --- | --- | --- | --- |
| conv1 | $1\to8$，$3\times3$，$p=1$ | $8\times28\times28$ | $8(1\cdot9+1)=80$ | $28\cdot28\cdot8\cdot9=56{,}448$ |
| pool1 | $2\times2$，$s=2$ | $8\times14\times14$ | 0 | 0 |
| conv2 | $8\to16$，$3\times3$，$p=1$ | $16\times14\times14$ | $16(8\cdot9+1)=1168$ | $14\cdot14\cdot16\cdot72=225{,}792$ |
| pool2 | $2\times2$，$s=2$ | $16\times7\times7$ | 0 | 0 |
| fc | $784\to10$ | $10$ | $784\cdot10+10=7850$ | $7840$ |

总参数量 $80+1168+7850=9098$。作为对照，同尺寸输入的 $784\to512\to256\to10$ 三层感知机参数量为 $401{,}920+131{,}328+2570=535{,}818$，是本网络的 $58.9$ 倍，且没有任何空间结构约束。

计算量的分布与参数量不同：conv2 的 MAC 是 conv1 的 $4$ 倍。三个因子相乘得到该比值：输入通道数为 $8$ 倍，输出通道数为 $2$ 倍，空间面积为 $1/4$，即 $8\times2\times1/4=4$。这说明参数量小不蕴含计算量小，部署时的延迟主要由 MAC 与内存访问决定。

### 6. 感受野递推

记第 $l$ 层输出的感受野边长为 $r_l$，该层一个输出步长在原始输入上对应的像素距离为跳跃步长 $j_l$。初始条件 $r_0=1$，$j_0=1$。对第 $l$ 层的核尺寸 $k_l$ 与步幅 $s_l$，有递推

$$r_l=r_{l-1}+(k_l-1)\,j_{l-1},\qquad j_l=j_{l-1}\,s_l$$

含义是：$j_{l-1}$ 是上一层相邻两个输出中心在输入上的间距，核每多覆盖一个上一层位置，感受野就扩大 $j_{l-1}$。

对 $3\times3$ 卷积、$2\times2$ 池化、$3\times3$ 卷积、$2\times2$ 池化、$3\times3$ 卷积的组合，逐步计算：

| 层 | $k$ | $s$ | $r_l$ | $j_l$ |
| --- | --- | --- | --- | --- |
| 初始 | — | — | 1 | 1 |
| conv1 | 3 | 1 | $1+2\cdot1=3$ | 1 |
| pool1 | 2 | 2 | $3+1\cdot1=4$ | 2 |
| conv2 | 3 | 1 | $4+2\cdot2=8$ | 2 |
| pool2 | 2 | 2 | $8+1\cdot2=10$ | 4 |
| conv3 | 3 | 1 | $10+2\cdot4=18$ | 4 |

第 3 个卷积层的一个单元依赖输入的 $18\times18$ 区域。该结果可按几何方式核对：conv3 的三个输入位置来自 pool2 的相邻输出，它们在原始输入上的间距为 $j=4$，两端相距 $(3-1)\times4=8$；每个 pool2 输出自身的感受野为 $10$，两者相加得 $10+8=18$，与递推结果一致。

递推的两条推论：

- 无步幅的 $L$ 层 $3\times3$ 卷积，感受野为 $1+2L$。$L=10$ 时只有 $21$，感受野随深度线性增长，这是深层网络需要大量层数才能覆盖整幅图像的原因。
- 步幅与空洞是放大感受野的两种手段：步幅同时降低分辨率，空洞在保持分辨率的前提下把 $j$ 的等效作用放大到核间隔上，代价是采样稀疏。

### 7. 权值共享与平移等变性

平移算子 $T_\delta$ 定义为 $(T_\delta X)[i,j]=X[i-\delta,j]$。对 $s=1$、忽略边界、单通道互相关：

$$(T_\delta X\star W)[i,j]=\sum_{u,v}W[u,v]\,(T_\delta X)[i+u,j+v]=\sum_{u,v}W[u,v]\,X[i+u-\delta,j+v]$$

而

$$\left(T_\delta(X\star W)\right)[i,j]=(X\star W)[i-\delta,j]=\sum_{u,v}W[u,v]\,X[i-\delta+u,j+v]$$

两式相等，因此 $T_\delta X\star W=T_\delta(X\star W)$，卷积对平移等变。等变性来自权值共享：核在所有位置相同，输入平移才等价于输出平移。

等变性在三种情况下被削弱或破坏：

1. 填充。边界处的补零位置随平移改变，$i$ 接近边界时窗口含零，单个位置的输出不再严格随输入平移。
2. 步幅。$s>1$ 时输出网格对输入平移只在 $s$ 的整数倍上保持等变，其余平移量产生格点相位差。
3. 池化与全局池化。局部最大池化使小范围平移不改变输出，得到局部不变性；全局平均池化把等变的特征图变为对平移不变的标量。等变指特征随输入移动，不变指特征不随输入移动，两者是不同性质，分类任务最终需要不变性，检测与分割需要等变性。

权值共享对反向传播的影响是梯度在位置上累加：由于所有位置共用 $\mathbf{W}$，$\partial L/\partial\mathbf{W}$ 等于各位置贡献之和，具体形式与 [[反向传播详解]] 中参数共享层的处理一致。

### 8. 池化类型与作用

池化窗口尺寸 $k$、步幅 $s$、填充 $p$ 的输出尺寸公式与卷积相同：

$$H_{out}=\left\lfloor\frac{H+2p-k}{s}\right\rfloor+1$$

常见类型：

| 类型 | 运算 | 反向传播 | 典型用途 |
| --- | --- | --- | --- |
| 最大池化 | 窗口内取最大值 | 梯度只回传至取到最大值的位置 | 保留显著响应，分类网络 |
| 平均池化 | 窗口内取均值 | 梯度均分到窗口内全部位置 | 平滑响应，需要位置平均时 |
| 全局平均池化 | 对每个通道全部空间位置取均值 | 同上，窗口等于整幅特征图 | 替代末端全连接层，减少参数 |
| 自适应池化 | 由目标输出尺寸反推窗口 | 同对应类型 | 输入尺寸可变时固定输出形状 |

作用有三项：降低空间分辨率从而减少后续计算量与参数量；增大跳跃步长 $j$，使后续层在相同核尺寸下覆盖更大的输入区域；通过取最大值或均值提供局部平移不变性。代价是丢弃窗口内的位置信息，对需要精确定位的任务（分割、检测的关键点）不利，现代架构常用步幅卷积替代池化，以避免不可学习的硬性下采样。

最大池化的反向传播是位置选择：前向记录窗口内最大值的位置，反向把上游梯度整体赋给该位置、其余位置为 $0$。当窗口内存在并列最大值时，PyTorch 按检索顺序把梯度分配给第一个最大值的位置，因此前向记录的位置必须与反向使用的掩码一致。

### 9. 1×1 卷积

$k_h=k_w=1$ 的卷积在每个空间位置上独立执行一次跨通道线性变换：

$$Y[n,o,i,j]=b[o]+\sum_{c=0}^{C_{in}-1}W[o,c,0,0]\,X[n,c,i,j]$$

其作用是把 $C_{in}$ 维通道向量映射为 $C_{out}$ 维，参数量 $C_{out}(C_{in}+1)$，MAC 为 $NHWC_{out}C_{in}$。它与「对每个像素施加同一个全连接层」完全等价，区别在于 1×1 卷积保留空间维、可批量处理，并可直接嵌入卷积堆叠。

三种用途：

1. 通道降维与升维，构成瓶颈结构。逐像素计算，$256\to64$、$3\times3$、$64\to256$ 的组合乘加数为 $256\cdot64+64\cdot9\cdot256+64\cdot256=180{,}224$，两个 $3\times3$ 的 $256\to256$ 卷积为 $2\cdot256\cdot9\cdot256=1{,}179{,}648$，前者约为后者的 $15.3\%$。
2. 在不改变空间尺寸的前提下增加非线性。每个 1×1 卷积后可接激活函数，等价于逐像素的多层感知机。
3. 通道混合，使不同通道的特征在每个位置上被重新组合，常用于注意力模块与通道重标定。

### 10. 经典架构演进

| 模型 | 年份 | 深度 | 关键结构 | 参数量 |
| --- | --- | --- | --- | --- |
| LeNet-5 | 1998 | 7 层 | 2 卷积 + 2 池化 + 3 全连接，$32\times32$ 输入 | 约 $6\times10^{4}$ |
| AlexNet | 2012 | 8 层 | ReLU、Dropout、重叠池化、双 GPU 训练 | 约 $6\times10^{7}$ |
| VGG-16 | 2014 | 16 层 | 全部使用 $3\times3$ 卷积堆叠，通道数逐段翻倍 | 约 $1.38\times10^{8}$ |
| ResNet-50 | 2015 | 50 层 | 残差块、批归一化、全局平均池化 | 约 $2.56\times10^{7}$ |

VGG 的设计依据可由参数量比较得到：两个 $3\times3$ 卷积的感受野等于一个 $5\times5$ 卷积，参数量为 $2C^2\cdot9$ 与 $C^2\cdot25$，比值为 $0.72$，且中间多一次非线性。这一结论使「小核堆叠」成为主流。

ResNet 解决的是**退化问题**（degradation problem）：在 CIFAR-10 上，$56$ 层普通卷积网络的训练误差高于 $20$ 层普通网络。训练误差随深度上升而非下降，说明问题不是过拟合，而是深层网络难以优化到恒等映射这一简单解。残差块把目标函数改写为

$$\mathbf{y}=\mathbf{x}+F(\mathbf{x};\{\mathbf{W}_i\})$$

若最优映射接近恒等，网络只需把 $F$ 的权值压到接近 $0$，比用非线性层精确拟合恒等映射容易。当输入输出通道数或空间尺寸不匹配时，用 $1\times1$ 卷积投影：$\mathbf{y}=\mathbf{W}_s\mathbf{x}+F(\mathbf{x})$。

梯度通路的解释直接由链式法则给出：

$$\frac{\partial L}{\partial\mathbf{x}}=\frac{\partial L}{\partial\mathbf{y}}\left(\mathbf{I}+\frac{\partial F}{\partial\mathbf{x}}\right)=\frac{\partial L}{\partial\mathbf{y}}+\frac{\partial L}{\partial\mathbf{y}}\frac{\partial F}{\partial\mathbf{x}}$$

第二项含 $\partial F/\partial\mathbf{x}$，可能很小；第一项是恒等项，把上游梯度原样传回，不经过任何权值乘法。将 $L$ 个残差块串联，展开得

$$\frac{\partial L}{\partial\mathbf{x}_0}=\frac{\partial L}{\partial\mathbf{x}_L}\prod_{l=1}^{L}\left(\mathbf{I}+\frac{\partial F_l}{\partial\mathbf{x}_{l-1}}\right)$$

连乘的每一项都含 $\mathbf{I}$，展开后存在 $2^L$ 条路径，其中包含全部由恒等项组成的路径，其系数为 $1$。因此梯度不会因深度增加而按指数衰减到零；这是残差结构相对普通深层网络在优化上的区别，也是 [[反向传播详解]] 中梯度连乘分析的一个直接应用。

## 关键直觉

> [!tip] 卷积是带平移共享约束的局部线性算子
> 一个卷积层可视为两件事的组合：在每个位置上用同一个 $C_{in}k_hk_w$ 维线性映射生成 $C_{out}$ 个响应，以及把该映射在所有位置上复用。参数共享把「同一模式在不同位置」合并为同一个参数，局部连接把「与全部像素相关」缩减为「与邻域相关」。输出尺寸公式是这个滑动过程在有限输入上的计数结果，感受野递推是这些局部窗口逐层复合后的覆盖范围。等变性由共享产生，不变性由池化或全局聚合产生，二者不可混用。

## 例子与代码

### 手算一个互相关

输入 $3\times3$，核 $2\times2$，$s=1$，$p=0$：

$$\mathbf{X}=\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix},\qquad \mathbf{W}=\begin{bmatrix}1&0\\0&-1\end{bmatrix}$$

按互相关公式，输出为 $2\times2$：

$$Y[0,0]=1\cdot1+2\cdot0+4\cdot0+5\cdot(-1)=-4$$
$$Y[0,1]=2-5=-3,\qquad Y[1,0]=4-7=-3,\qquad Y[1,1]=5-8=-3$$

该核计算的是左上像素减右下像素，即一种对角方向的差分。若按数学卷积，需先把核旋转 $180^\circ$ 得 $\begin{bmatrix}-1&0\\0&1\end{bmatrix}$，输出符号整体相反。框架实现互相关，因此训练得到的核直接用于上式，无需旋转。

### 输出尺寸与参数量的数值核对

```python
# 依赖：Python 3.10+，无需第三方库
def conv_out(h, k, p, s, d=1):
    """按 ⌊(H + 2p - d(k-1) - 1)/s⌋ + 1 计算输出边长"""
    k_eff = d * (k - 1) + 1          # 空洞卷积的等效核尺寸
    return (h + 2 * p - k_eff) // s + 1

for h, k, p, s in [(28, 3, 1, 1), (28, 5, 0, 1), (28, 3, 1, 2), (28, 3, 0, 2), (28, 2, 0, 2)]:
    print(f"H={h} k={k} p={p} s={s} -> {conv_out(h, k, p, s)}")

def conv_params(c_in, c_out, k, bias=True):
    return c_out * (c_in * k * k) + (c_out if bias else 0)

p1 = conv_params(1, 8, 3)            # 8 * (1*9 + 1)
p2 = conv_params(8, 16, 3)           # 16 * (8*9 + 1)
p_fc = (16 * 7 * 7) * 10 + 10        # 展平后接 10 类
print(p1, p2, p_fc, p1 + p2 + p_fc)
```

输出：

```text
H=28 k=3 p=1 s=1 -> 28
H=28 k=5 p=0 s=1 -> 24
H=28 k=3 p=1 s=2 -> 14
H=28 k=3 p=0 s=2 -> 13
H=28 k=2 p=0 s=2 -> 14
80 1168 7850 9098
```

第三、四行说明同样的 $k=3$ 与 $s=2$ 在 $p=1$ 时得到 $14$、在 $p=0$ 时得到 $13$：前者 $(28+2-3)=27$，后者 $(28-3)=25$，两者除以 $2$ 的余数都是 $1$，但可容纳的窗口起点数相差一。

### 感受野递推的数值验证

```python
def receptive_field(layers):
    """layers 为 [(k, s), ...]，返回最终感受野边长"""
    r, j = 1, 1                       # 初始感受野 1，跳跃 1
    for k, s in layers:
        r = r + (k - 1) * j           # 核每多覆盖一个位置，感受野扩大 j
        j = j * s                     # 步幅累积到跳跃
    return r

arch = [(3, 1), (2, 2), (3, 1), (2, 2), (3, 1)]   # conv-pool-conv-pool-conv
print("感受野:", receptive_field(arch))
print("10 层 3x3 卷积:", receptive_field([(3, 1)] * 10))
```

输出：

```text
感受野: 18
10 层 3x3 卷积: 21
```

### PyTorch 定义小型 CNN 并在 MNIST 上训练一个 epoch

依赖 PyTorch 2.x 与 torchvision 0.15 以上。先打印每层输出形状与参数量，再训练一个 epoch。

```python
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

torch.manual_seed(0)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


class SmallCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 8, kernel_size=3, stride=1, padding=1),   # 1x28x28 -> 8x28x28
            nn.ReLU(),
            nn.MaxPool2d(2),                                        # 8x28x28 -> 8x14x14
            nn.Conv2d(8, 16, kernel_size=3, stride=1, padding=1),   # 8x14x14 -> 16x14x14
            nn.ReLU(),
            nn.MaxPool2d(2),                                        # 16x14x14 -> 16x7x7
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),                                           # 16x7x7 -> 784
            nn.Linear(16 * 7 * 7, 10),
        )

    def forward(self, x):
        return self.classifier(self.features(x))


def trace(model, x):
    """在叶子模块上挂前向钩子，打印输出形状与本层参数量"""
    handles = []

    def make_hook(name):
        def hook(module, inputs, output):
            if not isinstance(output, torch.Tensor):
                return
            n = sum(p.numel() for p in module.parameters(recurse=False))
            print(f"{name:<16}{str(tuple(output.shape)):<24}{n:>8}")
        return hook

    for name, m in model.named_modules():
        if len(list(m.children())) == 0:        # 只挂叶子模块，避免重复打印容器
            handles.append(m.register_forward_hook(make_hook(name)))
    model.eval()
    with torch.no_grad():
        model(x)
    for h in handles:
        h.remove()


transform = transforms.Compose([
    transforms.ToTensor(),                       # uint8 [0,255] -> float32 [0,1]
    transforms.Normalize((0.1307,), (0.3081,)),  # MNIST 训练集均值与标准差
])
train_ds = datasets.MNIST(root="./data", train=True, download=True, transform=transform)
test_ds = datasets.MNIST(root="./data", train=False, download=True, transform=transform)
train_loader = DataLoader(train_ds, batch_size=64, shuffle=True)
test_loader = DataLoader(test_ds, batch_size=1000, shuffle=False)

model = SmallCNN().to(device)
print(f"{'层':<16}{'输出形状':<24}{'参数量':>8}")
x_demo, _ = next(iter(DataLoader(train_ds, batch_size=4)))
trace(model, x_demo.to(device))
print(f"{'总计':<16}{'':<24}{sum(p.numel() for p in model.parameters()):>8}")

opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()

model.train()
for step, (xb, yb) in enumerate(train_loader):
    xb, yb = xb.to(device), yb.to(device)
    opt.zero_grad()                 # 梯度累积，必须每步清零
    logits = model(xb)
    loss = loss_fn(logits, yb)
    loss.backward()
    opt.step()
    if (step + 1) % 200 == 0:
        print(f"step {step + 1:4d}/{len(train_loader)}  loss {loss.item():.4f}")

model.eval()                        # 切换 eval 以固定 BatchNorm 统计量、关闭 Dropout
correct = 0
with torch.no_grad():
    for xb, yb in test_loader:
        xb, yb = xb.to(device), yb.to(device)
        correct += (model(xb).argmax(dim=1) == yb).sum().item()
print(f"测试集准确率 {correct / len(test_ds):.4f}")
```

形状输出是确定的：

```text
层              输出形状                        参数量
features.0      (4, 8, 28, 28)                    80
features.1      (4, 8, 28, 28)                     0
features.2      (4, 8, 14, 14)                     0
features.3      (4, 16, 14, 14)                 1168
features.4      (4, 16, 14, 14)                    0
features.5      (4, 16, 7, 7)                      0
classifier.0    (4, 784)                           0
classifier.1    (4, 10)                         7850
总计                                             9098
```

训练部分的数值随随机种子、设备与 cuDNN 的非确定性浮动，可核对的量级为：初始批损失接近 $\ln10\approx2.303$；一个 epoch 后批损失降到 $0.05$ 附近，测试集准确率在 $0.98$ 至 $0.99$ 之间。若损失停在 $2.3$ 附近不下降，首先检查是否漏掉 `opt.zero_grad()` 或把标签传成了 one-hot。

`trace` 在 `eval` 模式下调用，目的是让批归一化使用运行统计量；当前网络不含批归一化，该设置不影响形状。钩子只挂在叶子模块上，因此容器 `features` 与 `classifier` 不会被重复统计；`recurse=False` 保证卷积层的参数量不包含其内部其他参数。

## 易错点

> [!warning] 常见错误
> - 通道顺序写成 NHWC。PyTorch 的 `Conv2d` 要求 $(N,C_{in},H,W)$。若把 $(N,28,28,1)$ 直接输入，$C_{in}=1$ 与实际的 $28$ 不符会报通道数错误；若 $C_{in}$ 恰好等于 $H$，则卷积在错误的维度上滑动，程序不报错而输出形状错误。`torchvision` 的 `ToTensor()` 已输出 CHW，无须手工转置。
> - 误用「padding 使尺寸不变」。$p=(k-1)/2$ 只在 $s=1$、$d=1$、$k$ 为奇数时成立。$k=2$ 时该式给 $0.5$，PyTorch 直接拒绝非整数填充；$s=2$ 时任何整数填充都不能保持尺寸。需要用 `padding="same"` 时，PyTorch 要求 `stride=1`。
> - 混淆 `Conv2d` 与 `MaxPool2d` 的默认参数。`Conv2d` 默认 `stride=1, padding=0`，`MaxPool2d(2)` 默认 `stride=kernel_size=2`。把池化写成 `MaxPool2d(2, stride=1)` 会使尺寸只减 1，后续全连接的输入维度随之出错，报错信息为矩阵乘法维度不匹配。
> - 池化后尺寸按 $H/2$ 手算。$28\to14$ 成立，$27\to13$ 而非 $13.5$，向下取整丢弃一个像素。连续多次池化时误差累积，$27\to13\to6\to3$，若按四舍五入写成 $27\to14$ 则全连接层维度必然错误。
> - 批归一化的位置与状态错误。标准顺序为卷积、批归一化、激活；把批归一化放在激活之后会改变非线性前的分布假设。推理时必须 `model.eval()`，否则批统计量持续更新且用当前批的均值方差做归一化，单样本推理结果不稳定。批归一化应使用 `BatchNorm2d` 而非 `BatchNorm1d`，后者只接受 $(N,C)$ 或 $(N,C,L)$ 形状，四维输入会直接报维度错误。
> - 展平顺序与维度计算错误。`nn.Flatten()` 默认从第 1 维开始展平，输出 $(N,C H W)$；若池化次数或填充与设计不符，$16\times7\times7=784$ 被写成 $16\times8\times8=1024$，线性层报维度错误。相反方向的错误是形状恰好相同而通道顺序被打乱，此时不报错但精度异常。

## 关联笔记

- 前置：[[神经网络与前向传播]] —— 提供张量形状约定、线性层与激活函数的定义，本篇的卷积层是它的局部连接推广。
- 前置：[[反向传播详解]] —— 参数共享层的梯度按位置累加，池化的梯度按最大值位置路由，均以该篇的计算图规则为基础。
- 后续：[[正则化与调参]] —— 批归一化、Dropout 与权重衰减在卷积网络中的放置位置与调参顺序由该篇统一处理。
- 后续：[[PyTorch实战入门]] —— 把本篇的模块拼装、数据加载与训练循环整理为完整工程流程。
- 对照：[[从RNN到注意力机制]] —— 卷积的权重与位置绑定且局部，注意力的权重由内容计算且全局，两条路径的归纳偏置差异是理解 Transformer 的起点。

## 达标检测

- [ ] 计算 $224\times224\times3$ 输入接 $4096$ 维全连接层的参数量与 float32 显存占用；写出含 $C_{in},C_{out},k,s,p,d$ 的互相关公式与参数量公式，并计算 $3\to64$、$k=7$、$s=2$、$p=3$ 的卷积层参数量与输出空间尺寸（输入 $224$），说明两者参数量的差异来源。
- [ ] 由窗口起点与右端下标的不等式推导输出尺寸公式，并计算 $H=28,k=5,p=2,s=2$ 与 $H=28,k=3,p=0,s=3$ 的输出边长。
- [ ] 用递推公式计算 conv3-pool2-conv3-pool2-conv3 的感受野，说明为何 10 层 $3\times3$ 卷积的感受野只有 21。
- [ ] 证明 $s=1$、无填充时互相关与平移算子可交换，并指出填充与步幅分别在哪一环节破坏该等式。
- [ ] 运行本篇 PyTorch 代码，核对 conv2 与 conv1 的参数量比值为 $14.6$，并说明该比值由哪些超参数决定。
- [ ] 指出把 $(N,H,W,C)$ 输入 `Conv2d` 时可能出现的两种后果，以及 `MaxPool2d(2, stride=1)` 引发的具体报错。

## 参考来源

- Goodfellow, Bengio, Courville, *Deep Learning*, 2016, 第 9 章「Convolutional Networks」 —— 对应本篇互相关定义、稀疏连接与参数共享的动机、池化的讨论以及卷积的等变性分析。
- d2l.ai《动手学深度学习》，第 6 章「卷积神经网络」 —— 对应输出尺寸公式、填充与步幅的数值示例、多输入多输出通道与 1×1 卷积的实现视角。
- He, Zhang, Ren, Sun, *Deep Residual Learning for Image Recognition*, arXiv:1512.03385 —— 对应本篇退化问题的表述、残差块结构与恒等映射的优化论证。
- Stanford CS231n 课程笔记，Convolutional Neural Networks 与 Convolutional Networks: Architectures —— 对应感受野、参数量与计算量的逐层核算，以及 LeNet、AlexNet、VGG、ResNet 的结构对比。
- PyTorch 官方文档，`torch.nn.Conv2d`、`torch.nn.MaxPool2d`、`torch.nn.Flatten` —— 对应默认参数、输出尺寸公式在框架中的实现与 `padding="same"` 的适用条件。
