🏠 总目录📚 本教程 18 · 经典计算机视觉 ← →

从像素矩阵到边缘,手工视觉先算了什么?

读后可检查:沿平滑与边缘的手算例理解局部算子,再比较立体视觉和 CNN 的表示方式。

📑 本页目录(点开跳转)

18 · 经典计算机视觉

⏱ 36 分钟 | ⭐ 深度学习之前,机器「看见」靠一层层手写的小卷积核 —— 其中一半今天还在跑


🎯 一句话

经典视觉把「看」拆成两步:先用固定的小核把图洗成边缘和区域,再拿几何和已知的三维模型去解释这些边缘。 ⭐ CNN 没有推翻第一步,它只是把「核由人写死」换成了「核由数据学」; 第二步的几何则原封不动地长在今天的深度相机、相机标定和 SLAM 里。

这一章和下一章是全板块唯一被深度学习大面积取代的两块,所以写法不同: 当年怎么做 → 为什么输 → 哪些今天仍是对的选择,第三段才是你要带走的。


🖼 一、图像在机器眼里就是一个矩阵

一张灰度图可以写成像素矩阵,每格存一个灰度值。彩色图可以分别记录红、绿、蓝三个通道。光照可控时,工业检测可用固定阈值区分亮暗区域。

💀 所有视觉方法共同的原罪:透视投影是多对一的。 三维 → 二维不可逆,完全不同的场景能投出一模一样的图(远处的大楼 vs 贴在镜头前的小纸片)。 ⚠️ 这不是经典方法的缺陷 —— 神经网络也没解决它,只是用「大楼比纸片常见」的统计先验把歧义压住了。

因为不可逆,机器人视觉被拆成两个阶段:

阶段 干什么 输出
图像处理 滤波:降噪、突出边缘、找区域 还是一张图
场景分析 解释:这些线条是什么物体、什么姿态 符号描述

第二阶段的输出长这样:地上叠着三块积木,写成 ((C B A FLOOR))。 ⭐ 这已经不是图像了,是一句能拿去做逻辑推理的话。

阴影下,怎样保住暗笔画?

整张图用同一个门槛,叫全局阈值(global threshold)。假设只截取两段各三格的纸面灰度,中央都是暗笔画。灰度是像素的亮度数值,越大越亮。

灰度 0 100 200 亮底 0 1 暗底 0 1 从左向右的像素位置
比较同一灰度轴上的两个凹口。两边的笔画都比各自的背景暗,但暗底整段都低于固定阈值 100。依据:OpenCV 阈值定义。

按暗笔画规则「灰度严格小于 100 才记 1」,亮底得到 [0, 0, 0],漏掉 160;暗底得到 [1, 1, 1],两边灰度为 80 的背景也被圈了进去。

自适应阈值(adaptive threshold)根据当前位置和邻居的灰度,给每个位置单独算门槛。

  1. 判断中心的 160。 窗口是 [180, 160, 180]。三格相加后除以 3,得到 520 ÷ 3 = 173⅓,再减 10,门槛是 163⅓。160 低于门槛,记作笔画 1。
  2. 向右移一格,判断右端的 180。 160 变成左邻居,右边缺的一格用端点 180 补上,窗口是 [160, 180, 180]。三格之和仍是 520,除以 3 再减 10,门槛仍是 163⅓。这次 180 高于门槛,记作背景 0。

T(i) = [I(i−1) + I(i) + I(i+1)] ÷ 3 − C。这里 i 是像素位置,I 是灰度,T 是该位置的阈值,C = 10 是演示用的灰度偏移。窗口是一行三格,包含中心。窗口伸出行的两端时复制最近的端点。全程保留精确分数,I(i) < T(i) 时记笔画 1,其余记背景 0。相等归背景。

局部偏暗也可能来自纹理。若纸底的三格是 [180, 170, 200],中心门槛为 (180 + 170 + 200) ÷ 3 − 10 = 173⅓,170 < 173⅓,于是纯背景也被误判。再用 [180, 165, 180] 核对等号:中心门槛是 (180 + 165 + 180) ÷ 3 − 10 = 165,结果为背景。

这里先掌握怎样在每个位置用这个门槛做判断。后面的滑窗平滑会继续说明怎样用窗口均值生成一张新图。

工程上,OpenCV 的 ADAPTIVE_THRESH_MEAN_C 在单通道 8 位图上用二维方窗均值减 C,边界复制端点且将输入区域独立处理。本例的实数门槛保留分数。采用 OpenCV 的 THRESH_BINARY_INV 时,只有 I > T 的位置输出 0,相等时输出前景值。依据:OpenCV adaptiveThreshold。

用 Python 核对阈值和误检

local_threshold 通过夹住两侧索引实现端点复制,用 Fraction 保留分数。local_mask 把严格比较的真假转成 1 和 0。直接运行可核对两段笔画、边缘、等号和纹理。

from fractions import Fraction

def local_threshold(profile, i, offset=10):
    left = profile[max(0, i - 1)]
    right = profile[min(len(profile) - 1, i + 1)]
    return Fraction(left + profile[i] + right, 3) - offset

def local_mask(profile):
    return [int(value < local_threshold(profile, i))
            for i, value in enumerate(profile)]

bright = [180, 160, 180]
shadow = [80, 60, 80]
texture = [180, 170, 200]
assert local_threshold(bright, 1) == Fraction(490, 3)
assert local_threshold(shadow, 1) == Fraction(190, 3)
assert local_threshold(texture, 1) == Fraction(520, 3)
assert local_threshold(bright, 0) == Fraction(490, 3)
assert [local_mask(row) for row in [bright, shadow, texture]] == [[0, 1, 0]] * 3
assert [[int(value < 100) for value in row] for row in [bright, shadow]] == [
    [0, 0, 0], [1, 1, 1],
]
assert local_threshold([180, 165, 180], 1) == 165
assert local_mask([180, 165, 180]) == [0, 0, 0]
print("局部阈值核对通过")
试一试:偏移从 10 调到 15,亮底笔画还在吗?

亮底中心阈值变为 520 ÷ 3 − 15 = 158⅓。160 高于门槛,中心会被记成背景 0。

选读 · 让一张图的亮度分布靠近另一张图

同一批零件换一盏灯拍,整张图里的暗、中、亮像素所占比例可能变了。二值化只回答每个像素有没有超过某个阈值。如果希望保留多档亮度,并让整张图的亮度比例接近参考图,就要先知道每一档有几个像素,再决定怎样重分配这些灰度级。

灰度直方图(gray-level histogram)按亮度从低到高记下每一档的像素数。像素值为 1,就给第 1 档加一,和 NumPy 的按整数索引计数是同一个动作。直方图规定化(histogram specification,也叫 histogram matching)用给定的目标分布来决定灰度映射。直方图均衡化以均匀分布为目标。灰度只有有限档时,结果可能仍有高低不同的档。

要比较两张图,先问一个共同的问题:亮度不超过这一档的像素占多少? 把从最低档到当前档的计数加起来,再除以全图像素数,就得到这一档的经验累积分布函数(empirical cumulative distribution function,经验 CDF)。例如原图的三档是 0、1、2,计数为 [1, 7, 2],到 1 为止已经数了 1 + 7 = 8 个,所以比例为 8 ÷ 10 = 0.8。换一张图,即使像素总数不同,这个比例也在 0 到 1 之间,可以直接比较。

把这套算法写成公式:F(g) = [h(0) + ⋯ + h(g)] / N。这里 g 是从 0 到最高档的整数灰度,h(i) 是灰度 i 的像素数,括号内从灰度 0 加到 g(含 g),N 是整张非空图的像素总数。F(g) 是无单位的比例,随着 g 增大只会上升或持平,到最高档等于 1。

下面的演示把源图与目标都放在同一个灰度网格 0、1、2 上,各有 10 个像素。目标计数为 [1, 4, 5]。先只看前两行,从左向右读每条阶梯在三档处的高度。输出两行会在下面算出来。

同一灰度网格上的累计像素比例
分布灰度 0灰度 1灰度 2
源图0.10.81.0
目标0.10.51.0
SML0.10.11.0
GML0.10.81.0

两种映射往哪边找?

SML:从源灰度出发源 1 档,累计比例 0.8
找最近的目标累计值目标 2 档,累计比例 1.0
整档移动源 1 档的 7 个像素全移到目标 2 档
GML:从目标灰度出发目标 1 档,累计比例 0.5
找最近的源累计值源 1 档,累计比例 0.8
两道切点之间成一组前一切点已取走源 0 档,本组只取源 1 档

单映射规则(Single Mapping Law,SML)每次拿一个源灰度级,比较它的累计比例和所有目标累计比例的绝对差。源 0 档的 0.1 对上目标 0 档的 0.1。源 1 档的 0.8 对目标三档的差依次是 0.7、0.3、0.2,所以选目标 2 档。源 2 档的 1.0 对上目标 2 档的 1.0。结果目标 0 档收到 1 个,1 档收到 0 个,2 档收到 7 + 2 = 9 个,即 [1, 0, 9]。

组映射规则(Group Mapping Law,GML)按目标灰度从低到高给源灰度划组。每个目标累计值对应一个源切点,切点是这一组最后包含的源灰度。第一个目标累计值 0.1 正好选中源 0 档。第二个是 0.5,对源三档的差依次为 0.4、0.3、0.5,所以选源 1 档。最后的 1.0 选源 2 档。切点依次为 0、1、2,每次从上一个切点之后开始取,三组各含一档,输出 [1, 7, 2]。切点可以重复,此时对应组为空。

两个规则都按整档移动像素。源 1 档的 7 个像素同灰度,不能把其中 4 个单独留给目标 1 档,所以这个目标无法靠整档映射精确实现。两个规则都用绝对差找最近值。遇到并列,本例从低档开始扫描并取第一个。这是演示的确定性约定,论文公式给的是最小化条件。GML 的切点从左到右不回退,最后一个切点覆盖源的最后一档。

要量化结果,就在相同灰度网格上比较输出和目标的 CDF,逐档取绝对差,再取最大的一个。SML 的三个差为 |0.1 − 0.1|、|0.1 − 0.5|、|1.0 − 1.0|,最大是 0.4。GML 对应的三个差为 0、|0.8 − 0.5|、0,最大是 0.3。这是这个例子在该指标上的结果。直方图只记录数量,同样的直方图可以来自空间结构完全不同的图。

用 Python 复算这 10 个像素

下面是一段完整的标准库程序。输入是同一灰度网格上两张像素总数相等的非空计数表,演示限制源表各档都有像素。accumulate 生成累计计数。两张表除以同一个正数 N 才得到 CDF,所以查找最近值时可先用整数,避免小数舍入影响并列判断。

from itertools import accumulate


def nearest(cumulative_counts, value):
    # 下标由低到高,距离相等时 min 保留先遇到的下标。
    return min(
        range(len(cumulative_counts)),
        key=lambda index: abs(cumulative_counts[index] - value),
    )


def match_histograms(source, target):
    source_cdf_counts = list(accumulate(source))
    target_cdf_counts = list(accumulate(target))

    single = [0] * len(target)
    for count, cutoff in zip(source, source_cdf_counts):
        target_bin = nearest(target_cdf_counts, cutoff)
        single[target_bin] += count

    grouped = []
    previous_cut = -1
    for cutoff in target_cdf_counts:
        cut = nearest(source_cdf_counts, cutoff)
        grouped.append(sum(source[previous_cut + 1:cut + 1]))
        previous_cut = cut
    return single, grouped


def max_cdf_gap(output, target):
    gaps = [
        abs(actual - desired)
        for actual, desired in zip(accumulate(output), accumulate(target))
    ]
    return max(gaps) / sum(target)


source = [1, 7, 2]
target = [1, 4, 5]
single, grouped = match_histograms(source, target)
assert sum(single) == sum(grouped) == sum(source)
print("SML", single, max_cdf_gap(single, target))
print("GML", grouped, max_cdf_gap(grouped, target))

equal_outputs = match_histograms(source, source)
print("同分布", [max_cdf_gap(hist, source) for hist in equal_outputs])
assert equal_outputs == (source, source)
assert nearest([1, 8, 10], 9) == 1

single 对每个源档执行一次加法。grouped 从上一个切点的下一档开始求和,切片的结束下标写成 cut + 1 才能包含当前切点。最后 max_cdf_gap 比较累计计数的最大差,再除以总数,得到比例差。

自己试一下:如果累计计数是 [1, 8, 10],要找最靠近 9 的一档,先算出两档的距离,再预测程序返回哪个下标。

查看核对过程

8 和 10 到 9 的距离都是 1。较低档的累计计数是 8,它的下标是 1,所以本程序返回 1。并列取值规则改变时,应重新核对映射和输出偏差。

这里用的是全图统计,同灰度的像素共享同一个输出。下一节的平滑会改用像素周围的小窗口,因此两个像素即使原灰度相同,也可能因邻居不同而得到不同结果。

映射规则来源:Y. J. Zhang,Improving the Accuracy of Direct Histogram Specification,Electronics Letters 28(3),213–214,1992,式 (3)–(4)。


🧹 二、平滑:一个能手算完的例子

真实图像永远带噪声。平滑=拿小窗口在图上滑,用窗口内所有值的平均替换中心值。 让窗口对准每个位置,按权重逐格乘加。均值核的权重前后对称,翻核求卷积与直接求相关结果相同。3×3 窗口在 4×4 上只有四个合法位置(中心必须落在内圈):

$$ I=\begin{bmatrix}9&9&9&3\\9&9&3&3\\9&3&3&3\\3&3&3&3\end{bmatrix} \quad\xrightarrow{\ \text{3×3 均值}\ }\quad \text{内圈四格变成}\ \begin{bmatrix}7&5\\5&4\end{bmatrix} $$

四个窗口的和是 63、45、45、33,除以 9 得 7 / 5 / 5 / 4(最后一个 3.67 四舍五入),外圈不动。

⭐ 原来 9 和 3 之间是一刀切的对角线,平滑后成了 9→7→5→4→3 的斜坡 —— 这就是平滑和边缘检测天然打架的证据:噪声被抹平,真边缘也被抹钝,细线被抹掉,粗线被加宽。


📐 三、边缘:本章的核心手算

顺着一行像素找亮度突变

从灰度图中抽出一行,按像素位置画出亮度,得到灰度剖面(intensity profile)。找边缘时,用上一节的小窗口看相邻格的变化。

灰度 0 3 阶跃 0 2 亮带 0 2 4 单亮点 0 2 4 从左向右的像素位置
沿同一尺度找突变。亮带有两侧边缘,单亮点在相邻两步内先升再降。依据:OpenCV 空间导数与相关。

先算相邻两格,再看差值怎么变

从左向右,右格减左格。阶跃 [0, 0, 3, 3] 逐对得到 [0−0, 3−0, 3−3] = [0, 3, 0]。这是前向差分(forward difference)。记 D(i) = I(i+1) − I(i),其中 I(i) 是位置 i 的灰度,D(i) 是从该格走向右邻的灰度变化。每步相隔一个像素。

想观察斜率在哪里改变,就把右侧那一步的差减去左侧那一步的差。这个以 i 为中心的中心二阶差分(centered second difference)是 D(i) − D(i−1) = I(i+1) − 2I(i) + I(i−1)。两个差都用到了中心,一个减中心,另一个加中心再整体被减,所以中心的系数是 −2。

亮带 [0, 0, 3, 3, 0, 0] 相邻相减得 [0, 3, 0, −3, 0]。再做 [3−0, 0−3, −3−0, 0−(−3)] = [3, −3, −3, 3],分别对应位置 1 至 4。每侧边缘的两边都有响应,符号反映相邻两步的差是变大还是变小。

这些差分只在窗口完整处计算:前向差分不算最后一格,中心二阶差分省略首尾。这里不填边。窗口从左至右直接乘权重,不翻核。这个约定叫相关(correlation),与 OpenCV filter2D 一致。把不对称核翻转再做卷积,会改变前向差分的方向约定。

二维拉普拉斯为什么会突出单亮点?

拉普拉斯(Laplacian)把多个方向上的二阶变化合在一起。下面选用带反号的八邻域离散核:中心 +8,周围八个位置都是 −1,相当于把「中心减邻点」对八个邻点加起来。八个邻点含上下左右及四个对角,权重不翻转,只在 3×3 窗口完整的位置计算。

如果这个亮点只是噪声,响应一样大。一维剖面 [0, 0, 3, 0, 0] 就有 [0, 3, −3, 0] 的一阶响应,再相减是 [3, −6, 3]。预平滑能降低这种孤立噪声的响应,也可能削弱窄亮带,窗口尺度要和希望保留的结构一起考虑。

同样在小窗口里求差,方向和阶数各有条件
算子看什么噪声与核的条件
Roberts 交叉算子在 2×2 窗口求两条对角线的一阶差窗内直接比较对角像素,孤立亮点也会响应
Sobel下图的两个 3×3 核分别估计横向、纵向一阶差用垂直于求差方向的加权合并缓和部分噪声,仍可能对噪声响应
Laplacian本例的 3×3 核用八邻域汇总二阶变化孤立纹理或噪声可能被放大。OpenCV Laplacian(ksize=1) 使用中心 −4、十字四邻 +1 的核,尺度和符号应按实际核解释

依据:OpenCV filter2D、Sobel 和 Laplacian 的窗口约定、scikit-image Roberts 双对角核。

用 Python 核对差分、亮点和常值区域

forward 让相邻像素两两成对。对它的输出再做一次差,得到 second。response 在二维图像内按核权重乘加。断言检查正负号、单亮点的中心及八邻点和常值区域。

def forward(profile):
    return [right - left for left, right in zip(profile, profile[1:])]

def second(profile):
    differences = forward(profile)
    return forward(differences)

kernel = ((-1, -1, -1), (-1, 8, -1), (-1, -1, -1))

def response(image, x, y):
    return sum(kernel[dy + 1][dx + 1] * image[y + dy][x + dx]
               for dy in (-1, 0, 1) for dx in (-1, 0, 1))

assert forward([0, 0, 3, 3]) == [0, 3, 0]
assert forward([0, 0, 3, 3, 0, 0]) == [0, 3, 0, -3, 0]
assert second([0, 0, 3, 3, 0, 0]) == [3, -3, -3, 3]
assert forward([0, 0, 3, 0, 0]) == [0, 3, -3, 0]
assert second([0, 0, 3, 0, 0]) == [3, -6, 3]
impulse = [[0] * 5 for _ in range(5)]
impulse[2][2] = 3
assert [[response(impulse, x, y) for x in range(1, 4)]
        for y in range(1, 4)] == [[-3, -3, -3], [-3, 24, -3], [-3, -3, -3]]
assert response([[3] * 3 for _ in range(3)], 1, 1) == 0
print("离散差分与二维核核对通过")
试一试:把阶跃顺序倒过来,前向差分怎么变?

[3, 3, 0, 0] 逐对得到 [3−3, 0−3, 0−0] = [0, −3, 0]。从左向右走,现在是从亮到暗。

从一行扩展到二维时,可以用一对核寻找横向和纵向的变化。下图把均值平滑和 Sobel 的两个方向核放在同一个窗口里对照。

同一套滑窗机制,换三个核就是三件事均值核(平滑)Sobel Gx(竖直边缘)Sobel Gy(水平边缘)1/91/91/91/91/91/91/91/91/9−10+1−20+2−10+1−1−2−1000+1+2+1滑窗、逐格相乘、求和 —— 三张图的机制完全一样⭐ 差别只在这九个数:经典 CV 由人写死,CNN 由数据学出来
要盯的不是核里的数字,是三张图的框架一模一样。经典视觉和 CNN 的分界线不在「用不用卷积」,而在这九个数从哪来。

拿刚才那个 4×4 的左上窗口手算:

$$ \begin{bmatrix}9&9&9\\9&9&3\\9&3&3\end{bmatrix} \Rightarrow G_x = (-9{+}9)+(-18{+}6)+(-9{+}3) = -18,\quad G_y = (-9{-}18{-}9)+(9{+}6{+}3) = -18 $$

边缘强度取 $|G_x|+|G_y| = 36$。四个位置全算完是 36 / 36 / 36 / 12,方向全是 −135°。

三个 36 沿对角排列,靠近 9 区和 3 区的分界;右下的 12 对应八格都是 3 的窗口。把 Sobel 的权重 2 换成 1 得到这里的 Prewitt 核,强度变为 24 / 24 / 24 / 12,前三格仍比最后一格强。两个结果的相对尺度随窗口内容改变。

复现只要四行(纯标准库,本机跑过):

def conv(img, k):                                 # 3×3 卷积
    return [[sum(img[y+dy][x+dx] * k[dy+1][dx+1]  # ⭐ 核与窗口逐格相乘再求和
                 for dy in (-1,0,1) for dx in (-1,0,1))
             for x in range(1, len(img[0])-1)] for y in range(1, len(img)-1)]

I  = [[9,9,9,3], [9,9,3,3], [9,3,3,3], [3,3,3,3]]
gx = conv(I, [[-1,0,1], [-2,0,2], [-1,0,1]])
gy = conv(I, [[-1,-2,-1], [0,0,0], [1,2,1]])
print([[abs(a)+abs(b) for a,b in zip(p,q)] for p,q in zip(gx,gy)])   # [[36, 36], [36, 12]]

找区域是边缘的反面:盯内部基本不变的一块,判据是强度差不超过阈值 $\varepsilon$。经典做法叫分裂-合并 —— 不同质就切成四块(四叉树),递归到不用再切,再把相邻同质块合回来。⭐ 没有参数要训,$\varepsilon$ 是你自己定的数。


🔍 四、场景分析:从线条到「这是个什么」

图像处理输出的还是图,场景分析要把它变成描述。因为场景到图像是多对一, 这一步必须往里加信息:相机在哪、光源在哪、可能有哪些物体。

对直棱物体拿直线段拟合边缘,对曲面物体拟合圆锥曲线,然后解释每条线代表什么。 在「只有平面、任一点最多三个面相交」的三面体世界里,答案只有三种标注: → 遮挡、+ 凸边(blade)、− 凹边(fold)。线条汇合处的结点按形状分 V、W、Y、T 四类, 而经典的 Huffman–Clowes 标注表算出来:208 种组合里只有 18 种物理上可实现。

⭐ 于是「看懂一张线画」变成一个纯粹的约束满足问题:给每条线选标注,使两端结点都落在合法表里。 这里没有一个数是从数据里学的,全是几何本身给的硬约束。

模型驱动视觉再进一步:工业场景里你事先就知道有什么 —— 传送带上来的就是那个零件,图纸你有。 那就拿几何模型去拟合:把立方体投影到图上,调尺寸位置朝向(欧拉角)直到和边缘图对上; 复杂形状用广义圆柱搭,每个 9 个参数。⚠️ 它做的不是识别,是配准 —— 只回答「已知是它,现在多大、在哪、朝哪」。这个分工今天几乎没变。


👁 五、立体视觉:两只眼睛才有深度

单图测距很难(例外:已知物体在地面上、又已知相机高度)。通用办法是两个镜头,间距 $b$ 叫基线。 同一个点在左右两幅图里位置不同,这个差叫视差 $d$。

双目几何:视差越大,说明离得越近P · 场景里的一个点深度 Z左像平面右像平面xLxR左相机右相机焦距 f基线 b视差 d = xL − xR ⟹ Z = f · b / d
整张图只有一个要点:视差 d 和深度 Z 成反比。近处的点在两幅图里差得远,远处的几乎重合 —— 立体视觉近处准、远处糊,这是几何决定的。

$$Z = \frac{f \cdot b}{d}$$

手算一组:$f = 800$ 像素、$b = 12\ \text{cm}$ 时,视差 40 → $Z = 2.4$ m,20 → 4.8 m,10 → 9.6 m,4 → 24 m。

⚠️ 视差从 10 掉到 4,深度就从 9.6 m 跳到 24 m。 误差按 $Z^2$ 放大 —— 匹配精度取 0.5 像素时, 2.4 m 处误差约 3 cm、24 m 处约 3 m。消费级深度相机量程只有几米,不是传感器不行,是 $Z^2$ 不讲道理。

还有个真难点叫对应问题:得先知道左图哪个像素和右图哪个像素是同一个点, 而无纹理的白墙上这件事无解(每个像素长得都一样)。 ⭐ 所以结构光相机要打散斑:它不是在测光,是在人为造纹理,好让对应问题有解。


🤝 六、和 CNN 的对照:本章最该记住的一条

经典边缘算子 CNN 第一层
运算 3×3 滑窗,逐格乘加 3×3 滑窗,逐格乘加
核里那九个数 人写死(Sobel / Prewitt) 反向传播学出来
核的数量 有几个用几个 几十上百个并行
后面接什么 人写的规则(拟合线段、结点标注) 同样的东西再来几十层

⭐ 关键事实:把训练好的 CNN 第一层卷积核画出来,它们和手工边缘算子长得惊人地像(各个朝向的明暗条纹)。 梯度下降自己重新发现了边缘检测。

⭐ CNN 不是推翻了经典视觉,是把「设计特征」换成了「学特征」。 卷积这个机制、局部感受野这个想法、层层抽象这个结构,全是经典视觉留下来的。 换掉的只有一件事:那九个数是谁定的。

那为什么一换就赢?赢在第一层之后。经典方法的第二第三层是人写的规则,而规则写到第三层就写不动了 —— 「猫」没有一条可以写下来的边缘组合规则。CNN 的第二第三层还是同一件事,有数据就能一直堆下去。

⚠️ 但学出来也有代价。1989 年的 ALVINN 用神经网络直接开车:输入 30×32 低分辨率图, 隐层只有 5 个 sigmoid 单元,输出 30 个单元投票定方向盘角度,训练数据是人类开车的 5 分钟录像:

💀 人类司机开得太好了。 训练数据里几乎没有「车已经偏出车道、需要打回来」的样本,走过一段长直路后网络就学成永远直行 —— 真偏了它不知道怎么救。⭐ 这是采样偏差最早的实例之一,而规则方法根本不会犯这个错: 「偏离中线就打方向」是一行规则,不需要在数据里出现过。


🧭 七、被取代了什么,还活着什么

诚实说:通用视觉上经典方法输了,而且输得彻底 —— 分类、检测、分割、姿态估计今天没有一个 SOTA 靠手写算子, 原因就是上一节那句:规则写不到第三层。 但「输了通用」不等于「没用了」——

还活着的部分 为什么没被换掉
边缘 / 角点检测 相机标定、图像拼接、SLAM 前端的第一步。⭐ 它要的是亚像素级可复算位置,不是语义
立体几何 深度相机、双目模组的基础就是 $Z = fb/d$。神经网络改的是对应问题,几何没得改
模型驱动配准 工业检测主力:图纸已有、光照可控、零训练数据,还能给出「差 0.2 mm」的可解释输出
二值化、连通域、形态学 产线上又快又稳;也常做神经模型的前后处理(去毛刺、补洞、合并碎片)

⭐ 判据一句话:要「这是什么」用学出来的,要「它在哪、差多少」用几何算出来的。 前者是语义问题,规则写不完;后者是测量问题,数据反而会引入不该有的偏差。

另有四种场景经典方法仍更合适:没有标注数据、必须解释每一步、 算力受限到跑不动网络、需要确定性保证(同输入同输出,且能证明误差上界)。


🔗 这一章连到哪里

去哪 为什么
ML基础 12 · CNN ⭐ 本章最该走的一条。那边的卷积、感受野、层层堆叠,机制和本章第三节一模一样,唯一改动是九个数从人写死变成学出来;带着这一章再读,「为什么是卷积不是全连接」会变得显然
数据这一关 15 · 采样偏差与幸存者偏差 ALVINN「司机开得太好所以学不会纠偏」是这个坑最早的实例,去看今天怎么系统性地防
19 · 经典 NLP 同一个故事的另一半:语言那边的手写规则也被接管了,也留下一批今天还在用的东西

✅ 检查点

  1. 为什么图像不能被直接反演成场景?这是经典方法特有的毛病吗?
  2. 那个 4×4 用 3×3 均值平滑,为什么只有四个位置?四个数是多少?暴露了平滑的什么代价?
  3. Sobel 的 $G_x$、$G_y$ 各找什么方向的边缘?左上窗口手算多少?四个位置的强度?换 Prewitt 呢?
  4. 三面体世界里线条只有哪三种标注?为什么说「解释一张线画」是个约束满足问题?
  5. 模型驱动视觉做的是识别还是配准?
  6. 立体视觉的深度公式?$f=800$、$b=12$ cm 时视差 10 和 4 各对应多远?为什么远处误差大得多?
  7. 对应问题是什么?结构光打散斑是在干什么?
  8. 经典边缘算子和 CNN 第一层,相同与不同各是什么?CNN 赢在哪一层?
  9. 举三类今天仍该用经典方法的场景,说出统一判据。
👀 答案
  1. 透视投影是多对一的变换:不同的三维场景能投出完全相同的图像(远处大楼 vs 镜头前小纸片)。⚠️ 不是经典方法特有的 —— 神经网络也没解决,只是用统计先验压住。
  2. 3×3 窗口中心必须落在内圈,4×4 的内圈只有 2×2 = 4 格。四窗和 63/45/45/33,除 9 得 7 / 5 / 5 / 4。代价:一刀切被抹成 9→7→5→4→3 的斜坡 —— 抹平噪声的同时也抹钝了真边缘。
  3. $G_x$ 找竖直边缘,$G_y$ 找水平边缘。左上窗口 $G_x = G_y = \mathbf{-18}$,强度 36,方向 −135°;四个位置 36 / 36 / 36 / 12。Prewitt 给 24 / 24 / 24 / 12 —— 同一个东西只差尺度。
  4. → 遮挡、+ 凸边、− 凹边。之所以是 CSP:每条线要选一个标注,而 V / W / Y / T 四类结点只允许极少数组合 —— 208 种组合中只有 18 种物理可实现。约束全来自几何,没有一个数是学的。
  5. 配准。它答不了「这是什么」,只答「已知是这个零件,现在多大、在哪、朝哪」—— 把已知模型(广义圆柱每个 9 参数)投影到图上调位姿,直到和边缘图对上。
  6. $Z = f\cdot b/d$。$d=10 \to \mathbf{9.6\ m}$,$d=4 \to \mathbf{24\ m}$。⚠️ 误差按 $Z^2$ 放大:0.5 像素精度下 2.4 m 处约 3 cm、24 m 处约 3 m。几何决定的,换算法没用。
  7. 判断左图哪个像素与右图哪个像素是同一场景点;⚠️ 白墙上无解。打散斑不是在测光,是人为造纹理。
  8. 相同:3×3 滑窗逐格乘加、局部感受野、层层抽象。不同:那九个数人写死还是学出来、核的数量、后面接人写的规则还是更多同样的层。CNN 赢在第二层往后:规则写到第三层就写不动了(「猫」没有可写下来的边缘组合规则)。
  9. 要「这是什么」用学出来的,要「它在哪、差多少」用几何算出来的。 三类任选:标定/拼接/SLAM 前端的边缘角点、工业模型配准(零数据、可解释到 0.2 mm)、二值化连通域的产线定位。另加无数据、要可解释、算力受限、要确定性保证。

本节回顾

⚡ 走神救援

先记住这几件事

下一节 👉 19-经典NLP.md

去那里的理由:视觉这边的结论是「手写的核输给了学出来的核」。语言那边有一套更精致的手写系统 —— 形式文法、句法分析树、指代消解规则,同样被接管了。但那一章有件本章没有的事: 有一块老技术不但没被取代,还在今天的 LLM 里换了个名字继续跑 —— 你每次让模型「只输出 JSON」,用的就是它。

打卡记录保存在你的浏览器里,首页能看到总进度