空间金字塔池化（Spatial Pyramid Pooling, SPP）原理和代码实现

上图是原文中给出的示意图，需要从下往上看:

首先是输入层(input image),其大小可以是任意的

进行卷积运算，到最后一个卷积层(图中是conv5)输出得到该层的特征映射(feature maps)，其大小也是任意的

下面进入SPP层

我们先看最左边有16个蓝色小格子的图，它的意思是将从conv5得到的特征映射分成16份，另外16X256中的256表示的是channel，即SPP对每一层都分成16份(不一定是等比分，原因看后面的内容就能理解了)。

中间的4个绿色小格子和右边1个紫色大格子也同理，即将特征映射分别分成4X256和1X256份

那么将特征映射分成若干等分是做什么用的呢？ 我们看SPP的名字就是到了，是做池化操作，一般选择MAX Pooling，即对每一份进行最大池化。

我们看上图，通过SPP层，特征映射被转化成了16X256+4X256+1X256 = 21X256的矩阵，在送入全连接时可以扩展成一维矩阵，即1X10752，所以第一个全连接层的参数就可以设置成10752了，这样也就解决了输入数据大小任意的问题了。

注意上面划分成多少份是可以自己是情况设置的，例如我们也可以设置成3X3等，但一般建议还是按照论文中说的的进行划分。

代码：

from math import floor, ceil
import torch
import torch.nn as nn
import torch.nn.functional as F
class SpatialPyramidPooling2d(nn.Module):
    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()
        print('多尺度提取信息，并进行特征融合...')
        print()
        for i in range(self.num_level):
            level = i + 1
            print('第',level,'次计算池化核：')
            kernel_size = (ceil(H / level), ceil(W / level))
            print('kernel_size: ',kernel_size)
            stride = (ceil(H / level), ceil(W / level))
            print('stride: ',stride)
            padding = (floor((kernel_size[0] * level - H + 1) / 2), floor((kernel_size[1] * level - W + 1) / 2))
            print('padding: ',padding)
            print()
            print('进行最大池化并将提取特征展开：')
            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
                print('展开大小为： ',res.size())  #64x1
                print()
            else:
                res = torch.cat((res, tensor), 1)  #  i=1 64x（1+4） i=2  64x（1+4+9）
                print('合并为： ',res.size())
                print()
        return res
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())
        # num_grid = 1 + 4 + 9 = 14
        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):
        print('x初始大小为：')
        N, C, H, W = x.size()
        print('N:', N, ' C:', C, ' H', H, ' W:', W)
        print()
        x = self.feature(x)
        print('x经过卷积、激活、最大池化、卷积、激活变成：')
        N, C, H, W = x.size()
        print('64(conv)->62(maxpool)->31(conv)->29')
        print('N:', N, ' C:', C, ' H', H, ' W:', W)
        print()
        print('x进行空间金字塔池化：')
        x = self.spp_layer(x)
        print('空间金字塔池化后，x进入全连接层：')
        x = self.linear(x)
        return x
if __name__ == '__main__':
    a = torch.rand((1, 3, 64, 64))
    net = SPPNet()
    output = net(a)
    print(output)

输出结果：

x初始大小为：
N: 1  C: 3  H 64  W: 64
 
x经过卷积、激活、最大池化、卷积、激活变成：
64(conv)->62(maxpool)->31(conv)->29
N: 1  C: 64  H 29  W: 29
 
x进行空间金字塔池化：
多尺度提取信息，并进行特征融合...
 
第 1 次计算池化核：
kernel_size:  (29, 29)
stride:  (29, 29)
padding:  (0, 0)
 
进行最大池化并将提取特征展开：
展开大小为：  torch.Size([1, 64])
 
第 2 次计算池化核：
kernel_size:  (15, 15)
stride:  (15, 15)
padding:  (1, 1)
 
进行最大池化并将提取特征展开：
合并为：  torch.Size([1, 320])
 
第 3 次计算池化核：
kernel_size:  (10, 10)
stride:  (10, 10)
padding:  (1, 1)
 
进行最大池化并将提取特征展开：
合并为：  torch.Size([1, 896])
 
空间金字塔池化后，x进入全连接层：
tensor([[-0.0894, -0.1091, -0.1104,  0.0846, -0.0732,  0.0539,  0.0072, -0.0244,
         -0.0082,  0.0929]], grad_fn=<AddmmBackward>)
 
Process finished with exit code 0