【深度学习SSD】——深刻解读SSD tensorflow及源码详解

 

 

本文主要针对SSD的tensorflow框架下的实现的源码解读即对网络模型的理解。

【前言】

首先在github上下载tensorflow版的SSD repository：https://github.com/balancap/SSD-Tensorflow

同时附上论文地址：SSD 论文下载

解压SSD-Tensorflow-master.zip 到自己工作目录下。

 

 

 

SSD直接采用卷积对不同的特征图来进行提取检测结果。对于形状为 的特征图，只需要采用 这样比较小的卷积核得到检测值；

SSD的检测值也与Yolo不太一样。对于每个单元的每个先验框，其都输出一套独立的检测值，对应一个边界框，主要分为两个部分。第一部分是各个类别的置信度或者评分，值得注意的是SSD将背景也当做了一个特殊的类别，如果检测目标共有 个类别，SSD其实需要预测 个置信度值，其中第一个置信度指的是不含目标或者属于背景的评分。后面当我们说 个类别置信度时，请记住里面包含背景那个特殊的类别，即真实的检测类别只有 个。在预测过程中，置信度最高的那个类别就是边界框所属的类别，特别地，当第一个置信度值最高时，表示边界框中并不包含目标。第二部分就是边界框的location，包含4个值 ，分别表示边界框的中心坐标以及宽高。但是真实预测值其实只是边界框相对于先验框的转换值(paper里面说是offset，但是觉得transformation更合适，参见R-CNN)。先验框位置用 表示，其对应边界框用 $表示，那么边界框的预测值 其实是 相对于 的转换值：

习惯上，我们称上面这个过程为边界框的编码（encode），预测时，你需要反向这个过程，即进行解码（decode），从预测值 中得到边界框的真实位置 ：

然而，在SSD的Caffe源码实现中还有trick，那就是设置variance超参数来调整检测值，通过bool参数variance_encoded_in_target来控制两种模式，当其为True时，表示variance被包含在预测值中，就是上面那种情况。但是如果是False（大部分采用这种方式，训练更容易？），就需要手动设置超参数variance，用来对 的4个值进行放缩，此时边界框需要这样解码：

综上所述，对于一个大小 的特征图，共有 个单元，每个单元设置的先验框数目记为 ，那么每个单元共需要 个预测值，所有的单元共需要 个预测值，由于SSD采用卷积做检测，所以就需要 个卷积核完成这个特征图的检测过程。

 

VGG16中的Conv4_3层将作为用于检测的第一个特征图。conv4_3层特征图大小是 ，但是该层比较靠前，其norm较大，所以在其后面增加了一个L2 Normalization层（参见ParseNet），以保证和后面的检测层差异不是很大，这个和Batch Normalization层不太一样，其仅仅是对每个像素点在channle维度做归一化，而Batch Normalization层是在[batch_size, width, height]三个维度上做归一化。归一化后一般设置一个可训练的放缩变量gamma。

 

 

默认情况下，每个特征图会有一个 且尺度为 的先验框，除此之外，还会设置一个尺度为 且 的先验框，这样每个特征图都设置了两个长宽比为1但大小不同的正方形先验框。注意最后一个特征图需要参考一个虚拟 来计算 。因此，每个特征图一共有 个先验框 ，但是在实现时，Conv4_3，Conv10_2和Conv11_2层仅使用4个先验框，它们不使用长宽比为 的先验框。每个单元的先验框的中心点分布在各个单元的中心，即 ，其中 为特征图的大小。

训练过程

（1）先验框匹配
在训练过程中，首先要确定训练图片中的ground truth（真实目标）与哪个先验框来进行匹配，与之匹配的先验框所对应的边界框将负责预测它。在Yolo中，ground truth的中心落在哪个单元格，该单元格中与其IOU最大的边界框负责预测它。但是在SSD中却完全不一样，SSD的先验框与ground truth的匹配原则主要有两点。首先，对于图片中每个ground truth，找到与其IOU最大的先验框，该先验框与其匹配，这样，可以保证每个ground truth一定与某个先验框匹配。通常称与ground truth匹配的先验框为正样本（其实应该是先验框对应的预测box，不过由于是一一对应的就这样称呼了），反之，若一个先验框没有与任何ground truth进行匹配，那么该先验框只能与背景匹配，就是负样本。一个图片中ground truth是非常少的， 而先验框却很多，如果仅按第一个原则匹配，很多先验框会是负样本，正负样本极其不平衡，所以需要第二个原则。第二个原则是：对于剩余的未匹配先验框，若某个ground truth的 大于某个阈值（一般是0.5），那么该先验框也与这个ground truth进行匹配。这意味着某个ground truth可能与多个先验框匹配，这是可以的。但是反过来却不可以，因为一个先验框只能匹配一个ground truth，如果多个ground truth与某个先验框 大于阈值，那么先验框只与IOU最大的那个先验框进行匹配。第二个原则一定在第一个原则之后进行，仔细考虑一下这种情况，如果某个ground truth所对应最大 小于阈值，并且所匹配的先验框却与另外一个ground truth的 大于阈值，那么该先验框应该匹配谁，答案应该是前者，首先要确保某个ground truth一定有一个先验框与之匹配。但是，这种情况我觉得基本上是不存在的。由于先验框很多，某个ground truth的最大 肯定大于阈值，所以可能只实施第二个原则既可以了，这里的TensorFlow版本就是只实施了第二个原则，但是这里的Pytorch两个原则都实施了。图8为一个匹配示意图，其中绿色的GT是ground truth，红色为先验框，FP表示负样本，TP表示正样本。

                              图8 先验框匹配示意图

尽管一个ground truth可以与多个先验框匹配，但是ground truth相对先验框还是太少了，所以负样本相对正样本会很多。为了保证正负样本尽量平衡，SSD采用了hard negative mining，就是对负样本进行抽样，抽样时按照置信度误差（预测背景的置信度越小，误差越大）进行降序排列，选取误差的较大的top-k作为训练的负样本，以保证正负样本比例接近1:3。

（2）损失函数
训练样本确定了，然后就是损失函数了。损失函数定义为位置误差（locatization loss， loc）与置信度误差（confidence loss, conf）的加权和：

其中 是先验框的正样本数量。这里 为一个指示参数，当 时表示第 个先验框与第 个ground truth匹配，并且ground truth的类别为 。 为类别置信度预测值。 为先验框的所对应边界框的位置预测值，而 是ground truth的位置参数。对于位置误差，其采用Smooth L1 loss，定义如下：

由于 的存在，所以位置误差仅针对正样本进行计算。值得注意的是，要先对ground truth的 进行编码得到 ，因为预测值 也是编码值，若设置variance_encoded_in_target=True，编码时要加上variance：

对于置信度误差，其采用softmax loss:

权重系数 通过交叉验证设置为1。

预测过程

预测过程比较简单，对于每个预测框，首先根据类别置信度确定其类别（置信度最大者）与置信度值，并过滤掉属于背景的预测框。然后根据置信度阈值（如0.5）过滤掉阈值较低的预测框。对于留下的预测框进行解码，根据先验框得到其真实的位置参数（解码后一般还需要做clip，防止预测框位置超出图片）。解码之后，一般需要根据置信度进行降序排列，然后仅保留top-k（如400）个预测框。最后就是进行NMS算法，过滤掉那些重叠度较大的预测框。最后剩余的预测框就是检测结果了。

一. 源码解读；

其中ssd_vgg_300.py代码解析如下：

[python] view plain copy

1. # Copyright 2016 Paul Balanca. All Rights Reserved.  
2. #  
3. # Licensed under the Apache License, Version 2.0 (the "License");  
4. # you may not use this file except in compliance with the License.  
5. # You may obtain a copy of the License at  
6. #  
7. #     http://www.apache.org/licenses/LICENSE-2.0  
8. #  
9. # Unless required by applicable law or agreed to in writing, software  
10. # distributed under the License is distributed on an "AS IS" BASIS,  
11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
12. # See the License for the specific language governing permissions and  
13. # limitations under the License.  
14. # ==============================================================================  
15. """Definition of 300 VGG-based SSD network. 
16.  
17. This model was initially introduced in: 
18. SSD: Single Shot MultiBox Detector 
19. Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, 
20. Cheng-Yang Fu, Alexander C. Berg 
21. https://arxiv.org/abs/1512.02325 
22.  
23. Two variants of the model are defined: the 300x300 and 512x512 models, the 
24. latter obtaining a slightly better accuracy on Pascal VOC. 
25.  
26. Usage: 
27.     with slim.arg_scope(ssd_vgg.ssd_vgg()): 
28.         outputs, end_points = ssd_vgg.ssd_vgg(inputs) 
29.  
30. This network port of the original Caffe model. The padding in TF and Caffe 
31. is slightly different, and can lead to severe accuracy drop if not taken care 
32. in a correct way! 
33.  
34. In Caffe, the output size of convolution and pooling layers are computing as 
35. following: h_o = (h_i + 2 * pad_h - kernel_h) / stride_h + 1 
36.  
37. Nevertheless, there is a subtle difference between both for stride > 1. In 
38. the case of convolution: 
39.     top_size = floor((bottom_size + 2*pad - kernel_size) / stride) + 1 
40. whereas for pooling: 
41.     top_size = ceil((bottom_size + 2*pad - kernel_size) / stride) + 1 
42. Hence implicitely allowing some additional padding even if pad = 0. This 
43. behaviour explains why pooling with stride and kernel of size 2 are behaving 
44. the same way in TensorFlow and Caffe. 
45.  
46. Nevertheless, this is not the case anymore for other kernel sizes, hence 
47. motivating the use of special padding layer for controlling these side-effects. 
48.  
49. @@ssd_vgg_300 
50. """  
51. import math  
52. from collections import namedtuple  
53.   
54. import numpy as np  
55. import tensorflow as tf  
56.   
57. import tf_extended as tfe  
58. from nets import custom_layers  
59. from nets import ssd_common  
60.   
61. slim = tf.contrib.slim  
62.   
63.   
64. # =========================================================================== #  
65. # SSD class definition.  
66. # =========================================================================== #  
67. #collections模块的namedtuple子类不仅可以使用item的index访问item，还可以通过item的name进行访问可以将namedtuple理解为c中的struct结构，其首先将各个item命名，然后对每个item赋予数据  
68. SSDParams = namedtuple('SSDParameters', ['img_shape',           #输入图像大小  
69.                                          'num_classes',         #分类类别数  
70.                                          'no_annotation_label', #无标注标签  
71.                                          'feat_layers',         #特征层  
72.                                          'feat_shapes',         #特征层形状大小  
73.                                          'anchor_size_bounds',  #锚点框大小上下边界，是与原图相比得到的小数值  
74.                                          'anchor_sizes',        #初始锚点框尺寸  
75.                                          'anchor_ratios',       #锚点框长宽比  
76.                                          'anchor_steps',        #特征图相对原始图像的缩放  
77.                                          'anchor_offset',       #锚点框中心的偏移  
78.                                          'normalizations',      #是否正则化  
79.                                          'prior_scaling'        #是对特征图参考框向gtbox做回归时用到的尺度缩放（0.1,0.1,0.2,0.2）  
80.                                          ])  
81.   
82.   
83. class SSDNet(object):  
84.     """Implementation of the SSD VGG-based 300 network. 
85.  
86.     The default features layers with 300x300 image input are: 
87.       conv4 ==> 38 x 38 
88.       conv7 ==> 19 x 19 
89.       conv8 ==> 10 x 10 
90.       conv9 ==> 5 x 5 
91.       conv10 ==> 3 x 3 
92.       conv11 ==> 1 x 1 
93.     The default image size used to train this network is 300x300.    #训练输入图像尺寸默认为300x300 
94.     """  
95.     default_params = SSDParams(             #默认参数  
96.         img_shape=(300, 300),  
97.         num_classes=21,  #包含背景在内，共21类目标类别  
98.         no_annotation_label=21,  
99.         feat_layers=['block4', 'block7', 'block8', 'block9', 'block10', 'block11'], #特征层名字  
100.         feat_shapes=[(38, 38), (19, 19), (10, 10), (5, 5), (3, 3), (1, 1)],       #特征层尺寸  
101.         anchor_size_bounds=[0.15, 0.90],                                             
102.         # anchor_size_bounds=[0.20, 0.90],                                        #论文中初始预测框大小为0.2x300~0.9x300；实际代码是[45,270]  
103.         anchor_sizes=[(21., 45.),   #直接给出的每个特征图上起初的锚点框大小；如第一个特征层框大小是h:21;w:45;  共6个特征图用于回归  
104.                       (45., 99.),   #越小的框能够得到原图上更多的局部信息，反之得到更多的全局信息；  
105.                       (99., 153.),  
106.                       (153., 207.),  
107.                       (207., 261.),  
108.                       (261., 315.)],  
109.         # anchor_sizes=[(30., 60.),  
110.         #               (60., 111.),  
111.         #               (111., 162.),  
112.         #               (162., 213.),  
113.         #               (213., 264.),  
114.         #               (264., 315.)],  
115.         anchor_ratios=[[2, .5],             #每个特征层上的每个特征点预测的box长宽比及数量；如：block4: def_boxes:4  
116.                        [2, .5, 3, 1./3],    #block7: def_boxes:6   （ratios中的4个+默认的1:1+额外增加的一个=6）  
117.                        [2, .5, 3, 1./3],    #block8: def_boxes:6  
118.                        [2, .5, 3, 1./3],    #block9: def_boxes:6  
119.                        [2, .5],             #block10: def_boxes:4  
120.                        [2, .5]],            #block11: def_boxes:4   #备注：实际上略去了默认的ratio=1以及多加了一个sqrt(初始框宽*初始框高)，后面代码有  
121.         anchor_steps=[8, 16, 32, 64, 100, 300],   #特征图锚点框放大到原始图的缩放比例；  
122.         anchor_offset=0.5,                        #每个锚点框中心点在该特征图cell中心，因此offset=0.5  
123.         normalizations=[20, -1, -1, -1, -1, -1],  #是否归一化，大于0则进行，否则不做归一化；目前看来只对block_4进行正则化，因为该层比较靠前，其norm较大，需做L2正则化（仅仅对每个像素在channel维度做归一化）以保证和后面检测层差异不是很大；  
124.         prior_scaling=[0.1, 0.1, 0.2, 0.2]        #特征图上每个目标与参考框间的尺寸缩放（y,x,h,w）解码时用到  
125.         )  
126.   
127.     def __init__(self, params=None):      #网络参数的初始化  
128.         """Init the SSD net with some parameters. Use the default ones 
129.         if none provided. 
130.         """  
131.         if isinstance(params, SSDParams):  #是否有参数输入，是则用输入的，否则使用默认的  
132.             self.params = params           #isinstance是python的內建函数，如果参数1与参数2的类型相同则返回true；  
133.         else:  
134.             self.params = SSDNet.default_params  
135.   
136.     # ======================================================================= #  
137.     def net(self, inputs,                            #定义网络模型  
138.             is_training=True,                        #是否训练  
139.             update_feat_shapes=True,                 #是否更新特征层的尺寸  
140.             dropout_keep_prob=0.5,                   #dropout=0.5  
141.             prediction_fn=slim.softmax,              #采用softmax预测结果  
142.             reuse=None,  
143.             scope='ssd_300_vgg'):                    #网络名：ssd_300_vgg   （基础网络时VGG，输入训练图像size是300x300）  
144.         """SSD network definition. 
145.         """  
146.         r = ssd_net(inputs,                               #网络输入参数r  
147.                     num_classes=self.params.num_classes,   
148.                     feat_layers=self.params.feat_layers,  
149.                     anchor_sizes=self.params.anchor_sizes,  
150.                     anchor_ratios=self.params.anchor_ratios,  
151.                     normalizations=self.params.normalizations,  
152.                     is_training=is_training,  
153.                     dropout_keep_prob=dropout_keep_prob,  
154.                     prediction_fn=prediction_fn,  
155.                     reuse=reuse,  
156.                     scope=scope)  
157.         # Update feature shapes (try at least!)    #下面这步我的理解就是让读者自行更改特征层的输入，未必论文中介绍的那几个block  
158.         if update_feat_shapes:                                               #是否更新特征层图像尺寸？  
159.             shapes = ssd_feat_shapes_from_net(r[0], self.params.feat_shapes)  #输入特征层图像尺寸以及inputs（应该是预测的特征尺寸），输出更新后的特征图尺寸列表  
160.             self.params = self.params._replace(feat_shapes=shapes)        #将更新的特征图尺寸shapes替换当前的特征图尺寸  
161.         return r                                                      #更新网络输入参数r    
162.   
163.     def arg_scope(self, weight_decay=0.0005, data_format='NHWC'):  #定义权重衰减=0.0005，L2正则化项系数；数据类型是NHWC  
164.         """Network arg_scope. 
165.         """  
166.         return ssd_arg_scope(weight_decay, data_format=data_format)  
167.   
168.     def arg_scope_caffe(self, caffe_scope):  
169.         """Caffe arg_scope used for weights importing. 
170.         """  
171.         return ssd_arg_scope_caffe(caffe_scope)        
172.   
173.     # ======================================================================= #  
174.     def update_feature_shapes(self, predictions):    #更新特征形状尺寸（来自预测结果）  
175.         """Update feature shapes from predictions collection (Tensor or Numpy 
176.         array). 
177.         """  
178.         shapes = ssd_feat_shapes_from_net(predictions, self.params.feat_shapes)  
179.         self.params = self.params._replace(feat_shapes=shapes)  
180.   
181.     def anchors(self, img_shape, dtype=np.float32):             #输入原始图像尺寸；返回每个特征层每个参考锚点框的位置及尺寸信息（x,y,h,w）          
182.         """Compute the default anchor boxes, given an image shape. 
183.         """  
184.         return ssd_anchors_all_layers(img_shape,                #这是个关键函数；检测所有特征层中的参考锚点框位置和尺寸信息  
185.                                       self.params.feat_shapes,  
186.                                       self.params.anchor_sizes,   
187.                                       self.params.anchor_ratios,  
188.                                       self.params.anchor_steps,  
189.                                       self.params.anchor_offset,  
190.                                       dtype)  
191.   
192.     def bboxes_encode(self, labels, bboxes, anchors,  #编码，用于将标签信息，真实目标信息和锚点框信息编码在一起；得到预测真实框到参考框的转换值  
193.                       scope=None):  
194.         """Encode labels and bounding boxes.    
195.         """  
196.         return ssd_common.tf_ssd_bboxes_encode(  
197.             labels, bboxes, anchors,  
198.             self.params.num_classes,  
199.             self.params.no_annotation_label,      #未标注的标签（应该代表背景）  
200.             ignore_threshold=0.5,                 #IOU筛选阈值  
201.             prior_scaling=self.params.prior_scaling,  #特征图目标与参考框间的尺寸缩放（0.1,0.1,0.2,0.2）  
202.             scope=scope)  
203.   
204.     def bboxes_decode(self, feat_localizations, anchors,  #解码，用锚点框信息，锚点框与预测真实框间的转换值，得到真是的预测框（ymin,xmin,ymax,xmax）  
205.                       scope='ssd_bboxes_decode'):  
206.         """Encode labels and bounding boxes. 
207.         """  
208.         return ssd_common.tf_ssd_bboxes_decode(  
209.             feat_localizations, anchors,  
210.             prior_scaling=self.params.prior_scaling,  
211.             scope=scope)  
212.   
213.     def detected_bboxes(self, predictions, localisations,   #通过SSD网络，得到检测到的bbox  
214.                         select_threshold=None, nms_threshold=0.5,  
215.                         clipping_bbox=None, top_k=400, keep_top_k=200):  
216.         """Get the detected bounding boxes from the SSD network output.     
217.         """  
218.         # Select top_k bboxes from predictions, and clip    #选取top_k=400个框，并对框做修建（超出原图尺寸范围的切掉）  
219.         rscores, rbboxes = \                                                       #得到对应某个类别的得分值以及bbox  
220.             ssd_common.tf_ssd_bboxes_select(predictions, localisations,  
221.                                             select_threshold=select_threshold,  
222.                                             num_classes=self.params.num_classes)  
223.         rscores, rbboxes = \                                     #按照得分高低，筛选出400个bbox和对应得分  
224.             tfe.bboxes_sort(rscores, rbboxes, top_k=top_k)  
225.         # Apply NMS algorithm.                                   #应用非极大值抑制，筛选掉与得分最高bbox重叠率大于0.5的，保留200个  
226.         rscores, rbboxes = \  
227.             tfe.bboxes_nms_batch(rscores, rbboxes,  
228.                                  nms_threshold=nms_threshold,  
229.                                  keep_top_k=keep_top_k)  
230.         if clipping_bbox is not None:  
231.             rbboxes = tfe.bboxes_clip(clipping_bbox, rbboxes)  
232.         return rscores, rbboxes                              #返回裁剪好的bbox和对应得分  
233. #尽管一个ground truth可以与多个先验框匹配，但是ground truth相对先验框还是太少了，  
234. #所以负样本相对正样本会很多。为了保证正负样本尽量平衡，SSD采用了hard negative mining，  
235. #就是对负样本进行抽样，抽样时按照置信度误差（预测背景的置信度越小，误差越大）进行降序排列，  
236. #选取误差的较大的top-k作为训练的负样本，以保证正负样本比例接近1:3  
237.     def losses(self, logits, localisations,  
238.                gclasses, glocalisations, gscores,  
239.                match_threshold=0.5,  
240.                negative_ratio=3.,  
241.                alpha=1.,  
242.                label_smoothing=0.,  
243.                scope='ssd_losses'):  
244.         """Define the SSD network losses. 
245.         """  
246.         return ssd_losses(logits, localisations,  
247.                           gclasses, glocalisations, gscores,  
248.                           match_threshold=match_threshold,  
249.                           negative_ratio=negative_ratio,  
250.                           alpha=alpha,  
251.                           label_smoothing=label_smoothing,  
252.                           scope=scope)  
253.   
254.   
255. # =========================================================================== #  
256. # SSD tools...  
257. # =========================================================================== #  
258. def ssd_size_bounds_to_values(size_bounds,  
259.                               n_feat_layers,  
260.                               img_shape=(300, 300)):  
261.     """Compute the reference sizes of the anchor boxes from relative bounds. 
262.     The absolute values are measured in pixels, based on the network 
263.     default size (300 pixels). 
264.  
265.     This function follows the computation performed in the original 
266.     implementation of SSD in Caffe. 
267.  
268.     Return: 
269.       list of list containing the absolute sizes at each scale. For each scale, 
270.       the ratios only apply to the first value. 
271.     """  
272.     assert img_shape[0] == img_shape[1]  
273.   
274.     img_size = img_shape[0]  
275.     min_ratio = int(size_bounds[0] * 100)  
276.     max_ratio = int(size_bounds[1] * 100)  
277.     step = int(math.floor((max_ratio - min_ratio) / (n_feat_layers - 2)))  
278.     # Start with the following smallest sizes.  
279.     sizes = [[img_size * size_bounds[0] / 2, img_size * size_bounds[0]]]  
280.     for ratio in range(min_ratio, max_ratio + 1, step):  
281.         sizes.append((img_size * ratio / 100.,  
282.                       img_size * (ratio + step) / 100.))  
283.     return sizes  
284.   
285.   
286. def ssd_feat_shapes_from_net(predictions, default_shapes=None):  
287.     """Try to obtain the feature shapes from the prediction layers. The latter 
288.     can be either a Tensor or Numpy ndarray. 
289.  
290.     Return: 
291.       list of feature shapes. Default values if predictions shape not fully 
292.       determined. 
293.     """  
294.     feat_shapes = []  
295.     for l in predictions:              #l:是预测的特征形状  
296.         # Get the shape, from either a np array or a tensor.  
297.         if isinstance(l, np.ndarray):  #如果l是np.ndarray类型，则将l的形状赋给shape；否则将shape作为list  
298.             shape = l.shape  
299.         else:  
300.             shape = l.get_shape().as_list()  
301.         shape = shape[1:4]  
302.         # Problem: undetermined shape...     #如果预测的特征尺寸未定，则使用默认的形状；否则将shape中的值赋给特征形状列表中  
303.         if None in shape:    
304.             return default_shapes  
305.         else:  
306.             feat_shapes.append(shape)  
307.     return feat_shapes                        #返回更新后的特征尺寸list  
308.   
309.   
310. def ssd_anchor_one_layer(img_shape,         #检测单个特征图中所有锚点的坐标和尺寸信息（未与原图做除法）  
311.                          feat_shape,  
312.                          sizes,  
313.                          ratios,  
314.                          step,  
315.                          offset=0.5,  
316.                          dtype=np.float32):  
317.     """Computer SSD default anchor boxes for one feature layer. 
318.  
319.     Determine the relative position grid of the centers, and the relative 
320.     width and height. 
321.  
322.     Arguments: 
323.       feat_shape: Feature shape, used for computing relative position grids; 
324.       size: Absolute reference sizes; 
325.       ratios: Ratios to use on these features; 
326.       img_shape: Image shape, used for computing height, width relatively to the 
327.         former; 
328.       offset: Grid offset. 
329.  
330.     Return: 
331.       y, x, h, w: Relative x and y grids, and height and width. 
332.     """  
333.     # Compute the position grid: simple way.  
334.     # y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]]  
335.     # y = (y.astype(dtype) + offset) / feat_shape[0]  
336.     # x = (x.astype(dtype) + offset) / feat_shape[1]  
337.     # Weird SSD-Caffe computation using steps values...    #归一化到原图的锚点中心坐标（x,y）;其坐标值域为(0,1)  
338.     y, x = np.mgrid[0:feat_shape[0], 0:feat_shape[1]]      #对于第一个特征图（block4：38x38）；y=[[0,0,……0],[1,1,……1]，……[37,37,……，37]]；而x=[[0,1,2……，37]，[0,1,2……，37],……[0,1,2……，37]]  
339.     y = (y.astype(dtype) + offset) * step / img_shape[0]   #将38个cell对应锚点框的y坐标偏移至每个cell中心，然后乘以相对原图缩放的比例，再除以原图  
340.     x = (x.astype(dtype) + offset) * step / img_shape[1]   #可以得到在原图上，相对原图比例大小的每个锚点中心坐标x,y  
341.   
342.     # Expand dims to support easy broadcasting.    #将锚点中心坐标扩大维度  
343.     y = np.expand_dims(y, axis=-1)   #对于第一个特征图，y的shape=38x38x1；x的shape=38x38x1  
344.     x = np.expand_dims(x, axis=-1)  
345.   
346.     # Compute relative height and width.  
347.     # Tries to follow the original implementation of SSD for the order.  
348.     num_anchors = len(sizes) + len(ratios)      #该特征图上每个点对应的锚点框数量;如：对于第一个特征图每个点预测4个锚点框（block4：38x38），2+2=4  
349.     h = np.zeros((num_anchors, ), dtype=dtype)     #对于第一个特征图，h的shape=4x；w的shape=4x  
350.     w = np.zeros((num_anchors, ), dtype=dtype)  
351.     # Add first anchor boxes with ratio=1.  
352.     h[0] = sizes[0] / img_shape[0]            #第一个锚点框的高h[0]=起始锚点的高/原图大小的高；例如：h[0]=21/300  
353.     w[0] = sizes[0] / img_shape[1]            #第一个锚点框的宽w[0]=起始锚点的宽/原图大小的宽；例如：h[0]=45/300  
354.     di = 1  #锚点宽个数偏移  
355.     if len(sizes) > 1:                       
356.         h[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[0]    #第二个锚点框的高h[1]=sqrt（起始锚点的高*起始锚点的宽）/原图大小的高；例如：h[1]=sqrt(21*45)/300  
357.         w[1] = math.sqrt(sizes[0] * sizes[1]) / img_shape[1]    #第二个锚点框的高w[1]=sqrt（起始锚点的高*起始锚点的宽）/原图大小的宽；例如：w[1]=sqrt(21*45)/300  
358.         di += 1     #di=2  
359.     for i, r in enumerate(ratios):                            #遍历长宽比例，第一个特征图，r只有两个，2和0.5；共四个锚点宽size（h[0]~h[3]）  
360.         h[i+di] = sizes[0] / img_shape[0] / math.sqrt(r)      #例如：对于第一个特征图，h[0+2]=h[2]=21/300/sqrt(2);w[0+2]=w[2]=45/300*sqrt(2)  
361.         w[i+di] = sizes[0] / img_shape[1] * math.sqrt(r)      #例如：对于第一个特征图，h[1+2]=h[3]=21/300/sqrt(0.5);w[1+2]=w[3]=45/300*sqrt(0.5)  
362.     return y, x, h, w                                         #返回没有归一化前的锚点坐标和尺寸  
363.   
364.   
365. def ssd_anchors_all_layers(img_shape,                 #检测所有特征图中锚点框的四个坐标信息； 输入原始图大小  
366.                            layers_shape,              #每个特征层形状尺寸  
367.                            anchor_sizes,              #起始特征图中框的长宽size  
368.                            anchor_ratios,             #锚点框长宽比列表  
369.                            anchor_steps,              #锚点框相对原图缩放比例  
370.                            offset=0.5,                #锚点中心在每个特征图cell中的偏移  
371.                            dtype=np.float32):              
372.     """Compute anchor boxes for all feature layers. 
373.     """  
374.     layers_anchors = []           #用于存放所有特征图中锚点框位置尺寸信息  
375.     for i, s in enumerate(layers_shape):                 #6个特征图尺寸；如：第0个是38x38  
376.         anchor_bboxes = ssd_anchor_one_layer(img_shape, s,     #分别计算每个特征图中锚点框的位置尺寸信息；  
377.                                              anchor_sizes[i],    #输入：第i个特征图中起始锚点框大小；如第0个是(21., 45.)  
378.                                              anchor_ratios[i],   #输入：第i个特征图中锚点框长宽比列表；如第0个是[2, .5]  
379.                                              anchor_steps[i],    #输入：第i个特征图中锚点框相对原始图的缩放比；如第0个是8  
380.                                              offset=offset, dtype=dtype)  #输入：锚点中心在每个特征图cell中的偏移  
381.         layers_anchors.append(anchor_bboxes)              #将6个特征图中每个特征图上的点对应的锚点框（6个或4个）保存  
382.     return layers_anchors  
383.   
384.   
385. # =========================================================================== #  
386. # Functional definition of VGG-based SSD 300.  
387. # =========================================================================== #  
388. def tensor_shape(x, rank=3):  
389.     """Returns the dimensions of a tensor. 
390.     Args: 
391.       image: A N-D Tensor of shape. 
392.     Returns: 
393.       A list of dimensions. Dimensions that are statically known are python 
394.         integers,otherwise they are integer scalar tensors. 
395.     """  
396.     if x.get_shape().is_fully_defined():  
397.         return x.get_shape().as_list()  
398.     else:  
399.         static_shape = x.get_shape().with_rank(rank).as_list()  
400.         dynamic_shape = tf.unstack(tf.shape(x), rank)  
401.         return [s if s is not None else d  
402.                 for s, d in zip(static_shape, dynamic_shape)]  
403.   
404.   
405. def ssd_multibox_layer(inputs,                    #输入特征层  
406.                        num_classes,               #类别数  
407.                        sizes,                     #参考先验框的尺度  
408.                        ratios=[1],                #默认的先验框长宽比为1  
409.                        normalization=-1,          #默认不做正则化  
410.                        bn_normalization=False):  
411.     """Construct a multibox layer, return a class and localization predictions. 
412.     """  
413.     net = inputs  
414.     if normalization > 0:    #如果输入整数，则进行L2正则化  
415.         net = custom_layers.l2_normalization(net, scaling=True)    #对通道所在维度进行正则化，随后乘以gamma缩放系数  
416.     # Number of anchors.  
417.     num_anchors = len(sizes) + len(ratios)  #每层特征图参考先验框的个数[4,6,6,6,4,4]  
418.   
419.     # Location.     #每个先验框对应4个坐标信息  
420.     num_loc_pred = num_anchors * 4    #特征图上每个单元预测的坐标所需维度=锚点框数*4  
421.     loc_pred = slim.conv2d(net, num_loc_pred, [3, 3], activation_fn=None,   #通过对特征图进行3x3卷积得到位置信息和类别权重信息  
422.                            scope='conv_loc')                                #该部分是定位信息，输出维度为[特征图h,特征图w,每个单元所有锚点框坐标]  
423.     loc_pred = custom_layers.channel_to_last(loc_pred)  
424.     loc_pred = tf.reshape(loc_pred,                                         #最后整个特征图所有锚点框预测目标位置 tensor为[h*w*每个cell先验框数，4]  
425.                           tensor_shape(loc_pred, 4)[:-1]+[num_anchors, 4])  
426.     # Class prediction.                                                #类别预测  
427.     num_cls_pred = num_anchors * num_classes                            #特征图上每个单元预测的类别所需维度=锚点框数*种类数  
428.     cls_pred = slim.conv2d(net, num_cls_pred, [3, 3], activation_fn=None, #该部分是类别信息，输出维度为[特征图h,特征图w,每个单元所有锚点框对应类别信息]  
429.                            scope='conv_cls')  
430.     cls_pred = custom_layers.channel_to_last(cls_pred)  
431.     cls_pred = tf.reshape(cls_pred,  
432.                           tensor_shape(cls_pred, 4)[:-1]+[num_anchors, num_classes]) #最后整个特征图所有锚点框预测类别 tensor为[h*w*每个cell先验框数，种类数]  
433.     return cls_pred, loc_pred  #返回预测得到的类别和box位置 tensor  
434.   
435.   
436. def ssd_net(inputs,                                             #定义ssd网络结构  
437.             num_classes=SSDNet.default_params.num_classes,      #分类数  
438.             feat_layers=SSDNet.default_params.feat_layers,      #特征层  
439.             anchor_sizes=SSDNet.default_params.anchor_sizes,  
440.             anchor_ratios=SSDNet.default_params.anchor_ratios,  
441.             normalizations=SSDNet.default_params.normalizations, #正则化  
442.             is_training=True,  
443.             dropout_keep_prob=0.5,  
444.             prediction_fn=slim.softmax,  
445.             reuse=None,  
446.             scope='ssd_300_vgg'):  
447.     """SSD net definition. 
448.     """  
449.     # if data_format == 'NCHW':  
450.     #     inputs = tf.transpose(inputs, perm=(0, 3, 1, 2))  
451.   
452.     # End_points collect relevant activations for external use.  
453.     end_points = {}   #用于收集每一层输出结果  
454.     with tf.variable_scope(scope, 'ssd_300_vgg', [inputs], reuse=reuse):  
455.         # Original VGG-16 blocks.  
456.         net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')    #VGG16网络的第一个conv，重复2次卷积，核为3x3,64个特征  
457.         end_points['block1'] = net                                              #conv1_2结果存入end_points，name='block1'  
458.         net = slim.max_pool2d(net, [2, 2], scope='pool1')  
459.         # Block 2.  
460.         net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')      #重复2次卷积，核为3x3,128个特征  
461.         end_points['block2'] = net                                              #conv2_2结果存入end_points，name='block2'  
462.         net = slim.max_pool2d(net, [2, 2], scope='pool2')  
463.         # Block 3.  
464.         net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')      #重复3次卷积，核为3x3,256个特征  
465.         end_points['block3'] = net                                              #conv3_3结果存入end_points，name='block3'  
466.         net = slim.max_pool2d(net, [2, 2], scope='pool3')  
467.         # Block 4.  
468.         net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')       #重复3次卷积，核为3x3,512个特征  
469.         end_points['block4'] = net                                               #conv4_3结果存入end_points，name='block4'  
470.         net = slim.max_pool2d(net, [2, 2], scope='pool4')  
471.         # Block 5.  
472.         net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')       #重复3次卷积，核为3x3,512个特征  
473.         end_points['block5'] = net                                               #conv5_3结果存入end_points，name='block5'  
474.         net = slim.max_pool2d(net, [3, 3], stride=1, scope='pool5')  
475.   
476.         # Additional SSD blocks.                                                  #去掉了VGG的全连接层  
477.         # Block 6: let's dilate the hell out of it!  
478.         net = slim.conv2d(net, 1024, [3, 3], rate=6, scope='conv6')              #将VGG基础网络最后的池化层结果做扩展卷积（带孔卷积）；  
479.         end_points['block6'] = net                                                #conv6结果存入end_points，name='block6'  
480.         net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training) #dropout层  
481.         # Block 7: 1x1 conv. Because the fuck.  
482.         net = slim.conv2d(net, 1024, [1, 1], scope='conv7')                          #将dropout后的网络做1x1卷积，输出1024特征，name='block7'  
483.         end_points['block7'] = net  
484.         net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training)   #将卷积后的网络继续做dropout  
485.   
486.         # Block 8/9/10/11: 1x1 and 3x3 convolutions stride 2 (except lasts).  
487.         end_point = 'block8'                                                           
488.         with tf.variable_scope(end_point):  
489.             net = slim.conv2d(net, 256, [1, 1], scope='conv1x1')           #对上述dropout的网络做1x1卷积，然后做3x3卷积，,输出512特征图，name=‘block8’  
490.             net = custom_layers.pad2d(net, pad=(1, 1))  
491.             net = slim.conv2d(net, 512, [3, 3], stride=2, scope='conv3x3', padding='VALID')  
492.         end_points[end_point] = net  
493.         end_point = 'block9'  
494.         with tf.variable_scope(end_point):  
495.             net = slim.conv2d(net, 128, [1, 1], scope='conv1x1')                 #对上述网络做1x1卷积，然后做3x3卷积，输出256特征图，name=‘block9’  
496.             net = custom_layers.pad2d(net, pad=(1, 1))  
497.             net = slim.conv2d(net, 256, [3, 3], stride=2, scope='conv3x3', padding='VALID')  
498.         end_points[end_point] = net  
499.         end_point = 'block10'  
500.         with tf.variable_scope(end_point):  
501.             net = slim.conv2d(net, 128, [1, 1], scope='conv1x1')               #对上述网络做1x1卷积，然后做3x3卷积，输出256特征图，name=‘block10’  
502.             net = slim.conv2d(net, 256, [3, 3], scope='conv3x3', padding='VALID')  
503.         end_points[end_point] = net  
504.         end_point = 'block11'  
505.         with tf.variable_scope(end_point):  
506.             net = slim.conv2d(net, 128, [1, 1], scope='conv1x1')              #对上述网络做1x1卷积，然后做3x3卷积，输出256特征图，name=‘block11’  
507.             net = slim.conv2d(net, 256, [3, 3], scope='conv3x3', padding='VALID')  
508.         end_points[end_point] = net  
509.   
510.         # Prediction and localisations layers. #预测和定位  
511.         predictions = []  
512.         logits = []  
513.         localisations = []  
514.         for i, layer in enumerate(feat_layers):               #遍历特征层  
515.             with tf.variable_scope(layer + '_box'):                #起个命名范围     
516.                 p, l = ssd_multibox_layer(end_points[layer],   #做多尺度大小box预测的特征层，返回每个cell中每个先验框预测的类别p和预测的位置l  
517.                                           num_classes,         #种类数  
518.                                           anchor_sizes[i],     #先验框尺度（同一特征图上的先验框尺度和长宽比一致）  
519.                                           anchor_ratios[i],    #先验框长宽比  
520.                                           normalizations[i])   #每个特征正则化信息，目前是只对第一个特征图做归一化操作；  
521.              #把每一层的预测收集  
522.             predictions.append(prediction_fn(p))  #prediction_fn为softmax，预测类别  
523.             logits.append(p) #把每个cell每个先验框预测的类别的概率值存在logits中  
524.             localisations.append(l)   #预测位置信息  
525.   
526.         return predictions, localisations, logits, end_points  #返回类别预测结果，位置预测结果，所属某个类别的概率值，以及特征层  
527. ssd_net.default_image_size = 300  
528.   
529.   
530. def ssd_arg_scope(weight_decay=0.0005, data_format='NHWC'):  #权重衰减系数=0.0005；其是L2正则化项的系数  
531.     """Defines the VGG arg scope. 
532.  
533.     Args: 
534.       weight_decay: The l2 regularization coefficient. 
535.  
536.     Returns: 
537.       An arg_scope. 
538.     """  
539.     with slim.arg_scope([slim.conv2d, slim.fully_connected],  
540.                         activation_fn=tf.nn.relu,  
541.                         weights_regularizer=slim.l2_regularizer(weight_decay),  
542.                         weights_initializer=tf.contrib.layers.xavier_initializer(),  
543.                         biases_initializer=tf.zeros_initializer()):  
544.         with slim.arg_scope([slim.conv2d, slim.max_pool2d],  
545.                             padding='SAME',  
546.                             data_format=data_format):  
547.             with slim.arg_scope([custom_layers.pad2d,  
548.                                  custom_layers.l2_normalization,  
549.                                  custom_layers.channel_to_last],  
550.                                 data_format=data_format) as sc:  
551.                 return sc  
552.   
553.   
554. # =========================================================================== #  
555. # Caffe scope: importing weights at initialization.  
556. # =========================================================================== #  
557. def ssd_arg_scope_caffe(caffe_scope):  
558.     """Caffe scope definition. 
559.  
560.     Args: 
561.       caffe_scope: Caffe scope object with loaded weights. 
562.  
563.     Returns: 
564.       An arg_scope. 
565.     """  
566.     # Default network arg scope.  
567.     with slim.arg_scope([slim.conv2d],  
568.                         activation_fn=tf.nn.relu,  
569.                         weights_initializer=caffe_scope.conv_weights_init(),  
570.                         biases_initializer=caffe_scope.conv_biases_init()):  
571.         with slim.arg_scope([slim.fully_connected],  
572.                             activation_fn=tf.nn.relu):  
573.             with slim.arg_scope([custom_layers.l2_normalization],  
574.                                 scale_initializer=caffe_scope.l2_norm_scale_init()):  
575.                 with slim.arg_scope([slim.conv2d, slim.max_pool2d],  
576.                                     padding='SAME') as sc:  
577.                     return sc  
578.   
579.   
580. # =========================================================================== #  
581. # SSD loss function.  
582. # =========================================================================== #  
583. def ssd_losses(logits, localisations,    #损失函数定义为位置误差和置信度误差的加权和；  
584.                gclasses, glocalisations, gscores,  
585.                match_threshold=0.5,  
586.                negative_ratio=3.,    
587.                alpha=1.,             #位置误差权重系数  
588.                label_smoothing=0.,  
589.                device='/cpu:0',  
590.                scope=None):  
591.     with tf.name_scope(scope, 'ssd_losses'):  
592.         lshape = tfe.get_shape(logits[0], 5)  
593.         num_classes = lshape[-1]  
594.         batch_size = lshape[0]  
595.   
596.         # Flatten out all vectors!  
597.         flogits = []  
598.         fgclasses = []  
599.         fgscores = []  
600.         flocalisations = []  
601.         fglocalisations = []  
602.         for i in range(len(logits)):  
603.             flogits.append(tf.reshape(logits[i], [-1, num_classes]))    #将类别的概率值reshape成（-1,21）  
604.             fgclasses.append(tf.reshape(gclasses[i], [-1]))             #真实类别  
605.             fgscores.append(tf.reshape(gscores[i], [-1]))               #预测真实目标的得分  
606.             flocalisations.append(tf.reshape(localisations[i], [-1, 4]))  #预测真实目标边框坐标（编码形式的值）  
607.             fglocalisations.append(tf.reshape(glocalisations[i], [-1, 4])) #用于将真实目标gt的坐标进行编码存储  
608.         # And concat the crap!  
609.         logits = tf.concat(flogits, axis=0)  
610.         gclasses = tf.concat(fgclasses, axis=0)  
611.         gscores = tf.concat(fgscores, axis=0)  
612.         localisations = tf.concat(flocalisations, axis=0)  
613.         glocalisations = tf.concat(fglocalisations, axis=0)  
614.         dtype = logits.dtype  
615.   
616.         # Compute positive matching mask...  
617.         pmask = gscores > match_threshold  #预测框与真实框IOU>0.5则将这个先验作为正样本  
618.         fpmask = tf.cast(pmask, dtype)  
619.         n_positives = tf.reduce_sum(fpmask)  #求正样本数量N  
620.   
621.         # Hard negative mining... 为了保证正负样本尽量平衡，SSD采用了hard negative mining，就是对负样本进行抽样，抽样时按照置信度误差（预测背景的置信度越小，误差越大）进行降序排列，选取误差的较大的top-k作为训练的负样本，以保证正负样本比例接近1:3  
622.         no_classes = tf.cast(pmask, tf.int32)  
623.         predictions = slim.softmax(logits)   #类别预测  
624.         nmask = tf.logical_and(tf.logical_not(pmask),  
625.                                gscores > -0.5)  
626.         fnmask = tf.cast(nmask, dtype)       
627.         nvalues = tf.where(nmask,  
628.                            predictions[:, 0],  
629.                            1. - fnmask)  
630.         nvalues_flat = tf.reshape(nvalues, [-1])  
631.         # Number of negative entries to select.  
632.         max_neg_entries = tf.cast(tf.reduce_sum(fnmask), tf.int32)    
633.         n_neg = tf.cast(negative_ratio * n_positives, tf.int32) + batch_size #负样本数量，保证是正样本3倍  
634.         n_neg = tf.minimum(n_neg, max_neg_entries)  
635.   
636.         val, idxes = tf.nn.top_k(-nvalues_flat, k=n_neg) #抽样时按照置信度误差（预测背景的置信度越小，误差越大）进行降序排列，选取误差的较大的top-k作为训练的负样本  
637.         max_hard_pred = -val[-1]  
638.         # Final negative mask.  
639.         nmask = tf.logical_and(nmask, nvalues < max_hard_pred)  
640.         fnmask = tf.cast(nmask, dtype)  
641.   
642.         # Add cross-entropy loss.    #交叉熵  
643.         with tf.name_scope('cross_entropy_pos'):  
644.             loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,   #类别置信度误差  
645.                                                                   labels=gclasses)  
646.             loss = tf.div(tf.reduce_sum(loss * fpmask), batch_size, name='value')  #将置信度误差除以正样本数后除以batch-size  
647.             tf.losses.add_loss(loss)  
648.   
649.         with tf.name_scope('cross_entropy_neg'):  
650.             loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,  
651.                                                                   labels=no_classes)  
652.             loss = tf.div(tf.reduce_sum(loss * fnmask), batch_size, name='value')  
653.             tf.losses.add_loss(loss)  
654.   
655.         # Add localization loss: smooth L1, L2, ...  
656.         with tf.name_scope('localization'):  
657.             # Weights Tensor: positive mask + random negative.  
658.             weights = tf.expand_dims(alpha * fpmask, axis=-1)  
659.             loss = custom_layers.abs_smooth(localisations - glocalisations)   #先验框对应边界的位置预测值-真实位置；然后做Smooth L1 loss  
660.             loss = tf.div(tf.reduce_sum(loss * weights), batch_size, name='value')  #将上面的loss*权重（=alpha/正样本数）求和后除以batch-size  
661.             tf.losses.add_loss(loss)  #获得置信度误差和位置误差的加权和  
662.   
663.   
664. def ssd_losses_old(logits, localisations,  
665.                    gclasses, glocalisations, gscores,  
666.                    match_threshold=0.5,  
667.                    negative_ratio=3.,  
668.                    alpha=1.,  
669.                    label_smoothing=0.,  
670.                    device='/cpu:0',  
671.                    scope=None):  
672.     """Loss functions for training the SSD 300 VGG network. 
673.  
674.     This function defines the different loss components of the SSD, and 
675.     adds them to the TF loss collection. 
676.  
677.     Arguments: 
678.       logits: (list of) predictions logits Tensors; 
679.       localisations: (list of) localisations Tensors; 
680.       gclasses: (list of) groundtruth labels Tensors; 
681.       glocalisations: (list of) groundtruth localisations Tensors; 
682.       gscores: (list of) groundtruth score Tensors; 
683.     """  
684.     with tf.device(device):  
685.         with tf.name_scope(scope, 'ssd_losses'):  
686.             l_cross_pos = []  
687.             l_cross_neg = []  
688.             l_loc = []  
689.             for i in range(len(logits)):  
690.                 dtype = logits[i].dtype  
691.                 with tf.name_scope('block_%i' % i):  
692.                     # Sizing weight...  
693.                     wsize = tfe.get_shape(logits[i], rank=5)  
694.                     wsize = wsize[1] * wsize[2] * wsize[3]  
695.   
696.                     # Positive mask.  
697.                     pmask = gscores[i] > match_threshold  
698.                     fpmask = tf.cast(pmask, dtype)  
699.                     n_positives = tf.reduce_sum(fpmask)  
700.   
701.                     # Select some random negative entries.  
702.                     # n_entries = np.prod(gclasses[i].get_shape().as_list())  
703.                     # r_positive = n_positives / n_entries  
704.                     # r_negative = negative_ratio * n_positives / (n_entries - n_positives)  
705.   
706.                     # Negative mask.  
707.                     no_classes = tf.cast(pmask, tf.int32)  
708.                     predictions = slim.softmax(logits[i])  
709.                     nmask = tf.logical_and(tf.logical_not(pmask),  
710.                                            gscores[i] > -0.5)  
711.                     fnmask = tf.cast(nmask, dtype)  
712.                     nvalues = tf.where(nmask,  
713.                                        predictions[:, :, :, :, 0],  
714.                                        1. - fnmask)  
715.                     nvalues_flat = tf.reshape(nvalues, [-1])  
716.                     # Number of negative entries to select.  
717.                     n_neg = tf.cast(negative_ratio * n_positives, tf.int32)  
718.                     n_neg = tf.maximum(n_neg, tf.size(nvalues_flat) // 8)  
719.                     n_neg = tf.maximum(n_neg, tf.shape(nvalues)[0] * 4)  
720.                     max_neg_entries = 1 + tf.cast(tf.reduce_sum(fnmask), tf.int32)  
721.                     n_neg = tf.minimum(n_neg, max_neg_entries)  
722.   
723.                     val, idxes = tf.nn.top_k(-nvalues_flat, k=n_neg)  
724.                     max_hard_pred = -val[-1]  
725.                     # Final negative mask.  
726.                     nmask = tf.logical_and(nmask, nvalues < max_hard_pred)  
727.                     fnmask = tf.cast(nmask, dtype)  
728.   
729.                     # Add cross-entropy loss.  
730.                     with tf.name_scope('cross_entropy_pos'):  
731.                         fpmask = wsize * fpmask  
732.                         loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits[i],  
733.                                                                               labels=gclasses[i])  
734.                         loss = tf.losses.compute_weighted_loss(loss, fpmask)  
735.                         l_cross_pos.append(loss)  
736.   
737.                     with tf.name_scope('cross_entropy_neg'):  
738.                         fnmask = wsize * fnmask  
739.                         loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits[i],  
740.                                                                               labels=no_classes)  
741.                         loss = tf.losses.compute_weighted_loss(loss, fnmask)  
742.                         l_cross_neg.append(loss)  
743.   
744.                     # Add localization loss: smooth L1, L2, ...  
745.                     with tf.name_scope('localization'):  
746.                         # Weights Tensor: positive mask + random negative.  
747.                         weights = tf.expand_dims(alpha * fpmask, axis=-1)  
748.                         loss = custom_layers.abs_smooth(localisations[i] - glocalisations[i])  
749.                         loss = tf.losses.compute_weighted_loss(loss, weights)  
750.                         l_loc.append(loss)  
751.   
752.             # Additional total losses...  
753.             with tf.name_scope('total'):  
754.                 total_cross_pos = tf.add_n(l_cross_pos, 'cross_entropy_pos')  
755.                 total_cross_neg = tf.add_n(l_cross_neg, 'cross_entropy_neg')  
756.                 total_cross = tf.add(total_cross_pos, total_cross_neg, 'cross_entropy')  
757.                 total_loc = tf.add_n(l_loc, 'localization')  
758.   
759.                 # Add to EXTRA LOSSES TF.collection  
760.                 tf.add_to_collection('EXTRA_LOSSES', total_cross_pos)  
761.                 tf.add_to_collection('EXTRA_LOSSES', total_cross_neg)  
762.                 tf.add_to_collection('EXTRA_LOSSES', total_cross)  
763.                 tf.add_to_collection('EXTRA_LOSSES', total_loc)  
764.   

 

其中custom_layers.py的代码解析如下：

1. # Copyright 2015 Paul Balanca. All Rights Reserved.

2. #

3. # Licensed under the Apache License, Version 2.0 (the "License");

4. # you may not use this file except in compliance with the License.

5. # You may obtain a copy of the License at

6. #

7. # http://www.apache.org/licenses/LICENSE-2.0

8. #

9. # Unless required by applicable law or agreed to in writing, software

10. # distributed under the License is distributed on an "AS IS" BASIS,

11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

12. # See the License for the specific language governing permissions and

13. # limitations under the License.

14. # ==============================================================================

15. """Implement some custom layers, not provided by TensorFlow.

16.  

17. Trying to follow as much as possible the style/standards used in

18. tf.contrib.layers

19. """

20. import tensorflow as tf

21.  

22. from tensorflow.contrib.framework.python.ops import add_arg_scope

23. from tensorflow.contrib.layers.python.layers import initializers

24. from tensorflow.contrib.framework.python.ops import variables

25. from tensorflow.contrib.layers.python.layers import utils

26. from tensorflow.python.ops import nn

27. from tensorflow.python.ops import init_ops

28. from tensorflow.python.ops import variable_scope

29.  
30.  

31. def abs_smooth(x):

32. """Smoothed absolute function. Useful to compute an L1 smooth error. 当预测值与目标值相差很大时, 梯度容易爆炸,因此L1 loss对噪声（outliers）更鲁棒

33.  

34. Define as:

35. x^2 / 2 if abs(x) < 1

36. abs(x) - 0.5 if abs(x) > 1

37. We use here a differentiable definition using min(x) and abs(x). Clearly

38. not optimal, but good enough for our purpose!

39. """

40. absx = tf.abs(x)

41. minx = tf.minimum(absx, 1)

42. r = 0.5 * ((absx - 1) * minx + absx) #计算得到L1 smooth loss

43. return r

44.  
45.  

46. @add_arg_scope

47. def l2_normalization( #L2正则化：稀疏正则化操作

48. inputs, #输入特征层，[batch_size,h,w,c]

49. scaling=False, #默认归一化后是否设置缩放变量gamma

50. scale_initializer=init_ops.ones_initializer(), #scale初始化为1

51. reuse=None,

52. variables_collections=None,

53. outputs_collections=None,

54. data_format='NHWC',

55. trainable=True,

56. scope=None):

57. """Implement L2 normalization on every feature (i.e. spatial normalization).

58.  

59. Should be extended in some near future to other dimensions, providing a more

60. flexible normalization framework.

61.  

62. Args:

63. inputs: a 4-D tensor with dimensions [batch_size, height, width, channels].

64. scaling: whether or not to add a post scaling operation along the dimensions

65. which have been normalized.

66. scale_initializer: An initializer for the weights.

67. reuse: whether or not the layer and its variables should be reused. To be

68. able to reuse the layer scope must be given.

69. variables_collections: optional list of collections for all the variables or

70. a dictionary containing a different list of collection per variable.

71. outputs_collections: collection to add the outputs.

72. data_format: NHWC or NCHW data format.

73. trainable: If `True` also add variables to the graph collection

74. `GraphKeys.TRAINABLE_VARIABLES` (see tf.Variable).

75. scope: Optional scope for `variable_scope`.

76. Returns:

77. A `Tensor` representing the output of the operation.

78. """

79.  

80. with variable_scope.variable_scope(

81. scope, 'L2Normalization', [inputs], reuse=reuse) as sc:

82. inputs_shape = inputs.get_shape() #得到输入特征层的维度信息

83. inputs_rank = inputs_shape.ndims #维度数=4

84. dtype = inputs.dtype.base_dtype #数据类型

85. if data_format == 'NHWC':

86. # norm_dim = tf.range(1, inputs_rank-1)

87. norm_dim = tf.range(inputs_rank-1, inputs_rank) #需要正则化的维度是4-1=3即channel这个维度

88. params_shape = inputs_shape[-1:] #通道数

89. elif data_format == 'NCHW':

90. # norm_dim = tf.range(2, inputs_rank)

91. norm_dim = tf.range(1, 2) #需要正则化的维度是第1维，即channel这个维度

92. params_shape = (inputs_shape[1]) #通道数

93.  

94. # Normalize along spatial dimensions.

95. outputs = nn.l2_normalize(inputs, norm_dim, epsilon=1e-12) #对通道所在维度进行正则化，其中epsilon是避免除0风险

96. # Additional scaling.

97. if scaling: #判断是否对正则化后设置缩放变量

98. scale_collections = utils.get_variable_collections(

99. variables_collections, 'scale')

100. scale = variables.model_variable('gamma',

101. shape=params_shape,

102. dtype=dtype,

103. initializer=scale_initializer,

104. collections=scale_collections,

105. trainable=trainable)

106. if data_format == 'NHWC':

107. outputs = tf.multiply(outputs, scale)

108. elif data_format == 'NCHW':

109. scale = tf.expand_dims(scale, axis=-1)

110. scale = tf.expand_dims(scale, axis=-1)

111. outputs = tf.multiply(outputs, scale)

112. # outputs = tf.transpose(outputs, perm=(0, 2, 3, 1))

113.  

114. return utils.collect_named_outputs(outputs_collections, #即返回L2_norm*gamma

115. sc.original_name_scope, outputs)

116.  
117.  

118. @add_arg_scope

119. def pad2d(inputs,

120. pad=(0, 0),

121. mode='CONSTANT',

122. data_format='NHWC',

123. trainable=True,

124. scope=None):

125. """2D Padding layer, adding a symmetric padding to H and W dimensions.

126.  

127. Aims to mimic padding in Caffe and MXNet, helping the port of models to

128. TensorFlow. Tries to follow the naming convention of `tf.contrib.layers`.

129.  

130. Args:

131. inputs: 4D input Tensor;

132. pad: 2-Tuple with padding values for H and W dimensions;

133. mode: Padding mode. C.f. `tf.pad`

134. data_format: NHWC or NCHW data format.

135. """

136. with tf.name_scope(scope, 'pad2d', [inputs]):

137. # Padding shape.

138. if data_format == 'NHWC':

139. paddings = [[0, 0], [pad[0], pad[0]], [pad[1], pad[1]], [0, 0]]

140. elif data_format == 'NCHW':

141. paddings = [[0, 0], [0, 0], [pad[0], pad[0]], [pad[1], pad[1]]]

142. net = tf.pad(inputs, paddings, mode=mode)

143. return net

144.  
145.  

146. @add_arg_scope

147. def channel_to_last(inputs, #作用，将输入的特征图网络的通道维度放在最后，返回变形后的网络

148. data_format='NHWC',

149. scope=None):

150. """Move the channel axis to the last dimension. Allows to

151. provide a single output format whatever the input data format.

152.  

153. Args:

154. inputs: Input Tensor;

155. data_format: NHWC or NCHW.

156. Return:

157. Input in NHWC format.

158. """

159. with tf.name_scope(scope, 'channel_to_last', [inputs]):

160. if data_format == 'NHWC':

161. net = inputs

162. elif data_format == 'NCHW':

163. net = tf.transpose(inputs, perm=(0, 2, 3, 1))

164. return net

 

其中ssd_common.py的代码解析如下：

[python] view plain copy

1. # Copyright 2015 Paul Balanca. All Rights Reserved.  
2. #  
3. # Licensed under the Apache License, Version 2.0 (the "License");  
4. # you may not use this file except in compliance with the License.  
5. # You may obtain a copy of the License at  
6. #  
7. #     http://www.apache.org/licenses/LICENSE-2.0  
8. #  
9. # Unless required by applicable law or agreed to in writing, software  
10. # distributed under the License is distributed on an "AS IS" BASIS,  
11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
12. # See the License for the specific language governing permissions and  
13. # limitations under the License.  
14. # ==============================================================================  
15. """Shared function between different SSD implementations. 
16. """  
17. import numpy as np  
18. import tensorflow as tf  
19. import tf_extended as tfe  
20.   
21.   
22. # =========================================================================== #  
23. # TensorFlow implementation of boxes SSD encoding / decoding.  
24. # =========================================================================== #  
25. def tf_ssd_bboxes_encode_layer(labels,          #gt标签，1D的tensor  
26.                                bboxes,          #Nx4的Tensor(float)，真实的bbox  
27.                                anchors_layer,      #参考锚点list  
28.                                num_classes,        #分类类别数  
29.                                no_annotation_label,  
30.                                ignore_threshold=0.5,                #gt和锚点框间的匹配阈值，大于该值则为正样本  
31.                                prior_scaling=[0.1, 0.1, 0.2, 0.2],  #真实值到预测值转换中用到的缩放  
32.                                dtype=tf.float32):  
33.     """Encode groundtruth labels and bounding boxes using SSD anchors from 
34.     one layer. 
35.  
36.     Arguments: 
37.       labels: 1D Tensor(int64) containing groundtruth labels; 
38.       bboxes: Nx4 Tensor(float) with bboxes relative coordinates; 
39.       anchors_layer: Numpy array with layer anchors; 
40.       matching_threshold: Threshold for positive match with groundtruth bboxes; 
41.       prior_scaling: Scaling of encoded coordinates. 
42.  
43.     Return: 
44.       (target_labels, target_localizations, target_scores): Target Tensors.   返回：包含目标标签类别，目标位置，目标置信度的tesndor 
45.     """  
46.     # Anchors coordinates and volume.  
47.     yref, xref, href, wref = anchors_layer   #此前每个特征图上点对应生成的锚点框作为参考框  
48.     ymin = yref - href / 2.                  #求参考框的左上角点（xmin,ymin）和右下角点(xmax,ymax)  
49.     xmin = xref - wref / 2.   #yref和xref的shape为（38,38,1）；href和wref的shape为（4，）  
50.     ymax = yref + href / 2.  
51.     xmax = xref + wref / 2.     
52.     vol_anchors = (xmax - xmin) * (ymax - ymin) #求参考框面积vol_anchors  
53.   
54.     # Initialize tensors...                            #shape表示每个特征图上总锚点数  
55.     shape = (yref.shape[0], yref.shape[1], href.size)  #对于第一个特征图，shape=(38,38,4)；第二个特征图的shape=(19,19,6)  
56.     feat_labels = tf.zeros(shape, dtype=tf.int64)   #初始化每个特征图上的点对应的各个box所属标签维度 如：38x38x4  
57.     feat_scores = tf.zeros(shape, dtype=dtype)      #初始化每个特征图上的点对应的各个box所属标目标的得分值维度 如：38x38x4  
58.   
59.     feat_ymin = tf.zeros(shape, dtype=dtype)    #预测每个特征图每个点所属目标的坐标 ；如38x38x4;初始化为全0  
60.     feat_xmin = tf.zeros(shape, dtype=dtype)  
61.     feat_ymax = tf.ones(shape, dtype=dtype)  
62.     feat_xmax = tf.ones(shape, dtype=dtype)  
63.   
64.     def jaccard_with_anchors(bbox):                      #计算gt的框和参考锚点框的重合度  
65.         """Compute jaccard score between a box and the anchors. 
66.         """  
67.         int_ymin = tf.maximum(ymin, bbox[0])           #计算重叠区域的坐标  
68.         int_xmin = tf.maximum(xmin, bbox[1])  
69.         int_ymax = tf.minimum(ymax, bbox[2])  
70.         int_xmax = tf.minimum(xmax, bbox[3])  
71.         h = tf.maximum(int_ymax - int_ymin, 0.)        #计算重叠区域的长与宽  
72.         w = tf.maximum(int_xmax - int_xmin, 0.)  
73.         # Volumes.  
74.         inter_vol = h * w                                 #重叠区域的面积  
75.         union_vol = vol_anchors - inter_vol \             #计算bbox和参考框的并集区域  
76.             + (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])  
77.         jaccard = tf.div(inter_vol, union_vol)           #计算IOU并返回该值  
78.         return jaccard                                   
79.   
80.     def intersection_with_anchors(bbox):                #计算某个参考框包含真实框的得分情况  
81.         """Compute intersection between score a box and the anchors. 
82.         """  
83.         int_ymin = tf.maximum(ymin, bbox[0])            #计算bbox和锚点框重叠区域的坐标和长宽  
84.         int_xmin = tf.maximum(xmin, bbox[1])  
85.         int_ymax = tf.minimum(ymax, bbox[2])  
86.         int_xmax = tf.minimum(xmax, bbox[3])  
87.         h = tf.maximum(int_ymax - int_ymin, 0.)  
88.         w = tf.maximum(int_xmax - int_xmin, 0.)  
89.         inter_vol = h * w                                 #重叠区域面积  
90.         scores = tf.div(inter_vol, vol_anchors)           #将重叠区域面积除以参考框面积作为该参考框得分值；  
91.         return scores  
92.   
93.     def condition(i, feat_labels, feat_scores,  
94.                   feat_ymin, feat_xmin, feat_ymax, feat_xmax):  
95.         """Condition: check label index. 
96.         """  
97.         r = tf.less(i, tf.shape(labels)) # 逐元素比较大小,遍历labels，因为i在body返回的时候加1了  
98.         return r[0]  
99.   
100.     def body(i, feat_labels, feat_scores,                 #该函数大致意思是选择与gt box IOU最大的锚点框负责回归任务，并预测对应的边界框，如此循环  
101.              feat_ymin, feat_xmin, feat_ymax, feat_xmax):  
102.         """Body: update feature labels, scores and bboxes. 
103.         Follow the original SSD paper for that purpose: 
104.           - assign values when jaccard > 0.5; 
105.           - only update if beat the score of other bboxes. 
106.         """  
107.         # Jaccard score.                                         #计算bbox与参考框的IOU值  
108.         label = labels[i]  
109.         bbox = bboxes[i]  
110.         jaccard = jaccard_with_anchors(bbox)  
111.         # Mask: check threshold + scores + no annotations + num_classes.  
112.         mask = tf.greater(jaccard, feat_scores)                  #当IOU大于feat_scores时，对应的mask至1，做筛选  
113.         # mask = tf.logical_and(mask, tf.greater(jaccard, matching_threshold))  
114.         mask = tf.logical_and(mask, feat_scores > -0.5)  
115.         mask = tf.logical_and(mask, label < num_classes)         #label满足<21  
116.         imask = tf.cast(mask, tf.int64)                          #将mask转换数据类型int型  
117.         fmask = tf.cast(mask, dtype)                             #将mask转换数据类型float型  
118.         # Update values using mask.  
119.         feat_labels = imask * label + (1 - imask) * feat_labels  #当mask=1，则feat_labels=1；否则为0，即背景  
120.         feat_scores = tf.where(mask, jaccard, feat_scores)       #tf.where表示如果mask为真则jaccard，否则为feat_scores  
121.           
122.         feat_ymin = fmask * bbox[0] + (1 - fmask) * feat_ymin    #选择与GT bbox IOU最大的框作为GT bbox，然后循环  
123.         feat_xmin = fmask * bbox[1] + (1 - fmask) * feat_xmin  
124.         feat_ymax = fmask * bbox[2] + (1 - fmask) * feat_ymax  
125.         feat_xmax = fmask * bbox[3] + (1 - fmask) * feat_xmax  
126.   
127.         # Check no annotation label: ignore these anchors...     #对没有标注标签的锚点框做忽视，应该是背景  
128.         # interscts = intersection_with_anchors(bbox)  
129.         # mask = tf.logical_and(interscts > ignore_threshold,  
130.         #                       label == no_annotation_label)  
131.         # # Replace scores by -1.  
132.         # feat_scores = tf.where(mask, -tf.cast(mask, dtype), feat_scores)  
133.   
134.         return [i+1, feat_labels, feat_scores,  
135.                 feat_ymin, feat_xmin, feat_ymax, feat_xmax]  
136.     # Main loop definition.  
137.     i = 0  
138.     [i, feat_labels, feat_scores,  
139.      feat_ymin, feat_xmin,  
140.      feat_ymax, feat_xmax] = tf.while_loop(condition, body,  
141.                                            [i, feat_labels, feat_scores,  
142.                                             feat_ymin, feat_xmin,  
143.                                             feat_ymax, feat_xmax])  
144.     # Transform to center / size.                               #转换为中心及长宽形式（计算补偿后的中心）  
145.     feat_cy = (feat_ymax + feat_ymin) / 2.  #真实预测值其实是边界框相对于先验框的转换值，encode就是为了求这个转换值  
146.     feat_cx = (feat_xmax + feat_xmin) / 2.    
147.     feat_h = feat_ymax - feat_ymin  
148.     feat_w = feat_xmax - feat_xmin  
149.     # Encode features.  
150.     feat_cy = (feat_cy - yref) / href / prior_scaling[0]   #(预测真实边界框中心y-参考框中心y)/参考框高/缩放尺度  
151.     feat_cx = (feat_cx - xref) / wref / prior_scaling[1]     
152.     feat_h = tf.log(feat_h / href) / prior_scaling[2]      #log(预测真实边界框高h/参考框高h)/缩放尺度  
153.     feat_w = tf.log(feat_w / wref) / prior_scaling[3]  
154.     # Use SSD ordering: x / y / w / h instead of ours.  
155.     feat_localizations = tf.stack([feat_cx, feat_cy, feat_w, feat_h], axis=-1)  #返回（cx转换值,cy转换值,w转换值,h转换值）形式的边界框的预测值（其实是预测框相对于参考框的转换）  
156.     return feat_labels, feat_localizations, feat_scores                         #返回目标标签，目标预测值（位置转换值），目标置信度  
157.     #经过我们回归得到的变换，经过变换得到真实框，所以这个地方损失函数其实是我们预测的是变换，我们实际的框和anchor之间的变换和我们预测的变换之间的loss。我们回归的是一种变换。并不是直接预测框，这个和YOLO是不一样的。和Faster RCNN是一样的  
158.   
159.   
160. def tf_ssd_bboxes_encode(labels,       #1D的tensor 包含gt标签  
161.                          bboxes,       #Nx4的tensor包含真实框的相对坐标  
162.                          anchors,      #参考锚点框信息（y,x,h,w) 其中y,x是中心坐标  
163.                          num_classes,  
164.                          no_annotation_label,  
165.                          ignore_threshold=0.5,  
166.                          prior_scaling=[0.1, 0.1, 0.2, 0.2],  
167.                          dtype=tf.float32,  
168.                          scope='ssd_bboxes_encode'):  
169.     """Encode groundtruth labels and bounding boxes using SSD net anchors. 
170.     Encoding boxes for all feature layers. 
171.  
172.     Arguments: 
173.       labels: 1D Tensor(int64) containing groundtruth labels; 
174.       bboxes: Nx4 Tensor(float) with bboxes relative coordinates; 
175.       anchors: List of Numpy array with layer anchors; 
176.       matching_threshold: Threshold for positive match with groundtruth bboxes; 
177.       prior_scaling: Scaling of encoded coordinates. 
178.  
179.     Return: 
180.       (target_labels, target_localizations, target_scores):  #返回：目标标签，目标位置，目标得分值（都是list形式） 
181.         Each element is a list of target Tensors. 
182.     """  
183.     with tf.name_scope(scope):    
184.         target_labels = []               #目标标签  
185.         target_localizations = []        #目标位置  
186.         target_scores = []               #目标得分  
187.         for i, anchors_layer in enumerate(anchors):                #对所有特征图中的参考框做遍历  
188.             with tf.name_scope('bboxes_encode_block_%i' % i):  
189.                 t_labels, t_loc, t_scores = \  
190.                     tf_ssd_bboxes_encode_layer(labels, bboxes, anchors_layer,    #输入真实标签，gt位置大小，参考框位置大小……得到预测真实标签，参考框到真实框的转换以及得分  
191.                                                num_classes, no_annotation_label,  
192.                                                ignore_threshold,  
193.                                                prior_scaling, dtype)  
194.                 target_labels.append(t_labels)  
195.                 target_localizations.append(t_loc)  
196.                 target_scores.append(t_scores)  
197.         return target_labels, target_localizations, target_scores  
198.   
199.   
200. def tf_ssd_bboxes_decode_layer(feat_localizations,   #解码，在预测时用到，根据之前得到的预测值相对于参考框的转换值后，反推出真实位置（该位置包括真实的x,y,w,h）  
201.                                anchors_layer,         #需要输入：预测框和参考框的转换feat_localizations，参考框位置尺度信息anchors_layer，以及转换时用到的缩放  
202.                                prior_scaling=[0.1, 0.1, 0.2, 0.2]):    #输出真实预测框的ymin,xmin，ymax,xmax  
203.     """Compute the relative bounding boxes from the layer features and 
204.     reference anchor bounding boxes. 
205.  
206.     Arguments: 
207.       feat_localizations: Tensor containing localization features. 
208.       anchors: List of numpy array containing anchor boxes. 
209.  
210.     Return: 
211.       Tensor Nx4: ymin, xmin, ymax, xmax 
212.     """  
213.     yref, xref, href, wref = anchors_layer    #锚点框的参考中心点以及长宽  
214.   
215.     # Compute center, height and width  
216.     cx = feat_localizations[:, :, :, :, 0] * wref * prior_scaling[0] + xref  
217.     cy = feat_localizations[:, :, :, :, 1] * href * prior_scaling[1] + yref  
218.     w = wref * tf.exp(feat_localizations[:, :, :, :, 2] * prior_scaling[2])  
219.     h = href * tf.exp(feat_localizations[:, :, :, :, 3] * prior_scaling[3])  
220.     # Boxes coordinates.  
221.     ymin = cy - h / 2.  
222.     xmin = cx - w / 2.  
223.     ymax = cy + h / 2.  
224.     xmax = cx + w / 2.  
225.     bboxes = tf.stack([ymin, xmin, ymax, xmax], axis=-1)  
226.     return bboxes     #预测真实框的坐标信息（两点式的框）  
227.   
228.   
229. def tf_ssd_bboxes_decode(feat_localizations,  
230.                          anchors,  
231.                          prior_scaling=[0.1, 0.1, 0.2, 0.2],  
232.                          scope='ssd_bboxes_decode'):  
233.     """Compute the relative bounding boxes from the SSD net features and 
234.     reference anchors bounding boxes. 
235.  
236.     Arguments: 
237.       feat_localizations: List of Tensors containing localization features. 
238.       anchors: List of numpy array containing anchor boxes. 
239.  
240.     Return: 
241.       List of Tensors Nx4: ymin, xmin, ymax, xmax 
242.     """  
243.     with tf.name_scope(scope):  
244.         bboxes = []  
245.         for i, anchors_layer in enumerate(anchors):  
246.             bboxes.append(  
247.                 tf_ssd_bboxes_decode_layer(feat_localizations[i],  
248.                                            anchors_layer,  
249.                                            prior_scaling))  
250.         return bboxes  
251.   
252.   
253. # =========================================================================== #  
254. # SSD boxes selection.  
255. # =========================================================================== #  
256. def tf_ssd_bboxes_select_layer(predictions_layer, localizations_layer,  #输入预测得到的类别和位置做筛选  
257.                                select_threshold=None,  
258.                                num_classes=21,  
259.                                ignore_class=0,  
260.                                scope=None):  
261.     """Extract classes, scores and bounding boxes from features in one layer. 
262.     Batch-compatible: inputs are supposed to have batch-type shapes. 
263.  
264.     Args: 
265.       predictions_layer: A SSD prediction layer; 
266.       localizations_layer: A SSD localization layer; 
267.       select_threshold: Classification threshold for selecting a box. All boxes 
268.         under the threshold are set to 'zero'. If None, no threshold applied. 
269.     Return: 
270.       d_scores, d_bboxes: Dictionary of scores and bboxes Tensors of 
271.         size Batches X N x 1 | 4. Each key corresponding to a class. 
272.     """  
273.     select_threshold = 0.0 if select_threshold is None else select_threshold  
274.     with tf.name_scope(scope, 'ssd_bboxes_select_layer',  
275.                        [predictions_layer, localizations_layer]):  
276.         # Reshape features: Batches x N x N_labels | 4  
277.         p_shape = tfe.get_shape(predictions_layer)  
278.         predictions_layer = tf.reshape(predictions_layer,  
279.                                        tf.stack([p_shape[0], -1, p_shape[-1]]))  
280.         l_shape = tfe.get_shape(localizations_layer)  
281.         localizations_layer = tf.reshape(localizations_layer,  
282.                                          tf.stack([l_shape[0], -1, l_shape[-1]]))  
283.   
284.         d_scores = {}  
285.         d_bboxes = {}  
286.         for c in range(0, num_classes):  
287.             if c != ignore_class:    #如果不是背景类别  
288.                 # Remove boxes under the threshold.   #去掉低于阈值的box  
289.                 scores = predictions_layer[:, :, c]    #预测为第c类别的得分值  
290.                 fmask = tf.cast(tf.greater_equal(scores, select_threshold), scores.dtype)  
291.                 scores = scores * fmask  #保留得分值大于阈值的得分  
292.                 bboxes = localizations_layer * tf.expand_dims(fmask, axis=-1)  
293.                 # Append to dictionary.  
294.                 d_scores[c] = scores  
295.                 d_bboxes[c] = bboxes  
296.   
297.         return d_scores, d_bboxes  #返回字典，每个字典里是对应某类的预测权重和框位置信息；  
298.   
299.   
300. def tf_ssd_bboxes_select(predictions_net, localizations_net,  #输入：SSD网络输出的预测层list；定位层list；类别选择框阈值（None表示都选）  
301.                          select_threshold=None,                #返回一个字典，key为类别，值为得分和bbox坐标  
302.                          num_classes=21,   #包含了背景类别  
303.                          ignore_class=0,   #第0类是背景  
304.                          scope=None):  
305.     """Extract classes, scores and bounding boxes from network output layers. 
306.     Batch-compatible: inputs are supposed to have batch-type shapes. 
307.  
308.     Args: 
309.       predictions_net: List of SSD prediction layers; 
310.       localizations_net: List of localization layers; 
311.       select_threshold: Classification threshold for selecting a box. All boxes 
312.         under the threshold are set to 'zero'. If None, no threshold applied. 
313.     Return: 
314.       d_scores, d_bboxes: Dictionary of scores and bboxes Tensors of      #返回一个字典，其中key是对应类别，值对应得分值和坐标信息 
315.         size Batches X N x 1 | 4. Each key corresponding to a class. 
316.     """  
317.     with tf.name_scope(scope, 'ssd_bboxes_select',  
318.                        [predictions_net, localizations_net]):  
319.         l_scores = []  
320.         l_bboxes = []  
321.         for i in range(len(predictions_net)):  
322.             scores, bboxes = tf_ssd_bboxes_select_layer(predictions_net[i],  
323.                                                         localizations_net[i],  
324.                                                         select_threshold,  
325.                                                         num_classes,  
326.                                                         ignore_class)  
327.             l_scores.append(scores)  #对应某个类别的得分  
328.             l_bboxes.append(bboxes)  #对应某个类别的box坐标信息  
329.         # Concat results.  
330.         d_scores = {}  
331.         d_bboxes = {}  
332.         for c in l_scores[0].keys():  
333.             ls = [s[c] for s in l_scores]  
334.             lb = [b[c] for b in l_bboxes]  
335.             d_scores[c] = tf.concat(ls, axis=1)  
336.             d_bboxes[c] = tf.concat(lb, axis=1)  
337.         return d_scores, d_bboxes  
338.   
339.   
340. def tf_ssd_bboxes_select_layer_all_classes(predictions_layer, localizations_layer,  
341.                                            select_threshold=None):  
342.     """Extract classes, scores and bounding boxes from features in one layer. 
343.      Batch-compatible: inputs are supposed to have batch-type shapes. 
344.  
345.      Args: 
346.        predictions_layer: A SSD prediction layer; 
347.        localizations_layer: A SSD localization layer; 
348.       select_threshold: Classification threshold for selecting a box. If None, 
349.         select boxes whose classification score is higher than 'no class'. 
350.      Return: 
351.       classes, scores, bboxes: Input Tensors.    #输出：类别，得分，框 
352.      """  
353.     # Reshape features: Batches x N x N_labels | 4  
354.     p_shape = tfe.get_shape(predictions_layer)  
355.     predictions_layer = tf.reshape(predictions_layer,  
356.                                    tf.stack([p_shape[0], -1, p_shape[-1]]))  
357.     l_shape = tfe.get_shape(localizations_layer)  
358.     localizations_layer = tf.reshape(localizations_layer,  
359.                                      tf.stack([l_shape[0], -1, l_shape[-1]]))  
360.     # Boxes selection: use threshold or score > no-label criteria.  
361.     if select_threshold is None or select_threshold == 0:  
362.         # Class prediction and scores: assign 0. to 0-class  
363.         classes = tf.argmax(predictions_layer, axis=2)  
364.         scores = tf.reduce_max(predictions_layer, axis=2)  
365.         scores = scores * tf.cast(classes > 0, scores.dtype)  
366.     else:  
367.         sub_predictions = predictions_layer[:, :, 1:]  
368.         classes = tf.argmax(sub_predictions, axis=2) + 1  
369.         scores = tf.reduce_max(sub_predictions, axis=2)  
370.         # Only keep predictions higher than threshold.  
371.         mask = tf.greater(scores, select_threshold)  
372.         classes = classes * tf.cast(mask, classes.dtype)  
373.         scores = scores * tf.cast(mask, scores.dtype)  
374.     # Assume localization layer already decoded.  
375.     bboxes = localizations_layer  
376.     return classes, scores, bboxes  #寻找当前特征图中类别，得分，bbox  
377.   
378.   
379. def tf_ssd_bboxes_select_all_classes(predictions_net, localizations_net,  
380.                                      select_threshold=None,  
381.                                      scope=None):  
382.     """Extract classes, scores and bounding boxes from network output layers. 
383.     Batch-compatible: inputs are supposed to have batch-type shapes. 
384.  
385.     Args: 
386.       predictions_net: List of SSD prediction layers; 
387.       localizations_net: List of localization layers; 
388.       select_threshold: Classification threshold for selecting a box. If None, 
389.         select boxes whose classification score is higher than 'no class'. 
390.     Return: 
391.       classes, scores, bboxes: Tensors. 
392.     """  
393.     with tf.name_scope(scope, 'ssd_bboxes_select',  
394.                        [predictions_net, localizations_net]):  
395.         l_classes = []  
396.         l_scores = []  
397.         l_bboxes = []  
398.         for i in range(len(predictions_net)):  
399.             classes, scores, bboxes = \  
400.                 tf_ssd_bboxes_select_layer_all_classes(predictions_net[i],  
401.                                                        localizations_net[i],  
402.                                                        select_threshold)  
403.             l_classes.append(classes)  
404.             l_scores.append(scores)  
405.             l_bboxes.append(bboxes)  
406.   
407.         classes = tf.concat(l_classes, axis=1)  
408.         scores = tf.concat(l_scores, axis=1)  
409.         bboxes = tf.concat(l_bboxes, axis=1)  
410.         return classes, scores, bboxes  #返回所有特征图综合得出的类别，得分，bbox  

 

 

 

参考文章：

https://zhuanlan.zhihu.com/p/33544892

https://zhuanlan.zhihu.com/p/25100992

https://blog.csdn.net/qq1483661204/article/details/79776065