Faster R-CNN 纯C++版本 + 使用最新的caffe
本方法参照纯C++版的Faster-Rcnn（通过caffe自定义RPN层实现） 进行设置更改，略有改动。
核心思想：通过添加自定义层（RPN层）代替python层，实现c++版的Faster R-CNN
Faster R-CNN 纯C++版本 融合 最新caffe
（1） 添加自定义层 rpn_layer.hpp ，把它放在 caffe/include/caffe/layers/ 目录下
#ifndef CAFFE_RPN_LAYER_HPP_
#define CAFFE_RPN_LAYER_HPP_
#include {
public:
explicit RPNLayer(const LayerParameter& param)
: Layer(param) {
m_score_.reset(new Blob());
m_box_.reset(new Blob());
local_anchors_.reset(new Blob());
}
virtual void LayerSetUp(const vector*>& bottom,
//const vector*>& top);
virtual void Backward_cpu(const vector > m_score_;
shared_ptr > m_box_;
shared_ptr >local_anchors_;
void generate_anchors();
vector<vector<float> > ratio_enum(vector<float>);
vector<float> whctrs(vector<float>);
vector<float> mkanchor(float w,float h,float x_ctr,float y_ctr);
vector<vector<float> > scale_enum(vector<float>);
//cv::Mat proposal_local_anchor(int width, int height);
void proposal_local_anchor();
void bbox_tranform_inv();
cv::Mat bbox_tranform_inv(cv::Mat local_anchors, cv::Mat boxs_delta);
void nms(std::vector （2）然后是源文件 rpn_layer.cpp， 放在 caffe/src/caffe/layers/ 目录下
#include ::LayerSetUp(
const vectorfor (int j = 0; j4+j] = gen_anchors_[i][j];
}
}
top[0]->Reshape(1, 5, 1, 1);
if (top.size() > 1)
{
top[1]->Reshape(1, 1, 1, 1);
}
}
template <typename Dtype>
void RPNLayer::generate_anchors(){
//generate base anchor
vector<float> base_anchor;
base_anchor.push_back(0);
base_anchor.push_back(0);
base_anchor.push_back(base_size_ - 1);
base_anchor.push_back(base_size_ - 1);
//enum ratio anchors
vector<vector<float> >ratio_anchors = ratio_enum(base_anchor);
for (int i = 0; i < ratio_anchors.size(); ++i)
{
vector<vector<float> > tmp = scale_enum(ratio_anchors[i]);
gen_anchors_.insert(gen_anchors_.end(), tmp.begin(), tmp.end());
}
}
template <typename Dtype>
vector<vector<float> > RPNLayer::scale_enum(vector<float> anchor){
vector<vector<float> > result;
vector<float> reform_anchor = whctrs(anchor);
float x_ctr = reform_anchor[2];
float y_ctr = reform_anchor[3];
float w = reform_anchor[0];
float h = reform_anchor[1];
for (int i = 0; i < anchor_scales_.size(); ++i)
{
float ws = w * anchor_scales_[i];
float hs = h * anchor_scales_[i];
vector<float> tmp = mkanchor(ws, hs, x_ctr, y_ctr);
result.push_back(tmp);
}
return result;
}
template <typename Dtype>
vector<vector<float> > RPNLayer::ratio_enum(vector<float> anchor){
vector<vector<float> > result;
vector<float> reform_anchor = whctrs(anchor);
float x_ctr = reform_anchor[2];
float y_ctr = reform_anchor[3];
float size = reform_anchor[0] * reform_anchor[1];
for (int i = 0; i < ratios_.size(); ++i)
{
float size_ratios = size / ratios_[i];
float ws = round(sqrt(size_ratios));
float hs = round(ws*ratios_[i]);
vector<float> tmp = mkanchor(ws, hs, x_ctr, y_ctr);
result.push_back(tmp);
}
return result;
}
template <typename Dtype>
vector<float> RPNLayer::mkanchor(float w, float h, float x_ctr, float y_ctr){
vector<float> tmp;
tmp.push_back(x_ctr - 0.5*(w - 1));
tmp.push_back(y_ctr - 0.5*(h - 1));
tmp.push_back(x_ctr + 0.5*(w - 1));
tmp.push_back(y_ctr + 0.5*(h - 1));
return tmp;
}
template <typename Dtype>
vector<float> RPNLayer::whctrs(vector<float> anchor){
vector<float> result;
result.push_back(anchor[2] - anchor[0] + 1); //w
result.push_back(anchor[3] - anchor[1] + 1); //h
result.push_back((anchor[2] + anchor[0]) / 2); //ctrx
result.push_back((anchor[3] + anchor[1]) / 2); //ctry
return result;
}
/*template
cv::Mat RPNLayer::proposal_local_anchor(int width, int height)
{
Blob shift;
cv::Mat shitf_x(height, width, CV_32SC1);
cv::Mat shitf_y(height, width, CV_32SC1);
for (size_t i = 0; i < width; i++)
{
for (size_t j = 0; j < height; j++)
{
shitf_x.at(j, i) = i * feat_stride_;
shitf_y.at(j, i) = j * feat_stride_;
}
}
shift.Reshape(anchors_nums_, width*height, 4, 1);
float *p = shift.mutable_cpu_diff(), *a = shift.mutable_cpu_data();
for (int i = 0; i < height*width; i++)
{
for (int j = 0; j < anchors_nums_; j++)
{
size_t num = i * 4 + j * 4 * height*width;
p[num + 0] = -shitf_x.at(i / shitf_x.cols, i % shitf_x.cols);
p[num + 2] = -shitf_x.at(i / shitf_x.cols, i % shitf_x.cols);
p[num + 1] = -shitf_y.at(i / shitf_y.cols, i % shitf_y.cols);
p[num + 3] = -shitf_y.at(i / shitf_y.cols, i % shitf_y.cols);
a[num + 0] = anchors_[j * 4 + 0];
a[num + 1] = anchors_[j * 4 + 1];
a[num + 2] = anchors_[j * 4 + 2];
a[num + 3] = anchors_[j * 4 + 3];
}
}
shift.Update();
cv::Mat loacl_anchors(anchors_nums_ * height*width, 4, CV_32FC1);
size_t num = 0;
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
for (int c = 0; c < anchors_nums_; ++c)
{
for (int k = 0; k < 4; ++k)
{
loacl_anchors.at((i*width + j)*anchors_nums_+c, k)= shift.data_at(c, i*width + j, k, 0);
}
}
}
}
return loacl_anchors;
}*/
template <typename Dtype>
void RPNLayer::proposal_local_anchor(){
int length = mymax(map_width_, map_height_);
int step = map_width_*map_height_;
int *map_m = new int[length];
for (int i = 0; i < length; ++i)
{
map_m[i] = i*feat_stride_;
}
Dtype *shift_x = new Dtype[step];
Dtype *shift_y = new Dtype[step];
for (int i = 0; i < map_height_; ++i)
{
for (int j = 0; j < map_width_; ++j)
{
shift_x[i*map_width_ + j] = map_m[j];
shift_y[i*map_width_ + j] = map_m[i];
}
}
local_anchors_->Reshape(1, anchors_nums_ * 4, map_height_, map_width_);
Dtype *a = local_anchors_->mutable_cpu_data();
for (int i = 0; i < anchors_nums_; ++i)
{
caffe_set(step, Dtype(anchors_[i * 4 + 0]), a + (i * 4 + 0) *step);
caffe_set(step, Dtype(anchors_[i * 4 + 1]), a + (i * 4 + 1) *step);
caffe_set(step, Dtype(anchors_[i * 4 + 2]), a + (i * 4 + 2) *step);
caffe_set(step, Dtype(anchors_[i * 4 + 3]), a + (i * 4 + 3) *step);
caffe_axpy(step, Dtype(1), shift_x, a + (i * 4 + 0)*step);
caffe_axpy(step, Dtype(1), shift_x, a + (i * 4 + 2)*step);
caffe_axpy(step, Dtype(1), shift_y, a + (i * 4 + 1)*step);
caffe_axpy(step, Dtype(1), shift_y, a + (i * 4 + 3)*step);
}
}
template<typename Dtype>
void RPNLayer::filter_boxs(cv::Mat& pre_box, cv::Mat& score, vector::filter_boxs(vector::bbox_tranform_inv(){
int channel = m_box_->channels();
int height = m_box_->height();
int width = m_box_->width();
int step = height*width;
Dtype * a = m_box_->mutable_cpu_data();
Dtype * b = local_anchors_->mutable_cpu_data();
for (int i = 0; i < channel / 4; ++i)
{
caffe_axpy(2*step, Dtype(-1), b + (i * 4 + 0)*step, b + (i * 4 + 2)*step);
caffe_add_scalar(2 * step, Dtype(1), b + (i * 4 + 2)*step);
caffe_axpy(2*step, Dtype(0.5), b + (i * 4 + 2)*step, b + (i * 4 + 0)*step);
caffe_mul(2 * step, b + (i * 4 + 2)*step, a + (i * 4 + 0)*step, a + (i * 4 + 0)*step);
caffe_add(2 * step, b + (i * 4 + 0)*step, a + (i * 4 + 0)*step, a + (i * 4 + 0)*step);
caffe_exp(2*step, a + (i * 4 + 2)*step, a + (i * 4 + 2)*step);
caffe_mul(2 * step, b + (i * 4 + 2)*step, a + (i * 4 + 2)*step, a + (i * 4 + 2)*step);
}
}
template<typename Dtype>
void RPNLayer::nms(std::vector::Forward_cpu(
const vector((i*width + j)*anchors_nums_ + k, c) = bottom[1]->data_at(0, k*4 + c, i, j);
}
}
}
}*/
//get sores 向右，前面anchors_nums_个位bg的得分，后面anchors_nums_为fg得分，我们需要的是后面的。
m_score_->CopyFrom(*(bottom[0]),false,true);
/*cv::Mat scores(height*width*anchors_nums_, 1, CV_32FC1);
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
for (int k = 0; k < anchors_nums_; ++k)
{
scores.at((i*width + j)*anchors_nums_+k, 0) = bottom[0]->data_at(0, k + anchors_nums_, i, j);
}
}
}*/
//get im_info
src_height_ = bottom[2]->data_at(0, 0,0,0);
src_width_ = bottom[2]->data_at(0, 1,0,0);
src_scale_ = bottom[2]->data_at(0, 2, 0, 0);
//gen local anchors 向右
proposal_local_anchor();
//cv::Mat local_anchors = proposal_local_anchor(width, height);
//Convert anchors into proposals via bbox transformations
bbox_tranform_inv();
/*for (int i = 0; i < pre_box.rows; ++i)
{
if (pre_box.at(i, 0) < 0) pre_box.at(i, 0) = 0;
if (pre_box.at(i, 0) > (src_width_ - 1)) pre_box.at(i, 0) = src_width_ - 1;
if (pre_box.at(i, 2) < 0) pre_box.at(i, 2) = 0;
if (pre_box.at(i, 2) > (src_width_ - 1)) pre_box.at(i, 2) = src_width_ - 1;
if (pre_box.at(i, 1) < 0) pre_box.at(i, 1) = 0;
if (pre_box.at(i, 1) > (src_height_ - 1)) pre_box.at(i, 1) = src_height_ - 1;
if (pre_box.at(i, 3) < 0) pre_box.at(i, 3) = 0;
if (pre_box.at(i, 3) > (src_height_ - 1)) pre_box.at(i, 3) = src_height_ - 1;
}*/
vector (3) 添加自定义层 roi pooling layer、smooth_L1_loss_layer（此层仅供训练时使用）
注意：参照的blog中提到需要添加roi pooling层，其实py-faster-rcnn的caffe-fast-rcnn中已经含有roi pooling layer，故此步骤如果用py-faster-rcnn的caffe-fast-rcnn可以不用添加，保留原始代码即可。如果用最新caffe，则需做如下操作：
1、将 py-faster-rcnn/caffe-fast-rcnn/src/caffe/layers/roi_pooling_layer.cpp 、roi_pooling_layer.cu 、smooth_L1_loss_layer.cpp、smooth_L1_loss_layer.cu 四个文件放入 caffe//src/caffe/layers/ 下
注意： roi pooling layer 用 py-faster-rcnn原本的代码也可以，用参照的blog里的代码也可。
2、将 py-faster-rcnn/caffe-fast-rcnn/include/caffe/fast_rcnn_layers.hpp、data_reader.hpp 放入 caffe/include/caffe/ 下
3、将 py-faster-rcnn/caffe-fast-rcnn/src/caffe/data_reader.cpp 放入 caffe//src/caffe/ 下
（4）在caffe/src/caffe/proto/caffe.proto 中声明这三个类
在message LayerParameter 中添加：
optional ROIPoolingParameter roi_pooling_param = 8266711;
optional SmoothL1LossParameter smooth_l1_loss_param = 8266712;
optional RPNParameter rpn_param = 8266713;在这个文件的最末尾，定义具体的参数
message ROIPoolingParameter {
optional uint32 pooled_h = 1 [default = 0];
optional uint32 pooled_w = 2 [default = 0];
optional float spatial_scale = 3 [default = 1];
}
message RPNParameter {
optional uint32 feat_stride = 1;
optional uint32 basesize = 2;
repeated uint32 scale = 3;
repeated float ratio = 4;
optional uint32 boxminsize =5;
optional uint32 per_nms_topn = 9;
optional uint32 post_nms_topn = 11;
optional float nms_thresh = 8;
}
message SmoothL1LossParameter {
// SmoothL1Loss(x) =
// 0.5 * (sigma * x) ** 2 -- if x < 1.0 / sigma / sigma
// |x| - 0.5 / sigma / sigma -- otherwise
optional float sigma = 1 [default = 1];
} （5）因为自定义层使用了RPN层，为了以后程序中各处都能使用该层，所以得在common.hpp和common.cpp文件的最末尾，添加对应的代码，注意这里的namespace RPN是和namespace caffe同一级的
1、头文件common.hpp里添加
namespace RPN{
struct abox
{
float x1;
float y1;
float x2;
float y2;
float score;
bool operator <(const abox&tmp) const{
return score < tmp.score;
}
};
void nms(std::vector源文件common.cpp里，为了防止说找不到cv::Mat类型的错误，添加opencv头文件
#include在} // namespace caffe后添加：
namespace RPN{
cv::Mat bbox_tranform_inv(cv::Mat local_anchors, cv::Mat boxs_delta){
cv::Mat pre_box(local_anchors.rows, local_anchors.cols, CV_32FC1);
for (int i = 0; i < local_anchors.rows; i++)
{
double pred_ctr_x, pred_ctr_y, src_ctr_x, src_ctr_y;
double dst_ctr_x, dst_ctr_y, dst_scl_x, dst_scl_y;
double src_w, src_h, pred_w, pred_h;
src_w = local_anchors.at<float>(i, 2) - local_anchors.at<float>(i, 0) + 1;
src_h = local_anchors.at<float>(i, 3) - local_anchors.at<float>(i, 1) + 1;
src_ctr_x = local_anchors.at<float>(i, 0) + 0.5 * src_w;
src_ctr_y = local_anchors.at<float>(i, 1) + 0.5 * src_h;
dst_ctr_x = boxs_delta.at<float>(i, 0);
dst_ctr_y = boxs_delta.at<float>(i, 1);
dst_scl_x = boxs_delta.at<float>(i, 2);
dst_scl_y = boxs_delta.at<float>(i, 3);
pred_ctr_x = dst_ctr_x*src_w + src_ctr_x;
pred_ctr_y = dst_ctr_y*src_h + src_ctr_y;
pred_w = exp(dst_scl_x) * src_w;
pred_h = exp(dst_scl_y) * src_h;
pre_box.at<float>(i, 0) = pred_ctr_x - 0.5*pred_w;
pre_box.at<float>(i, 1) = pred_ctr_y - 0.5*pred_h;
pre_box.at<float>(i, 2) = pred_ctr_x + 0.5*pred_w;
pre_box.at<float>(i, 3) = pred_ctr_y + 0.5*pred_h;
}
return pre_box;
}
void nms(std::vector(6) 更改caffe/src/caffe/util/blocking_queue.cpp
增加一个头文件
#include "caffe/data_reader.hpp"其次，在最末尾处，将如下代码
template class BlockingQueue<Batch<float>*>;
template class BlockingQueue<Batch<double>*>;更改为：
template class BlockingQueue<Batch<float>*>;
template class BlockingQueue<Batch<double>*>;
template class BlockingQueue<Datum*>;
template class BlockingQueue<shared_ptr<DataReader::QueuePair> >;（7）重新生成caffe.pb.h
cd $caffe/include/caffe/
mkdir proto
cd $caffe/src/caffe/proto
protoc --cpp_out=$your_home/caffe/include/caffe/proto/ caffe.proto执行完后会在$caffe/include/caffe/proto/下生成2个文件，caffe.pb.h和caffe.pb.cc。
（8）编译caffe
make clean
make -j8
make pycaffe (不需要用python的可以不用，反正编译耗时也不长）（9）环境已经配置好了，现在我们再加个类，用来对图片进行检测吧！编写头文件ObjectDetector.hpp
#define OBJECTDETECTOR_H
#define INPUT_SIZE_NARROW 600
#define INPUT_SIZE_LONG 1000
#include （10） 源文件ObjectDetector.cpp
#include "ObjectDetector.hpp"
#include float> > input_layer = net_->blob_by_name("data");
input_layer->Reshape(1, normalized.channels(), height, width);
net_->Reshape();
float* input_data = input_layer->mutable_cpu_data();
vectorfloat> > bbox_delt_data = net_->blob_by_name("bbox_pred"); // 13949*84
shared_ptrfloat> > score = net_->blob_by_name("cls_prob"); // 3949*21
map<int,vector//################ 将类别i的所有检测框的打分，保存
if(objectScore!=NULL){ //################ 将类别i的所有检测框的打分，保存
vector<float> tmp(aboxes.size()); //对于 类别i，检测出的矩形框的得分
for(int ii=0;iiinsert(pair<int,vector<float> >(i,tmp));
}
}
return label_objs;
} 注意：更改之处：net_->Forward(); 更改为 net_->ForwardFrom(0)；
这里的函数返回的是一个map对象，每一个键（类别label），对应一个矩形框向量。比如，一个20类检测任务，而一张图片里有3个人（标签是1），和2辆车（标签是5），那函数会返回一个map，其中有两个键值对，键1对应的值是一个3维的矩形框向量，分别代表着3个人的矩形框；键5对应的值是一个2维的矩形框向量，分别代表的是2辆车的矩形框。同时，函数还接受一个可选参数，可以返回每个矩形框各自对应的置信度。
（11）写个主函数，测试下效果，首先更改下网络描述文件test.prototxt，因为我们不需要python层了，那我们打开这个文件，定位到 Python层，
layer {
name: 'proposal'
type: 'Python'
bottom: 'rpn_cls_prob_reshape'
bottom: 'rpn_bbox_pred'
bottom: 'im_info'
top: 'rois'
python_param {
module: 'rpn.proposal_layer'
layer: 'ProposalLayer'
param_str: "'feat_stride': 16"
}
} 把它修改为
layer {
name: "proposal"
type: "RPN"
bottom: "rpn_cls_prob_reshape"
bottom: "rpn_bbox_pred"
bottom: "im_info"
top: "rois"
rpn_param {
feat_stride : 16
basesize : 16
scale : 8
scale : 16
scale : 32
ratio : 0.5
ratio : 1
ratio : 2
boxminsize :16
per_nms_topn : 6000 #参照的blog这个参数设为0，和Python不一样，造成c++效果比python差很多。所以我更改为6000，按照原版python参数设置更改了
post_nms_topn : 300 #同上
nms_thresh : 0.7 #同上
}
} （12）编写主函数进行测试
#include "ObjectDetector.hpp"
#include
#include
#include
#include return ss.str();
}
// void drawRectOnImage(cv::Mat& im, Rect pos) {
// int thickness = 2;
// Scalar color(0, 0, 255);// color is blue.
// Mat overlay;
// im.copyTo(overlay);
// rectangle(overlay, pos, color, thickness);
// double alpha = 0.5;
// cv::addWeighted(overlay, alpha, im, 1 - alpha, 0, im);
// }
// voffset: vertical offset
int drawTextOnImage(cv::Mat& im, Rect pos, float voffset, string text) {
int fontFace = CV_FONT_HERSHEY_SIMPLEX; //FONT_HERSHEY_PLAIN;
double fontScale = 1.0;
int thickness = 0.5;
int baseline = 0;
Size textSize = getTextSize(text, fontFace, fontScale, thickness, &baseline);
Mat overlay;
im.copyTo(overlay);
rectangle(overlay, Point(pos.x, pos.y + voffset),
Point(pos.x + textSize.width, pos.y + textSize.height + thickness + voffset),Scalar(255, 128, 128), CV_FILLED);
Point textOrg(pos.x, pos.y + textSize.height + thickness + voffset);
cv::putText(overlay, text, textOrg,fontFace, fontScale, Scalar(255, 255, 255), thickness, LINE_AA);
double alpha = 0.75;
cv::addWeighted(overlay, alpha, im, 1 - alpha, 0, im);
return textSize.height + thickness;
}
int main(int argc,char **argv){
::google::InitGoogleLogging(argv[0]);
#ifdef CPU_ONLY
cout<<"Use CPU\n";
#else
cout<<"Use GPU\n";
#endif
ObjectDetector detect("test.prototxt", "xx.caffemodel");
long start_time = clock();
Mat img=imread("xx.jpg");
if (img.empty()) {
cout << "img is empty! " << endl;
return 1;
}
map<int,vector<float> > score;
map<int,vector// cout << j << endl;
// drawRectOnImage(img, rects[j]);
// cv::rectangle(overlay, rects[j], Scalar(255, 128, 128), CV_FILLED);
cout << rects[j] << endl;
cout << "score is " << score[label][j] << endl;
rectangle(img,rects[j],Scalar(0,0,255),2); //画出矩形框
switch (label){
case 1: label_str = "label1"; break;
case 2: label_str = "label2";break;
case 3: label_str = "label3";break;
default: label_str = ""; cout << "label_str is error!" << endl; return 1;
}
// string txt= label_str+ " : " + num2str(score[label][j]);
// putText(overlay,txt,Point(rects[j].x,rects[j].y),CV_FONT_HERSHEY_SIMPLEX,0.5,Scalar(255,0,0)); //标记 类别：置信度
// putText(overlay,txt,Point(rects[j].x,rects[j].y),CV_FONT_HERSHEY_SIMPLEX,0.8,Scalar(255,0,0)); //标记 类别：置信度
int offset = drawTextOnImage(img, rects[j], 0, label_str);
int margin = 5;
drawTextOnImage(img, rects[j], offset + margin, num2str(score[label][j]));
// Point textOrg(rects[j].x, rects[j].y - 1);
// cv::putText(overlay, txt, textOrg,
// CV_FONT_HERSHEY_PLAIN, 1.0, Scalar(255, 255, 255), 1, LINE_AA);
// double alpha = 0.75;
// cv::addWeighted(overlay, alpha, img, 1 - alpha, 0, img);
}
}
cout << "time is " << double(clock() - start_time) / double(CLOCKS_PER_SEC) << endl;
//imshow("detect", img);
waitKey();
return 0;
} 如果需要使用CPU，请在代码前 #define CPU_ONLY 一下。
（13）最后一步，编译
g++ -o demo.exe main.cpp ObjectDetector.cpp -I /home/*****/caffe/include/ -I /home/*****/caffe/.build_release/src/ -I /usr/local/cuda-8.0/include/ `pkg-config --libs --cflags opencv` -L /home/****/caffe/build/lib/ -lcaffe -lglog -lboost_system -lprotobuf 然后执行./demo.exe 就可以了
注意：这里为了方便，直接输出的标签号以及对应的置信度了。可以看出 ，飞机的的label为1，船的label是4，我们从python版的demo.py中可以证实这点：
CLASSES = ('__background__',
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor') 这个根据自己模型需求改改就行。label的顺序按照py-faster-rcnn/lib/datasets/pascal_voc.py的
self._classes = ('__background__', # always index 0
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor')顺序进行标签排序，’background‘为0，aeroplane为1，以此类推。
结果
1、我看很多评论说，c++版本比python要更吃显存，更耗时，但我自己测试的效果没有这种感觉，不用最新caffe其实耗时和python基本差不多。
2、感觉用最新的caffe会比Faster R-CNN老版caffe要快一丁点
3、1080ti上测试 一张图平均（600*1000）0.3s （新or老caffe都差不多）
可能出现的错误
（1） 找不到libcaffe.so.1.0.0-rc3
./app.bin: error while loading shared libraries: libcaffe.so.1.0.0-rc3: cannot open shared object file: No such file or directory解决办法：
在/etc/ld.so.conf.d/下新添加caffe.conf
$Home
sudo vi /etc/ld.so.conf.d/caffe.conf然后把libcaffe.so.1.0.0-rc3所在的caffe/build/lib/地址写进caffe.conf
最后不要忘记 sudo ldconfig 一下