学习Faster R-CNN代码roi_pooling（三）

最新推荐文章于 2023-10-01 20:29:16 发布
最新推荐文章于 2023-10-01 20:29:16 发布
阅读量1.1k 收藏 6
点赞数
分类专栏： PyTorch 文章标签： roi_pooling pytorch_c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43872578/article/details/86628515
版权

这一篇单独拿出来了解一下roi_pooling/src/roi_pooling.c中C代码：

  • 说明

我查过一些，但没有查到太多有用的信息，连百度#include <TH/TH.h>都百度不出太多信息，更不知道THFloatTensor_data，THFloatTensor_size具体怎么用。可能我查到的信息还是太少了吧，下面说一下我自己的理解吧，不能保证正确。

  1. 关于头文件TH/TH.h
    #include<TH/TH.h>包括了 pytorch C 代码数据结构和函数的声明，这是pytorch底层接口。

  2. roi_pooling_forward的参数

int roi_pooling_forward(int pooled_height, int pooled_width, float spatial_scale,
                        THFloatTensor * features, THFloatTensor * rois, THFloatTensor * output)

pooled_height pooling后的高；
pooled_width pooling后的宽；
spatial_scale 空间尺度，输入图片与feature map之前的比值，这个feature map指roi pooling层的输入；
features 第一个网络卷积后的特征图；
rois 所有感兴趣区域；
output 指的是pooling后的结果？

  1. 函数里面的变量
// Grab the input tensor
    float * data_flat = THFloatTensor_data(features);
    float * rois_flat = THFloatTensor_data(rois);

    float * output_flat = THFloatTensor_data(output);

把这几个参数值提取出来。在C里面就是开辟一块连续的内存来存储这些数据。
THFloatTensor_data作用就是提取值吧。

// Number of ROIs
    int num_rois = THFloatTensor_size(rois, 0);
    int size_rois = THFloatTensor_size(rois, 1);

根据上面代码rois信息包括num_rois和size_rois，即感兴趣区域的数量和大小（这里的大小指的是roi的大小，准确的说是占据的内存区域）。

// batch size
    int batch_size = THFloatTensor_size(features, 0);
    if(batch_size != 1)
    {
        return 0;
    }
    // data height
    int data_height = THFloatTensor_size(features, 1);
    // data width
    int data_width = THFloatTensor_size(features, 2);
    // Number of channels
    int num_channels = THFloatTensor_size(features, 3);

features信息包括batch_size，data_height，data_width，num_channels即批尺寸，特征数据高度，特征数据宽度，特征的通道数。

// Set all element of the output tensor to -inf.
    THFloatStorage_fill(THFloatTensor_storage(output), -1);

开始是把所有输出张量的元素设置为负无穷。

接下来就要对每个ROI进行max pool了。

// For each ROI R = [batch_index x1 y1 x2 y2]: max pool over R
    int index_roi = 0;
    int index_output = 0;
    int n;
    for (n = 0; n < num_rois; ++n)

初始化roi索引是0；初始化输出索引是0。然后开始遍历所有的感兴趣区域。

        int roi_batch_ind = rois_flat[index_roi + 0];
        int roi_start_w = round(rois_flat[index_roi + 1] * spatial_scale);
        int roi_start_h = round(rois_flat[index_roi + 2] * spatial_scale);
        int roi_end_w = round(rois_flat[index_roi + 3] * spatial_scale);
        int roi_end_h = round(rois_flat[index_roi + 4] * spatial_scale);

上面代码是取出roi的信息，roi_batch_ind，roi_start_w，roi_start_h，roi_end_w，roi_end_h，包括批的索引，ROI左上角和右下角的坐标。

对于每个ROI，从rois_flat中取出索引以及坐标信息，坐标信息乘以spatial_scale是因为这个值是输入图片与feature map之前的比值所以乘上这个比值就是把坐标映射到了原图像上，而不是在featuremap上。映射到原图像时可能不是对齐的，所以这里要四舍五入取整。

        int roi_height = fmaxf(roi_end_h - roi_start_h + 1, 1);
        int roi_width = fmaxf(roi_end_w - roi_start_w + 1, 1);
        float bin_size_h = (float)(roi_height) / (float)(pooled_height);
        float bin_size_w = (float)(roi_width) / (float)(pooled_width);

得到ROI的高度和宽度，pooling后bin的高和宽，这里bin的长宽是个浮点数，不一定是整数。

        int index_data = roi_batch_ind * data_height * data_width * num_channels;
        const int output_area = pooled_width * pooled_height;

index_data指什么？是批索引乘以特征图高度乘以特征图宽度乘以特征图通道数。
output_area是pooling后输出的大小，因为pooling大小是固定的，这个值是不变的。

       int c, ph, pw;
        for (ph = 0; ph < pooled_height; ++ph)
        {
            for (pw = 0; pw < pooled_width; ++pw)
            {

上面代码就是进行对每个bin进行pooling了。

        int hstart = (floor((float)(ph) * bin_size_h));
        int wstart = (floor((float)(pw) * bin_size_w));
        int hend = (ceil((float)(ph + 1) * bin_size_h));
        int wend = (ceil((float)(pw + 1) * bin_size_w));

hstart和wstart是每个bin的在ROI的左上角位置。ceil函数是返回不小于这个数的整数，hend和wend就是bin在ROI的右下角位置。因为是ceil函数，所以左上角的bin不小于右下角的bin。

        hstart = fminf(fmaxf(hstart + roi_start_h, 0), data_height);
        hend = fminf(fmaxf(hend + roi_start_h, 0), data_height);
        wstart = fminf(fmaxf(wstart + roi_start_w, 0), data_width);
        wend = fminf(fmaxf(wend + roi_start_w, 0), data_width);

hstart、wstart、hend和wend就是返回bin在原图的位置，原本是在ROI中的位置。

       const int pool_index = index_output + (ph * pooled_width + pw);
        int is_empty = (hend <= hstart) || (wend <= wstart);
        if (is_empty)
        {
            for (c = 0; c < num_channels * output_area; c += output_area)
            {
                output_flat[pool_index + c] = 0;
             }
        }

pool_index就是pool的位置，像是C中二维数组的索引。pooling的输出是横向按通道数pooling的。

           int h, w, c;
            for (h = hstart; h < hend; ++h)
            {
                for (w = wstart; w < wend; ++w)
                {
                    for (c = 0; c < num_channels; ++c)
                    {
                        const int index = (h * data_width + w) * num_channels + c;
                        if (data_flat[index_data + index] > output_flat[pool_index + c * output_area])
                        {
                            output_flat[pool_index + c * output_area] = data_flat[index_data + index];
                        }
                    }
                }
            }

上面循环就是bin的高度嵌套宽度嵌套通道数，然后就取这个bin中的最大值。

        // Increment ROI index
        index_roi += size_rois;
        index_output += pooled_height * pooled_width * num_channels;

当处理完一个ROI之后，更新index_roi和index_output 信息，因为C语言中是连续内存，ROI索引就是加上size_rois即ROI大小，输出索引就是加上pooling后占据的内存大小。

OK，这样就结束了。放个图更直观的看一下：
例图引自博客：https://blog.csdn.net/auto1993/article/details/78514071
ROI pooling example
考虑一个88大小的feature map，一个ROI，以及输出大小为22。这里通道是1。

  1. 输入的固定大小的feature map
    在这里插入图片描述

  2. region proposal 投影之后位置（左上角，右下角坐标）：（0，3），（7，8）。
    在这里插入图片描述

  3. 将其划分为（22）个sections（因为输出大小为22）
    在这里插入图片描述
    上面代码中我注释时说过左上角的bin大于右下角的，但是我找的这个例图中似乎不是哦，这个看在代码中具体怎么规定吧。是这样吗？？？

  4. 对每个section做max pooling
    在这里插入图片描述

下面上完整代码
** ## roi_pooling/src/roi_pooling.c ## **

#include <TH/TH.h>
#include <math.h>

int roi_pooling_forward(int pooled_height, int pooled_width, float spatial_scale,
                        THFloatTensor * features, THFloatTensor * rois, THFloatTensor * output)
{
    // Grab the input tensor
    float * data_flat = THFloatTensor_data(features);
    float * rois_flat = THFloatTensor_data(rois);

    float * output_flat = THFloatTensor_data(output);

    // Number of ROIs
    int num_rois = THFloatTensor_size(rois, 0);
    int size_rois = THFloatTensor_size(rois, 1);
    // batch size
    int batch_size = THFloatTensor_size(features, 0);
    if(batch_size != 1)
    {
        return 0;
    }
    // data height
    int data_height = THFloatTensor_size(features, 1);
    // data width
    int data_width = THFloatTensor_size(features, 2);
    // Number of channels
    int num_channels = THFloatTensor_size(features, 3);

    // Set all element of the output tensor to -inf.
    THFloatStorage_fill(THFloatTensor_storage(output), -1);

    // For each ROI R = [batch_index x1 y1 x2 y2]: max pool over R
    int index_roi = 0;
    int index_output = 0;
    int n;
    for (n = 0; n < num_rois; ++n)
    {
        int roi_batch_ind = rois_flat[index_roi + 0];
        int roi_start_w = round(rois_flat[index_roi + 1] * spatial_scale);
        int roi_start_h = round(rois_flat[index_roi + 2] * spatial_scale);
        int roi_end_w = round(rois_flat[index_roi + 3] * spatial_scale);
        int roi_end_h = round(rois_flat[index_roi + 4] * spatial_scale);
        //      CHECK_GE(roi_batch_ind, 0);
        //      CHECK_LT(roi_batch_ind, batch_size);

        int roi_height = fmaxf(roi_end_h - roi_start_h + 1, 1);
        int roi_width = fmaxf(roi_end_w - roi_start_w + 1, 1);
        float bin_size_h = (float)(roi_height) / (float)(pooled_height);
        float bin_size_w = (float)(roi_width) / (float)(pooled_width);

        int index_data = roi_batch_ind * data_height * data_width * num_channels;
        const int output_area = pooled_width * pooled_height;

        int c, ph, pw;
        for (ph = 0; ph < pooled_height; ++ph)
        {
            for (pw = 0; pw < pooled_width; ++pw)
            {
                int hstart = (floor((float)(ph) * bin_size_h));
                int wstart = (floor((float)(pw) * bin_size_w));
                int hend = (ceil((float)(ph + 1) * bin_size_h));
                int wend = (ceil((float)(pw + 1) * bin_size_w));

                hstart = fminf(fmaxf(hstart + roi_start_h, 0), data_height);
                hend = fminf(fmaxf(hend + roi_start_h, 0), data_height);
                wstart = fminf(fmaxf(wstart + roi_start_w, 0), data_width);
                wend = fminf(fmaxf(wend + roi_start_w, 0), data_width);

                const int pool_index = index_output + (ph * pooled_width + pw);
                int is_empty = (hend <= hstart) || (wend <= wstart);
                if (is_empty)
                {
                    for (c = 0; c < num_channels * output_area; c += output_area)
                    {
                        output_flat[pool_index + c] = 0;
                    }
                }
                else
                {
                    int h, w, c;
                    for (h = hstart; h < hend; ++h)
                    {
                        for (w = wstart; w < wend; ++w)
                        {
                            for (c = 0; c < num_channels; ++c)
                            {
                                const int index = (h * data_width + w) * num_channels + c;
                                if (data_flat[index_data + index] > output_flat[pool_index + c * output_area])
                                {
                                    output_flat[pool_index + c * output_area] = data_flat[index_data + index];
                                }
                            }
                        }
                    }
                }
            }
        }

        // Increment ROI index
        index_roi += size_rois;
        index_output += pooled_height * pooled_width * num_channels;
    }
    return 1;
}

reference

  1. https://blog.csdn.net/auto1993/article/details/78514071
YF-Zhang
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
pytorch 从头开始faster-rcnn（五）：roi
a362682954的博客
10-02 1909
更新：2019/8/12 上文说到 最终获得的检测框将用于ROI层真值标签的生成，以及进行筛选3：1的正负样本放入ROI层进行训练（共128个）； 同时进入ROI层的还有vgg16生成的特征图，这个特征图用于上面说的3：1正负样本坐标将相应位置的特征图抠出来用于ROIpooling层进行金字塔池化，通过金字塔池化生成固定尺寸大小（7*7）特征图；在用来全连接层分类和定位，计算损失方式与PRN...
学习Faster R-CNN代码roi_pooling
smallwhite620451的博客
09-15 458
转自：https://www.cnblogs.com/wind-chaser/p/11355002.html 了解一下roi_pooling/src/roi_pooling.c中C代码： 1.关于头文件TH/TH.h #include<TH/TH.h>包括了 pytorch C 代码数据结构和函数的声明，这是pytorch底层接口。 2.roi_pooling_forward的参数 1 int roi_pooling_forward(int pooled_height, int poo
FasterRcnn RoiPooling（Pytorch版本）部分几个问题的解析
weixin_39504171的博客
05-18 560
FasterRcnn RoiPooling（Pytorch版本）部分几个问题的解析： （1）lib/model/roipooling文件夹中几个子文件夹的内容： faster rcnn pytorch中的roi pooling简介 简述： 1）src文件夹下是C和CUDA版本的源码，其中roi_pooling的操作的前向传播有C和CUDA版本，反向传播只有CUDA版本； 2）ext文件夹下存储src文件...
Faster-RCNN代码+理论——2
g11d111的博客
12-18 6091
接着上面，继续分析，下面接着rpn之后的内容开始分析。 前面，我们分析了RPN，得到了一些框和背景。按照下图，把RPN的输出输入给RoI pooling进行一系列操作。 ① 定义输入数据RPN，将RPN的输出输入到RoI#coding:UTF-8 from __future__ import division import random import pprint import sys impor
CenterNet demo运行问题（主要DCNv2版本问题）
最新发布
weixin_52905802的博客
10-01 311
2.运行demo后还是报错TH/TH.h: No such file or directory，，这是因为pytorch1.11后版本删除了THC.h模块，详细参考下列github链接，我主要参考第一个链接。1.这是因为作者给的DCNv2版本适配pytorch版本过低，在pytorch1.X版本中已经删除该版本，按照作者Issue7对DCNv2进行替换解决，详见下列github链接。CenterNet下载后，按照作者给的readme进行安装，并试运行demo，在运行过程中首先报错。
pytorch学习笔记（十八）：C 语言扩展 pytorch
Keith
12-20 5645
上篇博文已经介绍了如何通过 继承 Function ，然后使用python 来扩展 pytorch， 本文主要介绍如何通过 cffi 来扩展 pytorch 。官网给出了一个 MyAdd 的 Demo github地址，本文通过 这个 Demo 来搞定如何 通过 cffi 来扩展 pytorch。从github上clone下来代码，目录结构是这样的 package： script：（这个部分的示例
simple-faster-rcnn-pytorch_simple-faster-rcnn-_rcnnpytorch代码_pyt
09-11
《深度学习目标检测：PyTorch实现简单版Faster R-CNN详解》 在计算机视觉领域，目标检测是一项核心任务，旨在识别并定位图像中的特定对象。Faster R-CNN（快速区域卷积神经网络）是由Ross Girshick等人提出的，它在...
保姆级 Keras 实现 Faster R-CNN 十一 示例代码
09-02
此部分增加了 RoiPoolingLayer 自定义层, 实现了感兴趣区域转换为固定大小的特征图, 并不是完整的 Faster R-CNN 代码. 具体可参考 https://blog.csdn.net/yx123919804/article/details/132511398
py-faster-rcnn-master.rar_CNN 并行_hurryvyf_sweetwyk_图像特征融合_特征分类处
07-15
图像检测的算法，Faster R-CNN算法，先对整张图像进行卷积计算，然后通过感兴趣区域池化层(RoI Pooling Layer)将选择性搜索算法推荐出来的候选区域和卷积网络计算出的特征映射图进行融合，得到候选区域对应的特征...
Hi3559开发环境Ruyi Studio中caffe环境（包含roi_pooling）
03-29
这一操作在Fast R-CNN、Faster R-CNN等基于区域提议的检测网络中尤为关键。 在Ruyi Studio中集成ROI Pooling层，你需要： 1. 确保Caffe版本支持ROI Pooling，因为某些旧版本可能不包含这个层。 2. 在网络定义 ...
window安装torch7并运用TH
小石子的博客
12-14 978
记录一下安装TH库及自己踩过的坑安装环境安装torch尝试运行 安装环境 window10+vs2017 其它：cmake（我也不记得什么版本了，反正比较新） 我一开始用ubuntu编译了一个.so也是晕乎乎啊，注意，在linux运行的话，在ubuntu下进行编译，如果要在windows跑，就在window下进行编译。 安装torch 这里有一个官方介绍pytorch快速浏览 1.先找到源代码，clone下来，我是clone到window下。 2.打开cmake 其中第3步选择自己电脑上的vs版本及相应的
Pytorch变量类型转换
热门推荐
zchenack个人专栏
01-24 9万+
Pytorch的数据类型为各式各样的Tensor,Tensor可以理解为高维矩阵。与Numpy中的Array类似。Pytorch中的tensor又包括CPU上的数据类型和GPU上的数据类型，一般GPU上的Tensor是CPU上的Tensor加cuda()函数得到。通过使用Type函数可以查看变量类型。一般系统默认是torch.FloatTensor类型。例如data = torch.Tensor(
pytorch中torch.FloatTensor的用法
frank_haha的博客
03-29 1万+
Pytorch中只能对Variable类型变量求导 对x进行类型转换后可进行求导 但是直接求导还不行，因为x是一个矩阵。所以应该在backward函数里加上torch.FloatTensor，并指定求导后，梯度伸缩倍数。
TH库学习(一): THTensor, THStorage, THAllocator介绍
Sundrops的专栏
03-22 4537
pytorch中的底层很多代码都是来源于的torch的低层Tensor库 TH = TorcH THC = TorcH Cuda THCS = TorcH Cuda Sparse THCUNN = TorcH CUda Neural Network (see cunn) THD = TorcH Distributed THNN = TorcH Neural...
海思开发：yolo v5的 focus层 移植到海思上的方法
tangshopping的博客
12-15 7446
一、前言 经网友提醒，yolo v2的 passthrough 层与 v5 的 focus 层很像，因为海思是支持 passthrough 层的，鉴于此，花了点时间了解了一下，提出一些浅见，抛砖引玉。 二、区别 上文我说的是，二者很像，说明它们还是有区别的，现在说说区别。 1. passthrough 层 出于严谨，结合海思文档图片与 passthrough 源码来一起理解，先看看 passthrough 源码： // 它的源码是 c++ 的，不是 python 格式 int reorg_cpu(THFlo
torch.FloatTensor()
weixin_36670529的博客
05-07 4万+
类型转换, 将list ,numpy转化为tensor。 以list -> tensor为例： print(torch.FloatTensor([1,2])) # 输出: tensor([1., 2.]) 根据torch.Size()创建一个空tensor a = torch.tensor([[1, 2], [3, 4]]) print(torch.FloatTensor(a.si...
torch学习笔记3.3：实现自定义模块(gpu)
July's Pensieve
11-06 2550
在使用torch时，如果想自己实现一个层，则可以按照《torch学习笔记1：实现自定义层》 中的方法来实现。但是如果想要实现一个比较复杂的网络，往往需要自己实现多个层（或类），并且有时可能需要重写其他模块中已有的函数来达到自己的目的，如果还是在nn模块中添加，会比较混乱，并且不利于本地git仓库统一管理，这个时候，我们可以自己实现一个像nn一样的模块，在代码中使用时 require即可。 我们来实现
RuntimeError: Error compiling objects for extension报错及fatal error: THC/THC.h: No such file or direct
weixin_48781592的博客
09-17 2520
在配置FCOS以及yolov5的项目环境时常常遇到这个问题：RuntimeError: Error compiling objects for extension，尝试在网上直接搜这个问题，很多都是说pytorch和CUDA版本不对应以及其他问题，但是始终没有得到解决，最后尝试细看那一堆错误发现有一句：fatal error: THC/THC.h: No such file or direct，想到之前配另一个代码的环境就是这个问题，当时也是改了很久，然后这次又来，实在害怕再来一次，记录一下。
Faster-RCNN_TF实验及错误解决
To Be Continue
08-18 9236
Faster-RCNN_TF实验及错误解决 [TOC] note 这是我前一段时间学习Faster-RCNN_TF的一些笔记，包括程序运行出错的解决过程，和自己训练测试过程。 Faster-RCNN_TF github连接： https://github.com/smallcorgi/Faster-RCNN_TF Faster-RCNN_TF代码作者已经2年没有维护，并不完全兼容现在...
faster R-CNN中ROI pooling的原理是什么
06-02
在 Faster R-CNN 中，ROI Pooling 是一种用于提取感兴趣区域（Region of Interest，ROI）特征的操作。其基本原理是将每个 ROI 划分为固定大小的子区域，然后将每个子区域内的特征映射投影到固定大小的输出网格中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值