1 // clang-format off
2 // Generated file (from: concat_zero_sized.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
5 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
6 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
7 OperandType type11(Type::TENSOR_FLOAT32, {0, 2, 2, 2});
8 OperandType type2(Type::TENSOR_FLOAT32, {0});
9 OperandType type3(Type::TENSOR_INT32, {0});
10 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
11 OperandType type5(Type::TENSOR_INT32, {1});
12 OperandType type6(Type::FLOAT32, {});
13 OperandType type7(Type::INT32, {});
14 OperandType type8(Type::BOOL, {});
15 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
16 // Phase 1, operands
17 auto scores = model->addOperand(&type0);
18 auto roi = model->addOperand(&type1);
19 auto param = model->addOperand(&type5);
20 auto param1 = model->addOperand(&type6);
21 auto param2 = model->addOperand(&type7);
22 auto param3 = model->addOperand(&type7);
23 auto param4 = model->addOperand(&type6);
24 auto param5 = model->addOperand(&type6);
25 auto param6 = model->addOperand(&type6);
26 auto scoresOut = model->addOperand(&type2);
27 auto roiOut = model->addOperand(&type4);
28 auto classesOut = model->addOperand(&type3);
29 auto batchSplitOut = model->addOperand(&type3);
30 auto in = model->addOperand(&type9);
31 auto param7 = model->addOperand(&type7);
32 auto param8 = model->addOperand(&type7);
33 auto param9 = model->addOperand(&type6);
34 auto param10 = model->addOperand(&type6);
35 auto param11 = model->addOperand(&type7);
36 auto param12 = model->addOperand(&type7);
37 auto layout = model->addOperand(&type8);
38 auto featureMap = model->addOperand(&type10);
39 auto param13 = model->addOperand(&type7);
40 auto out = model->addOperand(&type11);
41 // Phase 2, operations
42 static float scores_init[] = {0.9f, 0.1f};
43 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
44 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
45 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
46 static int32_t param_init[] = {0};
47 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
48 static float param1_init[] = {0.3f};
49 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
50 static int32_t param2_init[] = {-1};
51 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
52 static int32_t param3_init[] = {0};
53 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
54 static float param4_init[] = {0.4f};
55 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
56 static float param5_init[] = {1.0f};
57 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
58 static float param6_init[] = {0.3f};
59 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
60 static int32_t param7_init[] = {2};
61 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
62 static int32_t param8_init[] = {2};
63 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
64 static float param9_init[] = {2.0f};
65 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
66 static float param10_init[] = {2.0f};
67 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
68 static int32_t param11_init[] = {4};
69 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
70 static int32_t param12_init[] = {4};
71 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
72 static bool8 layout_init[] = {false};
73 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
74 static int32_t param13_init[] = {3};
75 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
76 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
77 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
78 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
79 // Phase 3, inputs and outputs
80 model->identifyInputsAndOutputs(
81 {in},
82 {scoresOut, classesOut, out});
83 assert(model->isValid());
84 }
85
is_ignored(int i)86 inline bool is_ignored(int i) {
87 static std::set<int> ignore = {};
88 return ignore.find(i) != ignore.end();
89 }
90
CreateModel_relaxed(Model * model)91 void CreateModel_relaxed(Model *model) {
92 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
93 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
94 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
95 OperandType type11(Type::TENSOR_FLOAT32, {0, 2, 2, 2});
96 OperandType type2(Type::TENSOR_FLOAT32, {0});
97 OperandType type3(Type::TENSOR_INT32, {0});
98 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
99 OperandType type5(Type::TENSOR_INT32, {1});
100 OperandType type6(Type::FLOAT32, {});
101 OperandType type7(Type::INT32, {});
102 OperandType type8(Type::BOOL, {});
103 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
104 // Phase 1, operands
105 auto scores = model->addOperand(&type0);
106 auto roi = model->addOperand(&type1);
107 auto param = model->addOperand(&type5);
108 auto param1 = model->addOperand(&type6);
109 auto param2 = model->addOperand(&type7);
110 auto param3 = model->addOperand(&type7);
111 auto param4 = model->addOperand(&type6);
112 auto param5 = model->addOperand(&type6);
113 auto param6 = model->addOperand(&type6);
114 auto scoresOut = model->addOperand(&type2);
115 auto roiOut = model->addOperand(&type4);
116 auto classesOut = model->addOperand(&type3);
117 auto batchSplitOut = model->addOperand(&type3);
118 auto in = model->addOperand(&type9);
119 auto param7 = model->addOperand(&type7);
120 auto param8 = model->addOperand(&type7);
121 auto param9 = model->addOperand(&type6);
122 auto param10 = model->addOperand(&type6);
123 auto param11 = model->addOperand(&type7);
124 auto param12 = model->addOperand(&type7);
125 auto layout = model->addOperand(&type8);
126 auto featureMap = model->addOperand(&type10);
127 auto param13 = model->addOperand(&type7);
128 auto out = model->addOperand(&type11);
129 // Phase 2, operations
130 static float scores_init[] = {0.9f, 0.1f};
131 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
132 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
133 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
134 static int32_t param_init[] = {0};
135 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
136 static float param1_init[] = {0.3f};
137 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
138 static int32_t param2_init[] = {-1};
139 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
140 static int32_t param3_init[] = {0};
141 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
142 static float param4_init[] = {0.4f};
143 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
144 static float param5_init[] = {1.0f};
145 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
146 static float param6_init[] = {0.3f};
147 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
148 static int32_t param7_init[] = {2};
149 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
150 static int32_t param8_init[] = {2};
151 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
152 static float param9_init[] = {2.0f};
153 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
154 static float param10_init[] = {2.0f};
155 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
156 static int32_t param11_init[] = {4};
157 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
158 static int32_t param12_init[] = {4};
159 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
160 static bool8 layout_init[] = {false};
161 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
162 static int32_t param13_init[] = {3};
163 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
164 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
165 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
166 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
167 // Phase 3, inputs and outputs
168 model->identifyInputsAndOutputs(
169 {in},
170 {scoresOut, classesOut, out});
171 // Phase 4: set relaxed execution
172 model->relaxComputationFloat32toFloat16(true);
173 assert(model->isValid());
174 }
175
is_ignored_relaxed(int i)176 inline bool is_ignored_relaxed(int i) {
177 static std::set<int> ignore = {};
178 return ignore.find(i) != ignore.end();
179 }
180
CreateModel_quant8(Model * model)181 void CreateModel_quant8(Model *model) {
182 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
183 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
184 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 2}, 0.1f, 128);
185 OperandType type16(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
186 OperandType type17(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
187 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
188 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
189 OperandType type3(Type::TENSOR_INT32, {0});
190 OperandType type5(Type::TENSOR_INT32, {1});
191 OperandType type6(Type::FLOAT32, {});
192 OperandType type7(Type::INT32, {});
193 OperandType type8(Type::BOOL, {});
194 // Phase 1, operands
195 auto scores = model->addOperand(&type18);
196 auto roi = model->addOperand(&type16);
197 auto param = model->addOperand(&type5);
198 auto param1 = model->addOperand(&type6);
199 auto param2 = model->addOperand(&type7);
200 auto param3 = model->addOperand(&type7);
201 auto param4 = model->addOperand(&type6);
202 auto param5 = model->addOperand(&type6);
203 auto param6 = model->addOperand(&type6);
204 auto scoresOut = model->addOperand(&type19);
205 auto roiOut = model->addOperand(&type17);
206 auto classesOut = model->addOperand(&type3);
207 auto batchSplitOut = model->addOperand(&type3);
208 auto in = model->addOperand(&type14);
209 auto param7 = model->addOperand(&type7);
210 auto param8 = model->addOperand(&type7);
211 auto param9 = model->addOperand(&type6);
212 auto param10 = model->addOperand(&type6);
213 auto param11 = model->addOperand(&type7);
214 auto param12 = model->addOperand(&type7);
215 auto layout = model->addOperand(&type8);
216 auto featureMap = model->addOperand(&type13);
217 auto param13 = model->addOperand(&type7);
218 auto out = model->addOperand(&type15);
219 // Phase 2, operations
220 static uint8_t scores_init[] = {137, 129};
221 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
222 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
223 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
224 static int32_t param_init[] = {0};
225 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
226 static float param1_init[] = {0.3f};
227 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
228 static int32_t param2_init[] = {-1};
229 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
230 static int32_t param3_init[] = {0};
231 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
232 static float param4_init[] = {0.4f};
233 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
234 static float param5_init[] = {1.0f};
235 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
236 static float param6_init[] = {0.3f};
237 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
238 static int32_t param7_init[] = {2};
239 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
240 static int32_t param8_init[] = {2};
241 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
242 static float param9_init[] = {2.0f};
243 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
244 static float param10_init[] = {2.0f};
245 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
246 static int32_t param11_init[] = {4};
247 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
248 static int32_t param12_init[] = {4};
249 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
250 static bool8 layout_init[] = {false};
251 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
252 static int32_t param13_init[] = {3};
253 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
254 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
255 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
256 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
257 // Phase 3, inputs and outputs
258 model->identifyInputsAndOutputs(
259 {in},
260 {scoresOut, classesOut, out});
261 assert(model->isValid());
262 }
263
is_ignored_quant8(int i)264 inline bool is_ignored_quant8(int i) {
265 static std::set<int> ignore = {};
266 return ignore.find(i) != ignore.end();
267 }
268
CreateModel_float16(Model * model)269 void CreateModel_float16(Model *model) {
270 OperandType type20(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
271 OperandType type21(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
272 OperandType type22(Type::TENSOR_FLOAT16, {0, 2, 2, 2});
273 OperandType type23(Type::FLOAT16, {});
274 OperandType type24(Type::TENSOR_FLOAT16, {1, 8});
275 OperandType type25(Type::TENSOR_FLOAT16, {0, 4});
276 OperandType type26(Type::TENSOR_FLOAT16, {1, 2});
277 OperandType type27(Type::TENSOR_FLOAT16, {0});
278 OperandType type3(Type::TENSOR_INT32, {0});
279 OperandType type5(Type::TENSOR_INT32, {1});
280 OperandType type7(Type::INT32, {});
281 OperandType type8(Type::BOOL, {});
282 // Phase 1, operands
283 auto scores = model->addOperand(&type26);
284 auto roi = model->addOperand(&type24);
285 auto param = model->addOperand(&type5);
286 auto param1 = model->addOperand(&type23);
287 auto param2 = model->addOperand(&type7);
288 auto param3 = model->addOperand(&type7);
289 auto param4 = model->addOperand(&type23);
290 auto param5 = model->addOperand(&type23);
291 auto param6 = model->addOperand(&type23);
292 auto scoresOut = model->addOperand(&type27);
293 auto roiOut = model->addOperand(&type25);
294 auto classesOut = model->addOperand(&type3);
295 auto batchSplitOut = model->addOperand(&type3);
296 auto in = model->addOperand(&type21);
297 auto param7 = model->addOperand(&type7);
298 auto param8 = model->addOperand(&type7);
299 auto param9 = model->addOperand(&type23);
300 auto param10 = model->addOperand(&type23);
301 auto param11 = model->addOperand(&type7);
302 auto param12 = model->addOperand(&type7);
303 auto layout = model->addOperand(&type8);
304 auto featureMap = model->addOperand(&type20);
305 auto param13 = model->addOperand(&type7);
306 auto out = model->addOperand(&type22);
307 // Phase 2, operations
308 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
309 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
310 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
311 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
312 static int32_t param_init[] = {0};
313 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
314 static _Float16 param1_init[] = {0.30000001192092896f};
315 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
316 static int32_t param2_init[] = {-1};
317 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
318 static int32_t param3_init[] = {0};
319 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
320 static _Float16 param4_init[] = {0.4000000059604645f};
321 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
322 static _Float16 param5_init[] = {1.0f};
323 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
324 static _Float16 param6_init[] = {0.30000001192092896f};
325 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
326 static int32_t param7_init[] = {2};
327 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
328 static int32_t param8_init[] = {2};
329 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
330 static _Float16 param9_init[] = {2.0f};
331 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
332 static _Float16 param10_init[] = {2.0f};
333 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
334 static int32_t param11_init[] = {4};
335 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
336 static int32_t param12_init[] = {4};
337 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
338 static bool8 layout_init[] = {false};
339 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
340 static int32_t param13_init[] = {3};
341 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
342 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
343 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
344 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
345 // Phase 3, inputs and outputs
346 model->identifyInputsAndOutputs(
347 {in},
348 {scoresOut, classesOut, out});
349 assert(model->isValid());
350 }
351
is_ignored_float16(int i)352 inline bool is_ignored_float16(int i) {
353 static std::set<int> ignore = {};
354 return ignore.find(i) != ignore.end();
355 }
356
CreateModel_dynamic_output_shape(Model * model)357 void CreateModel_dynamic_output_shape(Model *model) {
358 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
359 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
360 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
361 OperandType type2(Type::TENSOR_FLOAT32, {0});
362 OperandType type28(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
363 OperandType type3(Type::TENSOR_INT32, {0});
364 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
365 OperandType type5(Type::TENSOR_INT32, {1});
366 OperandType type6(Type::FLOAT32, {});
367 OperandType type7(Type::INT32, {});
368 OperandType type8(Type::BOOL, {});
369 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
370 // Phase 1, operands
371 auto scores = model->addOperand(&type0);
372 auto roi = model->addOperand(&type1);
373 auto param = model->addOperand(&type5);
374 auto param1 = model->addOperand(&type6);
375 auto param2 = model->addOperand(&type7);
376 auto param3 = model->addOperand(&type7);
377 auto param4 = model->addOperand(&type6);
378 auto param5 = model->addOperand(&type6);
379 auto param6 = model->addOperand(&type6);
380 auto scoresOut = model->addOperand(&type2);
381 auto roiOut = model->addOperand(&type4);
382 auto classesOut = model->addOperand(&type3);
383 auto batchSplitOut = model->addOperand(&type3);
384 auto in = model->addOperand(&type9);
385 auto param7 = model->addOperand(&type7);
386 auto param8 = model->addOperand(&type7);
387 auto param9 = model->addOperand(&type6);
388 auto param10 = model->addOperand(&type6);
389 auto param11 = model->addOperand(&type7);
390 auto param12 = model->addOperand(&type7);
391 auto layout = model->addOperand(&type8);
392 auto featureMap = model->addOperand(&type10);
393 auto param13 = model->addOperand(&type7);
394 auto out = model->addOperand(&type28);
395 // Phase 2, operations
396 static float scores_init[] = {0.9f, 0.1f};
397 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
398 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
399 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
400 static int32_t param_init[] = {0};
401 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
402 static float param1_init[] = {0.3f};
403 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
404 static int32_t param2_init[] = {-1};
405 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
406 static int32_t param3_init[] = {0};
407 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
408 static float param4_init[] = {0.4f};
409 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
410 static float param5_init[] = {1.0f};
411 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
412 static float param6_init[] = {0.3f};
413 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
414 static int32_t param7_init[] = {2};
415 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
416 static int32_t param8_init[] = {2};
417 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
418 static float param9_init[] = {2.0f};
419 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
420 static float param10_init[] = {2.0f};
421 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
422 static int32_t param11_init[] = {4};
423 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
424 static int32_t param12_init[] = {4};
425 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
426 static bool8 layout_init[] = {false};
427 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
428 static int32_t param13_init[] = {3};
429 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
430 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
431 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
432 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
433 // Phase 3, inputs and outputs
434 model->identifyInputsAndOutputs(
435 {in},
436 {scoresOut, classesOut, out});
437 assert(model->isValid());
438 }
439
is_ignored_dynamic_output_shape(int i)440 inline bool is_ignored_dynamic_output_shape(int i) {
441 static std::set<int> ignore = {};
442 return ignore.find(i) != ignore.end();
443 }
444
CreateModel_dynamic_output_shape_relaxed(Model * model)445 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
446 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
447 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
448 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
449 OperandType type2(Type::TENSOR_FLOAT32, {0});
450 OperandType type28(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
451 OperandType type3(Type::TENSOR_INT32, {0});
452 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
453 OperandType type5(Type::TENSOR_INT32, {1});
454 OperandType type6(Type::FLOAT32, {});
455 OperandType type7(Type::INT32, {});
456 OperandType type8(Type::BOOL, {});
457 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
458 // Phase 1, operands
459 auto scores = model->addOperand(&type0);
460 auto roi = model->addOperand(&type1);
461 auto param = model->addOperand(&type5);
462 auto param1 = model->addOperand(&type6);
463 auto param2 = model->addOperand(&type7);
464 auto param3 = model->addOperand(&type7);
465 auto param4 = model->addOperand(&type6);
466 auto param5 = model->addOperand(&type6);
467 auto param6 = model->addOperand(&type6);
468 auto scoresOut = model->addOperand(&type2);
469 auto roiOut = model->addOperand(&type4);
470 auto classesOut = model->addOperand(&type3);
471 auto batchSplitOut = model->addOperand(&type3);
472 auto in = model->addOperand(&type9);
473 auto param7 = model->addOperand(&type7);
474 auto param8 = model->addOperand(&type7);
475 auto param9 = model->addOperand(&type6);
476 auto param10 = model->addOperand(&type6);
477 auto param11 = model->addOperand(&type7);
478 auto param12 = model->addOperand(&type7);
479 auto layout = model->addOperand(&type8);
480 auto featureMap = model->addOperand(&type10);
481 auto param13 = model->addOperand(&type7);
482 auto out = model->addOperand(&type28);
483 // Phase 2, operations
484 static float scores_init[] = {0.9f, 0.1f};
485 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
486 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
487 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
488 static int32_t param_init[] = {0};
489 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
490 static float param1_init[] = {0.3f};
491 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
492 static int32_t param2_init[] = {-1};
493 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
494 static int32_t param3_init[] = {0};
495 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
496 static float param4_init[] = {0.4f};
497 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
498 static float param5_init[] = {1.0f};
499 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
500 static float param6_init[] = {0.3f};
501 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
502 static int32_t param7_init[] = {2};
503 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
504 static int32_t param8_init[] = {2};
505 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
506 static float param9_init[] = {2.0f};
507 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
508 static float param10_init[] = {2.0f};
509 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
510 static int32_t param11_init[] = {4};
511 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
512 static int32_t param12_init[] = {4};
513 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
514 static bool8 layout_init[] = {false};
515 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
516 static int32_t param13_init[] = {3};
517 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
518 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
519 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
520 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
521 // Phase 3, inputs and outputs
522 model->identifyInputsAndOutputs(
523 {in},
524 {scoresOut, classesOut, out});
525 // Phase 4: set relaxed execution
526 model->relaxComputationFloat32toFloat16(true);
527 assert(model->isValid());
528 }
529
is_ignored_dynamic_output_shape_relaxed(int i)530 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
531 static std::set<int> ignore = {};
532 return ignore.find(i) != ignore.end();
533 }
534
CreateModel_dynamic_output_shape_quant8(Model * model)535 void CreateModel_dynamic_output_shape_quant8(Model *model) {
536 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
537 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
538 OperandType type16(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
539 OperandType type17(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
540 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
541 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
542 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.1f, 128);
543 OperandType type3(Type::TENSOR_INT32, {0});
544 OperandType type5(Type::TENSOR_INT32, {1});
545 OperandType type6(Type::FLOAT32, {});
546 OperandType type7(Type::INT32, {});
547 OperandType type8(Type::BOOL, {});
548 // Phase 1, operands
549 auto scores = model->addOperand(&type18);
550 auto roi = model->addOperand(&type16);
551 auto param = model->addOperand(&type5);
552 auto param1 = model->addOperand(&type6);
553 auto param2 = model->addOperand(&type7);
554 auto param3 = model->addOperand(&type7);
555 auto param4 = model->addOperand(&type6);
556 auto param5 = model->addOperand(&type6);
557 auto param6 = model->addOperand(&type6);
558 auto scoresOut = model->addOperand(&type19);
559 auto roiOut = model->addOperand(&type17);
560 auto classesOut = model->addOperand(&type3);
561 auto batchSplitOut = model->addOperand(&type3);
562 auto in = model->addOperand(&type14);
563 auto param7 = model->addOperand(&type7);
564 auto param8 = model->addOperand(&type7);
565 auto param9 = model->addOperand(&type6);
566 auto param10 = model->addOperand(&type6);
567 auto param11 = model->addOperand(&type7);
568 auto param12 = model->addOperand(&type7);
569 auto layout = model->addOperand(&type8);
570 auto featureMap = model->addOperand(&type13);
571 auto param13 = model->addOperand(&type7);
572 auto out = model->addOperand(&type29);
573 // Phase 2, operations
574 static uint8_t scores_init[] = {137, 129};
575 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
576 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
577 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
578 static int32_t param_init[] = {0};
579 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
580 static float param1_init[] = {0.3f};
581 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
582 static int32_t param2_init[] = {-1};
583 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
584 static int32_t param3_init[] = {0};
585 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
586 static float param4_init[] = {0.4f};
587 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
588 static float param5_init[] = {1.0f};
589 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
590 static float param6_init[] = {0.3f};
591 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
592 static int32_t param7_init[] = {2};
593 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
594 static int32_t param8_init[] = {2};
595 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
596 static float param9_init[] = {2.0f};
597 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
598 static float param10_init[] = {2.0f};
599 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
600 static int32_t param11_init[] = {4};
601 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
602 static int32_t param12_init[] = {4};
603 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
604 static bool8 layout_init[] = {false};
605 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
606 static int32_t param13_init[] = {3};
607 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
608 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
609 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
610 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
611 // Phase 3, inputs and outputs
612 model->identifyInputsAndOutputs(
613 {in},
614 {scoresOut, classesOut, out});
615 assert(model->isValid());
616 }
617
is_ignored_dynamic_output_shape_quant8(int i)618 inline bool is_ignored_dynamic_output_shape_quant8(int i) {
619 static std::set<int> ignore = {};
620 return ignore.find(i) != ignore.end();
621 }
622
CreateModel_dynamic_output_shape_float16(Model * model)623 void CreateModel_dynamic_output_shape_float16(Model *model) {
624 OperandType type20(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
625 OperandType type21(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
626 OperandType type23(Type::FLOAT16, {});
627 OperandType type24(Type::TENSOR_FLOAT16, {1, 8});
628 OperandType type25(Type::TENSOR_FLOAT16, {0, 4});
629 OperandType type26(Type::TENSOR_FLOAT16, {1, 2});
630 OperandType type3(Type::TENSOR_INT32, {0});
631 OperandType type30(Type::TENSOR_FLOAT16, {0});
632 OperandType type31(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
633 OperandType type5(Type::TENSOR_INT32, {1});
634 OperandType type7(Type::INT32, {});
635 OperandType type8(Type::BOOL, {});
636 // Phase 1, operands
637 auto scores = model->addOperand(&type26);
638 auto roi = model->addOperand(&type24);
639 auto param = model->addOperand(&type5);
640 auto param1 = model->addOperand(&type23);
641 auto param2 = model->addOperand(&type7);
642 auto param3 = model->addOperand(&type7);
643 auto param4 = model->addOperand(&type23);
644 auto param5 = model->addOperand(&type23);
645 auto param6 = model->addOperand(&type23);
646 auto scoresOut = model->addOperand(&type30);
647 auto roiOut = model->addOperand(&type25);
648 auto classesOut = model->addOperand(&type3);
649 auto batchSplitOut = model->addOperand(&type3);
650 auto in = model->addOperand(&type21);
651 auto param7 = model->addOperand(&type7);
652 auto param8 = model->addOperand(&type7);
653 auto param9 = model->addOperand(&type23);
654 auto param10 = model->addOperand(&type23);
655 auto param11 = model->addOperand(&type7);
656 auto param12 = model->addOperand(&type7);
657 auto layout = model->addOperand(&type8);
658 auto featureMap = model->addOperand(&type20);
659 auto param13 = model->addOperand(&type7);
660 auto out = model->addOperand(&type31);
661 // Phase 2, operations
662 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
663 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
664 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
665 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
666 static int32_t param_init[] = {0};
667 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
668 static _Float16 param1_init[] = {0.30000001192092896f};
669 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
670 static int32_t param2_init[] = {-1};
671 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
672 static int32_t param3_init[] = {0};
673 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
674 static _Float16 param4_init[] = {0.4000000059604645f};
675 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
676 static _Float16 param5_init[] = {1.0f};
677 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
678 static _Float16 param6_init[] = {0.30000001192092896f};
679 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
680 static int32_t param7_init[] = {2};
681 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
682 static int32_t param8_init[] = {2};
683 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
684 static _Float16 param9_init[] = {2.0f};
685 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
686 static _Float16 param10_init[] = {2.0f};
687 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
688 static int32_t param11_init[] = {4};
689 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
690 static int32_t param12_init[] = {4};
691 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
692 static bool8 layout_init[] = {false};
693 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
694 static int32_t param13_init[] = {3};
695 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
696 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
697 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
698 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap, featureMap, param13}, {out});
699 // Phase 3, inputs and outputs
700 model->identifyInputsAndOutputs(
701 {in},
702 {scoresOut, classesOut, out});
703 assert(model->isValid());
704 }
705
is_ignored_dynamic_output_shape_float16(int i)706 inline bool is_ignored_dynamic_output_shape_float16(int i) {
707 static std::set<int> ignore = {};
708 return ignore.find(i) != ignore.end();
709 }
710
CreateModel_2(Model * model)711 void CreateModel_2(Model *model) {
712 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
713 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
714 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
715 OperandType type12(Type::TENSOR_FLOAT32, {1, 2, 2, 1});
716 OperandType type2(Type::TENSOR_FLOAT32, {0});
717 OperandType type3(Type::TENSOR_INT32, {0});
718 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
719 OperandType type5(Type::TENSOR_INT32, {1});
720 OperandType type6(Type::FLOAT32, {});
721 OperandType type7(Type::INT32, {});
722 OperandType type8(Type::BOOL, {});
723 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
724 // Phase 1, operands
725 auto scores1 = model->addOperand(&type0);
726 auto roi1 = model->addOperand(&type1);
727 auto param14 = model->addOperand(&type5);
728 auto param15 = model->addOperand(&type6);
729 auto param16 = model->addOperand(&type7);
730 auto param17 = model->addOperand(&type7);
731 auto param18 = model->addOperand(&type6);
732 auto param19 = model->addOperand(&type6);
733 auto param20 = model->addOperand(&type6);
734 auto scoresOut1 = model->addOperand(&type2);
735 auto roiOut1 = model->addOperand(&type4);
736 auto classesOut1 = model->addOperand(&type3);
737 auto batchSplitOut1 = model->addOperand(&type3);
738 auto in1 = model->addOperand(&type9);
739 auto param21 = model->addOperand(&type7);
740 auto param22 = model->addOperand(&type7);
741 auto param23 = model->addOperand(&type6);
742 auto param24 = model->addOperand(&type6);
743 auto param25 = model->addOperand(&type7);
744 auto param26 = model->addOperand(&type7);
745 auto layout1 = model->addOperand(&type8);
746 auto featureMap1 = model->addOperand(&type10);
747 auto in2 = model->addOperand(&type12);
748 auto param27 = model->addOperand(&type7);
749 auto out1 = model->addOperand(&type12);
750 // Phase 2, operations
751 static float scores1_init[] = {0.9f, 0.1f};
752 model->setOperandValue(scores1, scores1_init, sizeof(float) * 2);
753 static float roi1_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
754 model->setOperandValue(roi1, roi1_init, sizeof(float) * 8);
755 static int32_t param14_init[] = {0};
756 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
757 static float param15_init[] = {0.3f};
758 model->setOperandValue(param15, param15_init, sizeof(float) * 1);
759 static int32_t param16_init[] = {-1};
760 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
761 static int32_t param17_init[] = {0};
762 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
763 static float param18_init[] = {0.4f};
764 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
765 static float param19_init[] = {1.0f};
766 model->setOperandValue(param19, param19_init, sizeof(float) * 1);
767 static float param20_init[] = {0.3f};
768 model->setOperandValue(param20, param20_init, sizeof(float) * 1);
769 static int32_t param21_init[] = {2};
770 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
771 static int32_t param22_init[] = {2};
772 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
773 static float param23_init[] = {2.0f};
774 model->setOperandValue(param23, param23_init, sizeof(float) * 1);
775 static float param24_init[] = {2.0f};
776 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
777 static int32_t param25_init[] = {4};
778 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
779 static int32_t param26_init[] = {4};
780 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
781 static bool8 layout1_init[] = {false};
782 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
783 static int32_t param27_init[] = {0};
784 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
785 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
786 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
787 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
788 // Phase 3, inputs and outputs
789 model->identifyInputsAndOutputs(
790 {in1, in2},
791 {scoresOut1, classesOut1, out1});
792 assert(model->isValid());
793 }
794
is_ignored_2(int i)795 inline bool is_ignored_2(int i) {
796 static std::set<int> ignore = {};
797 return ignore.find(i) != ignore.end();
798 }
799
CreateModel_relaxed_2(Model * model)800 void CreateModel_relaxed_2(Model *model) {
801 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
802 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
803 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
804 OperandType type12(Type::TENSOR_FLOAT32, {1, 2, 2, 1});
805 OperandType type2(Type::TENSOR_FLOAT32, {0});
806 OperandType type3(Type::TENSOR_INT32, {0});
807 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
808 OperandType type5(Type::TENSOR_INT32, {1});
809 OperandType type6(Type::FLOAT32, {});
810 OperandType type7(Type::INT32, {});
811 OperandType type8(Type::BOOL, {});
812 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
813 // Phase 1, operands
814 auto scores1 = model->addOperand(&type0);
815 auto roi1 = model->addOperand(&type1);
816 auto param14 = model->addOperand(&type5);
817 auto param15 = model->addOperand(&type6);
818 auto param16 = model->addOperand(&type7);
819 auto param17 = model->addOperand(&type7);
820 auto param18 = model->addOperand(&type6);
821 auto param19 = model->addOperand(&type6);
822 auto param20 = model->addOperand(&type6);
823 auto scoresOut1 = model->addOperand(&type2);
824 auto roiOut1 = model->addOperand(&type4);
825 auto classesOut1 = model->addOperand(&type3);
826 auto batchSplitOut1 = model->addOperand(&type3);
827 auto in1 = model->addOperand(&type9);
828 auto param21 = model->addOperand(&type7);
829 auto param22 = model->addOperand(&type7);
830 auto param23 = model->addOperand(&type6);
831 auto param24 = model->addOperand(&type6);
832 auto param25 = model->addOperand(&type7);
833 auto param26 = model->addOperand(&type7);
834 auto layout1 = model->addOperand(&type8);
835 auto featureMap1 = model->addOperand(&type10);
836 auto in2 = model->addOperand(&type12);
837 auto param27 = model->addOperand(&type7);
838 auto out1 = model->addOperand(&type12);
839 // Phase 2, operations
840 static float scores1_init[] = {0.9f, 0.1f};
841 model->setOperandValue(scores1, scores1_init, sizeof(float) * 2);
842 static float roi1_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
843 model->setOperandValue(roi1, roi1_init, sizeof(float) * 8);
844 static int32_t param14_init[] = {0};
845 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
846 static float param15_init[] = {0.3f};
847 model->setOperandValue(param15, param15_init, sizeof(float) * 1);
848 static int32_t param16_init[] = {-1};
849 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
850 static int32_t param17_init[] = {0};
851 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
852 static float param18_init[] = {0.4f};
853 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
854 static float param19_init[] = {1.0f};
855 model->setOperandValue(param19, param19_init, sizeof(float) * 1);
856 static float param20_init[] = {0.3f};
857 model->setOperandValue(param20, param20_init, sizeof(float) * 1);
858 static int32_t param21_init[] = {2};
859 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
860 static int32_t param22_init[] = {2};
861 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
862 static float param23_init[] = {2.0f};
863 model->setOperandValue(param23, param23_init, sizeof(float) * 1);
864 static float param24_init[] = {2.0f};
865 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
866 static int32_t param25_init[] = {4};
867 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
868 static int32_t param26_init[] = {4};
869 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
870 static bool8 layout1_init[] = {false};
871 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
872 static int32_t param27_init[] = {0};
873 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
874 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
875 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
876 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
877 // Phase 3, inputs and outputs
878 model->identifyInputsAndOutputs(
879 {in1, in2},
880 {scoresOut1, classesOut1, out1});
881 // Phase 4: set relaxed execution
882 model->relaxComputationFloat32toFloat16(true);
883 assert(model->isValid());
884 }
885
is_ignored_relaxed_2(int i)886 inline bool is_ignored_relaxed_2(int i) {
887 static std::set<int> ignore = {};
888 return ignore.find(i) != ignore.end();
889 }
890
CreateModel_quant8_2(Model * model)891 void CreateModel_quant8_2(Model *model) {
892 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
893 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
894 OperandType type16(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
895 OperandType type17(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
896 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
897 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
898 OperandType type3(Type::TENSOR_INT32, {0});
899 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.2f, 128);
900 OperandType type33(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.1f, 128);
901 OperandType type5(Type::TENSOR_INT32, {1});
902 OperandType type6(Type::FLOAT32, {});
903 OperandType type7(Type::INT32, {});
904 OperandType type8(Type::BOOL, {});
905 // Phase 1, operands
906 auto scores1 = model->addOperand(&type18);
907 auto roi1 = model->addOperand(&type16);
908 auto param14 = model->addOperand(&type5);
909 auto param15 = model->addOperand(&type6);
910 auto param16 = model->addOperand(&type7);
911 auto param17 = model->addOperand(&type7);
912 auto param18 = model->addOperand(&type6);
913 auto param19 = model->addOperand(&type6);
914 auto param20 = model->addOperand(&type6);
915 auto scoresOut1 = model->addOperand(&type19);
916 auto roiOut1 = model->addOperand(&type17);
917 auto classesOut1 = model->addOperand(&type3);
918 auto batchSplitOut1 = model->addOperand(&type3);
919 auto in1 = model->addOperand(&type14);
920 auto param21 = model->addOperand(&type7);
921 auto param22 = model->addOperand(&type7);
922 auto param23 = model->addOperand(&type6);
923 auto param24 = model->addOperand(&type6);
924 auto param25 = model->addOperand(&type7);
925 auto param26 = model->addOperand(&type7);
926 auto layout1 = model->addOperand(&type8);
927 auto featureMap1 = model->addOperand(&type13);
928 auto in2 = model->addOperand(&type32);
929 auto param27 = model->addOperand(&type7);
930 auto out1 = model->addOperand(&type33);
931 // Phase 2, operations
932 static uint8_t scores1_init[] = {137, 129};
933 model->setOperandValue(scores1, scores1_init, sizeof(uint8_t) * 2);
934 static uint16_t roi1_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
935 model->setOperandValue(roi1, roi1_init, sizeof(uint16_t) * 8);
936 static int32_t param14_init[] = {0};
937 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
938 static float param15_init[] = {0.3f};
939 model->setOperandValue(param15, param15_init, sizeof(float) * 1);
940 static int32_t param16_init[] = {-1};
941 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
942 static int32_t param17_init[] = {0};
943 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
944 static float param18_init[] = {0.4f};
945 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
946 static float param19_init[] = {1.0f};
947 model->setOperandValue(param19, param19_init, sizeof(float) * 1);
948 static float param20_init[] = {0.3f};
949 model->setOperandValue(param20, param20_init, sizeof(float) * 1);
950 static int32_t param21_init[] = {2};
951 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
952 static int32_t param22_init[] = {2};
953 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
954 static float param23_init[] = {2.0f};
955 model->setOperandValue(param23, param23_init, sizeof(float) * 1);
956 static float param24_init[] = {2.0f};
957 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
958 static int32_t param25_init[] = {4};
959 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
960 static int32_t param26_init[] = {4};
961 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
962 static bool8 layout1_init[] = {false};
963 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
964 static int32_t param27_init[] = {0};
965 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
966 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
967 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
968 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
969 // Phase 3, inputs and outputs
970 model->identifyInputsAndOutputs(
971 {in1, in2},
972 {scoresOut1, classesOut1, out1});
973 assert(model->isValid());
974 }
975
is_ignored_quant8_2(int i)976 inline bool is_ignored_quant8_2(int i) {
977 static std::set<int> ignore = {};
978 return ignore.find(i) != ignore.end();
979 }
980
CreateModel_float16_2(Model * model)981 void CreateModel_float16_2(Model *model) {
982 OperandType type20(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
983 OperandType type21(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
984 OperandType type23(Type::FLOAT16, {});
985 OperandType type24(Type::TENSOR_FLOAT16, {1, 8});
986 OperandType type25(Type::TENSOR_FLOAT16, {0, 4});
987 OperandType type26(Type::TENSOR_FLOAT16, {1, 2});
988 OperandType type27(Type::TENSOR_FLOAT16, {0});
989 OperandType type3(Type::TENSOR_INT32, {0});
990 OperandType type34(Type::TENSOR_FLOAT16, {1, 2, 2, 1});
991 OperandType type5(Type::TENSOR_INT32, {1});
992 OperandType type7(Type::INT32, {});
993 OperandType type8(Type::BOOL, {});
994 // Phase 1, operands
995 auto scores1 = model->addOperand(&type26);
996 auto roi1 = model->addOperand(&type24);
997 auto param14 = model->addOperand(&type5);
998 auto param15 = model->addOperand(&type23);
999 auto param16 = model->addOperand(&type7);
1000 auto param17 = model->addOperand(&type7);
1001 auto param18 = model->addOperand(&type23);
1002 auto param19 = model->addOperand(&type23);
1003 auto param20 = model->addOperand(&type23);
1004 auto scoresOut1 = model->addOperand(&type27);
1005 auto roiOut1 = model->addOperand(&type25);
1006 auto classesOut1 = model->addOperand(&type3);
1007 auto batchSplitOut1 = model->addOperand(&type3);
1008 auto in1 = model->addOperand(&type21);
1009 auto param21 = model->addOperand(&type7);
1010 auto param22 = model->addOperand(&type7);
1011 auto param23 = model->addOperand(&type23);
1012 auto param24 = model->addOperand(&type23);
1013 auto param25 = model->addOperand(&type7);
1014 auto param26 = model->addOperand(&type7);
1015 auto layout1 = model->addOperand(&type8);
1016 auto featureMap1 = model->addOperand(&type20);
1017 auto in2 = model->addOperand(&type34);
1018 auto param27 = model->addOperand(&type7);
1019 auto out1 = model->addOperand(&type34);
1020 // Phase 2, operations
1021 static _Float16 scores1_init[] = {0.8999999761581421f, 0.10000000149011612f};
1022 model->setOperandValue(scores1, scores1_init, sizeof(_Float16) * 2);
1023 static _Float16 roi1_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1024 model->setOperandValue(roi1, roi1_init, sizeof(_Float16) * 8);
1025 static int32_t param14_init[] = {0};
1026 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
1027 static _Float16 param15_init[] = {0.30000001192092896f};
1028 model->setOperandValue(param15, param15_init, sizeof(_Float16) * 1);
1029 static int32_t param16_init[] = {-1};
1030 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1031 static int32_t param17_init[] = {0};
1032 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
1033 static _Float16 param18_init[] = {0.4000000059604645f};
1034 model->setOperandValue(param18, param18_init, sizeof(_Float16) * 1);
1035 static _Float16 param19_init[] = {1.0f};
1036 model->setOperandValue(param19, param19_init, sizeof(_Float16) * 1);
1037 static _Float16 param20_init[] = {0.30000001192092896f};
1038 model->setOperandValue(param20, param20_init, sizeof(_Float16) * 1);
1039 static int32_t param21_init[] = {2};
1040 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1041 static int32_t param22_init[] = {2};
1042 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1043 static _Float16 param23_init[] = {2.0f};
1044 model->setOperandValue(param23, param23_init, sizeof(_Float16) * 1);
1045 static _Float16 param24_init[] = {2.0f};
1046 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1);
1047 static int32_t param25_init[] = {4};
1048 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1049 static int32_t param26_init[] = {4};
1050 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1051 static bool8 layout1_init[] = {false};
1052 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
1053 static int32_t param27_init[] = {0};
1054 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1055 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
1056 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
1057 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
1058 // Phase 3, inputs and outputs
1059 model->identifyInputsAndOutputs(
1060 {in1, in2},
1061 {scoresOut1, classesOut1, out1});
1062 assert(model->isValid());
1063 }
1064
is_ignored_float16_2(int i)1065 inline bool is_ignored_float16_2(int i) {
1066 static std::set<int> ignore = {};
1067 return ignore.find(i) != ignore.end();
1068 }
1069
CreateModel_dynamic_output_shape_2(Model * model)1070 void CreateModel_dynamic_output_shape_2(Model *model) {
1071 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
1072 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
1073 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
1074 OperandType type12(Type::TENSOR_FLOAT32, {1, 2, 2, 1});
1075 OperandType type2(Type::TENSOR_FLOAT32, {0});
1076 OperandType type28(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1077 OperandType type3(Type::TENSOR_INT32, {0});
1078 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
1079 OperandType type5(Type::TENSOR_INT32, {1});
1080 OperandType type6(Type::FLOAT32, {});
1081 OperandType type7(Type::INT32, {});
1082 OperandType type8(Type::BOOL, {});
1083 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
1084 // Phase 1, operands
1085 auto scores1 = model->addOperand(&type0);
1086 auto roi1 = model->addOperand(&type1);
1087 auto param14 = model->addOperand(&type5);
1088 auto param15 = model->addOperand(&type6);
1089 auto param16 = model->addOperand(&type7);
1090 auto param17 = model->addOperand(&type7);
1091 auto param18 = model->addOperand(&type6);
1092 auto param19 = model->addOperand(&type6);
1093 auto param20 = model->addOperand(&type6);
1094 auto scoresOut1 = model->addOperand(&type2);
1095 auto roiOut1 = model->addOperand(&type4);
1096 auto classesOut1 = model->addOperand(&type3);
1097 auto batchSplitOut1 = model->addOperand(&type3);
1098 auto in1 = model->addOperand(&type9);
1099 auto param21 = model->addOperand(&type7);
1100 auto param22 = model->addOperand(&type7);
1101 auto param23 = model->addOperand(&type6);
1102 auto param24 = model->addOperand(&type6);
1103 auto param25 = model->addOperand(&type7);
1104 auto param26 = model->addOperand(&type7);
1105 auto layout1 = model->addOperand(&type8);
1106 auto featureMap1 = model->addOperand(&type10);
1107 auto in2 = model->addOperand(&type12);
1108 auto param27 = model->addOperand(&type7);
1109 auto out1 = model->addOperand(&type28);
1110 // Phase 2, operations
1111 static float scores1_init[] = {0.9f, 0.1f};
1112 model->setOperandValue(scores1, scores1_init, sizeof(float) * 2);
1113 static float roi1_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1114 model->setOperandValue(roi1, roi1_init, sizeof(float) * 8);
1115 static int32_t param14_init[] = {0};
1116 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
1117 static float param15_init[] = {0.3f};
1118 model->setOperandValue(param15, param15_init, sizeof(float) * 1);
1119 static int32_t param16_init[] = {-1};
1120 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1121 static int32_t param17_init[] = {0};
1122 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
1123 static float param18_init[] = {0.4f};
1124 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1125 static float param19_init[] = {1.0f};
1126 model->setOperandValue(param19, param19_init, sizeof(float) * 1);
1127 static float param20_init[] = {0.3f};
1128 model->setOperandValue(param20, param20_init, sizeof(float) * 1);
1129 static int32_t param21_init[] = {2};
1130 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1131 static int32_t param22_init[] = {2};
1132 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1133 static float param23_init[] = {2.0f};
1134 model->setOperandValue(param23, param23_init, sizeof(float) * 1);
1135 static float param24_init[] = {2.0f};
1136 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
1137 static int32_t param25_init[] = {4};
1138 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1139 static int32_t param26_init[] = {4};
1140 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1141 static bool8 layout1_init[] = {false};
1142 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
1143 static int32_t param27_init[] = {0};
1144 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1145 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
1146 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
1147 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
1148 // Phase 3, inputs and outputs
1149 model->identifyInputsAndOutputs(
1150 {in1, in2},
1151 {scoresOut1, classesOut1, out1});
1152 assert(model->isValid());
1153 }
1154
is_ignored_dynamic_output_shape_2(int i)1155 inline bool is_ignored_dynamic_output_shape_2(int i) {
1156 static std::set<int> ignore = {};
1157 return ignore.find(i) != ignore.end();
1158 }
1159
CreateModel_dynamic_output_shape_relaxed_2(Model * model)1160 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) {
1161 OperandType type0(Type::TENSOR_FLOAT32, {1, 2});
1162 OperandType type1(Type::TENSOR_FLOAT32, {1, 8});
1163 OperandType type10(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
1164 OperandType type12(Type::TENSOR_FLOAT32, {1, 2, 2, 1});
1165 OperandType type2(Type::TENSOR_FLOAT32, {0});
1166 OperandType type28(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1167 OperandType type3(Type::TENSOR_INT32, {0});
1168 OperandType type4(Type::TENSOR_FLOAT32, {0, 4});
1169 OperandType type5(Type::TENSOR_INT32, {1});
1170 OperandType type6(Type::FLOAT32, {});
1171 OperandType type7(Type::INT32, {});
1172 OperandType type8(Type::BOOL, {});
1173 OperandType type9(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
1174 // Phase 1, operands
1175 auto scores1 = model->addOperand(&type0);
1176 auto roi1 = model->addOperand(&type1);
1177 auto param14 = model->addOperand(&type5);
1178 auto param15 = model->addOperand(&type6);
1179 auto param16 = model->addOperand(&type7);
1180 auto param17 = model->addOperand(&type7);
1181 auto param18 = model->addOperand(&type6);
1182 auto param19 = model->addOperand(&type6);
1183 auto param20 = model->addOperand(&type6);
1184 auto scoresOut1 = model->addOperand(&type2);
1185 auto roiOut1 = model->addOperand(&type4);
1186 auto classesOut1 = model->addOperand(&type3);
1187 auto batchSplitOut1 = model->addOperand(&type3);
1188 auto in1 = model->addOperand(&type9);
1189 auto param21 = model->addOperand(&type7);
1190 auto param22 = model->addOperand(&type7);
1191 auto param23 = model->addOperand(&type6);
1192 auto param24 = model->addOperand(&type6);
1193 auto param25 = model->addOperand(&type7);
1194 auto param26 = model->addOperand(&type7);
1195 auto layout1 = model->addOperand(&type8);
1196 auto featureMap1 = model->addOperand(&type10);
1197 auto in2 = model->addOperand(&type12);
1198 auto param27 = model->addOperand(&type7);
1199 auto out1 = model->addOperand(&type28);
1200 // Phase 2, operations
1201 static float scores1_init[] = {0.9f, 0.1f};
1202 model->setOperandValue(scores1, scores1_init, sizeof(float) * 2);
1203 static float roi1_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1204 model->setOperandValue(roi1, roi1_init, sizeof(float) * 8);
1205 static int32_t param14_init[] = {0};
1206 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
1207 static float param15_init[] = {0.3f};
1208 model->setOperandValue(param15, param15_init, sizeof(float) * 1);
1209 static int32_t param16_init[] = {-1};
1210 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1211 static int32_t param17_init[] = {0};
1212 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
1213 static float param18_init[] = {0.4f};
1214 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1215 static float param19_init[] = {1.0f};
1216 model->setOperandValue(param19, param19_init, sizeof(float) * 1);
1217 static float param20_init[] = {0.3f};
1218 model->setOperandValue(param20, param20_init, sizeof(float) * 1);
1219 static int32_t param21_init[] = {2};
1220 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1221 static int32_t param22_init[] = {2};
1222 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1223 static float param23_init[] = {2.0f};
1224 model->setOperandValue(param23, param23_init, sizeof(float) * 1);
1225 static float param24_init[] = {2.0f};
1226 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
1227 static int32_t param25_init[] = {4};
1228 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1229 static int32_t param26_init[] = {4};
1230 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1231 static bool8 layout1_init[] = {false};
1232 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
1233 static int32_t param27_init[] = {0};
1234 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1235 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
1236 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
1237 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
1238 // Phase 3, inputs and outputs
1239 model->identifyInputsAndOutputs(
1240 {in1, in2},
1241 {scoresOut1, classesOut1, out1});
1242 // Phase 4: set relaxed execution
1243 model->relaxComputationFloat32toFloat16(true);
1244 assert(model->isValid());
1245 }
1246
is_ignored_dynamic_output_shape_relaxed_2(int i)1247 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) {
1248 static std::set<int> ignore = {};
1249 return ignore.find(i) != ignore.end();
1250 }
1251
CreateModel_dynamic_output_shape_quant8_2(Model * model)1252 void CreateModel_dynamic_output_shape_quant8_2(Model *model) {
1253 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
1254 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
1255 OperandType type16(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
1256 OperandType type17(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
1257 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
1258 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
1259 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.1f, 128);
1260 OperandType type3(Type::TENSOR_INT32, {0});
1261 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.2f, 128);
1262 OperandType type5(Type::TENSOR_INT32, {1});
1263 OperandType type6(Type::FLOAT32, {});
1264 OperandType type7(Type::INT32, {});
1265 OperandType type8(Type::BOOL, {});
1266 // Phase 1, operands
1267 auto scores1 = model->addOperand(&type18);
1268 auto roi1 = model->addOperand(&type16);
1269 auto param14 = model->addOperand(&type5);
1270 auto param15 = model->addOperand(&type6);
1271 auto param16 = model->addOperand(&type7);
1272 auto param17 = model->addOperand(&type7);
1273 auto param18 = model->addOperand(&type6);
1274 auto param19 = model->addOperand(&type6);
1275 auto param20 = model->addOperand(&type6);
1276 auto scoresOut1 = model->addOperand(&type19);
1277 auto roiOut1 = model->addOperand(&type17);
1278 auto classesOut1 = model->addOperand(&type3);
1279 auto batchSplitOut1 = model->addOperand(&type3);
1280 auto in1 = model->addOperand(&type14);
1281 auto param21 = model->addOperand(&type7);
1282 auto param22 = model->addOperand(&type7);
1283 auto param23 = model->addOperand(&type6);
1284 auto param24 = model->addOperand(&type6);
1285 auto param25 = model->addOperand(&type7);
1286 auto param26 = model->addOperand(&type7);
1287 auto layout1 = model->addOperand(&type8);
1288 auto featureMap1 = model->addOperand(&type13);
1289 auto in2 = model->addOperand(&type32);
1290 auto param27 = model->addOperand(&type7);
1291 auto out1 = model->addOperand(&type29);
1292 // Phase 2, operations
1293 static uint8_t scores1_init[] = {137, 129};
1294 model->setOperandValue(scores1, scores1_init, sizeof(uint8_t) * 2);
1295 static uint16_t roi1_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
1296 model->setOperandValue(roi1, roi1_init, sizeof(uint16_t) * 8);
1297 static int32_t param14_init[] = {0};
1298 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
1299 static float param15_init[] = {0.3f};
1300 model->setOperandValue(param15, param15_init, sizeof(float) * 1);
1301 static int32_t param16_init[] = {-1};
1302 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1303 static int32_t param17_init[] = {0};
1304 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
1305 static float param18_init[] = {0.4f};
1306 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1307 static float param19_init[] = {1.0f};
1308 model->setOperandValue(param19, param19_init, sizeof(float) * 1);
1309 static float param20_init[] = {0.3f};
1310 model->setOperandValue(param20, param20_init, sizeof(float) * 1);
1311 static int32_t param21_init[] = {2};
1312 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1313 static int32_t param22_init[] = {2};
1314 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1315 static float param23_init[] = {2.0f};
1316 model->setOperandValue(param23, param23_init, sizeof(float) * 1);
1317 static float param24_init[] = {2.0f};
1318 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
1319 static int32_t param25_init[] = {4};
1320 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1321 static int32_t param26_init[] = {4};
1322 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1323 static bool8 layout1_init[] = {false};
1324 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
1325 static int32_t param27_init[] = {0};
1326 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1327 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
1328 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
1329 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
1330 // Phase 3, inputs and outputs
1331 model->identifyInputsAndOutputs(
1332 {in1, in2},
1333 {scoresOut1, classesOut1, out1});
1334 assert(model->isValid());
1335 }
1336
is_ignored_dynamic_output_shape_quant8_2(int i)1337 inline bool is_ignored_dynamic_output_shape_quant8_2(int i) {
1338 static std::set<int> ignore = {};
1339 return ignore.find(i) != ignore.end();
1340 }
1341
CreateModel_dynamic_output_shape_float16_2(Model * model)1342 void CreateModel_dynamic_output_shape_float16_2(Model *model) {
1343 OperandType type20(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
1344 OperandType type21(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
1345 OperandType type23(Type::FLOAT16, {});
1346 OperandType type24(Type::TENSOR_FLOAT16, {1, 8});
1347 OperandType type25(Type::TENSOR_FLOAT16, {0, 4});
1348 OperandType type26(Type::TENSOR_FLOAT16, {1, 2});
1349 OperandType type3(Type::TENSOR_INT32, {0});
1350 OperandType type30(Type::TENSOR_FLOAT16, {0});
1351 OperandType type31(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
1352 OperandType type34(Type::TENSOR_FLOAT16, {1, 2, 2, 1});
1353 OperandType type5(Type::TENSOR_INT32, {1});
1354 OperandType type7(Type::INT32, {});
1355 OperandType type8(Type::BOOL, {});
1356 // Phase 1, operands
1357 auto scores1 = model->addOperand(&type26);
1358 auto roi1 = model->addOperand(&type24);
1359 auto param14 = model->addOperand(&type5);
1360 auto param15 = model->addOperand(&type23);
1361 auto param16 = model->addOperand(&type7);
1362 auto param17 = model->addOperand(&type7);
1363 auto param18 = model->addOperand(&type23);
1364 auto param19 = model->addOperand(&type23);
1365 auto param20 = model->addOperand(&type23);
1366 auto scoresOut1 = model->addOperand(&type30);
1367 auto roiOut1 = model->addOperand(&type25);
1368 auto classesOut1 = model->addOperand(&type3);
1369 auto batchSplitOut1 = model->addOperand(&type3);
1370 auto in1 = model->addOperand(&type21);
1371 auto param21 = model->addOperand(&type7);
1372 auto param22 = model->addOperand(&type7);
1373 auto param23 = model->addOperand(&type23);
1374 auto param24 = model->addOperand(&type23);
1375 auto param25 = model->addOperand(&type7);
1376 auto param26 = model->addOperand(&type7);
1377 auto layout1 = model->addOperand(&type8);
1378 auto featureMap1 = model->addOperand(&type20);
1379 auto in2 = model->addOperand(&type34);
1380 auto param27 = model->addOperand(&type7);
1381 auto out1 = model->addOperand(&type31);
1382 // Phase 2, operations
1383 static _Float16 scores1_init[] = {0.8999999761581421f, 0.10000000149011612f};
1384 model->setOperandValue(scores1, scores1_init, sizeof(_Float16) * 2);
1385 static _Float16 roi1_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1386 model->setOperandValue(roi1, roi1_init, sizeof(_Float16) * 8);
1387 static int32_t param14_init[] = {0};
1388 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
1389 static _Float16 param15_init[] = {0.30000001192092896f};
1390 model->setOperandValue(param15, param15_init, sizeof(_Float16) * 1);
1391 static int32_t param16_init[] = {-1};
1392 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1393 static int32_t param17_init[] = {0};
1394 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
1395 static _Float16 param18_init[] = {0.4000000059604645f};
1396 model->setOperandValue(param18, param18_init, sizeof(_Float16) * 1);
1397 static _Float16 param19_init[] = {1.0f};
1398 model->setOperandValue(param19, param19_init, sizeof(_Float16) * 1);
1399 static _Float16 param20_init[] = {0.30000001192092896f};
1400 model->setOperandValue(param20, param20_init, sizeof(_Float16) * 1);
1401 static int32_t param21_init[] = {2};
1402 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1403 static int32_t param22_init[] = {2};
1404 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1405 static _Float16 param23_init[] = {2.0f};
1406 model->setOperandValue(param23, param23_init, sizeof(_Float16) * 1);
1407 static _Float16 param24_init[] = {2.0f};
1408 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1);
1409 static int32_t param25_init[] = {4};
1410 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1411 static int32_t param26_init[] = {4};
1412 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1413 static bool8 layout1_init[] = {false};
1414 model->setOperandValue(layout1, layout1_init, sizeof(bool8) * 1);
1415 static int32_t param27_init[] = {0};
1416 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1417 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores1, roi1, param14, param15, param16, param17, param18, param19, param20}, {scoresOut1, roiOut1, classesOut1, batchSplitOut1});
1418 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roiOut1, batchSplitOut1, param21, param22, param23, param24, param25, param26, layout1}, {featureMap1});
1419 model->addOperation(ANEURALNETWORKS_CONCATENATION, {featureMap1, in2, param27}, {out1});
1420 // Phase 3, inputs and outputs
1421 model->identifyInputsAndOutputs(
1422 {in1, in2},
1423 {scoresOut1, classesOut1, out1});
1424 assert(model->isValid());
1425 }
1426
is_ignored_dynamic_output_shape_float16_2(int i)1427 inline bool is_ignored_dynamic_output_shape_float16_2(int i) {
1428 static std::set<int> ignore = {};
1429 return ignore.find(i) != ignore.end();
1430 }
1431
1432