densenet加入inception代码实现

以下是使用PyTorch实现的DenseNet和Inception结合的代码：

import torch
import torch.nn as nn

class Inception(nn.Module):
    def __init__(self, in_channels):
        super(Inception, self).__init__()
        self.branch1x1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        
        self.branch5x5_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch5x5_2 = nn.Conv2d(16, 24, kernel_size=5, padding=2)
        
        self.branch3x3_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch3x3_2 = nn.Conv2d(16, 24, kernel_size=3, padding=1)
        self.branch3x3_3 = nn.Conv2d(24, 24, kernel_size=3, padding=1)
        
        self.branch_pool = nn.Conv2d(in_channels, 24, kernel_size=1)
        
    def forward(self, x):
        branch1x1 = self.branch1x1(x)
        
        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)
        
        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)
        
        branch_pool = nn.functional.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)
        
        outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
        return torch.cat(outputs, dim=1)

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(self.build_layer(in_channels + i*growth_rate, growth_rate))
            
    def build_layer(self, in_channels, out_channels):
        layer = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
        return layer
    
    def forward(self, x):
        features = [x]
        for layer in self.layers:
            x = layer(torch.cat(features, dim=1))
            features.append(x)
        return torch.cat(features, dim=1)

class Transition(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(Transition, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
        self.pool = nn.AvgPool2d(kernel_size=2, stride=2)
        
    def forward(self, x):
        x = self.conv(x)
        x = self.pool(x)
        return x

class DenseNet_Inception(nn.Module):
    def __init__(self, in_channels, growth_rate=32, block_layers=[6, 12, 24, 16], num_classes=10):
        super(DenseNet_Inception, self).__init__()
        
        self.conv1 = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3)
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.block1 = DenseBlock(64, growth_rate, block_layers[0])
        self.trans1 = Transition(64 + block_layers[0]*growth_rate, 128)
        
        self.block2 = nn.Sequential(
            DenseBlock(128, growth_rate, block_layers[1]),
            Inception(128 + block_layers[1]*growth_rate)
        )
        self.trans2 = Transition(152, 256)
        
        self.block3 = nn.Sequential(
            DenseBlock(256, growth_rate, block_layers[2]),
            Inception(256 + block_layers[2]*growth_rate)
        )
        self.trans3 = Transition(280, 512)
        
        self.block4 = nn.Sequential(
            DenseBlock(512, growth_rate, block_layers[3]),
            nn.BatchNorm2d(512 + block_layers[3]*growth_rate),
            nn.ReLU(inplace=True),
            nn.AdaptiveAvgPool2d((1,1))
        )
        self.fc = nn.Linear(512 + block_layers[3]*growth_rate, num_classes)
        
    def forward(self, x):
        x = self.conv1(x)
        x = self.pool1(x)
        
        x = self.block1(x)
        x = self.trans1(x)
        
        x = self.block2(x)
        x = self.trans2(x)
        
        x = self.block3(x)
        x = self.trans3(x)
        
        x = self.block4(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

这里实现的是一个DenseNet-121和Inception结合的网络，其中DenseNet-121的结构和官方实现类似，但是在第二个和第三个密集块之后加入了Inception模块。同时，由于Inception模块输出通道数为96，因此在第一个转换层之后输出通道数需要设置为128。由于Inception模块的存在，最后一个密集块的输出通道数也需要根据实际情况进行调整，这里设置为512。最后，全连接层的输入特征维度需要加上最后一个密集块输出的特征维度，即512 + 16*growth_rate，其中growth_rate为每个DenseBlock中每层输出的通道数。