AlexNet反向传播原理详解与实现：从数学推导到Python实战

1次阅读

没有评论

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

AlexNet 作为首个成功应用深度卷积网络的模型，其结构包含 5 个卷积层和 3 个全连接层。与全连接层不同，卷积层的参数共享和局部连接特性带来了两个核心挑战：

权值共享机制：同一个卷积核在不同位置重复使用，导致梯度计算时需要累加所有位置的贡献
三维张量运算 ：输入输出特征图的(height, width, channels) 三维结构，使得直接计算会导致嵌套循环，效率极低

设第 $l$ 层为卷积层，其前向传播可表示为：

$$Z^l = W^l \ast A^{l-1} + b^l$$

其中 $\ast$ 表示卷积运算。根据链式法则，损失函数 $L$ 对卷积核 $W^l$ 的梯度为：

$$
\frac{\partial L}{\partial W^l} = \frac{\partial L}{\partial Z^l} \cdot \frac{\partial Z^l}{\partial W^l} = \delta^l \ast rot180(A^{l-1})
$$

这里 $rot180$ 表示将输入旋转 180 度，实现真正的卷积运算（而非互相关）。

为提升计算效率，实践中常用 im2col 将卷积运算转化为矩阵乘法：

将输入局部感受野展开为列向量
将卷积核重塑为行向量
通过 GEMM（通用矩阵乘法）加速计算

转换后的梯度计算变为：

$$
\frac{\partial L}{\partial W} = (\delta_{col})^T \cdot X_{col}
$$

其中 $X_{col}$ 是 im2col 转换后的输入矩阵。

def conv_backward(d_out, cache):
    """d_out: 上游梯度 (N, F, H', W')
    cache: 前向传播保存的(input, w, b, conv_param)
    """
    x, w, b, conv_param = cache
    stride, pad = conv_param['stride'], conv_param['pad']

    # 转换输入为 im2col 矩阵
    x_col = im2col(x, w.shape, stride, pad)  # (C*HH*WW, N*H'*W')
    dout_col = d_out.transpose(1,2,3,0).reshape(F, -1)  # (F, N*H'*W')

    # 计算权重梯度
    dw = dout_col @ x_col.T  # (F, C*HH*WW)
    dw = dw.reshape(w.shape)

    # 计算输入梯度
    dx_col = w.reshape(F, -1).T @ dout_col  # (C*HH*WW, N*H'*W')
    dx = col2im(dx_col, x.shape, w.shape, stride, pad)

    # 偏置梯度
    db = np.sum(d_out, axis=(0,2,3))

    return dx, dw, db

def relu_backward(d_out, cache):
    """cache: 前向传播保存的输入 x"""
    x = cache
    dx = d_out * (x > 0)  # 小于 0 的位置梯度为 0
    return dx

def batchnorm_backward(d_out, cache):
    """cache: (x, gamma, beta, running_mean, running_var, sample_mean, sample_var, eps)"""
    N, D = d_out.shape
    x, gamma, _, _, _, mu, var, eps = cache

    # 计算中间导数
    dxhat = d_out * gamma
    dvar = np.sum(dxhat * (x - mu) * (-0.5) * (var + eps)**(-1.5), axis=0)
    dmu = np.sum(dxhat * (-1 / np.sqrt(var + eps)), axis=0) + \
          dvar * np.mean(-2 * (x - mu), axis=0)

    # 最终输入梯度
    dx = dxhat / np.sqrt(var + eps) + dvar * 2 * (x - mu)/N + dmu/N
    dgamma = np.sum(d_out * (x - mu) / np.sqrt(var + eps), axis=0)
    dbeta = np.sum(d_out, axis=0)

    return dx, dgamma, dbeta

梯度检查点：在内存受限时，只保存部分中间结果，需要时重新计算
异步计算：将数据传输与计算过程重叠（CUDA streams）
混合精度训练：使用 FP16 存储，FP32 计算关键部分

# 典型 CUDA 优化模式
def conv_kernel(d_out, x, w):
    # 每个线程块处理一个输出通道
    bid = blockIdx.x  # 输出通道索引
    tid = threadIdx.x  # 线程索引

    # 共享内存加速数据访问
    __shared__ float smem[BLOCK_SIZE];

    # 计算该线程负责的输出位置
    out_pos = bid * output_width * output_height + tid

    # 执行卷积计算...
    # ...

使用中心差分公式更准确：
$$\frac{f(x+\epsilon) – f(x-\epsilon)}{2\epsilon}$$
典型检查流程：
随机生成检查点（不要用全零）
计算数值梯度和解析梯度
相对误差应小于 1e-7

卷积层：He 初始化 $\sim N(0, \sqrt{2/fan_in})$
学习率：初始尝试 0.1，配合学习率衰减（如 cosine 调度）
批量大小：GPU 显存允许下尽量大（如 256）

残差连接扩展：ResNet 中需要处理恒等映射分支的梯度，需额外实现：
$$\frac{\partial L}{\partial x_{l}} = \frac{\partial L}{\partial x_{l+1}}} \cdot (1 + \frac{\partial F}{\partial x_{l}}})$$
自动微分 vs 手动实现：
PyTorch 的 autograd 适合快速实验
手动实现更利于理解本质，且能进行特定优化

通过这次完整实现，我深刻体会到反向传播就像乐高积木——每个模块的梯度计算都要严丝合缝。建议读者尝试在 CIFAR-10 上从头训练，观察各层梯度分布的变化规律。

正文完