经典CNN架构（LeNet/AlexNet/VGG） - 学习笔记-深度学习-上海佼艾

一、架构演进概览

卷积神经网络（Convolutional Neural Network, CNN）是深度学习时代计算机视觉领域最核心的技术支柱。从1998年Yann LeCun提出LeNet-5，到2012年AlexNet在ImageNet大赛上以绝对优势夺冠，再到2014年VGGNet以极简设计统一架构风格，这三条里程碑式的网络架构完整记录了深度学习从萌芽到爆发的演进历程。

本章将对三大经典CNN架构进行系统梳理，涵盖设计思想、核心创新、网络结构、代码实现和实战应用，帮助读者建立从历史脉络到技术细节的完整认知。理解这些基础架构，是掌握ResNet、Inception、MobileNet等现代网络的重要前提。

三大架构的历史定位

LeNet-5（1998）： 奠定CNN基本范式 — Conv + Pool + FC 的三段式结构
AlexNet（2012）： 引爆深度学习革命 — 大规模GPU训练 + ReLU/Dropout/LRN等关键技术
VGGNet（2014）： 极简主义设计哲学 — 统一的小卷积核堆叠策略，证明深度的重要性

二、LeNet-5：卷积神经网络的奠基者

2.1 诞生背景

LeNet-5由Yann LeCun等人在1998年提出，最初用于手写数字识别（MNIST数据集）。在传统机器学习方法（如SVM、K近邻）主导的时代，LeNet-5展示了端到端学习的强大能力：原始像素直接输入网络，经过卷积、池化、全连接层后输出分类结果，无需手工设计特征。这一"端到端"思想深刻影响了后续所有深度学习架构。

2.2 网络结构详解

LeNet-5的结构简洁而优雅，包含7层（不含输入层）：2个卷积层、2个池化层、3个全连接层。其整体结构可以概括为：输入 → Conv1 → Pool1 → Conv2 → Pool2 → FC3 → FC4 → FC5(输出)。

LeNet-5 网络结构示意: 输入: 32x32 灰度图像 │ [Conv1] 6@28x28 (5x5卷积核, stride=1) │ [Pool1] 6@14x14 (2x2平均池化, stride=2) │ [Conv2] 16@10x10 (5x5卷积核, stride=1) │ [Pool2] 16@5x5 (2x2平均池化, stride=2) │ [FC3] 120 个神经元 │ [FC4] 84 个神经元 │ [FC5] 10 个类别 (Softmax输出)

2.3 核心设计特点

卷积-池化交替提取特征： 每层卷积后紧跟池化层，逐步降低空间尺寸同时增加通道数，这是CNN处理图像的基本范式
稀疏连接与权值共享： 每个卷积核只连接局部感受野，同一卷积核在不同位置共享参数，极大减少参数量
多尺度特征融合： Conv2层使用了非对称连接表（部分卷积核只连接前一层特定特征图），增加特征多样性
原始激活函数： 使用sigmoid/tanh作为激活函数（ReLU尚未提出），训练速度较慢

参数量分析

LeNet-5的总参数量约为6.1万，其中卷积层占比约5%，全连接层占比约95%。这一特点在后续网络中持续存在——全连接层往往是参数量的大头，这也是后来全局平均池化（Global Average Pooling）被提出的重要原因。

2.4 MNIST实战效果

LeNet-5在MNIST数据集上取得了约0.9%的错误率，在当时是业界顶尖水平。时至今日，LeNet-5仍然是入门深度学习的经典教学案例，其代码实现仅需几十行PyTorch代码，却完整展现了一个深度学习项目的全部要素：数据加载、模型定义、训练循环、评估流程。

LeNet-5 的意义不仅在于手写数字识别，更在于它首次证明了：通过梯度下降训练的卷积神经网络可以在实际应用（支票识别、邮政分拣）中达到实用水平。这一思想在二十年后成为整个计算机视觉领域的基石。

三、AlexNet：深度学习革命的引爆点

3.1 历史性突破

2012年，Alex Krizhevsky、Ilya Sutskever和Geoffrey Hinton提出的AlexNet在ImageNet大规模视觉识别挑战赛（ILSVRC 2012）上取得了惊人的成绩：Top-5错误率15.3%，相比第二名（26.2%）提升了超过10个百分点。这一突破性结果彻底引爆了深度学习革命，开启了计算机视觉的新纪元。从此，CNN取代手工特征成为视觉识别的主流方法。

3.2 网络结构

AlexNet包含8层可学习参数：5个卷积层 + 3个全连接层。其输入为224×224×3的彩色图像，输出为1000个类别的概率分布。在原始设计中，由于当时GPU显存限制（NVIDIA GTX 580仅3GB显存），网络被拆分为在两个GPU上并行训练。

AlexNet 网络结构示意: 输入: 224x224x3 彩色图像 │ [Conv1] 96@55x55 (11x11, stride=4) → ReLU → LRN → MaxPool(3x3, s=2) │ [Conv2] 256@27x27 (5x5, stride=1, pad=2) → ReLU → LRN → MaxPool(3x3, s=2) │ [Conv3] 384@13x13 (3x3, stride=1, pad=1) → ReLU │ [Conv4] 384@13x13 (3x3, stride=1, pad=1) → ReLU │ [Conv5] 256@13x13 (3x3, stride=1, pad=1) → ReLU → MaxPool(3x3, s=2) │ [FC6] 4096 → ReLU → Dropout(0.5) │ [FC7] 4096 → ReLU → Dropout(0.5) │ [FC8] 1000 → Softmax

3.3 核心创新点

（1）ReLU激活函数

AlexNet使用ReLU（Rectified Linear Unit, f(x) = max(0, x)）替代传统的sigmoid/tanh。ReLU的梯度在正半轴恒为1，有效解决了深层网络中的梯度消失问题，同时大幅加快了训练速度——AlexNet在实验中达到相同错误率的速度比使用tanh快6倍。这一看似简单的改变，是深层网络训练成功的关键因素之一。

（2）Dropout正则化

在全连接层中引入Dropout（随机丢弃50%的神经元），训练时每次迭代都训练一个不同的子网络，相当于在多个子网络间共享权重进行集成学习。Dropout有效防止了全连接层（参数量巨大）的过拟合，成为深度学习中最经典的正则化技术之一。

（3）局部响应归一化（LRN）

LRN模拟了生物神经元的侧抑制（lateral inhibition）机制，在相邻通道间进行归一化，突出响应较大的神经元、抑制响应较小的神经元。这一技术在后续的VGG中被逐步弃用（实验证明其作用有限），但在AlexNet中是重要的性能提升手段。

（4）数据增强

AlexNet在训练时大量使用数据增强技术：水平翻转、随机裁剪（从256×256图像中随机裁剪224×224区域）、PCA颜色增强等。数据增强将训练集扩大了数千倍，显著提升了模型的泛化能力。

（5）重叠池化

使用stride=2、size=3的重叠池化（重叠1个单位），相比非重叠池化（stride=2、size=2）略微提升精度并降低过拟合。这项技术虽然细节很小，但体现了AlexNet团队对每个设计环节的精益求精。

AlexNet的关键参数汇总

总参数量：约6200万（其中全连接层占约5800万）
计算量：约1.1 GFLOPs（单次前向传播）
训练数据：ImageNet 120万张训练图像，1000个类别
训练耗时：使用2块GTX 580 GPU训练约5-6天
Top-5错误率：15.3%（ILSVRC 2012冠军）

"AlexNet的成功不仅仅是算法创新，更是一次'正确工程选择'的胜利：足够大的数据集（ImageNet）、足够强的算力（GPU）、足够好的激活函数（ReLU）、足够有效的正则化（Dropout），这些因素的结合才是深度学习爆发的真正原因。"

四、VGGNet：深度与简洁的完美平衡

4.1 设计哲学

2014年，牛津大学视觉几何组（Visual Geometry Group）的Karen Simonyan和Andrew Zisserman提出了VGGNet。其最显著的设计特点是使用统一的3×3小卷积核堆叠，取代AlexNet中使用的大卷积核（11×11, 5×5）。这一设计理念的核心洞察来自感受野分析：两个3×3卷积的堆叠等效于一个5×5卷积的感受野，三个3×3卷积的堆叠等效于一个7×7卷积的感受野，但具有更少的参数和更多的非线性变换。

4.2 网络结构：VGG16与VGG19

VGGNet有多个变体，其中最常用的是VGG16（13个卷积层 + 3个全连接层）和VGG19（16个卷积层 + 3个全连接层）。网络的整体结构被划分为5个卷积块（block），每个块内堆叠多个3×3卷积层，块之间通过2×2最大池化进行下采样。随着网络加深，特征图的通道数逐块翻倍：64 → 128 → 256 → 512 → 512。

VGG16 网络结构示意: 输入: 224x224x3 │ Block1: [Conv3-64] ×2 → MaxPool(2x2, s=2) # 224→112 │ Block2: [Conv3-128] ×2 → MaxPool(2x2, s=2) # 112→56 │ Block3: [Conv3-256] ×3 → MaxPool(2x2, s=2) # 56→28 │ Block4: [Conv3-512] ×3 → MaxPool(2x2, s=2) # 28→14 │ Block5: [Conv3-512] ×3 → MaxPool(2x2, s=2) # 14→7 │ FC6: 4096 → ReLU → Dropout │ FC7: 4096 → ReLU → Dropout │ FC8: 1000 → Softmax 注: Conv3-64 表示 64个3×3卷积核

4.3 核心设计特点

（1）小卷积核堆叠

VGGNet最具影响力的设计贡献是用3×3卷积堆叠替代大卷积核。这一设计有三个关键优势：
（a）参数量更少： 3个3×3卷积的参数量为3 × (3×3×C²) = 27C²，而1个7×7卷积的参数量为49C²，节省约45%的参数。
（b）更多非线性： 3个3×3卷积层之间包含3次ReLU激活，增加了网络的非线性表达能力。
（c）更少的计算量： 同等感受野下，小卷积核堆叠的计算效率更高。

（2）极深的统一架构

VGG将深度推进到16-19层，展示了深度对于视觉识别任务的重要性。后续的ResNet（152层）进一步验证了这一趋势。VGG的深度提升是ResNet的"预演"，但VGG没有残差连接，因此无法无限加深。

（3）通道数逐块翻倍

每次池化下采样后，特征图的空间尺寸减半，通道数翻倍。这一设计平衡了空间信息和语义信息：浅层关注局部纹理（大分辨率、少通道），深层关注全局语义（小分辨率、多通道）。

感受野等效性证明

堆叠两个3×3卷积覆盖的有效区域为[(3-1)×2+3]×[(3-1)×2+3] = 5×5，与一个5×5卷积等价。堆叠三个3×3卷积覆盖7×7区域。由于多层卷积之间插入了非线性激活，小卷积核堆叠在大感受野下拥有更强的特征表达能力。

4.4 参数量分析

VGG16的参数量约为1.38亿，远超AlexNet的6200万。其中全连接层占约1.03亿（前两个4096维全连接层的参数量为4096×4096×2 ≈ 3300万，加上卷积层到全连接层的连接约为1.02亿）。巨大的参数量使得VGGNet在训练和推理时都需要较大的存储和计算开销，一个VGG16模型的文件大小约为528MB。

VGGNet的竞赛成绩

ILSVRC 2014定位任务冠军（Localization Task）
ILSVRC 2014分类任务亚军（Classification Task，冠军为GoogLeNet/Inception）
VGG16 Top-5错误率：约7.3%
VGG19 Top-5错误率：约7.0%

五、三大架构横向对比

为了更直观地理解三大架构的差异，下面从多个维度进行系统对比。

对比维度	LeNet-5	AlexNet	VGG16
提出年份	1998	2012	2014
网络层数	5 (2 Conv + 3 FC)	8 (5 Conv + 3 FC)	16 (13 Conv + 3 FC)
参数量	~6.1万	~6200万	~1.38亿
计算量 (FLOPS)	~0.05 GFLOPs	~1.1 GFLOPs	~15.5 GFLOPs
输入尺寸	32×32 灰度	224×224 RGB	224×224 RGB
卷积核大小	5×5	11×11, 5×5, 3×3	3×3 (统一)
激活函数	sigmoid/tanh	ReLU	ReLU
正则化方法	无	Dropout + LRN	Dropout
归一化	无	LRN	无 (已废弃LRN)
GPU训练	无	双GPU (GTX 580)	单/多GPU
ImageNet Top-5错误率	—	15.3%	7.3%
模型文件大小	~0.2 MB	~240 MB	~528 MB
主要应用	手写数字识别	通用图像分类	通用图像分类/检测/分割

2.4→9.0

有效层数演进

6万→1.38亿

参数量增长

—→7.3%

ImageNet Top-5 错误率

0.05→15.5

计算量 FLOPS (G)

演进趋势总结： 从LeNet到VGG，CNN架构呈现三个明确的趋势：网络越来越深（5层→16层）、参数量越来越大（6万→1.38亿）、计算量越来越高（0.05→15.5 GFLOPs）。驱动这些增长的核心动力是：更大规模的数据集（MNIST→ImageNet 1000类）以及对更高精度的持续追求。然而，VGG的参数量已经到了一个需要反思的临界点——后续的ResNet和GoogLeNet开始探索如何在保持精度的情况下控制参数量和计算量。

六、PyTorch代码实现

下面给出三大架构的完整PyTorch实现，以模块化的方式定义各网络结构。代码中同时包含了直接构建和使用预训练权重两种方式。

6.1 LeNet-5 实现

import torch
import torch.nn as nn
import torch.nn.functional as F

class LeNet5(nn.Module):
    """LeNet-5: 输入 32x32 灰度图 → 10 类输出"""
    def __init__(self, num_classes=10):
        super().__init__()
        # Conv1: 1×32×32 → 6×28×28 → Pool: 6×14×14
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5, stride=1)
        # Conv2: 6×14×14 → 16×10×10 → Pool: 16×5×5
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5, stride=1)
        # 全连接层
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, num_classes)

    def forward(self, x):
        x = F.relu(self.conv1(x))           # Conv1 + ReLU
        x = F.avg_pool2d(x, kernel_size=2)  # Pool1
        x = F.relu(self.conv2(x))           # Conv2 + ReLU
        x = F.avg_pool2d(x, kernel_size=2)  # Pool2
        x = x.view(x.size(0), -1)           # Flatten
        x = F.relu(self.fc1(x))             # FC3
        x = F.relu(self.fc2(x))             # FC4
        x = self.fc3(x)                     # FC5 (logits)
        return x

# 验证模型
net = LeNet5()
print(f"LeNet-5 参数量: {sum(p.numel() for p in net.parameters()):,}")
# 输出: LeNet-5 参数量: 61,706

6.2 AlexNet 实现

class AlexNet(nn.Module):
    """AlexNet: 输入 224x224 RGB → 1000 类"""
    def __init__(self, num_classes=1000, dropout=0.5):
        super().__init__()
        # 特征提取 (5个卷积层)
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),  # Conv1
            nn.ReLU(inplace=True),
            nn.LocalResponseNorm(size=5, alpha=1e-4, beta=0.75),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2), # Conv2
            nn.ReLU(inplace=True),
            nn.LocalResponseNorm(size=5, alpha=1e-4, beta=0.75),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1), # Conv3
            nn.ReLU(inplace=True),

            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1), # Conv4
            nn.ReLU(inplace=True),

            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1), # Conv5
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        # 分类器 (3个全连接层)
        self.classifier = nn.Sequential(
            nn.Dropout(p=dropout),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=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), -1)
        x = self.classifier(x)
        return x

# 验证模型
net = AlexNet()
print(f"AlexNet 参数量: {sum(p.numel() for p in net.parameters()):,}")
# 输出: AlexNet 参数量: 62,378,344

6.3 VGG16 实现

def make_vgg_block(cfg: list) -> nn.Sequential:
    """根据配置列表构建VGG卷积块"""
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':  # 最大池化层
            layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
        else:          # 卷积层
            layers.append(nn.Conv2d(in_channels, v, kernel_size=3, padding=1))
            layers.append(nn.ReLU(inplace=True))
            in_channels = v
    return nn.Sequential(*layers)

# VGG16 配置: 13个卷积层 + 5个池化层
VGG16_CFG = [64, 64, 'M',
             128, 128, 'M',
             256, 256, 256, 'M',
             512, 512, 512, 'M',
             512, 512, 512, 'M']

class VGG16(nn.Module):
    """VGG16: 输入 224x224 RGB → 1000 类"""
    def __init__(self, num_classes=1000, dropout=0.5):
        super().__init__()
        self.features = make_vgg_block(VGG16_CFG)
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=dropout),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=dropout),
            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

# 验证模型
net = VGG16()
print(f"VGG16 参数量: {sum(p.numel() for p in net.parameters()):,}")
# 输出: VGG16 参数量: 138,357,544

6.4 使用预训练权重（迁移学习）

import torchvision.models as models

# === 方式一: 直接加载预训练模型 ===
alexnet_pretrained = models.alexnet(weights=models.AlexNet_Weights.IMAGENET1K_V1)
vgg16_pretrained = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1)

# 设置为评估模式
alexnet_pretrained.eval()
vgg16_pretrained.eval()

# === 方式二: 迁移学习 — 冻结特征提取层，替换分类器 ===
def create_transfer_model(arch='vgg16', num_classes=10):
    """创建迁移学习模型，冻结特征提取层"""
    if arch == 'vgg16':
        model = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1)
    elif arch == 'alexnet':
        model = models.alexnet(weights=models.AlexNet_Weights.IMAGENET1K_V1)
    else:
        raise ValueError(f"Unsupported architecture: {arch}")

    # 冻结所有参数（不计算梯度）
    for param in model.parameters():
        param.requires_grad = False

    # 替换分类器为新任务（最后一层重新训练）
    num_ftrs = model.classifier[6].in_features
    model.classifier[6] = nn.Linear(num_ftrs, num_classes)

    return model

# 示例: 创建用于10类自定义数据集的VGG16迁移模型
transfer_model = create_transfer_model(arch='vgg16', num_classes=10)
print(f"迁移学习模型参数量: {sum(p.numel() for p in transfer_model.parameters()):,}")
print(f"可训练参数量: {sum(p.numel() for p in transfer_model.parameters() if p.requires_grad):,}")
# 输出: 可训练参数量仅有最后一层分类器的参数

PyTorch迁移学习最佳实践

选择合适的预训练架构： 小数据集（<1000张）使用AlexNet，中等数据集使用VGG16，大数据集可直接使用ResNet/EfficientNet等更现代的网络
冻结策略： 冻结全部特征层 + 替换分类器（适用于数据集与ImageNet相似、数据量较少的情况）；或者冻结浅层 + 微调深层（适用于数据量中等的情况）
适当的数据增强： 使用torchvision.transforms进行随机裁剪、翻转、颜色抖动等增强操作
学习率设置： 对于冻结部分的迁移学习，新分类器的学习率可以设为1e-3到1e-4，比从头训练大1-2个数量级

七、训练技巧与工程实践

7.1 训练超参数配置

# 通用训练配置示例 (PyTorch)
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR

# 超参数设置
config = {
    'batch_size': 256,
    'learning_rate': 1e-2,
    'momentum': 0.9,
    'weight_decay': 5e-4,     # AlexNet原始论文使用
    'epochs': 90,
    'lr_step_size': 30,       # 每30个epoch学习率下降
    'lr_gamma': 0.1,          # 学习率衰减因子
}

# 优化器: SGD with Momentum
optimizer = optim.SGD(
    model.parameters(),
    lr=config['learning_rate'],
    momentum=config['momentum'],
    weight_decay=config['weight_decay']
)

# 学习率调度器: 阶梯下降
scheduler = StepLR(
    optimizer,
    step_size=config['lr_step_size'],
    gamma=config['lr_gamma']
)

# 损失函数: CrossEntropyLoss
criterion = nn.CrossEntropyLoss()

# 训练循环 (简化)
for epoch in range(config['epochs']):
    model.train()
    for batch_idx, (inputs, targets) in enumerate(train_loader):
        inputs, targets = inputs.cuda(), targets.cuda()
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
    scheduler.step()
    print(f"Epoch {epoch+1}/{config['epochs']}, Loss: {loss.item():.4f}")

7.2 各架构训练策略对比

策略	LeNet-5	AlexNet	VGG16
优化器	SGD	SGD + Momentum (0.9)	SGD + Momentum (0.9)
学习率	~1e-3	1e-2 (手动衰减)	1e-2 (阶梯衰减)
权值衰减	无	5e-4	5e-4
Batch Size	~64	128	256
训练轮数	~20	~90	~74
初始化方式	均匀分布	高斯(0,0.01)	Xavier初始化

工程实践要点

权重初始化至关重要： VGG使用Xavier/Glorot初始化，保证了各层梯度的方差一致性。不正确的初始化会导致深层网络训练失败
学习率策略： AlexNet和VGG都使用手动/阶梯式学习率衰减。实践中可尝试余弦退火（Cosine Annealing）或ReduceLROnPlateau等自适应策略
Batch Size选择： 较大的Batch Size（256）可以提供更稳定的梯度估计，但需要较多显存。若显存不足，可减小Batch Size并适当降低学习率

八、设计理念演进与启示

8.1 从LeNet到VGG的设计思想演变

三大架构的演进不仅是技术参数的提升，更体现了深度学习设计思想的深刻变革：

从手工设计到端到端学习： LeNet时期还需要设计部分手工特征（如SIFT、HOG），AlexNet和VGG标志着完全端到端学习的成熟
从浅层到深层： LeNet的5层到VGG的16层，深度提升了三倍。深层网络可以学习更层次化的特征表示——浅层识别边缘纹理，中间层识别部件形状，深层识别完整物体
从大卷积核到小卷积核堆叠： 11×11 → 5×5 → 3×3，卷积核越来越小但网络越来越深，体现了"以小为美"的设计哲学转变
从单GPU到分布式训练： AlexNet催生了大规模GPU训练的需求，推动整个深度学习基础设施的革新

VGGNet的设计哲学可以概括为"极简而统一"。它证明了在深度学习中，简单的架构加上足够的深度，就能取得强大的效果。这为后来ResNet的残差学习、Inception的模块化设计铺平了道路。

8.2 对后续架构的影响

三大经典架构为后续网络设计奠定了坚实基础：

传承脉络

ResNet（2015）： 继承VGG的小卷积核设计 + 引入残差连接解决梯度消失问题，将网络深度推至152层
GoogLeNet/Inception（2014）： 继承小卷积核思想 + 多尺度并行卷积（1×1, 3×3, 5×5），提升计算效率
MobileNet（2017）： 继承VGG的深度可分离卷积 + 轻量化设计，适应移动端部署
DenseNet（2017）： 继承ResNet的连接思想 + 密集连接（每层与之前所有层连接），缓解梯度消失

8.3 经典架构的当代价值

时至今日，虽然Transformer架构（ViT、Swin等）在图像分类任务上已经超越了传统CNN，但LeNet、AlexNet和VGG仍然具有重要的学习和应用价值：

教学价值： 三大架构完整呈现了CNN从无到有、从简到繁的演进历史，是学习深度学习的"活教材"
工程价值： VGG的预训练权重在迁移学习、特征提取、风格迁移等任务中仍然广泛使用，因其特征具有优良的通用性
部署价值： LeNet在MNIST等简单任务上仍有实用价值，推理速度快、模型体积小
研究价值： AlexNet和VGG在可解释性研究中常被用作基准模型，可视化分析其卷积核响应和特征图

九、核心要点总结

LeNet-5 — 教科书级原型：5层网络，61K参数，Conv-Pool-FC三段式结构确立了CNN基本范式。适用于MNIST等简单任务，但在大规模图像分类上能力有限
AlexNet — 深度学习引爆点：8层网络，62M参数，引入了ReLU、Dropout、LRN、GPU训练、数据增强等关键技术，在ImageNet上取得了跨时代突破（Top-5错误率15.3%）
VGGNet — 极简深度典范：16/19层网络，138M参数，统一使用3×3小卷积核堆叠，证明了深度对于视觉任务的关键作用。VGG16因其出色的迁移学习性能成为经典基准网络
演进趋势：网络越来越深（5层→16层）、参数量越来越大（6万→1.38亿）、卷积核越来越小（11×11→3×3）、设计越来越统一规范
工程实践：预训练模型 + 迁移学习是实际项目中最常用的方法，可以在小数据集上取得优秀效果
历史启示：CNN架构的演进体现了深度学习"简单统一 + 足够深度"的设计哲学，这一思想持续影响着ResNet、Transformer等现代架构