DesNet和ResNet 结合

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

创新思路：
ResNet 的核心在于通过残差连接解决了深度神经网络中梯度消失和网络退化的问题，使得网络可以更容易地学习恒等映射，能够训练更深的网络。而 DenseNet 的特点是层与层之间密集连接，每一层都接收前面所有层的特征图作为输入，这种连接方式增加了特征的复用性，减少了参数数量，并且缓解了梯度消失问题。

我们可以结合两者的优点，在模型的某些部分使用 ResNet 的残差连接，以帮助网络更好地学习深度特征和避免梯度问题；在另外一些部分使用 DenseNet 的密集连接，充分利用特征复用的优势。例如，在网络的浅层部分，使用 DenseNet 的密集连接结构，让网络快速提取和复用底层特征；在网络的深层部分，采用 ResNet 的残差连接，确保深层网络能够稳定地学习到复杂的特征表示。

模型结构图：
由于这里无法直接绘制专业的模型结构图，为你简单描述一下。

1. 输入层：接收图像数据。
2. 初始卷积层：进行初步的特征提取。
3. 浅层 DenseNet 模块：包含多个密集连接的层，每一层接收前面所有层的特征图作为输入。
4. 过渡层（可选）：用于降低特征图的维度，减少计算量。
5. 深层 ResNet 模块：由多个残差块组成，每个残差块包含跳跃连接和卷积操作。
6. 全局平均池化层：将特征图转换为固定长度的特征向量。
7. 全连接层：进行分类预测，输出类别概率。

import torch
import torch.nn as nn


# DenseNet的基本块
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):
            layer = 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, padding=1)
            )
            self.layers.append(layer)

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


# ResNet的残差块
class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        if in_channels != out_channels or stride != 1:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
        else:
            self.shortcut = nn.Identity()

    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)

        out += self.shortcut(identity)
        out = self.relu(out)
        return out


# 结合ResNet和DenseNet的模型
class CombinedModel(nn.Module):
    def __init__(self, num_classes):
        super(CombinedModel, self).__init__()
        self.initial_conv = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        # 浅层DenseNet模块
        self.dense_block1 = DenseBlock(64, 32, 3)
        self.transition1 = nn.Sequential(
            nn.BatchNorm2d(64 + 3 * 32),
            nn.ReLU(inplace=True),
            nn.Conv2d(64 + 3 * 32, 128, kernel_size=1)
        )

        # 深层ResNet模块
        self.res_block1 = ResidualBlock(128, 256, stride=2)
        self.res_block2 = ResidualBlock(256, 256)

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(256, num_classes)

    def forward(self, x):
        x = self.initial_conv(x)
        x = self.bn(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.dense_block1(x)
        x = self.transition1(x)

        x = self.res_block1(x)
        x = self.res_block2(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x

# 测试模型
model = CombinedModel(num_classes=10)
input_tensor = torch.randn(1, 3, 224, 224)
output = model(input_tensor)
print(output.shape)

 

当运行上述代码时，在终端中会输出模型输出的张量形状。代码运行没有报错，并且输出了合理的形状（例如对于分类 10 个类别的模型，输出形状为 torch.Size([1, 10]) ），则说明代码在语法和逻辑上没有明显问题。可以进一步使用实际的图像识别数据集（如 CIFAR-10 等）来训练和评估模型，以验证其在实际任务中的效果。