• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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