从零拆解CNN：核心组件、经典架构与PyTorch实战指南

1. 项目概述：从“黑盒”到“白盒”，拆解CNN的骨架与血肉

如果你刚接触深度学习，或者被各种复杂的网络结构图搞得晕头转向，那么今天这篇内容就是为你准备的。我们常把卷积神经网络（CNN）看作一个“黑盒”，输入图片，输出结果，中间过程仿佛魔法。但作为一名从业者，我深知，真正用好CNN，甚至能根据任务调整它，关键在于理解它的“整体框架”和内部“细节”。这就像组装一台精密仪器，你不仅要知道它有外壳、主板、CPU，还得清楚每个螺丝该拧在哪里，每条线路为何这样走。本文的目标，就是带你亲手把这台“仪器”拆开，看看每一个齿轮是如何咬合的，并且用最“人话”的方式，把那些看似高深的概念，比如卷积、池化、全连接，讲得明明白白。无论你是想入门计算机视觉的学生，还是需要快速应用CNN解决实际问题的工程师，这篇文章都能给你一张清晰的“装配图”和一套趁手的“工具”。

2. CNN的整体设计哲学：为什么是“卷积”？

在深入细节之前，我们必须先回答一个根本问题：为什么处理图像，大家首选CNN，而不是传统的全连接神经网络（ANN）？理解了这一点，你就能把握住CNN整个框架设计的灵魂。

想象一下，你要识别一张1000x1000像素的彩色图片。如果使用全连接网络，输入层就需要300万个神经元（100010003）。假设第一个隐藏层有1000个神经元，那么仅这一层的参数数量就高达30亿个（300万 * 1000）。这不仅是计算灾难，更关键的是，它完全忽略了图像数据一个至关重要的特性：局部相关性。

一张图片中，相邻的像素在语义上通常是高度相关的（比如同属于一只猫的耳朵），而距离很远的像素则可能毫无关系。全连接网络粗暴地将所有像素与所有神经元相连，迫使网络从头学习“像素距离近可能有关联”这个它本应天然具备的先验知识，效率极低，且极易过拟合。

CNN的设计哲学正是基于对图像这种空间结构的深刻洞察。它的核心思想是：

1. 局部感知：每个神经元不再与上一层的所有像素连接，而只连接输入区域的一个小窗口（如3x3）。这大大减少了参数数量。
2. 参数共享：同一个特征（比如一个边缘检测器）在整个图像的不同位置是通用的。这意味着，学习一个3x3的卷积核，就可以用它扫描整张图片来检测特定方向的边缘，而不是在每个位置都学习一个不同的检测器。这是CNN参数效率高的另一个关键。
3. 空间层次化：通过交替堆叠卷积层和池化层，网络能够逐步提取从低级到高级的特征。浅层网络学习边缘、角点；中层网络学习纹理、部件；深层网络则学习整个物体或场景的抽象表示。

所以，CNN的整体框架，本质上是一套为图像这类网格化数据量身定制的、高效的特征提取流水线。它的结构不是随意的，每一层都有其明确的职责和设计考量。

注意：很多人初学时会纠结于“为什么是3x3卷积核？”、“池化层是不是必须的？”。记住，这些是经典设计，源于实践和理论验证，但并非金科玉律。理解其背后的原因（局部性、平移不变性、降维），比死记硬背结构更重要。

3. 核心组件细节拆解：从卷积核到激活函数

现在，我们进入“显微镜”模式，仔细审视构成CNN框架的每一个核心部件。

3.1 卷积层：特征提取的“扫描仪”

卷积层是CNN的发动机。它的操作可以形象地理解为拿着一把小刷子（卷积核），在输入图像上从左到右、从上到下地滑动，进行局部区域的加权求和。

关键细节与计算过程：假设我们有一个5x5的单通道输入图像，使用一个3x3的卷积核，步长（stride）为1，不进行填充（padding）。

• 输入：5x5 矩阵I
• 卷积核：3x3 矩阵K
• 输出：一个3x3的特征图（Feature Map）。

计算输出特征图左上角第一个值的过程如下：

1. 将卷积核K覆盖在输入I的左上角3x3区域。
2. 对应位置元素相乘后求和：O[0,0] = I[0:3, 0:3] * K（逐元素乘积累加）。
3. 将卷积核向右滑动一个步长（stride=1），重复步骤2，得到O[0,1]。
4. 以此类推，直至扫描完整个输入区域。

为什么参数这么少？一个3x3卷积核有9个参数（+1个偏置）。假设这一层输出256个这样的特征图（即256个卷积核），那么参数总量是(3*3)*256 + 256 = 2560。如果使用全连接，即使输入是经过下采样的小特征图，参数也轻易上百万。这种效率是革命性的。

实操心得：

• 小卷积核的堆叠：现代网络（如VGGNet）普遍使用连续的3x3卷积来替代大的5x5或7x7卷积。两个3x3卷积层的感受野（能看到的输入区域）等同于一个5x5卷积层，但参数更少（233=18 vs 5*5=25），且引入了更多的非线性激活，使网络表达能力更强。
• 1x1卷积的妙用：1x1卷积不进行空间聚合，它的核心作用是进行通道间的信息融合与降维。在GoogLeNet的Inception模块和ResNet中广泛应用，能以极低的成本调整特征图的通道数，实现“网络中的网络”效果。

3.2 池化层：信息浓缩的“蒸馏器”

池化层通常跟在卷积层后面，主要作用是降维（下采样），减少数据量和参数，同时保持特征的不变性。

最大池化 vs 平均池化：

• 最大池化：取窗口内的最大值。它更强调纹理特征的保留，能更好地捕捉边缘、角点等显著性特征，在实践中更常用。
• 平均池化：取窗口内的平均值。它对背景信息更友好，但有时会稀释掉重要的特征信号。

例如，一个2x2最大池化，步长为2，会将一个4x4区域浓缩为1个值（该区域最大值）。这使后续层能在一个更抽象、更广阔的视野（感受野变大）上观察特征。

为什么需要池化？

1. 平移不变性增强：物体在图像中轻微移动，经过池化后，其高级特征表示可能变化不大。
2. 防止过拟合：减少参数和计算量。
3. 扩大感受野：让更深层的神经元能看到原始输入中更广阔的区域。

当前趋势：在一些现代架构中（如Striving for Simplicity: The All Convolutional Net），研究者发现带步长的卷积（Strided Convolution）有时可以替代池化层，在降维的同时还能学习更优的下采样方式。但池化因其简单、高效、稳定，在大多数基础模型中仍是标准配置。

3.3 激活函数：引入非线性的“火花塞”

如果没有激活函数，无论堆叠多少层卷积和线性运算，整个网络最终等价于一个线性模型，无法拟合复杂函数。激活函数为网络注入了非线性。

ReLU（Rectified Linear Unit）及其变种：

• 标准ReLU：f(x) = max(0, x)。这是目前最常用、默认的激活函数。它计算简单，能有效缓解梯度消失问题（对于正区间）。
• 缺陷：“Dead ReLU”问题。当输入为负时，梯度恒为0，神经元可能永远无法被激活。
• 变种：
  • Leaky ReLU：f(x) = max(αx, x)， α是一个很小的正数（如0.01）。给负区间一个微小的梯度，缓解“死亡”问题。
  • Parametric ReLU (PReLU)：将Leaky ReLU中的α作为可学习参数，让网络自己决定负区间的斜率。
  • ELU：在负区间使用指数函数，使得输出均值更接近0，可能加快训练速度。

选择建议：对于新手和大多数任务，直接使用标准ReLU即可。如果训练中发现大量神经元输出为0，可以考虑尝试Leaky ReLU或PReLU。

3.4 全连接层：决策的“法官”

在卷积和池化层提取了丰富的空间层次特征后，我们需要将这些特征“拍平”，用于最终的分类或回归任务。这就是全连接层的工作。

具体过程：

1. 将最后一个卷积/池化层输出的三维特征图（高度 x 宽度 x 通道数）展平（Flatten）成一个一维长向量。
2. 将这个向量输入到一个或几个全连接层中。每个全连接层就是一个传统的多层感知机。
3. 最后一个全连接层的输出节点数等于目标类别数（分类任务），其后通常接一个Softmax函数，将输出转换为概率分布。

全连接层的问题与演进： 全连接层参数巨大（通常占整个网络参数的80%以上），容易过拟合。因此，现代网络设计趋势是减少或移除全连接层。

• 全局平均池化（GAP）：在最后卷积层的输出上，对每个特征图直接取全局平均值，得到一个通道数长度的向量，直接送入Softmax。这彻底消除了全连接参数（如Network in Network, GoogLeNet后续版本）。
• 1x1卷积 + GAP：成为许多轻量级网络（如SqueezeNet）和高效架构的标准分类头。

4. 经典CNN架构演进与核心思想剖析

理解了零件，我们再来看看大师们是如何将它们组装成一部部性能强悍的“引擎”的。通过剖析经典模型，我们能更深刻地理解框架设计的精妙之处。

4.1 LeNet-5：开山鼻祖

Yann LeCun于1998年提出的LeNet-5，用于手写数字识别，确立了CNN的基本范式：卷积 -> 池化 -> 卷积 -> 池化 -> 全连接 -> 输出。它虽然简单，但包含了所有核心思想。其输入是32x32的灰度图，在今天看来微不足道，但在当时是突破性的。

4.2 AlexNet：深度学习的引爆点

2012年ImageNet竞赛冠军，将CNN带入大众视野。其关键细节包括：

• 使用ReLU激活函数：相比传统的Sigmoid/Tanh，大幅缓解梯度消失，训练更快。
• 使用Dropout：在全连接层随机丢弃部分神经元，强力正则化，防止过拟合。
• 数据增强：对训练图像进行随机裁剪、翻转等，增加数据多样性。
• 局部响应归一化（LRN）：后来被证明效果有限，已被更先进的Batch Normalization取代。

4.3 VGGNet：深度与规整之美

VGGNet（如VGG-16）的核心思想是堆叠更小的卷积核。它全部使用3x3卷积和2x2最大池化，通过增加网络深度（16-19层）来提升性能。这种设计使得网络结构非常规整、易于理解，但参数量巨大（主要在全连接层），计算成本高。

4.4 GoogLeNet (Inception v1)：宽度与高效

Inception模块的核心思想是在单一层内进行多尺度特征融合。一个Inception模块并行使用1x1, 3x3, 5x5卷积和3x3池化，然后将所有结果在通道维度拼接。为了控制计算量，在3x3和5x5卷积前，以及池化后，巧妙地引入了1x1卷积进行降维。这种设计让网络在每一层都能选择最合适的特征提取尺度，且计算高效。

4.5 ResNet：残差学习，深度难题的钥匙

当网络深度超过20层后，性能不升反降，这是梯度消失/爆炸和网络退化导致的。ResNet提出的残差块（Residual Block）是革命性的。 其核心公式是：输出 = F(x) + x，其中x是输入，F(x)是卷积层要学习的目标。为什么有效？网络不再学习一个完整的输出，而是学习输出与输入之间的残差（差值）。这使得恒等映射变得容易（只需将F(x)学习为0），梯度可以直接通过快捷连接（Shortcut Connection）回传，极大缓解了深度网络的训练难题，使得训练数百甚至上千层的网络成为可能。

4.6 轻量化网络：MobileNet, ShuffleNet

这些网络专为移动和嵌入式设备设计。其核心思想是分解标准卷积：

• 深度可分离卷积：将标准卷积分解为深度卷积（每个通道独立卷积）和逐点卷积（1x1卷积，进行通道融合）。这能大幅减少计算量和参数。
• 通道混洗：在组卷积之后，通过通道混洗操作促进不同组之间的信息交流。

5. 从理论到实践：构建一个CNN模型的完整流程

纸上得来终觉浅，绝知此事要躬行。下面，我们以PyTorch框架为例，手把手走一遍构建、训练、评估一个简单CNN（比如用于CIFAR-10分类）的完整流程，并穿插关键细节。

5.1 环境准备与数据加载

首先，确保安装了PyTorch和TorchVision。数据加载是第一步，也是容易出错的一步。

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms # 1. 定义数据预处理变换 # 训练集通常需要数据增强，验证/测试集则不需要 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), # 随机裁剪（增强） transforms.RandomHorizontalFlip(), # 随机水平翻转（增强） transforms.ToTensor(), # 转为Tensor，并归一化到[0,1] transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), # CIFAR-10的均值和标准差 ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) # 2. 加载数据集 trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)

实操心得：Normalize的均值和标准差参数需要根据数据集计算。使用预计算值能加速模型收敛。数据增强是防止过拟合、提升模型泛化能力的廉价且有效的手段，务必根据任务添加（如对于医学影像，随机翻转可能不适用）。

5.2 网络模型定义

我们来定义一个简化版的VGG风格网络。

class SimpleCNN(nn.Module): def __init__(self, num_classes=10): super(SimpleCNN, self).__init__() # 特征提取部分 self.features = nn.Sequential( # 卷积块1: 输入3通道， 输出32通道 nn.Conv2d(3, 32, kernel_size=3, padding=1), # 保持尺寸 (32x32) nn.BatchNorm2d(32), # 批归一化，加速训练，提升稳定性 nn.ReLU(inplace=True), nn.Conv2d(32, 32, kernel_size=3, padding=1), nn.BatchNorm2d(32), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # 尺寸减半 (16x16) # 卷积块2 nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # (8x8) # 卷积块3 nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), # (4x4) ) # 分类器部分 self.classifier = nn.Sequential( nn.Dropout(p=0.5), # Dropout防止过拟合 nn.Linear(128 * 4 * 4, 512), # 展平后的大小: 128*4*4 nn.ReLU(inplace=True), nn.Dropout(p=0.5), nn.Linear(512, num_classes) ) def forward(self, x): x = self.features(x) # 提取特征 x = torch.flatten(x, 1) # 展平，维度为 (batch_size, 128*4*4) x = self.classifier(x) # 分类 return x net = SimpleCNN()

关键细节解析：

• Padding=1：对于3x3卷积核，设置padding=1可以保持特征图的空间尺寸不变（输出尺寸 = (输入尺寸 - 核大小 + 2*padding)/stride + 1）。这便于我们计算和堆叠层。
• BatchNorm2d：批归一化层。它会对每一个批次的数据，在每个通道上进行归一化（减均值，除标准差），然后进行缩放和平移。它的作用是：极大缓解内部协变量偏移，允许使用更高的学习率，起到一定的正则化效果，是训练深层网络的“标配”。注意：在训练和测试时，BatchNorm的行为不同（训练时用批次统计量，测试时用移动平均统计量），PyTorch的model.eval()会自动处理。
• inplace=True：让ReLU操作直接在原内存上进行，节省少量显存。
• Dropout：在全连接层使用，随机将一部分神经元的输出置零。这是一种集成学习的思路，强迫网络不依赖于某些特定的神经元，增强鲁棒性。

5.3 训练循环与超参数设置

训练过程是模型学习的核心。

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net.to(device) criterion = nn.CrossEntropyLoss() # 多分类交叉熵损失 optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4) # 优化器 scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200) # 学习率调度器 def train(epoch): net.train() running_loss = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() # 梯度清零！这是易错点 outputs = net(inputs) # 前向传播 loss = criterion(outputs, labels) # 计算损失 loss.backward() # 反向传播，计算梯度 optimizer.step() # 优化器更新参数 running_loss += loss.item() if i % 100 == 99: # 每100个batch打印一次 print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 100:.3f}') running_loss = 0.0 def test(): net.eval() # 切换到评估模式，影响Dropout和BatchNorm correct = 0 total = 0 with torch.no_grad(): # 不计算梯度，节省内存和计算 for data in testloader: images, labels = data images, labels = images.to(device), labels.to(device) outputs = net(images) _, predicted = torch.max(outputs.data, 1) # 取概率最大的类别 total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100 * correct / total print(f'Accuracy on test set: {accuracy:.2f}%') return accuracy # 开始训练 for epoch in range(50): # 训练50个epoch train(epoch) scheduler.step() # 更新学习率 test() # 每个epoch结束后测试一次

超参数设置详解：

• 学习率（lr）：最重要的超参数。初始值0.1对于SGD优化器是常见起点。太大容易震荡不收敛，太小则收敛慢。
• 动量（momentum）：帮助优化器在正确方向上加速，并抑制震荡。0.9是常用值。
• 权重衰减（weight_decay）：即L2正则化，惩罚大的权重，防止过拟合。5e-4是CNN中常用的值。
• 学习率调度器（scheduler）：CosineAnnealingLR让学习率按余弦曲线从初始值衰减到0，是一种平滑且有效的策略。
• Batch Size：影响梯度估计的噪声和内存占用。较大的batch（如128, 256）训练更稳定，但可能泛化能力稍差；较小的batch噪声大，有时泛化更好。需要根据GPU内存调整。

5.4 模型评估与可视化理解

训练完成后，除了看测试集准确率，我们还可以深入看看模型到底学到了什么。

可视化卷积核：第一层卷积核直接处理原始像素，我们可以将其可视化，看看网络底层在寻找什么模式（通常是各种方向的边缘和色块）。

import matplotlib.pyplot as plt import numpy as np # 获取第一层卷积层的权重 weights = net.features[0].weight.data.cpu().numpy() # 形状: [out_channels, in_channels, kH, kW] fig, axes = plt.subplots(4, 8, figsize=(12, 6)) # 假设第一层输出32个通道 for i, ax in enumerate(axes.flat): if i < weights.shape[0]: # 对于RGB输入，取每个卷积核三个通道的平均值或分别显示 kernel = weights[i].mean(axis=0) # 平均 across RGB channels ax.imshow(kernel, cmap='gray') ax.axis('off') plt.suptitle('First Conv Layer Filters (Averaged across RGB)') plt.show()

可视化特征图：将某张图片输入网络，查看中间某层卷积层的输出特征图，可以直观理解不同通道关注图像的哪些部分。

def visualize_feature_maps(model, image_tensor, layer_index=0): model.eval() # 注册钩子来获取中间层输出 features = [] def hook_fn(module, input, output): features.append(output) hook = model.features[layer_index].register_forward_hook(hook_fn) with torch.no_grad(): _ = model(image_tensor.unsqueeze(0).to(device)) # 增加batch维度 hook.remove() # 移除钩子 feature_maps = features[0].squeeze(0).cpu().numpy() # [channels, H, W] # 绘制前若干个特征图 num_maps = min(16, feature_maps.shape[0]) fig, axes = plt.subplots(4, 4, figsize=(10, 10)) for i, ax in enumerate(axes.flat): if i < num_maps: ax.imshow(feature_maps[i], cmap='viridis') ax.axis('off') plt.suptitle(f'Feature Maps from Layer {layer_index}') plt.show() # 取一张测试图片 sample_data = next(iter(testloader)) sample_image, _ = sample_data visualize_feature_maps(net, sample_image[0], layer_index=4) # 可视化第二个卷积块后的特征

6. 常见问题、调优技巧与避坑指南

在实际操作中，你一定会遇到各种各样的问题。下面是我从无数次“炼丹”中总结出的经验。

6.1 模型不学习（Loss不下降）

这是新手最常遇到的问题。

• 检查数据与标签：首先确保数据加载正确。打印几张图片和对应的标签看看是否匹配。检查预处理（特别是归一化）是否正确。
• 检查损失函数：分类任务用交叉熵损失（nn.CrossEntropyLoss），回归任务用均方误差损失（nn.MSELoss）。别用错。
• 检查学习率：学习率设置不当是首要原因！尝试一个较大的范围进行扫描，如[1e-5, 1e-4, 1e-3, 1e-2, 0.1]。现代研究也常使用学习率预热（Warmup）策略，开始用很小的学习率，再逐步增大，有助于训练稳定。
• 检查梯度：在反向传播后，打印某些层权重的梯度范数。如果梯度接近0，可能是梯度消失，考虑使用残差连接、调整激活函数、或检查网络初始化。如果梯度是NaN，可能是数据有问题或学习率太高。
• 检查模型初始化：错误的初始化可能导致训练初期就陷入僵局。使用PyTorch默认的初始化通常没问题，对于深层网络，可以考虑使用He初始化（配合ReLU）或Xavier初始化。

6.2 模型过拟合（训练集精度高，测试集精度低）

• 获取更多数据：最有效的方法，但往往最难。
• 数据增强：如前所述，这是成本最低的正则化手段。根据任务设计增强策略（裁剪、翻转、旋转、颜色抖动、MixUp、CutMix等）。
• 正则化技术：
  • Dropout：如前所述，在全连接层和卷积层后都可以加。
  • 权重衰减（L2正则化）：在优化器中设置weight_decay参数。
  • Batch Normalization：本身也有轻微的正则化效果。
• 降低模型复杂度：减少网络层数或每层的通道数。在性能和泛化间取得平衡。
• 早停（Early Stopping）：监控验证集损失，当连续多个epoch不再下降时，停止训练。

6.3 训练不稳定（Loss震荡剧烈或爆炸）

• 降低学习率：这是最直接的解决方法。
• 使用梯度裁剪（Gradient Clipping）：特别是在训练RNN或非常深的网络时，可以防止梯度爆炸。

  torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

• 使用更稳定的优化器：从SGD with Momentum可以尝试切换到Adam或AdamW（Adam with decoupled weight decay）。Adam对学习率不那么敏感，通常能更快收敛，但最终泛化性能有时不如精调过的SGD。
• 确保BatchNorm处于正确模式：训练时用model.train()，评估时用model.eval()。

6.4 选择什么样的网络结构？

• 新手入门/基线模型：从ResNet-18/34或VGG-11/13开始。它们结构清晰，实现简单，预训练模型丰富。
• 追求高精度：ResNet-50/101/152、DenseNet、EfficientNet。这些是ImageNet等大型竞赛的常客。
• 移动端/嵌入式部署：MobileNet系列、ShuffleNet系列、EfficientNet-Lite。它们在精度和速度间取得了优秀平衡。
• 自定义任务：建议以成熟架构（如ResNet）为骨干网络，替换掉最后的分类头，适配你的任务（如分类数）。利用迁移学习，加载在ImageNet上预训练的权重，能极大加速收敛并提升性能。

6.5 一个实用的调优检查清单

在项目开始时，可以按以下顺序检查和调整：

1. 数据：加载、可视化、确保无误。应用恰当的数据增强。
2. 基线模型：选择一个简单模型（如文中的SimpleCNN），在小批量数据上过拟合。如果能在几十个样本上达到接近100%的训练精度，说明模型实现、数据流、损失函数基本正确。
3. 学习率：在完整数据上，使用学习率查找器（如PyTorch Lightning内置或自己实现）找到一个合适的初始学习率范围。
4. 正则化：加入Dropout、权重衰减、数据增强。如果出现过拟合，增强这些；如果欠拟合，减弱这些。
5. 架构搜索：尝试更深的网络（ResNet）、更宽的网络、或加入注意力机制等。
6. 超参数微调：对学习率调度、优化器参数（如Adam的beta）、Batch Size等进行网格搜索或随机搜索。
7. 集成：如果还有提升空间，可以训练多个模型进行集成。

记住，深度学习实验是迭代式的。一次只改变一个变量，并做好详细的实验记录（包括超参数、环境、结果），这是通往成功的唯一路径。