关于caffe转的rknn模型c++代码无法显示结果

你好，我自己的caffe模型转换好后，用py测试结果正确。
用咱们提供的rknn_ssd.cpp代码测试咱们自己的mobilenet ssd结果也是正常的，但是：
（1）修改rknn_ssd.cpp里面的类别个数，以及模型路径等去测试咱们提供的caffe文件夹中的vgg ssd时候不会显示任何结果；
（2）修改rknn_ssd.cpp里面的类别个数，以及模型路径等却测试我自己的mobilenet ssd结果也完全不搭边。
（3）我看咱们这个rknn_ssd.cpp代码是TensorFlow文件夹中的mobilenet ssd的测试demo，是否caffe的模型不能用？
（4）可以的话，麻烦可否一下以下几个宏的具体含义。
        #define NUM_RESULTS 2183            prior box个数/4？
        #define NUM_CLASSES 21                类别个数

        #define Y_SCALE 10.0f
        #define X_SCALE 10.0f
        #define H_SCALE 5.0f
        #define W_SCALE 5.0f
代码如下：

1. #include <stdio.h>
   
2. #include <stdint.h>
   
3. #include <stdlib.h>
   
4. #include <fstream>
   
5. #include <iostream>
   
6. #include <sys/time.h>
   
7. 
   
8. #include "rknn_api.h"
   
9. #include "opencv2/core/core.hpp"
   
10. #include "opencv2/imgproc/imgproc.hpp"
    
11. #include "opencv2/highgui/highgui.hpp"
    
12. 
    
13. #include <time.h>
    
14. 
    
15. using namespace std;
    
16. using namespace cv;
    
17. 
    
18. #define NUM_RESULTS         2183
    
19. #define NUM_CLASSES         21
    
20. 
    
21. #define Y_SCALE  10.0f
    
22. #define X_SCALE  10.0f
    
23. #define H_SCALE  5.0f
    
24. #define W_SCALE  5.0f
    
25. 
    
26. Scalar colorArray[10] = {
    
27.         Scalar(139,   0,   0, 255),
    
28.         Scalar(139,   0, 139, 255),
    
29.         Scalar(  0,   0, 139, 255),
    
30.         Scalar(  0, 100,   0, 255),
    
31.         Scalar(139, 139,   0, 255),
    
32.         Scalar(209, 206,   0, 255),
    
33.         Scalar(  0, 127, 255, 255),
    
34.         Scalar(139,  61,  72, 255),
    
35.         Scalar(  0, 255,   0, 255),
    
36.         Scalar(255,   0,   0, 255),
    
37. };
    
38. 
    
39. float MIN_SCORE = 0.7f;
    
40. 
    
41. float NMS_THRESHOLD = 0.45f;
    
42. 
    
43. 
    
44. int loadLabelName(string locationFilename, string* labels) {
    
45.     ifstream fin(locationFilename);
    
46.     string line;
    
47.     int lineNum = 0;
    
48.     while(getline(fin, line))
    
49.     {
    
50.         labels[lineNum] = line;
    
51.         lineNum++;
    
52.     }
    
53.     return 0;
    
54. }
    
55. 
    
56. int loadCoderOptions(string locationFilename, float (*boxPriors)[NUM_RESULTS])
    
57. {
    
58.     const char *d = ", ";
    
59.     ifstream fin(locationFilename);
    
60.     string line;
    
61.     int lineNum = 0;
    
62.     while(getline(fin, line))
    
63.     {
    
64.         char *line_str = const_cast<char *>(line.c_str());
    
65.         char *p;
    
66.         p = strtok(line_str, d);
    
67.         int priorIndex = 0;
    
68.         while (p) {
    
69.             float number = static_cast<float>(atof(p));
    
70.             boxPriors[lineNum][priorIndex++] = number;
    
71.             p=strtok(nullptr, d);
    
72.         }
    
73.         if (priorIndex != NUM_RESULTS) {
    
74.             return -1;
    
75.         }
    
76.         lineNum++;
    
77.     }
    
78.     return 0;
    
79. 
    
80. }
    
81. 
    
82. float CalculateOverlap(float xmin0, float ymin0, float xmax0, float ymax0, float xmin1, float ymin1, float xmax1, float ymax1) {
    
83.     float w = max(0.f, min(xmax0, xmax1) - max(xmin0, xmin1));
    
84.     float h = max(0.f, min(ymax0, ymax1) - max(ymin0, ymin1));
    
85.     float i = w * h;
    
86.     float u = (xmax0 - xmin0) * (ymax0 - ymin0) + (xmax1 - xmin1) * (ymax1 - ymin1) - i;
    
87.     return u <= 0.f ? 0.f : (i / u);
    
88. }
    
89. 
    
90. float expit(float x) {
    
91.     return (float) (1.0 / (1.0 + exp(-x)));
    
92. }
    
93. 
    
94. void decodeCenterSizeBoxes(float* predictions, float (*boxPriors)[NUM_RESULTS]) {
    
95. 
    
96.     for (int i = 0; i < NUM_RESULTS; ++i) {
    
97.         float ycenter = predictions[i*4+0] / Y_SCALE * boxPriors[2][i] + boxPriors[0][i];
    
98.         float xcenter = predictions[i*4+1] / X_SCALE * boxPriors[3][i] + boxPriors[1][i];
    
99.         float h = (float) exp(predictions[i*4 + 2] / H_SCALE) * boxPriors[2][i];
    
100.         float w = (float) exp(predictions[i*4 + 3] / W_SCALE) * boxPriors[3][i];
     
101. 
     
102.         float ymin = ycenter - h / 2.0f;
     
103.         float xmin = xcenter - w / 2.0f;
     
104.         float ymax = ycenter + h / 2.0f;
     
105.         float xmax = xcenter + w / 2.0f;
     
106. 
     
107.         predictions[i*4 + 0] = ymin;
     
108.         predictions[i*4 + 1] = xmin;
     
109.         predictions[i*4 + 2] = ymax;
     
110.         predictions[i*4 + 3] = xmax;
     
111.     }
     
112. }
     
113. 
     
114. int scaleToInputSize(float * outputClasses, int (*output)[NUM_RESULTS], int numClasses)
     
115. {
     
116.     int validCount = 0;
     
117.     // Scale them back to the input size.
     
118.     for (int i = 0; i < NUM_RESULTS; ++i) {
     
119.         float topClassScore = static_cast<float>(-1000.0);
     
120.         int topClassScoreIndex = -1;
     
121. 
     
122.         // Skip the first catch-all class.
     
123.         for (int j = 1; j < numClasses; ++j) {
     
124.             float score = expit(outputClasses[i*numClasses+j]);
     
125.             if (score > topClassScore) {
     
126.                 topClassScoreIndex = j;
     
127.                 topClassScore = score;
     
128.             }
     
129.         }
     
130. 
     
131.         if (topClassScore >= MIN_SCORE) {
     
132.             output[0][validCount] = i;
     
133.             output[1][validCount] = topClassScoreIndex;
     
134.             ++validCount;
     
135.         }
     
136.     }
     
137. 
     
138.     return validCount;
     
139. }
     
140. 
     
141. int nms(int validCount, float* outputLocations, int (*output)[NUM_RESULTS])
     
142. {
     
143.     for (int i=0; i < validCount; ++i) {
     
144.         if (output[0][i] == -1) {
     
145.             continue;
     
146.         }
     
147.         int n = output[0][i];
     
148.         for (int j=i + 1; j<validCount; ++j) {
     
149.             int m = output[0][j];
     
150.             if (m == -1) {
     
151.                 continue;
     
152.             }
     
153.             float xmin0 = outputLocations[n*4 + 1];
     
154.             float ymin0 = outputLocations[n*4 + 0];
     
155.             float xmax0 = outputLocations[n*4 + 3];
     
156.             float ymax0 = outputLocations[n*4 + 2];
     
157. 
     
158.             float xmin1 = outputLocations[m*4 + 1];
     
159.             float ymin1 = outputLocations[m*4 + 0];
     
160.             float xmax1 = outputLocations[m*4 + 3];
     
161.             float ymax1 = outputLocations[m*4 + 2];
     
162. 
     
163.             float iou = CalculateOverlap(xmin0, ymin0, xmax0, ymax0, xmin1, ymin1, xmax1, ymax1);
     
164. 
     
165.             if (iou >= NMS_THRESHOLD) {
     
166.                 output[0][j] = -1;
     
167.             }
     
168.         }
     
169.     }
     
170. 
     
171.     return 0;
     
172. }
     
173. 
     
174. int main(int argc, char** argv)
     
175. {
     
176.     const char *img_path = "./vgg_ssd/road_300x300.jpg";
     
177.     const char *model_path = "./vgg_ssd/vgg_ssd.rknn";
     
178.     const char *label_path = "./vgg_ssd/label.txt";
     
179.     const char *box_priors_path = "./vgg_ssd/mbox_priorbox_97.txt";
     
180. 
     
181.     //const char *img_path = "/tmp/road.bmp";
     
182.     //const char *model_path = "/tmp/mobilenet_ssd.rknn";
     
183.     //const char *label_path = "/tmp/coco_labels_list.txt";
     
184.     //const char *box_priors_path = "/tmp/box_priors.txt";
     
185. 
     
186.     const int img_width = 300;
     
187.     const int img_height = 300;
     
188.     const int img_channels = 3;
     
189.     const int input_index = 0;      // node name "Preprocessor/sub"
     
190. 
     
191.     const int output_elems1 = NUM_RESULTS * 4;
     
192.     const uint32_t output_size1 = output_elems1 * sizeof(float);
     
193.     const int output_index1 = 0;    // node name "concat"
     
194. 
     
195.     const int output_elems2 = NUM_RESULTS * NUM_CLASSES;
     
196.     const uint32_t output_size2 = output_elems2 * sizeof(float);
     
197.     const int output_index2 = 1;    // node name "concat_1"
     
198. 
     
199.     // Load image
     
200.     cv::Mat img = cv::imread(img_path, 1);
     
201.     if(!img.data) {
     
202.         printf("cv::imread %s fail!\n", img_path);
     
203.         return -1;
     
204.     }
     
205.     if(img.cols != img_width || img.rows != img_height)
     
206.         cv::resize(img, img, cv::Size(img_width, img_height), (0, 0), (0, 0), cv::INTER_LINEAR);
     
207. 
     
208.     // Load model
     
209.     FILE *fp = fopen(model_path, "rb");
     
210.     if(fp == NULL) {
     
211.         printf("fopen %s fail!\n", model_path);
     
212.         return -1;
     
213.     }
     
214.     fseek(fp, 0, SEEK_END);
     
215.     int model_len = ftell(fp);
     
216.     void *model = malloc(model_len);
     
217.     fseek(fp, 0, SEEK_SET);
     
218.     if(model_len != fread(model, 1, model_len, fp)) {
     
219.         printf("fread %s fail!\n", model_path);
     
220.         free(model);
     
221.         return -1;
     
222.     }
     
223. 
     
224.     // Start Inference
     
225.     rknn_input inputs[1];
     
226.     rknn_output outputs[2];
     
227.     rknn_tensor_attr outputs_attr[2];
     
228. 
     
229.     int ret = 0;
     
230.     rknn_context ctx = 0;
     
231. 
     
232.     ret = rknn_init(&ctx, model, model_len, RKNN_FLAG_PRIOR_MEDIUM);
     
233.     if(ret < 0) {
     
234.         printf("rknn_init fail! ret=%d\n", ret);
     
235.         goto Error;
     
236.     }
     
237. 
     
238.     outputs_attr[0].index = 0;
     
239.     ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(outputs_attr[0]), sizeof(outputs_attr[0]));
     
240.     if(ret < 0) {
     
241.         printf("rknn_query fail! ret=%d\n", ret);
     
242.         goto Error;
     
243.     }
     
244. 
     
245.     outputs_attr[1].index = 1;
     
246.     ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(outputs_attr[1]), sizeof(outputs_attr[1]));
     
247.     if(ret < 0) {
     
248.         printf("rknn_query fail! ret=%d\n", ret);
     
249.         goto Error;
     
250.     }
     
251. 
     
252.     inputs[0].index = input_index;
     
253.     inputs[0].buf = img.data;
     
254.     inputs[0].size = img_width * img_height * img_channels;
     
255.     inputs[0].pass_through = false;
     
256.     inputs[0].type = RKNN_TENSOR_UINT8;
     
257.     inputs[0].fmt = RKNN_TENSOR_NHWC;
     
258.     ret = rknn_inputs_set(ctx, 1, inputs);
     
259.     if(ret < 0) {
     
260.         printf("rknn_input_set fail! ret=%d\n", ret);
     
261.         goto Error;
     
262.     }
     
263. 
     
264.     ret = rknn_run(ctx, nullptr);
     
265.     if(ret < 0) {
     
266.         printf("rknn_run fail! ret=%d\n", ret);
     
267.         goto Error;
     
268.     }
     
269. 
     
270.     outputs[0].want_float = true;
     
271.     outputs[0].is_prealloc = false;
     
272.     outputs[1].want_float = true;
     
273.     outputs[1].is_prealloc = false;
     
274.      
     
275. 
     
276.     clock_t start,finish;
     
277.     double totaltime;
     
278.     start = clock();
     
279.     ret = rknn_outputs_get(ctx, 2, outputs, nullptr);
     
280.     finish=clock();
     
281.     totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
     
282.     cout<<"程序的inference时间为"<<totaltime<<"秒！"<<endl;
     
283. 
     
284. 
     
285.     if(ret < 0) {
     
286.         printf("rknn_outputs_get fail! ret=%d\n", ret);
     
287.         goto Error;
     
288.     }
     
289.      
     
290.      
     
291.     // Process output
     
292.     if(outputs[0].size == outputs_attr[0].n_elems*sizeof(float) && outputs[1].size == outputs_attr[1].n_elems*sizeof(float))
     
293.     {
     
294.         float boxPriors[4][NUM_RESULTS];
     
295.         string labels[91];
     
296. 
     
297.         /* load label and boxPriors */
     
298.         loadLabelName(label_path, labels);
     
299.         loadCoderOptions(box_priors_path, boxPriors);
     
300. 
     
301.         float* predictions = (float*)outputs[0].buf;
     
302.         float* outputClasses = (float*)outputs[1].buf;
     
303. 
     
304.         int output[2][NUM_RESULTS];
     
305. 
     
306.         /* transform */
     
307.         decodeCenterSizeBoxes(predictions, boxPriors);
     
308. 
     
309.         start = clock();
     
310.         int validCount = scaleToInputSize(outputClasses ,output, NUM_CLASSES);
     
311.         finish=clock();
     
312.         totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
     
313.         cout<<"程序的scaleToInputSize时间为"<<totaltime<<"秒！"<<endl;
     
314. 
     
315. 
     
316.         printf("validCount: %d\n", validCount);
     
317. 
     
318.         if (validCount < 100) {
     
319.             /* detect nest box */
     
320.             start = clock();
     
321.             nms(validCount, predictions, output);
     
322.             finish=clock();
     
323.             totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
     
324.             cout<<"程序的nms时间为"<<totaltime<<"秒！"<<endl;
     
325. 
     
326. 
     
327. 
     
328. 
     
329.             start = clock();
     
330.             Mat rgba = imread(img_path, CV_LOAD_IMAGE_UNCHANGED);
     
331.             cv::resize(rgba, rgba, cv::Size(300, 300), (0, 0), (0, 0), cv::INTER_LINEAR);
     
332.             finish=clock();
     
333.             totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
     
334.             cout<<"程序的imread时间为"<<totaltime<<"秒！"<<endl;
     
335.             
     
336.             start = clock();
     
337.             /* box valid detect target */
     
338.             for (int i = 0; i < validCount; ++i) {
     
339.                 if (output[0][i] == -1) {
     
340.                     continue;
     
341.                 }
     
342.                 int n = output[0][i];
     
343.                 int topClassScoreIndex = output[1][i];
     
344. 
     
345.                 int x1 = static_cast<int>(predictions[n * 4 + 1] * rgba.cols);
     
346.                 int y1 = static_cast<int>(predictions[n * 4 + 0] * rgba.rows);
     
347.                 int x2 = static_cast<int>(predictions[n * 4 + 3] * rgba.cols);
     
348.                 int y2 = static_cast<int>(predictions[n * 4 + 2] * rgba.rows);
     
349. 
     
350.                 string label = labels[topClassScoreIndex];
     
351. 
     
352.                 std::cout << label << "\t@ (" << x1 << ", " << y1 << ") (" << x2 << ", " << y2 << ")" << "\n";
     
353. 
     
354.                 rectangle(rgba, Point(x1, y1), Point(x2, y2), colorArray[topClassScoreIndex%10], 3);
     
355.                 putText(rgba, label, Point(x1, y1 - 12), 1, 2, Scalar(0, 255, 0, 255));
     
356.             }
     
357.             imwrite("out.jpg", rgba);
     
358.             //printf("write out.jpg succ!\n");
     
359.             finish=clock();
     
360.             totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
     
361.             cout<<"程序的draw时间为"<<totaltime<<"秒！"<<endl;
     
362. 
     
363.         } else {
     
364.             printf("validCount too much!\n");
     
365.         }
     
366.     }
     
367.     else
     
368.     {
     
369.         printf("rknn_outputs_get fail! get outputs_size = [%d, %d], but expect [%lu, %lu]!\n",
     
370.             outputs[0].size, outputs[1].size, outputs_attr[0].n_elems*sizeof(float), outputs_attr[1].n_elems*sizeof(float));
     
371.     }
     
372.    
     
373.    
     
374.     rknn_outputs_release(ctx, 2, outputs);
     
375. 
     
376. Error:
     
377.     if(ctx)             rknn_destroy(ctx);
     
378.     if(model)           free(model);
     
379.     if(fp)              fclose(fp);
     
380.     return 0;
     
381. }

复制代码

你的Python代码可以的话，那你对模型的输出格式和后处理有一定的概念，有几个点可以确认一下。
1.目前最新的rknn-toolkit，输出结果时，应该是有保留结果信息的，你可以在Python打印出来看一下，你的模型和mobilenet-ssd输出的格式不一定一致。
2.后处理不是简单套进去就可以，mobilenet-ssd只是提供参考，具体的后处理你要参考你Python的写法。
3.你可以在C里面把outputs的数据n_elems打印出来，跟你Python代码的结果对比一下。

troy 发表于 2020-6-12 11:59
你的Python代码可以的话，那你对模型的输出格式和后处理有一定的概念，有几个点可以确认一下。
1.目前最新 ...

谢谢回复。自己已经解决。

ylc123 发表于 2020-6-12 16:27
谢谢回复。自己已经解决。

你好，请问是怎么解决的？我也遇到这个问题了，能请教一下吗？