使用caffe训练一个多标签分类/回归模型
前言
这篇博客和上一篇性质差不多，都是旨在说明使用caffe训练图像分类模型的大概流程。不同的是，上篇博客讲的单标签图像分类问题，顾名思义，其输入和输出都是单标签或者可以说是单类别的，而此篇则把重点放在如何处理多标签分类/回归问题的输入和输出上。多标签分类/回归问题和单标签的工作流程比较类似，大致分为以下几个步骤，然后本博客再对各个环节做进一步解释。
- 准备数据（图像整理好放到合适的文件夹中，对应的ground-truth整理到一个txt中）。
- 编写用于模型输入的代码（使用python data layer来读取图片和label）。
- 网络模型的定义/编辑（从头编写或修改prototxt文件）。
- Solver的定义/编辑（solver是caffe用来训练网络的一个类似配置文件的东西）。
- 进行网络模型的训练与测试。
可以看出，此博客和上一篇在流程上的区别主要集中在第二步。博客写作时，caffe还不支持将含有多标签ground-truth的txt文件直接转换成LMDB文件。虽然仍然可以使用LMDB的格式，但是需要分别将图片和label放到两个LMDB文件中，操作略复杂，而caffe官网上比较推荐的一种方式是使用python data layer来直接读取图片和label，故本文也采用了这种形式。
准备数据
这一步先按一定的比例、一定的划分策略将数据集划分为训练集、验证集（根据具体情况可有可无）和测试集，如果要在使用caffe前手动地进行数据预处理或数据增强，尽量在数据集划分之前完成。数据划分好之后，对应的还要有标有ground-truth的txt文件，大致如下图所示：
文件的每一行代表一个样本，一行中第一项是图片的名称（名称前还可以有路径），后面是类别标签，具体的任务包含几类图像就对应着有多少个标签，每个标签都是非0即1的，0代表当前图片不属于这个标签，1则相反。图片名称以及各个标签之间以空格间隔。
编写用于模型输入的代码
这一步是这篇博客的重点。caffe自带的例子中也包含了使用python data layer来处理多标签输入的情况。我们更改一下例子给出的源文件大致即可实现自己的需求。首先，找到”caffe_root”/examples/pycaffe/layers/pascal_multilabel_datalayers.py，这个文件就是用于处理多标签输入的代码。此例子是关于PASCAL VOC 2012数据集上的多标签分类任务的，样本情况大致如下所示：
对应的ground-truth里除了有物体类别标签，还有各物体在图片中对应的bounding box，如果读者的任务和该例子相似，可以仔细研究下这份代码。本人的工作虽然也是处理多标签问题，但是是研究天气识别的，和这个例子略有不同，ground-truth中只有类别标签而已，所以对代码做了一定的修改，其实是变简单了。下面来看一下代码，先贴出全部代码，然后再主要讲一些需要修改的部分。
import scipy.misc
import caffe
import numpy as np
import os.path as osp
from random import shuffle
from PIL import Image
from tools import SimpleTransformer
class WeatherMultilabelDataLayerSync(caffe.Layer):
"""
This is a simple syncronous datalayer for training a multilabel model on
weather dataset.
"""
def setup(self, bottom, top):
self.top_names = ['data', 'label']
# === Read input parameters ===
# params is a python dictionary with layer parameters.
params = eval(self.param_str)
# Check the paramameters for validity.
check_params(params)
# store input as class variables
self.batch_size = params['batch_size']
# Create a batch loader to load the images.
self.batch_loader = BatchLoader(params, None)
# === reshape tops ===
# since we use a fixed input image size, we can shape the data layer
# once. Else, we'd have to do it in the reshape call.
top[0].reshape(
self.batch_size, 3, params['im_shape'][0], params['im_shape'][1])
top[1].reshape(self.batch_size, 7)
print_info("WeatherMultilabelDataLayerSync", params)
def forward(self, bottom, top):
"""
Load data.
"""
for itt in range(self.batch_size):
# Use the batch loader to load the next image.
im, multilabel = self.batch_loader.load_next_image()
# Add directly to the caffe data layer
top[0].data[itt, ...] = im
top[1].data[itt, ...] = multilabel
def reshape(self, bottom, top):
"""
There is no need to reshape the data, since the input is of fixed size
(rows and columns)
"""
pass
def backward(self, top, propagate_down, bottom):
"""
These layers does not back propagate
"""
pass
class BatchLoader(object):
"""
This class abstracts away the loading of images.
Images can either be loaded singly, or in a batch. The latter is used for
the asyncronous data layer to preload batches while other processing is
performed.
"""
def __init__(self, params, result):
self.result = result
self.batch_size = params['batch_size']
self.weather_root = params['weather_root']
self.im_shape = params['im_shape']
if params['split'] == 'train':
self.isshuffle = True
self.iscenter = False
self.isflip = True
else:
self.isshuffle = False
self.iscenter = True
self.isflip = False
# get list of image indexes.
self.floder = 'weather_' + params['split'] + '/' #data folder
list_file = params['split'] + '.txt'
self.indexlist = [line.rstrip('\n') for line in open(
osp.join(self.weather_root, list_file))]
#osp.join(self.weather_root, 'MultiLabel/', list_file))]
self._cur = 0 # current image
# this class does some simple data-manipulations
self.transformer = SimpleTransformer(center=self.iscenter)
# At the beginning, shuffle the train data
if self.isshuffle:
shuffle(self.indexlist)
print "BatchLoader initialized with {} images".format(
len(self.indexlist))
def load_next_image(self):
"""
Load the next image in a batch.
"""
# Did we finish an epoch?
if self._cur == len(self.indexlist):
self._cur = 0
if self.isshuffle:
shuffle(self.indexlist)
# Load an image
rowdata = self.indexlist[self._cur] # Get the rowdata
rowdata = rowdata.split()
image_file_name = rowdata[0]
im = np.asarray(Image.open(
osp.join(self.weather_root, self.floder, image_file_name)))
im = scipy.misc.imresize(im, [256, 256]) # resize
# do a simple horizontal flip as data augmentation
if self.isflip:
flip = np.random.choice(2)*2-1
im = im[:, ::flip, :]
# Load and prepare ground truth
multilabel = np.zeros(7).astype(np.float64)
for j in range(7):
multilabel[j] = np.float64(rowdata[j+1])
self._cur += 1
return self.transformer.preprocess(im), multilabel
def check_params(params):
"""
A utility function to check the parameters for the data layers.
"""
assert 'split' in params.keys(
), 'Params must include split (train, val, or test).'
required = ['batch_size', 'weather_root', 'im_shape']
for r in required:
assert r in params.keys(), 'Params must include {}'.format(r)
def print_info(name, params):
"""
Ouput some info regarding the class
"""
print "{} initialized for split: {}, with bs: {}, im_shape: {}.".format(
name,
params['split'],
params['batch_size'],
params['im_shape'])
代码修改
在setup函数中，有一个地方需要注意：
top[0].reshape(self.batch_size, 3, params['im_shape'][0],params['im_shape'][1])
# Note the 20 channels (because PASCAL has 20 classes.)
top[1].reshape(self.batch_size, 20)这是例子中的代码，top[0]中存储的是batch_size幅图像，而top[1]中则存储对应的标签。注释中也说了，因为这个PASCAL数据集中包含20类，所以就有了第二句代码的由来。而我的任务中有7类，所以top[1]这个地方就要改一改。
top[1].reshape(self.batch_size, 7)另外，紧随top[1]这句代码之后的是一句提示信息，最好也改成和自己任务对应的输出：
print_info("PascalMultilabelDataLayerSync", params) print_info("WeatherMultilabelDataLayerSync", params)
接下来，forward函数不用修改，而reshape与backward函数本身就没有函数体，也不用处理。
然后，BatchLoader这个类中有一些需要更改的地方，首先在 __init__ 函数中，数据的根目录变量最好改一下：
self.weather_root = params['weather_root']这个变量和字符串虽不代表真正的路径，但还是改为和自己任务相关的名称比较好。至于具体的路径是在网络结构定义的prototxt文件中指定的，这个在下一个大步骤中还会再次提到。
往下看是本人为了达到一定目的而加的一小段代码：
if params['split'] == 'train':
self.isshuffle = True
self.iscenter = False
self.isflip = True
else:
self.isshuffle = False
self.iscenter = True
self.isflip = False由于我的数据之前并没有手动地进行shuffle，所以这里针对训练集要处理一下。另外，为了进行一定的数据增强，如果是训练集，就进行随机地裁剪而不是裁图片的正中央，并且也会实施随机地镜像翻转。而对于测试集和验证集来说，这些条目则恰好相反。代码中变量的名字和意义都非常好理解，就不再赘述了。
我的训练、验证和测试用的数据是用三个文件夹分别存放的，所以又加了一个变量来准确定位到不同的数据：
self.floder = 'weather_' + params['split'] + '/' #data folder再往下是打开存有label信息的txt文件的代码，这里的路径需要改一下：
self.indexlist = [line.rstrip('\n') for line in open(osp.join(self.weather_root, list_file))]注意改成自己的目录变量名。
self.transformer = SimpleTransformer(center=self.iscenter)这句是创建一个用于图像变换的对象，而对应的类是在其他文件中定义的，为了实现自己的图像变换，我对这个类也做了修改，具体内容一会就会讲到。
前面提到要对数据进行shuffle，以下两句就是具体代码，非常简单，调一下shuffle函数就OK了。
if self.isshuffle:
shuffle(self.indexlist)再来看load_next_iamge函数，一上来先是对遍历数据时索引的处理：
if self._cur == len(self.indexlist):
self._cur = 0
if self.isshuffle:
shuffle(self.indexlist)当索引已经到了txt文件的末尾时，则把它重新置零，以便进行新一轮的迭代。除此之外，还要再做一步操作，就是对训练集进行了再一次的shuffle，避免每次迭代都是一样的数据顺序。
接着是实际读取数据的代码：
rowdata = self.indexlist[self._cur] # Get the rowdata
rowdata = rowdata.split()
image_file_name = rowdata[0]
im = np.asarray(Image.open(
osp.join(self.weather_root, self.floder, image_file_name)))
im = scipy.misc.imresize(im, [256, 256])先是读取txt文件的一行，然后就按空格对读取的数据进行分割。分割后的第一个数据就是图像名字，接着结合数据的根目录以及数据集的文件夹把图像读到Numpy的一个array中。由于图片大小不一，还要对所有图片统一先resize一下，resize的大小是本工作所用到的AlexNet约定俗成的参数。
然后就是为了数据增强而进行的随机翻转：
if self.isflip:
flip = np.random.choice(2)*2-1
im = im[:, ::flip, :]最后是读取label的代码，顺便对调用__init__ 函数中创建的transformer对象对图像进行一定的变换：
multilabel = np.zeros(7).astype(np.float64)
multilabel[:] = rowdata[1:]
self._cur += 1
return self.transformer.preprocess(im), multilabel该python文件中最后两个check_params和print_info函数都不用做任何修改。
对图像转换函数的修改
之后再来看一下定义图像变换函数的相关代码，找到”caffe_root”/examples/pycaffe/tools.py文件，同样先贴出全部代码，其实该文件中还有一个用于定义solver的类，这里就不讲了，solver文件可以直接对文件修改，没必要代码生成。
import numpy as np
class SimpleTransformer:
"""
SimpleTransformer is a simple class for preprocessing and deprocessing
images for caffe.
"""
def __init__(self, center=False):
mean=
np.load('/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Data/
mean.npy')
center_mean =
np.load('/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Data/
center_mean.npy')
self.mean = mean.transpose((1,2,0))
self.center_mean = center_mean.transpose((1,2,0))
self.scale = 1.0
self.center=center
def set_mean(self, mean):
"""
Set the mean to subtract for centering the data.
"""
self.mean = mean
def set_scale(self, scale):
"""
Set the data scaling.
"""
self.scale = scale
def crop(self, im, cropx=227, cropy=227):
## the image has the HWC channel order
y,x,_ = im.shape
if self.center:
startx = x//2-(cropx//2)
starty = y//2-(cropy//2)
else:
startx, starty = np.random.randint(0,29), np.random.randint(0,29)
return im[starty:starty+cropy,startx:startx+cropx,:]
def preprocess(self, im):
"""
preprocess() emulate the pre-processing occuring in the vgg16 caffe
prototxt.
"""
im = np.float64(im)
im = im[:, :, ::-1] # change to BGR
im -= self.mean
im = self.crop(im)
im *= self.scale
im = im.transpose((2, 0, 1))
return im
def deprocess(self, im):
"""
inverse of preprocess()
"""
im = im.transpose(1, 2, 0)
im /= self.scale
im += self.center_mean
im = im[:, :, ::-1] # change to RGB
return np.uint8(im)使用caffe训练网络时，数据的格式跟普通RGB图像的通道顺序不一样，所以需要我们手动地更改一下。而在上一篇讲单标签分类任务的博客中，数据是用caffe提供的工具转换成了LMDB文件，其中就包含了这些操作。在tools.py文件中，最主要的是preprocess函数，它包含了对图像所有的变换：
im = im[:, :, ::-1] # change to BGR
im -= self.mean
im = self.crop(im)
im *= self.scale
im = im.transpose((2, 0, 1))具体的，先转换成BGR的通道顺序，再减去训练集上计算出的均值，接着对图像进行裁剪，得到227*227的用于AlexNet输入的图片大小。乘scale这一句在本工作中其实没用到，因为scale的大小设为了1，可能对其他一些任务，scale可以设成不同的值。最后是对图像进行一下转置变换，也是为了应对caffe的要求。其中的均值mean是在__init__ 函数中设定好的：
mean = np.load('/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Data/mean.npy')需要注意的是，上篇博客中，利用caffe提供的脚本生成的均值文件是mean.
binaryproto文件，这里要用另一段代码将其转换成npy文件，以便进行Numpy数组间的计算，转换代码如下：
def convert(binaryproto='/home/wzg/caffe-master/data/weather/weather_mean.binaryproto',savepath='/home/wzg/caffe-master/data/weather/mean'):
blob = caffe.proto.caffe_pb2.BlobProto()
data = open(binaryproto, 'rb' ).read()
blob.ParseFromString(data)
arr = np.array(caffe.io.blobproto_to_array(blob))
out = arr[0]
np.save(savepath, out)其实也是利用了caffe提供的工具对mean.binaryproto文件进行了解析并将其转换成Numpy的array。
对图像的裁剪定义在crop函数中，操作还是比较简单的，就不详细解释了，只是相对于源代码来说，我特地区分了训练集和测试集的裁剪方式，一个是在图像内随机裁剪，一个是在中心裁剪。
在__init__ 函数中，除了读取mean.npy文件，我还读取了一个center_mean.npy文件，这个center_mean是为在deprocess函数中做图像反变换而生成的。反变换时，图像要加均值，但是网络中的数据已经是227*227大小了（反变换并不会把图像再变回256*256，因为网络中输入的就是227*227的图像），所以对应的均值矩阵的长宽也应该是227*227，这就需要对生成的mean.npy用crop函数做一下中心裁剪（由于训练集是随机裁剪的，并不能恢复回来，这里只对测试数据进行反变换），然后保存起来。另外读取均值文件后初始化时也要对其转置一下。
deprocess函数是为了在测试时方便显示出测试图像和对应的识别结果，达到一种直观的目的。如不需要这样的效果，完全可以不用定义这个函数，也不用再额外生成center_mean文件。
到此为止，关于网络输入的代码部分就讲完了，然后就是对网络结构定义文件的修改了。
网络模型的定义/编辑
相比于单标签分类任务，多标签的网络结构定义文件主要有两个地方需要更改，一个就是数据输入层：
layer {
name: "data"
type: "Python"
top: "data"
top: "label"
python_param {
module: "weather_multilabel_datalayers"
layer: "WeatherMultilabelDataLayerSync"
param_str: "{\'im_shape\': [227, 227], \'split\': \'train\',
\'batch_size\': 50, \'weather_root\':
\'/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Data/\'}"
}
}使用python data layer读取数据的话，相较于LMDB文件，网络定义的数据层没有了transform_param和data_param，取而代之的是python_param。python_param中，module项对应的是处理多标签输入的文件的名字（这里我的文件名为weather_multilabel_datalayers.py），layer项对应的是文件中的类名（class WeatherMultilabelDataLayerSync(caffe.Layer)），可以看到它是继承了caffe.Layer这个基类的。要使用这个文件以及之前提到的用于图像变换的tools.py文件还需要在自己用于训练网络的python文件中把相关路径加到系统路径中去：
import sys
sys.path.append(caffe_root+"examples/pycaffe")
sys.path.append(caffe_root+"examples/pycaffe/layers")
import tools数据层中接下来的param_str中定义了一些参数，这些参数会传给WeatherMultilabelDataLayerSync做处理，参数内容都很好理解。其中split就是为区分不同数据集加的一个变量，weather_root是数据存放的根目录，其下有含label信息的txt文件和装有图片数据的文件夹，情况如下：
读者完全可以根据自己的需求组织文件结构，不过在处理输入的文件中就需要做一定的更改了。另外，在数据层的定义中要特别注意其中含有很多反斜杠，应该是为了转义吧。
除了手动更改定义网络的prototxt文件，也可以写代码生成此文件，这里就不讲了，感兴趣者可以参考caffe官网给出的关于多标签分类的例子。
第二个要改的地方是loss层，单标签分类任务中，比较常用的loss函数是softmax loss function，而softmax loss的目的是从多类中选一类，正好适合单标签问题。对于多标签分类任务来说，SigmoidCrossEntropyLoss是比较合适的，因为它能独立地对多个标签进行预测，并且这个loss函数也是caffe已经实现好的。网络定义中的loss层如下：
layer {
name: "loss"
type: "SigmoidCrossEntropyLoss"
bottom: "score"
bottom: "label"
top: "loss"
}score是输出层的名字，label是输入层两个名字中的一个，另一个是data。这都比较好理解，loss函数就是将网络输出和ground-truth标签做比较，然后计算loss。
我在网络定义中，把accuracy也删除了，多标签的accuracy和单标签是不一样的，之后可以单独写代码来进行统计。我在这一大步骤中讲的主要是针对单标签分类任务的修改，而对于输出单元个数以及其他参数的说明可以参考我的上一篇博客。
Solver的定义/编辑
其实，多标签的solver和单标签的并没有什么区别，同样参考本人上篇博客就能有一个大概的了解，这里还是把相应的solver文件贴一下：
base_lr: 0.001
display: 100
gamma: 0.1
iter_size: 1
lr_policy: "step"
stepsize: 5000
max_iter: 10000
momentum: 0.9
snapshot: 5000
snapshot_prefix: "/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Snapshot/caffe_weather_train"
test_interval: 200
test_iter: 20
test_net: "/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Files/valnet.prototxt"
train_net: "/root/wangzhignag/WeatherRecognition/Modified/MultiLabel/Files/trainnet.prototxt"
weight_decay: 0.0005
solver_mode: GPU主要就是把train_net、test_net定义文件的路径改一下，snapshot_prefix改一下。不特别指定优化算法，默认就是随机梯度下降方法。如果采用其他优化算法的话，一定注意会有一些特定的参数需要指定，请查阅其他资料进行了解。
网络模型的训练与测试
先来看两个跟计算准确率相关的函数：
def hamming_distance(gt, est):
return sum([1 for (g, e) in zip(gt, est) if g == e]) / float(len(gt))这个函数虽然叫hamming_distance，但是和真正的海明距离是不一样的。从函数体中可以看出，这个函数就是计算了两个向量中，各个位置标签相同的次数占向量总长的一个比例。这个函数是为后面真正计算准确率做服务的。
def check_accuracy(net, num_batches, batch_size = 50):
acc = 0.0
for t in range(num_batches):
net.forward()
gts = net.blobs['label'].data
ests = net.blobs['score'].data > 0
for gt, est in zip(gts, ests): #for each ground truth and
estimated label vector
acc += hamming_distance(gt, est)
return acc / (num_batches * batch_size)从函数名就可以看出，此函数是计算分类准确率的。方法也很简单直观，就是让网络模型在测试集上跑一遍，然后不断累加之前定义的hamming_distance，最后求一个平均就OK了。
最后就是训练网络的run_solver函数了，其实这个函数和上篇博客中单标签任务的run_solver十分相似，这里就简单地贴一下代码：
def run_solvers(niter, solver, disp_interval=100, test_interval=200,
test_iter=20):
fig1,ax1=plt.subplots() #used for draw
fig2,ax2=plt.subplots() #used for draw
train_loss=np.zeros(np.ceil(niter*1.0/disp_interval))
test_acc=np.zeros(np.ceil(niter*1.0/test_interval))
atom_train_loss = 0
train_count, test_count = 0, 0
for it in range(1, niter+1):
solver.step(1)
atom_train_loss += solver.net.blobs['loss'].data
if it % disp_interval == 0:
train_loss[train_count] = atom_train_loss/disp_interval
atom_train_loss=0
print '\n##########%d iteration train: loss=%.3f\n' %(it,
train_loss[train_count])
train_count += 1
if it % test_interval == 0:
test_acc[test_count] = check_accuracy(solver.test_nets[0],
num_batches=20)
print '##########%d iteration Test: accuracy=%.3f\n' %(it,
test_acc[test_count])
test_count += 1
################## Draw
ax1.cla()
ax1.set_title('Display Loss')
ax1.set_xlabel('Iteration/100')
ax1.set_ylabel('Loss')
ax1.set_xlim(0,100)
ax1.grid()
ax1.plot(train_loss[:train_count],'r',label='train loss')
ax1.legend(loc='best')
ax2.cla()
ax2.set_title('Display Accuracy')
ax2.set_xlabel('Iteration/100')
ax2.set_ylabel('Accuracy')
ax2.set_xlim(0,100)
ax2.grid()
ax2.plot(range(0,test_count*2,2),
test_acc[:test_count],'g',label='test accuracy')
ax2.legend(loc='best')
plt.pause(1)
return train_loss, test_acc其实训练还是依靠solver的step()函数进行前向传播计算loss和后向传播计算梯度，然后再进行参数更新。不同于上篇博客里的run_solver函数，这里在测试阶段用到了刚刚定义的check_accuracy函数来计算测试集上的识别准确率。这里没有对测试集统计loss，也没有对训练集统计accuracy，因为整个跑一遍训练集的accuracy时间还是比较长的。不过，读者若是倾向于完备地输出这些数据，只要稍作修改也是完全可以实现的。
对于多标签分类任务，到此为止，基本上整个流程就讲完了，读者如果有不同的需求，可以在每个环节进行一定的修改。另外，多标签回归任务的处理其实和多标签分类任务非常像，流程都是一样的。只不过ground-truth不再是01标签，而是一系列连续的值，这个需要在第一步准备数据时就整理好。还有一点就是网络中的loss函数，此时SigmoidCrossEntropyLoss已经不能胜任多标签的回归任务，我们希望预测值和ground-truth越接近越好，EuclideanLoss是个合适的选择，它计算的是两个向量间的欧氏距离。最后，多标签回归问题也没有准确率而言了，EuclideanLoss可以直接作为评价标准，另外MSE(均方误差)也可以用来评测结果的好坏，实际上EuclideanLoss和MSE形式上也差不多，可以简单地认为它们就是一回事。