1. 先搞清楚这些经典CNN到底解决了什么问题

如果你刚开始接触深度学习，看到LeNet、AlexNet、VGGNet、GoogleNet、ResNet这一串名字可能会觉得头大。其实这些网络不是凭空出现的，每一个都是在解决前一个网络遇到的实际问题。

LeNet最早用于手写数字识别，证明了卷积神经网络（CNN）在图像识别上的可行性。但它的网络很浅，只能处理简单的小图片。

AlexNet在2012年ImageNet竞赛中一战成名，关键突破是证明了深层CNN的有效性，并且解决了训练深层网络的技术难题——比如用ReLU激活函数缓解梯度消失，用Dropout减少过拟合。

VGGNet的核心贡献是展示了网络深度的重要性，通过堆叠3x3小卷积核来构建更深的网络。但VGG参数量巨大，计算成本高。

GoogleNet（Inception）解决了深度和计算成本的平衡问题，提出了Inception模块，在同一层使用不同大小的卷积核并行处理，既增加了网络宽度又控制了参数数量。

ResNet则解决了深层网络训练中的梯度消失问题，通过残差连接让网络可以做到上百层甚至上千层还能正常训练。

我建议新手不要一上来就死记网络结构，而是先理解每个网络要解决的核心问题。这样当你自己设计网络时，才知道为什么要选择某种结构。

2. 环境配置：选对工具比盲目安装更重要

深度学习环境配置是很多新手的第一个坎。我见过太多人在这里浪费好几天时间，其实问题往往出在基础环节。

如果你用Windows系统，最省心的方案是直接安装Anaconda，然后用conda创建独立环境。不要直接在系统Python里装各种包，否则后面版本冲突会让你崩溃。

conda create -n deeplearning python=3.8 conda activate deeplearning conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

如果你的显卡不支持CUDA，就用CPU版本：

conda install pytorch torchvision torchaudio cpuonly -c pytorch

Linux用户更简单，直接用系统包管理器安装Python3.8+和pip，然后pip安装PyTorch即可。

我强烈建议新手先用CPU版本跑通整个流程，再考虑GPU加速。很多问题其实跟GPU无关，先用CPU排除基础问题更高效。

验证安装是否成功：

import torch import torchvision print(torch.__version__) print(torch.cuda.is_available()) # 显示是否支持GPU

如果这些命令能正常执行，说明基础环境没问题。不要一上来就追求最新版本，PyTorch 1.8+、TensorFlow 2.4+对于学习这些经典网络完全够用。

3. LeNet实战：从最简单的网络开始理解CNN

LeNet虽然简单，但包含了CNN的所有核心组件：卷积层、池化层、全连接层。这是理解CNN工作原理的最佳起点。

我们先在PyTorch里实现一个简化版LeNet：

import torch.nn as nn import torch.nn.functional as F class LeNet(nn.Module): def __init__(self): super(LeNet, self).__init__() self.conv1 = nn.Conv2d(1, 6, 5) # 输入通道1，输出通道6，卷积核5x5 self.pool = nn.AvgPool2d(2, 2) # 2x2平均池化 self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 4 * 4, 120) # 全连接层 self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) # 10分类输出 def forward(self, x): x = self.pool(F.relu(self.conv1(x))) # 卷积->激活->池化 x = self.pool(F.relu(self.conv2(x))) x = x.view(-1, 16 * 4 * 4) # 展平 x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x

关键要理解每个层的输入输出尺寸变化。比如第一层卷积：输入1x32x32（单通道32x32图像），经过6个5x5卷积核，输出6x28x28（32-5+1=28）。然后2x2池化，尺寸减半变成6x14x14。

实际训练时，我建议先用MNIST数据集测试，因为图片小、训练快：

from torchvision import datasets, transforms transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST('./data', train=False, transform=transform)

LeNet在MNIST上通常能达到98%+的准确率。如果达不到，先检查数据预处理和学习率设置，不要急着改网络结构。

4. AlexNet突破：深层网络训练的关键技术

AlexNet之所以重要，是因为它证明了深层CNN的可行性。但它的网络结构比LeNet复杂得多，参数量增加了数十倍。

AlexNet的核心改进有三点：

ReLU激活函数：之前常用sigmoid或tanh，在深层网络中容易出现梯度消失。ReLU计算简单，梯度要么是0要么是1，有效缓解了这个问题。

Dropout正则化：在全连接层使用Dropout，随机让一部分神经元失活，防止过拟合。训练时Dropout率通常设0.5，预测时关闭。

局部响应归一化：现在很少用了，当时是为了模仿生物神经元的侧抑制机制。

AlexNet的PyTorch实现：

class AlexNet(nn.Module): def __init__(self, num_classes=1000): super(AlexNet, self).__init__() self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(64, 192, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(192, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 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=3, stride=2), ) self.classifier = nn.Sequential( nn.Dropout(), nn.Linear(256 * 6 * 6, 4096), nn.ReLU(inplace=True), nn.Dropout(), 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), 256 * 6 * 6) x = self.classifier(x) return x

训练AlexNet时，batch size不能太小，否则收敛不稳定。如果显存不够，可以减小输入图像尺寸（从224x224降到128x128），或者使用梯度累积。

5. VGGNet：深度的重要性与3x3卷积核的优势

VGGNet的核心思想很简单：用堆叠的小卷积核代替大卷积核。比如两个3x3卷积堆叠的感受野相当于一个5x5卷积，但参数量更少（2*(3^2)=18 vs 5^2=25），而且多了非线性激活。

VGG常用的有VGG16和VGG19，数字代表带权重的层数。实现VGG16：

class VGG16(nn.Module): def __init__(self, num_classes=1000): super(VGG16, self).__init__() self.features = nn.Sequential( # 第一个卷积块：2层64通道 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), # 第二个卷积块：2层128通道 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), # 第三到第五个卷积块（略） ) self.classifier = nn.Sequential( nn.Linear(512 * 7 * 7, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, num_classes), )

VGGNet的缺点是参数量巨大，全连接层就占了大部分参数。实际使用时，我建议在ImageNet预训练模型基础上做微调，而不是从头训练。

如果显存不够，可以去掉最后一个全连接层，或者使用全局平均池化代替全连接层。

6. GoogleNet：Inception模块与计算效率的平衡

GoogleNet的核心创新是Inception模块，在同一层使用不同大小的卷积核并行处理，然后合并结果。这样既增加了网络宽度（提取多尺度特征），又控制了计算成本。

基础Inception模块结构：

class InceptionModule(nn.Module): def __init__(self, in_channels, out1x1, out3x3_reduce, out3x3, out5x5_reduce, out5x5, out_pool): super(InceptionModule, self).__init__() # 1x1卷积分支 self.branch1 = nn.Sequential( nn.Conv2d(in_channels, out1x1, kernel_size=1), nn.ReLU(inplace=True) ) # 3x3卷积分支（先1x1降维） self.branch2 = nn.Sequential( nn.Conv2d(in_channels, out3x3_reduce, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(out3x3_reduce, out3x3, kernel_size=3, padding=1), nn.ReLU(inplace=True) ) # 5x5卷积分支（先1x1降维） self.branch3 = nn.Sequential( nn.Conv2d(in_channels, out5x5_reduce, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(out5x5_reduce, out5x5, 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, out_pool, kernel_size=1), nn.ReLU(inplace=True) ) def forward(self, x): return torch.cat([self.branch1(x), self.branch2(x), self.branch3(x), self.branch4(x)], 1)

GoogleNet还引入了辅助分类器，在中间层添加额外的输出分支，帮助梯度回传，缓解梯度消失问题。

实际使用中，Inception模块的计算效率确实比单纯堆叠卷积层高，但代码复杂度也增加了。对于资源紧张的项目，要权衡这种复杂度带来的收益。

7. ResNet：残差连接解决深层网络训练难题

ResNet的残差连接是深度学习领域的重要突破，让网络可以做到几百层甚至上千层还能正常训练。

核心思想很简单：如果深层网络难以训练，那就让网络学习残差（差值），而不是直接学习目标映射。

基本残差块实现：

class BasicBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super(BasicBlock, self).__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) # shortcut连接，如果输入输出维度不一致需要1x1卷积调整 self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_channels) ) def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) # 残差连接 out = F.relu(out) return out

ResNet有18、34、50、101、152等不同深度版本。ResNet50及更深的网络使用Bottleneck模块，通过1x1卷积先降维再升维，减少计算量。

训练ResNet时，学习率设置很关键。我一般用余弦退火或者分段下降策略，初始学习率设0.1，每30轮乘以0.1。

8. 实战建议：如何选择和应用这些经典网络

学完这些网络后，关键是要知道在什么场景下用什么网络。我总结了一个简单选择指南：

小数据集简单任务：用LeNet或简单CNN就够了，复杂网络容易过拟合。

中等规模数据：用ResNet18/34或VGG11/13，在ImageNet预训练基础上微调。

大规模数据：用ResNet50/101、GoogleNet等更深的网络。

计算资源紧张：优先考虑GoogleNet或MobileNet，参数量少计算快。

需要高精度：ResNet152或者更现代的EfficientNet、Vision Transformer。

实际项目中，我建议先用ResNet50作为基线模型，因为它平衡了性能、速度和资源消耗。如果效果不够再尝试更复杂的网络。

预训练模型的使用技巧：

import torchvision.models as models # 加载预训练ResNet50 model = models.resnet50(pretrained=True) # 修改最后一层适配你的任务 num_features = model.fc.in_features model.fc = nn.Linear(num_features, your_num_classes) # 只训练最后一层（快速微调） for param in model.parameters(): param.requires_grad = False for param in model.fc.parameters(): param.requires_grad = True

训练时，数据增强很重要。至少要用随机水平翻转、随机裁剪、颜色抖动等基础增强。

最后提醒一点：不要盲目追求网络深度和复杂度。先确保数据质量、标注准确、预处理正确，这些基础问题解决后，再考虑模型优化。