Faster_rcnn训练自己的数据集(2)

在看了一些深度学习的目标检测的论文后，想着去用开源的代码去跑一下，看看实际的效果。于是小菜就想着直接把faster_rcnn用起来，包括前期的faster_rcnn安装和配置并运行其中的一个demo.py。后面是用自己的数据集训练faster_rcnn的模型。 
　1. 准备工作：

• 1) 搭建caffe框架

  这个可以参考Linux先搭建caffe的笔记。

• 2) 安装第三方依赖包：Cython、 Python-OpenCV、easydict

pip install cython  pip install easydict  apt-get install python-opencv  
1
2
3
1
2
3

• 3) 下载py-faster-rcnn

 # Make sure to clone with --recursive   git clone --recursive https://github.com/rbgirshick/py-faster-rcnn.git  
1
2
1
2

• 4) 编译faster_rcnn

进入py-faster-rcnn/lib，执行make

cd py-faster-rcnn/libmake
1
2
1
2

• 5) 配置faster_rcnn

进入py-faster-rcnn\caffe-fast-rcnn，执行

cp Makefile.config.example Makefile.config
1
1

然后，配置Makefile.config文件，配置好Makefile.config文件后，执行：

make –j4 && make pycaffe  
1
1

注：我在这一步出错了，老是不能编译成功。问题应该是出在Makefile.config文件内容中的，应该是出在路径添加中出错。

解决： 
　在原来搭建的caffe文件中将Makefile.config文件内容直接复制过来。 
接下来下载已经训练好的faster模型，进入py-faster_rcnn/data/scripts目录，执行./fech-faster_rcnn_models,sh

• 6) 测试faster_rcnn

运行网络和加载下载的模型进行最后的测试demo 
执行：

./tools/demo.py
1
1

出现问题： 
ImportError：No module named yaml 
解决:

sudo apt-get install python-yaml
1
1

2. 训练步骤：

• 1) 下载VOC2007数据集

  　　提供一个百度云地址：http://pan.baidu.com/s/1mhMKKw4 
  解压，然后，将该数据集放在py-faster-rcnn\data下，用自己的数据集替换VOC2007数据集。（替换Annotations，ImageSets和JPEGImages）（用你的Annotations，ImagesSets和JPEGImages替换py-faster-rcnn\data\VOCdevkit2007\VOC2007中对应文件夹）。

• 2) 下载ImageNet数据集下预训练得到的模型参数（用来初始化）

  　　提供一个百度云地址：http://pan.baidu.com/s/1hsxx8OW解压，然后将该文件放在py-faster-rcnn\data下。

• 3) 修改训练的配置文件

---

1.py－fasterrcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt/ 
stage1_fast_rcnn_train.pt修改

1.  layer {  2.    name: 'data'  3.    type: 'Python'  4.    top: 'data'  5.    top: 'rois'  6.    top: 'labels'  7.    top: 'bbox_targets'  8.    top: 'bbox_inside_weights'  9.    top: 'bbox_outside_weights'  10.   python_param {  11.     module: 'roi_data_layer.layer'  12.     layer: 'RoIDataLayer'  13.     param_str: "'num_classes': 16" #按训练集类别改，该值为类别数+1  14.   }  15. }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1.  layer {  2.    name: "cls_score"  3.    type: "InnerProduct"  4.    bottom: "fc7"  5.    top: "cls_score"  6.    param { lr_mult: 1.0 }  7.    param { lr_mult: 2.0 }  8.    inner_product_param {  9.      num_output: 16 #按训练集类别改，该值为类别数+1  10.     weight_filler {  11.       type: "gaussian"  12.       std: 0.01  13.     }  14.     bias_filler {  15.       type: "constant"  16.       value: 0  17.     }  18.   }  19. }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.  layer {  2.    name: "bbox_pred"  3.    type: "InnerProduct"  4.    bottom: "fc7"  5.    top: "bbox_pred"  6.    param { lr_mult: 1.0 }  7.    param { lr_mult: 2.0 }  8.    inner_product_param {  9.      num_output: 64 #按训练集类别改，该值为（类别数+1）*4  10.     weight_filler {  11.       type: "gaussian"  12.       std: 0.001  13.     }  14.     bias_filler {  15.       type: "constant"  16.       value: 0  17.     }  18.   }  19. } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.py-faster-rcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt/stage1_rpn_train.pt修改

1.  layer {  2.    name: 'input-data'  3.    type: 'Python'  4.    top: 'data'  5.    top: 'im_info'  6.    top: 'gt_boxes'  7.    python_param {  8.      module: 'roi_data_layer.layer'  9.      layer: 'RoIDataLayer'  10.     param_str: "'num_classes': 16" #按训练集类别改，该值为类别数+1  11.   }  12. }
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

3.py-faster-rcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt/stage2_fast_rcnn_train.pt修改

1.  layer {  2.    name: 'data'  3.    type: 'Python'  4.    top: 'data'  5.    top: 'rois'  6.    top: 'labels'  7.    top: 'bbox_targets'  8.    top: 'bbox_inside_weights'  9.    top: 'bbox_outside_weights'  10.   python_param {  11.     module: 'roi_data_layer.layer'  12.     layer: 'RoIDataLayer'  13.     param_str: "'num_classes': 16" #按训练集类别改，该值为类别数+1  14.   }  15. }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 1. layer {  2.    name: "cls_score"  3.    type: "InnerProduct"  4.    bottom: "fc7"  5.    top: "cls_score"  6.    param { lr_mult: 1.0 }  7.    param { lr_mult: 2.0 }  8.    inner_product_param {  9.      num_output: 16 #按训练集类别改，该值为类别数+1  10.     weight_filler {  11.       type: "gaussian"  12.       std: 0.01  13.     }  14.     bias_filler {  15.       type: "constant"  16.       value: 0  17.     }  18.   }  19. }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.  layer {  2.    name: "bbox_pred"  3.    type: "InnerProduct"  4.    bottom: "fc7"  5.    top: "bbox_pred"  6.    param { lr_mult: 1.0 }  7.    param { lr_mult: 2.0 }  8.    inner_product_param {  9.      num_output: 64 #按训练集类别改，该值为（类别数+1）*4  10.     weight_filler {  11.       type: "gaussian"  12.       std: 0.001  13.     }  14.     bias_filler {  15.       type: "constant"  16.       value: 0  17.     }  18.   }  19. } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.py-faster-rcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt/stage2_rpn_train.pt修改

1.  layer {  2.    name: 'input-data'  3.    type: 'Python'  4.    top: 'data'  5.    top: 'im_info'  6.    top: 'gt_boxes'  7.    python_param {  8.      module: 'roi_data_layer.layer'  9.      layer: 'RoIDataLayer'  10.     param_str: "'num_classes': 16" #按训练集类别改，该值为类别数+1  11.   }  12. }  
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

5.py-faster-rcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt/faster_rcnn_test.pt修改

1.  layer {  2.    name: "cls_score"  3.    type: "InnerProduct"  4.    bottom: "fc7"  5.    top: "cls_score"  6.    inner_product_param {  7.      num_output: 16 #按训练集类别改，该值为类别数+1  8.    }  9.  }  
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

1.  layer {  2.    name: "bbox_pred"  3.    type: "InnerProduct"  4.    bottom: "fc7"  5.    top: "bbox_pred"  6.    inner_product_param {  7.      num_output: 64 #按训练集类别改，该值为（类别数+1）*4  8.    }  9.  }  
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

6.py-faster-rcnn/lib/datasets/pascal_voc.py修改

1.class pascal_voc(imdb):   -    def __init__(self, image_set, year, devkit_path=None):   -        imdb.__init__(self, 'voc_' + year + '_' + image_set)   -        self._year = year   -        self._image_set = image_set   -        self._devkit_path = self._get_default_path() if devkit_path is None \   -                            else devkit_path   -        self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)   -        self._classes = ('__background__', # always index 0   -                         '你的标签1','你的标签2',你的标签3','你的标签4'   -                   )  
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

上面要改的地方是 
　修改训练集文件夹：

self._data_path = os.path.join(self._devkit_path, 'VOC'+self._year) 
1
1

　用你的数据集直接替换原来VOC2007内的Annotations，ImageSets和JPEGImages就不用修改,以免出现各种错误。 
 修改标签： 
self._classes = (‘background‘, # always index 0 
‘你的标签1’,’你的标签2’,’你的标签3’,’你的标签4’) 
修改成你的数据集的标签就行。 
（2） 
cls = self._class_to_ind[obj.find(‘name’).text.lower().strip()] 
这里把标签转成小写，如果你的标签含有大写字母，可能会出现KeyError的错误，所以建议标签用小写字母。建议训练的标签还是用小写的字母，如果最终需要用大写字母或中文显示标签，可参考：http://blog.csdn.net/sinat_30071459/article/details/51694037

7.py-faster-rcnn/lib/datasets/imdb.py修改 
　该文件的append_flipped_images(self)函数修改为：

1.  def append_flipped_images(self):  2.          num_images = self.num_images  3.          widths = [PIL.Image.open(self.image_path_at(i)).size[0]  4.                    for i in xrange(num_images)]  5.          for i in xrange(num_images):  6.              boxes = self.roidb[i]['boxes'].copy()  7.              oldx1 = boxes[:, 0].copy()  8.              oldx2 = boxes[:, 2].copy()  9.              boxes[:, 0] = widths[i] - oldx2 - 1  10.             print boxes[:, 0]  11.             boxes[:, 2] = widths[i] - oldx1 - 1  12.             print boxes[:, 0]  13.             assert (boxes[:, 2] >= boxes[:, 0]).all()  14.             entry = {'boxes' : boxes,  15.                      'gt_overlaps' : self.roidb[i]['gt_overlaps'],  16.                      'gt_classes' : self.roidb[i]['gt_classes'],  17.                      'flipped' : True}  18.             self.roidb.append(entry)  19.         self._image_index = self._image_index * 2  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注：为防止与之前的模型搞混,训练前把output文件夹删除（或改个其他名），还要把py-faster-rcnn/data/cache中的文件和 
py-faster-rcnn/data/VOCdevkit2007/annotations_cache中的文件删除（如果有的话）。 
4) 训练参数设置 
　可在py-faster-rcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt中的solve文件设置，迭代次数可在py-faster-rcnn\tools的train_faster_rcnn_alt_opt.py中修改： 
max_iters = [80000, 40000, 80000, 40000] 
　分别为4个阶段（rpn第1阶段，fast rcnn第1阶段，rpn第2阶段，fast rcnn第2阶段）的迭代次数。可改成你希望的迭代次数。如果改了这些数值，最好把py-faster-rcnn/models/pascal_voc/ZF/faster_rcnn_alt_opt里对应的solver文件（有4个）也修改，stepsize小于上面修改的数值。 
5) 开始训练 
进入py-faster-rcnn， 
执行

./experiments/scripts/faster_rcnn_alt_opt.sh 0 ZF pascal_voc 
1
1

这样，就开始训练了。 
我训练这里出错： 
开始数据集的制作中，标签的名字是数字1，出现KeyError ‘3’

解决：在生成XML文件的代码中修改标签的name为小写英文字母。 
错误： 
File “/py-faster-rcnn/tools/../lib/datasets/imdb.py”, line 108, in append_flipped_images 
assert (boxes[:, 2] >= boxes[:, 0]).all() 
解决：检查自己数据发现，左上角坐标（x,y）可能为0，或标定区域溢出图片 
1、修改lib/datasets/imdb.py，append_flipped_images()函数 
数据整理，在一行代码为 boxes[:, 2] = widths[i] - oldx1 - 1下加入代码： 
for b in range(len(boxes)): 
if boxes[b][2]< boxes[b][0]: 
boxes[b][0] = 0 
2、修改lib/datasets/pascal_voc.py，_load_pascal_annotation(,)函数 
将对Xmin,Ymin,Xmax,Ymax减一去掉，变为： 

6) 测试 
将训练得到的py-faster-rcnn\output\faster_rcnn_alt_opt***_trainval中ZF的caffemodel拷贝至py-faster-rcnn\data\faster_rcnn_models（如果没有这个文件夹，就新建一个），然后，修改：py-faster-rcnn\tools\demo.py,主要修改：

1.  CLASSES = ('__background__',  2.             '你的标签1', '你的标签2', '你的标签3', '你的标签4')  
1
2
1
2

改成你的数据集标签：

1.  NETS = {'vgg16': ('VGG16',  2.                    'VGG16_faster_rcnn_final.caffemodel'),  3.          'zf': ('ZF',  4.                    'ZF_faster_rcnn_final.caffemodel')} 
1
2
3
4
1
2
3
4

上面ZF的caffemodel改成你的caffemodel。

1.  im_names = ['1559.jpg','1564.jpg']  
1
1

改成你的测试图片。(测试图片放在py-faster-rcnn\data\demo中) 
7) 结果 
在py-faster-rcnn下， 
执行：./tools/demo.py –net zf 
或者将默认的模型改为zf：

parser.add_argument('--net', dest='demo_net', help='Network to use [vgg16]',                          choices=NETS.keys(), default='vgg16')  
1
2
1
2

修改： 
default=’zf’ 
执行：./tools/demo.py

在安装完成caffe后，并且编译完成github上的faster-rcnn Python版之后，可以采用自己的数据来训练faster-rcnn了。 
一，文件修改： 
1，在py-faster-rcnn目录下，找到lib/datasets/pascal_voc.py 文件打开逐一修改相应的函数： 
如果打算添加中文注释请，在文件开图添加#encoding:utf-8，不然会报错。 
以下为修改的细节：

1）、初始化函数init的修改，同时修改类名：

class hs(imdb):    def __init__(self, image_set, devkit_path=None):  # modified        imdb.__init__(self, image_set)        self._image_set = image_set        self._devkit_path = devkit_path#datasets路径        self._data_path = os.path.join(self._devkit_path,image_set)   #图片文件夹路径        self._classes = ('__background__', # always index 0                         'jyz','fzc','qnq')   #two classes        self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))         # form the dict{'__background__':'0','person':'1'}        self._image_ext = '.jpg'        self._image_index = self._load_image_set_index('ImageList.txt')        # Default to roidb handler        self._roidb_handler = self.selective_search_roidb        self._salt = str(uuid.uuid4())        self._comp_id = 'comp4'        # PASCAL specific config options        self.config = {'cleanup'     : True,                       'use_salt'    : True,                       'use_diff'    : False,                       'matlab_eval' : False,                       'rpn_file'    : None,                       'min_size'    : 16}  #小于16个像素的框扔掉        assert os.path.exists(self._devkit_path), \                'VOCdevkit path does not exist: {}'.format(self._devkit_path)        assert os.path.exists(self._data_path), \                'Path does not exist: {}'.format(self._data_path)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2）修改image_path_from_index函数的修改：

def image_path_from_index(self, index): #modified    """    Construct an image path from the image's "index" identifier.    """    image_path = os.path.join(self._data_path,index +'.jpg')    assert os.path.exists(image_path), \            'Path does not exist: {}'.format(image_path)    return image_path
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

3）修改_load_image_set_index函数：

def _load_image_set_index(self,imagelist): # modified    """    Load the indexes listed in this dataset's image set file.    """    # Example path to image set file:    # self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt    image_set_file = os.path.join(self._devkit_path, imagelist)    assert os.path.exists(image_set_file), \            'Path does not exist: {}'.format(image_set_file)    with open(image_set_file) as f:        image_index = [x.strip() for x in f.readlines()]    return image_index
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

4）修改_load_pascal_annotation(self, index):

def _load_pascal_annotation(self, index):    #modified    """    Load image and bounding boxes info from XML file in the PASCAL VOC    format.    """    filename = os.path.join(self._devkit_path, 'Annotations', index + '.xml')    tree = ET.parse(filename)    objs = tree.findall('object')    if not self.config['use_diff']:        # Exclude the samples labeled as difficult        non_diff_objs = [            obj for obj in objs if int(obj.find('difficult').text) == 0]        # if len(non_diff_objs) != len(objs):        #     print 'Removed {} difficult objects'.format(        #         len(objs) - len(non_diff_objs))        objs = non_diff_objs    num_objs = len(objs)    boxes = np.zeros((num_objs, 4), dtype=np.uint16)    gt_classes = np.zeros((num_objs), dtype=np.int32)    overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)    # "Seg" area for pascal is just the box area    seg_areas = np.zeros((num_objs), dtype=np.float32)    # Load object bounding boxes into a data frame.    for ix, obj in enumerate(objs):        bbox = obj.find('bndbox')        # Make pixel indexes 0-based        x1 = float(bbox.find('xmin').text)        y1 = float(bbox.find('ymin').text)        x2 = float(bbox.find('xmax').text)        y2 = float(bbox.find('ymax').text)        cls = self._class_to_ind[obj.find('name').text.lower().strip()]        boxes[ix, :] = [x1, y1, x2, y2]        gt_classes[ix] = cls        overlaps[ix, cls] = 1.0        seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)    overlaps = scipy.sparse.csr_matrix(overlaps)    return {'boxes' : boxes,            'gt_classes': gt_classes,            'gt_overlaps' : overlaps,            'flipped' : False,            'seg_areas' : seg_areas}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

5）main下面修改相应的路径：

if __name__ == '__main__':    from datasets.hs import hs    d = hs('hs', '/home/panyiming/py-faster-rcnn/lib/datasets')    res = d.roidb    from IPython import embed; embed()
1
2
3
4
5
6
1
2
3
4
5
6

2，在py-faster-rcnn目录下，找到lib/datasets/factory.py 并修改，修改后的文件如下：

# --------------------------------------------------------# Fast R-CNN# Copyright (c) 2015 Microsoft# Licensed under The MIT License [see LICENSE for details]# Written by Ross Girshick# --------------------------------------------------------"""Factory method for easily getting imdbs by name."""__sets = {}from datasets.hs import hsimport numpy as np# # Set up voc_<year>_<split> using selective search "fast" mode# for year in ['2007', '2012']:#     for split in ['train', 'val', 'trainval', 'test']:#         name = 'voc_{}_{}'.format(year, split)#         __sets[name] = (lambda split=split, year=year: pascal_voc(split, year))## # Set up coco_2014_<split># for year in ['2014']:#     for split in ['train', 'val', 'minival', 'valminusminival']:#         name = 'coco_{}_{}'.format(year, split)#         __sets[name] = (lambda split=split, year=year: coco(split, year))## # Set up coco_2015_<split># for year in ['2015']:#     for split in ['test', 'test-dev']:#         name = 'coco_{}_{}'.format(year, split)#         __sets[name] = (lambda split=split, year=year: coco(split, year))name = 'hs'devkit = '/home/panyiming/py-faster-rcnn/lib/datasets'__sets['hs'] = (lambda name = name,devkit = devkit: hs(name,devkit))def get_imdb(name):    """Get an imdb (image database) by name."""    if not __sets.has_key(name):        raise KeyError('Unknown dataset: {}'.format(name))    return __sets[name]()def list_imdbs():    """List all registered imdbs."""    return __sets.keys()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

二、模型的选择、训练以及测试： 
1.预训练模型介绍 
在github官网上的py-faster-rcnn的编译安装教程中有一步如下：

cd $FRCN_ROOT./data/scripts/fetch_faster_rcnn_models.sh
1
2
1
2

执行完成之后会在/data/scripts下产生压缩文件faster_rcnn_models.tgz，解压得到faster_rcnn_model文件夹，faster_rcnn_model文件夹下面是作者用faster rcnn训练好的三个网络,分别对应着小、中、大型网络，大家可以试用一下这几个网络，看一些检测效果，他们训练都迭代了80000次，数据集都是pascal_voc的数据集。

可以通过执行如下命令下载Imagenet上训练好的通用模型：

cd $FRCN_ROOT./data/scripts/fetch_imagenet_models.sh
1
2
1
2

执行完成之后会在/data/scripts下产生压缩文件imagenet_models.tgz，解压得到imagenet_models文件夹，imagenet_model文件夹下面是在Imagenet上训练好的通用模型，在这里用来初始化网络的参数.

2.修改模型文件配置 
模型文件在models下面对应的网络文件夹下，在这里我用中型网络的配置文件修改为例子 
比如：我的检测目标物是3类 ，那么我的类别就有两个类别即 background 和 3类目标 
因此，首先打开网络的模型文件夹，打开train.prototxt修改的地方重要有三个 
分别是个地方

首先在data层把num_classes 从原来的21类 20类+背景 ，改成 4类 3类目标+背景接在在cls_score层把num_output 从原来的21 改成 4RoI Proposal下有个名为name: 'roi-data'的层，将其num_classes修改为4在bbox_pred层把num_output 从原来的84 改成16， 为检测类别个数乘以4，

如果你要进一步修改网络训练中的学习速率，步长，gamma值，以及输出模型的名字，需要在同目录下的solver.prototxt中修改。

3.启动Fast RCNN网络训练

python ./tools/train_net.py --gpu 1 --solver models/hs/faster_rcnn_end2end/solver.prototxt --weights data/imagenet_models/VGG_CNN_M_1024.v2.caffemodel --imdb hs --iters 80000 --cfg experiments/cfgs/faster_rcnn_end2end.yml
1
1

命令解析： 
1）、train_net.py是网络的训练文件，之后的参数都是附带的输入参数。 
3）、–gpu 代表机器上的GPU编号，如果是nvidia系列的tesla显卡，可以在终端中输入nvidia-smi来查看当前的显卡负荷，选择合适的显卡。 
4）、–solver 代表模型的配置文件，train.prototxt的文件路径已经包含在这个文件之中。 
5）、-weights 代表初始化的权重文件，这里用的是Imagenet上预训练好的模型，中型的网络我们选择用VGG_CNN_M_1024.v2.caffemodel，此步可以省略，省略后会自动初始化。 
6）、–imdb 这里给出的训练的数据库名字需要在factory.py的_sets中，我在文件里面有。_sets[‘hs’]，train_net.py这个文件会调用factory.py再生成hs这个类，来读取数据。

4.启动Fast RCNN网络检测 
可以参考tools下面的demo.py 文件，来做检测，并且将检测的坐标结果输出到相应的txt文件中。