ROIPooling 学习笔记

最新推荐文章于 2022-11-13 20:31:55 发布
最新推荐文章于 2022-11-13 20:31:55 发布
阅读量854 收藏 5
点赞数
分类专栏： 模型细节模块学习 文章标签： 深度学习 目标检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luo841297935/article/details/88699495
版权

ROIPooling 学习笔记

ROIPooling的作用:
在Faster RCNN系列的论文中,由于RPN出来的区域尺寸各异,而输出到后续层的特征尺寸又期望是统一大小,所以可以通过ROIPooling层来实现特征尺寸统一.

ROIPing算法原理:

  1. 假设有一8*8的特征图
    在这里插入图片描述
  2. 其中ROI的起始位置是(0,2),ROI大小为6*5 在这里插入图片描述
  3. 设置输出特征图尺寸为2*2,选取每一个区域的最大值,具体操作如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  4. 最终得到的结果如下:
    在这里插入图片描述
  5. ROIPooling动图
    在这里插入图片描述
    注: 本文中ROI区域的获取方式和网络上一些博客中的方式不同(如下图),本文参考的是caffe源码的实现方式,后面会进行代码解读.
    在这里插入图片描述
  6. 反向传播示意图(具体数值与上文无必然联系)
    在这里插入图片描述
    ROIPing Caffe源码解读
namespace caffe {

  template <typename Dtype>
  __global__ void ROIPoolForward(const int nthreads, //线程数
                                 const Dtype* bottom_data,// 传入层数据指针
                                 const Dtype spatial_scale,//与原始图像相比,传入特征图的下采样倍数
                                 const int channels, //通道数
                                 const int height, //传入特征图高度
                                 const int width, //传入特征图宽度
                                 const int pooled_height, //传出特征图高度
                                 const int pooled_width, //传出特征图宽度
                                 const Dtype* bottom_rois, //传入层对应的ROI区域
                                 Dtype* top_data, //传出层数据指针
                                 int* argmax_data) //区域最大值位置索引
  {
    CUDA_KERNEL_LOOP(index, nthreads) {
      int pw = index % pooled_width; //表示传出数据对应的宽度索引
      int ph = (index / pooled_width) % pooled_height;//表示传出数据对应的高度索引
      int c = (index / pooled_width / pooled_height) % channels;//表示传出数据对应的通道索引
      int n = index / pooled_width / pooled_height / channels;//表示传出数据对应的batch索引
      //获取当前ROI在feature map上的位置
      bottom_rois += n * 5;
      int roi_batch_ind = bottom_rois[0];
      int roi_start_w = round(bottom_rois[1] * spatial_scale);
      int roi_start_h = round(bottom_rois[2] * spatial_scale);
      int roi_end_w = round(bottom_rois[3] * spatial_scale);
      int roi_end_h = round(bottom_rois[4] * spatial_scale);
      // 根据需要输出的feature map的大小,计算输入ROI中bin尺寸
      // 此时还是浮点数
      int roi_width = max(roi_end_w - roi_start_w + 1, 1);
      int roi_height = max(roi_end_h - roi_start_h + 1, 1);

      Dtype bin_size_h = static_cast<Dtype>(roi_height)
        / static_cast<Dtype>(pooled_height);
      Dtype bin_size_w = static_cast<Dtype>(roi_width)
        / static_cast<Dtype>(pooled_width);
      //获取bin的起始结束坐标,并做保护措施,注意起始坐标获取采用floor函数
      //即向下取整,结束坐标获取采用ceil函数,即向上取整,即会使得相邻两个bin有
      //重叠
      int hstart = static_cast<int>(floor(static_cast<Dtype>(ph)
        * bin_size_h));
      int wstart = static_cast<int>(floor(static_cast<Dtype>(pw)
        * bin_size_w));
      int hend = static_cast<int>(ceil(static_cast<Dtype>(ph + 1)
        * bin_size_h));
      int wend = static_cast<int>(ceil(static_cast<Dtype>(pw + 1)
        * bin_size_w));
      // (Add roi offsets and clip to input boundaries)
      hstart = min(max(hstart + roi_start_h, 0), height);
      hend = min(max(hend + roi_start_h, 0), height);
      wstart = min(max(wstart + roi_start_w, 0), width);
      wend = min(max(wend + roi_start_w, 0), width);
      bool is_empty = (hend <= hstart) || (wend <= wstart);

      // maxval用于记录每一个小块的最大值
      Dtype maxval = is_empty ? 0 : -FLT_MAX;
      // (If nothing is pooled, argmax = -1 causes nothing to be backprop'd)
      // maxidx 用于记录当前bin的最大值索引位置,默认值-1
      int maxidx = -1;
      // 根据传入参数将bottom_data偏移到感兴趣的那一层
      bottom_data += (roi_batch_ind * channels + c) * height * width;
      // 操作感兴趣层对应bin的数据,获取最大值,并记录最大值位置
      for (int h = hstart; h < hend; ++h) {
        for (int w = wstart; w < wend; ++w) {
          int bottom_index = h * width + w;
          if (bottom_data[bottom_index] > maxval) {
            maxval = bottom_data[bottom_index];
            maxidx = bottom_index;
          }
        }
      }
      top_data[index] = maxval;
      argmax_data[index] = maxidx;
    }
  }

  template <typename Dtype>
  void ROIPoolingLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
    const Dtype* bottom_data = bottom[0]->gpu_data();
    const Dtype* bottom_rois = bottom[1]->gpu_data();
    Dtype* top_data = top[0]->mutable_gpu_data();
    int* argmax_data = max_idx_.mutable_gpu_data();
    int count = top[0]->count();//前向运算的count数是由传出feature map的尺寸决定
    // NOLINT_NEXT_LINE(whitespace/operators)
    ROIPoolForward<Dtype> << <CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS >> >(
      count, bottom_data, spatial_scale_, channels_, height_, width_,
      pooled_height_, pooled_width_, bottom_rois, top_data, argmax_data);
    CUDA_POST_KERNEL_CHECK;
  }

  template <typename Dtype>
  __global__ void ROIPoolBackward(const int nthreads, //线程数
                                  const Dtype* top_diff, //传出层特征图梯度值
                                  const int* argmax_data, //区域最大值位置索引
                                  const int num_rois, //roi的个数
                                  const Dtype spatial_scale, //与原始图像相比,传入特征图的下采样倍数
                                  const int channels, //传入层通道数
                                  const int height, //传入层特征图高度
                                  const int width, //传入层特征图宽度
                                  const int pooled_height, //传出特征图高度
                                  const int pooled_width, //传出特征图宽度
                                  Dtype* bottom_diff, //传入层特征图梯度值
                                  const Dtype* bottom_rois) {//传入层ROI数据
    CUDA_KERNEL_LOOP(index, nthreads) {
      // (n, c, h, w) coords in bottom data
      int w = index % width;//表示传入数据对应的宽度索引
      int h = (index / width) % height;//表示传入数据对应的高度索引
      int c = (index / width / height) % channels;//表示传入数据对应的通道数索引
      int n = index / width / height / channels;//表示传入数据对应的batch索引

      Dtype gradient = 0;
      // Accumulate gradient over all ROIs that pooled this element
      // 累加所有ROI中跟这一点有关的梯度值
      for (int roi_n = 0; roi_n < num_rois; ++roi_n) {
        const Dtype* offset_bottom_rois = bottom_rois + roi_n * 5;
        int roi_batch_ind = offset_bottom_rois[0];
        // Skip if ROI's batch index doesn't match n
        if (n != roi_batch_ind) {
          continue;
        }

        int roi_start_w = round(offset_bottom_rois[1] * spatial_scale);
        int roi_start_h = round(offset_bottom_rois[2] * spatial_scale);
        int roi_end_w = round(offset_bottom_rois[3] * spatial_scale);
        int roi_end_h = round(offset_bottom_rois[4] * spatial_scale);

        // Skip if ROI doesn't include (h, w)
        //如果此点不在当前ROI内,则继续循环,若所有ROI都不包含此点,则此点梯度值为0
        const bool in_roi = (w >= roi_start_w && w <= roi_end_w &&
          h >= roi_start_h && h <= roi_end_h);
        if (!in_roi) {
          continue;
        }

        int offset = (roi_n * channels + c) * pooled_height * pooled_width;
        const Dtype* offset_top_diff = top_diff + offset;
        const int* offset_argmax_data = argmax_data + offset;

        // Compute feasible set of pooled units that could have pooled
        // this bottom unit

        // Force malformed ROIs to be 1x1

        // 以下操作是根据当前传入层数据的坐标查找传出层中对应位置的数据,并记录填充
        // 若当前传入层数据点对一个以上ROI做了贡献,则梯度累加
        int roi_width = max(roi_end_w - roi_start_w + 1, 1);
        int roi_height = max(roi_end_h - roi_start_h + 1, 1);
        Dtype bin_size_h = static_cast<Dtype>(roi_height)
          / static_cast<Dtype>(pooled_height);
        Dtype bin_size_w = static_cast<Dtype>(roi_width)
          / static_cast<Dtype>(pooled_width);

        int phstart = floor(static_cast<Dtype>(h - roi_start_h) / bin_size_h);
        int phend = ceil(static_cast<Dtype>(h - roi_start_h + 1) / bin_size_h);
        int pwstart = floor(static_cast<Dtype>(w - roi_start_w) / bin_size_w);
        int pwend = ceil(static_cast<Dtype>(w - roi_start_w + 1) / bin_size_w);

        phstart = min(max(phstart, 0), pooled_height);
        phend = min(max(phend, 0), pooled_height);
        pwstart = min(max(pwstart, 0), pooled_width);
        pwend = min(max(pwend, 0), pooled_width);

        for (int ph = phstart; ph < phend; ++ph) {
          for (int pw = pwstart; pw < pwend; ++pw) {
            if (offset_argmax_data[ph * pooled_width + pw] == (h * width + w)) {
              gradient += offset_top_diff[ph * pooled_width + pw];
            }
          }
        }
      }
      bottom_diff[index] = gradient;
    }
  }

  template <typename Dtype>
  void ROIPoolingLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
    if (!propagate_down[0]) {
      return;
    }
    // bottom和top的相对关系由forward决定
    const Dtype* bottom_rois = bottom[1]->gpu_data();
    const Dtype* top_diff = top[0]->gpu_diff();
    Dtype* bottom_diff = bottom[0]->mutable_gpu_diff();
    const int count = bottom[0]->count();//前向运算的count数是由传入feature map的尺寸决定
    caffe_gpu_set(count, Dtype(0.), bottom_diff);
    const int* argmax_data = max_idx_.gpu_data();
    // NOLINT_NEXT_LINE(whitespace/operators)
    ROIPoolBackward<Dtype> << <CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS >> >(
      count, top_diff, argmax_data, top[0]->num(), spatial_scale_, channels_,
      height_, width_, pooled_height_, pooled_width_, bottom_diff, bottom_rois);
    CUDA_POST_KERNEL_CHECK;
  }

  INSTANTIATE_LAYER_GPU_FUNCS(ROIPoolingLayer);

}  // namespace caffe
DL爱好者
关注
专栏目录
Android学习笔记
01-03
LinearLayoutCompat 线性布局 android:orientation=“vertical” 指定布局内控件排列方式为 垂直排列 android:layout_width=“match_parent” android:layout_height=“wrap_content” 有三个值match_parent、fill_...
Rol Pooling的作用
m0_66039584的博客
03-12 1027
ROL(Region of Interest) Pooling的作用
目标检测之ROI Pooling层解析
夏日山间过
08-04 5380
参考： 1 2 ROIs Pooling是Pooling层的一种，特点是输入特征图尺寸不固定，但是输出特征层尺寸固定。 ROI即region of interests，指的是特征图上的框。 在fast rcnn中，roi是指的是selective search完成之后得到的候选框在特征图上的映射。如下图： 而在faster rcnn中是在rpn之后产生的，然后再把各个候选框映射到...
ROI Pooling的作用及意义
thequitesunshine007的博客
06-23 7171
什么是ROI pooling？ ROI pooling 是对（Region of Interest）进行Pooling操作，广泛应用在物体检测的研究领域。 该操作的目的是对输入feature map中的不同大小的ROI利用池化方法获得固定大小的输出feature map。 ROI Pooling层的输入： 1，经过基础网络卷积和池化后的固定大小的特征图； 2，表示ROI信息的N*5维的矩阵，其中N表示ROI数目，纵坐标的第一列表示图片在输入特征图batch中的索引，之后四位是ROI的左上角和右下角坐标的信息
实例分割模型Mask R-CNN详解：从R-CNN，Fast R-CNN，Faster R-CNN再到Mask R-CNN
理想三旬
11-22 567
Mask R-CNN是ICCV 2017的best paper，彰显了机器学习计算机视觉领域在2017年的最新成果。在机器学习2017年的最新发展中，单任务的网络结构已经逐渐不再引人瞩目，取而代之的是集成，复杂，一石多鸟的多任务网络模型。Mask R-CNN就是典型的代表。本篇大作的一作是何凯明，在该篇论文发表的时候，何凯明已经去了FaceBook。我们先来看一下，Mask R-CNN取得了何等的成果。 在实例分割Mask R-CNN框架中，还是主要完成了三件事情： 目标检测，直接在结果图上绘制了目标框
ROI Pooling 与 SPP 理解
ggyy的NoteBook
07-31 1万+
介绍 ROI(Region of Interest) Pooling是Pooling的一种。在传统CNN中，Pooling层的作用主要有三个： 1、特征不变性，使模型更加关注是否存在某些特征而不是特征具体的位置，对于一些旋转和平移具有不变性 2、特征降维，使模型可以抽取更广泛围的特征，减小了下一层输入大小，进而减小计算量和参数个数 3、在一定程度防止过拟合，更方便优化 ROI Pooling是针对...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
学习笔记学习笔记学习笔记
01-29
学习笔记学习笔记学习笔记
MySQL进阶篇学习笔记
最新发布
05-14
黑马MySQL课程总结的学习笔记
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
ROI Pooling
Boolart的博客
11-13 212
ROI Pooling
深度学习常用算子（一）
Gapostal的专栏
08-22 1万+
1、起始输入 Data：输入数据第一层 2、激活算子 作用：引入非线性（通常需要区分的区域，直线是无法完全区分的） 1）Relu 公式：ReLU(x)=max(0,x) 2）LeakyRelu 公式：LeakyRelu(x) = (x >= 0 ? x : x*negative_slope); 3）Relu6 公式：LeakyRelu(x) = max(max(x, ...
从RoI Pooling 到 RoI Align -- Mask R-CNN 论文思想解析
weixin_42108090的博客
09-06 278
RoIAlign: RoIPool [12] is a standard operation for extracting a small feature map (e.g., 7×7) from each RoI. RoIPool first quantizes a floating-number RoI to the discrete granularity of the feature map, this quantized RoI is then subdivided into spatial ..
【深度学习】从 RoIPooling 到 RoIAlign
热门推荐
JNing
12-16 2万+
【深度学习】从 RoIPooling 到 RoIAlign
Python-深度学习-物体检测实战
11-04
购买课程后，添加小助手微信（微信号：csdnxy68）回复【唐宇迪】进入学习群，获取唐宇迪老师答疑计算机视觉-物体检测-通用解决框架Mask-Rcnn实战课程旨在帮助同学们快速掌握物体检测领域当下主流解决方案与网络框架构建原理，基于开源项目解读其应用领域与使用方法。通过debug方式，详细解读项目中每一模块核心源码，从代码角度理解网络实现方法与建模流程。为了方便同学们能将项目应用到自己的数据与任务中，实例演示如何针对自己的数据集制作标签与代码调整方法，全程实战操作，通俗讲解其中复杂的网络架构。
目标检测1——RoI Pooling和RoI Align
机器人视觉感知
08-14 3273
据此自适应计算池化核的大小，然后在划分后的池化核范围内进行最大值池化或均值池化，如图中绿色框中所示。其中计算线性插值的函数使用的方式是按邻近4个像素点对当前点贡献多少来决定的，也就是面积加权平均，可参考上面的线性插值介绍的文章。且在绿色框中的池化操作，池化核的大小也采用均分，而非近似的方法。，是固定的，因此其后可以跟全连接层用来实现，检测框类别的判断和更好的位置回归。对于物体检测的目标，我们关心的是对象是人，则上图中红色的框中人的框选区域就是。在不同的情况下用户关心的图像区域是不同的，因此。...
Faser-RCNN之ROIPooling详解
weixin_47142735的博客
06-06 2126
在Faster-rcnn中，ROIPooling的作用是将原图像上不同大小的proposal映射到特征图上同等大小的区域，以便后面进行分类和回归预测。既然是pooling,它的本质也是一种最大池化。那么究竟是如何映射的呢？ 可以通过代码来了解一下 这个是roi的代码部分，其中输入feature是网络输出的特征图，proposal是RPN网络生成的，并且经过筛选的候选框，image_shapes是原始图像的尺寸。输出就是经过roi之后固定区域的候选框。 通过debug来详细看一下各个部分的形状 featur
ROI Pooling和ROI Align、ROI Warp解析
m0_61899108的博客
12-11 3790
ROI Align 是何凯明在2017年的论文Mask-RCNN中提出的，该方法很好地解决了ROI Pooling操作中两次量化造成的区域不匹配（mis-alignment）问题。本文将先简单对比实验效果，然后介绍分析ROI Pooling流程以及产生局限性的具体原因，和ROI Align的解决方法，也将ROI Align、ROI Pooling、ROI Warp进行了比较。 ​
深度学习之 ROI Pooling
fenglepeng的博客
06-13 1万+
什么是ROI？ ROI是Region of interest的简写，指的是faster rcnn结构中，经过rpn层后，产生的proposal对应的box框。 ROIs Pooling顾名思义，是pooling层的一种，而且是针对ROIs的pooling。整个 ROI 的过程，就是将这些 proposal 抠出来的过程，得到大小统一的 feature map。 ROI Pooling 该层有两个输入： 从具有多个卷积核池化的深度网络中获得的固定大小的feature maps； 一个表示所有ROI的N*5的
JavaEE全栈学习笔记
"这是一份综合性的JavaEE学习笔记，由作者续祥整理，涵盖了从基础的Java知识到JavaEE的深入内容，还包括了Unix、Core Java、Java 5.0(Tiger)的新特性、XML以及Oracle数据库的相关学习资料。笔记详细介绍了各个主题的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值