第一次认认真真用 PyTorch 里的torch.nn.Conv2d，是从一个报错开始的。当时我照着某个教程写了个图像分类的小网络，把一张经过预处理的图片直接丢进model(img)，结果控制台冒出一行冷冰冰的提示：Expected 4D input, got 3D input。我那会儿人都是懵的，明明图片是 224×224 的彩色图，尺寸没毛病，凭什么不认？后来才明白，Conv2d要的不是一张"图"，而是一个四维张量——它把整个 batch 的图片打包在一起算，你要是没给它 batch 这个维度，它就不知道从哪里开始卷。
这篇内容就围绕Conv2d这个函数展开，适合两类人看：一类是刚入门 PyTorch、对着文档里一堆参数觉得"每个字都认识但连起来不知道在干嘛"的新手；另一类是已经写过一点网络、但主要靠抄代码，真要让手写卷积层就发怵的同学。写之前我把 PyTorch 官方文档、源码里的实现细节，以及实际调试中踩过的坑都过了一遍，所以这篇文章不会只停留在"函数签名长什么样"的层面，而是会把每个参数背后的逻辑、输入输出尺寸怎么算、数据怎么组织、哪些地方最容易出错都讲透。
1. 一个报错引发的思考：conv2d 到底在等什么数据
1.1 图片在 PyTorch 里的真实样子
先说结论：torch.nn.Conv2d要求输入必须是四维张量，形状是(N, C, H, W)。用大白话翻译就是：N 代表这一批有几张图（batch size），C 代表通道数（灰度图是 1，彩色图是 3），H 是高度，W 是宽度。
但很多初学者最开始接触图片时，脑子里只有"高、宽、颜色通道"这三个概念，也就是日常说的 HWC 顺序。如果用 OpenCV 的cv2.imread读图，拿到的数组维度就是(H, W, 3)，三个维度；如果用 PIL 读图，虽然也带通道，但同样不是 PyTorch 能直接吃的格式。
当初让我对维度问题彻底开窍的，是手动走了一遍数据转换的流程。下面这个ToTensor转换过程值得自己敲一遍，用代码把维度变来变去：
from PIL import Image import torch from torchvision import transforms # 读一张彩色图 img = Image.open("demo.jpg") print(type(img)) # <class 'PIL.JpegImagePlugin.JpegImageFile'> # 转换成 PyTorch 张量 tensor_img = transforms.ToTensor()(img) print(tensor_img.shape) # 输出：torch.Size([3, 224, 224]) # 注意：通道被挪到了最前面，变成了 C × H × W这一步做完能得到三维张量(3, 224, 224)，但Conv2d仍然不认，因为它还要一个 batch 维度。常见的做法是用unsqueeze(0)在最前面加一维，或者用tensor_img[None]，让维度变成(1, 3, 224, 224)：
batch_img = tensor_img.unsqueeze(0) print(batch_img.shape) # 输出：torch.Size([1, 3, 224, 224])这种"加维度"的操作看起来只是形式上的变化，实际上关系到 PyTorch 整个张量运算的规范。你可以理解为Conv2d内部是按 batch 里的每一张图单独计算卷积的，如果没有 batch 这个维度，它内部的循环逻辑就无处下手。
1.2 为什么 PyTorch 偏偏选 NCHW 而不是 NHWC
很多从 TensorFlow 过来的人会疑惑：TensorFlow 默认用 NHWC，PyTorch 却用 NCHW，这不折腾人吗？
其实这是有历史原因的。PyTorch 底层的张量存储方式更偏向 NCHW 的布局，在 GPU 上做卷积运算时，把通道放在最前面可以让显存访问模式更规整，尤其在使用 cuDNN 等底层库时，NCHW 往往能拿到更好的性能。而且 PyTorch 最早期的设计参考了大部分学术代码的习惯，论文里写卷积层的形状也基本都是(N, C, H, W)。
不过这里要提醒一句：NCHW 和 NHWC 在纯 PyTorch 的张量层面其实只是permute一下的问题，关键是要在数据进入网络的入口统一处理好。比如 PyTorch 自带的torchvision.datasets.ImageFolder配合transforms.ToTensor()，出来的就是(C, H, W)；而如果你自己用 OpenCV 读图再转 Tensor，那就要手动torch.from_numpy(img.transpose(2, 0, 1))。也就是说，你用什么库读图，就会天然地得到什么顺序的数组，这时候最保险的做法是在进入模型之前打印一行x.shape确认。
我自己习惯在 dataset 的__getitem__函数最后强制检查一遍形状，写多了就会形成条件反射，看到3x224x224就知道是 HWC 转 CHW 时漏了一步。
2. 参数逐个拆解：通道数、卷积核、步长和填充到底怎么配
2.1 in_channels 和 out_channels：通道数不是玄学
in_channels是输入张量的通道数，out_channels是这一层卷积输出的通道数。对一层卷积来说，in_channels必须和输入张量的C相等，否则直接报错；out_channels则是你自己决定的超参数，它决定了这一层用了多少个卷积核。
out_channels的取值，在经典网络里往往呈现一种规律：浅层少、深层多。比如 VGG16 里，第一个卷积层输出 64 个通道，后续层依次翻倍到 128、256、512，因为浅层主要提取边缘、颜色这些基础特征，特征图空间尺寸大，通道数不宜过多；深层特征图尺寸变小了，但需要更丰富的语义信息，所以通道数要涨上去。
我自己在做小数据集分类时，习惯从 32 或 64 起步，因为 224×224 的图直接上 128 通道，显存压力立刻就上来了。这里有一个经验公式可以帮你粗估参数规模：某一层卷积的参数量等于in_channels × out_channels × kernel_size × kernel_size（暂时忽略 bias）。算一下就知道，3 通道输入、64 个 3×3 卷积核，参数量只有 1728；但如果从 512 通道变成 512 通道，同样是 3×3 卷积，参数量直接来到 235 万。通道数一多，内存和计算量都会明显增长。
2.2 kernel_size、stride、padding：空间尺寸的三驾马车
这三个参数共同决定了卷积层输出的特征图尺寸。
kernel_size是卷积核的大小，常用的是 3×3、5×5、7×7。小卷积核叠加的效果往往优于单个大卷积核，比如两个 3×3 卷积堆叠，感受野相当于一个 5×5 卷积，但参数量更少、非线性更强，这就是 VGG 网络的基本设计逻辑。
stride是卷积核每次移动的步长。stride=1 时输出尺寸基本不变（配合 padding），stride=2 时特征图尺寸减半，这是下采样的常用方式。相比直接使用 MaxPool，用 stride=2 的卷积下采样现在越来越普遍，因为它本身带有可学习的参数，可以让网络在降采样过程中保留更多有用的信息。
padding则是在输入周围补零。它的核心作用是控制输出尺寸，避免特征图在每层卷积之后都肉眼可见地缩小。比如一个 224×224 的输入，如果连续用 3×3 卷积、stride=1、padding=0，那么每过一层就缩小 2 个像素，10 层之后就变成 204×204，很多设计好的网络结构会因此提前被截断。
下面这段代码展示了这三个参数如何共同影响输出：
import torch.nn as nn conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1) conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=2, padding=1) conv3 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, stride=1, padding=2)配合不同的输入尺寸，你会发现有的组合能让输出尺寸和输入完全一样，有的则会减半，关键在于 padding 的选择是否合理。
2.3 dilation、groups、bias：容易被忽略但影响很大的参数
dilation中文叫空洞卷积，它是在卷积核的元素之间插入空洞，从而扩大卷积感受野，但参数量不变。比如dilation=2的 3×3 卷积，实际覆盖范围相当于 5×5，常用于语义分割任务（如 DeepLab 系列）。这个参数新手阶段用得少，但理解它有助于后面看懂一些经典模型的代码。
groups是分组卷积。默认值是 1，就是普通卷积；如果是 2，输入通道和输出通道会被分成两组，各自独立做卷积。分组卷积可以大幅减少参数量和计算量，早期的 AlexNet 受限于当时的 GPU 显存，就用了分组卷积。但需要注意：分组卷积会切断不同组之间的信息交流，所以很多实际应用会在分组卷积之后接一个 1×1 卷积来融合通道信息（这就是 ShuffleNet、MobileNet 等轻量网络的核心思想）。
bias默认是 True，即每个输出通道有一个可学习的偏置项。卷积是线性运算"乘加"，偏置则提供了平移能力。虽然 BatchNorm 层通常会在卷积之后对数据做归一化，而 BatchNorm 本身自带平移参数，所以理论上可以抵消 bias 的作用，但在实际网络中，除非你能确认后面一定跟 BatchNorm，否则不建议贸然去掉 bias，保持默认 True 是最稳妥的。
3. 输出尺寸的计算公式与那些算不到整数的时刻
3.1 公式本身并不难，难的是理解为什么长这样
Conv2d输出尺寸的官方公式是：
[ H_{out} = \left\lfloor \frac{H_{in} + 2 \times padding - dilation \times (kernel_size - 1) - 1}{stride} + 1 \right\rfloor ]
宽度方向的公式完全一样，把 H 换成 W 即可。第一次看到这个公式的人很容易被 dilation 那个部分吓到，但只要你把 dilation=1 代进去，它就会退化成熟悉的：
[ H_{out} = \frac{H_{in} + 2 \times padding - kernel_size}{stride} + 1 ]
注意这里dilation × (kernel_size - 1)中的 dilation 其实就是普通卷积（dilation=1）时，卷积核实际扩展后的尺寸是kernel_size；dilation=2 时，实际覆盖范围变成了kernel_size + (kernel_size-1) × (dilation-1)，即 3×3 变成了等效 5×5。
我个人在不用写代码的情况下，快速估算输出尺寸的心算顺序是这样的：
- 先算卷积核的有效尺寸
effective_k = kernel_size + (kernel_size - 1) * (dilation - 1) - 再算
H_in + 2 * padding - effective_k - 除以上
stride，如果除不尽，向下取整 - 最后加 1
3.2 手算验证：从 224×224 到 112×112
举个最常见的例子。输入 224×224，想通过一层卷积把尺寸减半到 112×112，该怎么配参数？
如果使用stride=2，kernel_size 选 3，padding 则需要认真算一下：为了保证整除，我们需要224 + 2 × padding - 3能被 2 整除。224 和 3 都是奇数差，加 2×padding 后整体奇偶性和 padding 相关。最简单的配法是padding=1，这样224 + 2 - 3 = 223，除 2 得 111.5，向下取整再 +1 就是 112，刚好减半。
类似地，如果用kernel_size=3, stride=2, padding=0，那么(224 - 3)/2 + 1 = 111.5，向下取整是 111，再加 1 得 112，其实也是 112。但两边不对称，右侧的信息全部丢失了，不如 padding=1 的方式对称。
如果你希望输出尺寸和输入一样，也就是典型的"ResNet 基本块"用法，那公式就更简单：padding = (kernel_size - 1) // 2。kernel=3 就 padding=1，kernel=5 就 padding=2，kernel=7 就 padding=3，注意 stride 必须为 1，否则无法等大。
3.3 实际验证：代码里的形状打印
公式算归算，实战里我几乎不会手算每个尺寸，而是写一行打印，或者直接用 PyTorch 的summary。但你要真想知道代码跑出来的结果和公式是否对得上，下面这段可以试一下：
import torch import torch.nn as nn x = torch.randn(2, 3, 224, 224) conv = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=2, padding=1) y = conv(x) print(y.shape) # 输出：torch.Size([2, 32, 112, 112])如果你把 stride 改成 3，那就是另一个故事了，输出尺寸会变成(224 + 2 - 3)/3 + 1 = 75.33，向下取整 75，再加 1 得 76，实际要看到的是76。这种情况特征图减少了很多，信息损失比较剧烈，所以除非有明确的下采样需求，一般不会用 stride=3。
关于padding="same"，PyTorch 从 1.9 版本开始支持padding="same"和padding="valid"这两个字符串写法。same的目的是让输出尺寸和输入尺寸相等（在 stride=1 前提下），但 PyTorch 的实现并不是简单的对称填充，而是会自动计算最小需要的填充量，如果填充量为奇数，它会多补在右侧和下方。这个细节你有没有想过？很多人没看源码，以为"same"就是左右各补一半。实际上，当你输入尺寸为偶数、卷积核为偶数时，这种非对称填充会造成 1 像素的偏移，对一些对位置敏感的任务（如目标检测）会产生影响，所以最好还是手动指定padding。
4. 从单层到多层：搭一个能跑通的小型卷积网络
4.1 定义输入：怎么模拟一张真实的图片 batch
为了把前面的参数全部串起来，这里搭建一个用于 MNIST 手写数字分类的极简卷积网络。MNIST 图像尺寸是 28×28，单通道。数据从torchvision.datasets.MNIST读取时，transforms.ToTensor()已经把形状转换成了(1, 28, 28)，而 DataLoader 会自动把多个样本堆叠成(B, 1, 28, 28)。
如果你没有真实数据，也可以用torch.randn模拟一个 batch，方便快速验证网络结构：
import torch import torch.nn as nn # 模拟一个 batch 为 8 的灰度图 x = torch.randn(8, 1, 28, 28) print(x.shape) # torch.Size([8, 1, 28, 28])4.2 网络结构与每一层的 shape 变化
接下来定义一个小网络，包含两层卷积、ReLU 激活、最大池化，最后接全连接层：
class SimpleCNN(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1) self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1) self.pool = nn.MaxPool2d(kernel_size=2, stride=2) self.fc = nn.Linear(32 * 7 * 7, 10) def forward(self, x): x = torch.relu(self.conv1(x)) x = self.pool(x) x = torch.relu(self.conv2(x)) x = self.pool(x) x = x.view(x.size(0), -1) x = self.fc(x) return x让我把每一层的形状变化手动推演给你看，这一步值得你自己在纸上画一遍：
| 层 | 输入形状 | 输出形状 | 计算说明 |
|---|---|---|---|
| Conv2d(1, 16, k=3, s=1, p=1) | (8, 1, 28, 28) | (8, 16, 28, 28) | 尺寸不变，通道变 16 |
| MaxPool2d(k=2, s=2) | (8, 16, 28, 28) | (8, 16, 14, 14) | 空间尺寸减半 |
| Conv2d(16, 32, k=3, s=1, p=1) | (8, 16, 14, 14) | (8, 32, 14, 14) | 尺寸不变，通道变 32 |
| MaxPool2d(k=2, s=2) | (8, 32, 14, 14) | (8, 32, 7, 7) | 空间尺寸减半 |
| Flatten 展平 | (8, 32, 7, 7) | (8, 32×7×7) | view 展开为一维 |
| Linear | (8, 1568) | (8, 10) | 输出 10 类分数 |
这里有一个初学者特别容易踩的坑：self.fc = nn.Linear(32 * 7 * 7, 10)中的7是手动算出来的，如果前面的卷积或池化参数改了，这里的7就必须跟着改。在很多开源项目里，这种硬编码会让新手改网络结构的时候直接懵掉。比较稳妥的方法是，在 forward 里直接x = x.view(x.size(0), -1)，并且在搭建完网络后先用一个假的输入跑一遍summary，确认 shape 没对错。
4.3 训练前的前向测试
每次搭建完新网络，我的习惯是用一个假的输入先跑一遍前向，再决定要不要进入训练循环。这一步可以拦截大量低级错误：
net = SimpleCNN() fake_x = torch.randn(4, 1, 28, 28) out = net(fake_x) print(out.shape) # torch.Size([4, 10])如果这里输出了(4, 10)，说明网络结构基本没问题，后面再谈训练资源优化的事。
5. 我在实际使用中踩过的 conv2d 高频坑
5.1 三维输入直接丢进模型
这是最经典的报错，也是我开头提到的：Expected 4D input, got 3D input。原因无非是数据集返回的单张图没有加 batch 维度。解决办法是在forward入口或者训练代码里确认输入维度。数据如果是经过DataLoader生成的，正常都会带 batch 维；但如果你在测试阶段单张推理，或者自己手动写了 dataset 的__getitem__，就很容易丢掉这一维。
排查方式很直接：在 forward 第一行加print(x.shape)，看到torch.Size([1, 3, 224, 224])这种才会放心往下走。
5.2 in_channels 对不上预训练权重
加载一个在 ImageNet 上预训练好的 ResNet 时，第一层卷积的in_channels=3。如果用的是单通道灰度图，直接加载预训练模型就会报size mismatch for conv1.weight。很多人的第一反应是把灰度图复制三次变成三通道，这个办法有效，但其实是绕路。更优雅的方案是修改第一层卷积的输入通道数，比如把原来nn.Conv2d(3, 64, ...)替换成nn.Conv2d(1, 64, ...)，要么直接用weight.mean(dim=1, keepdim=True)对预训练权重做通道平均初始化。
这里要特别注意：如果只是把通道数从 3 改成 1，但加载时没有处理权重，那依然会报错。建议显式地新建一个卷积层，然后手动拷贝权重，这样既能看到日志，也不会在训练时莫名其妙地丢失前面的预训练信息。
5.3 kernel_size 传成元组的踩坑
nn.Conv2d(3, 16, kernel_size=(3, 3))是合法的，kernel_size=3也合法。但如果你脑子里想的是 3×3，却写成了kernel_size=(3, 1)，那就会得到一个不对称的卷积核，输出尺寸在不同方向上的变化也不一样。这个问题在调试中不太容易发现，因为不会报错，只会让网络表现变差。
遇到这种情况，我会在做网络结构审查时特意关注每个卷积层的kernel_size，因为这种非对称卷积在 MobileNet 等轻量网络里是故意设计的，但在普通分类网络里大多是误写。
5.4 显存溢出：你以为只和 batch_size 有关，其实通道数同样致命
显存溢出的排查很多人会先从 batch_size 下手，但在 Conv2d 的使用中，通道数、特征图尺寸、dilation 都会对显存产生直接影响。举个例子：输入(32, 64, 112, 112)，经过一个输出 128 通道的 3×3 卷积，光这一层的输出特征图就要占32 × 128 × 112 × 112 × 4 bytes ≈ 200 MB。如果后面还没有 BatchNorm 和激活函数的存储，很快就能堆到单卡放不下的程度。
解决办法有几种：调小 batch_size、减小输入分辨率、减少中间通道数、或者使用混合精度训练（AMP）。但在做这些操作之前，最好先用torch.cuda.max_memory_allocated()查看峰值显存，确认瓶颈到底在哪一层。
5.5 卷积层权重初始化不当导致收敛慢
PyTorch 默认的卷积权重初始化方式其实对大多数网络是够用的，但它不是万能的。比如在网络非常深、或者用了某些特殊激活函数（如nn.LeakyReLU）时，默认初始化可能导致深层梯度消失或爆炸。如果你发现 loss 一直不降，可以试试手动初始化：
def init_weights(m): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.zeros_(m.bias) net.apply(init_weights)这里kaiming_normal_是专门针对 ReLU 类激活函数设计的初始化方式，它能根据输入通道数自动缩放权重方差，避免前向传播时逐层放大或缩小。虽然 PyTorch 官方在Conv2d的默认实现里已经考虑了 ReLU 场景，但当你使用残差结构或特别深的网络时，显式初始化仍然是一道有效的保险。
6. 排查与调试：让 Conv2d 的表现可预期
6.1 用 torchinfo 打印每一层的输出形状
如果还在手动算每一层的 shape，那我建议试试torchinfo这个库。它不是 PyTorch 官方库，但在社区里几乎成了标配。用法很简单：
pip install torchinfofrom torchinfo import summary net = SimpleCNN() summary(net, input_size=(4, 1, 28, 28))它会把每一层的输出张量形状、参数量、显存占用都列出来。对比手动打印，summary对网络结构的整体性把控强很多，尤其适合排查卷积层和全连接层之间的维度衔接。
6.2 用 hook 查看中间特征图
有时候光看 shape 还不够，你还想知道某一层的激活值分布是否正常。比如过深的网络可能导致大量激活值为 0，这时可以通过注册 forward hook 来打印中间特征：
activation = {} def hook_fn(name): def fn(module, input, output): activation[name] = output.detach() return fn net.conv1.register_forward_hook(hook_fn("conv1_output")) net(torch.randn(1, 1, 28, 28)) # 查看激活值统计 feat = activation["conv1_output"] print(feat.shape) print(feat.mean().item(), feat.std().item())如果某一层输出的均值长期接近 0，而且标准差很小，说明信息流被阻断或饱和了，这通常是初始化不当、学习率过高或网络结构有问题。调试时可以多打印几个中间层的统计，形成一条"梯度/激活值的传导链路"，定位到具体是哪一层开始异常。
6.3 从单张图片 start：先过拟合再谈泛化
这个习惯让我省下了很多盲目调参的时间。当你搭好一个含Conv2d的网络时，先不要急着上完整数据集，而是只取十几个样本，去训练模型，目标是把这批样本的 loss 压到接近 0。如果十几个样本都无法拟合，那说明网络结构有 bug、学习率设置不合理或者数据预处理有问题。一旦能过拟合，再上完整数据训练，这时候出现的问题才可能是"泛化"层面的，而不是"代码 bug"层面。
这一步说白了就是把"模型能不能学会"和"模型泛化好不好"分成两个阶段排查。后者需要大量的实验经验和运气，前者则完全可以通过代码审查和 Debug 解决。
6.4 留意 evaluation 模式的差异
最后提一个容易忽略的细节：如果网络里用了BatchNorm，那么在验证阶段一定要调用model.eval()，否则 BatchNorm 会继续用当前 batch 的统计量做归一化，导致同样的图片在训练和推理时输出结果不同，而且这种差异往往只在多卡或 batch 较小时明显。Conv2d本身在 train/eval 模式下行为是一致的，但它后面的 BatchNorm 不是。每次从训练切换到推理，都需要执行model.eval()，再配合torch.no_grad()关掉梯度计算，这样既省显存，输出也更稳定。
7. 性能层面的两个进阶经验
7.1 合并小卷积层：减少 kernel 调度的开销
如果网络里连续跟了多个小卷积层，比如Conv2d(64, 64, 3)接BatchNorm接ReLU，再重复一次，可以尝试把两层卷积合并成一层，在训练时保持 BatchNorm 不变。这个操作能减少一次独立的 kernel 启动，对训练吞吐有一定帮助，尤其是在小 batch 场景下特别明显。
不过这种合并要满足一个前提：两层卷积之间没有非线性激活，也就是纯粹的线性变换叠加，合并后数学上是等价的。如果有激活函数，那合并就不成立了。
7.2 用 torch.backends.cudnn.benchmark 在 CNN 上开启自动调优
如果你的输入尺寸在训练过程中基本保持不变（这是绝大多数图像分类任务的情况），设置torch.backends.cudnn.benchmark = True可以让 PyTorch 在第一次迭代时自动测试多种卷积算法，选择最快的那个并缓存起来。这对于常规的Conv2d层是实打实的加速，尤其在 GPU 上。但如果你在训练中会频繁改变输入尺寸，比如做目标检测或者动态 padding，那这个选项反而会因为频繁重新测试算法而变慢，此时保持默认 False 更合适。
代码上就是在训练脚本开头加一句：
torch.backends.cudnn.benchmark = True就这么简单。但我要补充一句，它的收益在性能瓶颈确实在卷积计算时最明显，如果你的网络里大量时间都花在数据读取、归一化或者全连接层，那么这个加速可能感知不强。
8. 写在最后：从函数到网络的思维转变
回头看看整个使用Conv2d的过程，我发现最大的障碍从来不是记不住参数，而是没有从"图像"的思维转换成"张量"的思维。图像在你脑中是高、宽、颜色通道，但到了 PyTorch 里，它永远是一个(N, C, H, W)的四维张量，所有的卷积、池化、归一化操作都是围绕这个四维形状展开的。一旦接受了这个设定，再看到in_channels、out_channels、stride、padding这些参数，你就会自然地思考它们如何改变这个张量，而不是去死记公式。
我从第一次被 3D input 报错拦住，到现在能比较流畅地设计、调试、优化带卷积结构的网络，期间最大的心得就是：每改一个参数，都跑一次形状打印；每搭一个网络，都先过拟合小样本；每次换数据，都在入口处确认维度。这些习惯看起来琐碎，但它们在关键时刻能把你从"玄学调参"里拉回来。
如果你现在正被某个Conv2d相关的报错或者维度问题卡住，我建议你先别急着删层减通道，而是把输入形状和网络结构完整打印出来，对照这篇文章里的计算逻辑一步步推。多数情况下，问题会在你认真推演一次 shape 之后变的非常明显。
