手头这个 ConvNet 模型，名字听着朴素，但真要从零把它调到能跑、能收敛、能上线，中间的门道比教科书上写的多得多。卷积神经网络这几个字被讲烂了，可我发现身边不少同行的困惑并不在"什么是卷积"，而在于"为什么我的模型 loss 死活不降""为什么验证集准确率永远卡在随机水平""为什么训练时好好的，导出后精度掉一大截"。这篇就按我自己搭 ConvNet 的完整路径来写：先把结构设计的账算清楚，再把手写代码贴出来，最后把踩过的坑一个个摆上台面。适合刚接触卷积神经网络的入门者对照着跑一遍，也适合已经能训模型、但总在调参和部署环节反复翻车的人拿去查漏补缺。全文不堆公式吓人，该给的计算过程一个不少，该给的经验判断直接给结论。代码以 PyTorch 为准，换框架思路一致。

1. 先把 ConvNet 这件事拆开看

1.1 为什么图像任务不能直接上全连接

很多人学卷积神经网络的第一课就是"全连接参数量爆炸"，但爆炸到什么程度，多数人没算过。拿一张 224×224 的彩色图举例，展平后是 224×224×3 = 150528 维。如果下一层只做 1024 维的全连接，光这一层的权重就是 150528×1024 ≈ 1.54 亿个参数，按 float32 存要接近 600MB。这还只是第一层，网络稍微深一点，显存直接原地起飞。

参数量只是表面问题，更致命的是全连接层丢掉了图像的空间结构。把一张图展平成向量之后，左上角的像素和右下角的像素在输入向量里是平等排列的，模型完全不知道谁挨着谁。而图像的信息恰恰藏在邻域关系里——边缘是相邻像素的差值，纹理是局部区域的重复模式。全连接层要从零学出"相邻"这个概念，等于让模型自己去悟空间拓扑，效率极低。

卷积神经网络的两个设计直接解决了这两件事：局部连接让每个神经元只看一小块区域，权重共享让同一个卷积核在整张图上滑动复用。这两个约束一加，参数量立刻降几个数量级，同时把"局部性"和"平移等变"作为先验知识硬编码进了网络结构里。这就是为什么在图像任务上，一个几百万参数的 ConvNet 能打赢参数多几十倍的全连接网络。

1.2 卷积层到底在学什么

我倾向于把卷积核理解成一组可学习的"模板探测器"。浅层学到的通常是最基础的图案：水平边、垂直边、对角边、颜色斑块。这些不是人为设计的，是梯度下降自己找出来的，但几乎所有的网络都会收敛到类似的东西，因为自然图像的统计规律就摆在那里。

往深处走，第二层、第三层开始组合浅层的边缘，形成角点、弧线、纹理；再深就能拼出物体部件，比如轮子、眼睛、窗户。这个层级组合的观察最早来自对网络可视化的研究，现在已经是共识。理解这一点很关键，它解释了为什么堆叠小卷积核比用一个大卷积核更有效：两层 3×3 的感受野等于一层 5×5，但中间多了一次非线性激活，表达能力更强，而且参数更少。

还有一个容易被忽略的点：卷积核学的是相对模式而不是绝对位置。同一个"猫耳朵"检测器无论在图像左上角还是右下角，用的都是同一组权重。这种性质叫平移等变，它对图像任务几乎是白送的先验，也是 ConvNet 在小数据量下仍能工作的根本原因之一。

1.3 不同基础的人该从哪里切进去

如果你刚入门，建议跳过所有数学推导，先照着第 3 节的代码把模型跑通一次，看着 loss 曲线往下走，建立手感，再回头补第 2 节里的尺寸和感受野计算。反过来，如果你已经能训模型但总是调不好，直接跳到第 4 节的问题排查表，那里列的现象和解法基本覆盖了九成翻车场景。

至于已经要落地部署的，第 5 节的量化和预处理一致性检查是必读项，我见过太多次"离线 92%、上线 71%"的事故，最后查出来全是预处理没对齐这种低级问题。

2. 核心组件拆解与参数量账本

2.1 卷积层的四个超参数怎么定

一个卷积层的输出尺寸由输入尺寸 I、卷积核大小 K、填充 P、步长 S 共同决定，公式是：

O = floor((I + 2P - K) / S) + 1

这个公式必须背下来，因为调网络的时候九成的 shape 报错都源于它。举几个实战里最常用的组合：

我个人的习惯是：主干网络里所有保持尺寸的卷积统一用 K=3, S=1, P=1，需要下采样时用 S=2 而不是加池化层。理由是用 stride 做下采样比 max pooling 保留的信息多一些，而且能减少一层的内存开销。当然这是经验偏好，用池化也没问题，只是别在同一段网络里两种风格混着来，容易把尺寸算乱。

参数量的公式是K × K × C_in × C_out + C_out（含偏置）。计算量（乘加次数）近似为H_out × W_out × C_out × C_in × K × K。这两个数要养成随手估算的习惯，遇到显存不够或者推理太慢，第一反应应该是算账而不是瞎调。

2.2 感受野：为什么三连 3×3 比一个 7×7 划算

感受野指的是输出特征图上一个点对应原图多大区域。递推公式：

RF_i = RF_{i-1} + (K_i - 1) × stride_cumprod_{i-1}

其中stride_cumprod是前面所有层步长的累乘。手动算一遍三个 3×3 卷积（stride 全为 1）叠加的感受野：第一层 RF=3，第二层 RF=3+(3-1)×1=5，第三层 RF=5+(3-1)×1=7。所以三个 3×3 串联等效于一个 7×7 的感受野。

现在算参数账。假设输入输出通道都是 C：

• 三个 3×3：3 × (3×3×C×C) = 27C²
• 一个 7×7：7×7×C×C = 49C²

参数量少了 45%，而且中间多了两次 ReLU，非线性更强。这就是 VGG 之后几乎所有网络都用小核堆叠的原因。但要注意别走极端——感受野不能只靠堆 3×3 无限扩，层数太多会有梯度问题和计算效率问题，所以现代网络会用 stride=2 的卷积快速扩大感受野，再配合残差连接保证梯度能传回去。

提示：算感受野时别忘了 stride 的累乘效应。一个 stride=2 的层之后，后面每增加一个 3×3，感受野增量会翻倍，很多人在这一步算错，导致对模型"能看到多大范围"判断失准。

2.3 归一化、激活、池化的搭配取舍

**批归一化（BatchNorm）**几乎是 ConvNet 的标配，放在卷积之后、激活之前，即Conv → BN → ReLU。它的作用是把每层输入拉回稳定分布，允许用更大的学习率，收敛明显更快。但有两个坑：一是 batch size 很小时（比如小于 8）统计量不准，这时宁可换成 GroupNorm；二是推理时必须切到 eval 模式，否则会用当前 batch 的统计量，结果飘忽不定。

激活函数现在基本默认 ReLU 系列。ReLU 便宜、不会饱和，但存在"死亡神经元"问题——某个通道的输入长期为负，梯度恒为 0，这个通道就废了。想稳一点可以用 LeakyReLU（负半轴斜率 0.01）或者 GELU（计算稍贵但平滑）。我不建议在小模型上折腾 Swish 这类，收益不明显。

池化的选择上，全局平均池化（GAP）已经取代了大部分全连接分类头，参数量直接归零，还能缓解过拟合。中间层的下采样我更倾向用 stride 卷积，但如果你要做显著性检测这类需要保留精确位置的任务，max pooling 的表现会更稳一些。

2.4 一张表看清主流积木的成本

深度可分离卷积的省法值得单独说一句：它把标准卷积拆成"逐通道空间卷积 + 逐点通道混合"两步，计算量降到原来的约1/C_out + 1/K²。当 C_out=256、K=3 时，大约是原来的 1/9 到 1/8。代价是精度通常会掉 1 到 2 个点，靠后续的训练技巧和通道数调整能补回来大半。

3. 从零搭一个能跑起来的 ConvNet

3.1 数据管线：先保证喂进去的东西是对的

我见过太多"模型不收敛"的案例，最后问题出在数据上而不是网络上。开工前先把这几件事确认死：

1. 标签和文件名的映射关系。写个脚本随机抽 20 张图打印出来人工核对，这一步花五分钟，能省两天。
2. 训练和验证的划分不能有泄漏。同一个视频抽出来的帧、同一个物体的多角度照片，必须整组划分，不能随机打散，否则验证集准确率虚高得离谱。
3. 归一化参数要固定。要么用数据集自己统计的均值和方差，要么用通用的 ImageNet 值（mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]），关键是训练、验证、推理三处必须完全一致。

数据增强在小数据集上是刚需，我的默认组合是：随机裁剪（先 resize 到稍大尺寸再裁）、随机水平翻转、轻度的颜色抖动。更强的 RandAugment、MixUp、CutMix 在数据量少于一万张时收益明显，但要注意 MixUp 之后损失函数得换成软标签版本，别傻乎乎地还用交叉熵硬标签。

3.2 网络结构代码

下面这个结构是我常用的基线，够简单也够能打，跑中小规模数据集完全够用：

import torch import torch.nn as nn class ConvBlock(nn.Module): def __init__(self, c_in, c_out, stride=1): super().__init__() self.conv = nn.Conv2d(c_in, c_out, 3, stride, 1, bias=False) self.bn = nn.BatchNorm2d(c_out) self.act = nn.ReLU(inplace=True) def forward(self, x): return self.act(self.bn(self.conv(x))) class ConvNet(nn.Module): def __init__(self, num_classes=10, width=32): super().__init__() # 输入 3x224x224 self.stem = ConvBlock(3, width, stride=2) # 112 self.stage1 = nn.Sequential( ConvBlock(width, width), ConvBlock(width, width * 2, stride=2) # 56 ) self.stage2 = nn.Sequential( ConvBlock(width * 2, width * 2), ConvBlock(width * 2, width * 4, stride=2) # 28 ) self.stage3 = nn.Sequential( ConvBlock(width * 4, width * 4), ConvBlock(width * 4, width * 8, stride=2) # 14 ) self.stage4 = nn.Sequential( ConvBlock(width * 8, width * 8), ConvBlock(width * 8, width * 8) # 14 ) self.head = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Dropout(0.2), nn.Linear(width * 8, num_classes) ) def forward(self, x): x = self.stem(x) x = self.stage1(x) x = self.stage2(x) x = self.stage3(x) x = self.stage4(x) return self.head(x)

几个设计上的说明。bias=False是因为紧跟着 BN，偏置会被 BN 的减均值操作抵消掉，纯属浪费参数。AdaptiveAvgPool2d(1)让网络对输入尺寸不敏感，换分辨率不用改结构。width这个系数方便你快速缩放模型大小，width=32 时整个网络大约 300 万参数，width=64 就到 1200 万左右，按任务难度和显存挑。

如果数据量小、层数又想深一点，建议加残差连接，否则超过 20 层之后训练会明显变难：

class ResBlock(nn.Module): def __init__(self, c): super().__init__() self.body = nn.Sequential( ConvBlock(c, c), nn.Conv2d(c, c, 3, 1, 1, bias=False), nn.BatchNorm2d(c) ) self.act = nn.ReLU(inplace=True) def forward(self, x): return self.act(x + self.body(x))

3.3 训练循环与学习率策略

import torch.optim as optim from torch.optim.lr_scheduler import CosineAnnealingLR, LinearLR from torch.optim.lr_scheduler import SequentialLR from torch.cuda.amp import autocast, GradScaler device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = ConvNet(num_classes=10, width=32).to(device) criterion = nn.CrossEntropyLoss(label_smoothing=0.1) base_lr = 1e-3 * (batch_size / 256) # 线性缩放规则 optimizer = optim.AdamW(model.parameters(), lr=base_lr, weight_decay=5e-2) warmup = LinearLR(optimizer, start_factor=0.01, total_iters=5) cosine = CosineAnnealingLR(optimizer, T_max=epochs - 5, eta_min=1e-6) scheduler = SequentialLR(optimizer, [warmup, cosine], milestones=[5]) scaler = GradScaler() for epoch in range(epochs): model.train() for imgs, labels in train_loader: imgs, labels = imgs.to(device), labels.to(device) optimizer.zero_grad(set_to_none=True) with autocast(): loss = criterion(model(imgs), labels) scaler.scale(loss).backward() scaler.unscale_(optimizer) torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0) scaler.step(optimizer) scaler.update() scheduler.step()

学习率这块有几个值得说的经验。线性缩放规则是 batch size 翻倍、学习率也翻倍，但这个规则在 batch 超过 1024 之后就失效了，得改用 LARS 或者干脆不放大。warmup 不要省，尤其是加了 BN 的网络，前几个 epoch 学习率从很小的值慢慢爬升，能避开初期梯度爆炸。weight decay 用 AdamW 时给到 5e-2 不算大，因为 AdamW 的解耦实现让衰减只作用在权重上，和自适应梯度分开，这是和 Adam 里加 L2 惩罚的本质区别。

混合精度（AMP）能省 40% 左右的显存、提 20%~30% 的速度，代价是需要 GradScaler 处理梯度下溢。注意一点：scaler.unscale_必须在梯度裁剪之前调用，否则裁的是被缩放过的梯度，等于没裁。

3.4 训练现场该盯哪几个指标

只看 loss 是远远不够的。我每次开训会同时盯四个数：

• 训练 loss：平滑后的趋势应该单调下降，短期抖动正常，连续 200 步不降要警惕。
• 验证 loss：和训练 loss 的差值就是过拟合的度量。差值持续扩大且验证 loss 开始上升，说明该停或者该加正则了。
• 梯度范数：裁剪前的 grad norm 如果在 10 以上，说明学习率偏大或者数据有异常样本；如果长期在 1e-4 以下，说明学习率偏小或者网络太深梯度传不下去。
• 各层权重范数：某层权重突然缩到接近 0，通常是该层前面出了死亡 ReLU；突然放大好几倍，多半是学习率过高。

这些都是训练过程中每几十步打印一次就能看到的，写几行 tensorboard 或者 wandb 的代码就够，别等训完再回头看，那时候已经浪费了半天卡时。

4. 调参与训练故障排查实录

4.1 loss 不降时的排查顺序

这是被问得最多的问题。我总结了一套从便宜到贵的排查顺序，按这个走基本能定位：

第一步，先确认模型有没有能力过拟合一个极小数据集。拿 10 张图、关掉所有增强和正则，训 200 步。如果 loss 降不到接近 0，那说明是代码有 bug，不是调参问题。这一步能滤掉八成的"不收敛"求助。

第二步，检查数据和标签是否对齐。有个特别隐蔽的情况是 DataLoader 用了多个 worker 但 shuffle 的随机种子没处理好，导致同一个 batch 里图片和标签错位。快速验证方法是让模型在一批固定数据上反复训，看 loss 能不能到 0。

第三步，看学习率。太大会震荡甚至 NaN，太小会几乎不动。做一次 lr range test 最直接：学习率从 1e-6 指数增长到 1，画 loss 曲线，选下降最陡的那段的中值。

第四步，看初始化。BN 之后的层输出分布应该接近标准正态，如果发现某层输出全部接近 0 或者爆掉，说明初始化有问题。PyTorch 默认的 Kaiming 初始化在大多数情况下够用，但如果你自定义了层，记得手动初始化。

注意：不要一上来就怀疑"网络结构不行"。我排查过的上百个案例里，结构设计本身有问题的不到十个，剩下全是数据、标签、学习率、归一化这些工程细节。

4.2 过拟合还是欠拟合，看两条曲线就够

判断标准很直接：训练 loss 和验证 loss 都高 → 欠拟合；训练 loss 低、验证 loss 高 → 过拟合。

欠拟合的解法按性价比排序：加大模型宽度（比加深层数安全）、减少正则强度（weight decay 和 dropout 都调小）、延长训练轮数、检查数据增强是不是过猛。很多人一上来就加深网络，结果参数翻倍效果没变，还不如把 width 从 32 调到 48。

过拟合的解法：先加数据增强（成本最低），再加 weight decay，再考虑 dropout（只在分类头用，卷积层之间加 dropout 效果不稳定），最后才是减少模型容量。有个反直觉的结论——在小数据集上，加大模型配合强正则往往比小模型效果好，因为大模型的优化景观更平滑。所以别怕加宽。

还有个常被忽略的点：验证集太小的时候，准确率波动会大到没法判断。1000 张验证图，准确率的标准差大概是 1.5 个点，两个模型差 1 个点根本不可信。这种情况建议用 5 折交叉验证，或者至少把验证集做到 3000 张以上。

4.3 常见问题速查表

关于"多卡比单卡慢"这一条，我在一个轻量模型上实测过：单卡每轮 42 秒，双卡变成 58 秒。原因是模型太小，参数同步的通信时间超过了并行带来的收益。判断标准大致是参数量低于 1000 万就别折腾多卡，不如调大 batch 用梯度累积模拟。

5. 轻量化与部署落地

5.1 三条压缩路线的适用边界

模型要上边缘设备，绕不开压缩。主流三条路：

剪枝是去掉不重要的权重或通道。非结构化剪枝（单个权重置零）压缩率高但需要稀疏计算库支持，实际加速有限；结构化剪枝（整通道删除）能实打实提速，但精度损失更明显。我的做法是先训一个大模型，做通道级的 L1 范数排序，剪掉 30% 的低范数通道，再微调 20 个 epoch，一般能保住 98% 的精度。

量化把 float32 换成 int8，模型体积直接降到 1/4，推理速度提升 2 到 4 倍。后训练量化（PTQ）不需要重新训练，但需要一小批校准数据来统计激活值的分布；量化感知训练（QAT）精度更好但流程更重。经验上，分类任务用 PTQ 通常掉 0.5 个点以内，检测和分割任务掉得更多，得上 QAT。

知识蒸馏是让小模型学大模型的软输出。温度参数 T 一般取 3 到 5，硬标签和软标签的损失加权通常是 0.3 : 0.7。这个方法特别适合你有现成大模型、但部署端只能用轻量模型的情况。

三条路线可以叠加：先蒸馏把轻量模型的精度拉起来，再剪枝压缩，最后量化部署。我自己做过的一次组合，把模型从 45MB 压到 3.2MB，精度掉了 1.8 个点，在可接受范围内。

5.2 离线到线上，精度落差通常出在哪

这一段是我最想强调的。模型在本地跑出 92%，集成到服务里变成 71%，这种事故我处理过不止一次，原因几乎全在下面这几条：

第一，颜色通道顺序。训练用 PIL 读图是 RGB，线上用 OpenCV 读图默认是 BGR。这个坑极其常见，而且症状是"模型还能用，但精度掉得莫名其妙"。

第二，归一化的数值范围。训练时用了transforms.ToTensor()，它会把 0-255 缩到 0-1；线上如果直接把 uint8 数据喂进去，输入范围差了 255 倍，输出全是垃圾。

第三，resize 的插值方式。训练用 bicubic，线上用 bilinear，差异在小目标上会被放大。统一成同一种，并且确认 resize 之后有没有做 center crop。

第四，BN 的模式。导出 ONNX 时如果模型还在 train 模式，BN 层会被固化成用当前 batch 统计量，推理结果完全不对。导出前必须model.eval()。

第五，动态 shape。有些算子对动态输入尺寸支持不好，导出后遇到非标准尺寸会静默出错或直接报错。建议导出时固定输入尺寸，线上预处理严格按这个尺寸来。

我的习惯是写一个一致性校验脚本：拿 50 张线上真实图片，分别走训练时的预处理管线和线上的预处理管线，逐张比对张量差值的最大值，超过 1e-3 就报警。这个脚本五分钟能写完，能挡掉绝大多数线上事故。

最后再分享一个我做模型交付时的小习惯：checkpoint 里除了state_dict，一定同时存下这几样东西——预处理参数（mean/std/输入尺寸/插值方式）、类别顺序映射、训练时的 git commit、以及一份能跑通的最小推理示例。半年后你自己回头接手这个模型时，会感谢当时的自己。ConvNet 本身不难，难的是把从数据到线上这一整条链路上的每一个细节都对齐，而这条链路上任何一个环节的错位，都会以"模型效果不好"的形式表现出来。