1 // clang-format off
2 // Generated file (from: transpose_v1_2.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4   OperandType type0(Type::TENSOR_FLOAT32, {2, 2});
5   OperandType type1(Type::TENSOR_INT32, {0});
6   // Phase 1, operands
7   auto input = model->addOperand(&type0);
8   auto perms = model->addOperand(&type1);
9   auto output = model->addOperand(&type0);
10   // Phase 2, operations
11   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {input, perms}, {output});
12   // Phase 3, inputs and outputs
13   model->identifyInputsAndOutputs(
14     {input, perms},
15     {output});
16   assert(model->isValid());
17 }
18 
is_ignored(int i)19 inline bool is_ignored(int i) {
20   static std::set<int> ignore = {};
21   return ignore.find(i) != ignore.end();
22 }
23 
CreateModel_relaxed(Model * model)24 void CreateModel_relaxed(Model *model) {
25   OperandType type0(Type::TENSOR_FLOAT32, {2, 2});
26   OperandType type1(Type::TENSOR_INT32, {0});
27   // Phase 1, operands
28   auto input = model->addOperand(&type0);
29   auto perms = model->addOperand(&type1);
30   auto output = model->addOperand(&type0);
31   // Phase 2, operations
32   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {input, perms}, {output});
33   // Phase 3, inputs and outputs
34   model->identifyInputsAndOutputs(
35     {input, perms},
36     {output});
37   // Phase 4: set relaxed execution
38   model->relaxComputationFloat32toFloat16(true);
39   assert(model->isValid());
40 }
41 
is_ignored_relaxed(int i)42 inline bool is_ignored_relaxed(int i) {
43   static std::set<int> ignore = {};
44   return ignore.find(i) != ignore.end();
45 }
46 
CreateModel_quant8(Model * model)47 void CreateModel_quant8(Model *model) {
48   OperandType type1(Type::TENSOR_INT32, {0});
49   OperandType type14(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 0.5f, 0);
50   // Phase 1, operands
51   auto input = model->addOperand(&type14);
52   auto perms = model->addOperand(&type1);
53   auto output = model->addOperand(&type14);
54   // Phase 2, operations
55   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {input, perms}, {output});
56   // Phase 3, inputs and outputs
57   model->identifyInputsAndOutputs(
58     {input, perms},
59     {output});
60   assert(model->isValid());
61 }
62 
is_ignored_quant8(int i)63 inline bool is_ignored_quant8(int i) {
64   static std::set<int> ignore = {};
65   return ignore.find(i) != ignore.end();
66 }
67 
CreateModel_dynamic_output_shape(Model * model)68 void CreateModel_dynamic_output_shape(Model *model) {
69   OperandType type0(Type::TENSOR_FLOAT32, {2, 2});
70   OperandType type1(Type::TENSOR_INT32, {0});
71   OperandType type15(Type::TENSOR_FLOAT32, {0, 0});
72   // Phase 1, operands
73   auto input = model->addOperand(&type0);
74   auto perms = model->addOperand(&type1);
75   auto output = model->addOperand(&type15);
76   // Phase 2, operations
77   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {input, perms}, {output});
78   // Phase 3, inputs and outputs
79   model->identifyInputsAndOutputs(
80     {input, perms},
81     {output});
82   assert(model->isValid());
83 }
84 
is_ignored_dynamic_output_shape(int i)85 inline bool is_ignored_dynamic_output_shape(int i) {
86   static std::set<int> ignore = {};
87   return ignore.find(i) != ignore.end();
88 }
89 
CreateModel_dynamic_output_shape_relaxed(Model * model)90 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
91   OperandType type0(Type::TENSOR_FLOAT32, {2, 2});
92   OperandType type1(Type::TENSOR_INT32, {0});
93   OperandType type15(Type::TENSOR_FLOAT32, {0, 0});
94   // Phase 1, operands
95   auto input = model->addOperand(&type0);
96   auto perms = model->addOperand(&type1);
97   auto output = model->addOperand(&type15);
98   // Phase 2, operations
99   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {input, perms}, {output});
100   // Phase 3, inputs and outputs
101   model->identifyInputsAndOutputs(
102     {input, perms},
103     {output});
104   // Phase 4: set relaxed execution
105   model->relaxComputationFloat32toFloat16(true);
106   assert(model->isValid());
107 }
108 
is_ignored_dynamic_output_shape_relaxed(int i)109 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
110   static std::set<int> ignore = {};
111   return ignore.find(i) != ignore.end();
112 }
113 
CreateModel_dynamic_output_shape_quant8(Model * model)114 void CreateModel_dynamic_output_shape_quant8(Model *model) {
115   OperandType type1(Type::TENSOR_INT32, {0});
116   OperandType type14(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 0.5f, 0);
117   OperandType type16(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.5f, 0);
118   // Phase 1, operands
119   auto input = model->addOperand(&type14);
120   auto perms = model->addOperand(&type1);
121   auto output = model->addOperand(&type16);
122   // Phase 2, operations
123   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {input, perms}, {output});
124   // Phase 3, inputs and outputs
125   model->identifyInputsAndOutputs(
126     {input, perms},
127     {output});
128   assert(model->isValid());
129 }
130 
is_ignored_dynamic_output_shape_quant8(int i)131 inline bool is_ignored_dynamic_output_shape_quant8(int i) {
132   static std::set<int> ignore = {};
133   return ignore.find(i) != ignore.end();
134 }
135 
CreateModel_zero_sized(Model * model)136 void CreateModel_zero_sized(Model *model) {
137   OperandType type1(Type::TENSOR_INT32, {0});
138   OperandType type10(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
139   OperandType type11(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
140   OperandType type12(Type::TENSOR_FLOAT32, {0, 1, 2, 2});
141   OperandType type13(Type::TENSOR_INT32, {4});
142   OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
143   OperandType type3(Type::TENSOR_FLOAT32, {1, 8});
144   OperandType type4(Type::TENSOR_FLOAT32, {0});
145   OperandType type5(Type::TENSOR_FLOAT32, {0, 4});
146   OperandType type6(Type::TENSOR_INT32, {1});
147   OperandType type7(Type::FLOAT32, {});
148   OperandType type8(Type::INT32, {});
149   OperandType type9(Type::BOOL, {});
150   // Phase 1, operands
151   auto scores = model->addOperand(&type2);
152   auto roi = model->addOperand(&type3);
153   auto param = model->addOperand(&type6);
154   auto param1 = model->addOperand(&type7);
155   auto param2 = model->addOperand(&type8);
156   auto param3 = model->addOperand(&type8);
157   auto param4 = model->addOperand(&type7);
158   auto param5 = model->addOperand(&type7);
159   auto param6 = model->addOperand(&type7);
160   auto scoresOut = model->addOperand(&type4);
161   auto roiOut = model->addOperand(&type5);
162   auto classesOut = model->addOperand(&type1);
163   auto batchSplitOut = model->addOperand(&type1);
164   auto in = model->addOperand(&type10);
165   auto param7 = model->addOperand(&type8);
166   auto param8 = model->addOperand(&type8);
167   auto param9 = model->addOperand(&type7);
168   auto param10 = model->addOperand(&type7);
169   auto param11 = model->addOperand(&type8);
170   auto param12 = model->addOperand(&type8);
171   auto layout = model->addOperand(&type9);
172   auto featureMap = model->addOperand(&type11);
173   auto param13 = model->addOperand(&type13);
174   auto out = model->addOperand(&type12);
175   // Phase 2, operations
176   static float scores_init[] = {0.9f, 0.1f};
177   model->setOperandValue(scores, scores_init, sizeof(float) * 2);
178   static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
179   model->setOperandValue(roi, roi_init, sizeof(float) * 8);
180   static int32_t param_init[] = {0};
181   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
182   static float param1_init[] = {0.3f};
183   model->setOperandValue(param1, param1_init, sizeof(float) * 1);
184   static int32_t param2_init[] = {-1};
185   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
186   static int32_t param3_init[] = {0};
187   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
188   static float param4_init[] = {0.4f};
189   model->setOperandValue(param4, param4_init, sizeof(float) * 1);
190   static float param5_init[] = {1.0f};
191   model->setOperandValue(param5, param5_init, sizeof(float) * 1);
192   static float param6_init[] = {0.3f};
193   model->setOperandValue(param6, param6_init, sizeof(float) * 1);
194   static int32_t param7_init[] = {2};
195   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
196   static int32_t param8_init[] = {2};
197   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
198   static float param9_init[] = {2.0f};
199   model->setOperandValue(param9, param9_init, sizeof(float) * 1);
200   static float param10_init[] = {2.0f};
201   model->setOperandValue(param10, param10_init, sizeof(float) * 1);
202   static int32_t param11_init[] = {4};
203   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
204   static int32_t param12_init[] = {4};
205   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
206   static bool8 layout_init[] = {false};
207   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
208   static int32_t param13_init[] = {0, 3, 1, 2};
209   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
210   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
211   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
212   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
213   // Phase 3, inputs and outputs
214   model->identifyInputsAndOutputs(
215     {in},
216     {scoresOut, classesOut, out});
217   assert(model->isValid());
218 }
219 
is_ignored_zero_sized(int i)220 inline bool is_ignored_zero_sized(int i) {
221   static std::set<int> ignore = {};
222   return ignore.find(i) != ignore.end();
223 }
224 
CreateModel_zero_sized_relaxed(Model * model)225 void CreateModel_zero_sized_relaxed(Model *model) {
226   OperandType type1(Type::TENSOR_INT32, {0});
227   OperandType type10(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
228   OperandType type11(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
229   OperandType type12(Type::TENSOR_FLOAT32, {0, 1, 2, 2});
230   OperandType type13(Type::TENSOR_INT32, {4});
231   OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
232   OperandType type3(Type::TENSOR_FLOAT32, {1, 8});
233   OperandType type4(Type::TENSOR_FLOAT32, {0});
234   OperandType type5(Type::TENSOR_FLOAT32, {0, 4});
235   OperandType type6(Type::TENSOR_INT32, {1});
236   OperandType type7(Type::FLOAT32, {});
237   OperandType type8(Type::INT32, {});
238   OperandType type9(Type::BOOL, {});
239   // Phase 1, operands
240   auto scores = model->addOperand(&type2);
241   auto roi = model->addOperand(&type3);
242   auto param = model->addOperand(&type6);
243   auto param1 = model->addOperand(&type7);
244   auto param2 = model->addOperand(&type8);
245   auto param3 = model->addOperand(&type8);
246   auto param4 = model->addOperand(&type7);
247   auto param5 = model->addOperand(&type7);
248   auto param6 = model->addOperand(&type7);
249   auto scoresOut = model->addOperand(&type4);
250   auto roiOut = model->addOperand(&type5);
251   auto classesOut = model->addOperand(&type1);
252   auto batchSplitOut = model->addOperand(&type1);
253   auto in = model->addOperand(&type10);
254   auto param7 = model->addOperand(&type8);
255   auto param8 = model->addOperand(&type8);
256   auto param9 = model->addOperand(&type7);
257   auto param10 = model->addOperand(&type7);
258   auto param11 = model->addOperand(&type8);
259   auto param12 = model->addOperand(&type8);
260   auto layout = model->addOperand(&type9);
261   auto featureMap = model->addOperand(&type11);
262   auto param13 = model->addOperand(&type13);
263   auto out = model->addOperand(&type12);
264   // Phase 2, operations
265   static float scores_init[] = {0.9f, 0.1f};
266   model->setOperandValue(scores, scores_init, sizeof(float) * 2);
267   static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
268   model->setOperandValue(roi, roi_init, sizeof(float) * 8);
269   static int32_t param_init[] = {0};
270   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
271   static float param1_init[] = {0.3f};
272   model->setOperandValue(param1, param1_init, sizeof(float) * 1);
273   static int32_t param2_init[] = {-1};
274   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
275   static int32_t param3_init[] = {0};
276   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
277   static float param4_init[] = {0.4f};
278   model->setOperandValue(param4, param4_init, sizeof(float) * 1);
279   static float param5_init[] = {1.0f};
280   model->setOperandValue(param5, param5_init, sizeof(float) * 1);
281   static float param6_init[] = {0.3f};
282   model->setOperandValue(param6, param6_init, sizeof(float) * 1);
283   static int32_t param7_init[] = {2};
284   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
285   static int32_t param8_init[] = {2};
286   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
287   static float param9_init[] = {2.0f};
288   model->setOperandValue(param9, param9_init, sizeof(float) * 1);
289   static float param10_init[] = {2.0f};
290   model->setOperandValue(param10, param10_init, sizeof(float) * 1);
291   static int32_t param11_init[] = {4};
292   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
293   static int32_t param12_init[] = {4};
294   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
295   static bool8 layout_init[] = {false};
296   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
297   static int32_t param13_init[] = {0, 3, 1, 2};
298   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
299   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
300   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
301   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
302   // Phase 3, inputs and outputs
303   model->identifyInputsAndOutputs(
304     {in},
305     {scoresOut, classesOut, out});
306   // Phase 4: set relaxed execution
307   model->relaxComputationFloat32toFloat16(true);
308   assert(model->isValid());
309 }
310 
is_ignored_zero_sized_relaxed(int i)311 inline bool is_ignored_zero_sized_relaxed(int i) {
312   static std::set<int> ignore = {};
313   return ignore.find(i) != ignore.end();
314 }
315 
CreateModel_zero_sized_quant8(Model * model)316 void CreateModel_zero_sized_quant8(Model *model) {
317   OperandType type1(Type::TENSOR_INT32, {0});
318   OperandType type13(Type::TENSOR_INT32, {4});
319   OperandType type17(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
320   OperandType type18(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
321   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 1, 2, 2}, 0.1f, 128);
322   OperandType type20(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
323   OperandType type21(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
324   OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
325   OperandType type23(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
326   OperandType type6(Type::TENSOR_INT32, {1});
327   OperandType type7(Type::FLOAT32, {});
328   OperandType type8(Type::INT32, {});
329   OperandType type9(Type::BOOL, {});
330   // Phase 1, operands
331   auto scores = model->addOperand(&type22);
332   auto roi = model->addOperand(&type20);
333   auto param = model->addOperand(&type6);
334   auto param1 = model->addOperand(&type7);
335   auto param2 = model->addOperand(&type8);
336   auto param3 = model->addOperand(&type8);
337   auto param4 = model->addOperand(&type7);
338   auto param5 = model->addOperand(&type7);
339   auto param6 = model->addOperand(&type7);
340   auto scoresOut = model->addOperand(&type23);
341   auto roiOut = model->addOperand(&type21);
342   auto classesOut = model->addOperand(&type1);
343   auto batchSplitOut = model->addOperand(&type1);
344   auto in = model->addOperand(&type18);
345   auto param7 = model->addOperand(&type8);
346   auto param8 = model->addOperand(&type8);
347   auto param9 = model->addOperand(&type7);
348   auto param10 = model->addOperand(&type7);
349   auto param11 = model->addOperand(&type8);
350   auto param12 = model->addOperand(&type8);
351   auto layout = model->addOperand(&type9);
352   auto featureMap = model->addOperand(&type17);
353   auto param13 = model->addOperand(&type13);
354   auto out = model->addOperand(&type19);
355   // Phase 2, operations
356   static uint8_t scores_init[] = {137, 129};
357   model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
358   static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
359   model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
360   static int32_t param_init[] = {0};
361   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
362   static float param1_init[] = {0.3f};
363   model->setOperandValue(param1, param1_init, sizeof(float) * 1);
364   static int32_t param2_init[] = {-1};
365   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
366   static int32_t param3_init[] = {0};
367   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
368   static float param4_init[] = {0.4f};
369   model->setOperandValue(param4, param4_init, sizeof(float) * 1);
370   static float param5_init[] = {1.0f};
371   model->setOperandValue(param5, param5_init, sizeof(float) * 1);
372   static float param6_init[] = {0.3f};
373   model->setOperandValue(param6, param6_init, sizeof(float) * 1);
374   static int32_t param7_init[] = {2};
375   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
376   static int32_t param8_init[] = {2};
377   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
378   static float param9_init[] = {2.0f};
379   model->setOperandValue(param9, param9_init, sizeof(float) * 1);
380   static float param10_init[] = {2.0f};
381   model->setOperandValue(param10, param10_init, sizeof(float) * 1);
382   static int32_t param11_init[] = {4};
383   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
384   static int32_t param12_init[] = {4};
385   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
386   static bool8 layout_init[] = {false};
387   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
388   static int32_t param13_init[] = {0, 3, 1, 2};
389   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
390   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
391   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
392   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
393   // Phase 3, inputs and outputs
394   model->identifyInputsAndOutputs(
395     {in},
396     {scoresOut, classesOut, out});
397   assert(model->isValid());
398 }
399 
is_ignored_zero_sized_quant8(int i)400 inline bool is_ignored_zero_sized_quant8(int i) {
401   static std::set<int> ignore = {};
402   return ignore.find(i) != ignore.end();
403 }
404 
CreateModel_zero_sized_float16(Model * model)405 void CreateModel_zero_sized_float16(Model *model) {
406   OperandType type1(Type::TENSOR_INT32, {0});
407   OperandType type13(Type::TENSOR_INT32, {4});
408   OperandType type24(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
409   OperandType type25(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
410   OperandType type26(Type::TENSOR_FLOAT16, {0, 1, 2, 2});
411   OperandType type27(Type::FLOAT16, {});
412   OperandType type28(Type::TENSOR_FLOAT16, {1, 8});
413   OperandType type29(Type::TENSOR_FLOAT16, {0, 4});
414   OperandType type30(Type::TENSOR_FLOAT16, {1, 2});
415   OperandType type31(Type::TENSOR_FLOAT16, {0});
416   OperandType type6(Type::TENSOR_INT32, {1});
417   OperandType type8(Type::INT32, {});
418   OperandType type9(Type::BOOL, {});
419   // Phase 1, operands
420   auto scores = model->addOperand(&type30);
421   auto roi = model->addOperand(&type28);
422   auto param = model->addOperand(&type6);
423   auto param1 = model->addOperand(&type27);
424   auto param2 = model->addOperand(&type8);
425   auto param3 = model->addOperand(&type8);
426   auto param4 = model->addOperand(&type27);
427   auto param5 = model->addOperand(&type27);
428   auto param6 = model->addOperand(&type27);
429   auto scoresOut = model->addOperand(&type31);
430   auto roiOut = model->addOperand(&type29);
431   auto classesOut = model->addOperand(&type1);
432   auto batchSplitOut = model->addOperand(&type1);
433   auto in = model->addOperand(&type25);
434   auto param7 = model->addOperand(&type8);
435   auto param8 = model->addOperand(&type8);
436   auto param9 = model->addOperand(&type27);
437   auto param10 = model->addOperand(&type27);
438   auto param11 = model->addOperand(&type8);
439   auto param12 = model->addOperand(&type8);
440   auto layout = model->addOperand(&type9);
441   auto featureMap = model->addOperand(&type24);
442   auto param13 = model->addOperand(&type13);
443   auto out = model->addOperand(&type26);
444   // Phase 2, operations
445   static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
446   model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
447   static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
448   model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
449   static int32_t param_init[] = {0};
450   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
451   static _Float16 param1_init[] = {0.30000001192092896f};
452   model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
453   static int32_t param2_init[] = {-1};
454   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
455   static int32_t param3_init[] = {0};
456   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
457   static _Float16 param4_init[] = {0.4000000059604645f};
458   model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
459   static _Float16 param5_init[] = {1.0f};
460   model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
461   static _Float16 param6_init[] = {0.30000001192092896f};
462   model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
463   static int32_t param7_init[] = {2};
464   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
465   static int32_t param8_init[] = {2};
466   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
467   static _Float16 param9_init[] = {2.0f};
468   model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
469   static _Float16 param10_init[] = {2.0f};
470   model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
471   static int32_t param11_init[] = {4};
472   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
473   static int32_t param12_init[] = {4};
474   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
475   static bool8 layout_init[] = {false};
476   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
477   static int32_t param13_init[] = {0, 3, 1, 2};
478   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
479   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
480   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
481   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
482   // Phase 3, inputs and outputs
483   model->identifyInputsAndOutputs(
484     {in},
485     {scoresOut, classesOut, out});
486   assert(model->isValid());
487 }
488 
is_ignored_zero_sized_float16(int i)489 inline bool is_ignored_zero_sized_float16(int i) {
490   static std::set<int> ignore = {};
491   return ignore.find(i) != ignore.end();
492 }
493 
CreateModel_zero_sized_dynamic_output_shape(Model * model)494 void CreateModel_zero_sized_dynamic_output_shape(Model *model) {
495   OperandType type1(Type::TENSOR_INT32, {0});
496   OperandType type10(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
497   OperandType type11(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
498   OperandType type13(Type::TENSOR_INT32, {4});
499   OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
500   OperandType type3(Type::TENSOR_FLOAT32, {1, 8});
501   OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
502   OperandType type4(Type::TENSOR_FLOAT32, {0});
503   OperandType type5(Type::TENSOR_FLOAT32, {0, 4});
504   OperandType type6(Type::TENSOR_INT32, {1});
505   OperandType type7(Type::FLOAT32, {});
506   OperandType type8(Type::INT32, {});
507   OperandType type9(Type::BOOL, {});
508   // Phase 1, operands
509   auto scores = model->addOperand(&type2);
510   auto roi = model->addOperand(&type3);
511   auto param = model->addOperand(&type6);
512   auto param1 = model->addOperand(&type7);
513   auto param2 = model->addOperand(&type8);
514   auto param3 = model->addOperand(&type8);
515   auto param4 = model->addOperand(&type7);
516   auto param5 = model->addOperand(&type7);
517   auto param6 = model->addOperand(&type7);
518   auto scoresOut = model->addOperand(&type4);
519   auto roiOut = model->addOperand(&type5);
520   auto classesOut = model->addOperand(&type1);
521   auto batchSplitOut = model->addOperand(&type1);
522   auto in = model->addOperand(&type10);
523   auto param7 = model->addOperand(&type8);
524   auto param8 = model->addOperand(&type8);
525   auto param9 = model->addOperand(&type7);
526   auto param10 = model->addOperand(&type7);
527   auto param11 = model->addOperand(&type8);
528   auto param12 = model->addOperand(&type8);
529   auto layout = model->addOperand(&type9);
530   auto featureMap = model->addOperand(&type11);
531   auto param13 = model->addOperand(&type13);
532   auto out = model->addOperand(&type32);
533   // Phase 2, operations
534   static float scores_init[] = {0.9f, 0.1f};
535   model->setOperandValue(scores, scores_init, sizeof(float) * 2);
536   static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
537   model->setOperandValue(roi, roi_init, sizeof(float) * 8);
538   static int32_t param_init[] = {0};
539   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
540   static float param1_init[] = {0.3f};
541   model->setOperandValue(param1, param1_init, sizeof(float) * 1);
542   static int32_t param2_init[] = {-1};
543   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
544   static int32_t param3_init[] = {0};
545   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
546   static float param4_init[] = {0.4f};
547   model->setOperandValue(param4, param4_init, sizeof(float) * 1);
548   static float param5_init[] = {1.0f};
549   model->setOperandValue(param5, param5_init, sizeof(float) * 1);
550   static float param6_init[] = {0.3f};
551   model->setOperandValue(param6, param6_init, sizeof(float) * 1);
552   static int32_t param7_init[] = {2};
553   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
554   static int32_t param8_init[] = {2};
555   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
556   static float param9_init[] = {2.0f};
557   model->setOperandValue(param9, param9_init, sizeof(float) * 1);
558   static float param10_init[] = {2.0f};
559   model->setOperandValue(param10, param10_init, sizeof(float) * 1);
560   static int32_t param11_init[] = {4};
561   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
562   static int32_t param12_init[] = {4};
563   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
564   static bool8 layout_init[] = {false};
565   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
566   static int32_t param13_init[] = {0, 3, 1, 2};
567   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
568   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
569   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
570   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
571   // Phase 3, inputs and outputs
572   model->identifyInputsAndOutputs(
573     {in},
574     {scoresOut, classesOut, out});
575   assert(model->isValid());
576 }
577 
is_ignored_zero_sized_dynamic_output_shape(int i)578 inline bool is_ignored_zero_sized_dynamic_output_shape(int i) {
579   static std::set<int> ignore = {};
580   return ignore.find(i) != ignore.end();
581 }
582 
CreateModel_zero_sized_dynamic_output_shape_relaxed(Model * model)583 void CreateModel_zero_sized_dynamic_output_shape_relaxed(Model *model) {
584   OperandType type1(Type::TENSOR_INT32, {0});
585   OperandType type10(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
586   OperandType type11(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
587   OperandType type13(Type::TENSOR_INT32, {4});
588   OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
589   OperandType type3(Type::TENSOR_FLOAT32, {1, 8});
590   OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
591   OperandType type4(Type::TENSOR_FLOAT32, {0});
592   OperandType type5(Type::TENSOR_FLOAT32, {0, 4});
593   OperandType type6(Type::TENSOR_INT32, {1});
594   OperandType type7(Type::FLOAT32, {});
595   OperandType type8(Type::INT32, {});
596   OperandType type9(Type::BOOL, {});
597   // Phase 1, operands
598   auto scores = model->addOperand(&type2);
599   auto roi = model->addOperand(&type3);
600   auto param = model->addOperand(&type6);
601   auto param1 = model->addOperand(&type7);
602   auto param2 = model->addOperand(&type8);
603   auto param3 = model->addOperand(&type8);
604   auto param4 = model->addOperand(&type7);
605   auto param5 = model->addOperand(&type7);
606   auto param6 = model->addOperand(&type7);
607   auto scoresOut = model->addOperand(&type4);
608   auto roiOut = model->addOperand(&type5);
609   auto classesOut = model->addOperand(&type1);
610   auto batchSplitOut = model->addOperand(&type1);
611   auto in = model->addOperand(&type10);
612   auto param7 = model->addOperand(&type8);
613   auto param8 = model->addOperand(&type8);
614   auto param9 = model->addOperand(&type7);
615   auto param10 = model->addOperand(&type7);
616   auto param11 = model->addOperand(&type8);
617   auto param12 = model->addOperand(&type8);
618   auto layout = model->addOperand(&type9);
619   auto featureMap = model->addOperand(&type11);
620   auto param13 = model->addOperand(&type13);
621   auto out = model->addOperand(&type32);
622   // Phase 2, operations
623   static float scores_init[] = {0.9f, 0.1f};
624   model->setOperandValue(scores, scores_init, sizeof(float) * 2);
625   static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
626   model->setOperandValue(roi, roi_init, sizeof(float) * 8);
627   static int32_t param_init[] = {0};
628   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
629   static float param1_init[] = {0.3f};
630   model->setOperandValue(param1, param1_init, sizeof(float) * 1);
631   static int32_t param2_init[] = {-1};
632   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
633   static int32_t param3_init[] = {0};
634   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
635   static float param4_init[] = {0.4f};
636   model->setOperandValue(param4, param4_init, sizeof(float) * 1);
637   static float param5_init[] = {1.0f};
638   model->setOperandValue(param5, param5_init, sizeof(float) * 1);
639   static float param6_init[] = {0.3f};
640   model->setOperandValue(param6, param6_init, sizeof(float) * 1);
641   static int32_t param7_init[] = {2};
642   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
643   static int32_t param8_init[] = {2};
644   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
645   static float param9_init[] = {2.0f};
646   model->setOperandValue(param9, param9_init, sizeof(float) * 1);
647   static float param10_init[] = {2.0f};
648   model->setOperandValue(param10, param10_init, sizeof(float) * 1);
649   static int32_t param11_init[] = {4};
650   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
651   static int32_t param12_init[] = {4};
652   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
653   static bool8 layout_init[] = {false};
654   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
655   static int32_t param13_init[] = {0, 3, 1, 2};
656   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
657   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
658   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
659   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
660   // Phase 3, inputs and outputs
661   model->identifyInputsAndOutputs(
662     {in},
663     {scoresOut, classesOut, out});
664   // Phase 4: set relaxed execution
665   model->relaxComputationFloat32toFloat16(true);
666   assert(model->isValid());
667 }
668 
is_ignored_zero_sized_dynamic_output_shape_relaxed(int i)669 inline bool is_ignored_zero_sized_dynamic_output_shape_relaxed(int i) {
670   static std::set<int> ignore = {};
671   return ignore.find(i) != ignore.end();
672 }
673 
CreateModel_zero_sized_dynamic_output_shape_quant8(Model * model)674 void CreateModel_zero_sized_dynamic_output_shape_quant8(Model *model) {
675   OperandType type1(Type::TENSOR_INT32, {0});
676   OperandType type13(Type::TENSOR_INT32, {4});
677   OperandType type17(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
678   OperandType type18(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
679   OperandType type20(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
680   OperandType type21(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
681   OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
682   OperandType type23(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
683   OperandType type33(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.1f, 128);
684   OperandType type6(Type::TENSOR_INT32, {1});
685   OperandType type7(Type::FLOAT32, {});
686   OperandType type8(Type::INT32, {});
687   OperandType type9(Type::BOOL, {});
688   // Phase 1, operands
689   auto scores = model->addOperand(&type22);
690   auto roi = model->addOperand(&type20);
691   auto param = model->addOperand(&type6);
692   auto param1 = model->addOperand(&type7);
693   auto param2 = model->addOperand(&type8);
694   auto param3 = model->addOperand(&type8);
695   auto param4 = model->addOperand(&type7);
696   auto param5 = model->addOperand(&type7);
697   auto param6 = model->addOperand(&type7);
698   auto scoresOut = model->addOperand(&type23);
699   auto roiOut = model->addOperand(&type21);
700   auto classesOut = model->addOperand(&type1);
701   auto batchSplitOut = model->addOperand(&type1);
702   auto in = model->addOperand(&type18);
703   auto param7 = model->addOperand(&type8);
704   auto param8 = model->addOperand(&type8);
705   auto param9 = model->addOperand(&type7);
706   auto param10 = model->addOperand(&type7);
707   auto param11 = model->addOperand(&type8);
708   auto param12 = model->addOperand(&type8);
709   auto layout = model->addOperand(&type9);
710   auto featureMap = model->addOperand(&type17);
711   auto param13 = model->addOperand(&type13);
712   auto out = model->addOperand(&type33);
713   // Phase 2, operations
714   static uint8_t scores_init[] = {137, 129};
715   model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
716   static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
717   model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
718   static int32_t param_init[] = {0};
719   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
720   static float param1_init[] = {0.3f};
721   model->setOperandValue(param1, param1_init, sizeof(float) * 1);
722   static int32_t param2_init[] = {-1};
723   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
724   static int32_t param3_init[] = {0};
725   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
726   static float param4_init[] = {0.4f};
727   model->setOperandValue(param4, param4_init, sizeof(float) * 1);
728   static float param5_init[] = {1.0f};
729   model->setOperandValue(param5, param5_init, sizeof(float) * 1);
730   static float param6_init[] = {0.3f};
731   model->setOperandValue(param6, param6_init, sizeof(float) * 1);
732   static int32_t param7_init[] = {2};
733   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
734   static int32_t param8_init[] = {2};
735   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
736   static float param9_init[] = {2.0f};
737   model->setOperandValue(param9, param9_init, sizeof(float) * 1);
738   static float param10_init[] = {2.0f};
739   model->setOperandValue(param10, param10_init, sizeof(float) * 1);
740   static int32_t param11_init[] = {4};
741   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
742   static int32_t param12_init[] = {4};
743   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
744   static bool8 layout_init[] = {false};
745   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
746   static int32_t param13_init[] = {0, 3, 1, 2};
747   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
748   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
749   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
750   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
751   // Phase 3, inputs and outputs
752   model->identifyInputsAndOutputs(
753     {in},
754     {scoresOut, classesOut, out});
755   assert(model->isValid());
756 }
757 
is_ignored_zero_sized_dynamic_output_shape_quant8(int i)758 inline bool is_ignored_zero_sized_dynamic_output_shape_quant8(int i) {
759   static std::set<int> ignore = {};
760   return ignore.find(i) != ignore.end();
761 }
762 
CreateModel_zero_sized_dynamic_output_shape_float16(Model * model)763 void CreateModel_zero_sized_dynamic_output_shape_float16(Model *model) {
764   OperandType type1(Type::TENSOR_INT32, {0});
765   OperandType type13(Type::TENSOR_INT32, {4});
766   OperandType type24(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
767   OperandType type25(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
768   OperandType type27(Type::FLOAT16, {});
769   OperandType type28(Type::TENSOR_FLOAT16, {1, 8});
770   OperandType type29(Type::TENSOR_FLOAT16, {0, 4});
771   OperandType type30(Type::TENSOR_FLOAT16, {1, 2});
772   OperandType type34(Type::TENSOR_FLOAT16, {0});
773   OperandType type35(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
774   OperandType type6(Type::TENSOR_INT32, {1});
775   OperandType type8(Type::INT32, {});
776   OperandType type9(Type::BOOL, {});
777   // Phase 1, operands
778   auto scores = model->addOperand(&type30);
779   auto roi = model->addOperand(&type28);
780   auto param = model->addOperand(&type6);
781   auto param1 = model->addOperand(&type27);
782   auto param2 = model->addOperand(&type8);
783   auto param3 = model->addOperand(&type8);
784   auto param4 = model->addOperand(&type27);
785   auto param5 = model->addOperand(&type27);
786   auto param6 = model->addOperand(&type27);
787   auto scoresOut = model->addOperand(&type34);
788   auto roiOut = model->addOperand(&type29);
789   auto classesOut = model->addOperand(&type1);
790   auto batchSplitOut = model->addOperand(&type1);
791   auto in = model->addOperand(&type25);
792   auto param7 = model->addOperand(&type8);
793   auto param8 = model->addOperand(&type8);
794   auto param9 = model->addOperand(&type27);
795   auto param10 = model->addOperand(&type27);
796   auto param11 = model->addOperand(&type8);
797   auto param12 = model->addOperand(&type8);
798   auto layout = model->addOperand(&type9);
799   auto featureMap = model->addOperand(&type24);
800   auto param13 = model->addOperand(&type13);
801   auto out = model->addOperand(&type35);
802   // Phase 2, operations
803   static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
804   model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
805   static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
806   model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
807   static int32_t param_init[] = {0};
808   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
809   static _Float16 param1_init[] = {0.30000001192092896f};
810   model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
811   static int32_t param2_init[] = {-1};
812   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
813   static int32_t param3_init[] = {0};
814   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
815   static _Float16 param4_init[] = {0.4000000059604645f};
816   model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
817   static _Float16 param5_init[] = {1.0f};
818   model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
819   static _Float16 param6_init[] = {0.30000001192092896f};
820   model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
821   static int32_t param7_init[] = {2};
822   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
823   static int32_t param8_init[] = {2};
824   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
825   static _Float16 param9_init[] = {2.0f};
826   model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
827   static _Float16 param10_init[] = {2.0f};
828   model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
829   static int32_t param11_init[] = {4};
830   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
831   static int32_t param12_init[] = {4};
832   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
833   static bool8 layout_init[] = {false};
834   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
835   static int32_t param13_init[] = {0, 3, 1, 2};
836   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 4);
837   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
838   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
839   model->addOperation(ANEURALNETWORKS_TRANSPOSE, {featureMap, param13}, {out});
840   // Phase 3, inputs and outputs
841   model->identifyInputsAndOutputs(
842     {in},
843     {scoresOut, classesOut, out});
844   assert(model->isValid());
845 }
846 
is_ignored_zero_sized_dynamic_output_shape_float16(int i)847 inline bool is_ignored_zero_sized_dynamic_output_shape_float16(int i) {
848   static std::set<int> ignore = {};
849   return ignore.find(i) != ignore.end();
850 }
851 
852