如何使用caffe进行简单的分类，有哪些方式

有两种方式圆册

使用c++的方式

在caffe根目录下的 examples/cpp-classification/ 文件夹下面，有个classification.cpp文件，就是用来分类的。当然编译后，放在/build/examples/cpp_classification/ 下面

我们就直接运行命令：

# sudo ./build/examples/cpp_classification/classification.bin \ models/bvlc_reference_caffenet/deploy.prototxt \ models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \ data/ilsvrc12/imagenet_mean.binaryproto \ data/ilsvrc12/synset_words.txt \ examples/images/cat.jpg

命令很长，用了很多的\符号来换行。可以看出，从第二衫碰行开始就是参数，每行一个，共需要4个参数

运行成功后，输出top-5结果：

---------- Prediction for examples/images/cat.jpg ----------0.3134 - "n02123045 tabby, tabby cat"0.2380 - "n02123159 tiger cat"0.1235 - "n02124075 Egyptian cat"0.1003 - "n02119022 red fox, Vulpes vulpes"0.0715 - "n02127052 lynx, catamount"

即有0.3134的概率为tabby cat, 有0.2380的概率为tiger cat ......

使用python的方式

运行这个文件必需两个参数，一个输入图片文件，一个输出结果文件。而且运行必须在python目录下。假设当前目录是caffe根目录，则运行：

# cd python# sudo python classify.py ../或腔谈examples/images/cat.jpg result.npy

1.下载好来自ImageNet的training和validation数据集合；分别存放在如下的格式：

/path/to/imagenet/train/n01440764/n01440764_10026.JPEG

/path/to/imagenet/val/ILSVRC2012_val_00000001.JPEG

2. 进行一些预处理 *** 作：

cd $CAFFE_ROOT/data/ilsvrc12/

./get_ilsvrc_aux.sh

3.训练数据和测试数据分别放在train.txt和val.txt中，里面有他们的文件和相对应的标签；

4. 最后作者把1000类的类名用0--999表示，他们相对应的类别名称则用synset_words.txt 来存储他们之间的映射。

5.作者提到怎么去是否应该先把图像都归一化到256*256中，作者提到用Mapreduce去加快这种过程；

也可以直接这么做：

for name in /path/to/imagenet/val/*.JPEGdo

convert -resize 256x256\! $name $name

Done

6.在 create_imagenet.sh中设置训练的参数，并在里面指定训练和测试的数据库路径，如果图像没有提前归一化到相同的大小，则需要加”RESIZE=true“，设置”GLOG_logtostderr=1 “表示迅和了亩袭盯可以参考更多的信息，

在执行 ./create_imagenet.sh 之后会有新的数据文件生成：

ilsvrc12_train_leveldb 和 ilsvrc12_val_leveldb

7. 因为模型需要我们减去图像的均值，所以我们需要计算图像均值，在工具

tools/compute_image_mean.cpp 实现了这种 *** 作，

或者可以直接用：

./make_imagenet_mean.sh 脚本来进行计算图像均值，并生成：

data/ilsvrc12/imagenet_mean.binaryproto 文件

8.定义网络的结构：imagenet_train_val.prototxt .

里面有两行指定了数据库和图像的路径

source: "ilvsrc12_train_leveldb"

mean_file:"../../data/ilsvrc12/imagenet_mean.binaryproto"

并且指定了 include { phase: TRAIN } or include { phase: TEST } .来区分训练和测试

9.关于输入层的不同：

训练数据中，，data项来自 ilsvrc12_train_leveldb 并且进行了随机镜像 *** 作，测试数据中data项来自于ilsvrc12_val_leveldb 而没有进行随机镜像 *** 作；

10.输出层的不同：

输出层都为 softmax_loss 层，在训练网络当中，用来计算损失函数，并且用来初始化BP过程，测试网络同样有一个第二个输出层，accuracy，它用来报告测试的精度，在训练的过程中，测试网络将实例化并且测试准确率，产成的命令行为：Test score #0: xxx and Test score #1: xxx 等。

11.运行网络，其中设置

每批batch为256个，运行450000次迭代，接近90次epoch；

每1000次迭代，就在用测试集进行测试；

设置初始的学习率为0.01，并且每100000次迭代中进行学习率下降，大概进行20次epoch；

每20次epoch就显示出一些数据信息；

网络训练的动量为0.9，权重衰减因子为0.0005，

每10000次迭代中，就生成当前状态的快照；

这些设置在 examples/imagenet/imagenet_solver.prototxt .中进行设置，并且同样我们需要指定文件的路径：

net: "imagenet_train_val.prototxt"

12.开始训练网络：

./train_imagenet.sh

13. 在K20中，每20个迭代花费36s，所以，一幅图像的一次前馈+反馈（FW+BW）大概需要7ms，前馈花费2.5ms，剩下的是反馈，

可以在 examples/net_speed_benchmark.cpp 中进行时间的查看；禅州

14.因为我们有保存了快照，所以我们可以通过

./resume_training.sh 来进行resume恢复，脚本caffe_imagenet_train_1000.solverstate 保留了要恢复的所有信息，

15.总结，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"

}

---