1. 从一张手写数字图说起：为什么这些经典CNN值得反复拆解
很多人第一次接触深度学习，都是从MNIST数据集和LeNet-5开始的。一张28×28的灰度图，经过几层卷积和池化，最后输出0到9的分类概率——这个流程看起来简单到几乎不需要解释。但如果你真正动手复现过这些经典网络，就会发现一个尴尬的事实：能跑通代码和能理解设计意图，中间隔着一道很深的沟。
我自己在早期学习阶段就踩过这个坑。当时用框架自带的API搭了一个LeNet-5，训练准确率到了99%以上，觉得自己已经"掌握"了CNN。直到有一次需要把一个类似结构迁移到彩色图像任务上，才发现自己根本说不清楚：为什么第一层卷积核是5×5而不是3×3？为什么池化层选平均池化而不是最大池化？Sigmoid和Tanh在这里到底哪个更合适？这些问题在"调包"的时候完全不会暴露，但一旦需要自己做架构决策，就会全部涌上来。
这篇文章想做的事情很具体：把LeNet-5、AlexNet、GoogLeNet、VGGNet、BNInception、Inception-v3这几个经典网络放在一起，不是简单地罗列结构参数，而是从设计动机、关键取舍、实操复现中的真实问题三个维度来拆解。适合已经了解卷积基本概念、但还没有系统梳理过经典架构演进脉络的读者。如果你正在准备面试、需要做架构选型、或者想从"会调包"进阶到"能改网络"，这些内容应该能帮你省下不少翻论文和试错的时间。
需要提前说明的是，这些网络诞生于不同的硬件条件和数据背景下，很多设计选择在今天看来可能不是最优的，但理解它们"为什么在当时是合理的"，恰恰是培养架构直觉的关键。下面我会按照网络演进的顺序，逐个拆解每个架构的核心贡献和实操要点。
2. LeNet-5：卷积网络的最小可行原型
2.1 结构拆解：每一层到底在做什么
LeNet-5的结构在今天的标准下非常小巧，但它的每一层设计都有明确的意图。输入是32×32的单通道图像（注意不是28×28，原始论文中做了padding），接着是C1卷积层，使用6个5×5的卷积核，输出6个28×28的特征图。然后是S2池化层，采用平均池化，窗口2×2，步长2，输出6个14×14的特征图。再往后是C3卷积层，16个5×5卷积核，输出16个10×10的特征图。S4池化层同样2×2平均池化，输出16个5×5的特征图。最后是C5卷积层（实际上可以看作全连接层），120个5×5卷积核，输出120个1×1的特征图，再接F6全连接层84个神经元，输出层10个神经元对应0到9的分类。
这里有几个细节值得注意。第一，C3层的连接方式不是全连接，原始论文中采用了部分连接的策略——每个输出特征图只与输入特征图的一个子集相连。这样做有两个好处：一是减少参数量，二是强制不同特征图学习不同的特征组合。第二，激活函数用的是Sigmoid或Tanh，而不是今天主流的ReLU。第三，池化用的是平均池化，而且池化层之后通常会接一个可学习的缩放和平移参数。
import torch import torch.nn as nn class LeNet5(nn.Module): def __init__(self, num_classes=10): super(LeNet5, self).__init__() self.conv1 = nn.Conv2d(1, 6, kernel_size=5, padding=2) self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2) self.conv2 = nn.Conv2d(6, 16, kernel_size=5) self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2) self.conv3 = nn.Conv2d(16, 120, kernel_size=5) self.fc1 = nn.Linear(120, 84) self.fc2 = nn.Linear(84, num_classes) self.act = nn.Tanh() def forward(self, x): x = self.act(self.conv1(x)) x = self.pool1(x) x = self.act(self.conv2(x)) x = self.pool2(x) x = self.act(self.conv3(x)) x = x.view(x.size(0), -1) x = self.act(self.fc1(x)) x = self.fc2(x) return x上面这段代码是一个简化版的LeNet-5实现。注意我在第一层加了padding=2，这是为了让32×32的输入经过5×5卷积后仍然保持32×32的输出，与原始论文一致。如果你直接用28×28的MNIST图像，不加padding的话第一层输出就是24×24，后续的维度计算需要相应调整。
2.2 为什么用平均池化而不是最大池化
这个问题我在很多场合被问到过。在LeNet-5的时代，平均池化是更自然的选择，原因有几个层面。从信息论的角度看，平均池化保留了区域内的整体激活水平，相当于对特征做了一次平滑降采样。在MNIST这种背景干净、笔画连续的任务上，平均池化能够更好地保留笔画的整体形状信息。而最大池化更关注"区域内最强烈的响应"，在纹理丰富、边缘锐利的自然图像上表现更好，这也是为什么后来AlexNet转向了最大池化。
另一个容易被忽略的原因是梯度传播。平均池化的梯度是均匀分配到窗口内所有位置的，而最大池化只把梯度传给响应最大的那个位置。在深层网络还没有BatchNorm和残差连接的年代，平均池化的梯度特性对训练稳定性更友好。当然，这个优势随着后来训练技巧的成熟变得不那么重要了。
实操中我的建议是：如果你在做类似MNIST这种低分辨率、结构简单的图像任务，可以试试平均池化，有时候会比最大池化高零点几个百分点。但在自然图像任务上，最大池化通常是更好的起点。
2.3 复现LeNet-5时最容易忽略的三个细节
第一个细节是权重初始化。原始论文中使用的是均匀分布初始化，范围与扇入（fan-in）相关。今天我们用PyTorch或TensorFlow默认的初始化方法通常也能work，但如果你发现训练loss不下降，可以检查一下初始化尺度是否合理。一个经验规则是：卷积层的初始化标准差大约在sqrt(2/(fan_in))附近比较稳妥。
第二个细节是学习率调度。LeNet-5原始论文使用的是简单的固定学习率，但在实际复现中，我发现用余弦退火或者阶梯式衰减能更快收敛。特别是当你在MNIST上训练超过20个epoch时，固定学习率后期会出现明显的震荡。
第三个细节是数据预处理。原始论文中对输入做了归一化处理，但具体参数在今天的标准下可能不是最优的。我的习惯是先把像素值缩放到[0,1]，再减去0.1307、除以0.3081（这是MNIST的全局均值和标准差）。这个操作看起来简单，但对最终精度的影响通常在0.3%到0.5%之间。
注意：LeNet-5的参数量只有约6万，在今天的GPU上训练MNIST通常几秒钟就能跑完一个epoch。但正因为训练太快，很多人会忽略验证集的设计。建议至少留出10%的训练数据作为验证集，否则你很难发现过拟合的苗头。
3. AlexNet：深度学习的破冰之作
3.1 从LeNet到AlexNet：哪些改变真正重要
AlexNet在2012年的ImageNet竞赛中把top-5错误率从26%降到了15%左右，这个提升幅度在当时是颠覆性的。但如果你仔细对比AlexNet和LeNet的结构，会发现它们的基本骨架非常相似：卷积、池化、全连接。真正的差异在于规模和训练技巧。
AlexNet有6000万参数，是LeNet-5的一万倍。它有5个卷积层和3个全连接层，输入是224×224的RGB图像。第一层卷积用了96个11×11的卷积核，步长4。这个设计在今天看来非常激进——11×11的卷积核参数量巨大，而且步长4会丢失很多空间信息。但在2012年，GPU显存有限，用大卷积核加大的步长可以快速降低空间维度，减少后续层的计算量。
另一个关键改变是ReLU激活函数的引入。ReLU在正区间梯度恒为1，彻底解决了Sigmoid和Tanh在深层网络中的梯度消失问题。AlexNet论文中明确提到，使用ReLU的训练速度比使用Tanh快了大约6倍。这个数字在今天看来可能有些夸张，但方向是对的：ReLU让训练深层网络变得可行。
还有两个工程上的创新值得注意：Dropout和数据增强。Dropout在全连接层中以0.5的概率随机置零神经元，有效缓解了过拟合。数据增强包括随机裁剪、水平翻转、颜色抖动等操作，把训练集扩大了若干个数量级。这两个技巧在今天已经是标配，但在当时是突破性的。
3.2 11×11卷积核的代价与替代方案
AlexNet第一层用11×11卷积核，参数量是96×3×11×11=34848。如果换成两个连续的3×3卷积核（假设中间层通道数也是96），参数量是96×3×3×3 + 96×96×3×3 = 2592 + 82944 = 85536，反而更多。但如果换成5×5卷积核，参数量是96×3×5×5=7200，比11×11少了将近80%。
那为什么AlexNet不直接用5×5？原因在于感受野。11×11卷积核在步长4的情况下，单个输出像素的感受野就是11×11。如果用5×5卷积核加步长2，需要堆叠多层才能达到同样的感受野，而当时还没有BatchNorm，深层堆叠的训练难度很大。所以AlexNet的选择是在"感受野"和"训练可行性"之间做的折中。
在今天复现AlexNet时，我通常会做一个替换：把第一层的11×11卷积核换成多个3×3卷积核的堆叠，或者用5×5卷积核加适当的padding。这样参数量更少，训练也更稳定。实测下来，在ImageNet这样的数据集上，替换后的版本精度通常不会下降，有时还会略有提升。
3.3 双GPU训练的历史背景与今天的单卡复现
AlexNet原始论文中使用了两个GTX 580 GPU进行并行训练，因为当时单个GPU的显存只有3GB，放不下整个网络。网络被拆分成两半，分别放在两个GPU上，只在特定的层进行通信。这个设计在今天看来已经过时，但理解它的背景有助于你明白为什么AlexNet的某些层结构看起来"不对称"。
比如第二层卷积的输入通道数是48而不是96，因为每个GPU只处理自己那一半的特征图。第三层卷积又把两个GPU的特征图合并起来，所以输入通道数是96×2=192。这种设计在单卡复现时需要做相应的调整：把所有通道数合并，去掉GPU间的通信逻辑。
# 单卡版AlexNet的简化实现 class AlexNet(nn.Module): def __init__(self, num_classes=1000): super(AlexNet, self).__init__() self.features = nn.Sequential( nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), ) self.classifier = nn.Sequential( nn.Dropout(0.5), nn.Linear(256 * 6 * 6, 4096), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Linear(4096, num_classes), ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x这段代码在单卡上可以直接运行。注意输入尺寸需要是224×224，经过第一层卷积（11×11，步长4，padding2）后输出是55×55，再经过3×3最大池化（步长2）变成27×27，后续层的维度可以自行推导验证。
提示：AlexNet的全连接层参数量占了总参数的绝大部分（约5800万/6000万）。如果你在做迁移学习，通常只需要替换最后的分类层，前面的卷积层可以冻结或微调。冻结卷积层时，训练速度会快很多，但精度可能略低；微调所有层则更慢但通常效果更好。
4. VGGNet：用深度和规整性换性能
4.1 3×3卷积核堆叠的设计哲学
VGGNet的核心思想非常简洁：全部使用3×3卷积核，通过不断堆叠来增加网络深度。这个设计在当时是一个重要的转折点，因为它证明了"深度"本身就是一个独立的性能维度，不需要依赖大卷积核或复杂的连接方式。
两个3×3卷积核堆叠的感受野等于一个5×5卷积核，三个3×3堆叠等于一个7×7。但参数量上，三个3×3卷积核（假设输入输出通道数都是C）的参数量是3×(C×C×3×3)=27C²，而一个7×7卷积核的参数量是C×C×7×7=49C²。也就是说，用小的卷积核堆叠可以在达到相同感受野的同时减少参数量。更重要的是，多层堆叠引入了更多的非线性激活，增强了网络的表达能力。
VGGNet有多个版本，最常用的是VGG16和VGG19。VGG16包含13个卷积层和3个全连接层，结构非常规整：每经过2到4个卷积层就接一个最大池化层，通道数从64开始，每池化一次翻倍，直到512。这种规整性让VGGNet非常容易实现和修改，也是它至今仍被广泛用作特征提取器的原因之一。
4.2 VGG16的参数量分布与显存优化
VGG16的总参数量约1.38亿，其中绝大部分集中在全连接层。第一个全连接层是512×7×7到4096，参数量是512×7×7×4096≈1.02亿。这个数字非常惊人，意味着VGG16的卷积层其实只占了总参数量的不到10%。
这个参数量分布带来两个实际问题。第一是显存占用：在训练时，全连接层的激活值和梯度会占用大量显存。如果你用224×224的输入，batch size设为32，VGG16在训练时可能需要10GB以上的显存。第二是过拟合风险：全连接层参数量太大，在小数据集上很容易过拟合。
我的实操建议是：如果显存有限，可以把第一个全连接层的输入维度从512×7×7降下来。具体做法是在最后一个卷积块之后加一个全局平均池化层，把7×7的空间维度直接压成1×1，这样全连接层的输入就变成了512维，参数量从1.02亿降到200万左右。这个改动对精度的影响通常很小，但显存占用会大幅下降。
# 带全局平均池化的VGG16变体 class VGG16GAP(nn.Module): def __init__(self, num_classes=1000): super(VGG16GAP, self).__init__() self.features = nn.Sequential( # Block 1 nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(64, 64, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # Block 2 nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # Block 3 nn.Conv2d(128, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # Block 4 nn.Conv2d(256, 512, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # Block 5 nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), ) self.gap = nn.AdaptiveAvgPool2d((1, 1)) self.classifier = nn.Linear(512, num_classes) def forward(self, x): x = self.features(x) x = self.gap(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x这个变体在保持VGG16卷积结构的同时，把参数量降到了约1500万，显存占用减少了约80%。在ImageNet上，这个变体的top-5错误率通常比原始VGG16高0.5%到1%，但训练速度提升了将近一倍。
4.3 VGG作为特征提取器的实战经验
VGG16的卷积层至今仍然是很多视觉任务的首选特征提取器，原因在于它的特征层次非常清晰：浅层捕捉边缘和纹理，中层捕捉局部形状，深层捕捉语义信息。在做风格迁移、图像检索、目标检测等任务时，VGG16的中间层特征往往比后面更深的网络（如ResNet）更好用。
我在做图像风格迁移时，通常会用VGG19的conv4_2层提取内容特征，用conv1_1到conv5_1的多个层提取风格特征。这个组合在大多数风格上都能得到不错的效果。需要注意的是，VGG的特征提取器在使用前需要做特定的预处理：把像素值缩放到[0,1]，然后减去ImageNet的均值[0.485, 0.456, 0.406]，再除以标准差[0.229, 0.224, 0.225]。这个预处理顺序不能搞错，否则特征分布会偏移。
注意：VGG16的卷积层参数量虽然不大，但计算量不小。在CPU上做一次前向传播可能需要几秒钟。如果你只是做特征提取，建议用GPU，或者考虑用更轻量的网络（如MobileNet）替代。但在精度要求高的场景下，VGG的特征质量仍然很有竞争力。
5. GoogLeNet与Inception模块：多尺度并行的设计思路
5.1 Inception模块的核心动机：不同尺度的特征同时提取
GoogLeNet（也就是Inception-v1）在2014年的ImageNet竞赛中夺冠，它的核心创新是Inception模块。这个模块的设计动机很直接：在图像中，目标的大小变化很大，有的物体只占几十个像素，有的占据整个画面。如果只用单一尺度的卷积核，很难同时捕捉到不同尺度的特征。
Inception模块的做法是在同一层中并行使用多个不同尺寸的卷积核（1×1、3×3、5×5）和一个3×3最大池化，然后把所有输出在通道维度上拼接起来。这样网络在每一层都能同时看到不同尺度的特征，后续层可以自动选择最有用的尺度组合。
但直接这样做有一个问题：5×5卷积核的参数量和计算量都很大。所以GoogLeNet在3×3和5×5卷积之前，以及池化之后，都加了1×1卷积来做维度压缩。这个1×1卷积的作用是减少输入通道数，从而降低后续卷积的计算量。比如，如果输入是256通道，先用1×1卷积压到64通道，再做5×5卷积，计算量会降到原来的四分之一左右。
class InceptionModule(nn.Module): def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj): super(InceptionModule, self).__init__() self.branch1 = nn.Sequential( nn.Conv2d(in_channels, ch1x1, kernel_size=1), nn.ReLU(inplace=True) ) self.branch2 = nn.Sequential( nn.Conv2d(in_channels, ch3x3red, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1), nn.ReLU(inplace=True) ) self.branch3 = nn.Sequential( nn.Conv2d(in_channels, ch5x5red, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2), nn.ReLU(inplace=True) ) self.branch4 = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=1, padding=1), nn.Conv2d(in_channels, pool_proj, kernel_size=1), nn.ReLU(inplace=True) ) def forward(self, x): b1 = self.branch1(x) b2 = self.branch2(x) b3 = self.branch3(x) b4 = self.branch4(x) return torch.cat([b1, b2, b3, b4], dim=1)这个模块的四个分支分别对应1×1卷积、3×3卷积、5×5卷积和最大池化。每个分支的输出通道数需要提前设计好，使得拼接后的总通道数与预期一致。在GoogLeNet中，Inception模块的输出通道数通常在256到832之间。
5.2 1×1卷积的降维作用与计算量分析
1×1卷积在Inception模块中扮演了关键角色，但它的作用经常被低估。除了降维之外，1×1卷积还引入了额外的非线性变换，增强了模型的表达能力。从计算量的角度看，假设输入是256通道的28×28特征图，直接做5×5卷积（输出64通道）的计算量是256×64×5×5×28×28≈3.2×10^9次乘法。如果先用1×1卷积把256通道压到32通道，再做5×5卷积，计算量变成256×32×1×1×28×28 + 32×64×5×5×28×28≈6.4×10^8 + 4.0×10^8≈1.0×10^9，减少了将近70%。
这个计算量的节省在深层网络中非常可观。GoogLeNet虽然比VGG19深（22层 vs 19层），但参数量只有约500万，是VGG16的二十七分之一。这也是GoogLeNet能够在计算资源有限的设备上运行的原因之一。
实操中需要注意的是，1×1卷积的压缩比例需要仔细调节。压缩太狠会丢失信息，压缩不够则计算量节省有限。我的经验是：对于3×3分支，压缩比例通常在1/2到1/3之间；对于5×5分支，压缩比例可以更大，1/4到1/8都可以尝试。具体数值需要根据任务和数据集做实验确定。
5.3 GoogLeNet的辅助分类器：训练技巧还是必需组件
GoogLeNet在中间层引入了两个辅助分类器，分别接在Inception 4a和4d的输出上。辅助分类器本身是一个小型的分类网络，包含一个5×5平均池化、一个1×1卷积、两个全连接层和一个softmax输出。在训练时，辅助分类器的损失会以0.3的权重加到总损失中。
这个设计的初衷是缓解梯度消失。GoogLeNet有22层，在BatchNorm还没有普及的年代，深层网络的梯度传播是个大问题。辅助分类器相当于在中间层增加了额外的监督信号，让梯度能够更顺畅地传到浅层。但在今天，有了BatchNorm和更好的初始化方法，辅助分类器的作用已经不那么明显了。
我在复现GoogLeNet时通常会保留辅助分类器，但把权重降到0.1或直接去掉。实测下来，在ImageNet上去掉辅助分类器对最终精度的影响通常在0.2%以内，但训练速度会快一些。如果你在小数据集上训练，辅助分类器反而可能造成过拟合，建议直接去掉。
提示：GoogLeNet的输入尺寸是224×224，但它的全连接层之前用了全局平均池化，所以实际上可以接受更大的输入尺寸。如果你用320×320的输入，网络仍然可以正常工作，而且精度通常会略有提升，因为更大的输入保留了更多细节。
6. BNInception与Inception-v3：BatchNorm的引入与卷积分解
6.1 BNInception：BatchNorm如何改变训练动态
BNInception并不是一个官方名称，而是社区对"加了BatchNorm的Inception-v2"的俗称。Inception-v2在GoogLeNet的基础上做了几个重要改进，其中最核心的就是引入了Batch Normalization。
BatchNorm的作用是在每个mini-batch内对激活值做归一化，使其均值为0、方差为1，然后再用一个可学习的缩放和平移参数恢复表达能力。这个操作看起来简单，但它对训练动态的影响是深远的。在没有BatchNorm的时候，网络各层的输入分布会随着前层参数的变化而不断偏移，导致后层需要不断适应新的分布。BatchNorm把这个分布固定下来，让各层可以独立地学习，从而允许使用更大的学习率和更少的初始化技巧。
在Inception-v2中，BatchNorm被加在了卷积层之后、激活函数之前。这个位置很关键：如果加在激活函数之后，ReLU会把负值全部置零，归一化的效果会打折扣。加在激活函数之前，归一化后的值经过ReLU，正负分布更合理。
实测中，加了BatchNorm的Inception-v2训练速度比原始GoogLeNet快了将近一倍，而且对学习率的敏感度大幅降低。我试过用0.1的学习率训练BNInception，也能稳定收敛，而原始GoogLeNet用0.01的学习率都可能发散。
6.2 Inception-v3的卷积分解：从5×5到两个3×3
Inception-v3在Inception-v2的基础上进一步优化了Inception模块的结构，核心思想是卷积分解。具体来说，它把5×5卷积分解成两个连续的3×3卷积，把7×7卷积分解成1×7和7×1两个一维卷积。这样做的好处是减少参数量和计算量，同时保持相同的感受野。
以5×5分解为例，假设输入输出通道数都是C，直接做5×5卷积的参数量是C×C×5×5=25C²。分解成两个3×3卷积后，参数量是C×C×3×3 + C×C×3×3=18C²，减少了28%。如果考虑计算量，减少的比例类似。更重要的是，两个3×3卷积之间可以加非线性激活，表达能力反而更强。
Inception-v3还引入了非对称卷积分解，也就是把n×n卷积分解成1×n和n×1两个卷积。比如7×7卷积分解成1×7和7×1，参数量从49C²降到14C²，减少了70%以上。这种分解在浅层效果不明显，但在中层和深层（特征图尺寸较小的时候）非常有效。
class InceptionV3ModuleA(nn.Module): """Inception-v3的Module A，使用3×3分解""" def __init__(self, in_channels, pool_features): super(InceptionV3ModuleA, self).__init__() self.branch1x1 = nn.Sequential( nn.Conv2d(in_channels, 64, kernel_size=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True) ) self.branch5x5 = nn.Sequential( nn.Conv2d(in_channels, 48, kernel_size=1), nn.BatchNorm2d(48), nn.ReLU(inplace=True), nn.Conv2d(48, 64, kernel_size=5, padding=2), nn.BatchNorm2d(64), nn.ReLU(inplace=True) ) self.branch3x3dbl = nn.Sequential( nn.Conv2d(in_channels, 64, kernel_size=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 96, kernel_size=3, padding=1), nn.BatchNorm2d(96), nn.ReLU(inplace=True), nn.Conv2d(96, 96, kernel_size=3, padding=1), nn.BatchNorm2d(96), nn.ReLU(inplace=True) ) self.branch_pool = nn.Sequential( nn.AvgPool2d(kernel_size=3, stride=1, padding=1), nn.Conv2d(in_channels, pool_features, kernel_size=1), nn.BatchNorm2d(pool_features), nn.ReLU(inplace=True) ) def forward(self, x): b1 = self.branch1x1(x) b2 = self.branch5x5(x) b3 = self.branch3x3dbl(x) b4 = self.branch_pool(x) return torch.cat([b1, b2, b3, b4], dim=1)这个Module A的结构展示了Inception-v3的几个关键设计：1×1卷积降维、5×5卷积分解成两个3×3、池化分支用平均池化而不是最大池化。这些改动累积起来，让Inception-v3在参数量只有约2400万的情况下，达到了比VGG16（1.38亿参数）更好的精度。
6.3 标签平滑与辅助分类器的实战效果
Inception-v3还引入了标签平滑（Label Smoothing）正则化。传统的交叉熵损失使用one-hot标签，即正确类别的概率为1，其他为0。标签平滑把正确类别的概率降到0.9（或其他值），把剩余的概率均匀分配给其他类别。这样做可以防止模型对训练标签过度自信，提升泛化能力。
在ImageNet上，标签平滑通常能带来0.2%到0.3%的top-1精度提升。这个提升看起来不大，但在竞赛中往往很关键。实操中，标签平滑的参数通常设为0.1，也就是正确类别概率0.9，其他类别平分0.1。如果数据集较小或噪声较大，可以适当增大平滑参数。
Inception-v3的辅助分类器也做了改进：辅助分类器的第一个全连接层之后加了BatchNorm，而且辅助分类器的损失权重在训练后期会降为0。这个设计比GoogLeNet的辅助分类器更精细，效果也更好。我在复现时通常会保留辅助分类器，权重设为0.4，训练到80%的epoch后降为0。
注意：Inception-v3的输入尺寸是299×299，不是224×224。这个尺寸是经过精心设计的，使得经过多次下采样后，最后的特征图尺寸正好是8×8。如果你用其他尺寸的输入，需要相应调整网络结构或使用自适应池化。
7. 从这些经典架构中能带走什么
7.1 架构演进的几条主线
把这几个网络放在一起看，能清晰地看到几条演进主线。第一条是深度：从LeNet-5的7层到VGG19的19层再到GoogLeNet的22层，深度在不断增加，但增加的方式从"简单堆叠"变成了"精心设计"。第二条是参数量效率：AlexNet的6000万参数、VGG16的1.38亿参数，到GoogLeNet的500万、Inception-v3的2400万，参数量在减少但精度在提升，说明架构设计比单纯增加参数更重要。
第三条主线是训练技巧的进步：从Sigmoid到ReLU，从无归一化到BatchNorm，从固定学习率到各种调度策略，这些技巧让深层网络的训练从"不可能"变成了"常规操作"。第四条是模块化设计：Inception模块、残差模块、密集连接模块，这些可复用的模块让网络设计从"手工定制"变成了"积木搭建"。
理解这些主线的好处是，当你面对一个新的架构时，可以快速判断它的创新点在哪里，是深度、宽度、连接方式还是训练技巧。这种判断力比记住具体的网络结构更重要。
7.2 复现经典网络时的通用避坑清单
在复现这些经典网络时，有几个坑几乎每个人都会踩。第一个是输入尺寸不匹配。每个网络都有自己预期的输入尺寸，LeNet-5是32×32，AlexNet和VGG是224×224，Inception-v3是299×299。如果你用错了尺寸，要么网络报错，要么精度大幅下降。建议在复现前先确认输入尺寸，必要时用自适应池化层来兼容不同尺寸。
第二个是预处理不一致。不同的网络使用了不同的预处理参数，比如ImageNet的均值和标准差、像素值缩放范围等。这些参数看起来是细节，但对精度的影响通常在1%到2%。建议直接使用官方实现中的预处理参数，不要自己随意调整。
第三个是学习率和batch size的匹配。BatchNorm对batch size比较敏感，太小的batch size会导致统计量估计不准。如果显存有限，可以用梯度累积来模拟大batch size。学习率通常需要随着batch size线性缩放，但这个规则不是绝对的，需要根据实际情况调整。
第四个是权重初始化的选择。虽然现代框架的默认初始化通常够用，但在复现老网络时，如果发现训练不收敛，可以试试Xavier或Kaiming初始化。特别是对于没有BatchNorm的网络，初始化的重要性更高。
7.3 这些老架构在今天还有什么用
有人可能会问：现在都有ResNet、EfficientNet、Vision Transformer了，学这些老架构还有什么用？我的看法是，这些老架构的价值不在于直接使用，而在于理解设计原则。Inception的多尺度并行思想在今天的很多网络中仍然在使用，VGG的3×3堆叠原则是几乎所有现代CNN的基础，BatchNorm更是标配。
另外，这些老架构在特定场景下仍然有实用价值。VGG16作为特征提取器在风格迁移和图像检索中仍然很常见，因为它的特征层次清晰、预训练权重容易获取。GoogLeNet和Inception-v3在移动端和嵌入式设备上仍然有部署价值，因为它们的参数量和计算量相对较小。LeNet-5则是教学和快速原型验证的好工具，训练快、结构简单、容易修改。
我在做新任务时，通常会先用LeNet或VGG这样简单的架构跑一个baseline，确认数据和流程没问题后，再换更复杂的架构。这个习惯帮我省了很多时间，因为简单架构出问题时更容易定位。
7.4 从复现到改进：如何基于经典架构做创新
最后分享一个我从复现经典架构中总结出的创新方法：替换一个组件，观察效果。比如，把VGG的所有ReLU换成LeakyReLU，看看精度有没有变化；把Inception模块中的3×3卷积换成深度可分离卷积，看看参数量减少后精度下降多少；把BatchNorm换成GroupNorm，看看在小batch size下是否更稳定。
这种"控制变量"式的实验看起来简单，但能帮你快速建立对各个组件作用的直觉。我做过的一个实验是把AlexNet的所有最大池化换成平均池化，结果top-5错误率上升了约2%，这让我直观地理解了最大池化在自然图像任务上的优势。另一个实验是把VGG16的第一个全连接层换成全局平均池化，参数量减少了98%，精度只下降了0.8%，这个结果直接影响了我在后续项目中的架构选择。
这些实验不需要很强的计算资源，在单个GPU上几个小时就能跑完。比起读论文，动手做实验能让你更深刻地理解每个设计选择背后的权衡。如果你正在学习深度学习架构，我强烈建议你选一个经典网络，从头实现一遍，然后做几个替换实验。这个过程可能比读十篇论文更有收获。
