第一次照着教程手写边缘检测,输入是 5×5 灰度图,核是 3×3,输出只有 3×3。同事第一反应是程序把边框裁了,让你改回去。加上 padding,输出回到 5×5,但最外一圈明显偏暗,像加了个黑框。再往后接两个分支做拼接,一边 padding 0、一边 1,尺寸对不上,直接报错。

这三个现象都来自同一件事:卷积有严格的尺寸账本。窗口能放在哪些位置、越界时怎么补、每一步迈多远,决定了输出多大、边界值可不可信、多个分支能不能拼在一起。这篇就用一张能跑的小矩阵,把这本账从头算一遍。

输出为什么少了两圈

先把「卷积」这个词放下,看一个更朴素的动作。拿一个固定大小的小窗口,比如 3×3,盖在图上某个位置;窗口里的 9 个数和窗口下面盖住的 9 个数一一对应,相乘,再全部加起来,得到一个数。把这个数写到输出图对应的位置。然后窗口向右挪一格,重复;挪到行尾,回到下一行的开头;直到整个图扫完。

窗口不能悬空,必须完整盖在图里。5×5 的图,窗口左上角能放的列只有 0、1、2,再往右就有一列越界;行同理。所以输出是 3×3,四周各少一圈。这不是程序丢数据,而是「只在完全落在图内的位置计算」这条规则的结果,叫 valid 卷积。

这也解释了深网络里特征图为什么越来越小。每过一层 3×3 valid 卷积,宽高各减 2。十层下来,224×224 只剩 204×204;一直不减,几十层后连一个窗口都放不下。所以现代网络要么补边,要么接受缩小,要么用步长控制尺寸。

一个窗口在算什么

窗口里的 9 个数叫卷积核,也叫滤波器,是训练出来的参数。作用是把窗口覆盖的局部压成一个数,表示这里有没有某种模式。数值决定它在找什么:一边正一边负,通常在找亮度突变,也就是边缘;中间正四周负,在找小块亮点;全正且和等于 1,相当于局部平均。

「卷积」在深度学习里其实是互相关:核不翻转,直接和窗口逐元素相乘再求和。数学教材里的卷积会把核翻转 180 度,但框架实现和训练都不翻转,因为核是学出来的,翻不翻转只是参数顺序不同。理解这一点能避免一个常见的困惑:为什么手动推导和框架输出对不上,往往就是翻没翻核的差异。

这个动作有两个重要性质。第一是局部性:每个输出只看窗口内的一小块输入。第二是参数共享:同一个核在整张图上滑动,所有位置共用这 9 个参数。两者合起来,让卷积的参数量远小于全连接,也天然适合找「出现在哪里都一样的模式」。

一次卷积的三步
在输入上取一个与核同尺寸的窗口
窗口与核逐元素相乘,再把结果相加
把和写到输出图对应的一个位置

手算一次 5×5 加 3×3

下面用一张 5×5 的灰度矩阵和一个 3×3 的垂直边缘核做一次完整卷积。矩阵中间有一条竖着的亮线,值比背景高很多;核的第一列是负一、中间列是零、第三列是一。只用标准库,代码可以直接跑:

I = [
    [10, 10, 10, 10, 10],
    [10, 10, 90, 10, 10],
    [10, 10, 90, 10, 10],
    [10, 10, 90, 10, 10],
    [10, 10, 10, 10, 10],
]
K = [
    [-1, 0, 1],
    [-1, 0, 1],
    [-1, 0, 1],
]

def conv2d_valid(img, kernel):
    kh, kw = len(kernel), len(kernel[0])
    out = []
    for r in range(len(img) - kh + 1):
        line = []
        for c in range(len(img[0]) - kw + 1):
            s = 0
            for i in range(kh):
                for j in range(kw):
                    s += kernel[i][j] * img[r + i][c + j]
            line.append(s)
        out.append(line)
    return out

O = conv2d_valid(I, K)
print("conv output size:", len(O), len(O[0]))
for row in O:
    print(row)

for k, p, s in [(3, 0, 1), (3, 1, 1), (3, 0, 2)]:
    print("k=%d p=%d s=%d" % (k, p, s),
          "out", (5 - k + 2 * p) // s + 1)

本机实际输出:

conv output size: 3 3
[160, 0, -160]
[240, 0, -240]
[160, 0, -160]
k=3 p=0 s=1 out 3
k=3 p=1 s=1 out 5
k=3 p=0 s=2 out 2

左上角那个 160 怎么来的?窗口盖住第 0 到 2 行、第 0 到 2 列。第一行全是 10,乘加是负 10 加 0 加 10,等于 0;第二行是 10、10、90,得 80;第三行也是 80。三个 80 相加得 160。这个位置跨在亮线左边界上,所以有响应。

中间那个 0 呢?它对应第 1 到 3 行、第 1 到 3 列。每行都是 10、90、10。核中间列系数是 0,90 不参与计算;左边 10 乘负一,右边 10 乘正一,正好抵消。三行都是 0,总和还是 0。

这个 0 很值得琢磨。窗口明明盖住了一条亮线,却是零响应。原因不是核失效了,而是这个核只看「左右两边是否不同」:在亮线正中间,左右都是背景,亮度相同,所以没有边缘。真正有响应的是亮线的两侧,左边正、右边负,符号相反。这解释了一个常见现象:用一阶边缘核检测一条细线,会得到两条响应,而不是一条粗线。想要线本身有响应,得换二阶核,或者把两个方向的响应组合起来。

输出里的正负号也有意义。正负只代表亮暗过渡的方向,不代表「更像边缘」。取绝对值、平方或者后续层的组合,才把方向信息变成某种统一强度。训练时这些符号会被后面的层利用:一边正一边负,正好能区分「从暗到亮」和「从亮到暗」。

尺寸公式与 padding、stride 的代价

把上面的位置数法写成公式:输出边长等于 (H − K + 2P) / S + 1。H 是输入边长,K 是核边长,P 是四周各补几圈,S 是窗口每次挪几格。除不尽时向下取整,意思是最后那段不够一个完整窗口的位置直接不要。

用这个公式对一遍。5×5、3×3、不补边、步长 1:(5 − 3 + 0) / 1 + 1 = 3。补一圈:(5 − 3 + 2) / 1 + 1 = 5,输出和输入一样大。步长改成 2:(5 − 3 + 0) / 2 + 1 = 2,窗口只落在 0 和 2 两个位置,中间那些位置被跳过。这三个结果和程序输出完全一致。

padding 的代价是引入「不存在的像素」。补零最常见,但零不是中性值:整体偏亮的图,边缘突然出现一圈零,卷积会把它当成强烈突变,输出在边界异常大或异常小。这就是边缘发黑或发亮的来源,不是模型学错了,而是边界喂进去的值本来就不真实。

stride 的代价是信息被跳过。步长为 2,输出边长约减半,计算和内存都降下来,但被跳过的位置不参与这一层。目标很小又正好落在跳过的列上,这一层就看不到它。后面的层感受野更大,也许能从邻域推断,但信息已经打折。步长越大,漏检风险越高。

两者还影响多分支结构。一个分支 padding 1、步长 1,另一个 padding 0、步长 1,同样输入,输出差两圈,拼不到一起。残差连接要求两条路径形状一致,差一个像素都得补边或裁剪。报错通常很直白,定位时把每个分支的尺寸账单独算一遍。

多通道:核其实不是二维的

前面用的都是单通道灰度图。真实输入通常是三个通道,中间层的特征图可能有几十上百个通道。这时卷积核不再是一个二维矩阵,而是一个三维小块:宽、高、输入通道数。计算时,核在每个输入通道上各有一组权重,分别和对应通道的窗口相乘,最后把所有通道的结果加成一个数。

换句话说,一个 3×3 核作用在 3 通道输入上实际有 27 个权重;作用在 64 通道上有 576 个。它输出仍是一个通道。想要 32 通道输出,就需要 32 个这样的三维核,各自扫一遍输入,得到 32 张特征图叠起来。

参数量可以这样算:输出通道数 × 输入通道数 × 核宽 × 核高,再加上每个输出通道一个偏置。比如 3 通道输入、32 通道输出、3×3 核,是 32 × 3 × 3 × 3 = 864 个权重加 32 个偏置。这个量级很小,因为权重在空间上共享:不管图多大,都是这 864 个参数在滑动。

通道之间的混合也发生在这里。每个输出通道都看了所有输入通道,能按自己的权重把「红色边缘」「绿色纹理」「蓝色亮度」组合起来。层数堆下去,通道数越来越多,每个通道代表的组合也越来越抽象。这就是后面讲层级特征的基础。

1×1、depthwise 与分组卷积

1×1 卷积听起来奇怪:窗口只有一个像素,能看什么?它看的是通道。在这个位置上,把所有输入通道值加权求和,得到一个输出值。它不关心邻居,只做通道间的线性组合,作用是把通道数降下来或升上去,几乎不增加空间计算量。很多网络用它做瓶颈,先压通道再算 3×3,算完再升回去。

depthwise 卷积是另一种省法:每个输入通道单独用一个核,通道之间不混合。3 通道就用 3 个 3×3 核,各自卷各自的通道,输出还是 3 通道。参数量是 通道数 × 核宽 × 核高,比普通卷积少一个因子。代价是不能组合通道,所以后面通常接一个 1×1 卷积,这个组合叫深度可分离卷积。

普通卷积

每个输出通道看全部输入通道,表达能力强,参数量和计算量也最大。适合通道不多、需要充分混合信息的层,或精度优先、算力充足的场景。

深度可分离卷积

先按通道各自卷积,再用 1×1 混合通道,参数量和计算量都大幅下降。移动端和实时模型常用,但同样层数下表达弱一些,需要靠宽度或结构补回来。

分组卷积介于两者之间:把输入通道分组,每组只和自己组内通道卷积,最后拼起来。组数等于通道数就是 depthwise,组数等于 1 就是普通卷积。它用一组超参数连续控制「通道混合程度」和计算量。组数越多越省,但组间信息完全不流通,表达受限。

几种结构的取舍,最后都落在同一个问题:愿意用多少参数和计算,换多少通道混合能力。没有哪种一定更好。小模型、低延迟倾向 depthwise 加 1×1;服务器追求精度,普通卷积仍常见。看到 groups、depthwise 这些字段,先算参数量,就知道它在省哪笔账。

边界效应:补零不是免费的

回到最开始的黑框。补零让输出尺寸保住了,但边界处的值不可信。原因有两层:零和真实内容差得远;边界像素被窗口覆盖的次数比内部少。内部像素被很多窗口覆盖,边界只被少数窗口覆盖,它对输出的影响天然更弱。越靠边,统计越不稳定。

常见的缓解办法有几种。补零最简单,也是框架默认。复制边界值让边缘延续出去,不制造突变,但会拉出一条平坦带。镜像把边界内的像素翻折出去,过渡更自然,计算也稍贵。还有一种是干脆不补,接受输出缩小,让后续层只处理可靠的中心区域。

另一种思路是在网络设计上避开边界。主干用 same padding 保持尺寸,最后做全局池化,把空间压成一个向量,边界几个位置的影响被平均掉。或者用重叠滑窗推理,把边界区域交给相邻窗口补全。没有一种办法能完全消除边界效应,能做的是知道它存在,并在评估时把边缘和中心分开看。

还有个细节:padding 的值不一定非得是零。对归一化后的输入,零代表均值,补零相当于补一块平均亮度,比补纯黑中性。对没归一化的 0–255 输入,补零就是补黑,边界效应更强。这就是为什么预处理和网络结构要一起看,不能各调各的。

出了问题先查哪里

现象真实原因第一步查什么
输出比输入小了一圈用了 valid 卷积,没有补边按公式算一遍,确认 padding 是否为 0
补边后最外圈发黑或发亮补的零与真实内容差异过大,边界被当成突变打印边界输入值和输出值,比较内部同位置
两个分支拼接时报尺寸不符两边的 padding 或 stride 不一致分别打印两个分支的输出形状
输出尺寸比公式算的小一除不尽时被向下取整,末尾窗口被丢弃用整数除法手算,确认余数去了哪里
小目标在深层消失stride 跳过了目标所在位置,或多次缩小后信息丢失记录每层尺寸和目标的最小像素数
参数量比预期大很多把多通道核当成了单个二维核按「出通道 × 入通道 × 核宽 × 核高」重算
手动推导和框架输出对不上框架做的是互相关,没有翻转核核对是否翻转,再逐元素重算一个位置
边缘检测得到两条线而不是一条一阶边缘核在亮线两侧各响应一次检查核的正负分布和窗口覆盖的位置

表里最该先做的是第二行和第三行。边界和多分支尺寸问题不会训练出「稍微差一点」的结果,要么指标明显下降,要么直接报错。先打印形状和边界值,比换模型、调学习率快得多。

边界与代价

卷积不是万能的。它的核心假设是「同一个模式在图像的任何位置都该用同样的方式检测」,这叫平移等变性。物体换了个位置,响应也跟着换位置,这是好事;但物体旋转、缩放、遮挡之后,同一个核未必还能匹配。卷积本身不解决这些问题,要靠数据增强、多尺度结构或者别的机制。

参数共享省了参数,也限制了表达。一个核只能表达一种局部模式,覆盖多种就得多加通道,计算量跟着上来。深层网络的计算主要花在卷积上,特征图越大、通道越多,乘加次数成倍增长。depthwise 和分组卷积本质上都是在这笔账上做减法。

padding 和 stride 也一样,在「保尺寸」「省计算」「保信息」之间取舍。补边保尺寸,引入虚假边界;跳步省计算,丢信息;保信息就得高分辨率,计算和内存都上去。没有配置能同时拿满三样,只能按任务让步。检测小目标时分辨率和 stride 优先,实时分类时计算量先让步。

最后,卷积输出可计算,但不可直接解释。画出一个核看到边缘检测器,不能断言「这一层就在找边缘」。核和通道会组合,后面的层会重新加权,单个核的图案只是它在某个输入上的响应,不是所有输入上的含义。这一点下一篇还会展开。

当天能自验的五个练习

这五个练习都只用标准库,一张纸一支笔也能配合着做。每个都能在半小时内看到结果。

  1. 把上面的 5×5 输入和 3×3 核抄下来,手算输出左上角、中心、右下角三个值,再和程序输出对照。中心那个 0 要能用自己的话解释清楚。
  2. 把核换成 [[-1,-1,-1],[0,0,0],[1,1,1]],重新跑一遍,观察输出从检测竖边变成检测横边,记录哪些位置的值变了。
  3. 给输入四周补一圈零,用同一个核再跑,打印 5×5 的输出,找出最外圈和内部同位置值的差异,解释黑框从哪来。
  4. 把步长改成 2,手算输出尺寸并和程序结果对照,列出被跳过的窗口位置,说明哪些像素完全没有参与这一层。
  5. 把输入改成 3 通道,核改成 3×3×3,手算一个输出位置的乘加次数和参数量,再和单通道版本对比。

从一张特征图到一层层特征

卷积做的是一件很局部的事:用一个小窗口,把邻域里的像素压成一个数,表示这里有没有某种模式。核在整张图上共享,所以同一个模式出现在哪里都能被检测到;通道越多,能同时找的模式越多;层数越深,窗口能间接看到的范围越大。尺寸、补边、步长这些账,决定了信息在每一层怎么被保留或丢掉。

单个卷积层只能看到很小的邻域,但把它堆起来,后面的层就能看到前面层组合出来的更大结构。边缘怎么变成纹理,纹理怎么变成部件,部件怎么变成物体,这条层级是下一篇的主题。我们会用感受野的递推公式,算清楚一个深层神经元到底能「看到」原图多大的一块,也会讲清楚为什么深层特征并不等于人类命名的概念。