[C++ API] 如何使用rknn_init初始化多个模型

protossw512 发表于 2019-3-7 11:40
你好，你在c++运行的时候有发现c++下面跑模型比python下面慢么？

推理速度还好，主要是init时间太长了

nevin007 发表于 2019-3-7 13:41
推理速度还好，主要是init时间太长了

我今天专门分别在两边测试了下，发现c++ inference的速度比Python慢差不多一倍。不知道是哪里的问题。。你的c++ api是0.9.3吗？

protossw512 发表于 2019-3-7 16:36
我今天专门分别在两边测试了下，发现c++ inference的速度比Python慢差不多一倍。不知道是哪里的问题。。 ...

你好，我用的C++API版本是0.9.3，我测试过它自带的mobilenet-ssd，用SDK自带的测试函数：python约10ms，c++约12ms，你是怎么测试的？

nevin007 发表于 2019-3-7 16:48
你好，我用的C++API版本是0.9.3，我测试过它自带的mobilenet-ssd，用SDK自带的测试函数：python约10ms，c ...

奇怪了，我这里直接跑那个rknn_ssd需要22ms。你是在pc上交叉编译好了然后再在3399pro上运行的吗？还是直接在3399pro上编译运行的？我是后者。

protossw512 发表于 2019-3-8 05:24
奇怪了，我这里直接跑那个rknn_ssd需要22ms。你是在pc上交叉编译好了然后再在3399pro上运行的吗？还是直 ...

我终于找到原因了，因为我在init的时候加了RKNN_FLAG_COLLECT_PERF_MASK的flag,所以速度会变慢。。。然而不用加也能够测试速度。

protossw512 发表于 2019-3-8 07:09
我终于找到原因了，因为我在init的时候加了RKNN_FLAG_COLLECT_PERF_MASK的flag,所以速度会变慢。。。然而 ...

那你能同时初始化多个模型再做推理么

nevin007 发表于 2019-3-8 09:21
那你能同时初始化多个模型再做推理么

我还没试过，项目暂时还没用到多个模型。你是怎么实现的？是同样的rknn_context init多次么？ 还是说不同的rknn_context？

protossw512 发表于 2019-3-9 05:16
我还没试过，项目暂时还没用到多个模型。你是怎么实现的？是同样的rknn_context init多次么？ 还是说不同 ...

不同的context，我试过python可以，c++不行...

nevin007 发表于 2019-3-11 09:30
不同的context，我试过python可以，c++不行...

I rewrite the official demo to init two models, it works.
just for test，ignore the dirty code.
code：

1. #include <stdio.h>
   
2. #include <stdint.h>
   
3. #include <stdlib.h>
   
4. #include <fstream>
   
5. #include <iostream>
   
6. #include <algorithm>
   
7. #include <queue>
   
8. #include <sys/time.h>
   
9. 
   
10. #include "rknn_api.h"
    
11. #include "opencv2/core/core.hpp"
    
12. #include "opencv2/imgproc/imgproc.hpp"
    
13. #include "opencv2/highgui/highgui.hpp"
    
14. 
    
15. using namespace std;
    
16. 
    
17. template <class T>
    
18. void get_top_n(T* prediction, int prediction_size, size_t num_results,
    
19.                float threshold, std::vector<std::pair<float, int>>* top_results,
    
20.                bool input_floating) {
    
21.   // Will contain top N results in ascending order.
    
22.   std::priority_queue<std::pair<float, int>, std::vector<std::pair<float, int>>,
    
23.                       std::greater<std::pair<float, int>>>
    
24.       top_result_pq;
    
25. 
    
26.   const long count = prediction_size;  // NOLINT(runtime/int)
    
27.   for (int i = 0; i < count; ++i) {
    
28.     float value;
    
29.     if (input_floating)
    
30.       value = prediction[i];
    
31.     else
    
32.       value = prediction[i] / 255.0;
    
33.     // Only add it if it beats the threshold and has a chance at being in
    
34.     // the top N.
    
35.     if (value < threshold) {
    
36.       continue;
    
37.     }
    
38. 
    
39.     top_result_pq.push(std::pair<float, int>(value, i));
    
40. 
    
41.     // If at capacity, kick the smallest value out.
    
42.     if (top_result_pq.size() > num_results) {
    
43.       top_result_pq.pop();
    
44.     }
    
45.   }
    
46. 
    
47.   // Copy to output vector and reverse into descending order.
    
48.   while (!top_result_pq.empty()) {
    
49.     top_results->push_back(top_result_pq.top());
    
50.     top_result_pq.pop();
    
51.   }
    
52.   std::reverse(top_results->begin(), top_results->end());
    
53. }
    
54. 
    
55. int ReadLabelsFile(const string& file_name,
    
56.                             std::vector<string>* result,
    
57.                             size_t* found_label_count) {
    
58.   std::ifstream file(file_name);
    
59.   if (!file) {
    
60.     std::cerr << "Labels file " << file_name << " not found\n";
    
61.     return -1;
    
62.   }
    
63.   result->clear();
    
64.   string line;
    
65.   while (std::getline(file, line)) {
    
66.     result->push_back(line);
    
67.   }
    
68.   *found_label_count = result->size();
    
69.   const int padding = 16;
    
70.   while (result->size() % padding) {
    
71.     result->emplace_back();
    
72.   }
    
73.   return 0;
    
74. }
    
75. 
    
76. int main(int argc, char** argv)
    
77. {
    
78.     const char *img_path = "/home/toybrick/work/test/tmp/dog.jpg";
    
79.     const char *model_path = "/home/toybrick/work/test/tmp/mobilenet_v1-tf.rknn";
    
80.     const char *model_path2 = "/home/toybrick/work/test/tmp/mobilenet_ssd.rknn";
    
81.     const char *lable_path = "/home/toybrick/work/test/tmp/labels.txt";
    
82.     const int output_elems = 1001;
    
83. 
    
84.     const int img_width = 224;
    
85.     const int img_height = 224;
    
86.     const int img_channels = 3;
    
87. 
    
88.     const int input_index = 0;      // node name "input"
    
89.     const int output_index = 0;     // node name "MobilenetV1/Predictions/Reshape_1"
    
90. 
    
91.     // Load image
    
92.     cv::Mat img = cv::imread(img_path, 1);
    
93.     if(!img.data) {
    
94.         printf("cv::imread %s fail!\n", img_path);
    
95.         return -1;
    
96.     }
    
97.     if(img.cols != img_width || img.rows != img_height)
    
98.         cv::resize(img, img, cv::Size(img_width, img_height), (0, 0), (0, 0), cv::INTER_LINEAR);
    
99. 
    
100.     //BGR->RGB
     
101.     cv::cvtColor(img, img, cv::COLOR_BGR2RGB);
     
102. 
     
103.     // Load model
     
104.     FILE *fp = fopen(model_path, "rb");
     
105.     if(fp == NULL) {
     
106.         printf("fopen %s fail!\n", model_path);
     
107.         return -1;
     
108.     }
     
109.     fseek(fp, 0, SEEK_END);
     
110.     int model_len = ftell(fp);
     
111.     void *model = malloc(model_len);
     
112.     fseek(fp, 0, SEEK_SET);
     
113.     if(model_len != fread(model, 1, model_len, fp)) {
     
114.         printf("fread %s fail!\n", model_path);
     
115.         free(model);
     
116.         return -1;
     
117.     }
     
118. 
     
119.     // Start Inference
     
120.     rknn_input inputs[1];
     
121.     rknn_output outputs[1];
     
122.     rknn_tensor_attr output0_attr;
     
123. 
     
124.     int ret = 0;
     
125.     void *model2;
     
126.     rknn_context ctx1 = 0;
     
127.     rknn_context ctx2 = 0;
     
128. 
     
129.     ret = rknn_init(&ctx1, model, model_len, RKNN_FLAG_PRIOR_MEDIUM);
     
130.     if(ret < 0) {
     
131.         printf("rknn_init fail! ret=%d\n", ret);
     
132.         goto Error;
     
133.     }
     
134. 
     
135.     printf("rknn_init 1 succeed! ret=%d\n", ret);
     
136. 
     
137.     fclose(fp);
     
138.     model_len = 0;
     
139. 
     
140.     // Load model
     
141.     fp = fopen(model_path2, "rb");
     
142.     if(fp == NULL) {
     
143.         printf("fopen %s fail!\n", model_path);
     
144.         return -1;
     
145.     }
     
146.     fseek(fp, 0, SEEK_END);
     
147.     model_len = ftell(fp);
     
148.     model2 = malloc(model_len);
     
149.     fseek(fp, 0, SEEK_SET);
     
150.     if(model_len != fread(model2, 1, model_len, fp)) {
     
151.         printf("fread %s fail!\n", model_path2);
     
152.         free(model2);
     
153.         return -1;
     
154.     }
     
155. 
     
156.     ret = rknn_init(&ctx2, model2, model_len, RKNN_FLAG_PRIOR_MEDIUM);
     
157.     if(ret < 0) {
     
158.         printf("rknn_init fail! ret=%d\n", ret);
     
159.         goto Error;
     
160.     }
     
161. 
     
162.     printf("rknn_init 2 succeed! ret=%d\n", ret);
     
163. 
     
164.     output0_attr.index = 0;
     
165.     ret = rknn_query(ctx1, RKNN_QUERY_OUTPUT_ATTR, &output0_attr, sizeof(output0_attr));
     
166.     if(ret < 0) {
     
167.         printf("rknn_query fail! ret=%d\n", ret);
     
168.         goto Error;
     
169.     }
     
170. 
     
171.     inputs[0].index = input_index;
     
172.     inputs[0].buf = img.data;
     
173.     inputs[0].size = img_width * img_height * img_channels;
     
174.     inputs[0].pass_through = false;
     
175.     inputs[0].type = RKNN_TENSOR_UINT8;
     
176.     inputs[0].fmt = RKNN_TENSOR_NHWC;
     
177.     ret = rknn_inputs_set(ctx1, 1, inputs);
     
178.     if(ret < 0) {
     
179.         printf("rknn_input_set fail! ret=%d\n", ret);
     
180.         goto Error;
     
181.     }
     
182. 
     
183.     ret = rknn_run(ctx1, nullptr);
     
184.     if(ret < 0) {
     
185.         printf("rknn_run fail! ret=%d\n", ret);
     
186.         goto Error;
     
187.     }
     
188. 
     
189.     outputs[0].want_float = true;
     
190.     outputs[0].is_prealloc = false;
     
191.     ret = rknn_outputs_get(ctx1, 1, outputs, nullptr);
     
192.     if(ret < 0) {
     
193.         printf("rknn_outputs_get fail! ret=%d\n", ret);
     
194.         goto Error;
     
195.     }
     
196. 
     
197.     // Process output
     
198.     if(outputs[0].size == output0_attr.n_elems * sizeof(float))
     
199.     {
     
200.         const size_t num_results = 5;
     
201.         const float threshold = 0.001f;
     
202. 
     
203.         std::vector<std::pair<float, int>> top_results;
     
204.         get_top_n<float>((float*)outputs[0].buf, output_elems,
     
205.                            num_results, threshold, &top_results, true);
     
206. 
     
207.         std::vector<string> labels;
     
208.         size_t label_count;
     
209.         if (!ReadLabelsFile(lable_path, &labels, &label_count)) {
     
210.             for (const auto& result : top_results) {
     
211.                 const float confidence = result.first;
     
212.                 const int index = result.second;
     
213.                 std::cout << confidence << ": " << index << " " << labels[index] << "\n";
     
214.             }
     
215.         }
     
216.     }
     
217.     else
     
218.     {
     
219.         printf("rknn_outputs_get fail! get output_size = [%d], but expect %u!\n",
     
220.             outputs[0].size, (uint32_t)(output0_attr.n_elems * sizeof(float)));
     
221.     }
     
222. 
     
223.     rknn_outputs_release(ctx1, 1, outputs);
     
224. 
     
225. Error:
     
226.     if(ctx1 > 0)        rknn_destroy(ctx1);
     
227.     if(model)           free(model);
     
228.     if(fp)              fclose(fp);
     
229.     return 0;
     
230. }
     

复制代码

outputs：

[toybrick@localhost build]$ ./rknn_mobilenet
rknn_init 1 succeed! ret=0
rknn_init 2 succeed! ret=0
0.842285: 156 Shih-Tzu
0.0474243: 155 Pekinese
0.0256042: 188 Yorkshire terrier
0.0138168: 205 Lhasa
0.00746155: 263 Brabancon griffon