基于CNN的FashionMNIST数据集识别6——DenseNet模型

源码

import torch
from torch import nn
from torchsummary import summary

"""
DenseNet的核心组件：稠密层(DenseLayer)
实现特征复用机制，每个层的输出会与所有前序层的输出在通道维度拼接
"""


class DenseLayer(nn.Module):
    def __init__(self, input_channels, growth_rate):
        super().__init__()
        # 批归一化 + ReLU + 1x1卷积 (瓶颈层，减少计算量)
        self.bn1 = nn.BatchNorm2d(input_channels)
        self.conv1 = nn.Conv2d(input_channels, 4 * growth_rate, kernel_size=1)

        # 批归一化 + ReLU + 3x3卷积 (特征提取层)
        self.bn2 = nn.BatchNorm2d(4 * growth_rate)
        self.conv2 = nn.Conv2d(4 * growth_rate, growth_rate, kernel_size=3, padding=1)
        self.relu = nn.ReLU()

    def forward(self, x):
        # 前向传播：BN->ReLU->Conv(1x1)->BN->ReLU->Conv(3x3)
        out = self.conv1(self.relu(self.bn1(x)))
        out = self.conv2(self.relu(self.bn2(out)))
        # 将新特征与输入特征在通道维度拼接(实现特征复用)
        return torch.cat([x, out], 1)


"""
稠密块(DenseBlock)：由多个稠密层组成
每个稠密层的输入包含前面所有层的特征图
"""


class DenseBlock(nn.Module):
    def __init__(self, num_layers, input_channels, growth_rate):
        super().__init__()
        layers = []
        # 构建num_layers个稠密层
        for i in range(num_layers):
            # 每层的输入通道数 = 初始通道数 + 已添加的特征图数
            layers.append(DenseLayer(input_channels + i * growth_rate, growth_rate))
        self.block = nn.Sequential(*layers)

    def forward(self, x):
        return self.block(x)


"""
过渡层(TransitionLayer)：用于压缩特征图尺寸和通道数
包含1x1卷积和平均池化
"""


class TransitionLayer(nn.Module):
    def __init__(self, input_channels, output_channels):
        super().__init__()
        # 压缩通道数的1x1卷积
        self.bn = nn.BatchNorm2d(input_channels)
        self.conv = nn.Conv2d(input_channels, output_channels, kernel_size=1)
        # 下采样用的平均池化
        self.pool = nn.AvgPool2d(2, stride=2)
        self.relu = nn.ReLU()

    def forward(self, x):
        # 前向传播：BN->ReLU->Conv(1x1)->AvgPool
        out = self.conv(self.relu(self.bn(x)))
        return self.pool(out)


"""
完整的DenseNet网络结构
包含初始卷积层、多个稠密块+过渡层、分类层
"""


class DynamicDenseNet(nn.Module):
    def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16), num_classes=5):
        super().__init__()
        # 初始卷积层(标准CNN开始结构)
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),  # 下采样
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)  # 进一步下采样
        )

        # 构建稠密块和过渡层
        num_channels = 64  # 初始通道数
        for i, num_layers in enumerate(block_config):
            # 添加稠密块
            block = DenseBlock(num_layers, num_channels, growth_rate)
            self.features.add_module(f'denseblock{i + 1}', block)
            # 更新通道数(每个稠密层增加growth_rate个通道)
            num_channels += num_layers * growth_rate

            # 不是最后一个块时添加过渡层
            if i != len(block_config) - 1:
                trans = TransitionLayer(num_channels, num_channels // 2)
                self.features.add_module(f'transition{i + 1}', trans)
                num_channels = num_channels // 2  # 过渡层压缩通道数

        # 分类层
        self.classifier = nn.Sequential(
            nn.BatchNorm2d(num_channels),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d((1, 1)),  # 全局平均池化
            nn.Flatten(),
            nn.Linear(num_channels, num_classes)  # 全连接输出分类结果
        )

    def forward(self, x):
        features = self.features(x)
        return self.classifier(features)


# 测试代码
if __name__ == "__main__":
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = DynamicDenseNet().to(device)
    # 打印网络结构和参数统计(输入尺寸为3x224x224)
    print(summary(model, (3, 224, 224)))

流程图

设计理念

密集连接机制

在DenseNet中，每个层都与其后续的所有层直接连接。这意味着：

• 第l层的输入 = 所有前序层(0到l-1)的特征图拼接
• 数学表示：x_l = H_l([x_0, x_1, ..., x_{l-1}])
• 与传统架构相比，缓解了梯度消失问题，增强了特征传播

特征复用机制

• 每个层都可以访问所有前序层的特征图
• 网络自动学习在不同层级复用特征
• 减少了特征冗余，提高了参数效率

瓶颈层设计

每个DenseLayer包含：

1. ‌BN-ReLU-Conv(1×1)层‌：作为瓶颈层，减少特征图数量和计算量
   • 将输入通道压缩到4×growth_rate
2. ‌BN-ReLU-Conv(3×3)层‌：主特征提取层
   • 输出growth_rate个特征图（通常growth_rate=12-48）

增长率(growth_rate)参数

• 控制每个层添加到特征图的通道数
• 较小的growth_rate也能获得优异性能（如k=12 vs ResNet k=64）
• 决定模型容量和参数效率的关键超参数

过渡层设计

• ‌1×1卷积‌：压缩特征通道数（通常减少50%）
• ‌2×2平均池化‌：下采样特征图尺寸
• 公式：θ = 压缩因子（通常0.5）
  • output_channels = θ × input_channels

 充电：BatchNorm2d的用法

batchnorm2d是PyTorch中用于2D输入的批归一化(Batch Normalization)层。

通常只需要设置输入通道数即可。比如：

conv = nn.Conv2d(in_c, out_c, 3)
bn = nn.BatchNorm2d(out_c)  # 注意与卷积输出通道一致
relu = nn.ReLU()
output = relu(bn(conv(input)))

bn层可以做初始化设置，比如：

bn = nn.BatchNorm2d(64)
# 初始化缩放因子为1，偏移为0
nn.init.constant_(bn.weight, 1)  
nn.init.constant_(bn.bias, 0)

 需要注意的是，当批次数量太小时，使用bn层可能表现不稳定。当batch<16时，建议使用GroupNorm方法做替代