对训练得到的模型进行测试

原文：http://blog.csdn.net/jiongnima/article/details/52681816?locationNum=11&fps=1http://

请各位读者朋友们注意，鉴于大家比较关心测试caffe训练完毕的模型的步骤，笔者特地将在c++程序中调用caffe训练完毕的模型与classification.cpp解析整理成了完整的博客：

classification.cpp解析与使用cmake编译classification详见：在c++程序中调用caffe训练完毕的模型进行分类

工程化classification，将检测接口用cmake编译为.so文件并在程序中调用详见：caffe工程化实例：将caffe分类程序编译成.so文件并在程序中调用

下面是之前的原文：

续caffe初探1，2，3，在我们训练出自己的模型之后，就可以测试，或者说使用我们的模型来分类了，在我们使用网络模型对单张图片进行分类测试之前笔者还是列出测试所需物资清单：

兹测试所需物资清单如下：

（1）类名文件，未准备。标定分类名称的txt文件。

（2）测试图片，未准备。准备若干张供网络模型分类的图片。

（3）后缀名称为.caffemodel的网络模型文件，已准备。笔者已经在caffe初探3中生成了若干网络模型文件，在这里我们可以选择迭代10000次的模型文件，里面包含了网络参数。

（4）网络架构说明文件，未准备。网络架构说明文件是说明使用网络时的网络架构，该文件与我们训练模型时使用的./caffe/forkrecognition/train_val.prototxt文件类似，后续会详细说明。

（5）均值文件，已准备。在这里我们就使用在caffe初探2-3中训练模型时使用的均值文件。

（6）分类器，未准备。用来调用以上5类资源的文件。

一目了然，我们还有四类文件没有准备，那么，下面笔者就阐述一下怎么准备这四样东西。

1、有关类名文件的准备

类名文件为txt格式文件，作用是规定分类号对应的类名称，格式为：分类号：类名；一行对应一个类。因为我们是用来分类包含岔路口的图片和不包含岔路口的图片，因此就两类。在./caffe/forkrecognition/目录下面建立words.txt文件，文件内容如下所示。

2、测试图片的准备

因为笔者训练的模型是用来判断图片有没有岔路口，因此笔者准备了7张包含岔路口的图片和7张不包含岔路口的普通道路图片，并把他们尺寸调试成227*227的，放在./caffe/forkrecognition/test_images/目录下面，如下图所示。

3、网络架构说明文件

在我们使用分类器结合训练出的模型分类图片时，同样需要指定网络架构，有看过笔者前面的文章“caffe初探2：有关网络设计的探索”的读者朋友应该记得，笔者在该文章中特意提到了我们在训练模型时设计的网络结构中四个特殊的层，是训练模型时特别需要的。而我们在使用模型时使用的网络架构与训练模型时使用的网络架构的不同之处主要就在于这四个层。我们复制训练时使用的网络架构文件./caffe/forkrecognition/train_val.prototxt文件到./caffe/forkrecognition/目录下，新建名为deploy.prototxt的文件，文件内容如下所示。

[plain] view plain copy

1. name: "AlexNet"  
2. layer {  
3.   name: "forkdata"  
4.   type: "Input"  
5.   top: "data"  
6.   input_param { shape: { dim: 1 dim: 3 dim: 227 dim: 227 } }#我们只输入一张图片，因此第一个参数（批次）为1，第二个参数表示图片为三通道的，第三地四个参数表示图片的width与height。  
7. }#之后部分和训练网络时使用的./caffe/forkrecognition/train_val.prototxt文件几乎一样，只是去掉了卷积层，全连接层的参数设置，详见代码  
8. layer {  
9.   name: "conv1"  
10.   type: "Convolution"  
11.   bottom: "data"  
12.   top: "conv1"  
13.   param {  
14.     lr_mult: 1  
15.     decay_mult: 1  
16.   }  
17.   param {  
18.     lr_mult: 2  
19.     decay_mult: 0  
20.   }  
21.   convolution_param {  
22.     num_output: 96  
23.     kernel_size: 11  
24.     stride: 4  
25.   }  
26. }  
27. layer {  
28.   name: "relu1"  
29.   type: "ReLU"  
30.   bottom: "conv1"  
31.   top: "conv1"  
32. }  
33. layer {  
34.   name: "norm1"  
35.   type: "LRN"  
36.   bottom: "conv1"  
37.   top: "norm1"  
38.   lrn_param {  
39.     local_size: 5  
40.     alpha: 0.0001  
41.     beta: 0.75  
42.   }  
43. }  
44. layer {  
45.   name: "pool1"  
46.   type: "Pooling"  
47.   bottom: "norm1"  
48.   top: "pool1"  
49.   pooling_param {  
50.     pool: MAX  
51.     kernel_size: 3  
52.     stride: 2  
53.   }  
54. }  
55. layer {  
56.   name: "conv2"  
57.   type: "Convolution"  
58.   bottom: "pool1"  
59.   top: "conv2"  
60.   param {  
61.     lr_mult: 1  
62.     decay_mult: 1  
63.   }  
64.   param {  
65.     lr_mult: 2  
66.     decay_mult: 0  
67.   }  
68.   convolution_param {  
69.     num_output: 256  
70.     pad: 2  
71.     kernel_size: 5  
72.     group: 2  
73.   }  
74. }  
75. layer {  
76.   name: "relu2"  
77.   type: "ReLU"  
78.   bottom: "conv2"  
79.   top: "conv2"  
80. }  
81. layer {  
82.   name: "norm2"  
83.   type: "LRN"  
84.   bottom: "conv2"  
85.   top: "norm2"  
86.   lrn_param {  
87.     local_size: 5  
88.     alpha: 0.0001  
89.     beta: 0.75  
90.   }  
91. }  
92. layer {  
93.   name: "pool2"  
94.   type: "Pooling"  
95.   bottom: "norm2"  
96.   top: "pool2"  
97.   pooling_param {  
98.     pool: MAX  
99.     kernel_size: 3  
100.     stride: 2  
101.   }  
102. }  
103. layer {  
104.   name: "conv3"  
105.   type: "Convolution"  
106.   bottom: "pool2"  
107.   top: "conv3"  
108.   param {  
109.     lr_mult: 1  
110.     decay_mult: 1  
111.   }  
112.   param {  
113.     lr_mult: 2  
114.     decay_mult: 0  
115.   }  
116.   convolution_param {  
117.     num_output: 384  
118.     pad: 1  
119.     kernel_size: 3  
120.   }  
121. }  
122. layer {  
123.   name: "relu3"  
124.   type: "ReLU"  
125.   bottom: "conv3"  
126.   top: "conv3"  
127. }  
128. layer {  
129.   name: "conv4"  
130.   type: "Convolution"  
131.   bottom: "conv3"  
132.   top: "conv4"  
133.   param {  
134.     lr_mult: 1  
135.     decay_mult: 1  
136.   }  
137.   param {  
138.     lr_mult: 2  
139.     decay_mult: 0  
140.   }  
141.   convolution_param {  
142.     num_output: 384  
143.     pad: 1  
144.     kernel_size: 3  
145.     group: 2  
146.   }  
147. }  
148. layer {  
149.   name: "relu4"  
150.   type: "ReLU"  
151.   bottom: "conv4"  
152.   top: "conv4"  
153. }  
154. layer {  
155.   name: "conv5"  
156.   type: "Convolution"  
157.   bottom: "conv4"  
158.   top: "conv5"  
159.   param {  
160.     lr_mult: 1  
161.     decay_mult: 1  
162.   }  
163.   param {  
164.     lr_mult: 2  
165.     decay_mult: 0  
166.   }  
167.   convolution_param {  
168.     num_output: 256  
169.     pad: 1  
170.     kernel_size: 3  
171.     group: 2  
172.   }  
173. }  
174. layer {  
175.   name: "relu5"  
176.   type: "ReLU"  
177.   bottom: "conv5"  
178.   top: "conv5"  
179. }  
180. layer {  
181.   name: "pool5"  
182.   type: "Pooling"  
183.   bottom: "conv5"  
184.   top: "pool5"  
185.   pooling_param {  
186.     pool: MAX  
187.     kernel_size: 3  
188.     stride: 2  
189.   }  
190. }  
191. layer {  
192.   name: "fc6"  
193.   type: "InnerProduct"  
194.   bottom: "pool5"  
195.   top: "fc6"  
196.   param {  
197.     lr_mult: 1  
198.     decay_mult: 1  
199.   }  
200.   param {  
201.     lr_mult: 2  
202.     decay_mult: 0  
203.   }  
204.   inner_product_param {  
205.     num_output: 4096  
206.   }  
207. }  
208. layer {  
209.   name: "relu6"  
210.   type: "ReLU"  
211.   bottom: "fc6"  
212.   top: "fc6"  
213. }  
214. layer {  
215.   name: "drop6"  
216.   type: "Dropout"  
217.   bottom: "fc6"  
218.   top: "fc6"  
219.   dropout_param {  
220.     dropout_ratio: 0.5  
221.   }  
222. }  
223. layer {  
224.   name: "fc7"  
225.   type: "InnerProduct"  
226.   bottom: "fc6"  
227.   top: "fc7"  
228.   param {  
229.     lr_mult: 1  
230.     decay_mult: 1  
231.   }  
232.   param {  
233.     lr_mult: 2  
234.     decay_mult: 0  
235.   }  
236.   inner_product_param {  
237.     num_output: 4096  
238.   }  
239. }  
240. layer {  
241.   name: "relu7"  
242.   type: "ReLU"  
243.   bottom: "fc7"  
244.   top: "fc7"  
245. }  
246. layer {  
247.   name: "drop7"  
248.   type: "Dropout"  
249.   bottom: "fc7"  
250.   top: "fc7"  
251.   dropout_param {  
252.     dropout_ratio: 0.5  
253.   }  
254. }  
255. layer {  
256.   name: "forkfc8"  
257.   type: "InnerProduct"  
258.   bottom: "fc7"  
259.   top: "fc8"  
260.   param {  
261.     lr_mult: 1  
262.     decay_mult: 1  
263.   }  
264.   param {  
265.     lr_mult: 2  
266.     decay_mult: 0  
267.   }  
268.   inner_product_param {  
269.     num_output: 2  
270.   }  
271. }#之前的部分和训练网络时使用的./caffe/forkrecognition/train_val.prototxt文件几乎一样，只是去掉了卷积层，全连接层的参数设置  
272. layer {  #在使用训练好的模型时，不需要准确率层与损失层了，需要的是概率层，评估图片位于各个分类的概率。  
273.   name: "prob"  
274.   type: "Softmax"  
275.   bottom: "fc8"  
276.   top: "prob"  
277. }  

4、分类器

现在万事俱备，只欠东风，我们只需要构造分类器就能使用模型分类图片了。我们可以使用官方提供的分类器分类图片，官方提供了两种分类器接口，一种是c++接口，一种是python接口；在这里我们使用c++接口的分类器来分类图片。点开目录./caffe/examples/cpp_classification/目录，可以看到其中有两个文件，如下图所示。

其中classification.cpp就是分类器文件。让我们点开它旁边的readme.md文件查看它的用法，readme.md文件内容如下所示。

[plain] view plain copy

1. ---  
2. title: CaffeNet C++ Classification example  
3. description: A simple example performing image classification using the low-level C++ API.  
4. category: example  
5. include_in_docs: true  
6. priority: 10  
7. ---  
8.   
9. # Classifying ImageNet: using the C++ API  
10.   
11. Caffe, at its core, is written in C++. It is possible to use the C++  
12. API of Caffe to implement an image classification application similar  
13. to the Python code presented in one of the Notebook example. To look  
14. at a more general-purpose example of the Caffe C++ API, you should  
15. study the source code of the command line tool `caffe` in `tools/caffe.cpp`.  
16.   
17. ## Presentation  
18.   
19. A simple C++ code is proposed in  
20. `examples/cpp_classification/classification.cpp`. For the sake of  
21. simplicity, this example does not support oversampling of a single  
22. sample nor batching of multiple independant samples. This example is  
23. not trying to reach the maximum possible classification throughput on  
24. a system, but special care was given to avoid unnecessary  
25. pessimization while keeping the code readable.  
26.   
27. ## Compiling  
28.   
29. The C++ example is built automatically when compiling Caffe. To  
30. compile Caffe you should follow the documented instructions. The  
31. classification example will be built as `examples/classification.bin`   #classfication.cpp已经编译好了，生成了classification.bin文件  
32. in your build directory.  
33.   
34. ## Usage  
35.   
36. To use the pre-trained CaffeNet model with the classification example,  
37. you need to download it from the "Model Zoo" using the following  
38. script:  
39. ```  
40. ./scripts/download_model_binary.py models/bvlc_reference_caffenet  
41. ```  
42. The ImageNet labels file (also called the *synset file*) is also  
43. required in order to map a prediction to the name of the class:  
44. ```  
45. ./data/ilsvrc12/get_ilsvrc_aux.sh  
46. ```  
47. Using the files that were downloaded, we can classify the provided cat  
48. image (`examples/images/cat.jpg`) using this command:  
49. ```                                                 
50. ./build/examples/cpp_classification/classification.bin \              #在这里规定了调用分类器的方法  
51.   models/bvlc_reference_caffenet/deploy.prototxt \  
52.   models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \  
53.   data/ilsvrc12/imagenet_mean.binaryproto \  
54.   data/ilsvrc12/synset_words.txt \  
55.   examples/images/cat.jpg  
56. ```  
57. The output should look like this:  
58. ```  
59. ---------- Prediction for examples/images/cat.jpg ----------  
60. 0.3134 - "n02123045 tabby, tabby cat"  
61. 0.2380 - "n02123159 tiger cat"  
62. 0.1235 - "n02124075 Egyptian cat"  
63. 0.1003 - "n02119022 red fox, Vulpes vulpes"  
64. 0.0715 - "n02127052 lynx, catamount"  
65. ```  
66.   
67. ## Improving Performance  
68.   
69. To further improve performance, you will need to leverage the GPU  
70. more, here are some guidelines:  
71.   
72. * Move the data on the GPU early and perform all preprocessing  
73. operations there.  
74. * If you have many images to classify simultaneously, you should use  
75. batching (independent images are classified in a single forward pass).  
76. * Use multiple classification threads to ensure the GPU is always fully  
77. utilized and not waiting for an I/O blocked CPU thread.  

可见文件中详细阐述了分类器的用法，调用./caffe/build/examples/cpp_classification/文件目录下的classification.bin文件并传入五个参数：网络架构文件deploy.prototxt，训练生成的.caffemodel文件，均值文件，类名文件，测试图片。现在我们就利用此规范来测试某一张图片，如下图。

可见分类结果了，图中包含岔路口的概率为0.9627不包含岔路口的概率为0.0373。

大功告成！遗憾的是，笔者在整个训练及分类的过程中，由于数据集过小，使得结果的鲁棒性一般，有时会出错。

到这里为止，经过四期caffe初探，笔者已经完整地讲述了一遍caffe的分类用法及操作过程，也很希望各位读者朋友也能去了解与使用这一款强大的深度学习工具；同时，作为一个初涉机器学习领域的菜鸟，笔者也非常期待与各位读者朋友一起学习与交流，一起探索机器学习无边无际的知识海洋！

笔者在写作博客的时候，肯定会有一些谬误，万望各位读者朋友海涵，并诚恳地期待各位读者朋友能指出其中的不足，在此笔者表示最衷心的感谢。

读万卷书，行万里路，在向终点驰骋的途中，千万不要忽略一路上瑰丽的风景，祝各位读者朋友学业工作无往而不利！