1 // clang-format off
2 // Generated file (from: fully_connected_v1_2.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4 OperandType type0(Type::TENSOR_FLOAT32, {3, 1});
5 OperandType type1(Type::TENSOR_FLOAT32, {1, 1});
6 OperandType type2(Type::TENSOR_FLOAT32, {1});
7 OperandType type3(Type::INT32, {});
8 // Phase 1, operands
9 auto op1 = model->addOperand(&type0);
10 auto op2 = model->addOperand(&type1);
11 auto b0 = model->addOperand(&type2);
12 auto act = model->addOperand(&type3);
13 auto op3 = model->addOperand(&type0);
14 // Phase 2, operations
15 static float op2_init[] = {2.0f};
16 model->setOperandValue(op2, op2_init, sizeof(float) * 1);
17 static float b0_init[] = {4.0f};
18 model->setOperandValue(b0, b0_init, sizeof(float) * 1);
19 static int32_t act_init[] = {0};
20 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
21 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
22 // Phase 3, inputs and outputs
23 model->identifyInputsAndOutputs(
24 {op1},
25 {op3});
26 assert(model->isValid());
27 }
28
is_ignored(int i)29 inline bool is_ignored(int i) {
30 static std::set<int> ignore = {};
31 return ignore.find(i) != ignore.end();
32 }
33
CreateModel_relaxed(Model * model)34 void CreateModel_relaxed(Model *model) {
35 OperandType type0(Type::TENSOR_FLOAT32, {3, 1});
36 OperandType type1(Type::TENSOR_FLOAT32, {1, 1});
37 OperandType type2(Type::TENSOR_FLOAT32, {1});
38 OperandType type3(Type::INT32, {});
39 // Phase 1, operands
40 auto op1 = model->addOperand(&type0);
41 auto op2 = model->addOperand(&type1);
42 auto b0 = model->addOperand(&type2);
43 auto act = model->addOperand(&type3);
44 auto op3 = model->addOperand(&type0);
45 // Phase 2, operations
46 static float op2_init[] = {2.0f};
47 model->setOperandValue(op2, op2_init, sizeof(float) * 1);
48 static float b0_init[] = {4.0f};
49 model->setOperandValue(b0, b0_init, sizeof(float) * 1);
50 static int32_t act_init[] = {0};
51 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
52 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
53 // Phase 3, inputs and outputs
54 model->identifyInputsAndOutputs(
55 {op1},
56 {op3});
57 // Phase 4: set relaxed execution
58 model->relaxComputationFloat32toFloat16(true);
59 assert(model->isValid());
60 }
61
is_ignored_relaxed(int i)62 inline bool is_ignored_relaxed(int i) {
63 static std::set<int> ignore = {};
64 return ignore.find(i) != ignore.end();
65 }
66
CreateModel_float16(Model * model)67 void CreateModel_float16(Model *model) {
68 OperandType type16(Type::TENSOR_FLOAT16, {1});
69 OperandType type17(Type::TENSOR_FLOAT16, {3, 1});
70 OperandType type18(Type::TENSOR_FLOAT16, {1, 1});
71 OperandType type3(Type::INT32, {});
72 // Phase 1, operands
73 auto op1 = model->addOperand(&type17);
74 auto op2 = model->addOperand(&type18);
75 auto b0 = model->addOperand(&type16);
76 auto act = model->addOperand(&type3);
77 auto op3 = model->addOperand(&type17);
78 // Phase 2, operations
79 static _Float16 op2_init[] = {2.0f};
80 model->setOperandValue(op2, op2_init, sizeof(_Float16) * 1);
81 static _Float16 b0_init[] = {4.0f};
82 model->setOperandValue(b0, b0_init, sizeof(_Float16) * 1);
83 static int32_t act_init[] = {0};
84 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
85 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
86 // Phase 3, inputs and outputs
87 model->identifyInputsAndOutputs(
88 {op1},
89 {op3});
90 assert(model->isValid());
91 }
92
is_ignored_float16(int i)93 inline bool is_ignored_float16(int i) {
94 static std::set<int> ignore = {};
95 return ignore.find(i) != ignore.end();
96 }
97
CreateModel_quant8_mult_gt_1(Model * model)98 void CreateModel_quant8_mult_gt_1(Model *model) {
99 OperandType type19(Type::TENSOR_INT32, {1}, 0.25f, 0);
100 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {3, 1}, 0.5f, 127);
101 OperandType type21(Type::TENSOR_QUANT8_ASYMM, {1, 1}, 0.5f, 120);
102 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {3, 1}, 0.1f, 128);
103 OperandType type3(Type::INT32, {});
104 // Phase 1, operands
105 auto op1 = model->addOperand(&type20);
106 auto op2 = model->addOperand(&type21);
107 auto b0 = model->addOperand(&type19);
108 auto act = model->addOperand(&type3);
109 auto op3 = model->addOperand(&type22);
110 // Phase 2, operations
111 static uint8_t op2_init[] = {124};
112 model->setOperandValue(op2, op2_init, sizeof(uint8_t) * 1);
113 static int32_t b0_init[] = {16};
114 model->setOperandValue(b0, b0_init, sizeof(int32_t) * 1);
115 static int32_t act_init[] = {0};
116 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
117 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
118 // Phase 3, inputs and outputs
119 model->identifyInputsAndOutputs(
120 {op1},
121 {op3});
122 assert(model->isValid());
123 }
124
is_ignored_quant8_mult_gt_1(int i)125 inline bool is_ignored_quant8_mult_gt_1(int i) {
126 static std::set<int> ignore = {};
127 return ignore.find(i) != ignore.end();
128 }
129
CreateModel_dynamic_output_shape(Model * model)130 void CreateModel_dynamic_output_shape(Model *model) {
131 OperandType type0(Type::TENSOR_FLOAT32, {3, 1});
132 OperandType type1(Type::TENSOR_FLOAT32, {1, 1});
133 OperandType type2(Type::TENSOR_FLOAT32, {1});
134 OperandType type23(Type::TENSOR_FLOAT32, {0, 0});
135 OperandType type3(Type::INT32, {});
136 // Phase 1, operands
137 auto op1 = model->addOperand(&type0);
138 auto op2 = model->addOperand(&type1);
139 auto b0 = model->addOperand(&type2);
140 auto act = model->addOperand(&type3);
141 auto op3 = model->addOperand(&type23);
142 // Phase 2, operations
143 static float op2_init[] = {2.0f};
144 model->setOperandValue(op2, op2_init, sizeof(float) * 1);
145 static float b0_init[] = {4.0f};
146 model->setOperandValue(b0, b0_init, sizeof(float) * 1);
147 static int32_t act_init[] = {0};
148 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
149 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
150 // Phase 3, inputs and outputs
151 model->identifyInputsAndOutputs(
152 {op1},
153 {op3});
154 assert(model->isValid());
155 }
156
is_ignored_dynamic_output_shape(int i)157 inline bool is_ignored_dynamic_output_shape(int i) {
158 static std::set<int> ignore = {};
159 return ignore.find(i) != ignore.end();
160 }
161
CreateModel_dynamic_output_shape_relaxed(Model * model)162 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
163 OperandType type0(Type::TENSOR_FLOAT32, {3, 1});
164 OperandType type1(Type::TENSOR_FLOAT32, {1, 1});
165 OperandType type2(Type::TENSOR_FLOAT32, {1});
166 OperandType type23(Type::TENSOR_FLOAT32, {0, 0});
167 OperandType type3(Type::INT32, {});
168 // Phase 1, operands
169 auto op1 = model->addOperand(&type0);
170 auto op2 = model->addOperand(&type1);
171 auto b0 = model->addOperand(&type2);
172 auto act = model->addOperand(&type3);
173 auto op3 = model->addOperand(&type23);
174 // Phase 2, operations
175 static float op2_init[] = {2.0f};
176 model->setOperandValue(op2, op2_init, sizeof(float) * 1);
177 static float b0_init[] = {4.0f};
178 model->setOperandValue(b0, b0_init, sizeof(float) * 1);
179 static int32_t act_init[] = {0};
180 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
181 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
182 // Phase 3, inputs and outputs
183 model->identifyInputsAndOutputs(
184 {op1},
185 {op3});
186 // Phase 4: set relaxed execution
187 model->relaxComputationFloat32toFloat16(true);
188 assert(model->isValid());
189 }
190
is_ignored_dynamic_output_shape_relaxed(int i)191 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
192 static std::set<int> ignore = {};
193 return ignore.find(i) != ignore.end();
194 }
195
CreateModel_dynamic_output_shape_float16(Model * model)196 void CreateModel_dynamic_output_shape_float16(Model *model) {
197 OperandType type16(Type::TENSOR_FLOAT16, {1});
198 OperandType type17(Type::TENSOR_FLOAT16, {3, 1});
199 OperandType type18(Type::TENSOR_FLOAT16, {1, 1});
200 OperandType type24(Type::TENSOR_FLOAT16, {0, 0});
201 OperandType type3(Type::INT32, {});
202 // Phase 1, operands
203 auto op1 = model->addOperand(&type17);
204 auto op2 = model->addOperand(&type18);
205 auto b0 = model->addOperand(&type16);
206 auto act = model->addOperand(&type3);
207 auto op3 = model->addOperand(&type24);
208 // Phase 2, operations
209 static _Float16 op2_init[] = {2.0f};
210 model->setOperandValue(op2, op2_init, sizeof(_Float16) * 1);
211 static _Float16 b0_init[] = {4.0f};
212 model->setOperandValue(b0, b0_init, sizeof(_Float16) * 1);
213 static int32_t act_init[] = {0};
214 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
215 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
216 // Phase 3, inputs and outputs
217 model->identifyInputsAndOutputs(
218 {op1},
219 {op3});
220 assert(model->isValid());
221 }
222
is_ignored_dynamic_output_shape_float16(int i)223 inline bool is_ignored_dynamic_output_shape_float16(int i) {
224 static std::set<int> ignore = {};
225 return ignore.find(i) != ignore.end();
226 }
227
CreateModel_dynamic_output_shape_quant8_mult_gt_1(Model * model)228 void CreateModel_dynamic_output_shape_quant8_mult_gt_1(Model *model) {
229 OperandType type19(Type::TENSOR_INT32, {1}, 0.25f, 0);
230 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {3, 1}, 0.5f, 127);
231 OperandType type21(Type::TENSOR_QUANT8_ASYMM, {1, 1}, 0.5f, 120);
232 OperandType type25(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.1f, 128);
233 OperandType type3(Type::INT32, {});
234 // Phase 1, operands
235 auto op1 = model->addOperand(&type20);
236 auto op2 = model->addOperand(&type21);
237 auto b0 = model->addOperand(&type19);
238 auto act = model->addOperand(&type3);
239 auto op3 = model->addOperand(&type25);
240 // Phase 2, operations
241 static uint8_t op2_init[] = {124};
242 model->setOperandValue(op2, op2_init, sizeof(uint8_t) * 1);
243 static int32_t b0_init[] = {16};
244 model->setOperandValue(b0, b0_init, sizeof(int32_t) * 1);
245 static int32_t act_init[] = {0};
246 model->setOperandValue(act, act_init, sizeof(int32_t) * 1);
247 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {op1, op2, b0, act}, {op3});
248 // Phase 3, inputs and outputs
249 model->identifyInputsAndOutputs(
250 {op1},
251 {op3});
252 assert(model->isValid());
253 }
254
is_ignored_dynamic_output_shape_quant8_mult_gt_1(int i)255 inline bool is_ignored_dynamic_output_shape_quant8_mult_gt_1(int i) {
256 static std::set<int> ignore = {};
257 return ignore.find(i) != ignore.end();
258 }
259
CreateModel_zero_sized_nhwc(Model * model)260 void CreateModel_zero_sized_nhwc(Model *model) {
261 OperandType type10(Type::FLOAT32, {});
262 OperandType type11(Type::BOOL, {});
263 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 3});
264 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 3});
265 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
266 OperandType type15(Type::TENSOR_FLOAT32, {0, 1});
267 OperandType type2(Type::TENSOR_FLOAT32, {1});
268 OperandType type3(Type::INT32, {});
269 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
270 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
271 OperandType type6(Type::TENSOR_FLOAT32, {0});
272 OperandType type7(Type::TENSOR_INT32, {0});
273 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
274 OperandType type9(Type::TENSOR_INT32, {1});
275 // Phase 1, operands
276 auto scores = model->addOperand(&type4);
277 auto roi = model->addOperand(&type5);
278 auto param = model->addOperand(&type9);
279 auto param1 = model->addOperand(&type10);
280 auto param2 = model->addOperand(&type3);
281 auto param3 = model->addOperand(&type3);
282 auto param4 = model->addOperand(&type10);
283 auto param5 = model->addOperand(&type10);
284 auto param6 = model->addOperand(&type10);
285 auto scoresOut = model->addOperand(&type6);
286 auto roiOut = model->addOperand(&type8);
287 auto classesOut = model->addOperand(&type7);
288 auto batchSplitOut = model->addOperand(&type7);
289 auto in = model->addOperand(&type12);
290 auto param7 = model->addOperand(&type3);
291 auto param8 = model->addOperand(&type3);
292 auto param9 = model->addOperand(&type10);
293 auto param10 = model->addOperand(&type10);
294 auto param11 = model->addOperand(&type3);
295 auto param12 = model->addOperand(&type3);
296 auto layout = model->addOperand(&type11);
297 auto featureMap = model->addOperand(&type13);
298 auto weights = model->addOperand(&type14);
299 auto bias = model->addOperand(&type2);
300 auto param13 = model->addOperand(&type3);
301 auto out = model->addOperand(&type15);
302 // Phase 2, operations
303 static float scores_init[] = {0.9f, 0.1f};
304 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
305 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
306 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
307 static int32_t param_init[] = {0};
308 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
309 static float param1_init[] = {0.3f};
310 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
311 static int32_t param2_init[] = {-1};
312 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
313 static int32_t param3_init[] = {0};
314 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
315 static float param4_init[] = {0.4f};
316 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
317 static float param5_init[] = {1.0f};
318 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
319 static float param6_init[] = {0.3f};
320 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
321 static int32_t param7_init[] = {2};
322 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
323 static int32_t param8_init[] = {2};
324 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
325 static float param9_init[] = {2.0f};
326 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
327 static float param10_init[] = {2.0f};
328 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
329 static int32_t param11_init[] = {4};
330 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
331 static int32_t param12_init[] = {4};
332 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
333 static bool8 layout_init[] = {false};
334 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
335 static float weights_init[] = {1.0f, 2.0f, 3.0f};
336 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
337 static float bias_init[] = {1.0f};
338 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
339 static int32_t param13_init[] = {0};
340 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
341 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
342 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
343 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
344 // Phase 3, inputs and outputs
345 model->identifyInputsAndOutputs(
346 {in},
347 {scoresOut, classesOut, out});
348 assert(model->isValid());
349 }
350
is_ignored_zero_sized_nhwc(int i)351 inline bool is_ignored_zero_sized_nhwc(int i) {
352 static std::set<int> ignore = {};
353 return ignore.find(i) != ignore.end();
354 }
355
CreateModel_zero_sized_nhwc_relaxed(Model * model)356 void CreateModel_zero_sized_nhwc_relaxed(Model *model) {
357 OperandType type10(Type::FLOAT32, {});
358 OperandType type11(Type::BOOL, {});
359 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 3});
360 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 3});
361 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
362 OperandType type15(Type::TENSOR_FLOAT32, {0, 1});
363 OperandType type2(Type::TENSOR_FLOAT32, {1});
364 OperandType type3(Type::INT32, {});
365 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
366 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
367 OperandType type6(Type::TENSOR_FLOAT32, {0});
368 OperandType type7(Type::TENSOR_INT32, {0});
369 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
370 OperandType type9(Type::TENSOR_INT32, {1});
371 // Phase 1, operands
372 auto scores = model->addOperand(&type4);
373 auto roi = model->addOperand(&type5);
374 auto param = model->addOperand(&type9);
375 auto param1 = model->addOperand(&type10);
376 auto param2 = model->addOperand(&type3);
377 auto param3 = model->addOperand(&type3);
378 auto param4 = model->addOperand(&type10);
379 auto param5 = model->addOperand(&type10);
380 auto param6 = model->addOperand(&type10);
381 auto scoresOut = model->addOperand(&type6);
382 auto roiOut = model->addOperand(&type8);
383 auto classesOut = model->addOperand(&type7);
384 auto batchSplitOut = model->addOperand(&type7);
385 auto in = model->addOperand(&type12);
386 auto param7 = model->addOperand(&type3);
387 auto param8 = model->addOperand(&type3);
388 auto param9 = model->addOperand(&type10);
389 auto param10 = model->addOperand(&type10);
390 auto param11 = model->addOperand(&type3);
391 auto param12 = model->addOperand(&type3);
392 auto layout = model->addOperand(&type11);
393 auto featureMap = model->addOperand(&type13);
394 auto weights = model->addOperand(&type14);
395 auto bias = model->addOperand(&type2);
396 auto param13 = model->addOperand(&type3);
397 auto out = model->addOperand(&type15);
398 // Phase 2, operations
399 static float scores_init[] = {0.9f, 0.1f};
400 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
401 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
402 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
403 static int32_t param_init[] = {0};
404 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
405 static float param1_init[] = {0.3f};
406 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
407 static int32_t param2_init[] = {-1};
408 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
409 static int32_t param3_init[] = {0};
410 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
411 static float param4_init[] = {0.4f};
412 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
413 static float param5_init[] = {1.0f};
414 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
415 static float param6_init[] = {0.3f};
416 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
417 static int32_t param7_init[] = {2};
418 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
419 static int32_t param8_init[] = {2};
420 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
421 static float param9_init[] = {2.0f};
422 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
423 static float param10_init[] = {2.0f};
424 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
425 static int32_t param11_init[] = {4};
426 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
427 static int32_t param12_init[] = {4};
428 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
429 static bool8 layout_init[] = {false};
430 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
431 static float weights_init[] = {1.0f, 2.0f, 3.0f};
432 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
433 static float bias_init[] = {1.0f};
434 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
435 static int32_t param13_init[] = {0};
436 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
437 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
438 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
439 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
440 // Phase 3, inputs and outputs
441 model->identifyInputsAndOutputs(
442 {in},
443 {scoresOut, classesOut, out});
444 // Phase 4: set relaxed execution
445 model->relaxComputationFloat32toFloat16(true);
446 assert(model->isValid());
447 }
448
is_ignored_zero_sized_nhwc_relaxed(int i)449 inline bool is_ignored_zero_sized_nhwc_relaxed(int i) {
450 static std::set<int> ignore = {};
451 return ignore.find(i) != ignore.end();
452 }
453
CreateModel_zero_sized_nhwc_quant8(Model * model)454 void CreateModel_zero_sized_nhwc_quant8(Model *model) {
455 OperandType type10(Type::FLOAT32, {});
456 OperandType type11(Type::BOOL, {});
457 OperandType type26(Type::TENSOR_INT32, {1}, 0.01f, 0);
458 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 3}, 0.1f, 128);
459 OperandType type28(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 3}, 0.1f, 128);
460 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {0, 1}, 0.1f, 128);
461 OperandType type3(Type::INT32, {});
462 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
463 OperandType type31(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
464 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
465 OperandType type33(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
466 OperandType type34(Type::TENSOR_QUANT8_ASYMM, {1, 3}, 0.1f, 128);
467 OperandType type7(Type::TENSOR_INT32, {0});
468 OperandType type9(Type::TENSOR_INT32, {1});
469 // Phase 1, operands
470 auto scores = model->addOperand(&type32);
471 auto roi = model->addOperand(&type30);
472 auto param = model->addOperand(&type9);
473 auto param1 = model->addOperand(&type10);
474 auto param2 = model->addOperand(&type3);
475 auto param3 = model->addOperand(&type3);
476 auto param4 = model->addOperand(&type10);
477 auto param5 = model->addOperand(&type10);
478 auto param6 = model->addOperand(&type10);
479 auto scoresOut = model->addOperand(&type33);
480 auto roiOut = model->addOperand(&type31);
481 auto classesOut = model->addOperand(&type7);
482 auto batchSplitOut = model->addOperand(&type7);
483 auto in = model->addOperand(&type28);
484 auto param7 = model->addOperand(&type3);
485 auto param8 = model->addOperand(&type3);
486 auto param9 = model->addOperand(&type10);
487 auto param10 = model->addOperand(&type10);
488 auto param11 = model->addOperand(&type3);
489 auto param12 = model->addOperand(&type3);
490 auto layout = model->addOperand(&type11);
491 auto featureMap = model->addOperand(&type27);
492 auto weights = model->addOperand(&type34);
493 auto bias = model->addOperand(&type26);
494 auto param13 = model->addOperand(&type3);
495 auto out = model->addOperand(&type29);
496 // Phase 2, operations
497 static uint8_t scores_init[] = {137, 129};
498 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
499 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
500 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
501 static int32_t param_init[] = {0};
502 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
503 static float param1_init[] = {0.3f};
504 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
505 static int32_t param2_init[] = {-1};
506 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
507 static int32_t param3_init[] = {0};
508 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
509 static float param4_init[] = {0.4f};
510 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
511 static float param5_init[] = {1.0f};
512 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
513 static float param6_init[] = {0.3f};
514 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
515 static int32_t param7_init[] = {2};
516 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
517 static int32_t param8_init[] = {2};
518 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
519 static float param9_init[] = {2.0f};
520 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
521 static float param10_init[] = {2.0f};
522 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
523 static int32_t param11_init[] = {4};
524 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
525 static int32_t param12_init[] = {4};
526 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
527 static bool8 layout_init[] = {false};
528 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
529 static uint8_t weights_init[] = {138, 148, 158};
530 model->setOperandValue(weights, weights_init, sizeof(uint8_t) * 3);
531 static int32_t bias_init[] = {100};
532 model->setOperandValue(bias, bias_init, sizeof(int32_t) * 1);
533 static int32_t param13_init[] = {0};
534 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
535 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
536 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
537 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
538 // Phase 3, inputs and outputs
539 model->identifyInputsAndOutputs(
540 {in},
541 {scoresOut, classesOut, out});
542 assert(model->isValid());
543 }
544
is_ignored_zero_sized_nhwc_quant8(int i)545 inline bool is_ignored_zero_sized_nhwc_quant8(int i) {
546 static std::set<int> ignore = {};
547 return ignore.find(i) != ignore.end();
548 }
549
CreateModel_zero_sized_nhwc_float16(Model * model)550 void CreateModel_zero_sized_nhwc_float16(Model *model) {
551 OperandType type11(Type::BOOL, {});
552 OperandType type16(Type::TENSOR_FLOAT16, {1});
553 OperandType type3(Type::INT32, {});
554 OperandType type35(Type::TENSOR_FLOAT16, {0, 2, 2, 3});
555 OperandType type36(Type::TENSOR_FLOAT16, {1, 1, 1, 3});
556 OperandType type37(Type::TENSOR_FLOAT16, {0, 1});
557 OperandType type38(Type::FLOAT16, {});
558 OperandType type39(Type::TENSOR_FLOAT16, {1, 8});
559 OperandType type40(Type::TENSOR_FLOAT16, {0, 4});
560 OperandType type41(Type::TENSOR_FLOAT16, {1, 2});
561 OperandType type42(Type::TENSOR_FLOAT16, {0});
562 OperandType type43(Type::TENSOR_FLOAT16, {1, 3});
563 OperandType type7(Type::TENSOR_INT32, {0});
564 OperandType type9(Type::TENSOR_INT32, {1});
565 // Phase 1, operands
566 auto scores = model->addOperand(&type41);
567 auto roi = model->addOperand(&type39);
568 auto param = model->addOperand(&type9);
569 auto param1 = model->addOperand(&type38);
570 auto param2 = model->addOperand(&type3);
571 auto param3 = model->addOperand(&type3);
572 auto param4 = model->addOperand(&type38);
573 auto param5 = model->addOperand(&type38);
574 auto param6 = model->addOperand(&type38);
575 auto scoresOut = model->addOperand(&type42);
576 auto roiOut = model->addOperand(&type40);
577 auto classesOut = model->addOperand(&type7);
578 auto batchSplitOut = model->addOperand(&type7);
579 auto in = model->addOperand(&type36);
580 auto param7 = model->addOperand(&type3);
581 auto param8 = model->addOperand(&type3);
582 auto param9 = model->addOperand(&type38);
583 auto param10 = model->addOperand(&type38);
584 auto param11 = model->addOperand(&type3);
585 auto param12 = model->addOperand(&type3);
586 auto layout = model->addOperand(&type11);
587 auto featureMap = model->addOperand(&type35);
588 auto weights = model->addOperand(&type43);
589 auto bias = model->addOperand(&type16);
590 auto param13 = model->addOperand(&type3);
591 auto out = model->addOperand(&type37);
592 // Phase 2, operations
593 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
594 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
595 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
596 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
597 static int32_t param_init[] = {0};
598 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
599 static _Float16 param1_init[] = {0.30000001192092896f};
600 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
601 static int32_t param2_init[] = {-1};
602 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
603 static int32_t param3_init[] = {0};
604 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
605 static _Float16 param4_init[] = {0.4000000059604645f};
606 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
607 static _Float16 param5_init[] = {1.0f};
608 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
609 static _Float16 param6_init[] = {0.30000001192092896f};
610 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
611 static int32_t param7_init[] = {2};
612 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
613 static int32_t param8_init[] = {2};
614 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
615 static _Float16 param9_init[] = {2.0f};
616 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
617 static _Float16 param10_init[] = {2.0f};
618 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
619 static int32_t param11_init[] = {4};
620 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
621 static int32_t param12_init[] = {4};
622 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
623 static bool8 layout_init[] = {false};
624 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
625 static _Float16 weights_init[] = {1.0f, 2.0f, 3.0f};
626 model->setOperandValue(weights, weights_init, sizeof(_Float16) * 3);
627 static _Float16 bias_init[] = {1.0f};
628 model->setOperandValue(bias, bias_init, sizeof(_Float16) * 1);
629 static int32_t param13_init[] = {0};
630 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
631 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
632 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
633 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
634 // Phase 3, inputs and outputs
635 model->identifyInputsAndOutputs(
636 {in},
637 {scoresOut, classesOut, out});
638 assert(model->isValid());
639 }
640
is_ignored_zero_sized_nhwc_float16(int i)641 inline bool is_ignored_zero_sized_nhwc_float16(int i) {
642 static std::set<int> ignore = {};
643 return ignore.find(i) != ignore.end();
644 }
645
CreateModel_zero_sized_nchw(Model * model)646 void CreateModel_zero_sized_nchw(Model *model) {
647 OperandType type10(Type::FLOAT32, {});
648 OperandType type11(Type::BOOL, {});
649 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
650 OperandType type15(Type::TENSOR_FLOAT32, {0, 1});
651 OperandType type2(Type::TENSOR_FLOAT32, {1});
652 OperandType type3(Type::INT32, {});
653 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
654 OperandType type44(Type::TENSOR_FLOAT32, {0, 3, 2, 2});
655 OperandType type45(Type::TENSOR_FLOAT32, {1, 3, 1, 1});
656 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
657 OperandType type6(Type::TENSOR_FLOAT32, {0});
658 OperandType type7(Type::TENSOR_INT32, {0});
659 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
660 OperandType type9(Type::TENSOR_INT32, {1});
661 // Phase 1, operands
662 auto scores = model->addOperand(&type4);
663 auto roi = model->addOperand(&type5);
664 auto param = model->addOperand(&type9);
665 auto param1 = model->addOperand(&type10);
666 auto param2 = model->addOperand(&type3);
667 auto param3 = model->addOperand(&type3);
668 auto param4 = model->addOperand(&type10);
669 auto param5 = model->addOperand(&type10);
670 auto param6 = model->addOperand(&type10);
671 auto scoresOut = model->addOperand(&type6);
672 auto roiOut = model->addOperand(&type8);
673 auto classesOut = model->addOperand(&type7);
674 auto batchSplitOut = model->addOperand(&type7);
675 auto in = model->addOperand(&type45);
676 auto param7 = model->addOperand(&type3);
677 auto param8 = model->addOperand(&type3);
678 auto param9 = model->addOperand(&type10);
679 auto param10 = model->addOperand(&type10);
680 auto param11 = model->addOperand(&type3);
681 auto param12 = model->addOperand(&type3);
682 auto layout = model->addOperand(&type11);
683 auto featureMap = model->addOperand(&type44);
684 auto weights = model->addOperand(&type14);
685 auto bias = model->addOperand(&type2);
686 auto param13 = model->addOperand(&type3);
687 auto out = model->addOperand(&type15);
688 // Phase 2, operations
689 static float scores_init[] = {0.9f, 0.1f};
690 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
691 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
692 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
693 static int32_t param_init[] = {0};
694 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
695 static float param1_init[] = {0.3f};
696 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
697 static int32_t param2_init[] = {-1};
698 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
699 static int32_t param3_init[] = {0};
700 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
701 static float param4_init[] = {0.4f};
702 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
703 static float param5_init[] = {1.0f};
704 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
705 static float param6_init[] = {0.3f};
706 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
707 static int32_t param7_init[] = {2};
708 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
709 static int32_t param8_init[] = {2};
710 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
711 static float param9_init[] = {2.0f};
712 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
713 static float param10_init[] = {2.0f};
714 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
715 static int32_t param11_init[] = {4};
716 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
717 static int32_t param12_init[] = {4};
718 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
719 static bool8 layout_init[] = {true};
720 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
721 static float weights_init[] = {1.0f, 2.0f, 3.0f};
722 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
723 static float bias_init[] = {1.0f};
724 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
725 static int32_t param13_init[] = {0};
726 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
727 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
728 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
729 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
730 // Phase 3, inputs and outputs
731 model->identifyInputsAndOutputs(
732 {in},
733 {scoresOut, classesOut, out});
734 assert(model->isValid());
735 }
736
is_ignored_zero_sized_nchw(int i)737 inline bool is_ignored_zero_sized_nchw(int i) {
738 static std::set<int> ignore = {};
739 return ignore.find(i) != ignore.end();
740 }
741
CreateModel_zero_sized_nchw_relaxed(Model * model)742 void CreateModel_zero_sized_nchw_relaxed(Model *model) {
743 OperandType type10(Type::FLOAT32, {});
744 OperandType type11(Type::BOOL, {});
745 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
746 OperandType type15(Type::TENSOR_FLOAT32, {0, 1});
747 OperandType type2(Type::TENSOR_FLOAT32, {1});
748 OperandType type3(Type::INT32, {});
749 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
750 OperandType type44(Type::TENSOR_FLOAT32, {0, 3, 2, 2});
751 OperandType type45(Type::TENSOR_FLOAT32, {1, 3, 1, 1});
752 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
753 OperandType type6(Type::TENSOR_FLOAT32, {0});
754 OperandType type7(Type::TENSOR_INT32, {0});
755 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
756 OperandType type9(Type::TENSOR_INT32, {1});
757 // Phase 1, operands
758 auto scores = model->addOperand(&type4);
759 auto roi = model->addOperand(&type5);
760 auto param = model->addOperand(&type9);
761 auto param1 = model->addOperand(&type10);
762 auto param2 = model->addOperand(&type3);
763 auto param3 = model->addOperand(&type3);
764 auto param4 = model->addOperand(&type10);
765 auto param5 = model->addOperand(&type10);
766 auto param6 = model->addOperand(&type10);
767 auto scoresOut = model->addOperand(&type6);
768 auto roiOut = model->addOperand(&type8);
769 auto classesOut = model->addOperand(&type7);
770 auto batchSplitOut = model->addOperand(&type7);
771 auto in = model->addOperand(&type45);
772 auto param7 = model->addOperand(&type3);
773 auto param8 = model->addOperand(&type3);
774 auto param9 = model->addOperand(&type10);
775 auto param10 = model->addOperand(&type10);
776 auto param11 = model->addOperand(&type3);
777 auto param12 = model->addOperand(&type3);
778 auto layout = model->addOperand(&type11);
779 auto featureMap = model->addOperand(&type44);
780 auto weights = model->addOperand(&type14);
781 auto bias = model->addOperand(&type2);
782 auto param13 = model->addOperand(&type3);
783 auto out = model->addOperand(&type15);
784 // Phase 2, operations
785 static float scores_init[] = {0.9f, 0.1f};
786 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
787 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
788 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
789 static int32_t param_init[] = {0};
790 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
791 static float param1_init[] = {0.3f};
792 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
793 static int32_t param2_init[] = {-1};
794 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
795 static int32_t param3_init[] = {0};
796 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
797 static float param4_init[] = {0.4f};
798 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
799 static float param5_init[] = {1.0f};
800 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
801 static float param6_init[] = {0.3f};
802 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
803 static int32_t param7_init[] = {2};
804 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
805 static int32_t param8_init[] = {2};
806 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
807 static float param9_init[] = {2.0f};
808 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
809 static float param10_init[] = {2.0f};
810 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
811 static int32_t param11_init[] = {4};
812 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
813 static int32_t param12_init[] = {4};
814 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
815 static bool8 layout_init[] = {true};
816 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
817 static float weights_init[] = {1.0f, 2.0f, 3.0f};
818 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
819 static float bias_init[] = {1.0f};
820 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
821 static int32_t param13_init[] = {0};
822 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
823 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
824 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
825 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
826 // Phase 3, inputs and outputs
827 model->identifyInputsAndOutputs(
828 {in},
829 {scoresOut, classesOut, out});
830 // Phase 4: set relaxed execution
831 model->relaxComputationFloat32toFloat16(true);
832 assert(model->isValid());
833 }
834
is_ignored_zero_sized_nchw_relaxed(int i)835 inline bool is_ignored_zero_sized_nchw_relaxed(int i) {
836 static std::set<int> ignore = {};
837 return ignore.find(i) != ignore.end();
838 }
839
CreateModel_zero_sized_nchw_quant8(Model * model)840 void CreateModel_zero_sized_nchw_quant8(Model *model) {
841 OperandType type10(Type::FLOAT32, {});
842 OperandType type11(Type::BOOL, {});
843 OperandType type26(Type::TENSOR_INT32, {1}, 0.01f, 0);
844 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {0, 1}, 0.1f, 128);
845 OperandType type3(Type::INT32, {});
846 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
847 OperandType type31(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
848 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
849 OperandType type33(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
850 OperandType type34(Type::TENSOR_QUANT8_ASYMM, {1, 3}, 0.1f, 128);
851 OperandType type46(Type::TENSOR_QUANT8_ASYMM, {0, 3, 2, 2}, 0.1f, 128);
852 OperandType type47(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 1}, 0.1f, 128);
853 OperandType type7(Type::TENSOR_INT32, {0});
854 OperandType type9(Type::TENSOR_INT32, {1});
855 // Phase 1, operands
856 auto scores = model->addOperand(&type32);
857 auto roi = model->addOperand(&type30);
858 auto param = model->addOperand(&type9);
859 auto param1 = model->addOperand(&type10);
860 auto param2 = model->addOperand(&type3);
861 auto param3 = model->addOperand(&type3);
862 auto param4 = model->addOperand(&type10);
863 auto param5 = model->addOperand(&type10);
864 auto param6 = model->addOperand(&type10);
865 auto scoresOut = model->addOperand(&type33);
866 auto roiOut = model->addOperand(&type31);
867 auto classesOut = model->addOperand(&type7);
868 auto batchSplitOut = model->addOperand(&type7);
869 auto in = model->addOperand(&type47);
870 auto param7 = model->addOperand(&type3);
871 auto param8 = model->addOperand(&type3);
872 auto param9 = model->addOperand(&type10);
873 auto param10 = model->addOperand(&type10);
874 auto param11 = model->addOperand(&type3);
875 auto param12 = model->addOperand(&type3);
876 auto layout = model->addOperand(&type11);
877 auto featureMap = model->addOperand(&type46);
878 auto weights = model->addOperand(&type34);
879 auto bias = model->addOperand(&type26);
880 auto param13 = model->addOperand(&type3);
881 auto out = model->addOperand(&type29);
882 // Phase 2, operations
883 static uint8_t scores_init[] = {137, 129};
884 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
885 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
886 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
887 static int32_t param_init[] = {0};
888 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
889 static float param1_init[] = {0.3f};
890 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
891 static int32_t param2_init[] = {-1};
892 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
893 static int32_t param3_init[] = {0};
894 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
895 static float param4_init[] = {0.4f};
896 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
897 static float param5_init[] = {1.0f};
898 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
899 static float param6_init[] = {0.3f};
900 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
901 static int32_t param7_init[] = {2};
902 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
903 static int32_t param8_init[] = {2};
904 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
905 static float param9_init[] = {2.0f};
906 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
907 static float param10_init[] = {2.0f};
908 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
909 static int32_t param11_init[] = {4};
910 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
911 static int32_t param12_init[] = {4};
912 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
913 static bool8 layout_init[] = {true};
914 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
915 static uint8_t weights_init[] = {138, 148, 158};
916 model->setOperandValue(weights, weights_init, sizeof(uint8_t) * 3);
917 static int32_t bias_init[] = {100};
918 model->setOperandValue(bias, bias_init, sizeof(int32_t) * 1);
919 static int32_t param13_init[] = {0};
920 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
921 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
922 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
923 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
924 // Phase 3, inputs and outputs
925 model->identifyInputsAndOutputs(
926 {in},
927 {scoresOut, classesOut, out});
928 assert(model->isValid());
929 }
930
is_ignored_zero_sized_nchw_quant8(int i)931 inline bool is_ignored_zero_sized_nchw_quant8(int i) {
932 static std::set<int> ignore = {};
933 return ignore.find(i) != ignore.end();
934 }
935
CreateModel_zero_sized_nchw_float16(Model * model)936 void CreateModel_zero_sized_nchw_float16(Model *model) {
937 OperandType type11(Type::BOOL, {});
938 OperandType type16(Type::TENSOR_FLOAT16, {1});
939 OperandType type3(Type::INT32, {});
940 OperandType type37(Type::TENSOR_FLOAT16, {0, 1});
941 OperandType type38(Type::FLOAT16, {});
942 OperandType type39(Type::TENSOR_FLOAT16, {1, 8});
943 OperandType type40(Type::TENSOR_FLOAT16, {0, 4});
944 OperandType type41(Type::TENSOR_FLOAT16, {1, 2});
945 OperandType type42(Type::TENSOR_FLOAT16, {0});
946 OperandType type43(Type::TENSOR_FLOAT16, {1, 3});
947 OperandType type48(Type::TENSOR_FLOAT16, {0, 3, 2, 2});
948 OperandType type49(Type::TENSOR_FLOAT16, {1, 3, 1, 1});
949 OperandType type7(Type::TENSOR_INT32, {0});
950 OperandType type9(Type::TENSOR_INT32, {1});
951 // Phase 1, operands
952 auto scores = model->addOperand(&type41);
953 auto roi = model->addOperand(&type39);
954 auto param = model->addOperand(&type9);
955 auto param1 = model->addOperand(&type38);
956 auto param2 = model->addOperand(&type3);
957 auto param3 = model->addOperand(&type3);
958 auto param4 = model->addOperand(&type38);
959 auto param5 = model->addOperand(&type38);
960 auto param6 = model->addOperand(&type38);
961 auto scoresOut = model->addOperand(&type42);
962 auto roiOut = model->addOperand(&type40);
963 auto classesOut = model->addOperand(&type7);
964 auto batchSplitOut = model->addOperand(&type7);
965 auto in = model->addOperand(&type49);
966 auto param7 = model->addOperand(&type3);
967 auto param8 = model->addOperand(&type3);
968 auto param9 = model->addOperand(&type38);
969 auto param10 = model->addOperand(&type38);
970 auto param11 = model->addOperand(&type3);
971 auto param12 = model->addOperand(&type3);
972 auto layout = model->addOperand(&type11);
973 auto featureMap = model->addOperand(&type48);
974 auto weights = model->addOperand(&type43);
975 auto bias = model->addOperand(&type16);
976 auto param13 = model->addOperand(&type3);
977 auto out = model->addOperand(&type37);
978 // Phase 2, operations
979 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
980 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
981 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
982 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
983 static int32_t param_init[] = {0};
984 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
985 static _Float16 param1_init[] = {0.30000001192092896f};
986 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
987 static int32_t param2_init[] = {-1};
988 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
989 static int32_t param3_init[] = {0};
990 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
991 static _Float16 param4_init[] = {0.4000000059604645f};
992 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
993 static _Float16 param5_init[] = {1.0f};
994 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
995 static _Float16 param6_init[] = {0.30000001192092896f};
996 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
997 static int32_t param7_init[] = {2};
998 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
999 static int32_t param8_init[] = {2};
1000 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1001 static _Float16 param9_init[] = {2.0f};
1002 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
1003 static _Float16 param10_init[] = {2.0f};
1004 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
1005 static int32_t param11_init[] = {4};
1006 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1007 static int32_t param12_init[] = {4};
1008 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1009 static bool8 layout_init[] = {true};
1010 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1011 static _Float16 weights_init[] = {1.0f, 2.0f, 3.0f};
1012 model->setOperandValue(weights, weights_init, sizeof(_Float16) * 3);
1013 static _Float16 bias_init[] = {1.0f};
1014 model->setOperandValue(bias, bias_init, sizeof(_Float16) * 1);
1015 static int32_t param13_init[] = {0};
1016 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1017 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1018 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1019 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1020 // Phase 3, inputs and outputs
1021 model->identifyInputsAndOutputs(
1022 {in},
1023 {scoresOut, classesOut, out});
1024 assert(model->isValid());
1025 }
1026
is_ignored_zero_sized_nchw_float16(int i)1027 inline bool is_ignored_zero_sized_nchw_float16(int i) {
1028 static std::set<int> ignore = {};
1029 return ignore.find(i) != ignore.end();
1030 }
1031
CreateModel_zero_sized_dynamic_output_shape_nhwc(Model * model)1032 void CreateModel_zero_sized_dynamic_output_shape_nhwc(Model *model) {
1033 OperandType type10(Type::FLOAT32, {});
1034 OperandType type11(Type::BOOL, {});
1035 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 3});
1036 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 3});
1037 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
1038 OperandType type2(Type::TENSOR_FLOAT32, {1});
1039 OperandType type23(Type::TENSOR_FLOAT32, {0, 0});
1040 OperandType type3(Type::INT32, {});
1041 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
1042 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
1043 OperandType type6(Type::TENSOR_FLOAT32, {0});
1044 OperandType type7(Type::TENSOR_INT32, {0});
1045 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
1046 OperandType type9(Type::TENSOR_INT32, {1});
1047 // Phase 1, operands
1048 auto scores = model->addOperand(&type4);
1049 auto roi = model->addOperand(&type5);
1050 auto param = model->addOperand(&type9);
1051 auto param1 = model->addOperand(&type10);
1052 auto param2 = model->addOperand(&type3);
1053 auto param3 = model->addOperand(&type3);
1054 auto param4 = model->addOperand(&type10);
1055 auto param5 = model->addOperand(&type10);
1056 auto param6 = model->addOperand(&type10);
1057 auto scoresOut = model->addOperand(&type6);
1058 auto roiOut = model->addOperand(&type8);
1059 auto classesOut = model->addOperand(&type7);
1060 auto batchSplitOut = model->addOperand(&type7);
1061 auto in = model->addOperand(&type12);
1062 auto param7 = model->addOperand(&type3);
1063 auto param8 = model->addOperand(&type3);
1064 auto param9 = model->addOperand(&type10);
1065 auto param10 = model->addOperand(&type10);
1066 auto param11 = model->addOperand(&type3);
1067 auto param12 = model->addOperand(&type3);
1068 auto layout = model->addOperand(&type11);
1069 auto featureMap = model->addOperand(&type13);
1070 auto weights = model->addOperand(&type14);
1071 auto bias = model->addOperand(&type2);
1072 auto param13 = model->addOperand(&type3);
1073 auto out = model->addOperand(&type23);
1074 // Phase 2, operations
1075 static float scores_init[] = {0.9f, 0.1f};
1076 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
1077 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1078 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
1079 static int32_t param_init[] = {0};
1080 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1081 static float param1_init[] = {0.3f};
1082 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
1083 static int32_t param2_init[] = {-1};
1084 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1085 static int32_t param3_init[] = {0};
1086 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1087 static float param4_init[] = {0.4f};
1088 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
1089 static float param5_init[] = {1.0f};
1090 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
1091 static float param6_init[] = {0.3f};
1092 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
1093 static int32_t param7_init[] = {2};
1094 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1095 static int32_t param8_init[] = {2};
1096 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1097 static float param9_init[] = {2.0f};
1098 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1099 static float param10_init[] = {2.0f};
1100 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1101 static int32_t param11_init[] = {4};
1102 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1103 static int32_t param12_init[] = {4};
1104 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1105 static bool8 layout_init[] = {false};
1106 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1107 static float weights_init[] = {1.0f, 2.0f, 3.0f};
1108 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
1109 static float bias_init[] = {1.0f};
1110 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
1111 static int32_t param13_init[] = {0};
1112 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1113 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1114 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1115 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1116 // Phase 3, inputs and outputs
1117 model->identifyInputsAndOutputs(
1118 {in},
1119 {scoresOut, classesOut, out});
1120 assert(model->isValid());
1121 }
1122
is_ignored_zero_sized_dynamic_output_shape_nhwc(int i)1123 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc(int i) {
1124 static std::set<int> ignore = {};
1125 return ignore.find(i) != ignore.end();
1126 }
1127
CreateModel_zero_sized_dynamic_output_shape_nhwc_relaxed(Model * model)1128 void CreateModel_zero_sized_dynamic_output_shape_nhwc_relaxed(Model *model) {
1129 OperandType type10(Type::FLOAT32, {});
1130 OperandType type11(Type::BOOL, {});
1131 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 3});
1132 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 3});
1133 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
1134 OperandType type2(Type::TENSOR_FLOAT32, {1});
1135 OperandType type23(Type::TENSOR_FLOAT32, {0, 0});
1136 OperandType type3(Type::INT32, {});
1137 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
1138 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
1139 OperandType type6(Type::TENSOR_FLOAT32, {0});
1140 OperandType type7(Type::TENSOR_INT32, {0});
1141 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
1142 OperandType type9(Type::TENSOR_INT32, {1});
1143 // Phase 1, operands
1144 auto scores = model->addOperand(&type4);
1145 auto roi = model->addOperand(&type5);
1146 auto param = model->addOperand(&type9);
1147 auto param1 = model->addOperand(&type10);
1148 auto param2 = model->addOperand(&type3);
1149 auto param3 = model->addOperand(&type3);
1150 auto param4 = model->addOperand(&type10);
1151 auto param5 = model->addOperand(&type10);
1152 auto param6 = model->addOperand(&type10);
1153 auto scoresOut = model->addOperand(&type6);
1154 auto roiOut = model->addOperand(&type8);
1155 auto classesOut = model->addOperand(&type7);
1156 auto batchSplitOut = model->addOperand(&type7);
1157 auto in = model->addOperand(&type12);
1158 auto param7 = model->addOperand(&type3);
1159 auto param8 = model->addOperand(&type3);
1160 auto param9 = model->addOperand(&type10);
1161 auto param10 = model->addOperand(&type10);
1162 auto param11 = model->addOperand(&type3);
1163 auto param12 = model->addOperand(&type3);
1164 auto layout = model->addOperand(&type11);
1165 auto featureMap = model->addOperand(&type13);
1166 auto weights = model->addOperand(&type14);
1167 auto bias = model->addOperand(&type2);
1168 auto param13 = model->addOperand(&type3);
1169 auto out = model->addOperand(&type23);
1170 // Phase 2, operations
1171 static float scores_init[] = {0.9f, 0.1f};
1172 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
1173 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1174 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
1175 static int32_t param_init[] = {0};
1176 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1177 static float param1_init[] = {0.3f};
1178 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
1179 static int32_t param2_init[] = {-1};
1180 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1181 static int32_t param3_init[] = {0};
1182 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1183 static float param4_init[] = {0.4f};
1184 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
1185 static float param5_init[] = {1.0f};
1186 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
1187 static float param6_init[] = {0.3f};
1188 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
1189 static int32_t param7_init[] = {2};
1190 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1191 static int32_t param8_init[] = {2};
1192 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1193 static float param9_init[] = {2.0f};
1194 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1195 static float param10_init[] = {2.0f};
1196 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1197 static int32_t param11_init[] = {4};
1198 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1199 static int32_t param12_init[] = {4};
1200 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1201 static bool8 layout_init[] = {false};
1202 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1203 static float weights_init[] = {1.0f, 2.0f, 3.0f};
1204 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
1205 static float bias_init[] = {1.0f};
1206 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
1207 static int32_t param13_init[] = {0};
1208 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1209 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1210 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1211 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1212 // Phase 3, inputs and outputs
1213 model->identifyInputsAndOutputs(
1214 {in},
1215 {scoresOut, classesOut, out});
1216 // Phase 4: set relaxed execution
1217 model->relaxComputationFloat32toFloat16(true);
1218 assert(model->isValid());
1219 }
1220
is_ignored_zero_sized_dynamic_output_shape_nhwc_relaxed(int i)1221 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc_relaxed(int i) {
1222 static std::set<int> ignore = {};
1223 return ignore.find(i) != ignore.end();
1224 }
1225
CreateModel_zero_sized_dynamic_output_shape_nhwc_quant8(Model * model)1226 void CreateModel_zero_sized_dynamic_output_shape_nhwc_quant8(Model *model) {
1227 OperandType type10(Type::FLOAT32, {});
1228 OperandType type11(Type::BOOL, {});
1229 OperandType type25(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.1f, 128);
1230 OperandType type26(Type::TENSOR_INT32, {1}, 0.01f, 0);
1231 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 3}, 0.1f, 128);
1232 OperandType type28(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 3}, 0.1f, 128);
1233 OperandType type3(Type::INT32, {});
1234 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
1235 OperandType type31(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
1236 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
1237 OperandType type33(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
1238 OperandType type34(Type::TENSOR_QUANT8_ASYMM, {1, 3}, 0.1f, 128);
1239 OperandType type7(Type::TENSOR_INT32, {0});
1240 OperandType type9(Type::TENSOR_INT32, {1});
1241 // Phase 1, operands
1242 auto scores = model->addOperand(&type32);
1243 auto roi = model->addOperand(&type30);
1244 auto param = model->addOperand(&type9);
1245 auto param1 = model->addOperand(&type10);
1246 auto param2 = model->addOperand(&type3);
1247 auto param3 = model->addOperand(&type3);
1248 auto param4 = model->addOperand(&type10);
1249 auto param5 = model->addOperand(&type10);
1250 auto param6 = model->addOperand(&type10);
1251 auto scoresOut = model->addOperand(&type33);
1252 auto roiOut = model->addOperand(&type31);
1253 auto classesOut = model->addOperand(&type7);
1254 auto batchSplitOut = model->addOperand(&type7);
1255 auto in = model->addOperand(&type28);
1256 auto param7 = model->addOperand(&type3);
1257 auto param8 = model->addOperand(&type3);
1258 auto param9 = model->addOperand(&type10);
1259 auto param10 = model->addOperand(&type10);
1260 auto param11 = model->addOperand(&type3);
1261 auto param12 = model->addOperand(&type3);
1262 auto layout = model->addOperand(&type11);
1263 auto featureMap = model->addOperand(&type27);
1264 auto weights = model->addOperand(&type34);
1265 auto bias = model->addOperand(&type26);
1266 auto param13 = model->addOperand(&type3);
1267 auto out = model->addOperand(&type25);
1268 // Phase 2, operations
1269 static uint8_t scores_init[] = {137, 129};
1270 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
1271 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
1272 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
1273 static int32_t param_init[] = {0};
1274 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1275 static float param1_init[] = {0.3f};
1276 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
1277 static int32_t param2_init[] = {-1};
1278 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1279 static int32_t param3_init[] = {0};
1280 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1281 static float param4_init[] = {0.4f};
1282 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
1283 static float param5_init[] = {1.0f};
1284 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
1285 static float param6_init[] = {0.3f};
1286 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
1287 static int32_t param7_init[] = {2};
1288 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1289 static int32_t param8_init[] = {2};
1290 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1291 static float param9_init[] = {2.0f};
1292 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1293 static float param10_init[] = {2.0f};
1294 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1295 static int32_t param11_init[] = {4};
1296 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1297 static int32_t param12_init[] = {4};
1298 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1299 static bool8 layout_init[] = {false};
1300 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1301 static uint8_t weights_init[] = {138, 148, 158};
1302 model->setOperandValue(weights, weights_init, sizeof(uint8_t) * 3);
1303 static int32_t bias_init[] = {100};
1304 model->setOperandValue(bias, bias_init, sizeof(int32_t) * 1);
1305 static int32_t param13_init[] = {0};
1306 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1307 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1308 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1309 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1310 // Phase 3, inputs and outputs
1311 model->identifyInputsAndOutputs(
1312 {in},
1313 {scoresOut, classesOut, out});
1314 assert(model->isValid());
1315 }
1316
is_ignored_zero_sized_dynamic_output_shape_nhwc_quant8(int i)1317 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc_quant8(int i) {
1318 static std::set<int> ignore = {};
1319 return ignore.find(i) != ignore.end();
1320 }
1321
CreateModel_zero_sized_dynamic_output_shape_nhwc_float16(Model * model)1322 void CreateModel_zero_sized_dynamic_output_shape_nhwc_float16(Model *model) {
1323 OperandType type11(Type::BOOL, {});
1324 OperandType type16(Type::TENSOR_FLOAT16, {1});
1325 OperandType type24(Type::TENSOR_FLOAT16, {0, 0});
1326 OperandType type3(Type::INT32, {});
1327 OperandType type35(Type::TENSOR_FLOAT16, {0, 2, 2, 3});
1328 OperandType type36(Type::TENSOR_FLOAT16, {1, 1, 1, 3});
1329 OperandType type38(Type::FLOAT16, {});
1330 OperandType type39(Type::TENSOR_FLOAT16, {1, 8});
1331 OperandType type40(Type::TENSOR_FLOAT16, {0, 4});
1332 OperandType type41(Type::TENSOR_FLOAT16, {1, 2});
1333 OperandType type43(Type::TENSOR_FLOAT16, {1, 3});
1334 OperandType type50(Type::TENSOR_FLOAT16, {0});
1335 OperandType type7(Type::TENSOR_INT32, {0});
1336 OperandType type9(Type::TENSOR_INT32, {1});
1337 // Phase 1, operands
1338 auto scores = model->addOperand(&type41);
1339 auto roi = model->addOperand(&type39);
1340 auto param = model->addOperand(&type9);
1341 auto param1 = model->addOperand(&type38);
1342 auto param2 = model->addOperand(&type3);
1343 auto param3 = model->addOperand(&type3);
1344 auto param4 = model->addOperand(&type38);
1345 auto param5 = model->addOperand(&type38);
1346 auto param6 = model->addOperand(&type38);
1347 auto scoresOut = model->addOperand(&type50);
1348 auto roiOut = model->addOperand(&type40);
1349 auto classesOut = model->addOperand(&type7);
1350 auto batchSplitOut = model->addOperand(&type7);
1351 auto in = model->addOperand(&type36);
1352 auto param7 = model->addOperand(&type3);
1353 auto param8 = model->addOperand(&type3);
1354 auto param9 = model->addOperand(&type38);
1355 auto param10 = model->addOperand(&type38);
1356 auto param11 = model->addOperand(&type3);
1357 auto param12 = model->addOperand(&type3);
1358 auto layout = model->addOperand(&type11);
1359 auto featureMap = model->addOperand(&type35);
1360 auto weights = model->addOperand(&type43);
1361 auto bias = model->addOperand(&type16);
1362 auto param13 = model->addOperand(&type3);
1363 auto out = model->addOperand(&type24);
1364 // Phase 2, operations
1365 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
1366 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
1367 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1368 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
1369 static int32_t param_init[] = {0};
1370 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1371 static _Float16 param1_init[] = {0.30000001192092896f};
1372 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
1373 static int32_t param2_init[] = {-1};
1374 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1375 static int32_t param3_init[] = {0};
1376 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1377 static _Float16 param4_init[] = {0.4000000059604645f};
1378 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
1379 static _Float16 param5_init[] = {1.0f};
1380 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
1381 static _Float16 param6_init[] = {0.30000001192092896f};
1382 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
1383 static int32_t param7_init[] = {2};
1384 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1385 static int32_t param8_init[] = {2};
1386 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1387 static _Float16 param9_init[] = {2.0f};
1388 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
1389 static _Float16 param10_init[] = {2.0f};
1390 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
1391 static int32_t param11_init[] = {4};
1392 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1393 static int32_t param12_init[] = {4};
1394 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1395 static bool8 layout_init[] = {false};
1396 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1397 static _Float16 weights_init[] = {1.0f, 2.0f, 3.0f};
1398 model->setOperandValue(weights, weights_init, sizeof(_Float16) * 3);
1399 static _Float16 bias_init[] = {1.0f};
1400 model->setOperandValue(bias, bias_init, sizeof(_Float16) * 1);
1401 static int32_t param13_init[] = {0};
1402 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1403 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1404 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1405 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1406 // Phase 3, inputs and outputs
1407 model->identifyInputsAndOutputs(
1408 {in},
1409 {scoresOut, classesOut, out});
1410 assert(model->isValid());
1411 }
1412
is_ignored_zero_sized_dynamic_output_shape_nhwc_float16(int i)1413 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc_float16(int i) {
1414 static std::set<int> ignore = {};
1415 return ignore.find(i) != ignore.end();
1416 }
1417
CreateModel_zero_sized_dynamic_output_shape_nchw(Model * model)1418 void CreateModel_zero_sized_dynamic_output_shape_nchw(Model *model) {
1419 OperandType type10(Type::FLOAT32, {});
1420 OperandType type11(Type::BOOL, {});
1421 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
1422 OperandType type2(Type::TENSOR_FLOAT32, {1});
1423 OperandType type23(Type::TENSOR_FLOAT32, {0, 0});
1424 OperandType type3(Type::INT32, {});
1425 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
1426 OperandType type44(Type::TENSOR_FLOAT32, {0, 3, 2, 2});
1427 OperandType type45(Type::TENSOR_FLOAT32, {1, 3, 1, 1});
1428 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
1429 OperandType type6(Type::TENSOR_FLOAT32, {0});
1430 OperandType type7(Type::TENSOR_INT32, {0});
1431 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
1432 OperandType type9(Type::TENSOR_INT32, {1});
1433 // Phase 1, operands
1434 auto scores = model->addOperand(&type4);
1435 auto roi = model->addOperand(&type5);
1436 auto param = model->addOperand(&type9);
1437 auto param1 = model->addOperand(&type10);
1438 auto param2 = model->addOperand(&type3);
1439 auto param3 = model->addOperand(&type3);
1440 auto param4 = model->addOperand(&type10);
1441 auto param5 = model->addOperand(&type10);
1442 auto param6 = model->addOperand(&type10);
1443 auto scoresOut = model->addOperand(&type6);
1444 auto roiOut = model->addOperand(&type8);
1445 auto classesOut = model->addOperand(&type7);
1446 auto batchSplitOut = model->addOperand(&type7);
1447 auto in = model->addOperand(&type45);
1448 auto param7 = model->addOperand(&type3);
1449 auto param8 = model->addOperand(&type3);
1450 auto param9 = model->addOperand(&type10);
1451 auto param10 = model->addOperand(&type10);
1452 auto param11 = model->addOperand(&type3);
1453 auto param12 = model->addOperand(&type3);
1454 auto layout = model->addOperand(&type11);
1455 auto featureMap = model->addOperand(&type44);
1456 auto weights = model->addOperand(&type14);
1457 auto bias = model->addOperand(&type2);
1458 auto param13 = model->addOperand(&type3);
1459 auto out = model->addOperand(&type23);
1460 // Phase 2, operations
1461 static float scores_init[] = {0.9f, 0.1f};
1462 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
1463 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1464 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
1465 static int32_t param_init[] = {0};
1466 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1467 static float param1_init[] = {0.3f};
1468 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
1469 static int32_t param2_init[] = {-1};
1470 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1471 static int32_t param3_init[] = {0};
1472 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1473 static float param4_init[] = {0.4f};
1474 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
1475 static float param5_init[] = {1.0f};
1476 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
1477 static float param6_init[] = {0.3f};
1478 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
1479 static int32_t param7_init[] = {2};
1480 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1481 static int32_t param8_init[] = {2};
1482 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1483 static float param9_init[] = {2.0f};
1484 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1485 static float param10_init[] = {2.0f};
1486 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1487 static int32_t param11_init[] = {4};
1488 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1489 static int32_t param12_init[] = {4};
1490 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1491 static bool8 layout_init[] = {true};
1492 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1493 static float weights_init[] = {1.0f, 2.0f, 3.0f};
1494 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
1495 static float bias_init[] = {1.0f};
1496 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
1497 static int32_t param13_init[] = {0};
1498 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1499 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1500 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1501 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1502 // Phase 3, inputs and outputs
1503 model->identifyInputsAndOutputs(
1504 {in},
1505 {scoresOut, classesOut, out});
1506 assert(model->isValid());
1507 }
1508
is_ignored_zero_sized_dynamic_output_shape_nchw(int i)1509 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw(int i) {
1510 static std::set<int> ignore = {};
1511 return ignore.find(i) != ignore.end();
1512 }
1513
CreateModel_zero_sized_dynamic_output_shape_nchw_relaxed(Model * model)1514 void CreateModel_zero_sized_dynamic_output_shape_nchw_relaxed(Model *model) {
1515 OperandType type10(Type::FLOAT32, {});
1516 OperandType type11(Type::BOOL, {});
1517 OperandType type14(Type::TENSOR_FLOAT32, {1, 3});
1518 OperandType type2(Type::TENSOR_FLOAT32, {1});
1519 OperandType type23(Type::TENSOR_FLOAT32, {0, 0});
1520 OperandType type3(Type::INT32, {});
1521 OperandType type4(Type::TENSOR_FLOAT32, {1, 2});
1522 OperandType type44(Type::TENSOR_FLOAT32, {0, 3, 2, 2});
1523 OperandType type45(Type::TENSOR_FLOAT32, {1, 3, 1, 1});
1524 OperandType type5(Type::TENSOR_FLOAT32, {1, 8});
1525 OperandType type6(Type::TENSOR_FLOAT32, {0});
1526 OperandType type7(Type::TENSOR_INT32, {0});
1527 OperandType type8(Type::TENSOR_FLOAT32, {0, 4});
1528 OperandType type9(Type::TENSOR_INT32, {1});
1529 // Phase 1, operands
1530 auto scores = model->addOperand(&type4);
1531 auto roi = model->addOperand(&type5);
1532 auto param = model->addOperand(&type9);
1533 auto param1 = model->addOperand(&type10);
1534 auto param2 = model->addOperand(&type3);
1535 auto param3 = model->addOperand(&type3);
1536 auto param4 = model->addOperand(&type10);
1537 auto param5 = model->addOperand(&type10);
1538 auto param6 = model->addOperand(&type10);
1539 auto scoresOut = model->addOperand(&type6);
1540 auto roiOut = model->addOperand(&type8);
1541 auto classesOut = model->addOperand(&type7);
1542 auto batchSplitOut = model->addOperand(&type7);
1543 auto in = model->addOperand(&type45);
1544 auto param7 = model->addOperand(&type3);
1545 auto param8 = model->addOperand(&type3);
1546 auto param9 = model->addOperand(&type10);
1547 auto param10 = model->addOperand(&type10);
1548 auto param11 = model->addOperand(&type3);
1549 auto param12 = model->addOperand(&type3);
1550 auto layout = model->addOperand(&type11);
1551 auto featureMap = model->addOperand(&type44);
1552 auto weights = model->addOperand(&type14);
1553 auto bias = model->addOperand(&type2);
1554 auto param13 = model->addOperand(&type3);
1555 auto out = model->addOperand(&type23);
1556 // Phase 2, operations
1557 static float scores_init[] = {0.9f, 0.1f};
1558 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
1559 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1560 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
1561 static int32_t param_init[] = {0};
1562 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1563 static float param1_init[] = {0.3f};
1564 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
1565 static int32_t param2_init[] = {-1};
1566 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1567 static int32_t param3_init[] = {0};
1568 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1569 static float param4_init[] = {0.4f};
1570 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
1571 static float param5_init[] = {1.0f};
1572 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
1573 static float param6_init[] = {0.3f};
1574 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
1575 static int32_t param7_init[] = {2};
1576 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1577 static int32_t param8_init[] = {2};
1578 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1579 static float param9_init[] = {2.0f};
1580 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1581 static float param10_init[] = {2.0f};
1582 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1583 static int32_t param11_init[] = {4};
1584 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1585 static int32_t param12_init[] = {4};
1586 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1587 static bool8 layout_init[] = {true};
1588 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1589 static float weights_init[] = {1.0f, 2.0f, 3.0f};
1590 model->setOperandValue(weights, weights_init, sizeof(float) * 3);
1591 static float bias_init[] = {1.0f};
1592 model->setOperandValue(bias, bias_init, sizeof(float) * 1);
1593 static int32_t param13_init[] = {0};
1594 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1595 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1596 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1597 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1598 // Phase 3, inputs and outputs
1599 model->identifyInputsAndOutputs(
1600 {in},
1601 {scoresOut, classesOut, out});
1602 // Phase 4: set relaxed execution
1603 model->relaxComputationFloat32toFloat16(true);
1604 assert(model->isValid());
1605 }
1606
is_ignored_zero_sized_dynamic_output_shape_nchw_relaxed(int i)1607 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw_relaxed(int i) {
1608 static std::set<int> ignore = {};
1609 return ignore.find(i) != ignore.end();
1610 }
1611
CreateModel_zero_sized_dynamic_output_shape_nchw_quant8(Model * model)1612 void CreateModel_zero_sized_dynamic_output_shape_nchw_quant8(Model *model) {
1613 OperandType type10(Type::FLOAT32, {});
1614 OperandType type11(Type::BOOL, {});
1615 OperandType type25(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.1f, 128);
1616 OperandType type26(Type::TENSOR_INT32, {1}, 0.01f, 0);
1617 OperandType type3(Type::INT32, {});
1618 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
1619 OperandType type31(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
1620 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
1621 OperandType type33(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
1622 OperandType type34(Type::TENSOR_QUANT8_ASYMM, {1, 3}, 0.1f, 128);
1623 OperandType type46(Type::TENSOR_QUANT8_ASYMM, {0, 3, 2, 2}, 0.1f, 128);
1624 OperandType type47(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 1}, 0.1f, 128);
1625 OperandType type7(Type::TENSOR_INT32, {0});
1626 OperandType type9(Type::TENSOR_INT32, {1});
1627 // Phase 1, operands
1628 auto scores = model->addOperand(&type32);
1629 auto roi = model->addOperand(&type30);
1630 auto param = model->addOperand(&type9);
1631 auto param1 = model->addOperand(&type10);
1632 auto param2 = model->addOperand(&type3);
1633 auto param3 = model->addOperand(&type3);
1634 auto param4 = model->addOperand(&type10);
1635 auto param5 = model->addOperand(&type10);
1636 auto param6 = model->addOperand(&type10);
1637 auto scoresOut = model->addOperand(&type33);
1638 auto roiOut = model->addOperand(&type31);
1639 auto classesOut = model->addOperand(&type7);
1640 auto batchSplitOut = model->addOperand(&type7);
1641 auto in = model->addOperand(&type47);
1642 auto param7 = model->addOperand(&type3);
1643 auto param8 = model->addOperand(&type3);
1644 auto param9 = model->addOperand(&type10);
1645 auto param10 = model->addOperand(&type10);
1646 auto param11 = model->addOperand(&type3);
1647 auto param12 = model->addOperand(&type3);
1648 auto layout = model->addOperand(&type11);
1649 auto featureMap = model->addOperand(&type46);
1650 auto weights = model->addOperand(&type34);
1651 auto bias = model->addOperand(&type26);
1652 auto param13 = model->addOperand(&type3);
1653 auto out = model->addOperand(&type25);
1654 // Phase 2, operations
1655 static uint8_t scores_init[] = {137, 129};
1656 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
1657 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
1658 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
1659 static int32_t param_init[] = {0};
1660 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1661 static float param1_init[] = {0.3f};
1662 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
1663 static int32_t param2_init[] = {-1};
1664 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1665 static int32_t param3_init[] = {0};
1666 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1667 static float param4_init[] = {0.4f};
1668 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
1669 static float param5_init[] = {1.0f};
1670 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
1671 static float param6_init[] = {0.3f};
1672 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
1673 static int32_t param7_init[] = {2};
1674 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1675 static int32_t param8_init[] = {2};
1676 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1677 static float param9_init[] = {2.0f};
1678 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1679 static float param10_init[] = {2.0f};
1680 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1681 static int32_t param11_init[] = {4};
1682 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1683 static int32_t param12_init[] = {4};
1684 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1685 static bool8 layout_init[] = {true};
1686 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1687 static uint8_t weights_init[] = {138, 148, 158};
1688 model->setOperandValue(weights, weights_init, sizeof(uint8_t) * 3);
1689 static int32_t bias_init[] = {100};
1690 model->setOperandValue(bias, bias_init, sizeof(int32_t) * 1);
1691 static int32_t param13_init[] = {0};
1692 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1693 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1694 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1695 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1696 // Phase 3, inputs and outputs
1697 model->identifyInputsAndOutputs(
1698 {in},
1699 {scoresOut, classesOut, out});
1700 assert(model->isValid());
1701 }
1702
is_ignored_zero_sized_dynamic_output_shape_nchw_quant8(int i)1703 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw_quant8(int i) {
1704 static std::set<int> ignore = {};
1705 return ignore.find(i) != ignore.end();
1706 }
1707
CreateModel_zero_sized_dynamic_output_shape_nchw_float16(Model * model)1708 void CreateModel_zero_sized_dynamic_output_shape_nchw_float16(Model *model) {
1709 OperandType type11(Type::BOOL, {});
1710 OperandType type16(Type::TENSOR_FLOAT16, {1});
1711 OperandType type24(Type::TENSOR_FLOAT16, {0, 0});
1712 OperandType type3(Type::INT32, {});
1713 OperandType type38(Type::FLOAT16, {});
1714 OperandType type39(Type::TENSOR_FLOAT16, {1, 8});
1715 OperandType type40(Type::TENSOR_FLOAT16, {0, 4});
1716 OperandType type41(Type::TENSOR_FLOAT16, {1, 2});
1717 OperandType type43(Type::TENSOR_FLOAT16, {1, 3});
1718 OperandType type48(Type::TENSOR_FLOAT16, {0, 3, 2, 2});
1719 OperandType type49(Type::TENSOR_FLOAT16, {1, 3, 1, 1});
1720 OperandType type50(Type::TENSOR_FLOAT16, {0});
1721 OperandType type7(Type::TENSOR_INT32, {0});
1722 OperandType type9(Type::TENSOR_INT32, {1});
1723 // Phase 1, operands
1724 auto scores = model->addOperand(&type41);
1725 auto roi = model->addOperand(&type39);
1726 auto param = model->addOperand(&type9);
1727 auto param1 = model->addOperand(&type38);
1728 auto param2 = model->addOperand(&type3);
1729 auto param3 = model->addOperand(&type3);
1730 auto param4 = model->addOperand(&type38);
1731 auto param5 = model->addOperand(&type38);
1732 auto param6 = model->addOperand(&type38);
1733 auto scoresOut = model->addOperand(&type50);
1734 auto roiOut = model->addOperand(&type40);
1735 auto classesOut = model->addOperand(&type7);
1736 auto batchSplitOut = model->addOperand(&type7);
1737 auto in = model->addOperand(&type49);
1738 auto param7 = model->addOperand(&type3);
1739 auto param8 = model->addOperand(&type3);
1740 auto param9 = model->addOperand(&type38);
1741 auto param10 = model->addOperand(&type38);
1742 auto param11 = model->addOperand(&type3);
1743 auto param12 = model->addOperand(&type3);
1744 auto layout = model->addOperand(&type11);
1745 auto featureMap = model->addOperand(&type48);
1746 auto weights = model->addOperand(&type43);
1747 auto bias = model->addOperand(&type16);
1748 auto param13 = model->addOperand(&type3);
1749 auto out = model->addOperand(&type24);
1750 // Phase 2, operations
1751 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
1752 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
1753 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
1754 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
1755 static int32_t param_init[] = {0};
1756 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1757 static _Float16 param1_init[] = {0.30000001192092896f};
1758 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
1759 static int32_t param2_init[] = {-1};
1760 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
1761 static int32_t param3_init[] = {0};
1762 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
1763 static _Float16 param4_init[] = {0.4000000059604645f};
1764 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
1765 static _Float16 param5_init[] = {1.0f};
1766 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
1767 static _Float16 param6_init[] = {0.30000001192092896f};
1768 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
1769 static int32_t param7_init[] = {2};
1770 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1771 static int32_t param8_init[] = {2};
1772 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1773 static _Float16 param9_init[] = {2.0f};
1774 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
1775 static _Float16 param10_init[] = {2.0f};
1776 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
1777 static int32_t param11_init[] = {4};
1778 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1779 static int32_t param12_init[] = {4};
1780 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1781 static bool8 layout_init[] = {true};
1782 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1783 static _Float16 weights_init[] = {1.0f, 2.0f, 3.0f};
1784 model->setOperandValue(weights, weights_init, sizeof(_Float16) * 3);
1785 static _Float16 bias_init[] = {1.0f};
1786 model->setOperandValue(bias, bias_init, sizeof(_Float16) * 1);
1787 static int32_t param13_init[] = {0};
1788 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1789 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
1790 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
1791 model->addOperation(ANEURALNETWORKS_FULLY_CONNECTED, {featureMap, weights, bias, param13}, {out});
1792 // Phase 3, inputs and outputs
1793 model->identifyInputsAndOutputs(
1794 {in},
1795 {scoresOut, classesOut, out});
1796 assert(model->isValid());
1797 }
1798
is_ignored_zero_sized_dynamic_output_shape_nchw_float16(int i)1799 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw_float16(int i) {
1800 static std::set<int> ignore = {};
1801 return ignore.find(i) != ignore.end();
1802 }
1803
1804