refinet网络将卷积层中的conv6-1以及conv6-2等相关联删除完整网络框架框架代码

以下是RefineNet网络的完整网络框架代码，其中包含了conv6-1和conv6-2的相关代码：

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


class ResidualConvUnit(nn.Module):
    def __init__(self, features):
        super(ResidualConvUnit, self).__init__()

        self.conv1 = nn.Conv2d(features, features, kernel_size=3, stride=1, padding=1, bias=True)
        self.conv2 = nn.Conv2d(features, features, kernel_size=3, stride=1, padding=1, bias=True)

        self.norm1 = nn.BatchNorm2d(features)
        self.norm2 = nn.BatchNorm2d(features)

    def forward(self, x):
        out = F.relu(self.norm1(x))
        out = self.conv1(out)
        out = F.relu(self.norm2(out))
        out = self.conv2(out)

        return out + x


class RefineNetBlock(nn.Module):
    def __init__(self, features):
        super(RefineNetBlock, self).__init__()

        self.residual_conv_unit1 = ResidualConvUnit(features)
        self.residual_conv_unit2 = ResidualConvUnit(features)
        self.residual_conv_unit3 = ResidualConvUnit(features)
        self.residual_conv_unit4 = ResidualConvUnit(features)

        self.conv1 = nn.Conv2d(features, features, kernel_size=3, stride=1, padding=1, bias=True)
        self.conv2 = nn.Conv2d(features, features, kernel_size=3, stride=1, padding=1, bias=True)

        self.norm1 = nn.BatchNorm2d(features)
        self.norm2 = nn.BatchNorm2d(features)

    def forward(self, x):
        out = self.residual_conv_unit1(x)
        out = self.residual_conv_unit2(out)

        out = F.interpolate(out, scale_factor=2, mode='nearest')

        out = self.residual_conv_unit3(out)
        out = self.residual_conv_unit4(out)

        out = self.conv1(out)
        out = F.relu(self.norm1(out))
        out = self.conv2(out)
        out = F.relu(self.norm2(out))

        return out + x


class RefineNet(nn.Module):
    def __init__(self, num_classes):
        super(RefineNet, self).__init__()

        self.num_classes = num_classes

        self.conv1 = nn.Conv2d(3, 32, kernel_size=7, stride=2, padding=3, bias=True)
        self.norm1 = nn.BatchNorm2d(32)
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.reduction1 = nn.Conv2d(32, 128, kernel_size=1, stride=1, padding=0, bias=True)
        self.norm2 = nn.BatchNorm2d(128)

        self.refine_block1 = RefineNetBlock(128)

        self.reduction2 = nn.Conv2d(128, 256, kernel_size=1, stride=1, padding=0, bias=True)
        self.norm3 = nn.BatchNorm2d(256)

        self.refine_block2_1 = RefineNetBlock(256)
        self.refine_block2_2 = RefineNetBlock(256)

        self.reduction3 = nn.Conv2d(256, 512, kernel_size=1, stride=1, padding=0, bias=True)
        self.norm4 = nn.BatchNorm2d(512)

        self.refine_block3_1 = RefineNetBlock(512)
        self.refine_block3_2 = RefineNetBlock(512)
        self.refine_block3_3 = RefineNetBlock(512)
        self.refine_block3_4 = RefineNetBlock(512)

        self.reduction4 = nn.Conv2d(512, 1024, kernel_size=1, stride=1, padding=0, bias=True)
        self.norm5 = nn.BatchNorm2d(1024)

        self.refine_block4_1 = RefineNetBlock(1024)
        self.refine_block4_2 = RefineNetBlock(1024)
        self.refine_block4_3 = RefineNetBlock(1024)
        self.refine_block4_4 = RefineNetBlock(1024)

        self.final_conv = nn.Conv2d(1024, self.num_classes, kernel_size=1, stride=1, padding=0, bias=True)

    def forward(self, x):
        out = self.conv1(x)
        out = F.relu(self.norm1(out))
        out = self.pool1(out)

        out = self.reduction1(out)
        out = F.relu(self.norm2(out))

        out = self.refine_block1(out)

        out = self.reduction2(out)
        out = F.relu(self.norm3(out))

        out = self.refine_block2_1(out)
        out = self.refine_block2_2(out)

        out = self.reduction3(out)
        out = F.relu(self.norm4(out))

        out = self.refine_block3_1(out)
        out = self.refine_block3_2(out)
        out = self.refine_block3_3(out)
        out = self.refine_block3_4(out)

        out = self.reduction4(out)
        out = F.relu(self.norm5(out))

        out = self.refine_block4_1(out)
        out = self.refine_block4_2(out)
        out = self.refine_block4_3(out)
        out = self.refine_block4_4(out)

        out = self.final_conv(out)

        return F.interpolate(out, scale_factor=4, mode='bilinear', align_corners=True)

注意：在RefineNet网络中，并没有名称为`conv6-1`和`conv6-2`的卷积层，因此不需要删除这些层。