手撕CNN：用NumPy从零实现卷积、池化与反向传播-平芜编程栈

1. 为什么“手撕”卷积神经网络是绕不开的硬核基本功

“手撕CNN”这个词在算法岗面试、深度学习入门社群和高校实验课里反复出现，但它从来不是一句口号。我带过几届某高校实验室的本科生做图像识别项目，发现一个非常典型的断层现象：90%的同学能熟练调用PyTorch写nn.Conv2d()、nn.MaxPool2d()，跑通CIFAR-10准确率85%+，但当被问到“如果让你不依赖任何自动求导框架，只用纯Python和NumPy，从零实现一次前向传播+反向传播，你第一步写哪行代码？”——超过七成的人会卡在卷积核滑动的索引计算上，更别说推导∂L/∂W的维度变换逻辑。

这不是能力问题，而是训练路径的结构性缺失。当前主流教学把CNN当作一个“黑箱模块”，重点教你怎么堆叠层、调参、上GPU，却跳过了最核心的空间局部性建模本质和梯度在张量空间中的物理流动路径。而恰恰是这些被跳过的部分，在模型调试、自定义算子开发、边缘设备部署（比如把CNN移植到无PyTorch支持的嵌入式平台）时，成为决定成败的关键。比如某次为某跨平台系统做轻量化部署，第三方推理引擎不支持ConvTranspose2d的某些padding模式，我们不得不手写反卷积的前向逻辑来验证数值一致性——那一刻，所有“背过公式但没推过索引”的人，都得临时翻《深度学习》花书第6章重学。

关键词里虽然空着，但标题本身已锚定三个不可妥协的核心：原生Python（拒绝Cython/FFI加速，一切靠纯Python循环与NumPy向量化）、卷积神经网络（特指具备典型结构：卷积层→激活→池化→全连接→Softmax）、手撕（强调过程可追溯、每行代码有明确数学对应，而非封装后调用）。这意味着本文不会出现torch.compile()或onnx.export()这类高层抽象，也不会讨论ResNet50的ImageNet精度，而是回到1998年LeCun手写LeNet-5的原始精神：用最朴素的工具，复现最本质的机制。

你不需要是数学系出身，但得愿意接受“索引即世界”的编程哲学；你不必精通CUDA，但得理解为什么stride=2时输出尺寸是(H-K)//S + 1；你可能刚学完Python基础，但只要能看懂for i in range(3):，就能跟着把反向传播的链式法则一行行落地。接下来的内容，就是一份可逐行执行、可打断调试、可替换组件的“解剖级”实现指南——它不承诺最快，但保证最透；不追求最简，但坚持最真。

2. 卷积层的物理实现：从数学定义到内存寻址的完整映射

2.1 卷积运算的本质不是“乘加”，而是“空间对齐采样”

很多人初学卷积时，容易陷入“矩阵乘法”的思维陷阱，认为卷积是输入矩阵与卷积核矩阵的某种乘法变形。这是根本性误解。真正的卷积操作，其物理意义是：在输入特征图的每个空间位置上，用卷积核进行局部窗口采样，将采样值与核权重逐元素相乘后求和，生成输出特征图的一个像素点。这个过程完全由空间坐标驱动，与矩阵代数无关。

我们以最基础的2D卷积为例，设定明确参数：

输入张量X: 形状为(C_in, H_in, W_in)，即通道数×高度×宽度
卷积核W: 形状为(C_out, C_in, K, K)，即输出通道数×输入通道数×卷积核高×卷积核宽
步长stride = S，填充padding = P

那么输出张量Y的形状必然是(C_out, H_out, W_out)，其中：

H_out = floor((H_in + 2*P - K) / S) + 1 W_out = floor((W_in + 2*P - K) / S) + 1

这个公式不是魔法，而是由采样起始点约束决定的。假设输入左上角为坐标(0,0)，填充后有效输入区域左上角变为(-P,-P)，第一个卷积窗口中心必须落在(-P,-P)处才能覆盖填充区域。当步长为S时，第i个窗口的垂直起始行坐标为i*S - P，要求该坐标>= -P且<= H_in + P - K（确保窗口不越界），解不等式即得i的取值范围[0, H_out)。

提示：实际编码中，我们不直接计算i*S - P，而是用双重循环遍历输出坐标(i,j)，再反推输入窗口的起始坐标。这是避免浮点误差和索引越界的最稳妥方式。

2.2 纯Python实现：三层嵌套循环的必然性与优化边界

既然卷积本质是空间采样，那么最直白的实现就是三层嵌套循环：外层遍历输出通道c_out，中层遍历输出高度i，内层遍历输出宽度j。对每个(c_out, i, j)，再嵌套两层循环遍历卷积核的k_h和k_w，以及输入通道c_in，完成一次局部加权求和。

# 假设 X_pad 已完成 padding，形状为 (C_in, H_in+2P, W_in+2P) Y = np.zeros((C_out, H_out, W_out)) for c_out in range(C_out): for i in range(H_out): for j in range(W_out): # 计算当前输出点 (i,j) 对应的输入窗口起始坐标 h_start = i * S w_start = j * S # 在输入通道上累加：每个输入通道贡献一个标量 val = 0.0 for c_in in range(C_in): for k_h in range(K): for k_w in range(K): # 输入窗口内坐标：h_start+k_h, w_start+k_w val += X_pad[c_in, h_start + k_h, w_start + k_w] * W[c_out, c_in, k_h, k_w] Y[c_out, i, j] = val

这段代码的复杂度是O(C_out × C_in × H_out × W_out × K²)，看起来很暴力，但它是唯一能清晰映射数学定义的实现。很多教程为了“性能”直接上np.lib.stride_tricks.sliding_window_view或im2col，这反而掩盖了空间对齐的本质。我建议初学者务必先写通这种五重循环版本，再逐步优化。

实测对比（输入3×32×32，卷积核16×3×5×5，S=1,P=0）：

五重循环：约1.2秒
sliding_window_view+einsum：约0.08秒
im2col+matmul：约0.05秒

性能差24倍，但五重循环的每一行都能在草稿纸上画出对应的采样框，而im2col需要额外理解“将滑动窗口展平为列向量”的线性代数技巧。对于“手撕”目标，可解释性优先于速度——当你需要调试某个输出点数值异常时，能直接在循环里加print(i,j,c_out,k_h,k_w)定位问题，远比在matmul结果里二分查找高效。

2.3 Padding的两种实现哲学：对称填充 vs 非对称填充

Padding看似简单，实则暗藏玄机。torch.nn.Conv2d默认使用'zeros'填充，但padding参数接受两种形式：

单整数：如padding=2→ 四周各补2行/列
元组：如padding=(1,2,3,4)→ 上、下、左、右分别填充

手写时必须明确选择一种策略。我推荐显式四元组填充，因为：

它能精确控制每个边界的填充量，适配非对称卷积（如某些论文中提出的asymmetric kernel）
避免np.pad(X, pad_width=((0,0),(P,P),(P,P)))这种“偷懒写法”导致的通道维度混淆（pad_width第一维是batch，但我们的X没有batch维）

具体实现：

def pad_2d(x, pad_top, pad_bottom, pad_left, pad_right, mode='constant', constant_values=0): """x shape: (C, H, W)""" padded = np.pad(x, pad_width=((0,0), (pad_top, pad_bottom), (pad_left, pad_right)), mode=mode, constant_values=constant_values) return padded

关键细节：np.pad的pad_width参数顺序是(axis0, axis1, axis2)，而我们的x轴序是(C,H,W)，所以axis0对应通道C（不填充），axis1对应高度H（上下填充），axis2对应宽度W（左右填充）。这个顺序错一位，整个卷积结果就会全乱——我在某次为某图像处理Demo调试时，就因把pad_width写成((0,0),(pad_left,pad_right),(pad_top,pad_bottom))导致输出图像严重扭曲，花了三小时才定位到这行。

注意：mode='reflect'或'edge'填充在风格迁移等任务中很有用，但手撕初期建议死守'constant'，避免引入额外的边界处理逻辑。

3. 池化层的确定性规则：最大池化为何不能“随机采样”

3.1 池化不是降维，而是局部特征的“代表性提取”

常有人把池化层（Pooling）理解为“降低分辨率以减少计算量”，这是严重的功能误读。池化的真实作用是：在保持空间拓扑结构的前提下，对局部感受野内的特征响应进行鲁棒性聚合，抑制微小位移带来的响应变化。最大池化（Max Pooling）之所以成为绝对主流，并非因为它“快”，而是因为它的确定性和平移不变性。

考虑一个典型场景：输入是一张猫脸图像，卷积层检测到“耳朵边缘”特征。如果猫脸在图像中水平偏移1像素，最大池化仍大概率在相邻位置捕获到最强响应，而平均池化（Average Pooling）会因引入邻域弱响应而稀释峰值。这就是为什么ResNet等架构在残差连接后仍保留最大池化——它保障了特征的位置鲁棒性。

数学上，最大池化可定义为：对输入张量X的每个K×K窗口，输出该窗口内的最大值。其输出尺寸计算与卷积一致：

H_out = floor((H_in + 2*P - K) / S) + 1 W_out = floor((W_in + 2*P - K) / S) + 1

但注意：池化层没有可学习参数，因此无需反向传播权重梯度，只需传递输入梯度。

3.2 手写最大池化的两个致命陷阱

陷阱一：忽略梯度回传的“溯源”需求
反向传播时，损失L对池化输入X的梯度∂L/∂X，只在前向时取得最大值的位置上非零，其余位置为0。这意味着前向过程必须记录每个输出点对应的最大值坐标，否则反向时无法定位。

正确做法是前向时返回output和mask（布尔掩码）或indices（坐标元组）：

def max_pool2d_forward(x, kernel_size, stride, padding=0): # x: (C, H, W) x_padded = pad_2d(x, padding, padding, padding, padding) H_out = (x_padded.shape[1] - kernel_size) // stride + 1 W_out = (x_padded.shape[2] - kernel_size) // stride + 1 out = np.zeros((x.shape[0], H_out, W_out)) # 存储每个输出点的最大值坐标 (c, h, w) indices = {} for c in range(x.shape[0]): for i in range(H_out): for j in range(W_out): h_start = i * stride w_start = j * stride window = x_padded[c, h_start:h_start+kernel_size, w_start:w_start+kernel_size] max_val = np.max(window) out[c, i, j] = max_val # 找到第一个最大值的位置（处理并列情况） idx = np.unravel_index(np.argmax(window), window.shape) indices[(c, i, j)] = (c, h_start + idx[0], w_start + idx[1]) return out, indices

陷阱二：用np.max直接降维导致信息丢失
错误写法：out[c,i,j] = np.max(x_padded[c, h_start:h_start+K, w_start:w_start+K])
问题：np.max只返回标量，丢失了最大值在窗口内的相对坐标。必须用np.argmax配合np.unravel_index获取二维索引，再转换为全局坐标。

提示：np.argmax在遇到多个相同最大值时，返回第一个出现位置的索引。这是确定性行为，符合PyTorch的max_pool2d规范。若需随机选择，需额外实现，但“手撕”目标是复现标准行为，故不引入随机性。

3.3 池化层的反向传播：梯度的“单点注入”机制

池化反向传播是理解CNN梯度流的关键切口。其规则极其简单：将上游梯度∂L/∂Y的每个值，原封不动地注入到前向时记录的最大值位置，其余位置梯度为0。

def max_pool2d_backward(dout, indices, x_shape, kernel_size, stride, padding=0): # dout: (C, H_out, W_out), 损失对池化输出的梯度 # x_shape: 池化输入的原始形状 (C, H_in, W_in) dx = np.zeros(x_shape) x_padded = np.zeros((x_shape[0], x_shape[1]+2*padding, x_shape[2]+2*padding)) for (c, i, j), (c_idx, h_idx, w_idx) in indices.items(): # 将 dout[c,i,j] 注入 dx 的 (c_idx, h_idx, w_idx) 位置 # 注意：h_idx, w_idx 是在 padded 空间中的坐标，需映射回原始 x 空间 if padding > 0: h_orig = h_idx - padding w_orig = w_idx - padding if 0 <= h_orig < x_shape[1] and 0 <= w_orig < x_shape[2]: dx[c_idx, h_orig, w_orig] += dout[c, i, j] else: dx[c_idx, h_idx, w_idx] += dout[c, i, j] return dx

这个过程揭示了一个深刻事实：池化层是梯度的“选择性放大器”。它不改变梯度值大小，但将全部梯度能量聚焦到局部最强响应点上，迫使网络学习更具判别性的特征。这也是为什么去掉池化层后，网络往往需要更深的卷积层来补偿感受野——因为梯度不再被主动聚焦。

4. 全连接层与Softmax的耦合设计：数值稳定性是生死线

4.1 全连接层的“张量-向量”转换：为什么必须flatten

全连接层（Fully Connected Layer）在CNN中通常位于卷积-池化堆叠之后，负责将空间特征映射到类别空间。其输入是三维张量(C, H, W)，输出是向量(num_classes,)。关键步骤是flatten：将C×H×W个特征值拉直为长度为C*H*W的向量。

这里有个易被忽视的细节：flatten的顺序必须与卷积输出的内存布局严格一致。NumPy默认按行优先（C-order）展开，即先变最右维度（W），再变中间维度（H），最后变最左维度（C）。因此x.flatten()等价于x.reshape(-1)，其索引映射为：

x[c, h, w] → index = c*(H*W) + h*W + w

如果在卷积层实现时用了非标准索引（比如先遍历w再h），flatten后权重矩阵W_fc的列顺序就会错位，导致训练完全失效。我曾见过某开源项目因在卷积循环中把for w in range(W)写在for h in range(H)外层，导致后续全连接层梯度爆炸，调试三天才发现是内存布局错乱。

4.2 Softmax的数值灾难与安全实现

Softmax函数σ(z)_i = exp(z_i) / Σ_j exp(z_j)是分类任务的基石，但exp函数极易引发上溢（overflow）：当z_i很大（如z_i=1000）时，exp(1000)超出浮点数表示范围，变成inf，导致整个Softmax输出为nan。

标准解决方案是减去最大值（max-trick）：

σ(z)_i = exp(z_i - max_z) / Σ_j exp(z_j - max_z)

因为exp(z_i - max_z) ≤ 1，彻底规避上溢。且该变换不改变Softmax输出结果（分子分母同乘exp(max_z)）。

手写实现必须包含此保护：

def softmax_stable(z): # z: (num_classes,) z_shifted = z - np.max(z) # 减去最大值 exp_z = np.exp(z_shifted) return exp_z / np.sum(exp_z) def softmax_backward(y_pred, y_true): # y_pred: softmax输出 (num_classes,), y_true: one-hot标签 (num_classes,) # Softmax + CrossEntropy 的联合梯度 = y_pred - y_true return y_pred - y_true

注意：softmax_backward返回的是∂L/∂z（损失对全连接层输入的梯度），而非∂L/∂y_pred。这是因为在CrossEntropy LossL = -Σ y_true_i * log(y_pred_i)下，经链式法则推导，∂L/∂z = y_pred - y_true。这个简洁公式是深度学习框架高效实现的基础，手写时必须硬编码，而非分步计算∂L/∂y_pred再乘∂y_pred/∂z。

4.3 CrossEntropy Loss的隐式耦合：为什么不用单独实现log

分类任务中，Softmax常与CrossEntropy Loss联合使用。但二者存在强耦合：单独实现Softmax再接-log(y_pred[true_class])，会在y_pred[true_class]极小时触发log(0)下溢（-inf）。而联合实现的CrossEntropyLoss可利用softmax_backward的解析解y_pred - y_true，完全避开log计算。

因此，手撕CNN时，Loss层应直接接收全连接层输出z，内部完成Softmax+CrossEntropy的联合前向与反向：

class CrossEntropyLoss: def forward(self, z, y_true): # z: (num_classes,), y_true: int (true class index) or (num_classes,) one-hot self.z = z self.y_true = y_true # 联合前向：计算 softmax(z)，再计算 -log(softmax(z)[y_true]) # 但为数值稳定，用 log-sum-exp 技巧 z_max = np.max(z) z_shifted = z - z_max log_sum_exp = np.log(np.sum(np.exp(z_shifted))) self.softmax_output = np.exp(z_shifted) / np.sum(np.exp(z_shifted)) # CrossEntropy = -log(softmax(z)[y_true]) = z_max + log_sum_exp - z[y_true] if isinstance(y_true, int): loss = z_max + log_sum_exp - z[y_true] else: loss = z_max + log_sum_exp - np.sum(z * y_true) return loss def backward(self): # 联合反向：∂L/∂z = softmax(z) - y_true (one-hot) if isinstance(self.y_true, int): y_true_onehot = np.zeros_like(self.z) y_true_onehot[self.y_true] = 1.0 else: y_true_onehot = self.y_true return self.softmax_output - y_true_onehot

这个实现将数值稳定性、计算效率和数学正确性融为一体。它证明了一点：“手撕”不是复古，而是用最基础的工具，逼近工业级实现的内在智慧。

5. 反向传播的链式法则实战：从标量损失到每个卷积核权重

5.1 反向传播不是“自动”的，而是“手动追踪”的梯度路径

框架的loss.backward()给人造成一种错觉：梯度是自动计算的。实际上，反向传播是严格遵循链式法则，沿计算图反向传递梯度的过程。手写CNN时，我们必须像侦探一样，为每个中间变量v，明确写出∂L/∂v的表达式，并确保其维度与v匹配。

以卷积层为例，前向计算为：

Y = Conv2d(X, W, b) # Y: (C_out, H_out, W_out) Z = Y + b # b: (C_out,)，广播加法 A = ReLU(Z) # A: (C_out, H_out, W_out)

反向时，已知∂L/∂A（来自上层），需依次求：

∂L/∂Z = ∂L/∂A ⊙ I(Z>0)（ReLU导数）
∂L/∂Y = ∂L/∂Z（加法导数为1）
∂L/∂W和∂L/∂X（卷积导数）

其中∂L/∂W的计算是核心难点。根据卷积定义，Y[c_out,i,j] = Σ_{c_in,k_h,k_w} X[c_in, i*S+k_h, j*S+k_w] * W[c_out,c_in,k_h,k_w]，对W[c_out,c_in,k_h,k_w]求偏导，得到：

∂L/∂W[c_out,c_in,k_h,k_w] = Σ_{i,j} ∂L/∂Y[c_out,i,j] * X[c_in, i*S+k_h, j*S+k_w]

这本质上是输入X与上游梯度∂L/∂Y的互相关（cross-correlation），且∂L/∂W的形状与W完全一致(C_out, C_in, K, K)。

5.2 手写卷积反向传播：三重循环的物理意义

基于上述公式，∂L/∂W的手写实现仍是三重循环，但循环变量含义与前向不同：

外层：遍历输出通道c_out
中层：遍历输入通道c_in
内层：遍历卷积核空间k_h, k_w

对每个(c_out,c_in,k_h,k_w)，遍历所有能用到该权重的输出位置(i,j)，累加∂L/∂Y[c_out,i,j] * X[c_in, i*S+k_h, j*S+k_w]。

def conv2d_backward(dY, X, W, stride, padding): # dY: (C_out, H_out, W_out), X: (C_in, H_in, W_in), W: (C_out, C_in, K, K) C_out, C_in, K, _ = W.shape H_in, W_in = X.shape[1], X.shape[2] H_out, W_out = dY.shape[1], dY.shape[2] # 初始化 dW, dX dW = np.zeros_like(W) dX = np.zeros_like(X) # 计算 dW: 对每个 (c_out, c_in, k_h, k_w)，累加所有 (i,j) 的贡献 for c_out in range(C_out): for c_in in range(C_in): for k_h in range(K): for k_w in range(K): # 遍历所有能用到 W[c_out,c_in,k_h,k_w] 的输出位置 (i,j) # 约束：i*S + k_h < H_in+2P 且 i*S >= 0, 同理 j # 即 i ∈ [0, H_out), j ∈ [0, W_out)，且窗口不越界 for i in range(H_out): for j in range(W_out): # 计算输入窗口中对应位置的坐标 h_in = i * stride + k_h w_in = j * stride + k_w # 检查是否在填充后的有效范围内 if 0 <= h_in < H_in + 2*padding and 0 <= w_in < W_in + 2*padding: # 但 dX 需要映射回原始 X 空间，所以先判断是否在原始范围内 h_orig = h_in - padding w_orig = w_in - padding if 0 <= h_orig < H_in and 0 <= w_orig < W_in: # dW[c_out,c_in,k_h,k_w] += dY[c_out,i,j] * X_pad[c_in,h_in,w_in] # 但 X_pad 未显式存储，需用条件判断 dW[c_out, c_in, k_h, k_w] += dY[c_out, i, j] * X[c_in, h_orig, w_orig] # 计算 dX: 对每个输入位置 (c_in, h_in, w_in)，累加所有用到它的 dY 贡献 # 这需要遍历所有 (c_out, i, j, k_h, k_w) 组合，找到满足 h_in == i*S + k_h - P 的项 # 更高效的做法：对每个 (c_out, i, j)，将 dY[c_out,i,j] 分配到其影响的 X 区域 for c_out in range(C_out): for i in range(H_out): for j in range(W_out): for c_in in range(C_in): for k_h in range(K): for k_w in range(K): h_in = i * stride + k_h - padding w_in = j * stride + k_w - padding if 0 <= h_in < H_in and 0 <= w_in < W_in: dX[c_in, h_in, w_in] += dY[c_out, i, j] * W[c_out, c_in, k_h, k_w] return dW, dX

这段代码的复杂度是O(C_out*C_in*K²*H_out*W_out)，与前向一致。关键洞察在于：dW的计算是“收集”过程（多个dY点贡献到一个dW点），而dX的计算是“分发”过程（一个dY点贡献到多个dX点）。这种对称性体现了卷积运算的数学对偶性。

5.3 权重更新的工程细节：学习率衰减与梯度裁剪的必要性

反向传播得到dW后，权重更新看似简单：W = W - lr * dW。但在手写实现中，必须加入两个工程实践：

学习率衰减（Learning Rate Decay）：固定学习率lr会导致训练前期震荡、后期收敛慢。常用余弦退火：
```
def get_lr(epoch, initial_lr, total_epochs): return initial_lr * 0.5 * (1 + np.cos(np.pi * epoch / total_epochs))
```
梯度裁剪（Gradient Clipping）：CNN训练中，梯度爆炸（gradient explosion）比梯度消失更常见，尤其在深层网络中。当||dW||₂ > clip_value时，将dW缩放为dW * clip_value / ||dW||₂。
```
def clip_grad_norm(grad, max_norm): norm = np.linalg.norm(grad) if norm > max_norm: grad = grad * max_norm / norm return grad
```

我在某次为某图像处理Demo训练小型CNN时，未加梯度裁剪，第3轮训练dW的L2范数就突破1e6，导致权重瞬间变为nan。加入clip_value=1.0后，训练全程稳定。这印证了一个朴素真理：再精妙的数学，也需工程护栏来保障落地。

6. 完整训练循环与调试心法：如何让“手撕”真正跑起来

6.1 训练循环的骨架：数据加载、前向、损失、反向、更新的原子性

一个可运行的手撕CNN，其训练循环必须是原子化的、可打断的。以下是经过千锤百炼的最小可行骨架：

# 初始化网络 conv1 = Conv2dLayer(in_channels=3, out_channels=16, kernel_size=5, stride=1, padding=0) relu1 = ReLULayer() pool1 = MaxPool2dLayer(kernel_size=2, stride=2, padding=0) conv2 = Conv2dLayer(in_channels=16, out_channels=32, kernel_size=5, stride=1, padding=0) relu2 = ReLULayer() pool2 = MaxPool2dLayer(kernel_size=2, stride=2, padding=0) fc1 = LinearLayer(in_features=32*4*4, out_features=128) # 假设输入32x32，两次2x2池化后为4x4 relu3 = ReLULayer() fc2 = LinearLayer(in_features=128, out_features=10) loss_fn = CrossEntropyLoss() # 训练主循环 for epoch in range(num_epochs): total_loss = 0.0 correct = 0 total = 0 for batch_idx, (X_batch, y_batch) in enumerate(train_loader): # X_batch: (N, C, H, W), y_batch: (N,) # 注意：手撕时通常一次处理一个样本，或小批量（N=4/8），避免内存爆炸 # 前向传播（逐层调用） out = X_batch[0] # 取第一个样本，形状 (3,32,32) out = conv1.forward(out) out = relu1.forward(out) out = pool1.forward(out) out = conv2.forward(out) out = relu2.forward(out) out = pool2.forward(out) out = out.flatten() # (32,4,4) -> (512,) out = fc1.forward(out) out = relu3.forward(out) out = fc2.forward(out) # (128,) -> (10,) # 计算损失 loss = loss_fn.forward(out, y_batch[0]) total_loss += loss # 反向传播（逆序调用） dout = loss_fn.backward() dout = fc2.backward(dout) dout = relu3.backward(dout) dout = fc1.backward(dout) # fc1.backward 返回的 dout 是 (512,)，需 reshape 为 (32,4,4) dout = dout.reshape(32, 4, 4) dout = pool2.backward(dout) dout = relu2.backward(dout) dout = conv2.backward(dout) dout = pool1.backward(dout) dout = relu1.backward(dout) dout = conv1.backward(dout) # 更新权重（在每层 backward 中完成） # 例如 conv1.backward 内部调用：self.W -= lr * self.dW # 统计准确率 pred = np.argmax(out) if pred == y_batch[0]: correct += 1 total += 1 print(f"Epoch {epoch}: Loss={total_loss/len(train_loader):.4f}, Acc={correct/total:.4f}")

这个骨架的关键在于：每层的forward和backward方法必须是纯函数式的，不依赖外部状态。conv1.backward(dout)必须返回dX，且self.dW、self.db在方法内完成计算和更新。这种设计让调试像搭积木一样直观：你可以随时在任意forward后打印out.shape，在任意backward后打印dout.shape，确保维度严丝合缝。