深度学习的数学原理（十一）—— CNN：二维卷积的数学本质与图像特征提取

在前文的内容中，我们从一元线性回归的梯度下降原理出发，逐步推导了多元线性回归的矩阵表达与优化逻辑，拆解了反向传播的链式求导核心，解决了梯度消失/爆炸的激活函数优化问题，也讲解了从SGD到Adam的优化器演进思路，还通过正则化从数学层面解决了模型过拟合的核心困境，最终让多层感知机（MLP）实现了从线性拟合到非线性特征学习的跨越，也明确了反向传播+损失函数引导权重差异化更新，形成特征分工的底层规律。

但MLP在处理图像这类网格状空间数据时，暴露了天然的设计缺陷：全连接层的权重与输入像素一一对应，参数数量随输入维度呈指数级增长，极易引发过拟合；同时全连接层完全忽略了图像的空间局部相关性 （如相邻像素大概率属于同一特征、目标边缘由连续像素构成）与平移不变性（目标在图像中位置发生平移，其核心特征本质不变），让特征学习效率极低，无法适配计算机视觉的核心需求。

卷积神经网络（CNN）正是为解决这两大问题而生，它通过局部连接、参数共享、池化操作 三大核心设计，既大幅减少了模型的参数数量，又完美契合图像的空间特征属性，成为计算机视觉任务的基础模型。从本篇开始，我们将分三篇内容系统讲解CNN的数学原理与工程实现，严格遵循专栏数学推导→代码验证→可视化分析的核心逻辑，沿用统一的符号体系与实现风格，形成完整的知识闭环：

一、CNN的核心前置知识回顾

CNN的本质并非颠覆MLP的学习逻辑，而是在特征提取阶段 针对图像数据做了数学与工程上的优化，其核心仍遵循前向传播计算特征+反向传播更新参数的基本框架。因此本篇及后续内容会直接复用专栏前文的核心知识点，仅做关键回顾，无需重新推导：

反向传播的链式求导 ：从损失函数出发，逐层回传梯度并计算每个参数的偏导数，是CNN卷积核、池化层梯度推导的核心基础（深度学习的数学原理（三））；
非线性激活函数 ：ReLU仍是CNN的主流激活函数，通过单侧抑制解决梯度消失问题，让网络具备非线性特征学习能力（深度学习的数学原理（五））；
优化器与正则化 ：Adam优化器用于CNN的参数更新，Dropout、L2正则化用于缓解CNN的过拟合，其核心逻辑与MLP完全一致（深度学习的数学原理（七））；
权重的差异化分工 ：卷积核的权重会在反向传播+损失函数的引导下，自发学习不同的图像特征（如边缘、纹理、轮廓），与MLP神经元的权重分工逻辑高度契合（深度学习的数学原理（九））。

核心结论 ：CNN是MLP针对图像空间数据的特化优化版本，其所有参数更新、损失优化的逻辑均与MLP一脉相承，仅在特征提取的层结构设计上做了针对性改进。

二、二维离散卷积的数学定义

提到卷积，很多人会先联想到信号处理中的连续卷积，但CNN中使用的二维离散卷积 是其简化与适配版本（实际工程中为互相关操作，后续会明确区分），其数学本质是用一个固定大小的卷积核（滤波器），在二维输入数据上做滑动窗口的加权求和，实现局部特征的提取。

我们先从纯数学角度给出二维离散卷积的严格定义，再结合图像数据做通俗化解释，最后说明CNN工程实现与纯数学卷积的细微差异。

2.1 纯数学：二维离散卷积的严格定义

设二维输入矩阵为 X ∈ R H × W X \in \mathbb{R}^{H \times W} X∈RH×W（其中 H H H为高度， W W W为宽度，对应图像的高和宽），二维卷积核为 K ∈ R k h × k w K \in \mathbb{R}^{k_h \times k_w} K∈Rkh×kw（其中 k h k_h kh为卷积核高度， k w k_w kw为卷积核宽度，工程中通常取奇数，如3×3、5×5，便于确定卷积中心），则 X X X与 K K K的二维离散卷积 结果为矩阵 Y ∈ R H ′ × W ′ Y \in \mathbb{R}^{H' \times W'} Y∈RH′×W′，其中输出矩阵的每个元素 Y ( i , j ) Y(i,j) Y(i,j)的计算公式为：
Y ( i , j ) = ∑ m = 0 k h − 1 ∑ n = 0 k w − 1 X ( i + m , j + n ) ⋅ K ( k h − 1 − m , k w − 1 − n ) + b Y(i,j) = \sum_{m=0}^{k_h-1} \sum_{n=0}^{k_w-1} X(i+m, j+n) \cdot K(k_h-1-m, k_w-1-n) + b Y(i,j)=m=0∑kh−1n=0∑kw−1X(i+m,j+n)⋅K(kh−1−m,kw−1−n)+b

公式中各符号含义说明：

b b b为卷积层的偏置项，与MLP中的偏置作用完全一致，用于调整特征的基线值，解决特征分布偏移问题；
i ∈ [ 0 , H ′ − 1 ] i \in [0, H'-1] i∈[0,H′−1]， j ∈ [ 0 , W ′ − 1 ] j \in [0, W'-1] j∈[0,W′−1]，为输出矩阵的像素索引， H ′ H' H′、 W ′ W' W′为输出矩阵的高和宽，由输入尺寸、卷积核尺寸、步长、填充共同决定；
K ( k h − 1 − m , k w − 1 − n ) K(k_h-1-m, k_w-1-n) K(kh−1−m,kw−1−n)为卷积核的翻转操作：将卷积核先沿水平方向翻转，再沿垂直方向翻转（或先垂直后水平，结果一致），这是纯数学卷积的核心特征。

2.2 工程适配：CNN中的二维卷积（实际为互相关操作）

在图像特征提取任务中，卷积核的翻转操作 对特征提取的本质无任何影响，仅会改变卷积核的权重顺序，而工程实现中为了简化计算、提升效率，CNN框架（PyTorch、TensorFlow）均将卷积操作简化为互相关操作 ------直接去掉翻转步骤，这也是我们实际使用CNN时的真实卷积逻辑，其简化后的计算公式为：
Y ( i , j ) = ∑ m = 0 k h − 1 ∑ n = 0 k w − 1 X ( i + m , j + n ) ⋅ K ( m , n ) + b Y(i,j) = \sum_{m=0}^{k_h-1} \sum_{n=0}^{k_w-1} X(i+m, j+n) \cdot K(m, n) + b Y(i,j)=m=0∑kh−1n=0∑kw−1X(i+m,j+n)⋅K(m,n)+b

这一公式是CNN卷积层前向传播的核心数学表达式 ，后续的代码实现、梯度推导均基于此展开。为了便于理解，我们将其通俗化描述为：卷积核在输入图像上以固定步长滑动，每滑动到一个位置，就将卷积核的每个权重与对应位置的图像像素相乘，再将所有乘积求和，加上偏置后，得到输出矩阵对应位置的特征值。

2.3 卷积输出尺寸的数学计算

输出矩阵的尺寸 H ′ × W ′ H' \times W' H′×W′是CNN的基础知识点，由输入尺寸 H × W H \times W H×W、卷积核尺寸 k h × k w k_h \times k_w kh×kw、步长（Stride） s s s、填充（Padding） p p p四个参数共同决定，其中：

步长 s s s：卷积核在输入图像上滑动的步长，横向与纵向步长通常取相同值，记为 s s s；
填充 p p p：在输入图像的边缘填充0的层数，用于保持输入与输出的尺寸一致（如Same Padding），或减少边缘特征丢失（如Valid Padding，无填充）。

对应的尺寸计算公式为：
H ′ = ⌊ H + 2 p − k h s ⌋ + 1 H' = \left\lfloor \frac{H + 2p - k_h}{s} \right\rfloor + 1 H′=⌊sH+2p−kh⌋+1
W ′ = ⌊ W + 2 p − k w s ⌋ + 1 W' = \left\lfloor \frac{W + 2p - k_w}{s} \right\rfloor + 1 W′=⌊sW+2p−kw⌋+1

其中 ⌊ ⋅ ⌋ \lfloor \cdot \rfloor ⌊⋅⌋为向下取整操作，这一公式决定了卷积层的特征图尺寸变化，是构建CNN网络的基础，后续实现LeNet时会直接应用。

2.4 实际例子

为了让大家更直观地理解卷积输出尺寸计算与实际卷积操作的关联，我们结合工程中最常见的MNIST手写数字任务（28×28灰度图像），设计两组典型参数（无填充、有填充），完整展示"尺寸计算→卷积滑动→特征值计算"的全过程，与后续代码实现形成呼应。

先明确例子中用到的核心参数（贴合实际训练场景）：

输入图像 X X X：模拟MNIST局部图像，简化为 5 × 5 5 \times 5 5×5（便于手动计算，核心逻辑与28×28一致），像素值如下（灰度值0-255，此处简化为0-4）：

X = [ 1 2 3 2 1 0 1 2 1 0 0 0 1 0 0 0 1 2 1 0 1 2 3 2 1 ] X = \begin{bmatrix} 1 & 2 & 3 & 2 & 1 \\ 0 & 1 & 2 & 1 & 0 \\ 0 & 0 & 1 & 0 & 0 \\ 0 & 1 & 2 & 1 & 0 \\ 1 & 2 & 3 & 2 & 1 \end{bmatrix} X= 1000121012321232101210001

卷积核 K K K：工程常用3×3垂直边缘检测核（对应4.1节经典卷积核），权重如下： K = [ − 1 0 1 − 1 0 1 − 1 0 1 ] K = \begin{bmatrix} -1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1 \end{bmatrix} K= −1−1−1000111 ，偏置 b = 0 b = 0 b=0；
两组测试参数：
参数组1：无填充（ p = 0 p=0 p=0）、步长 s = 1 s=1 s=1（最基础场景）；
参数组2：有填充（ p = 1 p=1 p=1）、步长 s = 1 s=1 s=1（保持输入输出尺寸一致）。

例子1：无填充（p=0）、步长s=1

第一步：计算输出尺寸

输入尺寸 H = 5 , W = 5 H=5, W=5 H=5,W=5，卷积核尺寸 k h = 3 , k w = 3 k_h=3, k_w=3 kh=3,kw=3，代入尺寸公式：

H ′ = ⌊ 5 + 2 × 0 − 3 1 ⌋ + 1 = ( 2 ) + 1 = 3 H' = \left\lfloor \frac{5 + 2 \times 0 - 3}{1} \right\rfloor + 1 = (2) + 1 = 3 H′=⌊15+2×0−3⌋+1=(2)+1=3

W ′ = ⌊ 5 + 2 × 0 − 3 1 ⌋ + 1 = 3 W' = \left\lfloor \frac{5 + 2 \times 0 - 3}{1} \right\rfloor + 1 = 3 W′=⌊15+2×0−3⌋+1=3

因此输出特征图 Y Y Y尺寸为 3 × 3 3 \times 3 3×3。

第二步：卷积滑动与特征值计算

卷积核以步长1在输入 X X X上滑动，共滑动 3 × 3 = 9 3 \times 3 = 9 3×3=9个位置，每个位置计算加权求和（无偏置），具体过程如下：

滑动位置(0,0)（卷积核左上角对齐X(0,0)）：取X局部窗口 [ 1 2 3 0 1 2 0 0 1 ] \begin{bmatrix} 1 & 2 & 3 \\ 0 & 1 & 2 \\ 0 & 0 & 1 \end{bmatrix} 100210321 ，加权求和：
Y ( 0 , 0 ) = ( 1 × − 1 ) + ( 2 × 0 ) + ( 3 × 1 ) + ( 0 × − 1 ) + ( 1 × 0 ) + ( 2 × 1 ) + ( 0 × − 1 ) + ( 0 × 0 ) + ( 1 × 1 ) = − 1 + 0 + 3 + 0 + 0 + 2 + 0 + 0 + 1 = 5 Y(0,0) = (1 \times -1) + (2 \times 0) + (3 \times 1) + (0 \times -1) + (1 \times 0) + (2 \times 1) + (0 \times -1) + (0 \times 0) + (1 \times 1) = -1 + 0 + 3 + 0 + 0 + 2 + 0 + 0 + 1 = 5 Y(0,0)=(1×−1)+(2×0)+(3×1)+(0×−1)+(1×0)+(2×1)+(0×−1)+(0×0)+(1×1)=−1+0+3+0+0+2+0+0+1=5
滑动位置(0,1)（卷积核左上角对齐X(0,1)）：取X局部窗口 [ 2 3 2 1 2 1 0 1 0 ] \begin{bmatrix} 2 & 3 & 2 \\ 1 & 2 & 1 \\ 0 & 1 & 0 \end{bmatrix} 210321210 ，加权求和：
Y ( 0 , 1 ) = ( 2 × − 1 ) + ( 3 × 0 ) + ( 2 × 1 ) + ( 1 × − 1 ) + ( 2 × 0 ) + ( 1 × 1 ) + ( 0 × − 1 ) + ( 1 × 0 ) + ( 0 × 1 ) = − 2 + 0 + 2 − 1 + 0 + 1 + 0 + 0 + 0 = 0 Y(0,1) = (2 \times -1) + (3 \times 0) + (2 \times 1) + (1 \times -1) + (2 \times 0) + (1 \times 1) + (0 \times -1) + (1 \times 0) + (0 \times 1) = -2 + 0 + 2 -1 + 0 + 1 + 0 + 0 + 0 = 0 Y(0,1)=(2×−1)+(3×0)+(2×1)+(1×−1)+(2×0)+(1×1)+(0×−1)+(1×0)+(0×1)=−2+0+2−1+0+1+0+0+0=0
滑动位置(0,2)（卷积核左上角对齐X(0,2)）：同理计算， Y ( 0 , 2 ) = − 5 Y(0,2) = -5 Y(0,2)=−5；
滑动位置(1,0)： Y ( 1 , 0 ) = 3 Y(1,0) = 3 Y(1,0)=3；滑动位置(1,1)： Y ( 1 , 1 ) = 0 Y(1,1) = 0 Y(1,1)=0；滑动位置(1,2)： Y ( 1 , 2 ) = − 3 Y(1,2) = -3 Y(1,2)=−3；
滑动位置(2,0)： Y ( 2 , 0 ) = 5 Y(2,0) = 5 Y(2,0)=5；滑动位置(2,1)： Y ( 2 , 1 ) = 0 Y(2,1) = 0 Y(2,1)=0；滑动位置(2,2)： Y ( 2 , 2 ) = − 5 Y(2,2) = -5 Y(2,2)=−5。

第三步：最终输出特征图

Y = [ 5 0 − 5 3 0 − 3 5 0 − 5 ] Y = \begin{bmatrix} 5 & 0 & -5 \\ 3 & 0 & -3 \\ 5 & 0 & -5 \end{bmatrix} Y= 535000−5−3−5

结果分析：输出特征图中，正值对应垂直边缘的一侧，负值对应另一侧，0对应无垂直边缘区域，与垂直边缘检测核的功能完全匹配，直观体现了卷积的特征提取逻辑。

例子2：有填充（p=1）、步长s=1

第一步：输入填充与尺寸计算

填充 p = 1 p=1 p=1，即在输入 X X X的边缘填充1层0，填充后的输入 X p X_p Xp尺寸为 ( 5 + 2 × 1 ) × ( 5 + 2 × 1 ) = 7 × 7 (5+2×1) \times (5+2×1) = 7×7 (5+2×1)×(5+2×1)=7×7，填充后矩阵如下：

X p = [ 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 1 2 1 0 0 0 0 0 1 0 0 0 0 0 1 2 1 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 ] X_p = \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 2 & 3 & 2 & 1 & 0 \\ 0 & 0 & 1 & 2 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 2 & 1 & 0 & 0 \\ 0 & 1 & 2 & 3 & 2 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{bmatrix} Xp= 0000000010001002101200321230021012001000100000000

代入尺寸公式计算输出尺寸：

H ′ = ⌊ 5 + 2 × 1 − 3 1 ⌋ + 1 = ( 4 ) + 1 = 5 H' = \left\lfloor \frac{5 + 2 \times 1 - 3}{1} \right\rfloor + 1 = (4) + 1 = 5 H′=⌊15+2×1−3⌋+1=(4)+1=5

W ′ = 5 W' = 5 W′=5

输出尺寸与输入尺寸一致（5×5），这也是Same Padding的核心作用------避免边缘特征丢失，同时保持特征图尺寸连贯。

第二步：核心卷积逻辑

卷积核仍以步长1在填充后的 X p X_p Xp上滑动，共滑动 5 × 5 = 25 5×5=25 5×5=25个位置，计算逻辑与例子1完全一致（加权求和）。此处仅展示关键位置的计算的结果，完整输出特征图如下（验证填充后的效果）：

Y = [ 1 2 3 2 1 0 5 0 − 5 0 0 3 0 − 3 0 0 5 0 − 5 0 1 2 3 2 1 ] Y = \begin{bmatrix} 1 & 2 & 3 & 2 & 1 \\ 0 & 5 & 0 & -5 & 0 \\ 0 & 3 & 0 & -3 & 0 \\ 0 & 5 & 0 & -5 & 0 \\ 1 & 2 & 3 & 2 & 1 \end{bmatrix} Y= 1000125352300032−5−3−5210001

结果分析：填充后，输出特征图保留了原始输入的边缘信息（四周非零值），避免了无填充时边缘特征被截断的问题，这也是工程中训练CNN时常用Same Padding的原因。

我们可以看到，卷积输出尺寸的计算是卷积操作的前提，而卷积的本质就是"滑动窗口加权求和"，填充和步长的调整仅改变输入形态和滑动范围，不改变核心计算逻辑------这也是后续NumPy手动实现卷积的核心依据。

三、NumPy手动实现二维卷积：从数学公式到代码

为了更直观地理解二维卷积的数学本质，我们摒弃框架的封装，基于NumPy手动实现无填充、步长为1的二维卷积操作，完全对应上文中的CNN卷积核心公式。

3.1 核心实现思路

确定输入矩阵、卷积核的尺寸，根据尺寸公式计算输出矩阵的尺寸；
初始化全0的输出矩阵，用于存储卷积结果；
让卷积核在输入矩阵上以步长1滑动，遍历所有有效位置；
对每个滑动位置，执行像素与权重相乘→求和→加偏置的操作，将结果赋值给输出矩阵对应位置；
返回输出矩阵，完成卷积操作。

3.2 完整代码实现

python 复制代码

import numpy as np
import matplotlib.pyplot as plt

# 手动实现二维卷积（CNN实际使用的互相关操作，无填充，步长=1）
def conv2d_numpy(X, K, b=0.0):
    """
    二维卷积前向传播实现
    :param X: 输入矩阵，shape=(H, W)
    :param K: 卷积核，shape=(k_h, k_w)
    :param b: 偏置项，标量
    :return: 输出特征图，shape=(H', W')
    """
    # 获取输入和卷积核的尺寸
    H, W = X.shape
    k_h, k_w = K.shape
    # 计算输出尺寸（无填充p=0，步长s=1）
    H_out = (H - k_h) + 1
    W_out = (W - k_w) + 1
    # 初始化输出特征图
    Y = np.zeros((H_out, W_out))
    
    # 卷积核滑动遍历输入矩阵
    for i in range(H_out):
        for j in range(W_out):
            # 取输入的局部窗口，与卷积核尺寸一致
            X_window = X[i:i+k_h, j:j+k_w]
            # 核心操作：加权求和 + 偏置（对应CNN卷积公式）
            Y[i, j] = np.sum(X_window * K) + b
    return Y

# 测试：用简单矩阵验证卷积效果
if __name__ == "__main__":
    # 模拟2×2像素的简单图像（输入矩阵）
    X = np.array([[1, 2], 
                  [3, 4]], dtype=np.float32)
    # 定义3×3以下的卷积核（保证输出尺寸为正）
    K = np.array([[0.5, 0.5], 
                  [0.5, 0.5]], dtype=np.float32)
    # 偏置项
    b = 0.1
    # 执行手动卷积
    Y = conv2d_numpy(X, K, b)
    # 打印结果
    print("输入矩阵X：")
    print(X)
    print("\n卷积核K：")
    print(K)
    print("\n卷积输出Y：")
    print(Y)

3.3 结果验证与分析

运行代码后，输出结果为：

复制代码

输入矩阵X：
[[1. 2.]
 [3. 4.]]

卷积核K：
[[0.5 0.5]
 [0.5 0.5]]

卷积输出Y：
[[5.1]]

手动计算验证： ∑ ( X × K ) + b = ( 1 × 0.5 + 2 × 0.5 + 3 × 0.5 + 4 × 0.5 ) + 0.1 = 5 + 0.1 = 5.1 \sum(X \times K) + b = (1×0.5+2×0.5+3×0.5+4×0.5) + 0.1 = 5 + 0.1 = 5.1 ∑(X×K)+b=(1×0.5+2×0.5+3×0.5+4×0.5)+0.1=5+0.1=5.1，与代码输出完全一致，证明我们的实现严格贴合CNN的卷积数学公式。

这一实现虽然简单，但涵盖了CNN卷积层前向传播的核心逻辑，后续框架中的卷积操作，只是在此基础上做了步长、填充、多通道、批量处理的扩展，其本质不变。

四、卷积核的特征提取可视化：从简单边缘到图像特征

卷积核是CNN的特征检测器 ，不同的卷积核权重对应不同的特征提取能力，如检测水平边缘、垂直边缘、斜向边缘等。本节我们基于上述的手动卷积实现，加载真实的灰度图像，定义不同的经典卷积核，可视化卷积核的特征提取效果，直观理解卷积核如何通过加权求和提取图像局部特征。

4.1 经典卷积核定义

工程中常用的基础卷积核（3×3），可实现基础的边缘检测，其权重设计具有明确的数学逻辑：通过相邻像素的权重差，放大像素值的变化，从而检测出边缘。

垂直边缘检测核 ： K v e r t = [ − 1 0 1 − 1 0 1 − 1 0 1 ] K_{vert} = \begin{bmatrix} -1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1 \end{bmatrix} Kvert= −1−1−1000111
水平边缘检测核 ： K h o r i z = [ − 1 − 1 − 1 0 0 0 1 1 1 ] K_{horiz} = \begin{bmatrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{bmatrix} Khoriz= −101−101−101
平滑核（均值滤波） ： K s m o o t h = 1 9 [ 1 1 1 1 1 1 1 1 1 ] K_{smooth} = \frac{1}{9} \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix} Ksmooth=91 111111111
锐化核 ： K s h a r p = [ 0 − 1 0 − 1 5 − 1 0 − 1 0 ] K_{sharp} = \begin{bmatrix} 0 & -1 & 0 \\ -1 & 5 & -1 \\ 0 & -1 & 0 \end{bmatrix} Ksharp= 0−10−15−10−10

4.2 特征提取可视化代码

python 复制代码

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 复用上述的conv2d_numpy函数
def conv2d_numpy(X, K, b=0.0):
    H, W = X.shape
    k_h, k_w = K.shape
    H_out = (H - k_h) + 1
    W_out = (W - k_w) + 1
    Y = np.zeros((H_out, W_out))
    for i in range(H_out):
        for j in range(W_out):
            X_window = X[i:i+k_h, j:j+k_w]
            Y[i, j] = np.sum(X_window * K) + b
    # 归一化到0-255，便于显示
    Y = (Y - Y.min()) / (Y.max() - Y.min()) * 255
    Y = Y.astype(np.uint8)
    return Y

# 加载灰度图像（使用cv2加载，自动为灰度图）
img = cv2.imread("test_img.png", 0)
# 定义经典3×3卷积核
K_vert = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.float32)  # 垂直边缘
K_horiz = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]], dtype=np.float32)  # 水平边缘
K_smooth = np.ones((3,3), dtype=np.float32) / 9  # 平滑
K_sharp = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], dtype=np.float32)  # 锐化

# 执行卷积，提取不同特征
img_vert = conv2d_numpy(img, K_vert)
img_horiz = conv2d_numpy(img, K_horiz)
img_smooth = conv2d_numpy(img, K_smooth)
img_sharp = conv2d_numpy(img, K_sharp)

# 可视化结果
plt.figure(figsize=(16, 4))
plt.subplot(1,5,1), plt.imshow(img, cmap='gray'), plt.title('原始图像'), plt.axis('off')
plt.subplot(1,5,2), plt.imshow(img_vert, cmap='gray'), plt.title('垂直边缘'), plt.axis('off')
plt.subplot(1,5,3), plt.imshow(img_horiz, cmap='gray'), plt.title('水平边缘'), plt.axis('off')
plt.subplot(1,5,4), plt.imshow(img_smooth, cmap='gray'), plt.title('平滑'), plt.axis('off')
plt.subplot(1,5,5), plt.imshow(img_sharp, cmap='gray'), plt.title('锐化'), plt.axis('off')
plt.tight_layout()
plt.show()

4.3 结果分析

运行代码后，可清晰看到：

垂直边缘检测核仅保留了图像中的垂直边缘特征，水平边缘被抑制；
水平边缘检测核仅保留了图像中的水平边缘特征，垂直边缘被抑制；
平滑核通过均值加权，模糊了图像的细节，减少了噪声；
锐化核通过放大中心像素、抑制周围像素，增强了图像的边缘和细节。

这一结果直观证明了卷积核的权重决定了其特征提取能力，而在CNN的训练过程中，卷积核的权重并非人工设计，而是通过反向传播自动学习得到------网络会根据损失函数的误差反馈，调整卷积核的权重，让不同的卷积核自发学习不同的图像特征，最终形成特征分工，这与MLP神经元的权重分工逻辑完全一致。

五、CNN vs MLP：核心设计优势的数学与工程分析

CNN针对图像数据的三大核心设计（局部连接、参数共享、池化操作），从数学层面解决了MLP处理图像的天然缺陷，我们从参数数量、特征学习效率两个维度，对比分析CNN的核心优势，让设计思路与数学原理一一对应。

5.1 局部连接：利用图像的空间局部相关性

数学原理 ：图像的特征具有局部性，如边缘、纹理均由相邻像素构成，远离的像素对当前局部特征的贡献极小。因此卷积层仅让卷积核与输入图像的局部窗口 连接，而非全连接。
参数对比 ：假设输入为28×28的MNIST图像，MLP的全连接层需要 28 × 28 = 784 28×28=784 28×28=784个权重；而CNN使用3×3的卷积核，仅需要 3 × 3 = 9 3×3=9 3×3=9个权重，参数数量大幅减少。
核心优势：避免了无关像素的干扰，聚焦局部特征提取，同时减少参数数量，缓解过拟合。

5.2 参数共享：让同一卷积核提取全局相同特征

数学原理 ：同一特征在图像的不同位置具有相同的表达形式（如水平边缘在图像左上角和右下角的特征本质一致），因此可让同一卷积核在图像的所有位置共享权重，无需为每个位置设计单独的权重。
参数对比 ：28×28的图像，3×3的卷积核若采用全连接的权重设计，需要 784 × 9 = 7056 784×9=7056 784×9=7056个权重；而参数共享后，仅需要9个权重，参数数量呈指数级减少。
核心优势 ：大幅削减模型参数，避免过拟合，同时让网络具备平移不变性的基础------同一卷积核在不同位置能检测到相同的特征，无论目标在图像中如何平移，都能被有效提取。

5.3 池化操作：降维并保留核心特征

数学原理 ：池化层通过对局部特征图做最大值或平均值 操作，降低特征图的尺寸，同时保留局部区域的核心特征（如最大值池化保留边缘的关键像素，平均值池化保留区域的整体特征）。
参数影响 ：池化层无训练参数，仅通过固定的数学操作降维，后续卷积层的参数数量会随特征图尺寸的降低而减少。
核心优势 ：进一步减少计算量和参数数量，缓解过拟合，同时增强网络的尺度不变性------目标在图像中轻微缩放时，池化操作仍能保留其核心特征。

5.4 整体参数对比（MNIST任务）

以MNIST手写数字分类任务（28×28灰度图像）为例，对比简单MLP与简单CNN的参数数量：

MLP ：输入层784→隐藏层128→输出层10，参数数量为 784 × 128 + 128 × 10 = 102 , 528 784×128 + 128×10 = 102,528 784×128+128×10=102,528；
CNN ：1个3×3卷积层（输出16通道）→池化层→全连接层10，卷积层参数数量为 3 × 3 × 1 × 16 + 16 = 160 3×3×1×16 + 16 = 160 3×3×1×16+16=160，整体参数数量不足1万。

核心结论 ：CNN通过三大核心设计，从数学层面实现了参数高效利用，解决了MLP处理图像时的参数爆炸问题，同时契合图像的空间特征属性，让特征学习效率远高于MLP。

六、总结

本篇作为CNN的基础篇，从数学原理出发，系统讲解了二维离散卷积的定义、CNN工程实现的卷积逻辑、输出尺寸的计算，通过NumPy手动实现了卷积操作，可视化了卷积核的特征提取过程，并对比MLP分析了CNN的核心设计优势，核心要点总结如下：

CNN中的卷积实际为互相关操作 ，核心公式为 Y ( i , j ) = ∑ m = 0 k h − 1 ∑ n = 0 k w − 1 X ( i + m , j + n ) ⋅ K ( m , n ) + b Y(i,j) = \sum_{m=0}^{k_h-1} \sum_{n=0}^{k_w-1} X(i+m, j+n) \cdot K(m, n) + b Y(i,j)=∑m=0kh−1∑n=0kw−1X(i+m,j+n)⋅K(m,n)+b，是滑动窗口的加权求和；
卷积输出尺寸由 H ′ = ⌊ ( H + 2 p − k h ) / s ⌋ + 1 H' = \lfloor (H + 2p - k_h)/s \rfloor + 1 H′=⌊(H+2p−kh)/s⌋+1、 W ′ = ⌊ ( W + 2 p − k w ) / s ⌋ + 1 W' = \lfloor (W + 2p - k_w)/s \rfloor + 1 W′=⌊(W+2p−kw)/s⌋+1计算，是构建CNN的基础；
卷积核是特征检测器，不同权重对应不同的特征提取能力，其权重通过反向传播自动学习，形成特征分工；
CNN的局部连接、参数共享、池化操作三大核心设计，大幅减少参数数量，契合图像的空间特征，解决了MLP的天然缺陷。