DenseNet网络代码

以下是一个简单的DenseNet网络实现代码示例：

import torch
import torch.nn as nn

class DenseBlock(nn.Module):
    def __init__(self, in_channels, growth_rate, num_layers):
        super(DenseBlock, self).__init__()
        self.layers = nn.ModuleList()
        for i in range(num_layers):
            self.layers.append(nn.Sequential(
                nn.BatchNorm2d(in_channels + i * growth_rate),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels + i * growth_rate, growth_rate,
                          kernel_size=3, stride=1, padding=1, bias=False)
            ))

    def forward(self, x):
        features = [x]
        for layer in self.layers:
            new_features = layer(torch.cat(features, dim=1))
            features.append(new_features)
        return torch.cat(features, dim=1)

class TransitionLayer(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(TransitionLayer, self).__init__()

        self.downsample = nn.Sequential(
            nn.BatchNorm2d(in_channels),
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
            nn.AvgPool2d(kernel_size=2, stride=2)
        )

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

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

        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )

        num_features = 64
        for i, num_layers in enumerate(block_config):
            block = DenseBlock(num_features, growth_rate, num_layers)
            self.features.add_module('denseblock%d' % (i + 1), block)
            num_features = num_features + num_layers * growth_rate
            if i != len(block_config) - 1:
                trans = TransitionLayer(num_features, num_features // 2)
                self.features.add_module('transition%d' % (i + 1), trans)
                num_features = num_features // 2

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.classifier = nn.Linear(num_features, num_classes)

    def forward(self, x):
        features = self.features(x)
        out = self.avgpool(features)
        out = out.view(features.size(0), -1)
        out = self.classifier(out)
        return out

在这个实现中，我们定义了三个类：`DenseBlock`，`TransitionLayer`和`DenseNet`。`DenseBlock`实现了DenseNet中的密集块，`TransitionLayer`实现了DenseNet中的过渡层，而`DenseNet`则定义了整个网络的结构。

在`DenseNet`中，我们首先定义了一个序列模块，用于实现DenseNet的前几个卷积层和池化层。然后，我们循环遍历`block_config`中的元素，并在每个元素中定义一个密集块。如果这不是最后一个元素，则定义一个过渡层，将特征图的通道数减半，以便在下一个密集块中使用。最后，我们使用自适应平均池化层和线性分类器对特征图进行全局池化和分类。

这个实现代码可以自由修改以适应不同的数据集和任务。