CNN误差反向传播原理详解与Python实现：从数学推导到代码实战

1次阅读

共计 5525 个字符，预计需要花费 14 分钟才能阅读完成。

卷积神经网络（CNN）在计算机视觉领域有着举足轻重的地位，从图像分类到目标检测，它的表现都令人瞩目。而反向传播算法则是训练 CNN 的核心，它通过计算损失函数对网络参数的梯度，指导参数更新，使得网络能够逐步优化。

对于初学者来说，理解 CNN 的反向传播过程往往是一个挑战。与全连接网络相比，CNN 的反向传播涉及卷积操作和池化操作的特殊处理，这使得推导过程更加复杂。本文将带你一步步拆解这个过程，从数学公式到代码实现，让你彻底掌握 CNN 的反向传播机制。

卷积层的反向传播可以看作是对前向传播的逆过程。假设我们有一个卷积层，输入为 $X$，卷积核为 $W$，输出为 $Y$，那么前向传播可以表示为：

$$
Y = X \ast W
$$

其中 $\ast$ 表示卷积操作。在反向传播时，我们需要计算损失函数 $L$ 对 $W$ 的梯度 $\frac{\partial L}{\partial W}$。根据链式法则，这个梯度可以表示为：

$$
\frac{\partial L}{\partial W} = \frac{\partial L}{\partial Y} \ast \frac{\partial Y}{\partial W}
$$

这里 $\frac{\partial L}{\partial Y}$ 是从上一层传递下来的误差，而 $\frac{\partial Y}{\partial W}$ 可以通过对卷积操作求导得到。实际上，$\frac{\partial L}{\partial W}$ 的计算可以表示为输入 $X$ 与误差 $\frac{\partial L}{\partial Y}$ 的卷积：

$$
\frac{\partial L}{\partial W} = X \ast \frac{\partial L}{\partial Y}
$$

池化层（包括最大池化和平均池化）的反向传播略有不同。对于最大池化，梯度只回传到前向传播时被选中的最大值位置，其他位置的梯度为零。而对于平均池化，梯度均匀分配到前向传播时的所有输入位置。

具体来说，对于最大池化，如果前向传播时某个池化区域的最大值位于位置 $(i,j)$，那么反向传播时该位置的梯度就是上一层传递下来的梯度，其他位置为零。

对于平均池化，如果池化区域大小为 $k \times k$，那么该区域内每个位置的梯度都是上一层传递下来的梯度除以 $k^2$。

在得到 $\frac{\partial L}{\partial W}$ 后，我们可以使用梯度下降法来更新卷积核参数：

$$
W = W – \eta \cdot \frac{\partial L}{\partial W}
$$

其中 $\eta$ 是学习率，控制参数更新的步长。

下面我们使用 NumPy 来实现一个简单的 CNN 层，包含前向传播和反向传播的功能。

import numpy as np

class ConvLayer:
    def __init__(self, input_channels, output_channels, kernel_size, stride=1, padding=0):
        self.input_channels = input_channels
        self.output_channels = output_channels
        self.kernel_size = kernel_size
        self.stride = stride
        self.padding = padding

        # 初始化卷积核，使用 Xavier 初始化
        scale = np.sqrt(2. / (input_channels * kernel_size * kernel_size))
        self.W = np.random.randn(output_channels, input_channels, kernel_size, kernel_size) * scale
        self.b = np.zeros(output_channels)

    def forward(self, X):
        self.X = X
        batch_size, input_channels, input_height, input_width = X.shape

        # 计算输出尺寸
        output_height = (input_height - self.kernel_size + 2 * self.padding) // self.stride + 1
        output_width = (input_width - self.kernel_size + 2 * self.padding) // self.stride + 1

        # 添加 padding
        if self.padding > 0:
            X_padded = np.pad(X, ((0,0), (0,0), (self.padding, self.padding), (self.padding, self.padding)), mode='constant')
        else:
            X_padded = X

        # 初始化输出
        Y = np.zeros((batch_size, self.output_channels, output_height, output_width))

        # 执行卷积操作
        for b in range(batch_size):
            for c_out in range(self.output_channels):
                for h in range(output_height):
                    for w in range(output_width):
                        h_start = h * self.stride
                        h_end = h_start + self.kernel_size
                        w_start = w * self.stride
                        w_end = w_start + self.kernel_size

                        Y[b, c_out, h, w] = np.sum(X_padded[b, :, h_start:h_end, w_start:w_end] * self.W[c_out]
                        ) + self.b[c_out]

        return Y

    def backward(self, dY):
        batch_size, input_channels, input_height, input_width = self.X.shape

        # 初始化梯度
        dW = np.zeros_like(self.W)
        db = np.zeros_like(self.b)
        dX = np.zeros_like(self.X)

        # 添加 padding
        if self.padding > 0:
            X_padded = np.pad(self.X, ((0,0), (0,0), (self.padding, self.padding), (self.padding, self.padding)), mode='constant')
            dX_padded = np.pad(dX, ((0,0), (0,0), (self.padding, self.padding), (self.padding, self.padding)), mode='constant')
        else:
            X_padded = self.X
            dX_padded = dX

        output_height, output_width = dY.shape[2], dY.shape[3]

        # 计算 dW 和 db
        for b in range(batch_size):
            for c_out in range(self.output_channels):
                for h in range(output_height):
                    for w in range(output_width):
                        h_start = h * self.stride
                        h_end = h_start + self.kernel_size
                        w_start = w * self.stride
                        w_end = w_start + self.kernel_size

                        dW[c_out] += X_padded[b, :, h_start:h_end, w_start:w_end] * dY[b, c_out, h, w]
                        db[c_out] += dY[b, c_out, h, w]

                        dX_padded[b, :, h_start:h_end, w_start:w_end] += self.W[c_out] * dY[b, c_out, h, w]

        # 去除 padding
        if self.padding > 0:
            dX = dX_padded[:, :, self.padding:-self.padding, self.padding:-self.padding]
        else:
            dX = dX_padded

        return dX, dW, db

为了验证我们的反向传播实现是否正确，我们可以使用数值梯度检验的方法。基本思想是通过微小的扰动来计算梯度的近似值，然后与我们实现的梯度进行比较。

def numerical_gradient_check(layer, X, epsilon=1e-7):
    """数值梯度检验"""
    # 前向传播
    Y = layer.forward(X)

    # 随机生成 dY
    dY = np.random.randn(*Y.shape)

    # 反向传播得到梯度
    _, dW_analytic, db_analytic = layer.backward(dY)

    # 数值计算 dW
    dW_numeric = np.zeros_like(layer.W)
    for c_out in range(layer.output_channels):
        for c_in in range(layer.input_channels):
            for h in range(layer.kernel_size):
                for w in range(layer.kernel_size):
                    # 保存原始值
                    original = layer.W[c_out, c_in, h, w].copy()

                    # 计算 f(x + epsilon)
                    layer.W[c_out, c_in, h, w] = original + epsilon
                    Y_plus = layer.forward(X)
                    loss_plus = np.sum(Y_plus * dY)

                    # 计算 f(x - epsilon)
                    layer.W[c_out, c_in, h, w] = original - epsilon
                    Y_minus = layer.forward(X)
                    loss_minus = np.sum(Y_minus * dY)

                    # 恢复原始值
                    layer.W[c_out, c_in, h, w] = original

                    # 计算数值梯度
                    dW_numeric[c_out, c_in, h, w] = (loss_plus - loss_minus) / (2 * epsilon)

    # 比较数值梯度和解析梯度
    diff = np.linalg.norm(dW_analytic - dW_numeric) / (np.linalg.norm(dW_analytic) + np.linalg.norm(dW_numeric))
    print(f"dW 相对误差: {diff}")

    # 数值计算 db
    db_numeric = np.zeros_like(layer.b)
    for c_out in range(layer.output_channels):
        # 保存原始值
        original = layer.b[c_out].copy()

        # 计算 f(b + epsilon)
        layer.b[c_out] = original + epsilon
        Y_plus = layer.forward(X)
        loss_plus = np.sum(Y_plus * dY)

        # 计算 f(b - epsilon)
        layer.b[c_out] = original - epsilon
        Y_minus = layer.forward(X)
        loss_minus = np.sum(Y_minus * dY)

        # 恢复原始值
        layer.b[c_out] = original

        # 计算数值梯度
        db_numeric[c_out] = (loss_plus - loss_minus) / (2 * epsilon)

    # 比较数值梯度和解析梯度
    diff = np.linalg.norm(db_analytic - db_numeric) / (np.linalg.norm(db_analytic) + np.linalg.norm(db_numeric))
    print(f"db 相对误差: {diff}")

学习率是训练神经网络最重要的超参数之一。太大的学习率可能导致震荡甚至发散，太小的学习率则会使训练过程缓慢。建议：