用Python生成densenet例程

以下是使用Python生成DenseNet的例程：

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

class Bottleneck(nn.Module):
    def __init__(self, in_channels, growth_rate):
        super(Bottleneck, self).__init__()
        self.bn1 = nn.BatchNorm2d(in_channels)
        self.conv1 = nn.Conv2d(in_channels, 4 * growth_rate, kernel_size=1, bias=False)
        self.bn2 = nn.BatchNorm2d(4 * growth_rate)
        self.conv2 = nn.Conv2d(4 * growth_rate, growth_rate, kernel_size=3, padding=1, bias=False)

    def forward(self, x):
        out = self.conv1(F.relu(self.bn1(x)))
        out = self.conv2(F.relu(self.bn2(out)))
        out = torch.cat([out, x], 1)
        return out

class DenseBlock(nn.Module):
    def __init__(self, in_channels, growth_rate, num_layers):
        super(DenseBlock, self).__init__()
        self.layer = nn.ModuleList()
        for i in range(num_layers):
            self.layer.append(Bottleneck(in_channels + i * growth_rate, growth_rate))

    def forward(self, x):
        for layer in self.layer:
            out = layer(x)
            x = out
        return out

class Transition(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(Transition, self).__init__()
        self.bn = nn.BatchNorm2d(in_channels)
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)

    def forward(self, x):
        out = self.conv(F.relu(self.bn(x)))
        out = F.avg_pool2d(out, 2)
        return out

class DenseNet(nn.Module):
    def __init__(self, num_classes, growth_rate=32, block_config=(6, 12, 24, 16)):
        super(DenseNet, self).__init__()
        self.growth_rate = growth_rate

        # 初始卷积层
        self.conv1 = nn.Conv2d(3, 2 * growth_rate, kernel_size=3, padding=1, bias=False)

        # 第一组密集块和过渡层
        self.dense1 = DenseBlock(2 * growth_rate, growth_rate, block_config[0])
        self.trans1 = Transition(2 * growth_rate + block_config[0] * growth_rate, block_config[1] * growth_rate)

        # 第二组密集块和过渡层
        self.dense2 = DenseBlock(block_config[1] * growth_rate, growth_rate, block_config[1])
        self.trans2 = Transition(block_config[1] * growth_rate + block_config[1] * growth_rate, block_config[2] * growth_rate)

        # 第三组密集块和过渡层
        self.dense3 = DenseBlock(block_config[2] * growth_rate, growth_rate, block_config[2])
        self.trans3 = Transition(block_config[2] * growth_rate + block_config[2] * growth_rate, block_config[3] * growth_rate)

        # 第四组密集块和分类器
        self.dense4 = DenseBlock(block_config[3] * growth_rate, growth_rate, block_config[3])
        self.bn = nn.BatchNorm2d(block_config[3] * growth_rate + block_config[3] * growth_rate)
        self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(block_config[3] * growth_rate + block_config[3] * growth_rate, num_classes)

    def forward(self, x):
        out = self.conv1(x)
        out = F.max_pool2d(out, 2)

        out = self.trans1(self.dense1(out))
        out = self.trans2(self.dense2(out))
        out = self.trans3(self.dense3(out))
        out = self.dense4(out)

        out = self.avg_pool(F.relu(self.bn(out)))
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out

# 测试模型
net = DenseNet(num_classes=10)
x = torch.randn(1, 3, 32, 32)
y = net(x)
print(y.size())