第 13 章 · 经典网络结构

CNN 卷积神经网络

前面两部分搭的都是全连接网络(MLP)——每个输入都连到每个神经元。它处理“一行特征”很好, 可一旦面对图像就水土不服。这一章认识第一位“专才”:CNN(卷积神经网络), 它靠卷积这一招,又省参数又懂空间,是计算机视觉几十年的主力。

1. 全连接处理图像,卡在哪?

把一张图片摊平成一个长向量、直接喂给 MLP,会撞上三个问题:

• 参数爆炸:一张 1000×1000 的彩图摊平就是 300 万个输入。第一层哪怕只有 1000 个神经元,权重就有 30 亿个——根本训不动。
• 丢了空间结构:摊平后,原本相邻的像素被拆散到向量各处,“这两个点挨在一起”这种关键信息没了。
• 没有平移不变:猫出现在左上角和出现在右下角,对 MLP 是完全不同的输入,得各学一遍,极其浪费。

CNN 的所有设计,都是冲着这三点来的。

2. 卷积:一个小滤波器,在图上滑一遍

卷积的核心是一个很小的权重方块,叫卷积核 / 滤波器(kernel),比如 3×3。 它不看全图,只盖住图上的一小块(局部感受野),把这一小块和核做点积(第 1 章), 得到一个数;然后滑到下一个位置再算一个数……滑遍全图,就得到一张新的图,叫特征图(feature map)。

for (r : 输出的每一行)
  for (c : 输出的每一列) {
    sum = 0;
    for (i : 0..K) for (j : 0..K)                 // 核的每个位置  1
      sum += image[r+i][c+j] * kernel[i][j];      // 小块 · 核 (点积)
    feature_map[r][c] = activate(sum + bias);      // 一个输出像素   2
  }

① 用一条公式把“滑动点积”钉死

上面的伪代码写成一条公式,就是卷积层对每一个输出位置 (i, j) 做的事(先看单通道、先不加激活):

这条式子和配套代码里 conv2d.cpp 的三层内层循环逐字对应:对输入通道求和是通道循环、Σu / Σv 是核内那两层循环,i·S / j·S 就是代码里的 base_row / base_col。换句话说,卷积没有任何玄机——它就是“一个偏置 + 一堆乘加”,和第 2 章那个神经元的 Σw·x + b 是同一件事,只不过每次只吃局部那 K×K 个像素。

拿一个具体的 3×3 小块和 3×3 核,把这条式子从头算到尾(取 S=1、b=0):

Y = 1×1 + 2×0 + 3×1     (第一行: 小块 · 核, 逐元素相乘)
  + 0×0 + 1×1 + 2×0     (第二行)
  + 3×1 + 0×0 + 1×1     (第三行)
  + 0                    (偏置 b)
  = 1 + 3 + 1 + 3 + 1
  = 9                    ← 特征图上这一格的值

核每滑到一个新位置,就把上面这套“9 次乘、再全加起来”重做一遍,得到特征图上的下一格。整张特征图,就是同一个核(同一组 9 个权重)在图上滑一遍攒出来的——这也预告了下一节的权重共享。

② 一层卷积层,到底吃什么、吐什么?

真正的卷积层,输入和输出都不是“一串数”,而更像一摞图。 灰度图可以看成 1 个通道,彩图通常是 R/G/B 3 个通道。卷积层吃进去的是 [输入通道数, 高, 宽],吐出来的是 [输出通道数, 高, 宽]。所谓“输出通道数”,其实就是 你放了多少个卷积核——一个核产出一张特征图,多个核就产出多张特征图。

这也解释了一个容易忽略的点:如果输入是 RGB 三通道,那一个核不是 3×3,而是 3×3×3。 它要同时看红、绿、蓝三张图在同一位置的小块,再把它们合成一个输出值。也就是说,输出的“1 个通道” 往往是对所有输入通道共同加工的结果,不是只盯某个单独颜色通道。

③ stride 和 padding 在控制什么?

卷积核并不是只能“一格一格慢慢挪”。它每次往右/往下滑几格,由 stride(步幅) 决定; 边缘要不要先补一圈 0,由 padding(填充) 决定。它们直接决定输出特征图的大小:

3. 权重共享:参数暴减,还自带平移不变

这看似普通的“滑动”,一举解决了第 1 节的三个硬伤:

• 参数暴减:一个 3×3 的核只有 9 个权重,却要负责整张图。相比全连接动辄上亿,参数少了好几个数量级。
• 保留空间结构:核只看连在一起的一小块,天然尊重“相邻像素有关系”。
• 平移不变:同一个核扫全图,所以猫在哪个角落都能被同一个“猫特征核”检测到——不用各学一遍。

4. 池化:把特征图“缩一缩”

池化(pooling)是紧跟卷积的“下采样”:把特征图切成小块(如 2×2),每块只留一个代表值—— 最大池化取最大值,平均池化取平均。好处:

• 缩小尺寸、减少后续计算;
• 增强鲁棒性:物体轻微移动几个像素,最大值往往不变,识别更稳。

很多人第一次学 CNN 会把池化和卷积混在一起。其实它们分工完全不同: 卷积层负责“学花纹检测器”,有可训练权重;而池化层通常没有可训练参数,只是把已经提出来的特征图 缩一缩、留一个代表值。前者更像“发现有什么”,后者更像“把发现过的东西压缩保存”。

for (int out_row = 0; out_row < out_height; out_row++)
  for (int out_col = 0; out_col < out_width; out_col++) {
    best_value = -∞;                                      1
    for (int kh = 0; kh < kernel_height_; kh++)
      for (int kw = 0; kw < kernel_width_; kw++)
        best_value = max(best_value, input[channel][row][col]); 2
    output[channel][out_row][out_col] = best_value;      3
  }

5. 通道与堆叠:从边缘到物体

一个核只能检测一种花纹,所以每层会用很多个核,产出很多张特征图——这些就是 通道(channel)(彩图输入本身就有 R/G/B 三通道)。把“卷积 + 激活 + 池化”一层层堆起来, 就出现了神奇的层级特征:

这里再强调一次“通道”这个词,因为它在 CNN 里会出现两次、容易混: 输入通道说的是“进来有几张图一起看”(灰度 1 张、RGB 3 张); 输出通道说的是“这一层产出了几张特征图”,它等于卷积核的个数。 所以“通道变多”通常不是原图变彩了,而是模型在同一层里学会了更多种花纹检测器。

② 最后怎么从特征图变成“这是一只猫 / 这是数字 7”?

卷积、池化一路做下来,拿到的还是特征图,不是最终类别。真正把“看见了哪些边缘 / 部件”翻译成 “这张图属于哪一类”的,通常是最后那几层分类头:先把多通道特征图拉平(flatten), 再接一层或几层全连接,最后在类别数上输出 logits,过 softmax 得到概率。

pool_.Forward(relu_output, pooled_output);         1
flattened = FlattenTensor(pooled_output);          2

for (int cls = 0; cls < class_num_; cls++) {
  logits[cls] = fc_bias_[cls];
  for (int dim = 0; dim < flattened_dim_; dim++)
    logits[cls] += fc_weight_[cls][dim] * flattened[dim]; 3
}

③ 这个最小 CNN 分类网络长什么样?

到这里,卷积、池化、分类头这些零件都认识了。把它们按顺序拼起来,一个最小 CNN 分类器其实非常朴素: 图片进来 → 卷积提局部特征 → ReLU 加非线性 → 池化缩图 → Flatten 拉平 → 线性层输出类别分数。 下面拿本仓库的 MNIST 小 CNN 举一个具体尺寸的例子(1 通道 28×28 输入,8 个 5×5 卷积核,padding=2,2×2 池化):

④ 数一数:这张网到底有多少个可训练参数?

“卷积省参数”不能只当口号,得能数出来。参数只藏在两个地方:卷积核 + 卷积偏置,以及分类头的全连接权重 + 偏置(ReLU、池化、Flatten 都没有可训练参数)。两条计数公式如下:

代入本仓库最小 CNN 的默认配置(1×28×28 输入,8 个 5×5 核、padding=2 → 卷积输出 8×28×28,2×2 池化 → 8×14×14,Flatten = 8×14×14 = 1568,10 类):

⑤ 训练和推理各在做什么?

训练和推理用的是同一座 CNN,区别不在网络换了,而在于后面有没有标签、有无反向传播。 训练时,图片和正确类别一起喂进去,前向算出 10 类概率,再用交叉熵算损失,把误差一路反着传回去更新卷积层和分类头; 推理时则只有图片,做完前向后直接挑概率最高的那一类即可。

ForwardFeature(image, conv_output, relu_output,
               pooled_output, flattened);                 1
logits = fc(flattened);
probs = Softmax(logits);                                 2
loss += -log(max(probs[label], 1e-12));                 3

grad_logits = probs;
grad_logits[label] -= 1.0;                              4
pool_.Backward(grad_pooled, grad_relu);                 5
conv_.Backward(grad_conv, grad_input, learning_rate);   6
fc_weight_[cls][dim] -= learning_rate * grad_fc_weight[cls][dim]; 7

推理时就简单得多:只做前向,拿到 10 类概率后取最大值。你可以把它理解成“训练 = 前向 + 反向 + 更新”, “推理 = 只有前向 + 选最大”。这和前面学过的 MLP 没有本质区别,区别只是前半段从“全连接提特征”换成了“卷积提特征”。

6. 一眼看过经典结构

套路都是“卷积/池化叠很多层做特征,最后接几层全连接做分类”,只是越做越深、越做越巧:

• LeNet(1998):CNN 的鼻祖,就是用来识别手写数字(和本书的 MNIST 同一个任务)。
• AlexNet(2012):在 ImageNet 大赛上一鸣惊人,点燃了这一轮深度学习浪潮。
• ResNet(2015):靠残差连接(还记得吗?第 18 章 Transformer 也用它)把网络堆到上百层还训得动。

7. 对照真实代码:最小 CNN 怎么拼起来

上面讲的“卷积 → 激活 → 池化 → 分类头”,在配套项目里就被写成了一个非常小的分类器。 你可以把它理解成:前半段负责在图上找特征,最后一层负责拿这些特征做分类。

output = MakeTensor3D(output_channels_, out_height, out_width);
for (int oc = 0; oc < output_channels_; oc++)
  for (int out_row = 0; out_row < out_height; out_row++)
    for (int out_col = 0; out_col < out_width; out_col++) {
      double sum = bias_[oc];                                  1
      int base_row = out_row * stride_, base_col = out_col * stride_;
      for (int ic = 0; ic < input_channels_; ic++)
        for (int kh = 0; kh < kernel_height_; kh++)
          for (int kw = 0; kw < kernel_width_; kw++)
            sum += weight_[oc][ic][kh][kw] *                  2
                   last_input_padded_[ic][base_row + kh][base_col + kw];
      output[oc][out_row][out_col] = sum;                     3
    }

conv_.Forward(input, conv_output);                 1
relu_output = conv_output;
ApplyRelu(relu_output);                           2
pool_.Forward(relu_output, pooled_output);       3
flattened = FlattenTensor(pooled_output);        4

for (int cls = 0; cls < class_num_; cls++) {
  logits[cls] = fc_bias_[cls];
  for (int dim = 0; dim < flattened_dim_; dim++)
    logits[cls] += fc_weight_[cls][dim] * flattened[dim];
}                                                 5

8. 亲手跑一遍:同一批数字,MLP 和 CNN 各认出多少?

上一节的“自己跑一个”给了命令,这一节把结果摆上桌。三场小实验,规则只有一条:两边吃完全相同的训练图,谁也不多占。 口径先交代清楚——MLP 用第 23 章实战的原配方(784→128→64→10,Adam + 热身余弦学习率); CNN 用本章 demo 的默认(8 个 5×5 核,单样本 SGD,lr=0.01)。两者的训练器并不相同,所以请把它读作 “两座各自最顺手的积木对打”,而不是“优化器大赛”。下面每条数字,都可以用同一条命令亲手复现:

cd src/
# CNN 一方(参数即默认值,显式写出来方便对照)
./bin/cnn_mnist --epochs 3 \
  --train-limit 2000 --test-limit 10000 \
  --conv-channels 8 --kernel-size 5
# MLP 一方(第 23 章 demo,相同的数据预算)
./bin/mnist --train-limit 2000 --epochs 3

⑥ 第一局:同样 2000 张,谁学得好?

训练集只取前 2000 张、只训 3 轮,再用完整的 10000 张测试图打分:

⑦ 第二局:把数字挪个位置,差距拉开

第 3 节说权重共享“自带平移不变”,是骡子是马现在就遛:训练图原样不动,测试时把每张图整体挪 2~3 像素(空出的边缘补黑), 再让两个模型各认一遍。仍然各训 2000 张 / 3 轮,前 1000 张测试图逐张配对打分:

⑧ 第三局:换配置、加数据,两点收尾

最后两张小表,回答“那还能怎么调”(同一个 demo,一次只动一个开关):

一句话收掉这三局:MLP 是题海选手,CNN 是押中了题的专才。专才的偏置押对了(图像题),就是小数据更快、大数据更省参数; 偏置押错了题,就换另一种积木——序列题的偏置长什么样,正是后面 RNN 与注意力要回答的。

9. 大模型时代,CNN 还剩哪些地盘?

AlexNet 在 2012 年点燃这轮浪潮之后,C 位也换过:2020 年起,注意力和 Transformer 跨进视觉,ViT 一脉拿走了大规模图像榜单; 今天的多模态大模型,“眼睛”也大多长着 ViT 的样子。但“被抢走头条”不等于“被抢走饭碗”——把战场拆开看,结论很清楚:

已经让位的:

• 大规模图像分类 / 检测的前沿榜单:ViT、Swin、DINOv 一脉轮流坐庄——它们吃得起海量数据,正好养活注意力“什么偏置都不带”的大胃口;
• 多模态大模型的视觉编码器:CLIP-ViT 一支几乎成了默认的“眼睛”;
• 图像生成的新主干:DiT 把扩散模型从 U-Net 往 Transformer 搬——不过留意,U-Net 里至今也杵着大量卷积。

还得是 CNN 的:

动手与思考

CNN 专治图像。可另一类数据——一句话、一段时间序列——需要“记住前文”。 下一章认识第二位专才:RNN 与 LSTM,顺便看清它有哪些先天短板,为第四部分的注意力埋下伏笔。