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

最新推荐文章于 2022-11-05 15:18:40 发布
转载 最新推荐文章于 2022-11-05 15:18:40 发布 · 2.4k 阅读 · 1
本文详细介绍了faster-rcnn中的RPN网络结构，包括其前五层的卷积网络细节，如卷积核尺寸、池化操作以及如何得到13*13*256的特征图。接着，解析了RPN网络如何通过3*3的滑动窗口和不同卷积核将特征图转化为分类和回归的输出。此外，提到了RPN网络在损失函数上的应用，以及作者在./models/pascal_voc/ZF/faster_rcnn_alt_opt/stage1_rpn_train.pt 文件中的具体定义。

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

http://blog.csdn.net/sloanqin/article/details/51545125

【说明】：欢迎加入：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的卷积核就是大家平常理解的全连接；所以全连接只是卷积操作的一种特殊情况（当卷积核的大小与图片大小相同的时候，其实所谓的卷积就是全连接了）；

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-覃元元

Faster R-CNN网络架构详解和TensorFlow Hub实现（附源码）
专注AI领域
05-25 2010
Faster R-CNN的网络架构详解
（RegionProposal Network)RPN网络结构及详解
热门推荐
凹酱的DEEP LEARNING
05-23 19万+
RPN(RegionProposal Network)区域生成网络 Faster-RCNN的核心。在这里整理。 1.anchors。 特征可以看做一个尺度51*39的256通道图像，对于该图像的每一个位置，考虑9个可能的候选窗口：三种面积{128,256,512}×{128,256,512}×三种比例{1:1,1:2,2:1}{1:1,1:2,2:1}。这些候选窗口称为anchors...
详解RPN网络
weixin_42912710的博客
08-30 2万+
引言 RPN（Region Proposal Network）是Faster-RCNN网络用于提取预选框（也就是RCNN中使用selective search算法进行Region Proposal的部分），我们知道RCNN及Fast-RCNN中一个性能瓶颈就是提取预选框的部分，而RPN很好地对这个部分进行了优化，原因在于它将卷积神经网络引入了进来，使用特征提取的形式生成出预选框的位置从而降低了selective search算法带来的计算时间上的开销。 RPN( Region Proposal Networ
RPN（区域生成网络）
一名在读大学生，正在学习深度学习，会定期分享一些该领域内容。欢迎大家一起交流学习~
11-05 1万+
首先我们知道有H x W个结果，我们随机取一点，它跟原图肯定是有个一一映射关系的，由于原图和特征图大小不同，所以特征图上的一个点对应原图肯定是一个框，然而这个框很小，比如说8 x 8，这里8是指原图和特征图的比例，所以这个并不是我们想要的框，那我们不妨把框的左上角或者框的中心作为锚点（Anchor），然后想象出一堆框，具体多少，聪明的读者肯定已经猜到，K个，这也就是图中所说的K anchor boxes（由锚点产生的K个框）；我们不难发现，RPN在整个Faster RCNN中的位置，处于中间部分；
深度学习之 RPN（RegionProposal Network）- 区域候选网络
fenglepeng的博客
06-15 3万+
RPN的本质是 “ 基于滑窗的无类别obejct检测器 ” : 对于提取候选框最常用的SelectiveSearch方法，提取一副图像大概需要2s的时间，改进的EdgeBoxes算法将效率提高到了0.2s，但是这还不够。候选框提取不一定要在原图上做，特征图上同样可以，低分辨率特征图意味着更少的计算量，基于这个假设，MSRA的任少卿等人提出RPN（RegionProposal Network, 区域候选网络），完美解决了这个问题，它的主要功能是生成区域候选（Region Proposal）(可以看做是许多潜在
faster-rcnn 之 RPN网络的结构解析以及RPN代码详解
wzy的博客
12-21 1万+
【首先】：大家应该要了解卷积神经网络的连接方式，卷积核的维度，反向传播时是如何灵活的插入一层；这里我推荐一份资料，真是写的非常清晰，就是MatConvet的用户手册，这个框架底层借用的是caffe的算法，所以他们的数据结构，网络层的连接方式都是一样的；建议读者看看，很快的； 下载链接：点击打开链接 【前面5层】：作者RPN网络前面的5层借用的是ZF网络，这个网络的结构图我截个图放在下面
faster-rcnn 中的RPN网络的结构解析
复兴之矢
02-21 3253
本文转载自： http://blog.csdn.net/sloanqin/article/details/51545125 【说明】：欢迎加入：faster-rcnn 交流群 238138700，我想很多人在看faster-rcnn的时候，都会被RPN的网络结构和连接方式纠结，作者在文中说的不是很清晰，这里给出解析； 【首先】：大家应该要了解卷积神经网络的连接方式，卷
faster-rcnn之RPN网络的结构解析
浩瀚之水的专栏
09-13 1526
faster-rcnn之RPN网络的结构解析：大家应该要了解卷积神经网络的连接方式，卷积核的维度，反向传播时是如何灵活的插入一层；这里我推荐一份资料，真是写的非常清晰，就是MatConvet的用户手册，这个框架底层借用的是caffe的算法，所以他们的数据结构，网络层的连接方式都是一样的；建议读者看看，很快的； 下载链接：点击打开链接 【前面5层】：作者RPN网络前面的5层借用的是ZF网络，这个
【caffe】基本数据结构blob说明，用faster-rcnn 之 RPN网络的结构解析进行说明
ytusdc的博客
03-12 992
【caffe】基本数据结构blob 参考：https://www.cnblogs.com/zjutzz/p/5960289.html     blob是caffe中的基本数据结构，简单理解就是一个“4维数组”。但是，这个4维数组有什么意义？ BTW，TensorFlow这款google出的框架，带出了tensor（张量）的概念。虽然是数学概念，个人还是倾向于简单理解为“多维数组”，那么放在这里，...
目标检测之Faster RCNN详解
Just_do_myself的博客
04-13 8565
导读：Faster-RCNN发表于NIPS 2015上的一篇论文《Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks》。该算法最大的创新点是提出了RPN（Region Proposal Network）网络，利用Anchor机制将区域生成与卷积网络联系到一起，将检测速度一举提升到17 FPS，而且在VOC 2012测试集上实现了70.4%的检测效果，在当时可谓是以一己之力将目标检测推向了实时的高潮。后面
Faster-RCNN利用代码实现讲解算法原理
happyday_d的博客
01-05 6065
​ Faster-RCNN利用代码实现讲解原理 ​ 在学习Faster-RCNN时,阅读论文发现很多的细节不是很清楚,突然之间在网上看见Object Detection and Classification using R-CNNs 从代码的角度分析了Faster-RCNN的实现细节,本文中使用的代码为Pytorch实现的Faster-RCNN,github地址为:https://github.c...
faster-RCNN论文解析
WangKingJ的博客
10-14 1538
为了增加自己的理解，本文会从论文的理解和代码的解析两个方面来阐述。 一、概述 在目标检测领域，faster-RCNN表现出了极强的生命力，是现在很多目标算法的基础，尤其是其核心算法，RPN网络更是很多优秀的检测算法的基础。 网络上有很多优秀的论文解读的博客，本文也是以它们作为一个参考，然后再尽力配合一些编程方面的讲解。在编程方面，本文以VGG-16为例。 1、1目标 从编程的角度的来说，以fast...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值