ResNet+FPN实现+白嫖代码

不念不忘少年蓝@ 2022-11-22 10:24 163阅读 0赞

===========================================================

**有现成的代码：**[https://github.com/Kongsea/FPN\_TensorFlow][https_github.com_Kongsea_FPN_TensorFlow]

**推荐根据该博客来学习：[https://www.jianshu.com/p/324af87a11a6][https_www.jianshu.com_p_324af87a11a6]**

**[https://blog.csdn.net/bi\_diu1368/article/details/90812517][https_blog.csdn.net_bi_diu1368_article_details_90812517]**

============================================================

**纸上得来终觉浅，须知此事要coding！**

# ResNet+FPN实现 #

### 我们先说FPN的目的。   熟悉faster rcnn的人知道，faster rcnn利用的是vgg的最后的卷积特征，大小是7x7x512。而这造成了一个问题，经过多次卷积之后的特征通常拥有很大的感受野，**它们比较适合用来检测大物体，或者说，它们在检测小物体任务上效果很差**，所以像ssd和fpn这样的网络思想就是将前面和后面的的卷积层都拿出来，组成一个multisacle结果，既能检测大物体，又能检测小物体。   基于这个思想，fpn从ResNet 34层模型构造了一组新的特征，p2,p3,p4,p5，每一个p\_ipi都是ResNet中不同卷积层融合的结果，这保证了他们拥有多尺度信息。**他们拥有相同的维度，都是256**。   构造的方式如下，**先贴FPN：**   ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbWVhMjM_size_16_color_FFFFFF_t_70_pic_center] ###

### bottom-up就是简单的使用了ResNet34，主要是top-down中的思想。   在上文中我们提到c2-c5的大小和维度分别是56x56x64,28x28x128,14x14x256,7x7x512，所以在top-down中，先用了一个1x1x256的卷积将c5:7x7x512 变成了m5:7x7x256, 每一个m之后都接了一个3x3x256卷积用来消除不同层之间的混叠效果，其实也就是缓冲作用。   关于p4的构造，我们先将m5的feature map加倍，用简单的nearest neighbour upsamping方法就行，这样m5就变成了m5’:14x14x256，同时c4:14x14x256经过1x1x256得到c4’:14x14x256, 将m5’+c4’, element-wisely，就可以得到m4:14x14x256。   …   所以最后的p2-p5大小分别是   56x56x256。，28x28x256，14x14x256，7x7x256。 ###

### 这只是FPN结构，具体的FPN网络就比较复杂了，也贴一个![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbWVhMjM_size_16_color_FFFFFF_t_70_pic_center 1]   稍微讲一下FPN结构吧，用的原理就是图像处理中很简单但很重要的金字塔结构。以ResNet50为例，四层结构得到的特征图尺寸应为：（ResNet50可看我上一篇博客）   c1:torch.Size(\[1, 64, 56, 56\])   c2:torch.Size(\[1, 256, 56, 56\])   c3:torch.Size(\[1, 512, 28, 28\])   c4:torch.Size(\[1, 1024, 14, 14\])   c5:torch.Size(\[1, 2048, 7, 7\])   之后对c1-c5进行处理。我们的目标是输出四种特征图，其尺寸不同，但深度都为256。   P2:torch.Size(\[1, 256, 56, 56\])   P3:torch.Size(\[1, 256, 28, 28\])   P4:torch.Size(\[1, 256, 14, 14\])   P5:torch.Size(\[1, 256, 7, 7\])   具体做法是：   1.将c5降到256，经过3*3的卷积处理输出P5.   2.c5上采样后与经过1*1降维处理过的c4相加，再经3\*3卷积处理，得到P4。   以此类推… ###

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from torch.autograd import Variable
    class Bottleneck(nn.Module):
        expansion = 4
        def __init__(self, inplanes, planes, stride=1, downsample=None):
            super(Bottleneck, self).__init__()
            self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, stride=stride, bias=False)
            self.bn1 = nn.BatchNorm2d(planes)
            self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
            self.bn2 = nn.BatchNorm2d(planes)
            self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
            self.bn3 = nn.BatchNorm2d(planes * 4)
            self.relu = nn.ReLU(inplace=True)
            self.downsample = downsample
            self.stride = stride
        def forward(self, x):
            residual = x
            out = self.conv1(x)
            out = self.bn1(out)
            out = self.relu(out)
            out = self.conv2(out)
            out = self.bn2(out)
            out = self.relu(out)
            out = self.conv3(out)
            out = self.bn3(out)
            if self.downsample is not None:
                residual = self.downsample(x)
            out += residual
            out = self.relu(out)
            return out
    class FPN(nn.Module):
        def __init__(self, block, layers):
            super(FPN, self).__init__()
            self.in_planes = 64
            self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
            self.bn1 = nn.BatchNorm2d(64)
            # Bottom-up layers
            self.layer1 = self._make_layer(block,  64, layers[0])
            self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
            self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
            self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
            # Top layer
            self.toplayer = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0)  # Reduce channels
            # Smooth layers
            self.smooth1 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
            self.smooth2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
            self.smooth3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
            # Lateral layers
            self.latlayer1 = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0)
            self.latlayer2 = nn.Conv2d( 512, 256, kernel_size=1, stride=1, padding=0)
            self.latlayer3 = nn.Conv2d( 256, 256, kernel_size=1, stride=1, padding=0)
    
        def _make_layer(self, block, planes, blocks, stride=1):
            downsample = None
            if stride != 1 or self.in_planes != planes * block.expansion:
                downsample = nn.Sequential(
                    nn.Conv2d(self.in_planes, planes * block.expansion,
                              kernel_size=1, stride=stride, bias=False),
                    nn.BatchNorm2d(planes * block.expansion),
                )
            layers = []
            layers.append(block(self.in_planes, planes, stride, downsample))
            self.in_planes = planes * block.expansion
            for i in range(1, blocks):
                layers.append(block(self.in_planes, planes))
            return nn.Sequential(*layers)
        def _upsample_add(self, x, y):
            _,_,H,W = y.size()
            return F.interpolate(x, size=(H,W), mode='bilinear',align_corners=True) + y
        def forward(self, x):
            # Bottom-up
            c1 = F.relu(self.bn1(self.conv1(x)))
            c1 = F.max_pool2d(c1, kernel_size=3, stride=2, padding=1)
            #print(f'c1:{c1.shape}')
            c2 = self.layer1(c1)
            #print(f'c2:{c2.shape}')
            c3 = self.layer2(c2)
            #print(f'c3:{c3.shape}')
            c4 = self.layer3(c3)
            #print(f'c4:{c4.shape}')
            c5 = self.layer4(c4)
            #print(f'c5:{c5.shape}')
            # Top-down
            p5 = self.toplayer(c5)
            #print(f'p5:{p5.shape}')
            p4 = self._upsample_add(p5, self.latlayer1(c4))
            #print(f'latlayer1(c4):{self.latlayer1(c4).shape}, p4:{p4.shape}')
            p3 = self._upsample_add(p4, self.latlayer2(c3))
            #print(f'latlayer1(c3):{self.latlayer2(c3).shape}, p3:{p3.shape}')
            p2 = self._upsample_add(p3, self.latlayer3(c2))
            #print(f'latlayer1(c2):{self.latlayer3(c2).shape}, p2:{p2.shape}')
            # Smooth
            p4 = self.smooth1(p4)
            p3 = self.smooth2(p3)
            p2 = self.smooth3(p2)
            return p2, p3, p4, p5
    def FPN101():
        # return FPN(Bottleneck, [2,4,23,3])
        return FPN(Bottleneck, [3,4,6,3])
    def test():
        net = FPN101()
        fms = net(Variable(torch.randn(1,3,224,224)))
        for fm in fms:
            print(fm.size())

[https_github.com_Kongsea_FPN_TensorFlow]: https://github.com/Kongsea/FPN_TensorFlow
[https_www.jianshu.com_p_324af87a11a6]: https://www.jianshu.com/p/324af87a11a6
[https_blog.csdn.net_bi_diu1368_article_details_90812517]: https://blog.csdn.net/bi_diu1368/article/details/90812517
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbWVhMjM_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/9d37ca0ec6de4a23bfa8ea2f1dfe4e5e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbWVhMjM_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200329010409900.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbWVhMjM=,size_16,color_FFFFFF,t_70#pic_center