『深度概念』原理图解代码FPN Feature Pyramid Networks

0 原理

FPN 2017年Facebook的Tsung-Yi Lin等提出了FPN特征金字塔架构,可以灵活地应用在不同地任务中去,包括目标检测、实例分割等实现端到端训练。

之前算法采用多尺度特征融合的方式一般是采用融合后的特征做预测,而FPN算法不一样的地方在于预测是在不同特征层独立进行的,利用深层特征通过上采样和低层特征做融合。被广泛使用,有效提高小目标检测及mAP.
 

在以往的faster rcnn进行目标检测时,无论是rpn还是fast rcnn,roi 都作用在最后一层,这在大目标的检测没有问题,但是对于小目标的检测就有些问题。因为对于小目标来说,当进行卷积池化到最后一层,实际上语义信息已经没有了,因为我们都知道对于一个roi映射到某个feature map的方法就是将底层坐标直接除以stride,显然越后,映射过去后就越小,甚至可能就没有了。 所以为了解决多尺度检测的问题,引入了特征金字塔网络。

下面我们介绍一下特征金字塔网络。如下引用[1]


 

  • 图(a)是相当常见的一种多尺度方法,称为featurized image pyramid,这种方法在较早的人工设计特征(DPM)时被广泛使用,在CNN中也有人使用过。就是对input iamge进行multi scale,通过设置不同的缩放比例实现。这种可以解决多尺度,但是相当于训练了多个模型(假设要求输入大小固定),即便允许输入大小不固定,但是也增加了存储不同scale图像的内存空间。

  • 图(b)就是CNN了,cnn相比人工设计特征,能够自己学习到更高级的语义特征,同时CNN对尺度变化鲁棒,因此如图,从单个尺度的输入计算的特征也能用来识别,但是遇到明显的多尺度目标检测时,还是需要金字塔结构来进一步提升准确率。
    从现在在imageNet和COCO数据集上领先的的一些方法来看,在测试的时候都用到了featurized image pyramid方法,即结合(a),(b)。 说明了特征化图像金字塔的每一级的好处在于,产生了多尺度的特征表示,每一级的特征都有很强的语义(因为都用cnn生成的特征),包括高分辨率的一级(最大尺度的输入图像)。
    但是这种模式有明显的弊端,相比于原来方法,时间增长了4倍,很难在实时应用中使用,同样,也增大了存储代价,这就是为什么只是在测试阶段使用image pyramid。但是如果只在测试阶段使用,那么训练和测试在推断的时候会不一致。所以,最近的一些方法干脆舍弃了image pyramid。

但是image pyramid不是计算多尺度特征表示的唯一方法。deepCNN能够层次化的特征,而且因为池化的作用,会产生金字塔形的特征,具有一种内在的多尺度。但是问题在于,高分辨率的map(浅层)具有low-level的特征,所以浅层的目标识别性能较弱。这也是不同level融合的目的。

  • 如图(c),SSD较早尝试了使用CNN金字塔形的层级特征。理想情况下,SSD风格的金字塔 重利用了前向过程计算出的来自多层的多尺度特征图,因此这种形式是不消耗额外的资源的。但是SSD为了避免使用low-level的特征,放弃了浅层的feature map,而是从conv4_3开始建立金字塔,而且加入了一些新的层。因此SSD放弃了重利用更高分辨率的feature map,但是这些feature map对检测小目标非常重要。这就是SSD与FPN的区别。

  • 图(4)是FPN的结构,FPN是为了自然地利用CNN层级特征的金字塔形式,同时生成在所有尺度上都具有强语义信息的特征金字塔。所以FPN的结构设计了top-down结构和横向连接,以此融合具有高分辨率的浅层layer和具有丰富语义信息的深层layer。这样就实现了从单尺度的单张输入图像,快速构建在所有尺度上都具有强语义信息的特征金字塔,同时不产生明显的代价。

下面我们再来看一下相似的网络:

 


这里写图片描述


上面一个带有skip connection的网络结构在预测的时候是在finest level(自顶向下的最后一层)进行的,简单讲就是经过多次上采样并融合特征到最后一步,拿最后一步生成的特征做预测。而FPN网络结构和上面的类似,区别在于预测是在每一层中独立进行的。后面的实验证明finest level的效果不如FPN好,原因在于FPN网络是一个窗口大小固定的滑动窗口检测器,因此在金字塔的不同层滑动可以增加其对尺度变化的鲁棒性。另外虽然finest level有更多的anchor,但仍然效果不如FPN好,说明增加anchor的数量并不能有效提高准确率。

 

自下而上的路径

CNN的前馈计算就是自下而上的路径,特征图经过卷积核计算,通常是越变越小的,也有一些特征层的输出和原来大小一样,称为“相同网络阶段”(same network stage )。对于本文的特征金字塔,作者为每个阶段定义一个金字塔级别, 然后选择每个阶段的最后一层的输出作为特征图的参考集。 这种选择是很自然的,因为每个阶段的最深层应该具有最强的特征。具体来说,对于ResNets,作者使用了每个阶段的最后一个残差结构的特征激活输出。将这些残差模块输出表示为{C2, C3, C4, C5},对应于conv2,conv3,conv4和conv5的输出,并且注意它们相对于输入图像具有{4, 8, 16, 32}像素的步长。考虑到内存占用,没有将conv1包含在金字塔中。

自上而下的路径和横向连接

自上而下的路径(the top-down pathway )是如何去结合低层高分辨率的特征呢?方法就是,把更抽象,语义更强的高层特征图进行上取样,然后把该特征横向连接(lateral connections )至前一层特征,因此高层特征得到加强。值得注意的是,横向连接的两层特征在空间尺寸上要相同。这样做应该主要是为了利用底层的定位细节信息。

下图显示连接细节。把高层特征做2倍上采样(最邻近上采样法,可以参考反卷积),然后将其和对应的前一层特征结合(前一层要经过1 * 1的卷积核才能用,目的是改变channels,应该是要和后一层的channels相同),结合方式就是做像素间的加法。重复迭代该过程,直至生成最精细的特征图。迭代开始阶段,作者在C5层后面加了一个1 * 1的卷积核来产生最粗略的特征图,最后,作者用3 * 3的卷积核去处理已经融合的特征图(为了消除上采样的混叠效应),以生成最后需要的特征图。为了后面的应用能够在所有层级共享分类层,这里坐着固定了3*3卷积后的输出通道为d,这里设为256.因此所有额外的卷积层(比如P2)具有256通道输出。这些额外层没有用非线性。

{C2, C3, C4, C5}层对应的融合特征层为{P2, P3, P4, P5},对应的层空间尺寸是相通的。

 


这里写图片描述

 

1 图解

2 代码

'''FPN in PyTorch.
See the paper "Feature Pyramid Networks for Object Detection" for more details.
'''
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, in_planes, planes, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(self.expansion*planes)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_planes != self.expansion*planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        out += self.shortcut(x)
        out = F.relu(out)
        return out


class FPN(nn.Module):
    def __init__(self, block, num_blocks):
        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, num_blocks[0], stride=1)
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
        self.layer4 = self._make_layer(block, 512, num_blocks[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, num_blocks, stride):
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_planes, planes, stride))
            self.in_planes = planes * block.expansion
        return nn.Sequential(*layers)

    def _upsample_add(self, x, y):
        '''Upsample and add two feature maps.

        Args:
          x: (Variable) top feature map to be upsampled.
          y: (Variable) lateral feature map.

        Returns:
          (Variable) added feature map.

        Note in PyTorch, when input size is odd, the upsampled feature map
        with `F.upsample(..., scale_factor=2, mode='nearest')`
        maybe not equal to the lateral feature map size.

        e.g.
        original input size: [N,_,15,15] ->
        conv2d feature map size: [N,_,8,8] ->
        upsampled feature map size: [N,_,16,16]

        So we choose bilinear upsample which supports arbitrary output sizes.
        '''
        _,_,H,W = y.size()
        return F.upsample(x, size=(H,W), mode='bilinear') + 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, [2,2,2,2])

def test():
    net = FPN101()
    fms = net(Variable(torch.randn(1,3,600,900)))
    for fm in fms:
        print(fm.size())

test()

输出:

c1:torch.Size([1, 64, 150, 225])
c2:torch.Size([1, 256, 150, 225])
c3:torch.Size([1, 512, 75, 113])
c4:torch.Size([1, 1024, 38, 57])
c5:torch.Size([1, 2048, 19, 29])
p5:torch.Size([1, 256, 19, 29])
latlayer1(c4):torch.Size([1, 256, 38, 57]), p4:torch.Size([1, 256, 38, 57])
latlayer1(c3):torch.Size([1, 256, 75, 113]), p3:torch.Size([1, 256, 75, 113])
latlayer1(c2):torch.Size([1, 256, 150, 225]), p2:torch.Size([1, 256, 150, 225])

# p2, p3, p4, p5
torch.Size([1, 256, 150, 225])
torch.Size([1, 256, 75, 113])
torch.Size([1, 256, 38, 57])
torch.Size([1, 256, 19, 29])

 

-1 参考

  1. https://blog.csdn.net/xiamentingtao/article/details/78598027
  2. https://blog.csdn.net/shiwanghualuo/article/details/102467313

 

©️2020 CSDN 皮肤主题: 1024 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值