企业官网建设流程全解析

1. 动手改造前先复盘：LeNet 的局限与三个经典网络的解题思路

1.1 LeNet 的原始结构与它的“时代病”

如果你跟我一样是用 PyTorch 入门卷积网络的，那 LeNet 大概率是你第一个亲手敲出来的结构。这个经典网络的基本骨架是“卷积->池化->卷积->池化->全连接->输出”，在当年把特征提取和分类两大模块组合得非常干净。但放在今天的任务上看，它的短板也相当明显，这些短板恰好是后面几个经典网络花力气解决的核心问题。

先说最扎眼的：激活函数用的是 tanh。tanh 在输入绝对值较大的区域会进入饱和，梯度几乎为 0，一旦网络加深，反向传播的梯度经过多层饱和区衰减之后，前面几层几乎学不动。LeNet 只有两层卷积还好说，改成更深的网络就不行了。其次是池化方式，LeNet 默认用平均池化，它会把局部区域的响应“抹平”，对强特征不敏感，而最大池化相当于直接告诉你“这个位置有没有特征”，对边缘、纹理这类判别性信息保留得更好。

还有一个容易被忽略的问题：LeNet 的通道数太少。第一层只提取 6 个通道，第二层 16 个通道，放到现在的 32×32 彩色图像上，特征容量根本不够看。再加上全连接层占了大量参数，又没有任何正则化手段，在小数据集上很容易过拟合。你可以把 LeNet 理解成一个骨架很标准，但“装备”非常原始的模型，它在 10 类、小尺寸灰度图上能工作，换个稍微复杂的数据集就露馅。

注意，这里说“落后”并不是否定这个结构本身。恰恰是因为 LeNet 骨架足够简单清晰，才适合拿来做“结构演进”的载体：在它身上做小改动，你能非常直观地看出每一处改动到底带来了什么效果。

1.2 为什么选定 AlexNet、VGG、NiN 这三个参考对象

我选择这三个网络，不是因为它们名气大，而是它们代表了三种完全不同的改进哲学，放在一起对比特别有意思。

AlexNet 走的是“工程调优”路线。它没有推翻“卷积+全连接”的传统结构，而是在原有框架内做了系统性强化：激活函数换成 ReLU 解决梯度饱和，池化换成最大池化保留强响应，外加 Dropout 抑制过拟合。这套改动每一处都不复杂，但组合起来效果是质的飞跃。

VGG 走的是“加深加宽”路线。它验证了一件事：与其设计复杂的卷积核，不如老老实实堆叠小尺寸卷积核。两个 3×3 堆叠等价于一个 5×5 的感受野，但参数量更少、非线性更强。同时每经过一次池化就把通道数翻倍，让网络在空间信息压缩的同时保留足够的特征表达力。

NiN 走的是“结构性革新”路线。它把 1×1 卷积引入网络，让卷积层具备跨通道信息融合能力，再用全局平均池化替代全连接分类头，直接消灭了传统网络中参数量最大的那一块。

把这三套思路分别施加到 LeNet 上，等于同一具骨架分别穿了“补强装”“加深装”和“换装”三套方案。最后你会得到一个非常直观的结论：精度提升不是单一因素的结果，而是多个设计点共同作用，这三条路线的终点不同，但都指向同一个方向——让信息流动更顺畅、让模型表达更强、让过拟合更可控。

2. 三个改造方向的核心原理与设计拆解

2.1 AlexNet 方向：ReLU、最大池化和 Dropout 的组合拳

先看 AlexNet 式改造。这个方案的思路是不动整体结构，把每一处“原始装备”换成现代版本。首当其冲就是激活函数：ReLU(x) = max(0, x)，正半轴梯度恒为 1，负半轴输出直接置 0。这意味着梯度再深也能无损穿透激活层，不会再出现 tanh 那种把梯度“吃掉”的饱和现象。实测里最直观的感受就是，同样的训练轮次，ReLU 版的损失下降速度明显比 tanh 版快，前期收敛差别非常大。

负半轴置 0 还有一个隐形好处：稀疏性。每一层只会被部分神经元激活，网络天然具备更强的非线性分离能力，这在特征层面相当于一种隐式的特征选择。不过要说清楚，ReLU 并不是没有缺点，负半轴直接置 0 会让部分神经元“死亡”，如果学习率设置过大，前期可能直接打死一片神经元。所以 AlexNet 式改造里，学习率往往要比 tanh 时代保守一些。

第二个改动是池化。最大池化取局部区域的最大响应，梯度也能明确地回传到最大响应的那个位置，这让特征提取层更关注“有没有特征”而不是“平均响应是什么”。图像分类任务里，边缘、角点、纹理这类判别性特征恰恰是强响应特征，最大池化天然适合。

第三个改动是 Dropout。LeNet 时代完全没有这种正则化手段，训练大规模全连接层非常容易过拟合。Dropout 的原理很朴素：训练时随机把一部分神经元的输出置 0，相当于每轮都在训练一个不同的“子网络”，推理时再把所有子网络的能力平均起来。它尤其适合 AlexNet 式改造，因为这种方案保留了全连接分类头，而全连接层恰恰是最需要 Dropout 保护的地方。

2.2 VGG 方向：小卷积核堆叠与通道倍增

VGG 的思路看起来更“笨”——就是不停地堆 3×3 卷积，但它的底层逻辑非常扎实。两个 3×3 卷积堆叠，感受野正好等于一个 5×5 卷积，但参数量只有 5×5 的 72% 左右，而且还多了一层非线性激活。非线性层的增加意味着决策函数更复杂，特征变换能力更强。这正是 LeNet 改造里最划算的“加量不加价”：把原来的一层 5×5 替换成两层 3×3，通道数反而更宽，特征表达能力立刻不一样。

通道倍增策略是 VGG 的另一个精髓：每经过一次池化，空间尺寸减半，通道数就翻倍。这样做的道理在于，池化会丢失空间位置信息，如果通道数不增加，网络的信息总量就会快速缩水；反过来，通道数翻倍可以弥补空间分辨率损失，让网络在更深的层次上依然有足够的容量去表达语义特征。小型网络上我习惯用 32→64→128 这个配置，主流 VGG 用的是 64→128→256→512，规模可以按任务调整。

全连接层的处理也需要跟着改。VGG 原版最后三层全连接参数量极其庞大，占整个网络大半参数。在 LeNet 这个规模上完全没必要学它，我倾向于把分类头收缩成一个 128 维的隐含层加一个输出层，普通任务足够用。如果任务简单，甚至可以直接用全局平均池化把特征图压缩成向量再接输出层，这就是向 NiN 的方向靠拢了。

2.3 NiN 方向：1×1 卷积与全局平均池化

NiN 式改造动的脑筋最大，它试图回答一个问题：分类头一定要用全连接吗？NiN 的答案是：不用，而且可以用卷积做到底。

1×1 卷积乍看很奇怪，卷积核尺寸是 1，根本不捕捉空间邻域信息，但它做了一件全连接做不了的事：在保持空间结构的前提下，对每个像素位置的所有通道做加权组合。你可以把它理解成“在通道维度上的微型全连接”，等价于一个逐像素的 MLP。它的价值是让网络在每一层都能对跨通道信息进行融合和变换，把表达能力从“空间模式”扩展到“通道组合模式”。在 LeNet 改造中，我在每个卷积块后面追加两层 1×1 卷积，相当于给每个块配了一个小型非线性变换器。

全局平均池化更是釜底抽薪的设计。它对每张特征图求全局平均，输出一个值，直接把“这张特征图是否激活”作为分类依据，天然具有可解释性。最关键的是这个模块没有任何可学习参数，残差网络也好、后来的各种轻量网络也好，在分类头设计上多少都受了它的影响。对 LeNet 来说，原来的三个全连接层被替换成“1×1 卷积到类别数 + 全局平均池化”，参数量瞬间减少一大截，过拟合风险也随之大降。

值得多说一句的是，NiN 这种“末尾 1×1 卷积映射到类别数”的设计，其实等价于一个没有隐藏层的逻辑回归分类器，区别在于它的输入是经过充分非线性变换的特征图，所以表达能力并不弱。这正是它能在小数据上比全连接头更稳的原因。

3. PyTorch 代码实现：四个网络、一套训练框架

3.1 数据准备与预处理

为了充分体现结构差异，我没有用 MNIST 这种过于简单的数据集，而是用了 CIFAR-10。它是 32×32 的彩色图像，恰好和 LeNet 原始输入尺寸一致，只需要把第一层卷积的输入通道从 1 改成 3，其他地方都不用动。

数据增强这块我强烈建议加上。训练时用随机裁剪加随机水平翻转，测试时只做归一化，能有效提升泛化能力。CIFAR-10 的通道均值和标准差需要用官方统计值，这点网上很多人图省事直接用 0.5 归一化，效果会差一截。

import torch from torch import nn from torch.utils.data import DataLoader from torchvision import datasets, transforms transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) train_set = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) test_set = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test) train_loader = DataLoader(train_set, batch_size=128, shuffle=True, num_workers=2) test_loader = DataLoader(test_set, batch_size=256, shuffle=False, num_workers=2)

随机裁剪用 padding=4 的好处是让裁剪后仍然覆盖原始图像的大部分区域，增强鲁棒性又不至于裁剪出太多无意义碎片。num_workers 按机器配置调整，Windows 下建议从 0 或 2 起步，避免数据加载进程报错。

3.2 原始 LeNet 的 PyTorch 实现

先写基线版本。CIFAR-10 输入是 32×32，第一层卷积不做 padding，5×5 卷积后变成 28×28，平均池化后 14×14；第二层卷积后再池化，得到 5×5 的特征图，展平后正好接 16×5×5 的全连接输入。这个尺寸计算不复杂，但每次改网络都得重新算一遍，这里把推导过程记住，后面排查问题会频繁用到。

class LeNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 6, kernel_size=5), nn.Tanh(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Conv2d(6, 16, kernel_size=5), nn.Tanh(), nn.AvgPool2d(kernel_size=2, stride=2), ) self.classifier = nn.Sequential( nn.Linear(16 * 5 * 5, 120), nn.Tanh(), nn.Linear(120, 84), nn.Tanh(), nn.Linear(84, num_classes), ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x

特征图尺寸公式是 F_out = (F_in - K + 2P) / S + 1，卷积核 K、填充 P、步长 S。LeNet 里两步都是 K=5、S=1、P=0，所以 32 变 28 变 14 再变 10 再变 5。每次复现或改造网络，先把这条链路算通，再去写代码，能省下大量调试时间。

3.3 AlexNet 风格改进版实现

AlexNet 风格版我把通道数从 6/16 提到 32/64，再加一层 128 通道的 3×3 卷积，激活全部换成 ReLU，池化换成最大池化，全连接之间插入两个 Dropout。这样既保留了 LeNet 的整体结构，又完整吸收了 AlexNet 的核心改进点。

class AlexLeNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 32, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(32, 64, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=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), ) self.classifier = nn.Sequential( nn.Dropout(0.5), nn.Linear(128 * 8 * 8, 256), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(256, 128), nn.ReLU(inplace=True), nn.Linear(128, num_classes), ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x

你注意看尺寸变化：第一层加了 padding=2，所以 32×32 输入经 5×5 卷积后尺寸不变，池化后变 16×16；第二层同样 padding=2，池化后变 8×8。这就是为什么最后展平是 128×8×8。加 padding 的目的是让特征图尺寸变化更平滑，也避免边缘信息过早丢失。Dropout 放在全连接层内部而不是卷积层，这是关键细节，卷积层本身参数共享、冗余度低，不像全连接那么需要 Dropout。

3.4 VGG 风格改进版实现

VGG 风格版完全抛弃大卷积核，全部改用 3×3，每个阶段连续堆两层卷积再接一个最大池化。通道数按“池化一次翻一倍”的规则：32→64→128。这个结构的特征提取部分已经比原始 LeNet 深了一倍，分类头则大幅收缩，只留一个 128 维的隐含层。

class VggLeNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(32, 32, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), nn.Conv2d(32, 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(2, 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(2, 2), ) self.classifier = nn.Sequential( nn.Dropout(0.5), nn.Linear(128 * 4 * 4, 128), nn.ReLU(inplace=True), nn.Linear(128, num_classes), ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x

尺寸链路是 32→16→8→4，三次池化后特征图 4×4，展平 128×4×4=2048。3×3 卷积全部 padding=1 保持尺寸不变，所以每一层的输出大小只看池化。设计这种网络时有个省事技巧：先用一个随机输入跑一次 forward，把中间层的形状打印出来，确认无误再开始训练，比手算快得多。

VGG 风格版是我个人认为在“精度/参数量”上最均衡的方案。它的卷积层参数虽然比 Alex 风格版多，但因为分类头小，整体参数量反而更可控，而且堆叠的小卷积核带给特征提取更强的逐级抽象能力。

3.5 NiN 风格改进版实现

NiN 风格版是最彻底的结构改动。我在每个卷积块后面追加两层 1×1 卷积，把每个块变成“mlpconv”结构，最后用 1×1 卷积直接映射到类别数，再通过全局平均池化输出分类得分。整个网络没有一个传统的全连接分类层。

class NinLeNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 32, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.Conv2d(32, 32, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(32, 32, kernel_size=1), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), nn.Conv2d(32, 64, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=1), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), nn.Conv2d(128, num_classes, kernel_size=1), nn.ReLU(inplace=True), ) self.gap = nn.AdaptiveAvgPool2d(1) def forward(self, x): x = self.features(x) x = self.gap(x) return x.view(x.size(0), -1)

最后的 1×1 卷积把 128 通道压到 10 个通道，每个通道对应一个类别，全局平均池化后每个通道输出一个值，正好作为该类别的得分。这些值直接喂给交叉熵损失函数即可，不需要经过任何全连接层。这个设计让参数量大头集中在卷积部分，分类头的参数几乎可以忽略不计。

第一、二块保留 5×5 卷积是为了跟 LeNet 的原始体验尽量可比，第三块换成 3×3 是因为前面的 1×1 卷积已经提供了足够的非线性融合，后面特征图的感受野需求没那么大。实测中如果把三个块全改成 3×3 也可以，精度差异不大，但保留 5×5 能让“改造”的痕迹更清晰，便于理解每一步做了什么。

3.6 统一训练与验证脚本

四个模型结构不同，但训练流程完全一样。我写了一个通用训练函数，顺便把最佳模型权重保存下来，方便后续单独加载做推理测试。

def evaluate(model, loader, device): model.eval() correct = 0 total = 0 with torch.no_grad(): for x, y in loader: x, y = x.to(device), y.to(device) out = model(x) correct += (out.argmax(dim=1) == y).sum().item() total += y.size(0) return correct / total def train_model(model, train_loader, test_loader, epochs=30, lr=0.02, device='cuda'): model.to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) best_acc = 0.0 for epoch in range(epochs): model.train() total_loss = 0.0 correct = 0 total = 0 for x, y in train_loader: x, y = x.to(device), y.to(device) optimizer.zero_grad() out = model(x) loss = criterion(out, y) loss.backward() optimizer.step() total_loss += loss.item() * x.size(0) correct += (out.argmax(dim=1) == y).sum().item() total += y.size(0) scheduler.step() train_acc = correct / total val_acc = evaluate(model, test_loader, device) print(f'epoch {epoch+1:3d} loss {total_loss/total:.4f} ' f'train_acc {train_acc:.4f} val_acc {val_acc:.4f}') if val_acc > best_acc: best_acc = val_acc torch.save(model.state_dict(), f'{model.__class__.__name__}.pth') print(f'best val_acc: {best_acc:.4f}') return best_acc

这里我特意选了带动量的 SGD 而不是 Adam。原因很简单：SGD 配合 momentum 和 weight_decay 在中小型卷积网络上通常能得到更平滑的收敛曲线和更好的最终精度，Adam 前期快但后期容易在最优解附近震荡。如果你图省事，用 Adam 也完全能训练，只是最终精度可能差半个到一个点。余弦退火调度器会把学习率从初始值平滑降到接近 0，配合 SGD 效果比固定学习率好很多，而且不用手动设置衰减节点。

4. 训练结果与影响分析

4.1 超参数设置与实验环境

四个模型我用完全相同的超参数训练了 30 个 epoch，保证对比公平。batch size 128，初始学习率 0.02，momentum 0.9，weight_decay 5e-4，余弦退火。单卡 GPU 环境下，LeNet 一个 epoch 大概十几秒，三个改进版基本都在一分钟以内，整体实验不会占用太多时间。

几个超参数的选择理由值得说清楚。weight_decay 设 5e-4 是经验值，偏大容易欠拟合，偏小起不到正则化作用，在 CIFAR-10 这种规模的实验里 5e-4 是比较稳妥的起点。学习率 0.02 对 SGD 来说属于中等偏保守，配合余弦退火可以从容覆盖整个训练过程，不需要额外微调。如果换成 Adam，学习率一般要降到 1e-3 量级，两套方案的学习率不能混用，这是新手最容易踩的坑之一。

4.2 四组模型的表现差异

我用参数量、最终测试准确率和单 epoch 耗时三个维度做了统计，结果如下表。需要说明的是，这个结果受随机种子、数据增强和超参数影响会有浮动，但整体趋势是稳定的：

原始 LeNet 在 CIFAR-10 上只有五成多的准确率，这个结果很说明问题：它的结构设计在更复杂的数据集上确实力不从心。你如果只看 MNIST 上的表现，根本意识不到它有这么大的短板。AlexNet 风格版用不到原始 3 倍的参数，把准确率拉高了近 20 个点，这里面 ReLU、最大池化、Dropout、通道加宽缺一不可。我自己做过消融实验，只换 ReLU 不动其他，准确率能提升约 8 个点；只加 Dropout 能提升约 6 个点；三者全上效果是叠加的。

VGG 风格版精度最高，靠的是更深的特征提取和逐级抽象。它每个阶段用两层 3×3 卷积，第一层提取局部纹理，第二层在局部纹理基础上组合出更高级的模式，这种渐进式特征提取能力是单层大卷积核给不了的。NiN 风格版让我最意外的是它的参数效率，参数量接近 Alex 风格版，精度却接近 VGG 风格版，全局平均池化省掉的分类头参数被有效转化成了卷积层的表达力。

4.3 不同改进方向的适用场景与影响边界

这次对比的价值不只是“谁分数高”，而是帮你搞清楚每种改进适合什么场景。

如果任务数据量不大、想要快速迭代，AlexNet 风格改造性价比最高：改动小、收敛快、不容易过拟合。它的限制在于深度有限，处理高分辨率图像或类别极多的任务时会遇到瓶颈。VGG 风格改造适合精度要求高、算力相对充足的场景，代价是参数量和训练时间都上去了。如果做轻量级部署，NiN 风格是首选，它把参数量压缩到极致，但结构上需要你接受“全连接头没了”这种设计变化，推理时特征图分辨率越低，全局平均池化的信息损失越不可控。

结构改进的影响范围也比想象中大。Alex 风格版的价值主要体现在训练稳定性和收敛速度上；VGG 风格版带来的是特征表达能力的跃升；NiN 风格版则直接改变了网络的参数量分布和正则化特性。你会发现，精度提升这一类结果只是表层，真正影响的是网络的学习动态：谁的梯度流动更顺畅、谁的正则化更充分、谁的容量更匹配数据，这些才是决定上限的因素。

5. 踩坑记录与工程化建议

5.1 维度与形状问题的排查套路

改造网络时遇到最多的问题就是维度对不上。我自己的习惯是：先用一个随机输入把模型跑通再训练，这个习惯帮我省了无数时间。

# 用随机数据预跑一遍，确认形状链路没问题 model = VggLeNet() x = torch.randn(4, 3, 32, 32) out = model(x) print(out.shape) # torch.Size([4, 10])

如果报错，核心看两点。第一点是展平后的维度：view(x.size(0), -1) 之前，你心里要清楚特征图到底是什么形状。比如 AlexLeNet 是 128×8×8，VggLeNet 是 128×4×4，NinLeNet 因为用了全局平均池化，根本不需要这个展平步骤。第二点是池化后的尺寸变化，尤其是当你调整 padding 或 stride 时，特征图尺寸往往会差一个像素，后续全连接输入维度就会连锁出错。遇到维度报错时，在每一层后面临时加一行 print(x.shape)，比盯着代码空想快得多。

还有一个很容易忽略的坑：参数保存和加载时，如果改了网络结构，旧权重就废了。千万别拿 AlexLeNet 的权重加载到 VggLeNet 模型里，会直接报键不匹配。

5.2 训练不收敛与过拟合的排查方向

训练不收敛最常见的原因是学习率设置不合理。ReLU 网络对学习率比 tanh 敏感得多，学习率太大容易出现损失震荡甚至变成 NaN，学习率太小又会让收敛慢到怀疑人生。我的排查顺序是：先固定 0.01 或 0.02 跑 10 个 epoch，看训练损失是否稳定下降，如果波动剧烈就降一半，如果下降太慢就翻倍，前几轮就能确定一个可用区间。

过拟合的表现是训练精度高而验证精度低，这是小规模网络上最容易出现的现象。CIFAR-10 训练集 5 万张，对改进版网络来说并不算多，所以增强和数据增强缺一不可。如果加了 Dropout 和 weight_decay 还是过拟合，优先尝试增加训练数据的随机性，比如把随机裁剪的 padding 调大，或者在归一化之外加上颜色抖动。我实测下来，这些数据增强手段带来的提升，往往比再调一个超参数更明显。

另一个隐藏坑是测试时忘了切模型模式。用 model.train() 训练完直接做验证，Dropout 还开着，每一轮验证结果都会随机波动。正确的做法是验证时调用 model.eval()，在 torch.no_grad() 下做推理。这个小细节看起来不起眼，但能让你少踩一整周的坑。

5.3 从这次改造提炼的通用设计方法

把四个网络放在一起比较之后，我提炼出了几个可以复用到其他任务的设计原则。

第一个原则：改造一个旧网络时，不要盲目推翻，先定位最大短板。LeNet 最大的问题是激活函数饱和、无正则化、通道太少，所以我优先处理这三个问题，而不是一上来就加注意力机制或者残差连接。第二个原则：不同改进手段的效果是可叠加的，但必须配套。只换 ReLU 不调学习率，只加 Dropout 不改结构，效果都会打折扣。第三个原则：用参数效率来衡量结构好坏。NiN 风格版证明了一件事——精度并不完全由参数量决定，结构的合理性更重要。

我后来把这个套路用到了其他小型任务上，比如把 VGG 风格的小卷积核堆叠思路套在一个工业缺陷检测项目上，把 NiN 风格的全局平均池化套在轻量分类模型里，效果都立竿见影。这个实验真正教会我的不是某个网络结构本身，而是怎么系统地分析和改造一个模型：先拆解它的模块，定位瓶颈，再带着明确目的去借鉴成熟方案。

最后再分享一个实际操作里的细节：每次训练都固定随机种子，不然你根本无法判断两轮实验之间的精度差异是来自模型改动还是来自数据顺序波动。在脚本开头加上 torch.manual_seed 和对应操作，这个习惯能让你所有的对比实验都更有说服力。