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 #这里看的很清楚,作者通过1*1*256*36的卷积核,将前面的256维数据转换成了36个输出  
  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-覃元元


你可能感兴趣的:(DL)