经典CNN架构剖析：LeNet到DenseNet的里程碑演进与核心创新

引言

卷积神经网络（CNN）的发展历程，就是一部深度学习的进化史。从1998年的LeNet，到今天的Vision Transformers，每一次架构创新都重新定义了计算机视觉的能力边界。这篇文章将带你深入理解LeNet、AlexNet、VGG、ResNet和DenseNet这些经典CNN架构，梳理它们如何一步步攻克训练难题、提升性能，并为你提供可复现的代码实现与设计思想。

📂 所属阶段：第二阶段 — 深度学习视觉基础（CNN 篇）
🔗 相关章节：卷积核、步长与池化 · 手写数字识别 (MNIST) 实战

1. LeNet（1998）- 深度学习的奠基之作

1.1 历史背景与意义

LeNet由Yann LeCun在1998年提出，是第一个真正意义上的卷积神经网络。它最初用于手写数字识别，在MNIST数据集上取得了突破性成果，也为后来所有CNN架构树立了基本范式。

LeNet-5 架构结构

输入层（32×32） → C1卷积层（6个5×5核） → S2池化层 → C3卷积层（16个5×5核） → S4池化层 → C5全连接卷积层 → F6全连接层 → 输出层

核心基础创新

首次引入卷积层和池化层的组合
提出参数共享机制
设计局部连接模式

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

class LeNet5(nn.Module):
    """
    LeNet-5网络实现
    """
    def __init__(self, num_classes=10):
        super(LeNet5, self).__init__()
        
        # C1: 卷积层 - 6个5×5卷积核
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
        # S2: 平均池化层 - 2×2窗口
        self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2)
        # C3: 卷积层 - 16个5×5卷积核
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
        # S4: 平均池化层 - 2×2窗口
        self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2)
        # C5: 全连接卷积层 - 120个5×5卷积核
        self.conv3 = nn.Conv2d(16, 120, kernel_size=5)
        # F6: 全连接层 - 84个神经元
        self.fc1 = nn.Linear(120, 84)
        # 输出层 - 10个神经元（对应10个数字类别）
        self.fc2 = nn.Linear(84, num_classes)
        
        # 激活函数
        self.tanh = nn.Tanh()
    
    def forward(self, x):
        # C1: 卷积 + 激活
        x = self.tanh(self.conv1(x))
        # S2: 池化
        x = self.pool1(x)
        # C3: 卷积 + 激活
        x = self.tanh(self.conv2(x))
        # S4: 池化
        x = self.pool2(x)
        # C5: 卷积 + 激活
        x = self.tanh(self.conv3(x))
        # 展平
        x = x.view(x.size(0), -1)
        # F6: 全连接 + 激活
        x = self.tanh(self.fc1(x))
        # 输出层
        x = self.fc2(x)
        return x

LeNet-5 参数量分析

输入: 32×32灰度图像
C1: 6×(5×5)+6 = 156 参数
S2: 2×2平均池化，无参数
C3: 16×6×(5×5)+16 = 2,416 参数
S4: 2×2平均池化，无参数
C5: 120×16×(5×5)+120 = 48,120 参数
F6: 120×84+84 = 10,164 参数
输出: 84×10+10 = 850 参数
总参数量: ~61,700

1.2 LeNet的创新点与现代影响

核心创新逻辑

卷积层：
- 同一个卷积核在整个图像上滑动，实现参数共享，大幅减少参数量
- 每个输出神经元只与输入的局部区域连接，获取局部感受野
- 无论数字出现在图像的哪个位置，卷积核都能检测到相同的特征，天然具备平移不变性
池化层：
- 压缩特征图的空间尺寸，降低计算量
- 对微小平移更加鲁棒，进一步提升平移不变性
层次化特征提取：
- 浅层（C1/S2）负责提取边缘、纹理等基础特征
- 深层（C3/S4/C5）逐步组合出更具语义信息的抽象特征（如数字的部件）

对现代CNN的影响

确立了 “卷积+池化堆叠提取特征，全连接层分类” 的基础架构
参数共享和局部连接成为所有CNN的底层设计原则
层次化特征提取的思想至今仍是视觉模型的核心

2. AlexNet（2012）- 深度学习复兴的里程碑

2.1 历史意义与突破

2012年，Alex Krizhevsky等人提出的AlexNet在ImageNet大规模视觉识别挑战赛（ILSVRC 2012）中，以Top-5错误率15.3%的成绩夺冠（第二名错误率高达26.2%）。这一结果震惊了整个计算机视觉界，标志着深度学习时代正式开启，也让GPU训练走入大众视野。

AlexNet 架构结构

输入: 224×224 RGB图像

特征提取部分

Conv1: 96个11×11卷积核，步长4
MaxPool1: 3×3窗口，步长2
Conv2: 256个5×5卷积核，使用分组卷积（适配当时的双GPU并行）
MaxPool2: 3×3窗口，步长2
Conv3: 384个3×3卷积核
Conv4: 384个3×3卷积核，分组卷积
Conv5: 256个3×3卷积核，分组卷积
MaxPool3: 3×3窗口，步长2

分类部分

FC1: 4096个神经元
FC2: 4096个神经元
FC3: 1000个神经元（对应ImageNet类别数）

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    """
    AlexNet网络实现（简化分组卷积，适配单GPU）
    """
    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        
        # 特征提取部分
        self.features = nn.Sequential(
            # Conv1: 96个11×11卷积核，步长4，padding2确保输出55×55
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            # MaxPool1: 3×3窗口，步长2
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            # Conv2: 原256分组→简化为192
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            # MaxPool2: 3×3窗口，步长2
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            # Conv3: 原384→简化为384核心层
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            
            # Conv4: 原384→简化为256
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            
            # Conv5: 原256
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            # MaxPool3: 3×3窗口，步长2
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        
        # 自适应平均池化，适配任意输入尺寸
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        
        # 分类器部分
        self.classifier = nn.Sequential(
            # Dropout: 丢弃率0.5
            nn.Dropout(p=0.5),
            # FC1: 4096个神经元
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            # Dropout: 丢弃率0.5
            nn.Dropout(p=0.5),
            # FC2: 4096个神经元
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            # FC3: 1000个神经元
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

2.2 AlexNet的技术创新

六大关键突破

ReLU激活函数
ReLU函数的定义非常简单：当输入大于0时原样输出，输入小于等于0时输出0。
- 在正数区间梯度恒为1，彻底避免了Sigmoid、tanh这类饱和激活函数带来的梯度消失问题
- 计算量小，训练速度比tanh快数倍
Dropout正则化
- 训练时以50%概率随机将全连接层的神经元输出置零
- 这迫使每个神经元不能过度依赖其他特定的神经元，破坏了“协同适应”，从而显著防止过拟合
数据增强
- 对原始256×256图像随机裁剪出224×224的区域
- 以50%概率进行水平翻转
- 对RGB像素值施加PCA颜色扰动，模拟光照变化
- 这些手段让训练样本数量成倍增加，有效缓解过拟合
重叠池化
- 池化窗口大小设为3×3，步长设为2，这使得相邻池化窗口之间有像素重叠
- 相比传统的不重叠池化（窗口大小等于步长），这种设计能进一步抑制过拟合
局部响应归一化（LRN）
- 借鉴生物学中神经元的“侧抑制”原理，在通道之间做局部竞争，增强模型的泛化能力
- 不过在后续的VGG、ResNet等模型中，LRN的作用被更有效的BN层取代
GPU并行计算
- 使用两块GTX 580显卡训练了约6天
- 网络中的分组卷积将模型拆成两部分，分别在两块GPU上运行，解决了当时单卡显存不足的问题

AlexNet参数规模

原论文总参数量约6000万，且80%以上集中在全连接层（FC1、FC2），这也是后来模型精简的重点。

3. VGGNet（2014）- 深度与统一性的典范

3.1 VGGNet设计理念

2014年，牛津大学视觉几何组（Visual Geometry Group）提出了VGGNet，以其极简统一的结构和对深度的执着探索闻名。VGGNet用一个个小卷积核不断堆叠，证明了网络深度是提升性能的关键，并由此确立了“以小卷积核构建深层网络”的设计范式。

VGGNet 核心设计规则

统一卷积核：所有卷积层都只使用3×3的小卷积核
统一池化：所有池化层都是2×2窗口、步长2
通道翻倍：每经过一次池化（空间尺寸减半），通道数翻倍，保持时间与空间的平衡
全连接收尾：最后使用三个连续的全连接层完成分类

主流VGG版本

版本	卷积层数量	全连接层数量	总参数量（ImageNet）
VGG-11	8	3	~132M
VGG-13	10	3	~133M
VGG-16	13	3	~138M
VGG-19	16	3	~143M

import torch
import torch.nn as nn

class VGG(nn.Module):
    """
    VGG网络实现
    """
    def __init__(self, features, num_classes=1000, init_weights=True):
        super(VGG, self).__init__()
        self.features = features
        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)

def make_layers(cfg, batch_norm=False):
    """
    根据配置创建VGG层
    """
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)

# VGG配置
cfgs = {
    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],  # VGG-11
    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],  # VGG-13
    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],  # VGG-16
    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],  # VGG-19
}

def vgg16(pretrained=False, **kwargs):
    """
    VGG-16网络（最常用版本）
    """
    if pretrained:
        kwargs['init_weights'] = False
    model = VGG(make_layers(cfgs['D']), **kwargs)
    return model

3.2 VGGNet的架构优势

小卷积核堆叠的两大核心优势

等价感受野，更丰富的非线性
- 连续使用两个3×3卷积，其理论感受野大小等同于一个5×5卷积
- 连续使用三个3×3卷积，感受野等同于一个7×7卷积
- 但小卷积核堆叠的过程中会经过更多次ReLU激活，因此网络拥有更强的表达能力，能学习更复杂的决策边界
更高的参数效率
我们以输入通道数和输出通道数均为C为例进行对比：
- 一个5×5卷积层需要参数量（含偏置）为：C × (5×5) × C + C ，约为 26C（这里简化计为C为独立维度）
- 两个3×3卷积层总参数量（含偏置）为：2 × [ C × (3×3) × C + C ] ，约为 20C
- 参数节省大约23% 。如果忽略偏置项，节省比例更高。

正因为这种高效的设计，VGG-16和VGG-19至今仍被广泛用作特征提取的骨干网络。

4. ResNet（2015）- 解决深度网络训练难题

4.1 残差学习的提出

2015年，微软研究院的何恺明等人提出了ResNet，引入残差连接（Residual Connection），一举解决了困扰学界多年的深度网络训练退化问题——即网络加深后训练误差不降反升的现象。ResNet让训练一百多层甚至上千层的网络变得稳定可控，并在ILSVRC 2015中以Top-5错误率3.57%夺冠。

网络退化问题的本质

按理论设想，更深的网络至少可以通过学习恒等映射（即输出等于输入）来达到浅层网络的性能。然而，仅靠堆叠非线性层直接拟合恒等映射非常困难，梯度在反向传播时逐渐衰减，导致深层网络难以有效训练。

残差学习的核心思想

ResNet将学习目标从直接的期望映射 H(x)，转变为学习残差映射 F(x) = H(x) - x。最终网络输出为：

输出 = 残差 + 输入

如果期望映射就是恒等映射，网络只需要将残差映射 F(x) 学习为0即可——这远比直接学习恒等映射容易（理论上只需把卷积核权重全部置零）。更重要的是，残差连接为梯度提供了一条直接回传的“高速公路”，从根本上缓解了梯度消失问题。

import torch
import torch.nn as nn

class BasicBlock(nn.Module):
    """
    基础残差块（用于ResNet-18, ResNet-34）
    """
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        # 残差连接：将跳跃连接identity与卷积输出相加
        out += identity
        out = self.relu(out)

        return out

class Bottleneck(nn.Module):
    """
    瓶颈残差块（用于ResNet-50, ResNet-101, ResNet-152）
    expansion=4，通过先降维再升维大幅减少计算量
    """
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        # 1×1卷积降维
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        # 3×3卷积提取特征
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        # 1×1卷积升维
        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out

class ResNet(nn.Module):
    """
    ResNet网络
    """
    def __init__(self, block, layers, num_classes=1000):
        super(ResNet, self).__init__()
        self.inplanes = 64
        # 初始层：7×7卷积+3×3最大池化，快速降维
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        # 四个残差块组
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        
        # 全局平均池化+全连接分类
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        # 初始化权重
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)

    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)

        return x

def resnet18(**kwargs):
    """ResNet-18（轻量级骨干网）"""
    return ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)

def resnet50(**kwargs):
    """ResNet-50（最常用的标准骨干网）"""
    return ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)

5. DenseNet（2016）- 密集连接的极致

5.1 密集连接的创新

2016年，康奈尔大学和清华大学的研究者提出了DenseNet，以一种密集连接（Dense Connection） 的方式将特征重用发挥到极致。在DenseNet中，每一层都会接收前面所有层输出的特征图作为输入，并将自己的输出传递给后续所有层。

密集连接的核心思想

假设一个网络中有 L 层，第 l 层的输入不是只来自前一层，而是把第0层（输入）到第 l-1 层所有的输出特征图在通道维度上拼接起来。这个拼接后的巨大特征块会送入一个复合函数 Hl（通常是 BN → ReLU → Conv 的组合）进行处理。

DenseNet的核心组件

Dense Block：内部实现密集连接，特征图在通道维度不断增长
Transition Layer：夹在Dense Block之间的过渡层，负责压缩通道数（通常减半）并缩小空间尺寸
Growth Rate（增长率）：Dense Block中每一层输出的新特征图的通道数，记为 k（常见取值12或32），它控制着模型“胖瘦”

import torch
import torch.nn as nn
import torch.nn.functional as F
from collections import OrderedDict

class _DenseLayer(nn.Sequential):
    """
    DenseNet层：BN→ReLU→1×1 Conv→BN→ReLU→3×3 Conv
    先用1×1 Conv降维，减少计算量
    """
    def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
        super(_DenseLayer, self).__init__()
        self.add_module('norm1', nn.BatchNorm2d(num_input_features)),
        self.add_module('relu1', nn.ReLU(inplace=True)),
        self.add_module('conv1', nn.Conv2d(num_input_features, bn_size *
                                           growth_rate, kernel_size=1, stride=1,
                                           bias=False)),
        self.add_module('norm2', nn.BatchNorm2d(bn_size * growth_rate)),
        self.add_module('relu2', nn.ReLU(inplace=True)),
        self.add_module('conv2', nn.Conv2d(bn_size * growth_rate, growth_rate,
                                           kernel_size=3, stride=1, padding=1,
                                           bias=False)),
        self.drop_rate = drop_rate

    def forward(self, x):
        new_features = super(_DenseLayer, self).forward(x)
        if self.drop_rate > 0:
            new_features = F.dropout(new_features, p=self.drop_rate,
                                   training=self.training)
        # 密集连接：将新特征与之前所有特征拼接
        return torch.cat([x, new_features], 1)

class _DenseBlock(nn.Sequential):
    """DenseNet块：包含多个DenseLayer"""
    def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate):
        super(_DenseBlock, self).__init__()
        for i in range(num_layers):
            layer = _DenseLayer(num_input_features + i * growth_rate,
                               growth_rate, bn_size, drop_rate)
            self.add_module('denselayer%d' % (i + 1), layer)

class _Transition(nn.Sequential):
    """过渡层：通道数减半 + 空间尺寸减半"""
    def __init__(self, num_input_features, num_output_features):
        super(_Transition, self).__init__()
        self.add_module('norm', nn.BatchNorm2d(num_input_features))
        self.add_module('relu', nn.ReLU(inplace=True))
        self.add_module('conv', nn.Conv2d(num_input_features, num_output_features,
                                          kernel_size=1, stride=1, bias=False))
        self.add_module('pool', nn.AvgPool2d(kernel_size=2, stride=2))

class DenseNet(nn.Module):
    """DenseNet网络"""
    def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),
                 num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000):
        super(DenseNet, self).__init__()

        self.features = nn.Sequential(OrderedDict([
            ('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2,
                                padding=3, bias=False)),
            ('norm0', nn.BatchNorm2d(num_init_features)),
            ('relu0', nn.ReLU(inplace=True)),
            ('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
        ]))

        num_features = num_init_features
        for i, num_layers in enumerate(block_config):
            block = _DenseBlock(num_layers=num_layers,
                               num_input_features=num_features,
                               bn_size=bn_size,
                               growth_rate=growth_rate,
                               drop_rate=drop_rate)
            self.features.add_module('denseblock%d' % (i + 1), block)
            num_features = num_features + num_layers * growth_rate
            if i != len(block_config) - 1:
                trans = _Transition(num_input_features=num_features,
                                   num_output_features=num_features // 2)
                self.features.add_module('transition%d' % (i + 1), trans)
                num_features = num_features // 2

        self.features.add_module('norm5', nn.BatchNorm2d(num_features))
        self.classifier = nn.Linear(num_features, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.constant_(m.bias, 0)

    def forward(self, x):
        features = self.features(x)
        out = F.relu(features, inplace=True)
        out = F.adaptive_avg_pool2d(out, (1, 1))
        out = torch.flatten(out, 1)
        out = self.classifier(out)
        return out

DenseNet的核心优势

最大化特征重用：每一层都能直接访问前面所有层产生的基础特征，减少重复学习
参数效率极高：在同等精度下，DenseNet的参数量通常只有ResNet的1/3左右
有效缓解梯度消失：密集连接为浅层提供了多条梯度回传路径
信息流动更顺畅：特征拼接让数据在不同层之间的传递几乎没有瓶颈

6. 经典CNN架构对比与演进总结

6.1 架构核心指标对比

架构	年份	核心创新	常用深度	总参数量（ImageNet）	核心问题解决
LeNet	1998	CNN基础架构、参数共享	5	~60K	证明CNN在视觉任务上的可行性
AlexNet	2012	ReLU、Dropout、GPU并行	8	~60M	开启深度学习时代，突破性能瓶颈
VGGNet	2014	统一小卷积核、深度探索	16-19	~138M	证明深度是提升性能的关键
ResNet	2015	残差连接、批归一化	50-152	~25M（ResNet-50）	解决深度网络的训练退化问题
DenseNet	2016	密集连接、特征重用	121-201	~8M（DenseNet-121）	最大化特征重用，进一步提升参数效率

6.2 架构设计理念的演进

从浅到深
- 从LeNet的5层一路发展到DenseNet的200+层
- 核心障碍：梯度消失、训练退化 → 解决工具：ReLU、残差连接
从大核到小核堆叠
- LeNet/AlexNet中广泛使用5×5、7×7甚至11×11的大卷积核
- VGGNet之后统一采用3×3小卷积核堆叠 → 等价感受野、更多非线性、参数更高效
从直连到跳连
- 传统网络：逐层直连
- ResNet：用加法实现残差跳连
- DenseNet：用通道拼接实现密集跳连 → 为梯度和信息传播开辟更多路径
从单一组件到标准化复合组件
- 基础组件：卷积、池化、激活
- 现代组件：BN → ReLU → Conv 的固定组合，甚至是 DenseNet 中更细化的 BN → ReLU → 1×1 Conv → BN → ReLU → 3×3 Conv

7. 总结

经典CNN架构的发展史，是一部从“可行”到“极致优化”的进化史，每一次突破都在解决当时深度学习的核心障碍：

核心里程碑

LeNet：奠定了CNN的基础结构，提出了参数共享与局部连接
AlexNet：引入ReLU、Dropout等关键技术，借助GPU开启深度学习时代
VGGNet：用统一的3×3卷积探索深度极限，确立深度对性能的重要性
ResNet：残差连接彻底解决深度网络的训练退化，让上百层网络训练成为可能
DenseNet：密集连接实现特征极致重用，用更少的参数达到更高的精度

核心技术遗产

参数共享和局部连接：CNN的本质属性
ReLU：深度网络的首选激活函数
残差连接：现代深度网络的标配
层次化特征提取：所有视觉模型的核心思想

💡 重要提醒：建议你优先实现并彻底理解ResNet-18和ResNet-50，它们是当前应用最广泛的骨干网络，也是不少前沿视觉架构的基石。

🔗 扩展阅读

#经典CNN架构剖析：LeNet到DenseNet的里程碑演进与核心创新

#引言

#1. LeNet（1998）- 深度学习的奠基之作

#1.1 历史背景与意义

#LeNet-5 架构结构

#核心基础创新

#LeNet-5 参数量分析

#1.2 LeNet的创新点与现代影响

#核心创新逻辑

#对现代CNN的影响

#2. AlexNet（2012）- 深度学习复兴的里程碑

#2.1 历史意义与突破

#AlexNet 架构结构

#特征提取部分

#分类部分

#2.2 AlexNet的技术创新

#六大关键突破

#AlexNet参数规模

#3. VGGNet（2014）- 深度与统一性的典范

#3.1 VGGNet设计理念

#VGGNet 核心设计规则

#主流VGG版本

#3.2 VGGNet的架构优势

#小卷积核堆叠的两大核心优势

#4. ResNet（2015）- 解决深度网络训练难题

#4.1 残差学习的提出

#网络退化问题的本质

#残差学习的核心思想

#5. DenseNet（2016）- 密集连接的极致

#5.1 密集连接的创新

#密集连接的核心思想

#DenseNet的核心组件

#DenseNet的核心优势

#6. 经典CNN架构对比与演进总结

#6.1 架构核心指标对比

#6.2 架构设计理念的演进

#相关教程

#7. 总结

#核心里程碑

#核心技术遗产