• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

目标

具体实现

（一）环境

语言环境：Python 3.10
编 译 器: PyCharm
框 架: Pytorch

（二）具体步骤

1. DenseNet121.py

import torch  
import torch.nn as nn  
import torch.nn.functional as F  
import math  
  
  
# 实现DenseLayer（密集连接层）  
class DenseLayer(nn.Module):  
    def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):  
        super(DenseLayer, self).__init__()  
        # BN -> ReLU -> Conv(1x1) -> BN -> ReLU -> Conv(3x3)  
        self.norm1 = nn.BatchNorm2d(num_input_features)  # 第一个批归一化层  
        self.relu1 = nn.ReLU(inplace=True)  # 第一个ReLU激活函数  
        self.conv1 = nn.Conv2d(num_input_features, bn_size * growth_rate,  
                               kernel_size=1, stride=1, bias=False)  # 1x1卷积层  
  
        self.norm2 = nn.BatchNorm2d(bn_size * growth_rate)  # 第二个批归一化层  
        self.relu2 = nn.ReLU(inplace=True)  # 第二个ReLU激活函数  
        self.conv2 = nn.Conv2d(bn_size * growth_rate, growth_rate,  
                               kernel_size=3, stride=1, padding=1, bias=False)  # 3x3卷积层  
  
        self.drop_rate = drop_rate  # Dropout率  
  
    def forward(self, x):  
        # 保存输入特征，用于后续的密集连接  
        new_features = self.norm1(x)  
        new_features = self.relu1(new_features)  
        new_features = self.conv1(new_features)  
  
        new_features = self.norm2(new_features)  
        new_features = self.relu2(new_features)  
        new_features = self.conv2(new_features)  
  
        # 如果设置了dropout，则应用dropout  
        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)  
  
  
# 实现DenseBlock（密集块）  
class DenseBlock(nn.Module):  
    def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate):  
        super(DenseBlock, self).__init__()  
        # 创建指定数量的DenseLayer，每一层的输入特征数量都会增加  
        self.layers = nn.ModuleList()  
        for i in range(num_layers):  
            layer = DenseLayer(  
                num_input_features + i * growth_rate,  
                growth_rate=growth_rate,  
                bn_size=bn_size,  
                drop_rate=drop_rate  
            )  
            self.layers.append(layer)  
  
    def forward(self, x):  
        # 依次通过所有的DenseLayer  
        features = x  
        for layer in self.layers:  
            features = layer(features)  
        return features  
  
  
# 实现TransitionLayer（过渡层）  
class TransitionLayer(nn.Module):  
    def __init__(self, num_input_features, num_output_features):  
        super(TransitionLayer, self).__init__()  
        # BN -> Conv(1x1) -> AvgPool(2x2)  
        self.norm = nn.BatchNorm2d(num_input_features)  # 批归一化层  
        self.relu = nn.ReLU(inplace=True)  # ReLU激活函数  
        self.conv = nn.Conv2d(num_input_features, num_output_features,  
                              kernel_size=1, stride=1, bias=False)  # 1x1卷积层  
        self.pool = nn.AvgPool2d(kernel_size=2, stride=2)  # 平均池化层  
  
    def forward(self, x):  
        x = self.norm(x)  
        x = self.relu(x)  
        x = self.conv(x)  
        x = self.pool(x)  
        return x  
  
  
# 实现完整的DenseNet121模型  
class DenseNet121(nn.Module):  
    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(DenseNet121, self).__init__()  
  
        # 首先是一个7x7的卷积层，步长为2  
        self.features = nn.Sequential()  
        self.features.add_module('conv0',  
                                 nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False))  # 初始卷积层  
        self.features.add_module('norm0', nn.BatchNorm2d(num_init_features))  # 批归一化层  
        self.features.add_module('relu0', nn.ReLU(inplace=True))  # ReLU激活函数  
        self.features.add_module('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1))  # 最大池化层  
  
        # 依次添加DenseBlock和TransitionLayer  
        num_features = num_init_features  
        for i, num_layers in enumerate(block_config):  
            # 添加DenseBlock  
            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(f'denseblock{i + 1}', block)  
            num_features = num_features + num_layers * growth_rate  
  
            # 如果不是最后一个block，则添加TransitionLayer  
            if i != len(block_config) - 1:  
                # 过渡层将特征图数量减半  
                trans = TransitionLayer(  
                    num_input_features=num_features,  
                    num_output_features=num_features // 2  
                )  
                self.features.add_module(f'transition{i + 1}', trans)  
                num_features = num_features // 2  
  
        # 最后添加一个BatchNorm  
        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)  # 使用Kaiming初始化卷积层权重  
            elif isinstance(m, nn.BatchNorm2d):  
                nn.init.constant_(m.weight, 1)  # 初始化批归一化层的权重为1  
                nn.init.constant_(m.bias, 0)  # 初始化批归一化层的偏置为0  
            elif isinstance(m, nn.Linear):  
                nn.init.constant_(m.bias, 0)  # 初始化全连接层的偏置为0  
  
    def forward(self, x):  
        features = self.features(x)  # 提取特征  
        out = F.relu(features, inplace=True)  # 应用ReLU激活函数  
        out = F.adaptive_avg_pool2d(out, (1, 1))  # 全局平均池化  
        out = torch.flatten(out, 1)  # 展平特征  
        out = self.classifier(out)  # 分类  
        return out  
  
  
# 创建DenseNet121模型实例  
def create_densenet121(num_classes=1000, pretrained=False):  
    model = DenseNet121(num_classes=num_classes)  
    return model  
  
  
# 使用示例  
if __name__ == "__main__":  
    # 创建模型  
    model = create_densenet121()  
    print(model)  
  
    # 创建随机输入张量 (batch_size, channels, height, width)    x = torch.randn(1, 3, 224, 224)  
  
    # 前向传播  
    output = model(x)  
    print(f"Input shape: {x.shape}")  
    print(f"Output shape: {output.shape}")