caffe接口中python代码和c++代码的转换

caffe使用别人训练好的模型

我觉得都是一样的套路，不管是python还是c++

掌握好步骤流程就行

加载网络结构流程

_1、设置gpu或者cpu模式

2、设置gpu设备号

3、加载网络结构，caffeModel和prototxt文件

4、处理输入图片，例如减去均值和归一化操作

5、前向传播

6、处理计算之后的结果_

#python代码
#ssd mobileNet检测图片

import numpy as np
import sys,os
import cv2
caffe_root = '/home/ssd/caffe/'
sys.path.insert(0, caffe_root + 'python')
import caffe
import time

net_file= 'deploy.prototxt'
caffe_model= 'tr.caffemodel'
test_dir = "/home/qwe/Desktop/12"

if not os.path.exists(caffe_model):
print("MobileNetSSD_deploy.affemodel does not exist,")
print("use merge_bn.py to generate it.")
exit()
caffe.set_mode_gpu()
caffe.set_device(0)
net = caffe.Net(net_file,caffe_model,caffe.TEST)

CLASSES = ('background', 'obj')

def preprocess(src):
img = cv2.resize(src, (512,256))
img = img - 127.5
img = img * 0.007843
return img

def postprocess(img, out):
h = img.shape[0]
w = img.shape[1]
box = out['detection_out'][0,0,:,3:7] * np.array([w, h, w, h])

cls = out['detection_out'][0,0,:,1]
conf = out['detection_out'][0,0,:,2]

return (box.astype(np.int32), conf, cls)

def detect(imgfile):
origimg = cv2.imread(imgfile)

img = preprocess(origimg)

img = img.astype(np.float32)
img = img.transpose((2, 0, 1))

start_time = time.time()
net.blobs['data'].data[...] = img
out = net.forward()
box, conf, cls = postprocess(origimg, out)
pro_time = time.time() - start_time
print('use time: ' + str(pro_time) + 's')

for i in range(len(box)):
p1 = (box[i][0], box[i][1])
p2 = (box[i][2], box[i][3])
cv2.rectangle(origimg, p1, p2, (0,255,0))
p3 = (max(p1[0], 15), max(p1[1], 15))
title = "%s:%.2f" % (CLASSES[int(cls[i])], conf[i])
cv2.putText(origimg, title, p3, cv2.FONT_ITALIC, 0.6, (0, 255, 0), 1)
cv2.imshow("SSD", origimg)

k = cv2.waitKey(0) & 0xff
#Exit if ESC pressed
if k == 27 : return False
return True

for f in os.listdir(test_dir):
if detect(test_dir + "/" + f) == False:
break

|——————————————————————————

|—–从上面的python代码中可以看出完整的加载模型流程

|—–而使用c++会有几点需要注意的地方

|——————————————————————————

//-------ssd.h

class Detector
{
public:
Detector(const string& model_file,const string& weights_file);

std::vector<std::vector<float> > Detect(const cv::Mat& _img);

private:
boost::shared_ptr<Net<float> > net_;
};

//------ssd.cpp

Detector::Detector(const string &model_file, const string &weights_file)
{
#ifdef CPU_ONLY
Caffe::set_mode(Caffe::CPU);
#else
Caffe::set_mode(Caffe::GPU);
#endif

/* Load the network. */
net_.reset(new Net<float>(model_file, TEST));
net_->CopyTrainedLayersFrom(weights_file);

}

std::vector<std::vector<float> >Detector::Detect(const cv::Mat &_img)
{
cv::Mat img = _img.clone();

Blob<float>* inputBlob = net_->input_blobs()[0];
int width = inputBlob->width();            //网络规定的输入图片的宽度和高度
int height = inputBlob->height();
cv::resize(img,img,cv::Size(width,height));//将测试图片进行调整大小
img.convertTo(img, CV_32FC3);   //转为浮点图
img = (img - 127.5) * 0.007843;

float* data = inputBlob->mutable_cpu_data();   //将图片的像素值，复制进网络的输入Blob
for (int k = 0; k<3; ++k){
for (int i = 0; i<height; ++i){
for (int j = 0; j<width; ++j){
int index = (k*height + i)*width + j;  //获取偏移量
data[index] = img.at<Vec3f>(i, j)[k];
}
}
}

vector<Blob<float>* > inputs(1, inputBlob);
//const vector<Blob<float>* >& outputBlobs = net_->Forward(inputs);   //进行前向传播，并返回最后一层的blob
const vector<Blob<float>* >& outputBlobs = net_->Forward();   //进行前向传播，并返回最后一层的blob

Blob<float>* outputBlob = outputBlobs[0];      //输出blob
const float* result = outputBlob->cpu_data();

vector<vector<float> > detections;
for (int i = 0; i<outputBlob->count(); ++i)       //将输出blob里的特征数值，拷贝到vector里并返回
{
if (result[0] == -1) {
// Skip invalid detection.
result += 7;
continue;
}
vector<float> detection(result, result + 7);
detections.push_back(detection);
result += 7;
}
return detections;
}

几个不同的地方

_1，将待测试图片加载进网络中

2，运算完成之后取出数据_

python中写法比较简单，按照套路直接写

加载待测图片

#python 代码
#----------------------------
#加载待测图片
origimg = cv2.imread(imgfile)
#将图片减去均值，归一化处理
img = cv2.resize(src, (512,256))
img = img - 127.5
img = img * 0.007843
#将图片转换成float类型
img = img.astype(np.float32)
img = img.transpose((2, 0, 1))
#将图片内容送进网络中进行前向传播
net.blobs['data'].data[...] = img
#前向传播
out = net.forward()

/*c++代码
-------------------------------------*/
//opencv 读取图片文件
cv::Mat img = cv::imread(fileName);

Blob<float>* inputBlob = net_->input_blobs()[0];
//网络规定的输入图片的宽度和高度
int width = inputBlob->width();
int height = inputBlob->height();
cv::resize(img,img,cv::Size(width,height));//将测试图片进行调整大小
img.convertTo(img, CV_32FC3);   //转为浮点图
img = (img - 127.5) * 0.007843; //减去均值，归一化图像
/*减均值也可以使用cv::subtract函数，例如：
cv::Mat mean(height,width,image.type(),cv::Scalar(102.9801,115,122.77);
cv::Mat normalized;
cv::subtract(image,mean,normalized);
*/
//------
//将图片加载进网络结构前向传播
float* data = inputBlob->mutable_cpu_data();  //将图片的像素值，复制进网络的输入Blob
for (int k = 0; k<3; ++k)
{
for (int i = 0; i<height; ++i){
for (int j = 0; j<width; ++j){
int index = (k*height + i)*width + j;  //获取偏移量
data[index] = img.at<Vec3f>(i, j)[k];
}
}
}
/*也可以写成下面的形式
std::vector<cv::Mat> input_channels;
float* input_data = inputBlob->mutable_cpu_data();
for (int i = 0; i < inputBlob->channels(); ++i)
{
cv::Mat channel(height, width, CV_32FC1, input_data);
input_channels->push_back(channel);
input_data += width * height;
}
cv::split(img, input_channels);
*/
//前向传播，直接取最后一层输出结果
const vector<Blob<float>* >& outputBlobs = net_->Forward();
//这样的写法要注意网络结构最后是否有多个分支，如果是多个分支，则会导致最后的结果将多个分支的结果融合在一起，不好区分。

从前向传播之后取最后的检测结果

#python代码
#------------------------
#out = net.forward()
h = img.shape[0] #待测图片的高
w = img.shape[1] #待测图片的宽
#取出out中的detection_out的blob中的数据，按照blob名字取数据。
#detection_out中的是包含7个float数据，从第4个到第7个分别代表位置坐标
#由于要还原到原来的图片中的实际位置，所以分别乘以原图中的宽高
box = out['detection_out'][0,0:3,7] * np.array([w,h,w,h)
cls = out['detection_out'][0,0,:,1] #第二个位置是分类结果
conf = out['detection_out'][0,0,:,2]#第三个位置是分类置信度

/*C++代码
----------------------------*/
const vector<Blob<float>* >& outputBlobs = net_->Forward();
Blob<float>* outputBlob = outputBlobs[0];      //输出blob
const float* result = outputBlob->cpu_data();

vector<vector<float> > detections;
//注意这里 outputBlob->count() 和 outputBlob->height()的数值也许是不一样的
for (int i = 0; i<outputBlob->count(); ++i)
{
if (result[0] == -1) {
// Skip invalid detection.
result += 7;
continue;
}
vector<float> detection(result, result + 7);
detections.push_back(detection);
result += 7;
}