pytorch-ssd源码解读（一）------------PriorBox（默认框生成）

柔情只为你懂 2022-02-13 05:11 203阅读 0赞

*  [源码地址][Link 1]

# 一、相关函数 #

本部分介绍一下代码中使用的不常见的函数

**1、torch.clamp( ）**

该函数原型如下：

torch.clamp(input, min, max, out=None)  --> Tensor

将输入input张量每个元素的夹紧到区间 \[min,max\]，并返回结果到一个新张量。其实就是我们常用的截断函数（分段阈值）。

![201904262236268.png][]

举个例子：

input = torch.Tensor([2,1,0.5,-0.5])
    output = torch.clamp(input,0,1)
    print(output)
    
    '''
    output
    Out[16]: tensor([1.0000, 1.0000, 0.5000, 0.0000])
    '''

**2.itertools.product()**

原型如下：

product(*iterables, repeat=1) --> product object

iterables是可迭代对象,repeat指定iterable重复几次,即: product(A,repeat=3)等价于product(A,A,A)。

该函数用于求输入迭代对象的笛卡尔积，相当于一个嵌套的for循环。注意：prodcut函数返回的是一个迭代器

import itertools
    
    list1 = ['a', 'b']
    list2 = ['c', 'd']
    for item in itertools.product(list1,list2):
        print(item)

输出：

![20190427143444601.png][]

e.g.2 输出(1,1),(1,2)...(1,5),(2,1),(2,2)....(5,5)这些笛卡尔坐标

import itertools
    list1 = [1,2,3,4,5]
    
    for item in itertools.product(list1,repeat=2):
        print(item)

输出：

![20190427143946548.png][]

# 二、相关参数 #

cfg = {
        'num_classes': 21,
        'lr_steps': (80000, 100000, 120000),
        'max_iter': 120000,
        'feature_maps': [38, 19, 10, 5, 3, 1],
        'min_dim': 300,
        'steps': [8, 16, 32, 64, 100, 300],
        'min_sizes': [30, 60, 111, 162, 213, 264],
        'max_sizes': [60, 111, 162, 213, 264, 315],
        'aspect_ratios': [[2], [2, 3], [2, 3], [2, 3], [2], [2]],
        'variance': [0.1, 0.2],
        'clip': True,
        'name': 'VOC',
    }

1.num\_classes 当前数据集中的类别数目+背景（对于voc数据集来说20+1）

2.lr\_steps 学习率下降的地方（这份代码是仿照caffe-ssd改造的，caffe中学习率的调整是根据迭代次数进行调整的，pytorch中一般是根据epoch调整的）

3.max\_iter 最大迭代次数，达到max\_iter则停止训练

--------------------

以上三个参数与当前层无关，暂时不必关注

--------------------

4.feature\_maps 检测层特征图的尺寸

在vgg版的ssd中检测层分别是conv4\_3,fc7,conv6\_2,conv7\_2,conv8\_2,conv9\_2对应尺寸分别为38\*38,19\*19,10\*10,5\*5,3\*3,1\*1

5.min\_dim 输入图片的短边长，由于这里输入图片都resize成正方形了，直接理解为input的尺寸

6.steps 计算卷积层产生的prior\_box距离原图的步长（本参数需要好好理解）

step参数本质上是该层的特征图相对于网络输入层输入图像的下采样率，用于计算当前特征图上某一位置处所有默认框中心坐标在网络输入层输入图像坐标系下的坐标。举个例子，就是你在缩放一幅图像时，对于缩放后的图像，其上每一像素点的像素值是通过插值得到的，那如何有效插值就需要用到后向计算，即需要找出当前像素点坐标值对应于原始图像上的坐标值，由原始图像上这一坐标值来最邻近或双线性插值，重点就在于需要找出原始图像上的坐标值。而这里的step就是用来计算特征图上某一位置处所有默认框中心坐标在网络输入层输入图像坐标系下的坐标，对应的就是下采样率，拿conv4\_3而言，下采样率为38/300约为8（实际上就是8，因为经过三次最大池化操作，但由于caffe中的池化采用向上取整，导致约等于8），故step=8，其余层大家可以自行计算一下（不要过于纠结准确下采样率，大致就行，毕竟最后都是要通过网络自行学习的，没必要那么精确）。

注：![20190427150743663.png][] 其中为网络输入层输入图像大小。

7.min\_sizes 和max\_size

这两个参数都是当前特征层的默认框尺寸（论文中的scale参数）对应到inout坐标系下的尺寸。论文第k层默认框的尺寸为

![20190427151820116.png][]

当前层的min\_size就等于sk乘以min\_dim,max\_size等于s(k+1)乘以min\_dim。论文中每个层的默认框对应两种长宽比为1的框，这里的min\_sizie和max\_size的意思是第二种ratio为1的默认框对应回原图中尺寸应该在min\_szie和max\_size之间，这种默认框的计算公式为sqrt(s\_k \* s\_(k+1))。

ps：个人感觉这里的min\_size和max\_size其实和scale参数在信息表征上是重复的，之所以直接写出来可能是为了更直观的表明该层预测的框尺寸也应该在min\_size和max\_size之间。

8. aspect\_ratios  默认框的长宽比。六种尺度对应六个产生prior\_box的卷积层

e.g conv4\_3对应的aspect\_ratios为2，表明该层有（1,1,1/2,2/1）四种尺寸的默认框

fc\_7层对应的aspect\_ratios为\[2,3\]表明该层有（1，1，1/2，2/1，1/3，3/1）六种尺寸的默认框

9.variance   产生默认框的层并没有使用该参数，暂时不清楚如何使用

10. clip 产生的默认框是相对于原图的比例，在0-1之间。该参数表示将默认框比例限制在0-1之间，大于1的设为1，小于0的设为0。  ps：根据论文中计算出的默认框尺寸是符合0-1之间的，个人猜测这个函数是为了后期的升级欸和维护。

# 三、代码解读 #

from __future__ import division
    from math import sqrt as sqrt
    from itertools import product as product
    import torch
    
    
    """
    # SSD300 CONFIGS
    cfg = {
        'num_classes': 21,
        'lr_steps': (80000, 100000, 120000),
        'max_iter': 120000,
        'feature_maps': [38, 19, 10, 5, 3, 1],
        'min_dim': 300,
        'steps': [8, 16, 32, 64, 100, 300],
        'min_sizes': [30, 60, 111, 162, 213, 264],
        'max_sizes': [60, 111, 162, 213, 264, 315],
        'aspect_ratios': [[2], [2, 3], [2, 3], [2, 3], [2], [2]],
        'variance': [0.1, 0.2],
        'clip': True,
        'name': 'VOC',
    }
    """
    
    class PriorBox(object):
        """Compute priorbox coordinates in center-offset form for each source
        feature map.
        """
        def __init__(self, cfg):
            super(PriorBox, self).__init__()
            self.image_size = cfg['min_dim']
            # number of priors for feature map location (either 4 or 6)
            self.num_priors = len(cfg['aspect_ratios'])
            self.variance = cfg['variance'] or [0.1]
            self.feature_maps = cfg['feature_maps']
            self.min_sizes = cfg['min_sizes']
            self.max_sizes = cfg['max_sizes']
            self.steps = cfg['steps']
            self.aspect_ratios = cfg['aspect_ratios']
            self.clip = cfg['clip']
            self.version = cfg['name']
            for v in self.variance:
                if v <= 0:
                    raise ValueError('Variances must be greater than 0')
    
        def forward(self):
            mean = []
            for k, f in enumerate(self.feature_maps):  #遍历6个特征图，每个特征图分别生成默认框
                for i, j in product(range(f), repeat=2):  #针对每个特征图遍历所有坐标
    
                    """
                     将特征图的坐标对应回原图坐标，然后缩放成0-1的相对距离
                    原始公式应该为cx = (j+0.5) * step /min_dim，这里拆分成两步计算
                    """
     
                    f_k = self.image_size / self.steps[k] 
                    # unit center x,y
                    cx = (j + 0.5) / f_k
                    cy = (i + 0.5) / f_k
    
                    # aspect_ratio: 1
                    # rel size: min_size
                    """第一种ratio为1的框"""
                    s_k = self.min_sizes[k]/self.image_size
                    mean += [cx, cy, s_k, s_k]
    
                    # aspect_ratio: 1
                    # rel size: sqrt(s_k * s_(k+1))
                    """
                    产生第二种ratio为1的默认框
                    """
                    s_k_prime = sqrt(s_k * (self.max_sizes[k]/self.image_size))
                    mean += [cx, cy, s_k_prime, s_k_prime]
    
                    # rest of aspect ratios
                    """针对每层设置的ratio参数，产生其他2个或者4个ratio为[1/2,2/1,1/3,/3/1]的默认框
                    """
                    for ar in self.aspect_ratios[k]:
                        mean += [cx, cy, s_k*sqrt(ar), s_k/sqrt(ar)]
                        mean += [cx, cy, s_k/sqrt(ar), s_k*sqrt(ar)]
            # back to torch land
            """将产生的默认框转化为n行4列的标准形式，每行代表一个默认框[x,y,w,h]"""
            output = torch.Tensor(mean).view(-1, 4)  
            if self.clip:
                output.clamp_(max=1, min=0)
            return output

[Link 1]: https://github.com/amdegroot/ssd.pytorch/blob/master/layers/functions/prior_box.py
[201904262236268.png]: /images/20220213/15b03b81433a430ba52aced6ab46d89b.png
[20190427143444601.png]: /images/20220213/12d83ff4ab4c484aaa3c1722b9ff38bf.png
[20190427143946548.png]: /images/20220213/a88773f4091c43728ed9039b5ea17b43.png
[20190427150743663.png]: /images/20220213/293c43bc14a445188f3789ea5110cd06.png
[20190427151820116.png]: /images/20220213/b513af174df64985b5b1f1666d195e2b.png