下载程序，

git clone https://github.com/Orpine/py-R-FCN.git

打开py-R-FCN,下载caffe

git clone https://github.com/Microsoft/caffe.git

编译Cython模块

cd lib

make

结果如下图所示：

结果如下图所示：

下载训练，测试，验证数据集：

wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar

wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar

wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCdevkit_08-Jun-2007.tar

wget http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar

解压到VOCdevkit文件夹中：

tar xvf VOCtrainval_06-Nov-2007.tar

tar xvf VOCtest_06-Nov-2007.tar

tar xvf VOCdevkit_08-Jun-2007.tar

tar xvf VOCtrainval_11-May-2012.tar

VOCdevkit文件夹的结构如下图所示：

由于py-faster-rcnn不支持多个训练集，我们创造一个新的文件夹叫做VOC0712，把VOC2007和VOC2012里的JPEGImage和Annonation融合到一个单独的文件夹JPEGImage和Annonation里，用下面的程序生成新的ImageSets文件夹：

1. %writetxt.m
2. file = dir('F:\VOC0712\Annotations\*.xml');
3. len = length(file);
4. num_trainval=sort(randperm(len, floor(9*len/10)));%trainval集占所有数据的9/10，可以根据需要设置
5. num_train=sort(num_trainval(randperm(length(num_trainval), floor(5*length(num_trainval)/6))));%train集占trainval集的5/6，可以根据需要设置
6. num_val=setdiff(num_trainval,num_train);%trainval集剩下的作为val集
7. num_test=setdiff(1:len,num_trainval);%所有数据中剩下的作为test集
8. path = 'F:\VOC0712\ImageSets\Main\';
9. fid=fopen(strcat(path, 'trainval.txt'),'a+');
10. for i=1:length(num_trainval)
11. s = sprintf('%s',file(num_trainval(i)).name);
12. fprintf(fid,[s(1:length(s)-4) '\n']);
13. end
14. fclose(fid);
15. fid=fopen(strcat(path, 'train.txt'),'a+');
16. for i=1:length(num_train)
17. s = sprintf('%s',file(num_train(i)).name);
18. fprintf(fid,[s(1:length(s)-4) '\n']);
19. end
20. fclose(fid);
21. fid=fopen(strcat(path, 'val.txt'),'a+');
22. for i=1:length(num_val)
23. s = sprintf('%s',file(num_val(i)).name);
24. fprintf(fid,[s(1:length(s)-4) '\n']);
25. end
26. fclose(fid);
27. fid=fopen(strcat(path, 'test.txt'),'a+');
28. for i=1:length(num_test)
29. s = sprintf('%s',file(num_test(i)).name);
30. if ~isempty(strfind(s,'plain'))
31. fprintf(fid,[s(1:length(s)-4) '\n']);
32. end
33. end
34. fclose(fid);

为VOCdevkit创造新的超链接：VOCdevkit0712，如下图所示

下载在ImageNet上预训练好的模型，放到./data/imagenet_models里，如下图所示：

下面开始用VOC0712训练：

experiments/scripts/rfcn_end2end.sh 使用联合近似训练

experiments/scripts/rfcn_end2end_ohem.sh 使用联合近似训练+OHEM

experiments/scripts/rfcn_alt_opt_5stage_ohem.sh 使用分布训练+OHEM

./experiments/scripts/rfcn_end2end[_ohem].sh [GPU_ID] [NET] [DATASET] [--set ...]

下面开始用py-rfcn来训练自己的数据集:(我的数据集是标准pascal voc数据集，名字叫做VOC5000)

首先修改网络模型：

1.修改/py-R-FCN/models/pascal_voc/ResNet-50/rfcn_end2end/class-aware/train_ohem.prototxt

1. name: "ResNet-50"
2. layer {
3. name: 'input-data'
4. type: 'Python'
5. top: 'data'
6. top: 'im_info'
7. top: 'gt_boxes'
8. python_param {
9. module: 'roi_data_layer.layer'
10. layer: 'RoIDataLayer'
11. param_str: "'num_classes': 2" #改为你的数据集的类别数+1
12. }
13. }
14. layer {
15. name: 'roi-data'
16. type: 'Python'
17. bottom: 'rpn_rois'
18. bottom: 'gt_boxes'
19. top: 'rois'
20. top: 'labels'
21. top: 'bbox_targets'
22. top: 'bbox_inside_weights'
23. top: 'bbox_outside_weights'
24. python_param {
25. module: 'rpn.proposal_target_layer'
26. layer: 'ProposalTargetLayer'
27. param_str: "'num_classes': 2"#改为你的数据集的类别数+1
28. }
29. }
30. layer {
31. bottom: "conv_new_1"
32. top: "rfcn_cls"
33. name: "rfcn_cls"
34. type: "Convolution"
35. convolution_param {
36. num_output: 98 #2*(7^2) cls_num*(score_maps_size^2)(类别数+1)*49
37. kernel_size: 1
38. pad: 0
39. weight_filler {
40. type: "gaussian"
41. std: 0.01
42. }
43. bias_filler {
44. type: "constant"
45. value: 0
46. }
47. }
48. param {
49. lr_mult: 1.0
50. }
51. param {
52. lr_mult: 2.0
53. }
54. }
55. layer {
56. bottom: "conv_new_1"
57. top: "rfcn_bbox"
58. name: "rfcn_bbox"
59. type: "Convolution"
60. convolution_param {
61. num_output: 392 #8*(7^2) cls_num*(score_maps_size^2)（类别数+1）*49*4
62. kernel_size: 1
63. pad: 0
64. weight_filler {
65. type: "gaussian"
66. std: 0.01
67. }
68. bias_filler {
69. type: "constant"
70. value: 0
71. }
72. }
73. param {
74. lr_mult: 1.0
75. }
76. param {
77. lr_mult: 2.0
78. }
79. }
80. layer {
81. bottom: "rfcn_cls"
82. bottom: "rois"
83. top: "psroipooled_cls_rois"
84. name: "psroipooled_cls_rois"
85. type: "PSROIPooling"
86. psroi_pooling_param {
87. spatial_scale: 0.0625
88. output_dim: 2  #类别数+1
89. group_size: 7
90. }
91. }
92. layer {
93. bottom: "rfcn_bbox"
94. bottom: "rois"
95. top: "psroipooled_loc_rois"
96. name: "psroipooled_loc_rois"
97. type: "PSROIPooling"
98. psroi_pooling_param {
99. spatial_scale: 0.0625
100. output_dim: 8#类别数*4
101. group_size: 7
102. }
103. }

2.修改/py-R-FCN/models/pascal_voc/ResNet-50/rfcn_end2end/class-aware/test.prototxt

1. layer {
2. bottom: "conv_new_1"
3. top: "rfcn_cls"
4. name: "rfcn_cls"
5. type: "Convolution"
6. convolution_param {
7. num_output: 98 #21*(7^2) cls_num*(score_maps_size^2)(类别数+1)*2
8. kernel_size: 1
9. pad: 0
10. weight_filler {
11. type: "gaussian"
12. std: 0.01
13. }
14. bias_filler {
15. type: "constant"
16. value: 0
17. }
18. }
19. param {
20. lr_mult: 1.0
21. }
22. param {
23. lr_mult: 2.0
24. }
25. }
26. layer {
27. bottom: "conv_new_1"
28. top: "rfcn_bbox"
29. name: "rfcn_bbox"
30. type: "Convolution"
31. convolution_param {
32. num_output: 392 #8*(7^2) cls_num*(score_maps_size^2)（类别数+1）*49*4
33. kernel_size: 1
34. pad: 0
35. weight_filler {
36. type: "gaussian"
37. std: 0.01
38. }
39. bias_filler {
40. type: "constant"
41. value: 0
42. }
43. }
44. param {
45. lr_mult: 1.0
46. }
47. param {
48. lr_mult: 2.0
49. }
50. }
51. layer {
52. bottom: "rfcn_cls"
53. bottom: "rois"
54. top: "psroipooled_cls_rois"
55. name: "psroipooled_cls_rois"
56. type: "PSROIPooling"
57. psroi_pooling_param {
58. spatial_scale: 0.0625
59. output_dim: 2 #（类别数+1）
60. group_size: 7
61. }
62. }
63. layer {
64. bottom: "rfcn_bbox"
65. bottom: "rois"
66. top: "psroipooled_loc_rois"
67. name: "psroipooled_loc_rois"
68. type: "PSROIPooling"
69. psroi_pooling_param {
70. spatial_scale: 0.0625
71. output_dim: 8 #（类别数+1）*4
72. group_size: 7
73. }
74. }
75. layer {
76. name: "cls_prob_reshape"
77. type: "Reshape"
78. bottom: "cls_prob_pre"
79. top: "cls_prob"
80. reshape_param {
81. shape {
82. dim: -1
83. dim: 2 #（类别数+1）
84. }
85. }
86. }
87. layer {
88. name: "bbox_pred_reshape"
89. type: "Reshape"
90. bottom: "bbox_pred_pre"
91. top: "bbox_pred"
92. reshape_param {
93. shape {
94. dim: -1
95. dim: 8 #（类别数+1）*4
96. }
97. }
98. }

3.修改/py-R-FCN/lib/datasets/pascal_voc.py

1. class pascal_voc(imdb):
2. def __init__(self, image_set, year, devkit_path=None):
3. imdb.__init__(self, 'voc_' + year + '_' + image_set)
4. self._year = year
5. self._image_set = image_set
6. self._devkit_path = self._get_default_path() if devkit_path is None \
7. else devkit_path
8. self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
9. self._classes = ('__background__', # always index 0
10. 'aeroplane')
11. self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
12. self._image_ext = '.jpg'
13. 修改self._classes为你的类别加背景。

4./py-R-FCN/lib/datasets/factory.py修改

1. for year in ['2007', '2012','2001','2002','2006','5000']:
2. for split in ['train', 'val', 'trainval', 'test']:
3. name = 'voc_{}_{}'.format(year, split)
4. __sets[name] = (lambda split=split, year=year: pascal_voc(split, year))
5. 我的数据集叫：VOC5000，所以把5000加到年份当中。

5/py-R-FCN/experiments/scripts/rfcn_end2end_ohem.sh修改

1. case $DATASET in
2. pascal_voc)
3. TRAIN_IMDB="voc_5000_trainval"
4. TEST_IMDB="voc_5000_test"
5. PT_DIR="pascal_voc"
6. ITERS=4000
7. ;;
8. 把训练数据集和测试数据集改为你的数据集，迭代次数改为4000。

开始训练：./experiments/scripts/rfcn_end2end_ohem.sh 0 ResNet-50 pascal_voc

迭代4000次，取得了81.2%的精度。