魔改检测模型RFBNet用作分类的实验，含pytorch代码

RFBNet是一个比较经典的图像分割模型，该模型使用了空洞卷积、多分支融合和残差的思路。

论文地址：https://arxiv.org/pdf/1711.07767.pdf

其核心模块的示意图如下：

因为我本身的研究方向只有分类和分割，不做检测。

所以，我尝试把这个模块融入到分类模型中。

一方面是好奇，是否能提升分类结果，其次也是作为pytorch代码的日常训练。

实验思路很简单，首先图像输入vgg19的前两个stage，后接一个RFB模块，最后接全局池化和FC层。

代码：

class RFBNet(nn.Module):

    def __init__(self, RFBBlock, num_classes=6):
        super(RFBNet, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 64, 3, 1, 1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 64, 3, 1, 1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2,2)
            )
        self.layer2 = nn.Sequential(
            nn.Conv2d(64, 128, 3, 1, 1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.Conv2d(128, 128, 3, 1, 1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(2,2)
            )
        self.layer3 = self._make_layer(RFBBlock,128,512)
        self.gap1 = nn.Sequential(nn.AdaptiveAvgPool2d(1))
        self.fc1 = nn.Sequential(
            nn.Flatten(),
            nn.Linear(512,6),)

    def forward(self,x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.gap1(x)
        out = self.fc1(x)
        return out
        
    def _make_layer(self,block,in_planes, out_planes):
        layer = block(in_planes, out_planes)
        return nn.Sequential(layer)

RFB模块的代码如下：

class RFBBlock(nn.Module):

    def __init__(self, in_planes, out_planes, stride=1, scale = 0.1, visual = 1):
        super(RFBBlock, self).__init__()
        self.scale = scale
        self.out_channels = out_planes
        inter_planes = in_planes // 8
        self.branch0 = nn.Sequential(
                BasicConv(in_planes, 2*inter_planes, kernel_size=1, stride=stride),
                BasicConv(2*inter_planes, 2*inter_planes, kernel_size=3, stride=1, padding=visual, dilation=visual, relu=False)
                )
        self.branch1 = nn.Sequential(
                BasicConv(in_planes, inter_planes, kernel_size=1, stride=1),
                BasicConv(inter_planes, 2*inter_planes, kernel_size=(3,3), stride=stride, padding=(1,1)),
                BasicConv(2*inter_planes, 2*inter_planes, kernel_size=3, stride=1, padding=visual+1, dilation=visual+1, relu=False)
                )
        self.branch2 = nn.Sequential(
                BasicConv(in_planes, inter_planes, kernel_size=1, stride=1),
                BasicConv(inter_planes, (inter_planes//2)*3, kernel_size=3, stride=1, padding=1),
                BasicConv((inter_planes//2)*3, 2*inter_planes, kernel_size=3, stride=stride, padding=1),
                BasicConv(2*inter_planes, 2*inter_planes, kernel_size=3, stride=1, padding=2*visual+1, dilation=2*visual+1, relu=False)
                )

        self.ConvLinear = BasicConv(6*inter_planes, out_planes, kernel_size=1, stride=1, relu=False)
        self.shortcut = BasicConv(in_planes, out_planes, kernel_size=1, stride=stride, relu=False)
        self.relu = nn.ReLU(inplace=False)

    def forward(self,x):
        x0 = self.branch0(x)
        x1 = self.branch1(x)
        x2 = self.branch2(x)

        out = torch.cat((x0,x1,x2),1)
        out = self.ConvLinear(out)
        short = self.shortcut(x)
        out = out*self.scale + short
        out = self.relu(out)

        return out

这么简单一改之后，模型的实验结果比VGG19和resnet都强，但是这种级别的创新想发论文是不可能的，只能发表在csdn上（笑