faster-rcnn 之 RPN网络的结构解析

【说明】：欢迎加入：faster-rcnn 交流群 238138700，我想很多人在看faster-rcnn的时候，都会被RPN的网络结构和连接方式纠结，作者在文中说的不是很清晰，这里给出解析；

【首先】：大家应该要了解卷积神经网络的连接方式，卷积核的维度，反向传播时是如何灵活的插入一层；这里我推荐一份资料，真是写的非常清晰，就是MatConvet的用户手册，这个框架底层借用的是caffe的算法，所以他们的数据结构，网络层的连接方式都是一样的；建议读者看看，很快的；

下载链接：点击打开链接

【前面5层】：作者RPN网络前面的5层借用的是ZF网络，这个网络的结构图我截个图放在下面，并分析下为什么是这样子的；

1、首先，输入图片大小是 224*224*3（这个3是三个通道，也就是RGB三种）

2、然后第一层的卷积核维度是 7*7*3*96 （所以大家要认识到卷积核都是4维的，在caffe的矩阵计算中都是这么实现的）；

3、所以conv1得到的结果是110*110*96 （这个110来自于 (224-7+pad)/2 +1 ，这个pad是我们常说的填充，也就是在图片的周围补充像素，这样做的目的是为了能够整除，除以2是因为2是图中的stride， 这个计算方法在上面建议的文档中有说明与推导的）；

4、然后就是做一次池化，得到pool1， 池化的核的大小是3*3，所以池化后图片的维度是55*55*96  （  (110-3+pad)/2 +1 =55 ）；

5、然后接着就是再一次卷积，这次的卷积核的维度是5*5*96*256 ，得到conv2：26*26*256；

6、后面就是类似的过程了，我就不详细一步步算了，要注意有些地方除法除不尽，作者是做了填充了，在caffe的prototxt文件中，可以看到每一层的pad的大小；

7、最后作者取的是conv5的输出，也就是13*13*256送给RPN网络的；

【RPN部分】：然后，我们看看RPN部分的结构：

1、前面我们指出，这个conv feature map的维度是13*13*256的；

2、作者在文章中指出，sliding window的大小是3*3的，那么如何得到这个256-d的向量呢？ 这个很简单了，我们只需要一个3*3*256*256这样的一个4维的卷积核，就可以将每一个3*3的sliding window 卷积成一个256维的向量；

这里读者要注意啊，作者这里画的示意图 仅仅是 针对一个sliding window的；在实际实现中，我们有很多个sliding window，所以得到的并不是一维的256-d向量，实际上还是一个3维的矩阵数据结构；可能写成for循环做sliding window大家会比较清楚，当用矩阵运算的时候，会稍微绕些；

3、然后就是k=9，所以cls layer就是18个输出节点了，那么在256-d和cls layer之间使用一个1*1*256*18的卷积核，就可以得到cls layer，当然这个1*1*256*18的卷积核就是大家平常理解的全连接；所以全连接只是卷积操作的一种特殊情况（当卷积核的大小是1*1的时候）；

4、reg layer也是一样了，reg layer的输出是36个，所以对应的卷积核是1*1*256*36，这样就可以得到reg layer的输出了；

5、然后cls layer 和reg layer后面都会接到自己的损失函数上，给出损失函数的值，同时会根据求导的结果，给出反向传播的数据，这个过程读者还是参考上面给的文档，写的挺清楚的；

【作者关于RPN网络的具体定义】：这个作者是放在./models/pascal_voc/ZF/faster_rcnn_alt_opt/stage1_rpn_train.pt 文件中的；

我把这个文件拿出来给注释下：

[plain]  view plain  copy

 

1. name: "ZF"  
2. layer {  
3.   name: 'input-data' #这一层就是最开始数据输入  
4.   type: 'Python'  
5.   top: 'data' # top表示该层的输出，所以可以看到这一层输出三组数据，data，真值框gt_boxes，和相关信息im_info  
6.   top: 'im_info' # 这些都是存储在矩阵中的  
7.   top: 'gt_boxes'  
8.   python_param {  
9.     module: 'roi_data_layer.layer'  
10.     layer: 'RoIDataLayer'  
11.     param_str: "'num_classes': 21"  
12.   }  
13. }  
14.   
15. #========= conv1-conv5 ============  
16.   
17. layer {  
18.     name: "conv1"  
19.     type: "Convolution"  
20.     bottom: "data" # 输入data  
21.     top: "conv1" # 输出conv1，这里conv1就代表了这一层输出数据的名称，存储在对应的矩阵中  
22.     param { lr_mult: 1.0 }  
23.     param { lr_mult: 2.0 }  
24.     convolution_param {  
25.         num_output: 96  
26.         kernel_size: 7  
27.         pad: 3  # 这里可以看到卷积1层 填充了3个像素  
28.         stride: 2  
29.     }  
30. }  
31. layer {  
32.     name: "relu1"  
33.     type: "ReLU"  
34.     bottom: "conv1"  
35.     top: "conv1"  
36. }  
37. layer {  
38.     name: "norm1"  
39.     type: "LRN"  
40.     bottom: "conv1"  
41.     top: "norm1" # 做归一化操作，通俗点说就是做个除法  
42.     lrn_param {  
43.         local_size: 3  
44.         alpha: 0.00005  
45.         beta: 0.75  
46.         norm_region: WITHIN_CHANNEL  
47.     engine: CAFFE  
48.     }  
49. }  
50. layer {  
51.     name: "pool1"  
52.     type: "Pooling"  
53.     bottom: "norm1"  
54.     top: "pool1"  
55.     pooling_param {  
56.         kernel_size: 3  
57.         stride: 2  
58.         pad: 1 # 池化的时候，又做了填充  
59.         pool: MAX  
60.     }  
61. }  
62. layer {  
63.     name: "conv2"  
64.     type: "Convolution"  
65.     bottom: "pool1"  
66.     top: "conv2"  
67.     param { lr_mult: 1.0 }  
68.     param { lr_mult: 2.0 }  
69.     convolution_param {  
70.         num_output: 256  
71.         kernel_size: 5  
72.         pad: 2  
73.         stride: 2  
74.     }  
75. }  
76. layer {  
77.     name: "relu2"  
78.     type: "ReLU"  
79.     bottom: "conv2"  
80.     top: "conv2"  
81. }  
82. layer {  
83.     name: "norm2"  
84.     type: "LRN"  
85.     bottom: "conv2"  
86.     top: "norm2"  
87.     lrn_param {  
88.         local_size: 3  
89.         alpha: 0.00005  
90.         beta: 0.75  
91.         norm_region: WITHIN_CHANNEL  
92.     engine: CAFFE  
93.     }  
94. }  
95. layer {  
96.     name: "pool2"  
97.     type: "Pooling"  
98.     bottom: "norm2"  
99.     top: "pool2"  
100.     pooling_param {  
101.         kernel_size: 3  
102.         stride: 2  
103.         pad: 1  
104.         pool: MAX  
105.     }  
106. }  
107. layer {  
108.     name: "conv3"  
109.     type: "Convolution"  
110.     bottom: "pool2"  
111.     top: "conv3"  
112.     param { lr_mult: 1.0 }  
113.     param { lr_mult: 2.0 }  
114.     convolution_param {  
115.         num_output: 384  
116.         kernel_size: 3  
117.         pad: 1  
118.         stride: 1  
119.     }  
120. }  
121. layer {  
122.     name: "relu3"  
123.     type: "ReLU"  
124.     bottom: "conv3"  
125.     top: "conv3"  
126. }  
127. layer {  
128.     name: "conv4"  
129.     type: "Convolution"  
130.     bottom: "conv3"  
131.     top: "conv4"  
132.     param { lr_mult: 1.0 }  
133.     param { lr_mult: 2.0 }  
134.     convolution_param {  
135.         num_output: 384  
136.         kernel_size: 3  
137.         pad: 1  
138.         stride: 1  
139.     }  
140. }  
141. layer {  
142.     name: "relu4"  
143.     type: "ReLU"  
144.     bottom: "conv4"  
145.     top: "conv4"  
146. }  
147. layer {  
148.     name: "conv5"  
149.     type: "Convolution"  
150.     bottom: "conv4"  
151.     top: "conv5"  
152.     param { lr_mult: 1.0 }  
153.     param { lr_mult: 2.0 }  
154.     convolution_param {  
155.         num_output: 256  
156.         kernel_size: 3  
157.         pad: 1  
158.         stride: 1  
159.     }  
160. }  
161. layer {  
162.     name: "relu5"  
163.     type: "ReLU"  
164.     bottom: "conv5"  
165.     top: "conv5"  
166. }  
167.   
168. #========= RPN ============  
169. # 到我们的RPN网络部分了，前面的都是共享的5层卷积层的部分  
170. layer {  
171.   name: "rpn_conv1"  
172.   type: "Convolution"  
173.   bottom: "conv5"  
174.   top: "rpn_conv1"  
175.   param { lr_mult: 1.0 }  
176.   param { lr_mult: 2.0 }  
177.   convolution_param {  
178.     num_output: 256  
179.     kernel_size: 3 pad: 1 stride: 1 #这里作者把每个滑窗3*3，通过3*3*256*256的卷积核输出256维，完整的输出其实是12*12*256,  
180.     weight_filler { type: "gaussian" std: 0.01 }  
181.     bias_filler { type: "constant" value: 0 }  
182.   }  
183. }  
184. layer {  
185.   name: "rpn_relu1"  
186.   type: "ReLU"  
187.   bottom: "rpn_conv1"  
188.   top: "rpn_conv1"  
189. }  
190. layer {  
191.   name: "rpn_cls_score"  
192.   type: "Convolution"  
193.   bottom: "rpn_conv1"  
194.   top: "rpn_cls_score"  
195.   param { lr_mult: 1.0 }  
196.   param { lr_mult: 2.0 }  
197.   convolution_param {  
198.     num_output: 18   # 2(bg/fg) * 9(anchors)  
199.     kernel_size: 1 pad: 0 stride: 1 #这里看的很清楚，作者通过1*1*256*18的卷积核，将前面的256维数据转换成了18个输出  
200.     weight_filler { type: "gaussian" std: 0.01 }  
201.     bias_filler { type: "constant" value: 0 }  
202.   }  
203. }  
204. layer {  
205.   name: "rpn_bbox_pred"  
206.   type: "Convolution"  
207.   bottom: "rpn_conv1"  
208.   top: "rpn_bbox_pred"  
209.   param { lr_mult: 1.0 }  
210.   param { lr_mult: 2.0 }  
211.   convolution_param {  
212.     num_output: 36   # 4 * 9(anchors)  
213.     kernel_size: 1 pad: 0 stride: 1 <span style="font-family: Arial, Helvetica, sans-serif;">#这里看的很清楚，作者通过1*1*256*36的卷积核，将前面的256维数据转换成了36个输出</span>  
214.     weight_filler { type: "gaussian" std: 0.01 }  
215.     bias_filler { type: "constant" value: 0 }  
216.   }  
217. }  
218. layer {  
219.    bottom: "rpn_cls_score"  
220.    top: "rpn_cls_score_reshape" # 我们之前说过，其实这一层是12*12*256的，所以后面我们要送给损失函数，需要将这个矩阵reshape一下，我们需要的是144个滑窗，每个对应的256的向量  
221.    name: "rpn_cls_score_reshape"  
222.    type: "Reshape"  
223.    reshape_param { shape { dim: 0 dim: 2 dim: -1 dim: 0 } }  
224. }  
225. layer {  
226.   name: 'rpn-data'  
227.   type: 'Python'  
228.   bottom: 'rpn_cls_score'  
229.   bottom: 'gt_boxes'  
230.   bottom: 'im_info'  
231.   bottom: 'data'  
232.   top: 'rpn_labels'  
233.   top: 'rpn_bbox_targets'  
234.   top: 'rpn_bbox_inside_weights'  
235.   top: 'rpn_bbox_outside_weights'  
236.   python_param {  
237.     module: 'rpn.anchor_target_layer'  
238.     layer: 'AnchorTargetLayer'  
239.     param_str: "'feat_stride': 16"  
240.   }  
241. }  
242. layer {  
243.   name: "rpn_loss_cls"  
244.   type: "SoftmaxWithLoss" # 很明显这里是计算softmax的损失，输入labels和cls layer的18个输出（中间reshape了一下），输出损失函数的具体值  
245.   bottom: "rpn_cls_score_reshape"  
246.   bottom: "rpn_labels"  
247.   propagate_down: 1  
248.   propagate_down: 0  
249.   top: "rpn_cls_loss"  
250.   loss_weight: 1  
251.   loss_param {  
252.     ignore_label: -1  
253.     normalize: true  
254.   }  
255. }  
256. layer {  
257.   name: "rpn_loss_bbox"  
258.   type: "SmoothL1Loss" # 这里计算的框回归损失函数具体的值  
259.   bottom: "rpn_bbox_pred"  
260.   bottom: "rpn_bbox_targets"  
261.   bottom: "rpn_bbox_inside_weights"  
262.   bottom: "rpn_bbox_outside_weights"  
263.   top: "rpn_loss_bbox"  
264.   loss_weight: 1  
265.   smooth_l1_loss_param { sigma: 3.0 }  
266. }  
267.   
268. #========= RCNN ============  
269. # Dummy layers so that initial parameters are saved into the output net  
270.   
271. layer {  
272.   name: "dummy_roi_pool_conv5"  
273.   type: "DummyData"  
274.   top: "dummy_roi_pool_conv5"  
275.   dummy_data_param {  
276.     shape { dim: 1 dim: 9216 }  
277.     data_filler { type: "gaussian" std: 0.01 }  
278.   }  
279. }  
280. layer {  
281.   name: "fc6"  
282.   type: "InnerProduct"  
283.   bottom: "dummy_roi_pool_conv5"  
284.   top: "fc6"  
285.   param { lr_mult: 0 decay_mult: 0 }  
286.   param { lr_mult: 0 decay_mult: 0 }  
287.   inner_product_param {  
288.     num_output: 4096  
289.   }  
290. }  
291. layer {  
292.   name: "relu6"  
293.   type: "ReLU"  
294.   bottom: "fc6"  
295.   top: "fc6"  
296. }  
297. layer {  
298.   name: "fc7"  
299.   type: "InnerProduct"  
300.   bottom: "fc6"  
301.   top: "fc7"  
302.   param { lr_mult: 0 decay_mult: 0 }  
303.   param { lr_mult: 0 decay_mult: 0 }  
304.   inner_product_param {  
305.     num_output: 4096  
306.   }  
307. }  
308. layer {  
309.   name: "silence_fc7"  
310.   type: "Silence"  
311.   bottom: "fc7"  
312. }  

ps：等源码看完之后，我再注释得更详细些；

作者：香蕉麦乐迪--sloanqin-覃元元