如何在程序中调用Caffe做图像分类，调用caffe图像分类

Caffe是目前深度学习比较优秀好用的一个开源库，采样c++和CUDA实现，具有速度快，模型定义方便等优点。学习了几天过后，发现也有一个不方便的地方，就是在我的程序中调用Caffe做图像分类没有直接的接口。Caffe的数据层可以从数据库（支持leveldb、lmdb、hdf5）、图片、和内存中读入。我们要在程序中使用，当然得从内存中读入，我们首先在模型定义文件中定义数据层：

layers {

name: "mydata"

type: MEMORY_DATA

top: "data"

top: "label"

transform_param {

scale: 0.00390625

}

memory_data_param {

batch_size: 10

channels: 1

height: 24

width: 24

}

}

这里必须设置memory_data_param中的四个参数，对应这些参数可以参见源码中caffe.proto文件。现在，我们可以设计一个Classifier类来封装一下：

#ifndef CAFFE_CLASSIFIER_H

#define CAFFE_CLASSIFIER_H

#include <string>

#include <vector>

#include "caffe/net.hpp"

#include "caffe/data_layers.hpp"

#include <opencv2/core.hpp>

using cv::Mat

namespace caffe {

template <typename Dtype>

class Classifier {

public:

explicit Classifier(const string&param_file, const string&weights_file)

Dtype test(vector<Mat>&images, vector<int>&labels, int iter_num)

virtual ~Classifier() {}

inline shared_ptr<Net<Dtype>>net() { return net_}

void predict(vector<Mat>&images, vector<int>*labels)

void predict(vector<Dtype>&data, vector<int>*labels, int num)

void extract_feature(vector<Mat>&images, vector<vector<Dtype>>*out)

protected:

shared_ptr<Net<Dtype>>net_

MemoryDataLayer<Dtype>*m_layer_

int batch_size_

int channels_

int height_

int width_

DISABLE_COPY_AND_ASSIGN(Classifier)

}

}//namespace

#endif //CAFFE_CLASSIFIER_H

构造函数中我们通过模型定义文件（.prototxt）和训练好的模型（.caffemodel）文件构造一个Net对象，并用m_layer_指向Net中的memory data层，以便待会调用MemoryDataLayer中AddMatVector和Reset函数加入数据。

#include <cstdio>

#include <algorithm>

#include <string>

#include <vector>

#include "caffe/net.hpp"

#include "caffe/proto/caffe.pb.h"

#include "caffe/util/io.hpp"

#include "caffe/util/math_functions.hpp"

#include "caffe/util/upgrade_proto.hpp"

#include "caffe_classifier.h"

namespace caffe {

template <typename Dtype>

Classifier<Dtype>::Classifier(const string&param_file, const string&weights_file) : net_()

{

net_.reset(new Net<Dtype>(param_file, TEST))

net_->CopyTrainedLayersFrom(weights_file)

//m_layer_ = (MemoryDataLayer<Dtype>*)net_->layer_by_name("mnist").get()

m_layer_ = (MemoryDataLayer<Dtype>*)net_->layers()[0].get()

batch_size_ = m_layer_->batch_size()

channels_ = m_layer_->channels()

height_ = m_layer_->height()

width_ = m_layer_->width()

}

template <typename Dtype>

Dtype Classifier<Dtype>::test(vector<Mat>&images, vector<int>&labels, int iter_num)

{

m_layer_->AddMatVector(images, labels)

//

int iterations = iter_num

vector<Blob<Dtype>* >bottom_vec

vector<int>test_score_output_id

vector<Dtype>test_score

Dtype loss = 0

for (int i = 0i <iterations++i) {

Dtype iter_loss

const vector<Blob<Dtype>*>&result =

net_->Forward(bottom_vec, &iter_loss)

loss += iter_loss

int idx = 0

for (int j = 0j <result.size()++j) {

const Dtype* result_vec = result[j]->cpu_data()

for (int k = 0k <result[j]->count()++k, ++idx) {

const Dtype score = result_vec[k]

if (i == 0) {

test_score.push_back(score)

test_score_output_id.push_back(j)

} else {

test_score[idx] += score

}

const std::string&output_name = net_->blob_names()[

net_->output_blob_indices()[j]]

LOG(INFO) <<"Batch " <<i <<", " <<output_name <<" = " <<score

}

}

}

loss /= iterations

LOG(INFO) <<"Loss: " <<loss

return loss

}

template <typename Dtype>

void Classifier<Dtype>::predict(vector<Mat>&images, vector<int>*labels)

{

int original_length = images.size()

if(original_length == 0)

return

int valid_length = original_length / batch_size_ * batch_size_

if(original_length != valid_length)

{

valid_length += batch_size_

for(int i = original_lengthi <valid_lengthi++)

{

images.push_back(images[0].clone())

}

}

vector<int>valid_labels, predicted_labels

valid_labels.resize(valid_length, 0)

m_layer_->AddMatVector(images, valid_labels)

vector<Blob<Dtype>* >bottom_vec

for(int i = 0i <valid_length / batch_size_i++)

{

const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)

const Dtype * result_vec = result[1]->cpu_data()

for(int j = 0j <result[1]->count()j++)

{

predicted_labels.push_back(result_vec[j])

}

}

if(original_length != valid_length)

{

images.erase(images.begin()+original_length, images.end())

}

labels->resize(original_length, 0)

std::copy(predicted_labels.begin(), predicted_labels.begin() + original_length, labels->begin())

}

template <typename Dtype>

void Classifier<Dtype>::predict(vector<Dtype>&data, vector<int>*labels, int num)

{

int size = channels_*height_*width_

CHECK_EQ(data.size(), num*size)

int original_length = num

if(original_length == 0)

return

int valid_length = original_length / batch_size_ * batch_size_

if(original_length != valid_length)

{

valid_length += batch_size_

for(int i = original_lengthi <valid_lengthi++)

{

for(int j = 0j <sizej++)

data.push_back(0)

}

}

vector<int>predicted_labels

Dtype * label_ = new Dtype[valid_length]

memset(label_, 0, valid_length)

m_layer_->Reset(data.data(), label_, valid_length)

vector<Blob<Dtype>* >bottom_vec

for(int i = 0i <valid_length / batch_size_i++)

{

const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)

const Dtype * result_vec = result[1]->cpu_data()

for(int j = 0j <result[1]->count()j++)

{

predicted_labels.push_back(result_vec[j])

}

}

if(original_length != valid_length)

{

data.erase(data.begin()+original_length*size, data.end())

}

delete [] label_

labels->resize(original_length, 0)

std::copy(predicted_labels.begin(), predicted_labels.begin() + original_length, labels->begin())

}

template <typename Dtype>

void Classifier<Dtype>::extract_feature(vector<Mat>&images, vector<vector<Dtype>>*out)

{

int original_length = images.size()

if(original_length == 0)

return

int valid_length = original_length / batch_size_ * batch_size_

if(original_length != valid_length)

{

valid_length += batch_size_

for(int i = original_lengthi <valid_lengthi++)

{

images.push_back(images[0].clone())

}

}

vector<int>valid_labels

valid_labels.resize(valid_length, 0)

m_layer_->AddMatVector(images, valid_labels)

vector<Blob<Dtype>* >bottom_vec

out->clear()

for(int i = 0i <valid_length / batch_size_i++)

{

const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)

const Dtype * result_vec = result[0]->cpu_data()

const int dim = result[0]->count(1)

for(int j = 0j <result[0]->num()j++)

{

const Dtype * ptr = result_vec + j * dim

vector<Dtype>one_

for(int k = 0k <dim++k)

one_.push_back(ptr[k])

out->push_back(one_)

}

}

if(original_length != valid_length)

{

images.erase(images.begin()+original_length, images.end())

out->erase(out->begin()+original_length, out->end())

}

}

INSTANTIATE_CLASS(Classifier)

} // namespace caffe

由于加入的数据个数必须是batch_size的整数倍，所以我们在加入数据时采用填充的方式。

CHECK_EQ(num % batch_size_, 0) <<

"The added data must be a multiple of the batch size." //AddMatVector

在模型文件的最后，我们把训练时的loss层改为argmax层：

layers {

name: "predicted"

type: ARGMAX

bottom: "prob"

top: "predicted"

}

一、问题

在成功编译caffe的源码之后，可以在Python环境中使用caffe。

在Ubuntu环境下，打开python解释程序，输入import caffe时：出现以下错误

>>>import caffe

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ImportError: No module named caffe

二、解决思路

基本思路是把caffe中的python导入到解释器中

三、解决方法

第一种方法：设置环境变量

在终中输入：

export PYTHONPATH=~/caffe/python #caffe的路径下面的python

则该终端起作用，关掉终端后或重新打开一终端，则失效。

放到配置文件中，可以永久有效果，命令 *** 作如下：

A.把环境变量路径放到 ~/.bashrc文件中

sudo echo export PYTHONPATH="~/caffe/python" >>~/.bashrc

B.使环境变量生效

source ~/.bashrc

第二种方法：通过代码来实现

在每个python代码中使用以下代码： (这个方法在写python代码时有用)

caffe_root = '~/caffe/python '

import sys

sys.path.insert(0, caffe_root + 'python')

import caffe

1) 输入归一化 x_norm = (x-u)/std, 其中u和std是个累计计算的均值和方差。

2）y=alpha×x_norm + beta，对归一化后的x进行比例缩放和位移。其中alpha和beta是通过迭代学习的。

那么caffe中的bn层其实只做了第一件事，scale层做了第二件事，所以两者要一起使用。

一，在Caffe中使用Batch Normalization需要注意以下两点：

1. 要配合Scale层一起使用。

2. 训练的时候，将BN层的use_global_stats设置为false，然后测试的时候将use_global_stats设置为true。

二，基本公式梳理：

Scale层主要完成 top=alpha∗bottom+betatop=alpha∗bottom+beta的过程，则层中主要有两个参数alphaalpha与betabeta,

求导会比较简单。∂y∂x=alpha∂y∂alpha=x∂y∂beta=1。 需要注意的是alphaalpha与betabeta均为向量，针对输入的channelschannels进行的处理，因此不能简单的认定为一个floatfloat的实数。

三，具体实现该部分将结合源码实现解析scalescale层:

在Caffe proto中ScaleParameter中对Scale有如下几个参数：

1，基本成员变量，基本成员变量主要包含了Bias层的参数以及Scale层完成对应通道的标注工作。

2，基本成员函数，主要包含了LayerSetup,Reshape ,Forward和Backward ，内部调用的时候bias_term为true的时候会调用biasLayer的相关函数。

3，Reshape 调整输入输出与中间变量，Reshape层完成许多中间变量的size初始化。

4，Forward 前向计算，前向计算，在BN中国紧跟着BN的归一化输出，完成乘以alpha与+bias的 *** 作，由于alpha与bias均为C的向量，因此需要先进行广播。

5，Backward 反向计算，主要求解三个梯度，对alpha 、beta和输入的bottom(此处的temp)。

---