[深度学习] RCNNs系列（1） Ubuntu下Faster RCNN配置及训练和测试自己的数据方法

最近用到Faster RCNN进行目标检测，前前后后两周把RCNN，SPPNet，Fast RCNN和Faster RCNN大体调查了一遍，准备写一个RCNNs系列，后面还要加上今年最新的Mask RCNN。

要想开个头，知道RCNNs在目标检测方向的优势，那就先用用作者的代码，跑跑自己的代码，下面就是在Ubuntu下进行Faster RCNN配置的方法。

一、Faster RCNN环境配置及demo运行

虽然Faster RCNN中作者加入了很多新的东西，比如怎么选Anchar，怎么计算多任务的loss等等，所幸的是作者开源了代码，让我们很容易就能够用他的算法实现我们自己的任务。在运行自己的任务之前，我们首先要做的就是确保我们已经配置好源代码的运行环境。

本文是在Caffe已经配置好的条件下进行的，如果Caffe的需求库，比如opencv等等还没有弄好，建议先去把Caffe配置好。

（1）首先使用git把Faster RCNN的源码下载到本地：

git clone --recursive https://github.com/rbgirshick/py-faster-rcnn.git

（2）安装cpython和python-opencv

pip install cpython
apt-get install python-opencv

（3）下载Faster RCNN并安装好cpython以后，进入py-faster-rcnn/lib中使用命令编译一下

make

（4）进入py-faster-rcnn/caffe-fast-rcnn，配置Makefile.config文件，目录中有Makefile.config.example文件，可以按照这个文件进行修改，或者使用你配置caffe时的Makefile.config文件。我这里有一个配置文件，可以参考。我的配置文件用到了cuDNN，开始我使用cuDNN的时候总会在编译时报错，后来在在windows上配置py-faster-rcnn和调参经验中找到了解决办法，解决办法如下：

把Caffe中的include/caffe/layers/cudnn_relu_layer.hpp，/include/caffe/layers/cudnn_sigmoid_layer.hpp，/include/caffe/layers/cudnn_tanh_layer.hpp和/include/caffe/util/cudnn.hpp替换py-faster-rcnn/caffe-fast-rcnn中对应的文件；
把Caffe中的src/caffe/layers/cudnn_relu_layer.cpp，src/caffe/layers/cudnn_relu_layer.cu，src/caffe/layers/cudnn_sigmoid_layer.cpp，src/caffe/layers/cudnn_sigmoid_layer.cu，src/caffe/layer/cudnn_tanh_layer.cpp，src/caffe/layers/cudnn_tanh_layer.cu替换掉py-faster-rcnn/caffe-fast-rcnn中对应的文件；
把py-faster-rcnn/caffe-fast-rcnn中src/caffe/layers/cudnn_conv_layer.cu文件中的cudnnConvolutionBackwardData_v3全部换为cudnnConvolutionBackwardData，把cudnnConvolutionBackwardFilter_v3全部换为cudnnConvolutionBackwardFilter。

如果自己的显卡配置足够的话，强烈建议开启cudnn，cudnn不仅可以起到加速的作用，而且我跑实验的时候发现加入cudnn以后可以明显的降低显存的使用。如下图所示：

开启cudnn之前：

开启cudnn之后：

可以看到显存减少了将近2G，非常可观，强烈建议开启。

（5）配置好Makefile以后，在caffe-fast-rcnn中执行命令进行编译

make -j8 && make pycaffe

（6）这个时候，基本上faster RCNN也就配置好了，让我们看一下是否真的能够运行。首先我们下载几个作者已经训练好的caffemodel，如果现在直接运行demo.py的话会提示你没有caffemodel文件，然后询问是否运行过py-faster-rcnn/data/scripts/fetch_faster_rcnn_models.sh文件，我们可以找到该文件中的下载链接，用迅雷一会就可以下载好，如果直接运行该文件可能要不少时间。把下载好的文件中VGG16_faster_rcnn_final.caffemodel文件复制到py-faster-rcnn/data/faster_rcnn_models中

（7）运行py-faster-rcnn/experiments/tools/demo.py文件，不出意外的话，会出现如下错误：

修改py-faster-rcnn/lib/fast_rcnn/train.py文件，在文件中引入text_format

import google.protobuf.text_format

再次运行demo.py文件，这次应该可以运行成功！

二、Faster RCNN训练自己的数据

既然已经把Faster RCNN配置好，下一步我们来训练自己的数据吧。Faster RCNN论文中采用的训练方法分为几个阶段，训练起来比较麻烦，我们这里采用源码中的end to end的训练方式，更简便一些。

2.1 建立数据集

为了让我们的训练更简单些，我们不去改动源码中读写数据的方式，而是把我们的数据集改成Pascal VOC的数据集格式，Pascal VOC数据集主要分为三个部分：Annotations，JPEGImages和ImageSets。其中JPEGImages中存放的是训练和测试时需要的图像；Annotations存放的是每个图像中所有目标的bounding box信息，每个图像对应一个xml文件；ImageSet文件中存放的Main目录，而Main目录中就是训练和测试时需要的文件列表，主要分为train.txt, test.txt, trainval.txt, val.txt可以根据文件名就知道哪些是训练数据列表，哪些是测试数据列表。

这里如果我们有这样结构的数据集当然最好了，如果没有这样的数据集的话就需要自己建立。建立数据集的话可以参考：将数据集做成VOC2007格式用于Faster-RCNN训练——小咸鱼_的博客。

这里解说一下我的获取方法，因为我的数据比较特殊，是由在线数据转换过来的，所以我很容易的就获得了各个目标的bounding box信息，所以没有使用参考博客的方法。我最终获得的bounding box信息文件如下所示：

Train_IMG\000001.jpg 97 6 174 202 305
Train_IMG\000001.jpg 8 56 198 282 162
......省略若干行
Train_IMG\000001.jpg 90 537 194 699 314

其中每个图像对应一个bounding box文件，每个文件中的每一行表示一个目标的bounding box，每一行由6列数据组成，第1列数据为图像的路径，第2列为该目标的分类，第3列为bounding box的左上角的x（对应图像的列，即mincol），第4列为bounding box的左上角的y（对应图像的行，即minrow），第5列为bounding box的右下角的x（对应图像的列，即maxcol），第6列为bounding box右下角的y（对应图像的行，即maxrow）。

然后我们接下来要做的就是把这些bounding box文件转换为VOC数据集格式的xml文件，我这里是从github上找到的一个Python开源代码（但是作者的原址找不到了，所以这里没能给出参考链接，如果有人有原址欢迎告知，我会把原址贴上）上进行的改动，源码如下：

# -*- coding:utf-8 -*-

__author__ = "peic"

import xml.dom
import xml.dom.minidom
import os

from PIL import Image

'''
根据下面的路径和文件，将output.txt制作成xml的标注
'''

# xml文件规范定义
_INDENT = ' ' * 4
_NEW_LINE = '\n'
_FOLDER_NODE = 'VOC2007'
_ROOT_NODE = 'annotation'
_DATABASE_NAME = 'CROHME offline ME Dataset'
_CLASS = 'person'
_ANNOTATION = 'PASCAL VOC2007'
_AUTHOR = 'hanchao'

_SEGMENTED = '0'
_DIFFICULT = '0'
_TRUNCATED = '0'
_POSE = 'Unspecified'
#需要注意，这一项是存放bounding box对应图像的目录
_IMAGE_PATH = 'Train_IMG'
#这一项是保存生成xml文件的目录
_ANNOTATION_SAVE_PATH = 'Annotations'

_IMAGE_CHANNEL = 3


# 封装创建节点的过程
def createElementNode(doc, tag, attr):
    # 创建一个元素节点
    element_node = doc.createElement(tag)

    # 创建一个文本节点
    text_node = doc.createTextNode(attr)

    # 将文本节点作为元素节点的子节点
    element_node.appendChild(text_node)
    
    return element_node


# 封装添加一个子节点的过程
def createChildNode(doc, tag, attr, parent_node):

    child_node = createElementNode(doc, tag, attr)
    parent_node.appendChild(child_node)

# object节点比较特殊
def createObjectNode(doc, attrs):
    object_node = doc.createElement('object')
    createChildNode(doc, 'name', attrs['classification'], object_node)
    createChildNode(doc, 'pose', _POSE, object_node)
    createChildNode(doc, 'truncated', _TRUNCATED, object_node)
    createChildNode(doc, 'difficult', _DIFFICULT, object_node)

    bndbox_node = doc.createElement('bndbox')
    createChildNode(doc, 'xmin', attrs['xmin'], bndbox_node)
    createChildNode(doc, 'ymin', attrs['ymin'], bndbox_node)
    createChildNode(doc, 'xmax', attrs['xmax'], bndbox_node)
    createChildNode(doc, 'ymax', attrs['ymax'], bndbox_node)
    object_node.appendChild(bndbox_node)

    return object_node

# 将documentElement写入XML文件中
def writeXMLFile(doc, filename):
    tmpfile = open('tmp.xml', 'w')
    doc.writexml(tmpfile, addindent=' '*4, newl='\n', encoding='utf-8')
    tmpfile.close()


    # 删除第一行默认添加的标记
    fin = open('tmp.xml')
    fout = open(filename, 'w')
    lines = fin.readlines()

    for line in lines[1:]:
        if line.split():
            fout.writelines(line)

    #new_lines = ''.join(lines[1:])
    #fout.write(new_lines)
    fin.close()
    fout.close()

# 创建XML文档并写入节点信息
def createXMLFile(attrs, width, height, filename):

    # 创建文档对象, 文档对象用于创建各种节点
    my_dom = xml.dom.getDOMImplementation()
    doc = my_dom.createDocument(None, _ROOT_NODE, None)

    # 获得根节点
    root_node = doc.documentElement

    # folder节点
    createChildNode(doc, 'folder', _FOLDER_NODE, root_node)
    
    # filename节点
    createChildNode(doc, 'filename', attrs['name'], root_node)

    # source节点
    source_node = doc.createElement('source')
    # source的子节点
    createChildNode(doc, 'database', _DATABASE_NAME, source_node)
    createChildNode(doc, 'annotation', _ANNOTATION, source_node)
    createChildNode(doc, 'image', 'flickr', source_node)
    createChildNode(doc, 'flickrid', 'NULL', source_node)
    root_node.appendChild(source_node)

    # owner节点
    owner_node = doc.createElement('owner')
    # owner的子节点
    createChildNode(doc, 'flickrid', 'NULL', owner_node)
    createChildNode(doc, 'name', _AUTHOR, owner_node)
    root_node.appendChild(owner_node)

    # size节点
    size_node = doc.createElement('size')
    createChildNode(doc, 'width', str(width), size_node)
    createChildNode(doc, 'height', str(height), size_node)
    createChildNode(doc, 'depth', str(_IMAGE_CHANNEL), size_node)
    root_node.appendChild(size_node)

    # segmented节点
    createChildNode(doc, 'segmented', _SEGMENTED, root_node)

    # object节点
    object_node = createObjectNode(doc, attrs)
    root_node.appendChild(object_node)

    # 写入文件
    writeXMLFile(doc, filename)

def generate_xml(txt_filename):
    #注意，这里的txt_filename文件是待转换的bounding box文件
    ouput_file = open(txt_filename)
    current_dirpath = os.path.dirname(os.path.abspath('__file__'))

    if not os.path.exists(_ANNOTATION_SAVE_PATH):
        os.mkdir(_ANNOTATION_SAVE_PATH)

    lines = ouput_file.readlines()
    for line in lines:
        s = line.rstrip()
        array = s.split(' ')
        #print len(array)
        attrs = dict()
        attrs['name'] = array[0].split('\\')[1]
        attrs['classification'] = array[1]
        attrs['xmin'] = array[2]
        attrs['ymin'] = array[3]
        attrs['xmax'] = array[4]
        attrs['ymax'] = array[5]

        # 构建XML文件名称
        xml_file_name = os.path.join(_ANNOTATION_SAVE_PATH, (attrs['name'].split('.'))[0] + '.xml')
        #print xml_file_name

        if os.path.exists( xml_file_name):
            # print('do exists')
            existed_doc = xml.dom.minidom.parse(xml_file_name)
            root_node = existed_doc.documentElement
            
            # 如果XML存在了, 添加object节点信息即可
            object_node = createObjectNode(existed_doc, attrs)
            root_node.appendChild(object_node)

            # 写入文件
            writeXMLFile(existed_doc, xml_file_name)
            
        else:
            # print('not exists')
            # 如果XML文件不存在, 创建文件并写入节点信息
            img_name = attrs['name']
            img_path = os.path.join(current_dirpath, _IMAGE_PATH, img_name)
            # 获取图片信息
            img = Image.open(img_path)
            width, height = img.size
            img.close()
            
            # 创建XML文件
            createXMLFile(attrs, width, height, xml_file_name)

执行的Main程序如下：

#coding=utf-8
'''
Created on 2017年4月18日

@author: hanchao
'''
import generate_xml
import os.path
import cv2
# 
if __name__ == "__main__":
    for dir,path,filenames in os.walk('Train_BB'):#Train_BB是存放bounding box文件的目录
        for filename in filenames:
            print dir  + '/' + filename
            generate_xml.generate_xml(dir  + '/' + filename)

最终生成的xml文件会保存在Annotations目录中。

对于ImageSets/Main中的几个文件就比较好建立了，只需要把训练、验证和测试集中图像名称写入到对应的文件中即可。

接下来，可以自己在py-faster-rcnn/data中建立一个VOCdevkit2007目录，在该目录中建立VOC2007子目录，然后把JPEGImages，Annotaions和ImageSets目录复制到该目录中，即准备好了自己的数据。

注意： Faster RCNN对图像和目标的大小以及长宽比是有一定要求的，具体的讨论见用ImageNet的数据集(ILSVRC2014)训练Faster R-CNN——Jiajun的博客

在这里我有深痛的教训T_T，我的数据集中设置目标的长宽比在0.1～10之间，图像的长宽比在0.3～7之间

2.2 训练自己的数据

经过前面的铺垫，我们终于可以训练自己的数据了。

接下来我们需要下载几个模型，看过论文的都知道，作者的训练首先使用在ImageNet上训练好的模型对网络结构进行初始化，然后再训练的网络，我们现在下载的模型就是进行初始化的模型，下载地址： https://pan.baidu.com/s/1c2tfkRm 下载完成后，把文件加压把模型放在py-faster-rcnn/data/imagenet_models中即可。

接下来，我们只需要更改几个文件即可。（注意，我这里使用的是端到端的训练方式，所以改动全部为end to end的，如果使用论文中的分阶段训练的方式，则需要改动alt_opt对应的文件）

（1）更改py-faster-rcnn/experiments/scripts/faster_rcnn_end2end.sh文件，该文件中的问题在于没有设置各个文件的绝对路径，所以运行起来可能有问题，把两个time后的路径设置加上py-faster-rcnn的绝对路径即可，我更改后示例如下：

time /home/hanchao/py-faster-rcnn/tools/train_net.py --gpu ${GPU_ID} \
  --solver /home/hanchao/py-faster-rcnn/models/${PT_DIR}/${NET}/faster_rcnn_end2end/solver.prototxt \
  --weights /home/hanchao/py-faster-rcnn/data/imagenet_models/${NET}.v2.caffemodel \
  --imdb ${TRAIN_IMDB} \
  --iters ${ITERS} \
  --cfg /home/hanchao/py-faster-rcnn/experiments/cfgs/faster_rcnn_end2end.yml \
  ${EXTRA_ARGS}

（2）更改py-faster-rcnn/models/pascal_voc/VGG16/faster_rcnn_end2end目录中的train，test和solver文件（我采用的是VGG16网络，如果使用ZF网络，去修改对应目录下文件即可）。把train和test中所有的21和84改成你的分类类型数+1和（你的分类类型数+1）×4即可。在solver文件中加入绝对路径；

（3）更改py-faster-rcnn/lib/datasets/pascal_voc.py文件，更改self._classes中标签换成自己的标签，即

        self._classes = ('__background__', # always index 0
                         '你的标签1', '你的标签2', '你的标签3')

注意这里的标签不要有大写符号。

（4）文章中还采用了horizontal flip以扩充数据，我的数据是字符，因此不能扩充，所以我把py-faster-rcnn/lib/datasets/imdb.py中append_flipped_images(self)函数改为

    def append_flipped_images(self):
#        num_images = self.num_images
#        widths = self._get_widths()
#        for i in xrange(num_images):
#            boxes = self.roidb[i]['boxes'].copy()
#            oldx1 = boxes[:, 0].copy()
#            oldx2 = boxes[:, 2].copy()
#            boxes[:, 0] = widths[i] - oldx2 - 1
#            boxes[:, 2] = widths[i] - oldx1 - 1
#            assert (boxes[:, 2] >= boxes[:, 0]).all()
#            entry = {'boxes' : boxes,
#                     'gt_overlaps' : self.roidb[i]['gt_overlaps'],
#                     'gt_classes' : self.roidb[i]['gt_classes'],
#                     'flipped' : True}
#            self.roidb.append(entry)
#        self._image_index = self._image_index * 2
        self._image_index = self._image_index

如果你的数据比较多的话同样也可以去掉这个函数，该函数也可能会引发一些问题，具体更改和解决方法参见 Faster-RCNN+ZF用自己的数据集训练模型(Python版本)——小咸鱼_的博客

好啦，接下来应该就可以愉快的训练自己的数据了，进入py-faster-rcnn/experiments/scripts目录，使用命令

faster_rcnn_end2end.sh 0 VGG16 pascal_voc

其中0表示你训练时使用的gpu标号，VGG16是模型类型，具体的内容可以去读faster_rcnn_end2end.sh的源码。

（注意：如果更改数据以后，再次训练以前一定要把py-faster-rcnn/data中的cache目录删掉，否则训练时用的还是以前的数据）

训练结束后，把训练好的模型放入到py-faster-rcnn/data/faster_rcnn_models中，然后调用把demo.py中的测试图片换成自己的测试图像，运行进行测试，如果有需要，也可以自己修改demo文件，程序还是很容易看懂的。

这就是训练的全部过程了，因为配置起来也有一定的时间了，有些错误也记不太清了，我把我还记得的坑都写在上面了，如果配置过程中有其他的一些错误，欢迎在评论里一起交流。

附录

————————————————————————

1. 在测试的时候，可能会出现IndexError: too many indices for array，出现这个错误的原因是你的测试集中有的类别没有出现，在这里只需要在py-faster-rcnn/lib/datasets/voc_eval.py中BB = BB[sorted_ind, :]前一句加上if len(BB) != 0:即可。

2. 在测试时还有可能出现KeyError: '某样本名'，这是因为你数据更改了，但是程序有cache文件，把py-faster-rcnn/data/VOCdevkit2007/annotations_cache目录删除即可。