caffe实现多标签分类：制作LMDB的方式

柔光的暖阳◎ 2022-02-23 09:03 225阅读 0赞

Caffe自带的图像转LMDB接口只支持单label，对于多label的任务，可以使用HDF5的格式，也可以通过修改caffe代码来实现，　我的文章Caffe 实现多标签分类　里介绍了怎么通过修改ImageDataLayer来实现Multilabel的任务，　本篇文章介绍怎么通过修改DataLayer来实现带Multilabel的ＬＭＤＢ格式数据输入的分类任务

１．　首先修改代码

修改下面的几个文件：

$CAFFE\_ROOT/src/caffe/proto/caffe.proto

$CAFFE\_ROOT/src/caffe/layers/data\_layer.cpp

$CAFFE\_ROOT/src/caffe/util/io.cpp

$CAFFE\_ROOT/include/caffe/util/io.hpp

$CAFFE\_ROOT/tools/convert\_imageset.cpp

(1) 修改　caffe.proto

在　message Datum \{ \}里添加用于容纳labels的一项

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70][]

repeated float labels = 8;

如果你的Label只有int类型，可以用　repeated int32 labels = 8;

(2) 修改　data\_layer.cpp

修改函数　DataLayerSetUp()

新的代码：

vector<int> label\_shape(2);  
label\_shape\[0\] = batch\_size;  
label\_shape\[1\] = datum.labels\_size();  
　　　代码修改前后，右边是修改后的代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 1][]

修改函数　　load\_batch()

新的代码：

int labelSize = datum.labels\_size();  
for(int i = 0; i < labelSize; i++)\{  
top\_label\[item\_id\*labelSize + i\] = datum.labels(i);  
\}  
代码修改前后，右边是修改后的代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 2][]

(3) 修改　io.hpp

新的代码

bool ReadFileToDatum(const string& filename, const vector<float> label, Datum\* datum);  
  
inline bool ReadFileToDatum(const string& filename, Datum\* datum) \{  
return ReadFileToDatum(filename, vector<float>(), datum);  
\}  
  
bool ReadImageToDatum(const string& filename, const vector<float> label,  
const int height, const int width, const bool is\_color,  
const std::string & encoding, Datum\* datum);  
  
inline bool ReadImageToDatum(const string& filename, const vector<float> label,  
const int height, const int width, const bool is\_color, Datum\* datum) \{  
return ReadImageToDatum(filename, label, height, width, is\_color,  
"", datum);  
\}  
  
inline bool ReadImageToDatum(const string& filename, const vector<float> label,  
const int height, const int width, Datum\* datum) \{  
return ReadImageToDatum(filename, label, height, width, true, datum);  
\}  
  
inline bool ReadImageToDatum(const string& filename, const vector<float> label,  
const bool is\_color, Datum\* datum) \{  
return ReadImageToDatum(filename, label, 0, 0, is\_color, datum);  
\}  
  
inline bool ReadImageToDatum(const string& filename, const vector<float> label,  
Datum\* datum) \{  
return ReadImageToDatum(filename, label, 0, 0, true, datum);  
\}  
  
inline bool ReadImageToDatum(const string& filename, const vector<float> label,  
const std::string & encoding, Datum\* datum) \{  
return ReadImageToDatum(filename, label, 0, 0, true, encoding, datum);  
\}  
代码修改前后，右边是修改后的代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 3][]

(4) 修改　io.cpp

修改函数　ReadImageToDatum()

修改后的代码

bool ReadImageToDatum(const string& filename, const vector<float> label,  
const int height, const int width, const bool is\_color,  
const std::string & encoding, Datum\* datum) \{  
cv::Mat cv\_img = ReadImageToCVMat(filename, height, width, is\_color);  
if (cv\_img.data) \{  
if (encoding.size()) \{  
if ( (cv\_img.channels() == 3) == is\_color && !height && !width &&  
matchExt(filename, encoding) )  
return ReadFileToDatum(filename, label, datum);  
std::vector<uchar> buf;  
cv::imencode("."+encoding, cv\_img, buf);  
datum->set\_data(std::string(reinterpret\_cast<char\*>(&buf\[0\]),  
buf.size()));  
  
datum->clear\_labels();  
for (int i = 0; i < label.size(); i++)\{  
datum->add\_labels(label\[i\]);  
\}  
datum->set\_encoded(true);  
return true;  
\}  
CVMatToDatum(cv\_img, datum);  
  
datum->clear\_labels();  
for (int i = 0; i < label.size(); i++)\{  
datum->add\_labels(label\[i\]);  
\}  
return true;  
\} else \{  
return false;  
\}  
\}  
代码修改前后，右边是修改后的代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 4][]

修改函数　ReadFileToDatum()

修改后的代码

bool ReadFileToDatum(const string& filename, const vector<float> label,  
Datum\* datum) \{  
std::streampos size;  
  
fstream file(filename.c\_str(), ios::in|ios::binary|ios::ate);  
if (file.is\_open()) \{  
size = file.tellg();  
std::string buffer(size, ' ');  
file.seekg(0, ios::beg);  
file.read(&buffer\[0\], size);  
file.close();  
datum->set\_data(buffer);  
  
datum->clear\_labels();  
for (int i = 0; i < label.size(); i++)\{  
datum->add\_labels(label\[i\]);  
\}  
datum->set\_encoded(true);  
return true;  
\} else \{  
return false;  
\}  
\}  
　　　代码修改前后，右边是修改后的代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 5][]

(5) 修改 convert\_imageset.cpp

修改部分新的代码

std::vector<std::pair<std::string, vector<float> > > lines;  
std::string line, filename;  
  
float label;  
while (std::getline(infile, line)) \{  
std::istringstream iss(line);  
iss >> filename;  
std::vector<float> labels;  
while(iss >> label) \{  
labels.push\_back(label);  
\}  
lines.push\_back(std::make\_pair(filename, labels));  
\}  
　　　代码修改前后，右边是修改后的代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 6][]

2. 编译代码

mark@ubuntu:~/caffe/build$ make all  
mark@ubuntu:~/caffe/build$ sudo make install

3. 生成ＬＭＤＢ文件

编译成功后，使用新生成的 convert\_imageset 将训练所用的图片转换成ＬＭＤＢ文件

将训练所用图片转换为ＬＭＤＢ文件

mark@ubuntu:~/caffe$ sudo ./build/tools/convert\_imageset -shuffle=true /home/mark/data/ /home/mark/data/train.txt ./examples/captcha/captcha\_train\_lmdb

/home/mark/data/　 是训练所用的图片所在的root目录  
/home/mark/data/train.txt　　记录每个训练图片文件的名称和标签，它的内容见下图，训练图片文件的名称和/home/mark/data/拼接起来是训练图片的绝对路径  
./examples/captcha/captcha\_train\_lmdb 是生成的lmdb文件所在目录

同样可以将测试图片转换成ＬＭＤＢ文件

mark@ubuntu:~/caffe$ sudo ./build/tools/convert\_imageset -shuffle=true /home/mark/data/ /home/mark/data/test.txt ./examples/captcha/captcha\_test\_lmdb

4. 网络结构和solver

网络结构文件　captcha\_train\_test\_lmdb.prototxt

name: "captcha"  
layer \{  
name: "Input"  
type: "Data"  
top: "data"  
top: "label"  
include \{  
phase: TRAIN  
\}  
transform\_param \{  
scale: 0.00390625  
\}  
data\_param \{  
source: "examples/captcha/captcha\_train\_lmdb"  
batch\_size: 50  
backend: LMDB  
\}  
\}

layer \{  
name: "Input"  
type: "Data"  
top: "data"  
top: "label"  
include \{  
phase: TEST  
\}  
transform\_param \{  
scale: 0.00390625  
\}  
data\_param \{  
source: "examples/captcha/captcha\_test\_lmdb"  
batch\_size: 20  
backend: LMDB  
\}  
\}

layer \{  
name: "slice"  
type: "Slice"  
bottom: "label"  
top: "label\_1"  
top: "label\_2"  
top: "label\_3"  
top: "label\_4"  
slice\_param \{  
axis: 1  
slice\_point:1  
slice\_point:2  
slice\_point:3  
\}  
\}

layer \{  
name: "conv1"  
type: "Convolution"  
bottom: "data"  
top: "conv1"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
convolution\_param \{  
num\_output: 20  
kernel\_size: 5  
stride: 1  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}  
layer \{  
name: "pool1"  
type: "Pooling"  
bottom: "conv1"  
top: "pool1"  
pooling\_param \{  
pool: MAX  
kernel\_size: 2  
stride: 2  
\}  
\}  
layer \{  
name: "conv2"  
type: "Convolution"  
bottom: "pool1"  
top: "conv2"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
convolution\_param \{  
num\_output: 50  
kernel\_size: 5  
stride: 1  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}  
layer \{  
name: "pool2"  
type: "Pooling"  
bottom: "conv2"  
top: "pool2"  
pooling\_param \{  
pool: MAX  
kernel\_size: 2  
stride: 2  
\}  
\}  
layer \{  
name: "ip1"  
type: "InnerProduct"  
bottom: "pool2"  
top: "ip1"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
inner\_product\_param \{  
num\_output: 500  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}  
layer \{  
name: "relu1"  
type: "ReLU"  
bottom: "ip1"  
top: "ip1"  
\}

layer \{  
name: "ip2"  
type: "InnerProduct"  
bottom: "ip1"  
top: "ip2"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
inner\_product\_param \{  
num\_output: 100  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}

layer \{  
name: "ip3\_1"  
type: "InnerProduct"  
bottom: "ip2"  
top: "ip3\_1"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
inner\_product\_param \{  
num\_output: 10  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}

layer \{  
name: "ip3\_2"  
type: "InnerProduct"  
bottom: "ip2"  
top: "ip3\_2"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
inner\_product\_param \{  
num\_output: 10  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}

layer \{  
name: "ip3\_3"  
type: "InnerProduct"  
bottom: "ip2"  
top: "ip3\_3"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
inner\_product\_param \{  
num\_output: 10  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}

layer \{  
name: "ip3\_4"  
type: "InnerProduct"  
bottom: "ip2"  
top: "ip3\_4"  
param \{  
lr\_mult: 1  
\}  
param \{  
lr\_mult: 2  
\}  
inner\_product\_param \{  
num\_output: 10  
weight\_filler \{  
type: "xavier"  
\}  
bias\_filler \{  
type: "constant"  
\}  
\}  
\}

layer \{  
name: "accuracy1"  
type: "Accuracy"  
bottom: "ip3\_1"  
bottom: "label\_1"  
top: "accuracy1"  
include \{  
phase: TEST  
\}  
\}  
layer \{  
name: "loss1"  
type: "SoftmaxWithLoss"  
bottom: "ip3\_1"  
bottom: "label\_1"  
top: "loss1"  
\}

layer \{  
name: "accuracy2"  
type: "Accuracy"  
bottom: "ip3\_2"  
bottom: "label\_2"  
top: "accuracy2"  
include \{  
phase: TEST  
\}  
\}  
layer \{  
name: "loss2"  
type: "SoftmaxWithLoss"  
bottom: "ip3\_2"  
bottom: "label\_2"  
top: "loss2"  
\}

layer \{  
name: "accuracy3"  
type: "Accuracy"  
bottom: "ip3\_3"  
bottom: "label\_3"  
top: "accuracy3"  
include \{  
phase: TEST  
\}  
\}  
layer \{  
name: "loss3"  
type: "SoftmaxWithLoss"  
bottom: "ip3\_3"  
bottom: "label\_3"  
top: "loss3"  
\}

layer \{  
name: "accuracy4"  
type: "Accuracy"  
bottom: "ip3\_4"  
bottom: "label\_4"  
top: "accuracy4"  
include \{  
phase: TEST  
\}  
\}  
layer \{  
name: "loss4"  
type: "SoftmaxWithLoss"  
bottom: "ip3\_4"  
bottom: "label\_4"  
top: "loss4"  
\}  
solver文件　captcha\_solver\_lmdb.prototxt  
\# The train/test net protocol buffer definition  
net: "examples/captcha/captcha\_train\_test\_lmdb.prototxt"  
\# test\_iter specifies how many forward passes the test should carry out.  
\# covering the full 9,800 testing images.  
test\_iter: 200  
\# Carry out testing every 200 training iterations.  
test\_interval: 200  
\# The base learning rate, momentum and the weight decay of the network.  
base\_lr: 0.001  
momentum: 0.9  
weight\_decay: 0.0005  
\# The learning rate policy  
lr\_policy: "inv"  
gamma: 0.0001  
power: 0.75  
\# Display every 100 iterations  
display: 100  
\# The maximum number of iterations  
max\_iter: 10000  
\# snapshot intermediate results  
snapshot: 5000  
snapshot\_prefix: "examples/captcha/captcha"  
\# solver mode: CPU or GPU  
solver\_mode: GPU

5. 开始训练  
mark@ubuntu:~/caffe$ sudo ./build/tools/caffe train --solver=examples/captcha/captcha\_solver\_lmdb.prototxt

训练完后，生成model文件： captcha\_iter\_10000.caffemodel

6. 用生成的model 文件进行测试

首先，需要一个deploy.prototxt文件，在captcha\_train\_test\_lmdb.prototxt的基础上修改，修改后保存为　captcha\_deploy\_lmdb.prototxt 内容如下

name: "captcha"

input: "data"  
input\_dim: 1 \# batchsize  
input\_dim: 3 \# number of channels - rgb  
input\_dim: 60 \# height  
input\_dim: 160 \# width

layer \{  
name: "prob1"  
type: "Softmax"  
bottom: "ip3\_1"  
top: "prob1"  
\}  
layer \{  
name: "prob2"  
type: "Softmax"  
bottom: "ip3\_2"  
top: "prob2"  
\}  
layer \{  
name: "prob3"  
type: "Softmax"  
bottom: "ip3\_3"  
top: "prob3"  
\}  
layer \{  
name: "prob4"  
type: "Softmax"  
bottom: "ip3\_4"  
top: "prob4"  
\}

编写测试代码：

import numpy as np    
    import os    
    import sys   
    os.environ['GLOG_minloglevel'] = '3'   
    import caffe    
        
    CAFFE_ROOT = '/home/mark/caffe'    
    deploy_file_name = 'captcha_deploy_lmdb.prototxt'    
    model_file_name  = 'captcha_iter_10000.caffemodel'   
      
    IMAGE_HEIGHT = 60  
    IMAGE_WIDTH = 160  
    IMAGE_CHANNEL = 3  
      
    def classify(imageFileName):  
        deploy_file = CAFFE_ROOT + '/examples/captcha/' + deploy_file_name    
        model_file  = CAFFE_ROOT + '/examples/captcha/' + model_file_name  
        #初始化caffe   
        net = caffe.Net(deploy_file, model_file, caffe.TEST)  
      
        #数据预处理      
        transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})      
        transformer.set_transpose('data', (2, 0, 1))#pycaffe读取的图片文件格式为H×W×C，需转化为C×H×W  
      
        #pycaffe将图片存储为[0, 1], 如果模型输入用的是0~255的原始格式,需要做如下转换  
        #transformer.set_raw_scale('data', 255)     
      
        transformer.set_channel_swap('data', (2, 1, 0))#caffe中图片是BGR格式，而原始格式是RGB，所以要转化   
      
        # 将输入图片格式转化为合适格式（与deploy文件相同）  
        net.blobs['data'].reshape(1, IMAGE_CHANNEL, IMAGE_HEIGHT, IMAGE_WIDTH)  
      
        #读取图片  
        #参数color: True(default)是彩色图，False是灰度图  
        img = caffe.io.load_image(imageFileName, color=True)  
      
        #数据输入、预处理  
        net.blobs['data'].data[...] = transformer.preprocess('data', img)  
      
        #前向迭代，即分类  
        out = net.forward()  
      
        #求出每个标签概率最大值的下标  
        result = []  
        predict1 = out['prob1'][0].argmax()  
        result.append(predict1)  
      
        predict2 = out['prob2'][0].argmax()  
        result.append(predict2)  
      
        predict3 = out['prob3'][0].argmax()  
        result.append(predict3)  
      
        predict4 = out['prob4'][0].argmax()  
        result.append(predict4)      
          
        return result  
              
    if __name__ == '__main__':  
      
       imgList = sys.argv[1:]  
       for captcha in imgList:  
           predict = classify(captcha)  
           print "captcha:", captcha, "  predict:", predict

原文：https://blog.csdn.net/sushiqian/article/details/78771546

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70]: /images/20220223/daf0aadcdbe64753bf944021adc10112.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 1]: /images/20220223/8877cb90f31845b3b8e32b753c0e2530.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 2]: /images/20220223/3d92cf31189f46da9536cb6ffe7c54cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 3]: /images/20220223/a5e5b587bb2d4cd3abe3fc9ae00b28d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 4]: /images/20220223/2eb40a64754446469676c3e3b972155a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 5]: /images/20220223/7dfdf982d788439cbd1e78244e204f63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmZWkxMDE_size_16_color_FFFFFF_t_70 6]: /images/20220223/cea58fb4c3f74538a93106c566acbfae.png