Spp-net原理

妖狐艹你老母 2024-04-17 17:23 41阅读 0赞

原文链接：https://blog.csdn.net/qq\_31442743/article/details/80770619

## 1 基础框架 ##

CNN网络需要固定尺寸的图像输入，SPPNet将任意大小的图像池化生成固定长度的图像表示，提升R-CNN检测的速度24-102倍。

固定图像尺寸输入的问题，截取的区域未涵盖整个目标或者缩放带来图像的扭曲。

事实上，CNN的卷积层不需要固定尺寸的图像，全连接层是需要固定大小输入的，因此提出了SPP层放到卷积层的后面，改进后的网络如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70]  
 SPP是BOW的扩展，将图像从精细空间划分到粗糙空间，之后将局部特征聚集。在CNN成为主流之前，SPP在检测和分类的应用比较广泛。

SPP的优点：

1）任意尺寸输入，固定大小输出

2）层多

3）可对任意尺度提取的特征进行池化。

## 2 理解池化 ##

说下池化，其实池化很容易理解，先看图：  
  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 1]  
  R-CNN提取特征比较耗时，需要对每个warp的区域进行学习，而SPPNet只对图像进行一次卷积，之后使用SPPNet在特征图上提取特征。结合EdgeBoxes提取的proposal，系统处理一幅图像需要0.5s。

SPP层的结构如下，将紧跟最后一个卷积层的池化层使用SPP代替，输出向量大小为kM，k=filters,M=bins，作为全连接层的输入。至此，网络不仅可对任意长宽比的图像进行处理，而且可对任意尺度的图像进行处理。尺度在深层网络学习中也很重要。  
  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 2]

## 3 SPP-Net公式 ##

设输入数据大小是（c, hin ，win），分别表示通道数，高度，宽度；  
池化数量：（n，n）；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 3]  
Kh表示核的高度  
Sh表示高度方向的步长  
Ph表示高度方向的填充数量，需要乘以2

注意核和步长的计算公式都使用的是ceil()，即向上取整，而padding使用的是floor()，即向下取整。

## 4 网络训练 ##

1.multi-size训练，输入尺寸在\[180,224\]之间，假设最后一个卷积层的输出大小为a×a，若给定金字塔层有n×n 个bins，进行滑动窗池化，窗口尺寸为win=⌈a/n⌉，步长为str=⌊a/n⌋，使用一个网络完成一个完整epoch的训练，之后切换到另外一个网络。只是在训练的时候用到多尺寸，测试时直接将SPPNet应用于任意尺寸的图像。

2.如果原图输入是224x224，对于conv5出来后的输出，是13x13x256的，可以理解成有256个这样的filter，每个filter对应一张13x13的reponse map。

重点内容如果像上图那样将reponse map分成4x4 2x2 1x1三张子图，做max pooling后，出来的特征就是固定长度的(16+4+1)x256那么多的维度了。如果原图的输入不是224x224，出来的特征依然是(16+4+1)x256

直觉地说，可以理解成将原来固定大小为(3x3)窗口的pool5改成了自适应窗口大小，窗口的大小和reponse map成比例，保证了经过pooling后出来的feature的长度是一致的。

## 5 结论: ##

输入层：一张任意大小的图片,假设其大小为(w,h)。

输出层：21个神经元。

也就是我们输入一张任意大小的特征图的时候，我们希望提取出21个特征。空间金字塔特征提取的过程如下  
  ![在这里插入图片描述][2019082911245939.png]  
  如上图所示，当我们输入一张图片的时候，我们利用不同大小的刻度，对一张图片进行了划分。上面示意图中，利用了三种不同大小的刻度，对一张输入的图片进行了划分，最后总共可以得到16+4+1=21个块，我们即将从这21个块中，每个块提取出一个特征，这样刚好就是我们要提取的21维特征向量。

1) 第一张图片,我们把一张完整的图片，分成了16个块，也就是每个块的大小就是(w/4,h/4);

2) 第二张图片，划分了4个块，每个块的大小就是(w/2,h/2);

3) 第三张图片，把一整张图片作为了一个块，也就是块的大小为(w,h)

空间金字塔最大池化的过程，其实就是从这21个图片块中，分别计算每个块的最大值，从而得到一个输出神经元。最后把一张任意大小的图片转换成了一个固定大小的21维特征（当然你可以设计其它维数的输出，增加金字塔的层数，或者改变划分网格的大小）。

上面的三种不同刻度的划分，每一种刻度我们称之为：金字塔的一层，每一个图片块大小我们称之为：windows size了。如果你希望，金字塔的某一层输出n\*n个特征，那么你就要用windows size大小为：(w/n,h/n)进行池化了。

当我们有很多层网络的时候，当网络输入的是一张任意大小的图片，这个时候我们可以一直进行卷积、池化，直到网络的倒数几层的时候，也就是我们即将与全连接层连接的时候，就要使用金字塔池化，使得任意大小的特征图都能够转换成固定大小的特征向量，这就是空间金字塔池化的奥义（多尺度特征提取出固定大小的特征向量）

## 6代码实现 ##

采用PyTorch深度学习框架，构建了一个SPP层，代码如下：

#coding=utf-8
    import math
    import torch
    import torch.nn.functional as F
    
    # 构建SPP层(空间金字塔池化层)
    class SPPLayer(torch.nn.Module):
    
        def __init__(self, num_levels, pool_type='max_pool'):
            super(SPPLayer, self).__init__()
    
            self.num_levels = num_levels
            self.pool_type = pool_type
    
        def forward(self, x):
            num, c, h, w = x.size() # num:样本数量 c:通道数 h:高 w:宽
            for i in range(self.num_levels):
                level = i+1
                kernel_size = (math.ceil(h / level), math.ceil(w / level))
                stride = (math.ceil(h / level), math.ceil(w / level))
                pooling = (math.floor((kernel_size[0]*level-h+1)/2), math.floor((kernel_size[1]*level-w+1)/2))
    
                # 选择池化方式 
                if self.pool_type == 'max_pool':
                    tensor = F.max_pool2d(x, kernel_size=kernel_size, stride=stride, padding=pooling).view(num, -1)
                else:
                    tensor = F.avg_pool2d(x, kernel_size=kernel_size, stride=stride, padding=pooling).view(num, -1)
    
                # 展开、拼接
                if (i == 0):
                    x_flatten = tensor.view(num, -1)
                else:
                    x_flatten = torch.cat((x_flatten, tensor.view(num, -1)), 1)
            return x_flatten

其中num\_levels为3时，表示分成的特征图为三个，分别是1等分特征图、4等分特征图和16等分的特征图，可以单独对模型的spp-net进行测试。测试代码如下：

from math import floor, ceil
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class SpatialPyramidPooling2d(nn.Module):
        r"""apply spatial pyramid pooling over a 4d input(a mini-batch of 2d inputs
        with additional channel dimension) as described in the paper
        'Spatial Pyramid Pooling in deep convolutional Networks for visual recognition'
        Args:
            num_level:
            pool_type: max_pool, avg_pool, Default:max_pool
        By the way, the target output size is num_grid:
            num_grid = 0
            for i in range num_level:
                num_grid += (i + 1) * (i + 1)
            num_grid = num_grid * channels # channels is the channel dimension of input data
        examples:
            # >>> input = torch.randn((1,3,32,32), dtype=torch.float32)
            # >>> net = torch.nn.Sequential(nn.Conv2d(in_channels=3,out_channels=32,kernel_size=3,stride=1),\
            #                               nn.ReLU(),\
            #                               SpatialPyramidPooling2d(num_level=2,pool_type='avg_pool'),\
            #                               nn.Linear(32 * (1*1 + 2*2), 10))
            # >>> output = net(input)
        """
    
        def __init__(self, num_level, pool_type='max_pool'):
            super(SpatialPyramidPooling2d, self).__init__()
            self.num_level = num_level
            self.pool_type = pool_type
    
        def forward(self, x):
            N, C, H, W = x.size()
            for i in range(self.num_level):
                level = i + 1
                kernel_size = (ceil(H / level), ceil(W / level))
                stride = (ceil(H / level), ceil(W / level))
                padding = (floor((kernel_size[0] * level - H + 1) / 2), floor((kernel_size[1] * level - W + 1) / 2))
    
                if self.pool_type == 'max_pool':
                    tensor = (F.max_pool2d(x, kernel_size=kernel_size, stride=stride, padding=padding)).view(N, -1)
                else:
                    tensor = (F.avg_pool2d(x, kernel_size=kernel_size, stride=stride, padding=padding)).view(N, -1)
    
                if i == 0:
                    res = tensor
                else:
                    res = torch.cat((res, tensor), 1)
            return res
    
        def __repr__(self):
            return self.__class__.__name__ + '(' \
                   + 'num_level = ' + str(self.num_level) \
                   + ', pool_type = ' + str(self.pool_type) + ')'
    
    
    class SPPNet(nn.Module):
        def __init__(self, num_level=3, pool_type='max_pool'):
            super(SPPNet, self).__init__()
            self.num_level = num_level
            self.pool_type = pool_type
            self.feature = nn.Sequential(nn.Conv2d(3, 64, 3), nn.ReLU(),nn.MaxPool2d(2),nn.Conv2d(64, 64, 3),nn.ReLU())
            self.num_grid = self._cal_num_grids(num_level)
            self.spp_layer = SpatialPyramidPooling2d(num_level)
            self.linear = nn.Sequential(nn.Linear(self.num_grid * 64, 512),nn.Linear(512, 10))
    
        def _cal_num_grids(self, level):
            count = 0
            for i in range(level):
                count += (i + 1) * (i + 1)
            return count
    
        def forward(self, x):
            x = self.feature(x)
            x = self.spp_layer(x)
            print(x.size())
            x = self.linear(x)
            return x
    
    
    if __name__ == '__main__':
        a = torch.rand((1, 3, 64, 64))
        net = SPPNet()
        output = net(a)
        print(output)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d96ed21f25bb412abb6ce3b12a216940.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/042d7d80f5344260acddb9e892d4ef40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/c328cf1904c94b63a4ac452fe5496ef7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/38f7e819e9964477ac2bdea0db9cc46e.png
[2019082911245939.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/ac7151bd9e0b41b2b4dc6eedd0392cf4.png