将以下ResUnet网络修改为Dense U-Net：class ResidualConvnnModule def __init__self input_dim output_dim stride padding superResidualConv self__init__ selfconv_block = nnSequential nnBa

修改后的Dense U-Net网络如下所示：

class DenseBlock(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(DenseBlock, self).__init__()

        self.conv_block = nn.Sequential(
            nn.BatchNorm2d(input_dim),
            nn.ReLU(),
            nn.Conv2d(
                input_dim, output_dim, kernel_size=3, stride=1, padding=1
            ),
        )

    def forward(self, x):
        return torch.cat([x, self.conv_block(x)], dim=1)


class DenseU_Net(nn.Module):
    def __init__(self, channel, output_ch, filters=[64, 128, 256, 512, 1024]):
        super(DenseU_Net, self).__init__()

        self.input_layer = nn.Sequential(
            nn.Conv2d(channel, filters[0], kernel_size=3, padding=1),
            nn.BatchNorm2d(filters[0]),
            nn.ReLU(),
            nn.Conv2d(filters[0], filters[0], kernel_size=3, padding=1),
        )

        self.dense_block_1 = DenseBlock(filters[0], filters[1])
        self.dense_block_2 = DenseBlock(filters[0] + filters[1], filters[2])
        self.dense_block_3 = DenseBlock(filters[0] + filters[1] + filters[2], filters[3])

        self.bridge = DenseBlock(filters[0] + filters[1] + filters[2] + filters[3], filters[4])

        self.upsample_1 = Upsample(filters[4], filters[3], 2, 2)
        self.up_dense_block1 = DenseBlock(filters[3] + filters[3], filters[3])

        self.upsample_2 = Upsample(filters[3], filters[2], 2, 2)
        self.up_dense_block2 = DenseBlock(filters[2] + filters[2], filters[2])

        self.upsample_3 = Upsample(filters[2], filters[1], 2, 2)
        self.up_dense_block3 = DenseBlock(filters[1] + filters[1], filters[1])

        self.upsample_4 = Upsample(filters[1], filters[0], 2, 2)
        self.up_dense_block4 = DenseBlock(filters[0] + filters[0], filters[0])

        self.output_layer = nn.Sequential(
            nn.Conv2d(filters[0], output_ch, kernel_size=1, stride=1),
            # nn.Sigmoid(),
        )

    def forward(self, x):
        # Encode
        x1 = self.input_layer(x)
        x2 = self.dense_block_1(x1)
        x3 = self.dense_block_2(torch.cat([x1, x2], dim=1))
        x4 = self.dense_block_3(torch.cat([x1, x2, x3], dim=1))
        # Bridge
        x5 = self.bridge(torch.cat([x1, x2, x3, x4], dim=1))
        # Decode
        x6 = self.upsample_1(x5)
        x7 = self.up_dense_block1(torch.cat([x6, x4], dim=1))

        x8 = self.upsample_2(x7)
        x9 = self.up_dense_block2(torch.cat([x8, x3], dim=1))

        x10 = self.upsample_3(x9)
        x11 = self.up_dense_block3(torch.cat([x10, x2], dim=1))

        x12 = self.upsample_4(x11)
        x13 = self.up_dense_block4(torch.cat([x12, x1], dim=1))

        output = self.output_layer(x13)

        return output

在Dense U-Net中，我们使用了DenseBlock代替ResidualConv。DenseBlock在每个层级中将输入特征图与经过卷积的特征图连接起来，以增加特征的多样性和丰富性。在解码阶段，我们使用了与编码阶段相对应的反卷积层（Upsample）和DenseBlock来恢复分辨率和特征。输出层与原始的ResUnet网络保持不变。