rpn 订阅
RPN(risk priority number)是事件发生的频率、严重程度和检测等级三者乘积,被称为风险系数 或 风险顺序数,其数值愈大潜在问题愈严重,用来衡量可能的工艺缺陷,以便采取可能的预防措施减少关键的工艺变化,使工艺更加可靠。对于工艺的矫正首先应集中在那些最受关注和风险程度最高的环节。RPN值范围从1(绝对最好)到1000(绝对最差)。确定从何处着手的最好方式是利用RPN的pareto图,筛选那些累积等级远低于80%的项目。 展开全文
RPN(risk priority number)是事件发生的频率、严重程度和检测等级三者乘积,被称为风险系数 或 风险顺序数,其数值愈大潜在问题愈严重,用来衡量可能的工艺缺陷,以便采取可能的预防措施减少关键的工艺变化,使工艺更加可靠。对于工艺的矫正首先应集中在那些最受关注和风险程度最高的环节。RPN值范围从1(绝对最好)到1000(绝对最差)。确定从何处着手的最好方式是利用RPN的pareto图,筛选那些累积等级远低于80%的项目。
信息
衡    量
可能的工艺缺陷
简    称
RPN
中文名
风险优先因子
外文名
risk priority number
代码整洁之道内容简介
公式严重程度(S)-严重性是一个数值主观估计,是客户(下一个用户)或最终用户将感知失败的影响。 发生(O)-发生或有时被称为可能性,是一个数值主观估计的可能性,故障模式将发生在设计寿命期间,或在生产过程中。检测(D)-检测有时被称为有效性。它是一个控制有效性的数值,主观估计是在出售之前,检测出原因或失败模式。作为一般规则,任何导致严重9或10程度的失效模式。将是首要任务。当评估风险时,权重是最重要的。
收起全文
精华内容
下载资源
问答
  • RPN

    2020-10-24 16:16:47
    这篇细讲了RPN的细节:https://blog.csdn.net/ying86615791/article/details/72788414 强调一点,就是下图中的那个intermediate的作用。 原文中提到的是一个小网络以滑动窗口的...结合图形我的理解是RPN的网络是以一个3

    这篇拉通的讲了faster r-cnn:https://www.zhihu.com/collection/595537451
    这篇细讲了RPN的细节:https://blog.csdn.net/ying86615791/article/details/72788414

    强调一点,就是下图中的那个intermediate的作用。
    原文中提到的是一个小网络以滑动窗口的形式划过最后一个卷积层输出的feature maps,并且这个小的network的窗口空间大小是nn的。
    结合图形我的理解是RPN的网络是以一个3
    3256的卷积层开始的,之后跟了两个小的卷积层的分支,一个是cls用于判定anchor是positive还是negative,另一个reg用于模型回归,模型回归的目标是真实boxes与anchor boxes之间坐标的偏置。将偏置和anchor boxes的坐标带入预先设定的公式中,就得到了最终预测的boxes坐标。
    所以RPN的输入可以理解为feature map(m
    n大小)上的一个33的小区域,每次RPN以滑动窗口的形式从上面的mn的特征图上依次选取33的区域作为输入,用来对mn的特征图上的以每个像素点为中心的33区域进一步提取特征,在特征图边界的点提取时做padding,进一步提取后得到的特征再由后面两个分支分别做11卷积分别得到2k的scores和4k的coordinates。
    在这里插入图片描述

    展开全文
  • rpn

    2020-12-20 15:18:58
    注意: 在 RPN 的时候,已经对 anchor 做了一遍 NMS,在 RCNN 测试的时候,还要再做一遍 在 RPN 的时候,已经对 anchor 的位置做了回归调整,在 RCNN 阶段还要对 RoI 再做一遍 在 RPN 阶段分类是二分类,而 Fast ...

    本文原载于知乎专栏「人工智障的深度瞎学之路」

    Faster R-CNN 的极简实现: github: simple-faster-rcnn-pytorch(http://t.cn/RHCDoPv )

    本文插图地址(含五幅高清矢量图):draw.io(http://t.cn/RQzroe3 )

      1 概述

    在目标检测领域, Faster R-CNN 表现出了极强的生命力, 虽然是 2015 年的论文(https://arxiv.org/abs/1506.01497),但它至今仍是许多目标检测算法的基础,这在日新月异的深度学习领域十分难得。Faster R-CNN 还被应用到更多的领域中, 比如人体关键点检测、目标追踪、 实例分割还有图像描述等。

    现在很多优秀的 Faster R-CNN 博客大都是针对论文讲解,本文将尝试从编程角度讲解 Faster R-CNN 的实现。由于 Faster R-CNN 流程复杂,符号较多,容易混淆,本文以 VGG16 为例,所有插图、数值皆是基于 VGG16+VOC2007 。

    1.1 目标

    从编程实现角度角度来讲, 以 Faster R-CNN 为代表的 Object Detection 任务,可以描述成:

    给定一张图片, 找出图中的有哪些对象, 以及这些对象的位置和置信概率。

    目标检测任务

    1.2 整体架构

    Faster R-CNN 的整体流程如下图所示。

    Faster R-CNN 整体架构

    从编程角度来说, Faster R-CNN 主要分为四部分(图中四个绿色框):

    • Dataset:数据,提供符合要求的数据格式(目前常用数据集是 VOC 和 COCO)

    • Extractor: 利用 CNN 提取图片特征features(原始论文用的是 ZF 和 VGG16,后来人们又用 ResNet101)

    • RPN(Region Proposal Network): 负责提供候选区域rois(每张图给出大概 2000 个候选框)

    • RoIHead: 负责对rois分类和微调。对 RPN 找出的rois,判断它是否包含目标,并修正框的位置和座标

    Faster R-CNN 整体的流程可以分为三步:

    • 提特征: 图片(img)经过预训练的网络(Extractor),提取到了图片的特征(feature

    • Region Proposal: 利用提取的特征(feature),经过 RPN 网络,找出一定数量的rois(region of interests)。

    • 分类与回归:将rois和图像特征features,输入到RoIHead,对这些rois进行分类,判断都属于什么类别,同时对这些rois的位置进行微调。

      2 详细实现

    2.1 数据

    对与每张图片,需要进行如下数据处理:

    • 图片进行缩放,使得长边小于等于 1000,短边小于等于 600(至少有一个等于)。

    • 对相应的 bounding boxes 也也进行同等尺度的缩放。

    • 对于 Caffe 的 VGG16 预训练模型,需要图片位于 0-255,BGR 格式,并减去一个均值,使得图片像素的均值为 0。

    最后返回四个值供模型训练:

    • images : 3×H×W ,BGR 三通道,宽 W,高 H

    • bboxes: 4×K , K 个 bounding boxes,每个 bounding box 的左上角和右下角的座标,形如(Y_min,X_min, Y_max,X_max), 第 Y 行,第 X 列。

    • labels:K, 对应 K 个 bounding boxes 的 label(对于 VOC 取值范围为 [0-19])

    • scale: 缩放的倍数, 原图 H'×W'被 resize 到了 HxW(scale=H/H' )

    需要注意的是,目前大多数 Faster R-CNN 实现都只支持 batch-size=1 的训练(http://t.cn/RQzdbYt 和http://t.cn/R5vaVPi 实现支持 batch_size>1)。

    2.2 Extractor

    Extractor 使用的是预训练好的模型提取图片的特征。论文中主要使用的是 Caffe 的预训练模型 VGG16。修改如下图所示:为了节省显存,前四层卷积层的学习率设为 0。Conv4_3 的输出作为图片特征(feature)。conv4_3 相比于输入,下采样了 16 倍,也就是说输入的图片尺寸为 3×H×W,那么feature的尺寸就是 C×(H/16)×(W/16)。VGG 最后的三层全连接层的前两层,一般用来初始化 RoIHead 的部分参数,这个我们稍后再讲。总之,一张图片,经过 extractor 之后,会得到一个 C×(H/16)×(W/16) 的 feature map。

    Extractor: VGG16

    2.3 RPN

    Faster R-CNN 最突出的贡献就在于提出了 Region Proposal Network(RPN)代替了 Selective Search,从而将候选区域提取的时间开销几乎降为 0(2s -> 0.01s)。

    2.3.1 Anchor

    在 RPN 中,作者提出了anchor。Anchor 是大小和尺寸固定的候选框。论文中用到的 anchor 有三种尺寸和三种比例,如下图所示,三种尺寸分别是小(蓝 128)中(红 256)大(绿 512),三个比例分别是 1:1,1:2,2:1。3×3 的组合总共有 9 种 anchor。

     

     

    然后用这 9 种 anchor 在特征图(feature)左右上下移动,每一个特征图上的点都有 9 个 anchor,最终生成了 (H/16)× (W/16)×9 个anchor. 对于一个 512×62×37 的 feature map,有 62×37×9~ 20000 个 anchor。 也就是对一张图片,有 20000 个左右的 anchor。这种做法很像是暴力穷举,20000 多个 anchor,哪怕是蒙也能够把绝大多数的 ground truth bounding boxes 蒙中。

    2.3.2 训练 RPN

    RPN 的总体架构如下图所示:

    RPN 架构

    anchor 的数量和 feature map 相关,不同的 feature map 对应的 anchor 数量也不一样。RPN 在Extractor输出的 feature maps 的基础之上,先增加了一个卷积(用来语义空间转换?),然后利用两个 1x1 的卷积分别进行二分类(是否为正样本)和位置回归。进行分类的卷积核通道数为 9×2(9 个 anchor,每个 anchor 二分类,使用交叉熵损失),进行回归的卷积核通道数为 9×4(9 个 anchor,每个 anchor 有 4 个位置参数)。RPN 是一个全卷积网络(fully convolutional network),这样对输入图片的尺寸就没有要求了。

    接下来 RPN 做的事情就是利用(AnchorTargetCreator)将 20000 多个候选的 anchor 选出 256 个 anchor 进行分类和回归位置。选择过程如下:

    • 对于每一个 ground truth bounding box (gt_bbox),选择和它重叠度(IoU)最高的一个 anchor 作为正样本

    • 对于剩下的 anchor,从中选择和任意一个gt_bbox重叠度超过 0.7 的 anchor,作为正样本,正样本的数目不超过 128 个。

    • 随机选择和gt_bbox重叠度小于 0.3 的 anchor 作为负样本。负样本和正样本的总数为 256。

    对于每个 anchorgt_label 要么为 1(前景),要么为 0(背景),而 gt_loc 则是由 4 个位置参数 (tx,ty,tw,th) 组成,这样比直接回归座标更好。

    计算分类损失用的是交叉熵损失,而计算回归损失用的是 Smooth_l1_loss. 在计算回归损失的时候,只计算正样本(前景)的损失,不计算负样本的位置损失。

    2.3.3 RPN 生成 RoIs

    RPN 在自身训练的同时,还会提供 RoIs(region of interests)给 Fast RCNN(RoIHead)作为训练样本。RPN 生成 RoIs 的过程 (ProposalCreator) 如下:

    • 对于每张图片,利用它的 feature map, 计算 (H/16)× (W/16)×9(大概 20000)个 anchor 属于前景的概率,以及对应的位置参数。

    • 选取概率较大的 12000 个 anchor

    • 利用回归的位置参数,修正这 12000 个 anchor 的位置,得到 RoIs

    • 利用非极大值((Non-maximum suppression, NMS)抑制,选出概率最大的 2000 个 RoIs

    注意:在 inference 的时候,为了提高处理速度,12000 和 2000 分别变为 6000 和 300.

    注意:这部分的操作不需要进行反向传播,因此可以利用 numpy/tensor 实现。

    RPN 的输出:RoIs(形如 2000×4 或者 300×4 的 tensor)

    2.4 RoIHead/Fast R-CNN

    RPN 只是给出了 2000 个候选框,RoI Head 在给出的 2000 候选框之上继续进行分类和位置参数的回归。

    2.4.1 网络结构

    RoIHead 网络结构

    由于 RoIs 给出的 2000 个候选框,分别对应 feature map 不同大小的区域。首先利用ProposalTargetCreator 挑选出 128 个 sample_rois, 然后使用了 RoIPooling 将这些不同尺寸的区域全部 pooling 到同一个尺度(7×7)上。下图就是一个例子,对于 feature map 上两个不同尺度的 RoI,经过 RoIPooling 之后,最后得到了 3×3 的 feature map.

    RoIPooling

    RoI Pooling 是一种特殊的 Pooling 操作,给定一张图片的 Feature map (512×H/16×W/16) ,和 128 个候选区域的座标(128×4),RoI Pooling 将这些区域统一下采样到 (512×7×7),就得到了 128×512×7×7 的向量。可以看成是一个 batch-size=128,通道数为 512,7×7 的 feature map。

    为什么要 pooling 成 7×7 的尺度?是为了能够共享权重。在之前讲过,除了用到 VGG 前几层的卷积之外,最后的全连接层也可以继续利用。当所有的 RoIs 都被 pooling 成(512×7×7)的 feature map 后,将它 reshape 成一个一维的向量,就可以利用 VGG16 预训练的权重,初始化前两层全连接。最后再接两个全连接层,分别是:

    • FC 21 用来分类,预测 RoIs 属于哪个类别(20 个类 + 背景)

    • FC 84 用来回归位置(21 个类,每个类都有 4 个位置参数)

    2.4.2 训练

    前面讲过,RPN 会产生大约 2000 个 RoIs,这 2000 个 RoIs 不是都拿去训练,而是利用ProposalTargetCreator 选择 128 个 RoIs 用以训练。选择的规则如下:

    • RoIs 和 gt_bboxes 的 IoU 大于 0.5 的,选择一些(比如 32 个)

    • 选择 RoIs 和 gt_bboxes 的 IoU 小于等于 0(或者 0.1)的选择一些(比如 128-32=96 个)作为负样本

    为了便于训练,对选择出的 128 个 RoIs,还对他们的gt_roi_loc 进行标准化处理(减去均值除以标准差)

    对于分类问题, 直接利用交叉熵损失. 而对于位置的回归损失, 一样采用 Smooth_L1Loss, 只不过只对正样本计算损失. 而且是只对正样本中的这个类别 4 个参数计算损失。举例来说:

    • 一个 RoI 在经过 FC 84 后会输出一个 84 维的 loc 向量. 如果这个 RoI 是负样本, 则这 84 维向量不参与计算 L1_Loss

    • 如果这个 RoI 是正样本, 属于 label K, 那么它的第 K×4, K×4+1 ,K×4+2, K×4+3 这 4 个数参与计算损失,其余的不参与计算损失。

    2.4.3 生成预测结果

    测试的时候对所有的 RoIs(大概 300 个左右) 计算概率,并利用位置参数调整预测候选框的位置。然后再用一遍极大值抑制(之前在 RPN 的ProposalCreator用过)。

    注意:

    • 在 RPN 的时候,已经对 anchor 做了一遍 NMS,在 RCNN 测试的时候,还要再做一遍

    • 在 RPN 的时候,已经对 anchor 的位置做了回归调整,在 RCNN 阶段还要对 RoI 再做一遍

    • 在 RPN 阶段分类是二分类,而 Fast RCNN 阶段是 21 分类

    2.5 模型架构图

    最后整体的模型架构图如下:

    整体网络结构

    需要注意的是: 蓝色箭头的线代表着计算图,梯度反向传播会经过。而红色部分的线不需要进行反向传播(论文了中提到了ProposalCreator生成 RoIs 的过程也能进行反向传播,但需要专门的算法,https://arxiv.org/abs/1512.04412)。

      3 概念对比

    在 Faster RCNN 中有几个概念,容易混淆,或者具有较强的相似性。在此我列出来并做对比,希望对你理解有帮助。

    3.1 bbox anchor RoI loc

    BBox:全称是 bounding box,边界框。其中 Ground Truth Bounding Box 是每一张图中人工标注的框的位置。一张图中有几个目标,就有几个框 (一般小于 10 个框)。Faster R-CNN 的预测结果也可以叫 bounding box,不过一般叫 Predict Bounding Box.

    Anchor:锚?是人为选定的具有一定尺度、比例的框。一个 feature map 的锚的数目有上万个(比如 20000)。

    RoI:region of interest,候选框。Faster R-CNN 之前传统的做法是利用 selective search 从一张图上大概 2000 个候选框框。现在利用 RPN 可以从上万的 anchor 中找出一定数目更有可能的候选框。在训练 RCNN 的时候,这个数目是 2000,在测试推理阶段,这个数目是 300(为了速度)我个人实验发现 RPN 生成更多的 RoI 能得到更高的 mAP。

    RoI 不是单纯的从 anchor 中选取一些出来作为候选框,它还会利用回归位置参数,微调 anchor 的形状和位置。

    可以这么理解:在 RPN 阶段,先穷举生成千上万个 anchor,然后利用 Ground Truth Bounding Boxes,训练这些 anchor,而后从 anchor 中找出一定数目的候选区域(RoIs)。RoIs 在下一阶段用来训练 RoIHead,最后生成 Predict Bounding Boxes。

    loc: bbox,anchor 和 RoI,本质上都是一个框,可以用四个数(y_min, x_min, y_max, x_max)表示框的位置,即左上角的座标和右下角的座标。这里之所以先写 y,再写 x 是为了数组索引方便,但也需要千万注意不要弄混了。 我在实现的时候,没注意,导致输入到 RoIPooling 的座标不对,浪费了好长时间。除了用这四个数表示一个座标之外,还可以用(y,x,h,w)表示,即框的中心座标和长宽。在训练中进行位置回归的时候,用的是后一种的表示。

    3.2 四类损失

    虽然原始论文中用的4-Step Alternating Training 即四步交替迭代训练。然而现在 github 上开源的实现大多是采用近似联合训练(Approximate joint training),端到端,一步到位,速度更快。

    在训练 Faster RCNN 的时候有四个损失:

    • RPN 分类损失:anchor 是否为前景(二分类)

    • RPN 位置回归损失:anchor 位置微调

    • RoI 分类损失:RoI 所属类别(21 分类,多了一个类作为背景)

    • RoI 位置回归损失:继续对 RoI 位置微调

    四个损失相加作为最后的损失,反向传播,更新参数。

    3.3 三个 creator

    在一开始阅读源码的时候,我常常把 Faster RCNN 中用到的三个Creator弄混。

    • AnchorTargetCreator : 负责在训练 RPN 的时候,从上万个 anchor 中选择一些 (比如 256) 进行训练,以使得正负样本比例大概是 1:1. 同时给出训练的位置参数目标。 即返回gt_rpn_locgt_rpn_label

    • ProposalTargetCreator: 负责在训练 RoIHead/Fast R-CNN 的时候,从 RoIs 选择一部分 (比如 128 个) 用以训练。同时给定训练目标, 返回(sample_RoIgt_RoI_locgt_RoI_label

    • ProposalCreator: 在 RPN 中,从上万个 anchor 中,选择一定数目(2000 或者 300),调整大小和位置,生成 RoIs,用以 Fast R-CNN 训练或者测试。

    其中AnchorTargetCreatorProposalTargetCreator是为了生成训练的目标,只在训练阶段用到,ProposalCreator是 RPN 为 Fast R-CNN 生成 RoIs,在训练和测试阶段都会用到。三个共同点在于他们都不需要考虑反向传播(因此不同框架间可以共享 numpy 实现)

    3.4 感受野与 scale

    从直观上讲,感受野(receptive field)就是视觉感受区域的大小。在卷积神经网络中,感受野的定义是卷积神经网络每一层输出的特征图(feature map)上的像素点在原始图像上映射的区域大小。我的理解是,feature map 上的某一点f对应输入图片中的一个区域,这个区域中的点发生变化,f可能随之变化。而这个区域外的其它点不论如何改变,f的值都不会受之影响。VGG16 的 conv4_3 的感受野为 228,即 feature map 上每一个点,都包含了原图一个 228×228 区域的信息。

    Scale:输入图片的尺寸比上 feature map 的尺寸。比如输入图片是 3×224×224,feature map 是 512×14×14,那么 scale 就是 14/224=1/16。可以认为 feature map 中一个点对应输入图片的 16 个像素。由于相邻的同尺寸、同比例的 anchor 是在 feature map 上的距离是一个点,对应到输入图片中就是 16 个像素。在一定程度上可以认为 anchor 的精度为 16 个像素。不过还需要考虑原图相比于输入图片又做过缩放(这也是 dataset 返回的scale参数的作用,这个的scale指的是原图和输入图片的缩放尺度,和上面的 scale 不一样)。

      4 实现方案

    其实上半年好几次都要用到 Faster R-CNN,但是每回看到各种上万行,几万行代码,简直无从下手。而且直到 罗若天大神(http://t.cn/RQzgAxb )的 ruotianluo/pytorch-faster-rcnn(http://t.cn/RQzgGEo )之前,PyTorch 的 Faster R-CNN 并未有合格的实现(速度和精度)。最早 PyTorch 实现的 Faster R-CNN 有 longcw/faster_rcnn_pytorch(http://t.cn/RJzfpuS )和 fmassa/fast_rcn(http://t.cn/RQzgJFy ) 后者是当之无愧的最简实现(1,245 行代码,包括空行注释,纯 Python 实现),然而速度太慢,效果较差,fmassa 最后也放弃了这个项目。前者又太过复杂,mAP 也比论文中差一点(0.661VS 0.699)。当前 github 上的大多数实现都是基于py-faster-rcnn,RBG 大神的代码很健壮,考虑的很全面,支持很丰富,基本上 git clone 下来,准备一下数据模型就能直接跑起来。然而对我来说太过复杂,我的脑细胞比较少,上百个文件,动不动就好几层的嵌套封装,很容易令人头大。

    趁着最近时间充裕了一些,我决定从头撸一个,刚开始写没多久,就发现 chainercv(http://t.cn/RN2kZoJ ) 内置了 Faster R-CNN 的实现,而且 Faster R-CNN 中用到的许多函数(比如对 bbox 的各种操作计算),chainercv 都提供了内置支持 (其实 py-faster-rcnn 也有封装好的函数,但是 chainercv 的文档写的太详细了!)。所以大多数函数都是直接 copy&paste,把 chainer 的代码改成 pytorch/numpy,增加了一些可视化代码等。不过 cupy 的内容并没有改成 THTensor。因为 cupy 现在已经是一个独立的包,感觉比 cffi 好用(虽然我并不会 C....)。

      总结

    最终写了一个简单版本的 Faster R-CNN,代码地址在 github:simple-faster-rcnn-pytorch(http://t.cn/RHCDoPv )

    这个实现主要有以下几个特点:

    • 代码简单:除去空行,注释,说明等,大概有 2000 行左右代码,如果想学习如何实现 Faster R-CNN,这是个不错的参考。

    • 效果够好:超过论文中的指标(论文 mAP 是 69.9, 本程序利用 caffe 版本 VGG16 最低能达到 0.70,最高能达到 0.712,预训练的模型在 github 中提供链接可以下载)

    • 速度足够快:TITAN Xp 上最快只要 3 小时左右(关闭验证与可视化)就能完成训练

    • 显存占用较小:3G 左右的显存占用

    ^_^

    这个项目其实写代码没花太多时间,大多数时间花在调试上。有报错的 bug 都很容易解决,最怕的是逻辑 bug,只能一句句检查,或者在 ipdb 中一步一步的执行,看输出是否和预期一样,还不一定找得出来。不过通过一步步执行,感觉对 Faster R-CNN 的细节理解也更深了。

    写完这个代码,也算是基本掌握了 Faster R-CNN。在写代码中踩了许多坑,也学到了很多,其中几个收获 / 教训是:

    • 在复现别人的代码的时候,不要自作聪明做什么 “改进”,先严格的按照论文或者官方代码实现(比如把 SGD 优化器换成 Adam,基本训不动,后来调了一下发现要把学习率降 10 倍,但是效果依旧远不如 SGD)。

    • 不要偷懒,尽可能的 “Match Everything”。由于 torchvision 中有预训练好的 VGG16,而 caffe 预训练 VGG 要求输入图片像素在 0-255 之间(torchvision 是 0-1),BGR 格式的,标准化只减均值,不除以标准差,看起来有点别扭(总之就是要多写几十行代码 + 专门下载模型)。然后我就用 torchvision 的预训练模型初始化,最后用了一大堆的 trick,各种手动调参,才把 mAP 调到 0.7(正常跑,不调参的话大概在 0.692 附近)。某天晚上抱着试试的心态,睡前把 VGG 的模型改成 caffe 的,第二天早上起来一看轻轻松松 0.705 ...

    • 有个小 trick:把别人用其它框架训练好的模型权重转换成自己框架的,然后计算在验证集的分数,如果分数相差无几,那么说明,相关的代码没有 bug,就不用花太多时间检查这部分代码了。

    • 认真。那几天常常一连几个小时盯着屏幕,眼睛疼,很多单词敲错了没发现,有些报错了很容易发现,但是有些就。。。 比如计算分数的代码就写错了一个单词。然后我自己看模型的泛化效果不错,但就是分数特别低,我还把模型训练部分的代码又过了好几遍。。。

    • 纸上得来终觉浅, 绝知此事要 coding。

    • 当初要是再仔细读一读 最近一点微小的工作(http://t.cn/RQzgn7p )和 ruotianluo/pytorch-faster-rcnn(http://t.cn/RQzgGEo )的 readme,能少踩不少坑。

    P.S. 在 github 上搜索 faster rcnn,感觉有一半以上都是华人写的。

    最后,求 Star github: simple-faster-rcnn-pytorch(http://t.cn/RHCDoPv )

    展开全文
  • RPN 解析

    万次阅读 多人点赞 2017-01-12 11:10:09
    RPN全称是Region Proposal Network,Region Proposal的中文意思是“区域选取”,也就是“提取候选框”的意思,所以RPN就是用来提取候选框的网络; 1. RPN的意义 RPN第一次出现在世人眼中是在Faster RCNN这个...

    RPN全称是Region Proposal Network,Region
    Proposal的中文意思是“区域选取”,也就是“提取候选框”的意思,所以RPN就是用来提取候选框的网络;

    1. RPN的意义

    RPN第一次出现在世人眼中是在Faster RCNN这个结构中,专门用来提取候选框,在RCNN和Fast RCNN等物体检测架构中,用来提取候选框的方法通常是Selective Search,是比较传统的方法,而且比较耗时,在CPU上要2s一张图。所以作者提出RPN,专门用来提取候选框,一方面RPN耗时少,另一方面RPN可以很容易结合到Fast RCNN中,称为一个整体。

    RPN的引入,可以说是真正意义上把物体检测整个流程融入到一个神经网络中,这个网络结构叫做Faster RCNN;
    Faster RCNN = RPN + Fast RCNN
    这里写图片描述
    图1 Faster RCNN的整体结构

    我们不难发现,RPN在整个Faster RCNN中的位置,处于中间部分;

    2. RPN的运作机制

    我们先来看看Faster RCNN原文中的图:
    这里写图片描述
    图2 RPN的结构

    图2展示了RPN的整个过程,一个特征图经过sliding window处理,得到256维特征,然后通过两次全连接得到结果2k个分数和4k个坐标;相信大家一定有很多不懂的地方;我把相关的问题一一列举:

    1. RPN的input 特征图指的是哪个特征图?
    2. 为什么是用sliding window?文中不是说用CNN么?
    3. 256维特征向量如何获得的?
    4. 2k和4k中的k指的是什么?
    5. 图右侧不同形状的矩形和Anchors又是如何得到的?

    首先回答第一个问题,RPN的输入特征图就是图1中Faster RCNN的公共Feature Map,也称共享Feature Map,主要用以RPN和RoI Pooling共享;

    对于第二个问题,我们可以把3x3的sliding window看作是对特征图做了一次3x3的卷积操作,最后得到了一个channel数目是256的特征图,尺寸和公共特征图相同,我们假设是256 x (H x W)

    对于第三个问题,我们可以近似的把这个特征图看作有H x W个向量,每个向量是256维,那么图中的256维指的就是其中一个向量,然后我们要对每个特征向量做两次全连接操作,一个得到2个分数,一个得到4个坐标,由于我们要对每个向量做同样的全连接操作,等同于对整个特征图做两次1 x 1的卷积,得到一个2 x H x W和一个4 x H x W大小的特征图,换句话说,有H x W个结果,每个结果包含2个分数和4个坐标;
    这里写图片描述
    图3 问题1,2,3的解答描述图

    这里我们需要解释一下为何是2个分数,因为RPN是提候选框,还不用判断类别,所以只要求区分是不是物体就行,那么就有两个分数,前景(物体)的分数,和背景的分数;
    我们还需要注意:4个坐标是指针对原图坐标的偏移,首先一定要记住是原图;
    此时读者肯定有疑问,原图哪里来的坐标呢?
    这里我要解答最后两个问题了:
    首先我们知道有H x W个结果,我们随机取一点,它跟原图肯定是有个一一映射关系的,由于原图和特征图大小不同,所以特征图上的一个点对应原图肯定是一个框,然而这个框很小,比如说8 x 8,这里8是指原图和特征图的比例,所以这个并不是我们想要的框,那我们不妨把框的左上角或者框的中心作为锚点(Anchor),然后想象出一堆框,具体多少,聪明的读者肯定已经猜到,K个,这也就是图中所说的K anchor boxes(由锚点产生的K个框);换句话说,H x W个点,每个点对应原图有K个框,那么就有H x W x k个框默默的在原图上,那RPN的结果其实就是判断这些框是不是物体以及他们的偏移;那么K个框到底有多大,长宽比是多少?这里是预先设定好的,共有9种组合,所以k等于9,最后我们的结果是针对这9种组合的,所以有H x W x 9个结果,也就是18个分数和36个坐标;
    这里写图片描述
    图4 问题4,5的解答描述图

    这里宣传一下我的公共号,懒人学AI,欢迎大家关注,共同学习:
    这里写图片描述

    3. RPN的整个流程回顾

    最后我们再把RPN整个流程走一遍,首先通过一系列卷积得到公共特征图,假设他的大小是N x 16 x 16,然后我们进入RPN阶段,首先经过一个3 x 3的卷积,得到一个256 x 16 x 16的特征图,也可以看作16 x 16个256维特征向量,然后经过两次1 x 1的卷积,分别得到一个18 x 16 x 16的特征图,和一个36 x 16 x 16的特征图,也就是16 x 16 x 9个结果,每个结果包含2个分数和4个坐标,再结合预先定义的Anchors,经过后处理,就得到候选框;整个流程如图5:
    这里写图片描述
    图5 RPN整个流程

    展开全文
  • rpn计算 手机RPN计算器
  • #rpn-计算器 使用 RPN 的计算器。 使用自定义表达式树制作。 2014 年为 APCS 制造。
  • L2RPN:CodaLab L2RPN-源码

    2021-05-03 15:03:39
    cd L2RPN/ python setup.py install Pypownet简介: : 基本用法 运行测试 python Run_and_Submit_agent.py 您可以在“ Run_and_Submit_agent.py”文件中修改慢性病和时间步的测试次数。 训练模型 python -m ...
  • numworks-rpn 这是NumWorks的RPN计算器。 入门 git clone https://github.com/boricj/numworks-rpn.git apps/rpn # Quick test run on simulator make PLATFORM=simulator EPSILON_APPS='rpn settings' # Complete...
  • RPN网络

    万次阅读 多人点赞 2019-06-25 13:53:00
    RPN 思路: 1、先通过conv层+pooling层+relu层,可以是vgg,得到featuremaps。 2、在featuremaps上提取对应的图。在第一步基础上,先通过rpn生成regionproposals。通过softmax判断anchors(9个框),是...

    RPN

           这里写图片描述 

    思路:

    1、先通过conv层+pooling层+relu层,可以是vgg,得到feature maps。

    2、在feature maps上提取对应的图。在第一步基础上,先通过rpn生成region proposals。通过softmax判断anchors(9个框),是foreground还是background,再通过bounding box regression 进行修正anchors,也就是进一步确定proposals。

    3、目的是为了得到proposals feature maps,提取框的特征图,这一步是为了下面的分类做准备,也就是先得到框图在分类。这一步先通过上面得到的proposals,和roi pooling,提取proposals feature maps。

    4、分类。用proposals feature maps和一开始的proposals判断类别。

    1、一个图片从由p*q大小,变为m*n大小(600*1000),进入网络,经过13个conv,13个relu,4个pooling。得到feature maps(40*60*256)。

    2、先经过3*3conv,经过1*1conv,分成foreground和background,上面一条线是通过softmax分类anchor,获得foreground和background,下面计算anchor的boundingboxregression偏移情况。然后计算出来proposals。

    3、roi pooling,用proposals从最一开始的feature maps,通过全连接和softmax,分类。

    步骤:

    1、卷积层

        包括conv,relu,pooling。以vgg16为例,13个conv参数为kernelsize为3*3,pad为1,4个pooling为2*2,stride为2,一个图形进去网络出来后大小为m/16 ,n/16的feature maps。

    2、region proposal networks(RPN)

    • 上面一层目的是为了完成分类anchors(9个框),以获得foreground和background,目的是留着foreground。
    • 下面是对anchors进行bounding box regression,为了得到精准的参数,可以帮助后面得到精准的proposal。
    • 最后proposal是为了整合上面两个步骤得到proposal。

         从第一层说,进入3*3前图形是m/16 ,n/16的feature maps,进行3*3卷积应该是为了更好融合每个点周围的信息,每个点都有9个anchors,如下所示:每个点都有256-d,每个点都要对框分fore和back,为2个维度,所以为2k,k为9个框,所以每个点输出为W*H*18。同理回归是需要四个值定框,分别为左上右下,4个维度,所以为4k,为W*H*36。虽然文章里面有些到,但是其实在程序里面没有这样的内容,找不到所谓的框和所谓框的四个维度。

         proposals layer 3个输入,一个是分类器结果foreground,一个是anchor回归结果reg,还有一个是im-info,就是把图像进行了缩减后,进行proposal layer。

    1、先再生成anchor,对做reg回归。

    2、按照输入foreground softmax scores对anchor排序。目的找到最优anchor(2000个)。

    3、通过feat_stride和im_info,把anchor映射回原图。

    4、nms。

    5、按照nms由大到小排序foreground anchors。提取top作为结果输出proposal(256个)。

    from:https://blog.csdn.net/N_Sapientia/article/details/81487968


     

    这里介绍一下分类层中的两个reshape操作:

       对于cls层,使用1*1的卷积操作输出了18(9个anchor*2类fg/bg)个通道的feature map,大小不变。而对于regression层,也使用1*1的卷积层输出了36(4*9个anchor)个通道的feature map,大小不变。 

       对于cls层后又接了一个reshape层,其实只是为了便于softmax分类,这就要从caffe的实现形式说起了。在caffe基本数据结构blob中以如下形式保存数据:blob=[batch_size, channel,height,width]

       对应至上面的保存bg/fg anchors的矩阵,其在caffe blob中的存储形式为[1, 2*9, H, W]。而在softmax分类时需要进行fg/bg二分类,所以reshape layer会将其变为[1, 2, 9*H, W]大小,即单独“腾空”出来一个维度以便softmax分类,之后再reshape回复原状。

                             

    从中其实我们也能发现,对于rpn每个点的18个输出通道,前9个为背景的预测分数,而后9个为前景的预测分数。

       对于regression,不需要这样的操作,那么他的36个通道是不是也是如上面18个通道那样呢?即第一个9通道为dx,第二个为dy,第三个为dw,第五个是dh。还是我们比较容易想到的那种,即第一个通道是第一个盒子的回归量(dx1,dy1,dw1,dh1),第二个为(dx2,dy2,dw,2,dh2).....。待后面查看对应的bbox_targets就知道了

    正如图上所示,我们还需要准备一个层rpn-data。

    layer {
      name: 'rpn-data'
      type: 'Python'
      bottom: 'rpn_cls_score'
      bottom: 'gt_boxes'
      bottom: 'im_info'
      bottom: 'data'
      top: 'rpn_labels'
      top: 'rpn_bbox_targets'
      top: 'rpn_bbox_inside_weights'
      top: 'rpn_bbox_outside_weights'
      python_param {
        module: 'rpn.anchor_target_layer'
        layer: 'AnchorTargetLayer'
        param_str: "'feat_stride': 16"
      }
    }

    这一层输入四个量:data,gt_boxes,im_info,rpn_cls_score,其中前三个是我们在前面说过的,

    data:         1*3*600*1000 
    gt_boxes: N*5,                   N为groundtruth box的个数,每一行为(x1, y1, x2, y2, cls) ,而且这里的gt_box是经过缩放的。
    im_info: 1*3                   (h,w,scale) 

    rpn_cls_score是cls层输出的18通道,shape可以看成是1*18*H*W.  

    输出为4个量:

    rpn_labels : (1, 1, 9 * height, width)

    rpn_bbox_targets(回归目标): (1, 36,height, width)

    rpn_bbox_inside_weights(内权重):(1, 36,height, width)

    rpn_bbox_outside_weights(外权重):(1, 36,height, width)

    通俗地来讲,这一层产生了具体的anchor坐标,并与groundtruth box进行了重叠度计算,输出了kabel与回归目标。

           regression可以利用rpn_bbox_pred,rpn_bbox_targets,rpn_bbox_inside_weights,rpn_bbox_outside_weights计算SmoothL1Loss,输出rpn_loss_bbox。

    回到我们之前有一个问题rpn_bbox_pred的shape怎么构造的。其实从rpn_bbox_targets的生成过程中可以推断出应该采用后一种,即第一个盒子的回归量(dx1,dy1,dw1,dh1),第二个为(dx2,dy2,dw,2,dh2).....,这样顺序着来。

    from:https://blog.csdn.net/alibabazhouyu/article/details/80875383

    RPN结构流程图:

                      

    Note:

    1. 只有在train时,cls+reg才能得到强监督信息(来源于ground truth)。即ground truth会告诉cls+reg结构,哪些才是真的前景,从而引导cls+reg结构学得正确区分前后景的能力;在测试阶段,就要靠cls+reg自力更生了。
    2. 在train阶段,会输出约2000个proposal,但只会抽取其中256个proposal来训练RPN的cls+reg结构;到了测试阶段,则直接输出最高score的300个proposal。此时由于没有了监督信息,所有RPN**并不知道这些proposal是否为前景**,整个过程只是惯性地推送一波无tag的proposal给后面的Fast R-CNN。

    1、在 RPN头部 ,通过以下结构生成 anchor(其实就是一堆有编号有坐标的bbox);  

    2、在 RPN中部, 分类分支(cls) 和 边框回归分支(bbox reg) 分别对这堆anchor进行计算。Note: two stage型的检测算法在RPN 之后 还会进行 再一次 的 分类任务 和 边框回归任务,以进一步提升检测精度;

    3、在 RPN末端,通过对 两个分支的结果进行汇总,来实现对anchor的 初步筛除(先剔除越界的anchor,再根据cls结果通过NMS去重)和 初步偏移(根据bbox reg结果),此时输出的都改头换面叫 Proposal 。


    损失函数_add_losses

    faster rcnn包括两个损失:rpn网络的损失+rcnn网络的损失。其中每个损失又包括分类损失和回归损失。分类损失使用的是交叉熵,回归损失使用的是smooth L1 loss。

    其中rpn_cross_entropy和rpn_loss_box是RPN网络的两个损失,cls_score和bbox_pred是rcnn网络的两个损失。前两个损失用于判断archor是否是ground truth(二分类);后两个损失的batchsize是256。

    将rpn_label(1,?,?,2)中不是-1的index取出来,之后将rpn_cls_score(1,?,?,2)及rpn_label中对应于index的取出,计算sparse_softmax_cross_entropy_with_logits,得到rpn_cross_entropy。

    计算rpn_bbox_pred(1,?,?,36)和rpn_bbox_targets(1,?,?,36)的_smooth_l1_loss,得到rpn_loss_box。

    rpn_bbox_targets= bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])  # 通过archors和archors对应的正样本计算坐标的偏移

    计算cls_score(256*21)和label(256个正样本和负样本对应的真实的类别)的sparse_softmax_cross_entropy_with_logits:cross_entropy。

    labels, rois, roi_scores, bbox_targets, bbox_inside_weights = _sample_rois(all_rois, all_scores, gt_boxes, fg_rois_per_image, rois_per_image, _num_classes) # 选择256个archors

    计算bbox_pred(256*84)和bbox_targets(256*84)的_smooth_l1_loss:loss_box。

    最终将上面四个loss相加,得到总的loss(还需要加上regularization_loss)。

    至此,损失构造完毕。

    def _add_losses(self, sigma_rpn=3.0):
        with tf.variable_scope('LOSS_' + self._tag) as scope:
            rpn_cls_score = tf.reshape(self._predictions['rpn_cls_score_reshape'], [-1, 2])  # 每个archors是正样本还是负样本
            rpn_label = tf.reshape(self._anchor_targets['rpn_labels'], [-1])  # 特征图中每个位置对应的是正样本、负样本还是不关注(去除了边界在图像外面的archors)
            rpn_select = tf.where(tf.not_equal(rpn_label, -1))    # 不关注的archor到的索引
            rpn_cls_score = tf.reshape(tf.gather(rpn_cls_score, rpn_select), [-1, 2])    # 去除不关注的archor
            rpn_label = tf.reshape(tf.gather(rpn_label, rpn_select), [-1])        # 去除不关注的label
            rpn_cross_entropy = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=rpn_cls_score, labels=rpn_label))  # rpn二分类的损失
    
            rpn_bbox_pred = self._predictions['rpn_bbox_pred']  #  每个位置的9个archors回归位置偏移
            rpn_bbox_targets = self._anchor_targets['rpn_bbox_targets']   # 特征图中每个位置和对应的正样本的坐标偏移(很多为0)
            rpn_bbox_inside_weights = self._anchor_targets['rpn_bbox_inside_weights']  # 正样本的权重为1(去除负样本和不关注的样本,均为0)
            rpn_bbox_outside_weights = self._anchor_targets['rpn_bbox_outside_weights']   #   正样本和负样本(不包括不关注的样本)归一化的权重
            rpn_loss_box = self._smooth_l1_loss(rpn_bbox_pred, rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights, sigma=sigma_rpn, dim=[1, 2, 3])
    
            cls_score = self._predictions["cls_score"]  # 用于rcnn分类的256个archors的特征
            label = tf.reshape(self._proposal_targets["labels"], [-1])   # 正样本和负样本对应的真实的类别
            cross_entropy = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=cls_score, labels=label))   # rcnn分类的损失
    
            bbox_pred = self._predictions['bbox_pred']   # RCNN, bbox loss
            bbox_targets = self._proposal_targets['bbox_targets']    # 256*(4*21)的矩阵,只有为正样本时,对应类别的坐标才不为0,其他类别的坐标全为0
            bbox_inside_weights = self._proposal_targets['bbox_inside_weights']  # 256*(4*21)的矩阵,正样本时,对应类别四个坐标的权重为1,其他全为0
            bbox_outside_weights = self._proposal_targets['bbox_outside_weights']   # 256*(4*21)的矩阵,正样本时,对应类别四个坐标的权重为1,其他全为0
            loss_box = self._smooth_l1_loss(bbox_pred, bbox_targets, bbox_inside_weights, bbox_outside_weights)
    
            self._losses['cross_entropy'] = cross_entropy
            self._losses['loss_box'] = loss_box
            self._losses['rpn_cross_entropy'] = rpn_cross_entropy
            self._losses['rpn_loss_box'] = rpn_loss_box
    
            loss = cross_entropy + loss_box + rpn_cross_entropy + rpn_loss_box  # 总共的损失
            regularization_loss = tf.add_n(tf.losses.get_regularization_losses(), 'regu')
            self._losses['total_loss'] = loss + regularization_loss
    
            self._event_summaries.update(self._losses)
    
        return loss

     

    caffe prototxt文件:https://github.com/rbgirshick/py-faster-rcnn/tree/master/models/pascal_voc/ZF/faster_rcnn_end2end

     

     

    展开全文
  • (RegionProposal Network)RPN网络结构及详解

    万次阅读 多人点赞 2018-05-23 17:40:38
    RPN(RegionProposal Network)区域生成网络 Faster-RCNN的核心。在这里整理。 1.anchors。 特征可以看做一个尺度51*39的256通道图像,对于该图像的每一个位置,考虑9个可能的候选窗口:三种面积{128,256,512}×{...
  • RPN Calculator

    2020-11-27 06:58:47
    <div><p>An RPN Calculator with programmer, scientific, and statistical modes.</p><p>该提问来源于开源项目:wbond/package_control_channel</p></div>
  • rpn-开源

    2021-04-27 19:20:10
    小型RPN(HP48样式)计算器,在文本模式下以交互方式(通过GNU Readline)或自动方式(通过管道)工作
  • RPN 编译器和解释器 用于教学目的的简单 RPN 编译器和解释器。 概述 该项目是为在 Cerner DevCon 演讲中使用而开发的。 该项目的基本目标是演示使用纯函数风格构建一个简单的编译器。 除了接受表达式作为输入的 I/O ...
  • RPN理解

    2020-09-03 17:11:48
    背景 首次提出在faster-rcnn中,用于替代以前的SS算法或者滑动窗口+图像...可以看到RPN网络实际分为2条线,上面一条通过softmax分类anchors获得positive和negative分类,下面一条用于计算对于anchors的bounding box r
  • 学习RPN

    2019-11-17 14:50:34
    RPN全称Region Proposal Network,Region Proposal 的意思是“区域选择”,也就是提取候选框的意思,所以RPN就是用来提取候选框的网络。 1.RPN的意义 RPN第一次出现是在Faster RCNN这个结构中,是专门用来提取候选...
  • RPN详解

    千次阅读 2018-12-03 18:50:59
    RPN全称是Region Proposal Network,Region  Proposal的中文意思是“区域选取”,也就是“提取候选框”的意思,所以RPN就是用来提取候选框的网络; 1. RPN的意义 RPN第一次出现在世人眼中是在Fa...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,024
精华内容 1,609
关键字:

rpn