1 // clang-format off
2 // Generated file (from: roi_align.mod.py). Do not edit
CreateModel_nhwc(Model * model)3 void CreateModel_nhwc(Model *model) {
4 OperandType type0(Type::BOOL, {});
5 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
6 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
7 OperandType type3(Type::TENSOR_FLOAT32, {4, 2, 2, 1});
8 OperandType type4(Type::TENSOR_INT32, {4});
9 OperandType type5(Type::INT32, {});
10 OperandType type6(Type::FLOAT32, {});
11 // Phase 1, operands
12 auto in = model->addOperand(&type1);
13 auto roi = model->addOperand(&type2);
14 auto param = model->addOperand(&type4);
15 auto param1 = model->addOperand(&type5);
16 auto param2 = model->addOperand(&type5);
17 auto param3 = model->addOperand(&type6);
18 auto param4 = model->addOperand(&type6);
19 auto param5 = model->addOperand(&type5);
20 auto param6 = model->addOperand(&type5);
21 auto layout = model->addOperand(&type0);
22 auto out = model->addOperand(&type3);
23 // Phase 2, operations
24 static int32_t param_init[] = {0, 0, 0, 0};
25 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
26 static int32_t param1_init[] = {2};
27 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
28 static int32_t param2_init[] = {2};
29 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
30 static float param3_init[] = {2.0f};
31 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
32 static float param4_init[] = {2.0f};
33 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
34 static int32_t param5_init[] = {4};
35 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
36 static int32_t param6_init[] = {4};
37 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
38 static bool8 layout_init[] = {false};
39 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
40 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
41 // Phase 3, inputs and outputs
42 model->identifyInputsAndOutputs(
43 {in, roi},
44 {out});
45 assert(model->isValid());
46 }
47
is_ignored_nhwc(int i)48 inline bool is_ignored_nhwc(int i) {
49 static std::set<int> ignore = {};
50 return ignore.find(i) != ignore.end();
51 }
52
CreateModel_nhwc_relaxed(Model * model)53 void CreateModel_nhwc_relaxed(Model *model) {
54 OperandType type0(Type::BOOL, {});
55 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
56 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
57 OperandType type3(Type::TENSOR_FLOAT32, {4, 2, 2, 1});
58 OperandType type4(Type::TENSOR_INT32, {4});
59 OperandType type5(Type::INT32, {});
60 OperandType type6(Type::FLOAT32, {});
61 // Phase 1, operands
62 auto in = model->addOperand(&type1);
63 auto roi = model->addOperand(&type2);
64 auto param = model->addOperand(&type4);
65 auto param1 = model->addOperand(&type5);
66 auto param2 = model->addOperand(&type5);
67 auto param3 = model->addOperand(&type6);
68 auto param4 = model->addOperand(&type6);
69 auto param5 = model->addOperand(&type5);
70 auto param6 = model->addOperand(&type5);
71 auto layout = model->addOperand(&type0);
72 auto out = model->addOperand(&type3);
73 // Phase 2, operations
74 static int32_t param_init[] = {0, 0, 0, 0};
75 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
76 static int32_t param1_init[] = {2};
77 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
78 static int32_t param2_init[] = {2};
79 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
80 static float param3_init[] = {2.0f};
81 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
82 static float param4_init[] = {2.0f};
83 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
84 static int32_t param5_init[] = {4};
85 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
86 static int32_t param6_init[] = {4};
87 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
88 static bool8 layout_init[] = {false};
89 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
90 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
91 // Phase 3, inputs and outputs
92 model->identifyInputsAndOutputs(
93 {in, roi},
94 {out});
95 // Phase 4: set relaxed execution
96 model->relaxComputationFloat32toFloat16(true);
97 assert(model->isValid());
98 }
99
is_ignored_nhwc_relaxed(int i)100 inline bool is_ignored_nhwc_relaxed(int i) {
101 static std::set<int> ignore = {};
102 return ignore.find(i) != ignore.end();
103 }
104
CreateModel_nhwc_quant8(Model * model)105 void CreateModel_nhwc_quant8(Model *model) {
106 OperandType type0(Type::BOOL, {});
107 OperandType type25(Type::TENSOR_QUANT8_ASYMM, {1, 4, 4, 1}, 0.25f, 128);
108 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {4, 2, 2, 1}, 0.0625f, 128);
109 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
110 OperandType type4(Type::TENSOR_INT32, {4});
111 OperandType type5(Type::INT32, {});
112 OperandType type6(Type::FLOAT32, {});
113 // Phase 1, operands
114 auto in = model->addOperand(&type25);
115 auto roi = model->addOperand(&type27);
116 auto param = model->addOperand(&type4);
117 auto param1 = model->addOperand(&type5);
118 auto param2 = model->addOperand(&type5);
119 auto param3 = model->addOperand(&type6);
120 auto param4 = model->addOperand(&type6);
121 auto param5 = model->addOperand(&type5);
122 auto param6 = model->addOperand(&type5);
123 auto layout = model->addOperand(&type0);
124 auto out = model->addOperand(&type26);
125 // Phase 2, operations
126 static int32_t param_init[] = {0, 0, 0, 0};
127 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
128 static int32_t param1_init[] = {2};
129 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
130 static int32_t param2_init[] = {2};
131 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
132 static float param3_init[] = {2.0f};
133 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
134 static float param4_init[] = {2.0f};
135 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
136 static int32_t param5_init[] = {4};
137 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
138 static int32_t param6_init[] = {4};
139 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
140 static bool8 layout_init[] = {false};
141 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
142 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
143 // Phase 3, inputs and outputs
144 model->identifyInputsAndOutputs(
145 {in, roi},
146 {out});
147 assert(model->isValid());
148 }
149
is_ignored_nhwc_quant8(int i)150 inline bool is_ignored_nhwc_quant8(int i) {
151 static std::set<int> ignore = {};
152 return ignore.find(i) != ignore.end();
153 }
154
CreateModel_nhwc_float16(Model * model)155 void CreateModel_nhwc_float16(Model *model) {
156 OperandType type0(Type::BOOL, {});
157 OperandType type28(Type::TENSOR_FLOAT16, {1, 4, 4, 1});
158 OperandType type29(Type::TENSOR_FLOAT16, {4, 2, 2, 1});
159 OperandType type30(Type::FLOAT16, {});
160 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
161 OperandType type4(Type::TENSOR_INT32, {4});
162 OperandType type5(Type::INT32, {});
163 // Phase 1, operands
164 auto in = model->addOperand(&type28);
165 auto roi = model->addOperand(&type31);
166 auto param = model->addOperand(&type4);
167 auto param1 = model->addOperand(&type5);
168 auto param2 = model->addOperand(&type5);
169 auto param3 = model->addOperand(&type30);
170 auto param4 = model->addOperand(&type30);
171 auto param5 = model->addOperand(&type5);
172 auto param6 = model->addOperand(&type5);
173 auto layout = model->addOperand(&type0);
174 auto out = model->addOperand(&type29);
175 // Phase 2, operations
176 static int32_t param_init[] = {0, 0, 0, 0};
177 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
178 static int32_t param1_init[] = {2};
179 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
180 static int32_t param2_init[] = {2};
181 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
182 static _Float16 param3_init[] = {2.0f};
183 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
184 static _Float16 param4_init[] = {2.0f};
185 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
186 static int32_t param5_init[] = {4};
187 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
188 static int32_t param6_init[] = {4};
189 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
190 static bool8 layout_init[] = {false};
191 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
192 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
193 // Phase 3, inputs and outputs
194 model->identifyInputsAndOutputs(
195 {in, roi},
196 {out});
197 assert(model->isValid());
198 }
199
is_ignored_nhwc_float16(int i)200 inline bool is_ignored_nhwc_float16(int i) {
201 static std::set<int> ignore = {};
202 return ignore.find(i) != ignore.end();
203 }
204
CreateModel_nchw(Model * model)205 void CreateModel_nchw(Model *model) {
206 OperandType type0(Type::BOOL, {});
207 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
208 OperandType type32(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
209 OperandType type33(Type::TENSOR_FLOAT32, {4, 1, 2, 2});
210 OperandType type4(Type::TENSOR_INT32, {4});
211 OperandType type5(Type::INT32, {});
212 OperandType type6(Type::FLOAT32, {});
213 // Phase 1, operands
214 auto in = model->addOperand(&type32);
215 auto roi = model->addOperand(&type2);
216 auto param = model->addOperand(&type4);
217 auto param1 = model->addOperand(&type5);
218 auto param2 = model->addOperand(&type5);
219 auto param3 = model->addOperand(&type6);
220 auto param4 = model->addOperand(&type6);
221 auto param5 = model->addOperand(&type5);
222 auto param6 = model->addOperand(&type5);
223 auto layout = model->addOperand(&type0);
224 auto out = model->addOperand(&type33);
225 // Phase 2, operations
226 static int32_t param_init[] = {0, 0, 0, 0};
227 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
228 static int32_t param1_init[] = {2};
229 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
230 static int32_t param2_init[] = {2};
231 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
232 static float param3_init[] = {2.0f};
233 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
234 static float param4_init[] = {2.0f};
235 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
236 static int32_t param5_init[] = {4};
237 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
238 static int32_t param6_init[] = {4};
239 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
240 static bool8 layout_init[] = {true};
241 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
242 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
243 // Phase 3, inputs and outputs
244 model->identifyInputsAndOutputs(
245 {in, roi},
246 {out});
247 assert(model->isValid());
248 }
249
is_ignored_nchw(int i)250 inline bool is_ignored_nchw(int i) {
251 static std::set<int> ignore = {};
252 return ignore.find(i) != ignore.end();
253 }
254
CreateModel_nchw_relaxed(Model * model)255 void CreateModel_nchw_relaxed(Model *model) {
256 OperandType type0(Type::BOOL, {});
257 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
258 OperandType type32(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
259 OperandType type33(Type::TENSOR_FLOAT32, {4, 1, 2, 2});
260 OperandType type4(Type::TENSOR_INT32, {4});
261 OperandType type5(Type::INT32, {});
262 OperandType type6(Type::FLOAT32, {});
263 // Phase 1, operands
264 auto in = model->addOperand(&type32);
265 auto roi = model->addOperand(&type2);
266 auto param = model->addOperand(&type4);
267 auto param1 = model->addOperand(&type5);
268 auto param2 = model->addOperand(&type5);
269 auto param3 = model->addOperand(&type6);
270 auto param4 = model->addOperand(&type6);
271 auto param5 = model->addOperand(&type5);
272 auto param6 = model->addOperand(&type5);
273 auto layout = model->addOperand(&type0);
274 auto out = model->addOperand(&type33);
275 // Phase 2, operations
276 static int32_t param_init[] = {0, 0, 0, 0};
277 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
278 static int32_t param1_init[] = {2};
279 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
280 static int32_t param2_init[] = {2};
281 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
282 static float param3_init[] = {2.0f};
283 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
284 static float param4_init[] = {2.0f};
285 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
286 static int32_t param5_init[] = {4};
287 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
288 static int32_t param6_init[] = {4};
289 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
290 static bool8 layout_init[] = {true};
291 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
292 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
293 // Phase 3, inputs and outputs
294 model->identifyInputsAndOutputs(
295 {in, roi},
296 {out});
297 // Phase 4: set relaxed execution
298 model->relaxComputationFloat32toFloat16(true);
299 assert(model->isValid());
300 }
301
is_ignored_nchw_relaxed(int i)302 inline bool is_ignored_nchw_relaxed(int i) {
303 static std::set<int> ignore = {};
304 return ignore.find(i) != ignore.end();
305 }
306
CreateModel_nchw_quant8(Model * model)307 void CreateModel_nchw_quant8(Model *model) {
308 OperandType type0(Type::BOOL, {});
309 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
310 OperandType type34(Type::TENSOR_QUANT8_ASYMM, {1, 1, 4, 4}, 0.25f, 128);
311 OperandType type35(Type::TENSOR_QUANT8_ASYMM, {4, 1, 2, 2}, 0.0625f, 128);
312 OperandType type4(Type::TENSOR_INT32, {4});
313 OperandType type5(Type::INT32, {});
314 OperandType type6(Type::FLOAT32, {});
315 // Phase 1, operands
316 auto in = model->addOperand(&type34);
317 auto roi = model->addOperand(&type27);
318 auto param = model->addOperand(&type4);
319 auto param1 = model->addOperand(&type5);
320 auto param2 = model->addOperand(&type5);
321 auto param3 = model->addOperand(&type6);
322 auto param4 = model->addOperand(&type6);
323 auto param5 = model->addOperand(&type5);
324 auto param6 = model->addOperand(&type5);
325 auto layout = model->addOperand(&type0);
326 auto out = model->addOperand(&type35);
327 // Phase 2, operations
328 static int32_t param_init[] = {0, 0, 0, 0};
329 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
330 static int32_t param1_init[] = {2};
331 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
332 static int32_t param2_init[] = {2};
333 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
334 static float param3_init[] = {2.0f};
335 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
336 static float param4_init[] = {2.0f};
337 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
338 static int32_t param5_init[] = {4};
339 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
340 static int32_t param6_init[] = {4};
341 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
342 static bool8 layout_init[] = {true};
343 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
344 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
345 // Phase 3, inputs and outputs
346 model->identifyInputsAndOutputs(
347 {in, roi},
348 {out});
349 assert(model->isValid());
350 }
351
is_ignored_nchw_quant8(int i)352 inline bool is_ignored_nchw_quant8(int i) {
353 static std::set<int> ignore = {};
354 return ignore.find(i) != ignore.end();
355 }
356
CreateModel_nchw_float16(Model * model)357 void CreateModel_nchw_float16(Model *model) {
358 OperandType type0(Type::BOOL, {});
359 OperandType type30(Type::FLOAT16, {});
360 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
361 OperandType type36(Type::TENSOR_FLOAT16, {1, 1, 4, 4});
362 OperandType type37(Type::TENSOR_FLOAT16, {4, 1, 2, 2});
363 OperandType type4(Type::TENSOR_INT32, {4});
364 OperandType type5(Type::INT32, {});
365 // Phase 1, operands
366 auto in = model->addOperand(&type36);
367 auto roi = model->addOperand(&type31);
368 auto param = model->addOperand(&type4);
369 auto param1 = model->addOperand(&type5);
370 auto param2 = model->addOperand(&type5);
371 auto param3 = model->addOperand(&type30);
372 auto param4 = model->addOperand(&type30);
373 auto param5 = model->addOperand(&type5);
374 auto param6 = model->addOperand(&type5);
375 auto layout = model->addOperand(&type0);
376 auto out = model->addOperand(&type37);
377 // Phase 2, operations
378 static int32_t param_init[] = {0, 0, 0, 0};
379 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
380 static int32_t param1_init[] = {2};
381 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
382 static int32_t param2_init[] = {2};
383 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
384 static _Float16 param3_init[] = {2.0f};
385 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
386 static _Float16 param4_init[] = {2.0f};
387 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
388 static int32_t param5_init[] = {4};
389 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
390 static int32_t param6_init[] = {4};
391 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
392 static bool8 layout_init[] = {true};
393 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
394 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
395 // Phase 3, inputs and outputs
396 model->identifyInputsAndOutputs(
397 {in, roi},
398 {out});
399 assert(model->isValid());
400 }
401
is_ignored_nchw_float16(int i)402 inline bool is_ignored_nchw_float16(int i) {
403 static std::set<int> ignore = {};
404 return ignore.find(i) != ignore.end();
405 }
406
CreateModel_dynamic_output_shape_nhwc(Model * model)407 void CreateModel_dynamic_output_shape_nhwc(Model *model) {
408 OperandType type0(Type::BOOL, {});
409 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
410 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
411 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
412 OperandType type4(Type::TENSOR_INT32, {4});
413 OperandType type5(Type::INT32, {});
414 OperandType type6(Type::FLOAT32, {});
415 // Phase 1, operands
416 auto in = model->addOperand(&type1);
417 auto roi = model->addOperand(&type2);
418 auto param = model->addOperand(&type4);
419 auto param1 = model->addOperand(&type5);
420 auto param2 = model->addOperand(&type5);
421 auto param3 = model->addOperand(&type6);
422 auto param4 = model->addOperand(&type6);
423 auto param5 = model->addOperand(&type5);
424 auto param6 = model->addOperand(&type5);
425 auto layout = model->addOperand(&type0);
426 auto out = model->addOperand(&type38);
427 // Phase 2, operations
428 static int32_t param_init[] = {0, 0, 0, 0};
429 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
430 static int32_t param1_init[] = {2};
431 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
432 static int32_t param2_init[] = {2};
433 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
434 static float param3_init[] = {2.0f};
435 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
436 static float param4_init[] = {2.0f};
437 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
438 static int32_t param5_init[] = {4};
439 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
440 static int32_t param6_init[] = {4};
441 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
442 static bool8 layout_init[] = {false};
443 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
444 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
445 // Phase 3, inputs and outputs
446 model->identifyInputsAndOutputs(
447 {in, roi},
448 {out});
449 assert(model->isValid());
450 }
451
is_ignored_dynamic_output_shape_nhwc(int i)452 inline bool is_ignored_dynamic_output_shape_nhwc(int i) {
453 static std::set<int> ignore = {};
454 return ignore.find(i) != ignore.end();
455 }
456
CreateModel_dynamic_output_shape_nhwc_relaxed(Model * model)457 void CreateModel_dynamic_output_shape_nhwc_relaxed(Model *model) {
458 OperandType type0(Type::BOOL, {});
459 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
460 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
461 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
462 OperandType type4(Type::TENSOR_INT32, {4});
463 OperandType type5(Type::INT32, {});
464 OperandType type6(Type::FLOAT32, {});
465 // Phase 1, operands
466 auto in = model->addOperand(&type1);
467 auto roi = model->addOperand(&type2);
468 auto param = model->addOperand(&type4);
469 auto param1 = model->addOperand(&type5);
470 auto param2 = model->addOperand(&type5);
471 auto param3 = model->addOperand(&type6);
472 auto param4 = model->addOperand(&type6);
473 auto param5 = model->addOperand(&type5);
474 auto param6 = model->addOperand(&type5);
475 auto layout = model->addOperand(&type0);
476 auto out = model->addOperand(&type38);
477 // Phase 2, operations
478 static int32_t param_init[] = {0, 0, 0, 0};
479 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
480 static int32_t param1_init[] = {2};
481 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
482 static int32_t param2_init[] = {2};
483 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
484 static float param3_init[] = {2.0f};
485 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
486 static float param4_init[] = {2.0f};
487 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
488 static int32_t param5_init[] = {4};
489 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
490 static int32_t param6_init[] = {4};
491 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
492 static bool8 layout_init[] = {false};
493 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
494 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
495 // Phase 3, inputs and outputs
496 model->identifyInputsAndOutputs(
497 {in, roi},
498 {out});
499 // Phase 4: set relaxed execution
500 model->relaxComputationFloat32toFloat16(true);
501 assert(model->isValid());
502 }
503
is_ignored_dynamic_output_shape_nhwc_relaxed(int i)504 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed(int i) {
505 static std::set<int> ignore = {};
506 return ignore.find(i) != ignore.end();
507 }
508
CreateModel_dynamic_output_shape_nhwc_quant8(Model * model)509 void CreateModel_dynamic_output_shape_nhwc_quant8(Model *model) {
510 OperandType type0(Type::BOOL, {});
511 OperandType type25(Type::TENSOR_QUANT8_ASYMM, {1, 4, 4, 1}, 0.25f, 128);
512 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
513 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0625f, 128);
514 OperandType type4(Type::TENSOR_INT32, {4});
515 OperandType type5(Type::INT32, {});
516 OperandType type6(Type::FLOAT32, {});
517 // Phase 1, operands
518 auto in = model->addOperand(&type25);
519 auto roi = model->addOperand(&type27);
520 auto param = model->addOperand(&type4);
521 auto param1 = model->addOperand(&type5);
522 auto param2 = model->addOperand(&type5);
523 auto param3 = model->addOperand(&type6);
524 auto param4 = model->addOperand(&type6);
525 auto param5 = model->addOperand(&type5);
526 auto param6 = model->addOperand(&type5);
527 auto layout = model->addOperand(&type0);
528 auto out = model->addOperand(&type39);
529 // Phase 2, operations
530 static int32_t param_init[] = {0, 0, 0, 0};
531 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
532 static int32_t param1_init[] = {2};
533 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
534 static int32_t param2_init[] = {2};
535 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
536 static float param3_init[] = {2.0f};
537 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
538 static float param4_init[] = {2.0f};
539 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
540 static int32_t param5_init[] = {4};
541 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
542 static int32_t param6_init[] = {4};
543 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
544 static bool8 layout_init[] = {false};
545 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
546 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
547 // Phase 3, inputs and outputs
548 model->identifyInputsAndOutputs(
549 {in, roi},
550 {out});
551 assert(model->isValid());
552 }
553
is_ignored_dynamic_output_shape_nhwc_quant8(int i)554 inline bool is_ignored_dynamic_output_shape_nhwc_quant8(int i) {
555 static std::set<int> ignore = {};
556 return ignore.find(i) != ignore.end();
557 }
558
CreateModel_dynamic_output_shape_nhwc_float16(Model * model)559 void CreateModel_dynamic_output_shape_nhwc_float16(Model *model) {
560 OperandType type0(Type::BOOL, {});
561 OperandType type28(Type::TENSOR_FLOAT16, {1, 4, 4, 1});
562 OperandType type30(Type::FLOAT16, {});
563 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
564 OperandType type4(Type::TENSOR_INT32, {4});
565 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
566 OperandType type5(Type::INT32, {});
567 // Phase 1, operands
568 auto in = model->addOperand(&type28);
569 auto roi = model->addOperand(&type31);
570 auto param = model->addOperand(&type4);
571 auto param1 = model->addOperand(&type5);
572 auto param2 = model->addOperand(&type5);
573 auto param3 = model->addOperand(&type30);
574 auto param4 = model->addOperand(&type30);
575 auto param5 = model->addOperand(&type5);
576 auto param6 = model->addOperand(&type5);
577 auto layout = model->addOperand(&type0);
578 auto out = model->addOperand(&type40);
579 // Phase 2, operations
580 static int32_t param_init[] = {0, 0, 0, 0};
581 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
582 static int32_t param1_init[] = {2};
583 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
584 static int32_t param2_init[] = {2};
585 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
586 static _Float16 param3_init[] = {2.0f};
587 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
588 static _Float16 param4_init[] = {2.0f};
589 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
590 static int32_t param5_init[] = {4};
591 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
592 static int32_t param6_init[] = {4};
593 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
594 static bool8 layout_init[] = {false};
595 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
596 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
597 // Phase 3, inputs and outputs
598 model->identifyInputsAndOutputs(
599 {in, roi},
600 {out});
601 assert(model->isValid());
602 }
603
is_ignored_dynamic_output_shape_nhwc_float16(int i)604 inline bool is_ignored_dynamic_output_shape_nhwc_float16(int i) {
605 static std::set<int> ignore = {};
606 return ignore.find(i) != ignore.end();
607 }
608
CreateModel_dynamic_output_shape_nchw(Model * model)609 void CreateModel_dynamic_output_shape_nchw(Model *model) {
610 OperandType type0(Type::BOOL, {});
611 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
612 OperandType type32(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
613 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
614 OperandType type4(Type::TENSOR_INT32, {4});
615 OperandType type5(Type::INT32, {});
616 OperandType type6(Type::FLOAT32, {});
617 // Phase 1, operands
618 auto in = model->addOperand(&type32);
619 auto roi = model->addOperand(&type2);
620 auto param = model->addOperand(&type4);
621 auto param1 = model->addOperand(&type5);
622 auto param2 = model->addOperand(&type5);
623 auto param3 = model->addOperand(&type6);
624 auto param4 = model->addOperand(&type6);
625 auto param5 = model->addOperand(&type5);
626 auto param6 = model->addOperand(&type5);
627 auto layout = model->addOperand(&type0);
628 auto out = model->addOperand(&type38);
629 // Phase 2, operations
630 static int32_t param_init[] = {0, 0, 0, 0};
631 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
632 static int32_t param1_init[] = {2};
633 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
634 static int32_t param2_init[] = {2};
635 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
636 static float param3_init[] = {2.0f};
637 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
638 static float param4_init[] = {2.0f};
639 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
640 static int32_t param5_init[] = {4};
641 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
642 static int32_t param6_init[] = {4};
643 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
644 static bool8 layout_init[] = {true};
645 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
646 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
647 // Phase 3, inputs and outputs
648 model->identifyInputsAndOutputs(
649 {in, roi},
650 {out});
651 assert(model->isValid());
652 }
653
is_ignored_dynamic_output_shape_nchw(int i)654 inline bool is_ignored_dynamic_output_shape_nchw(int i) {
655 static std::set<int> ignore = {};
656 return ignore.find(i) != ignore.end();
657 }
658
CreateModel_dynamic_output_shape_nchw_relaxed(Model * model)659 void CreateModel_dynamic_output_shape_nchw_relaxed(Model *model) {
660 OperandType type0(Type::BOOL, {});
661 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
662 OperandType type32(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
663 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
664 OperandType type4(Type::TENSOR_INT32, {4});
665 OperandType type5(Type::INT32, {});
666 OperandType type6(Type::FLOAT32, {});
667 // Phase 1, operands
668 auto in = model->addOperand(&type32);
669 auto roi = model->addOperand(&type2);
670 auto param = model->addOperand(&type4);
671 auto param1 = model->addOperand(&type5);
672 auto param2 = model->addOperand(&type5);
673 auto param3 = model->addOperand(&type6);
674 auto param4 = model->addOperand(&type6);
675 auto param5 = model->addOperand(&type5);
676 auto param6 = model->addOperand(&type5);
677 auto layout = model->addOperand(&type0);
678 auto out = model->addOperand(&type38);
679 // Phase 2, operations
680 static int32_t param_init[] = {0, 0, 0, 0};
681 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
682 static int32_t param1_init[] = {2};
683 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
684 static int32_t param2_init[] = {2};
685 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
686 static float param3_init[] = {2.0f};
687 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
688 static float param4_init[] = {2.0f};
689 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
690 static int32_t param5_init[] = {4};
691 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
692 static int32_t param6_init[] = {4};
693 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
694 static bool8 layout_init[] = {true};
695 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
696 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
697 // Phase 3, inputs and outputs
698 model->identifyInputsAndOutputs(
699 {in, roi},
700 {out});
701 // Phase 4: set relaxed execution
702 model->relaxComputationFloat32toFloat16(true);
703 assert(model->isValid());
704 }
705
is_ignored_dynamic_output_shape_nchw_relaxed(int i)706 inline bool is_ignored_dynamic_output_shape_nchw_relaxed(int i) {
707 static std::set<int> ignore = {};
708 return ignore.find(i) != ignore.end();
709 }
710
CreateModel_dynamic_output_shape_nchw_quant8(Model * model)711 void CreateModel_dynamic_output_shape_nchw_quant8(Model *model) {
712 OperandType type0(Type::BOOL, {});
713 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
714 OperandType type34(Type::TENSOR_QUANT8_ASYMM, {1, 1, 4, 4}, 0.25f, 128);
715 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0625f, 128);
716 OperandType type4(Type::TENSOR_INT32, {4});
717 OperandType type5(Type::INT32, {});
718 OperandType type6(Type::FLOAT32, {});
719 // Phase 1, operands
720 auto in = model->addOperand(&type34);
721 auto roi = model->addOperand(&type27);
722 auto param = model->addOperand(&type4);
723 auto param1 = model->addOperand(&type5);
724 auto param2 = model->addOperand(&type5);
725 auto param3 = model->addOperand(&type6);
726 auto param4 = model->addOperand(&type6);
727 auto param5 = model->addOperand(&type5);
728 auto param6 = model->addOperand(&type5);
729 auto layout = model->addOperand(&type0);
730 auto out = model->addOperand(&type39);
731 // Phase 2, operations
732 static int32_t param_init[] = {0, 0, 0, 0};
733 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
734 static int32_t param1_init[] = {2};
735 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
736 static int32_t param2_init[] = {2};
737 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
738 static float param3_init[] = {2.0f};
739 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
740 static float param4_init[] = {2.0f};
741 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
742 static int32_t param5_init[] = {4};
743 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
744 static int32_t param6_init[] = {4};
745 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
746 static bool8 layout_init[] = {true};
747 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
748 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
749 // Phase 3, inputs and outputs
750 model->identifyInputsAndOutputs(
751 {in, roi},
752 {out});
753 assert(model->isValid());
754 }
755
is_ignored_dynamic_output_shape_nchw_quant8(int i)756 inline bool is_ignored_dynamic_output_shape_nchw_quant8(int i) {
757 static std::set<int> ignore = {};
758 return ignore.find(i) != ignore.end();
759 }
760
CreateModel_dynamic_output_shape_nchw_float16(Model * model)761 void CreateModel_dynamic_output_shape_nchw_float16(Model *model) {
762 OperandType type0(Type::BOOL, {});
763 OperandType type30(Type::FLOAT16, {});
764 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
765 OperandType type36(Type::TENSOR_FLOAT16, {1, 1, 4, 4});
766 OperandType type4(Type::TENSOR_INT32, {4});
767 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
768 OperandType type5(Type::INT32, {});
769 // Phase 1, operands
770 auto in = model->addOperand(&type36);
771 auto roi = model->addOperand(&type31);
772 auto param = model->addOperand(&type4);
773 auto param1 = model->addOperand(&type5);
774 auto param2 = model->addOperand(&type5);
775 auto param3 = model->addOperand(&type30);
776 auto param4 = model->addOperand(&type30);
777 auto param5 = model->addOperand(&type5);
778 auto param6 = model->addOperand(&type5);
779 auto layout = model->addOperand(&type0);
780 auto out = model->addOperand(&type40);
781 // Phase 2, operations
782 static int32_t param_init[] = {0, 0, 0, 0};
783 model->setOperandValue(param, param_init, sizeof(int32_t) * 4);
784 static int32_t param1_init[] = {2};
785 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
786 static int32_t param2_init[] = {2};
787 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
788 static _Float16 param3_init[] = {2.0f};
789 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
790 static _Float16 param4_init[] = {2.0f};
791 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
792 static int32_t param5_init[] = {4};
793 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
794 static int32_t param6_init[] = {4};
795 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
796 static bool8 layout_init[] = {true};
797 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
798 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roi, param, param1, param2, param3, param4, param5, param6, layout}, {out});
799 // Phase 3, inputs and outputs
800 model->identifyInputsAndOutputs(
801 {in, roi},
802 {out});
803 assert(model->isValid());
804 }
805
is_ignored_dynamic_output_shape_nchw_float16(int i)806 inline bool is_ignored_dynamic_output_shape_nchw_float16(int i) {
807 static std::set<int> ignore = {};
808 return ignore.find(i) != ignore.end();
809 }
810
CreateModel_nhwc_2(Model * model)811 void CreateModel_nhwc_2(Model *model) {
812 OperandType type0(Type::BOOL, {});
813 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
814 OperandType type4(Type::TENSOR_INT32, {4});
815 OperandType type5(Type::INT32, {});
816 OperandType type6(Type::FLOAT32, {});
817 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
818 OperandType type8(Type::TENSOR_FLOAT32, {4, 2, 3, 2});
819 // Phase 1, operands
820 auto in1 = model->addOperand(&type7);
821 auto roi1 = model->addOperand(&type2);
822 auto param7 = model->addOperand(&type4);
823 auto param8 = model->addOperand(&type5);
824 auto param9 = model->addOperand(&type5);
825 auto param10 = model->addOperand(&type6);
826 auto param11 = model->addOperand(&type6);
827 auto param12 = model->addOperand(&type5);
828 auto param13 = model->addOperand(&type5);
829 auto layout = model->addOperand(&type0);
830 auto out1 = model->addOperand(&type8);
831 // Phase 2, operations
832 static int32_t param7_init[] = {0, 0, 3, 3};
833 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
834 static int32_t param8_init[] = {2};
835 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
836 static int32_t param9_init[] = {3};
837 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
838 static float param10_init[] = {4.0f};
839 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
840 static float param11_init[] = {4.0f};
841 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
842 static int32_t param12_init[] = {4};
843 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
844 static int32_t param13_init[] = {4};
845 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
846 static bool8 layout_init[] = {false};
847 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
848 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
849 // Phase 3, inputs and outputs
850 model->identifyInputsAndOutputs(
851 {in1, roi1},
852 {out1});
853 assert(model->isValid());
854 }
855
is_ignored_nhwc_2(int i)856 inline bool is_ignored_nhwc_2(int i) {
857 static std::set<int> ignore = {};
858 return ignore.find(i) != ignore.end();
859 }
860
CreateModel_nhwc_relaxed_2(Model * model)861 void CreateModel_nhwc_relaxed_2(Model *model) {
862 OperandType type0(Type::BOOL, {});
863 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
864 OperandType type4(Type::TENSOR_INT32, {4});
865 OperandType type5(Type::INT32, {});
866 OperandType type6(Type::FLOAT32, {});
867 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
868 OperandType type8(Type::TENSOR_FLOAT32, {4, 2, 3, 2});
869 // Phase 1, operands
870 auto in1 = model->addOperand(&type7);
871 auto roi1 = model->addOperand(&type2);
872 auto param7 = model->addOperand(&type4);
873 auto param8 = model->addOperand(&type5);
874 auto param9 = model->addOperand(&type5);
875 auto param10 = model->addOperand(&type6);
876 auto param11 = model->addOperand(&type6);
877 auto param12 = model->addOperand(&type5);
878 auto param13 = model->addOperand(&type5);
879 auto layout = model->addOperand(&type0);
880 auto out1 = model->addOperand(&type8);
881 // Phase 2, operations
882 static int32_t param7_init[] = {0, 0, 3, 3};
883 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
884 static int32_t param8_init[] = {2};
885 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
886 static int32_t param9_init[] = {3};
887 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
888 static float param10_init[] = {4.0f};
889 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
890 static float param11_init[] = {4.0f};
891 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
892 static int32_t param12_init[] = {4};
893 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
894 static int32_t param13_init[] = {4};
895 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
896 static bool8 layout_init[] = {false};
897 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
898 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
899 // Phase 3, inputs and outputs
900 model->identifyInputsAndOutputs(
901 {in1, roi1},
902 {out1});
903 // Phase 4: set relaxed execution
904 model->relaxComputationFloat32toFloat16(true);
905 assert(model->isValid());
906 }
907
is_ignored_nhwc_relaxed_2(int i)908 inline bool is_ignored_nhwc_relaxed_2(int i) {
909 static std::set<int> ignore = {};
910 return ignore.find(i) != ignore.end();
911 }
912
CreateModel_nhwc_quant8_2(Model * model)913 void CreateModel_nhwc_quant8_2(Model *model) {
914 OperandType type0(Type::BOOL, {});
915 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
916 OperandType type4(Type::TENSOR_INT32, {4});
917 OperandType type41(Type::TENSOR_QUANT8_ASYMM, {4, 4, 8, 2}, 0.04f, 0);
918 OperandType type42(Type::TENSOR_QUANT8_ASYMM, {4, 2, 3, 2}, 0.03125f, 10);
919 OperandType type5(Type::INT32, {});
920 OperandType type6(Type::FLOAT32, {});
921 // Phase 1, operands
922 auto in1 = model->addOperand(&type41);
923 auto roi1 = model->addOperand(&type27);
924 auto param7 = model->addOperand(&type4);
925 auto param8 = model->addOperand(&type5);
926 auto param9 = model->addOperand(&type5);
927 auto param10 = model->addOperand(&type6);
928 auto param11 = model->addOperand(&type6);
929 auto param12 = model->addOperand(&type5);
930 auto param13 = model->addOperand(&type5);
931 auto layout = model->addOperand(&type0);
932 auto out1 = model->addOperand(&type42);
933 // Phase 2, operations
934 static int32_t param7_init[] = {0, 0, 3, 3};
935 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
936 static int32_t param8_init[] = {2};
937 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
938 static int32_t param9_init[] = {3};
939 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
940 static float param10_init[] = {4.0f};
941 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
942 static float param11_init[] = {4.0f};
943 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
944 static int32_t param12_init[] = {4};
945 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
946 static int32_t param13_init[] = {4};
947 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
948 static bool8 layout_init[] = {false};
949 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
950 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
951 // Phase 3, inputs and outputs
952 model->identifyInputsAndOutputs(
953 {in1, roi1},
954 {out1});
955 assert(model->isValid());
956 }
957
is_ignored_nhwc_quant8_2(int i)958 inline bool is_ignored_nhwc_quant8_2(int i) {
959 static std::set<int> ignore = {};
960 return ignore.find(i) != ignore.end();
961 }
962
CreateModel_nhwc_float16_2(Model * model)963 void CreateModel_nhwc_float16_2(Model *model) {
964 OperandType type0(Type::BOOL, {});
965 OperandType type30(Type::FLOAT16, {});
966 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
967 OperandType type4(Type::TENSOR_INT32, {4});
968 OperandType type43(Type::TENSOR_FLOAT16, {4, 4, 8, 2});
969 OperandType type44(Type::TENSOR_FLOAT16, {4, 2, 3, 2});
970 OperandType type5(Type::INT32, {});
971 // Phase 1, operands
972 auto in1 = model->addOperand(&type43);
973 auto roi1 = model->addOperand(&type31);
974 auto param7 = model->addOperand(&type4);
975 auto param8 = model->addOperand(&type5);
976 auto param9 = model->addOperand(&type5);
977 auto param10 = model->addOperand(&type30);
978 auto param11 = model->addOperand(&type30);
979 auto param12 = model->addOperand(&type5);
980 auto param13 = model->addOperand(&type5);
981 auto layout = model->addOperand(&type0);
982 auto out1 = model->addOperand(&type44);
983 // Phase 2, operations
984 static int32_t param7_init[] = {0, 0, 3, 3};
985 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
986 static int32_t param8_init[] = {2};
987 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
988 static int32_t param9_init[] = {3};
989 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
990 static _Float16 param10_init[] = {4.0f};
991 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
992 static _Float16 param11_init[] = {4.0f};
993 model->setOperandValue(param11, param11_init, sizeof(_Float16) * 1);
994 static int32_t param12_init[] = {4};
995 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
996 static int32_t param13_init[] = {4};
997 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
998 static bool8 layout_init[] = {false};
999 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1000 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1001 // Phase 3, inputs and outputs
1002 model->identifyInputsAndOutputs(
1003 {in1, roi1},
1004 {out1});
1005 assert(model->isValid());
1006 }
1007
is_ignored_nhwc_float16_2(int i)1008 inline bool is_ignored_nhwc_float16_2(int i) {
1009 static std::set<int> ignore = {};
1010 return ignore.find(i) != ignore.end();
1011 }
1012
CreateModel_nchw_2(Model * model)1013 void CreateModel_nchw_2(Model *model) {
1014 OperandType type0(Type::BOOL, {});
1015 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1016 OperandType type4(Type::TENSOR_INT32, {4});
1017 OperandType type45(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
1018 OperandType type46(Type::TENSOR_FLOAT32, {4, 2, 2, 3});
1019 OperandType type5(Type::INT32, {});
1020 OperandType type6(Type::FLOAT32, {});
1021 // Phase 1, operands
1022 auto in1 = model->addOperand(&type45);
1023 auto roi1 = model->addOperand(&type2);
1024 auto param7 = model->addOperand(&type4);
1025 auto param8 = model->addOperand(&type5);
1026 auto param9 = model->addOperand(&type5);
1027 auto param10 = model->addOperand(&type6);
1028 auto param11 = model->addOperand(&type6);
1029 auto param12 = model->addOperand(&type5);
1030 auto param13 = model->addOperand(&type5);
1031 auto layout = model->addOperand(&type0);
1032 auto out1 = model->addOperand(&type46);
1033 // Phase 2, operations
1034 static int32_t param7_init[] = {0, 0, 3, 3};
1035 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1036 static int32_t param8_init[] = {2};
1037 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1038 static int32_t param9_init[] = {3};
1039 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1040 static float param10_init[] = {4.0f};
1041 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1042 static float param11_init[] = {4.0f};
1043 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1044 static int32_t param12_init[] = {4};
1045 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1046 static int32_t param13_init[] = {4};
1047 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1048 static bool8 layout_init[] = {true};
1049 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1050 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1051 // Phase 3, inputs and outputs
1052 model->identifyInputsAndOutputs(
1053 {in1, roi1},
1054 {out1});
1055 assert(model->isValid());
1056 }
1057
is_ignored_nchw_2(int i)1058 inline bool is_ignored_nchw_2(int i) {
1059 static std::set<int> ignore = {};
1060 return ignore.find(i) != ignore.end();
1061 }
1062
CreateModel_nchw_relaxed_2(Model * model)1063 void CreateModel_nchw_relaxed_2(Model *model) {
1064 OperandType type0(Type::BOOL, {});
1065 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1066 OperandType type4(Type::TENSOR_INT32, {4});
1067 OperandType type45(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
1068 OperandType type46(Type::TENSOR_FLOAT32, {4, 2, 2, 3});
1069 OperandType type5(Type::INT32, {});
1070 OperandType type6(Type::FLOAT32, {});
1071 // Phase 1, operands
1072 auto in1 = model->addOperand(&type45);
1073 auto roi1 = model->addOperand(&type2);
1074 auto param7 = model->addOperand(&type4);
1075 auto param8 = model->addOperand(&type5);
1076 auto param9 = model->addOperand(&type5);
1077 auto param10 = model->addOperand(&type6);
1078 auto param11 = model->addOperand(&type6);
1079 auto param12 = model->addOperand(&type5);
1080 auto param13 = model->addOperand(&type5);
1081 auto layout = model->addOperand(&type0);
1082 auto out1 = model->addOperand(&type46);
1083 // Phase 2, operations
1084 static int32_t param7_init[] = {0, 0, 3, 3};
1085 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1086 static int32_t param8_init[] = {2};
1087 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1088 static int32_t param9_init[] = {3};
1089 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1090 static float param10_init[] = {4.0f};
1091 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1092 static float param11_init[] = {4.0f};
1093 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1094 static int32_t param12_init[] = {4};
1095 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1096 static int32_t param13_init[] = {4};
1097 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1098 static bool8 layout_init[] = {true};
1099 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1100 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1101 // Phase 3, inputs and outputs
1102 model->identifyInputsAndOutputs(
1103 {in1, roi1},
1104 {out1});
1105 // Phase 4: set relaxed execution
1106 model->relaxComputationFloat32toFloat16(true);
1107 assert(model->isValid());
1108 }
1109
is_ignored_nchw_relaxed_2(int i)1110 inline bool is_ignored_nchw_relaxed_2(int i) {
1111 static std::set<int> ignore = {};
1112 return ignore.find(i) != ignore.end();
1113 }
1114
CreateModel_nchw_quant8_2(Model * model)1115 void CreateModel_nchw_quant8_2(Model *model) {
1116 OperandType type0(Type::BOOL, {});
1117 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1118 OperandType type4(Type::TENSOR_INT32, {4});
1119 OperandType type47(Type::TENSOR_QUANT8_ASYMM, {4, 2, 4, 8}, 0.04f, 0);
1120 OperandType type48(Type::TENSOR_QUANT8_ASYMM, {4, 2, 2, 3}, 0.03125f, 10);
1121 OperandType type5(Type::INT32, {});
1122 OperandType type6(Type::FLOAT32, {});
1123 // Phase 1, operands
1124 auto in1 = model->addOperand(&type47);
1125 auto roi1 = model->addOperand(&type27);
1126 auto param7 = model->addOperand(&type4);
1127 auto param8 = model->addOperand(&type5);
1128 auto param9 = model->addOperand(&type5);
1129 auto param10 = model->addOperand(&type6);
1130 auto param11 = model->addOperand(&type6);
1131 auto param12 = model->addOperand(&type5);
1132 auto param13 = model->addOperand(&type5);
1133 auto layout = model->addOperand(&type0);
1134 auto out1 = model->addOperand(&type48);
1135 // Phase 2, operations
1136 static int32_t param7_init[] = {0, 0, 3, 3};
1137 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1138 static int32_t param8_init[] = {2};
1139 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1140 static int32_t param9_init[] = {3};
1141 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1142 static float param10_init[] = {4.0f};
1143 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1144 static float param11_init[] = {4.0f};
1145 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1146 static int32_t param12_init[] = {4};
1147 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1148 static int32_t param13_init[] = {4};
1149 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1150 static bool8 layout_init[] = {true};
1151 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1152 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1153 // Phase 3, inputs and outputs
1154 model->identifyInputsAndOutputs(
1155 {in1, roi1},
1156 {out1});
1157 assert(model->isValid());
1158 }
1159
is_ignored_nchw_quant8_2(int i)1160 inline bool is_ignored_nchw_quant8_2(int i) {
1161 static std::set<int> ignore = {};
1162 return ignore.find(i) != ignore.end();
1163 }
1164
CreateModel_nchw_float16_2(Model * model)1165 void CreateModel_nchw_float16_2(Model *model) {
1166 OperandType type0(Type::BOOL, {});
1167 OperandType type30(Type::FLOAT16, {});
1168 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
1169 OperandType type4(Type::TENSOR_INT32, {4});
1170 OperandType type49(Type::TENSOR_FLOAT16, {4, 2, 4, 8});
1171 OperandType type5(Type::INT32, {});
1172 OperandType type50(Type::TENSOR_FLOAT16, {4, 2, 2, 3});
1173 // Phase 1, operands
1174 auto in1 = model->addOperand(&type49);
1175 auto roi1 = model->addOperand(&type31);
1176 auto param7 = model->addOperand(&type4);
1177 auto param8 = model->addOperand(&type5);
1178 auto param9 = model->addOperand(&type5);
1179 auto param10 = model->addOperand(&type30);
1180 auto param11 = model->addOperand(&type30);
1181 auto param12 = model->addOperand(&type5);
1182 auto param13 = model->addOperand(&type5);
1183 auto layout = model->addOperand(&type0);
1184 auto out1 = model->addOperand(&type50);
1185 // Phase 2, operations
1186 static int32_t param7_init[] = {0, 0, 3, 3};
1187 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1188 static int32_t param8_init[] = {2};
1189 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1190 static int32_t param9_init[] = {3};
1191 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1192 static _Float16 param10_init[] = {4.0f};
1193 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
1194 static _Float16 param11_init[] = {4.0f};
1195 model->setOperandValue(param11, param11_init, sizeof(_Float16) * 1);
1196 static int32_t param12_init[] = {4};
1197 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1198 static int32_t param13_init[] = {4};
1199 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1200 static bool8 layout_init[] = {true};
1201 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1202 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1203 // Phase 3, inputs and outputs
1204 model->identifyInputsAndOutputs(
1205 {in1, roi1},
1206 {out1});
1207 assert(model->isValid());
1208 }
1209
is_ignored_nchw_float16_2(int i)1210 inline bool is_ignored_nchw_float16_2(int i) {
1211 static std::set<int> ignore = {};
1212 return ignore.find(i) != ignore.end();
1213 }
1214
CreateModel_dynamic_output_shape_nhwc_2(Model * model)1215 void CreateModel_dynamic_output_shape_nhwc_2(Model *model) {
1216 OperandType type0(Type::BOOL, {});
1217 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1218 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1219 OperandType type4(Type::TENSOR_INT32, {4});
1220 OperandType type5(Type::INT32, {});
1221 OperandType type6(Type::FLOAT32, {});
1222 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
1223 // Phase 1, operands
1224 auto in1 = model->addOperand(&type7);
1225 auto roi1 = model->addOperand(&type2);
1226 auto param7 = model->addOperand(&type4);
1227 auto param8 = model->addOperand(&type5);
1228 auto param9 = model->addOperand(&type5);
1229 auto param10 = model->addOperand(&type6);
1230 auto param11 = model->addOperand(&type6);
1231 auto param12 = model->addOperand(&type5);
1232 auto param13 = model->addOperand(&type5);
1233 auto layout = model->addOperand(&type0);
1234 auto out1 = model->addOperand(&type38);
1235 // Phase 2, operations
1236 static int32_t param7_init[] = {0, 0, 3, 3};
1237 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1238 static int32_t param8_init[] = {2};
1239 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1240 static int32_t param9_init[] = {3};
1241 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1242 static float param10_init[] = {4.0f};
1243 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1244 static float param11_init[] = {4.0f};
1245 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1246 static int32_t param12_init[] = {4};
1247 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1248 static int32_t param13_init[] = {4};
1249 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1250 static bool8 layout_init[] = {false};
1251 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1252 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1253 // Phase 3, inputs and outputs
1254 model->identifyInputsAndOutputs(
1255 {in1, roi1},
1256 {out1});
1257 assert(model->isValid());
1258 }
1259
is_ignored_dynamic_output_shape_nhwc_2(int i)1260 inline bool is_ignored_dynamic_output_shape_nhwc_2(int i) {
1261 static std::set<int> ignore = {};
1262 return ignore.find(i) != ignore.end();
1263 }
1264
CreateModel_dynamic_output_shape_nhwc_relaxed_2(Model * model)1265 void CreateModel_dynamic_output_shape_nhwc_relaxed_2(Model *model) {
1266 OperandType type0(Type::BOOL, {});
1267 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1268 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1269 OperandType type4(Type::TENSOR_INT32, {4});
1270 OperandType type5(Type::INT32, {});
1271 OperandType type6(Type::FLOAT32, {});
1272 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
1273 // Phase 1, operands
1274 auto in1 = model->addOperand(&type7);
1275 auto roi1 = model->addOperand(&type2);
1276 auto param7 = model->addOperand(&type4);
1277 auto param8 = model->addOperand(&type5);
1278 auto param9 = model->addOperand(&type5);
1279 auto param10 = model->addOperand(&type6);
1280 auto param11 = model->addOperand(&type6);
1281 auto param12 = model->addOperand(&type5);
1282 auto param13 = model->addOperand(&type5);
1283 auto layout = model->addOperand(&type0);
1284 auto out1 = model->addOperand(&type38);
1285 // Phase 2, operations
1286 static int32_t param7_init[] = {0, 0, 3, 3};
1287 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1288 static int32_t param8_init[] = {2};
1289 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1290 static int32_t param9_init[] = {3};
1291 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1292 static float param10_init[] = {4.0f};
1293 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1294 static float param11_init[] = {4.0f};
1295 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1296 static int32_t param12_init[] = {4};
1297 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1298 static int32_t param13_init[] = {4};
1299 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1300 static bool8 layout_init[] = {false};
1301 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1302 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1303 // Phase 3, inputs and outputs
1304 model->identifyInputsAndOutputs(
1305 {in1, roi1},
1306 {out1});
1307 // Phase 4: set relaxed execution
1308 model->relaxComputationFloat32toFloat16(true);
1309 assert(model->isValid());
1310 }
1311
is_ignored_dynamic_output_shape_nhwc_relaxed_2(int i)1312 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_2(int i) {
1313 static std::set<int> ignore = {};
1314 return ignore.find(i) != ignore.end();
1315 }
1316
CreateModel_dynamic_output_shape_nhwc_quant8_2(Model * model)1317 void CreateModel_dynamic_output_shape_nhwc_quant8_2(Model *model) {
1318 OperandType type0(Type::BOOL, {});
1319 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1320 OperandType type4(Type::TENSOR_INT32, {4});
1321 OperandType type41(Type::TENSOR_QUANT8_ASYMM, {4, 4, 8, 2}, 0.04f, 0);
1322 OperandType type5(Type::INT32, {});
1323 OperandType type51(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.03125f, 10);
1324 OperandType type6(Type::FLOAT32, {});
1325 // Phase 1, operands
1326 auto in1 = model->addOperand(&type41);
1327 auto roi1 = model->addOperand(&type27);
1328 auto param7 = model->addOperand(&type4);
1329 auto param8 = model->addOperand(&type5);
1330 auto param9 = model->addOperand(&type5);
1331 auto param10 = model->addOperand(&type6);
1332 auto param11 = model->addOperand(&type6);
1333 auto param12 = model->addOperand(&type5);
1334 auto param13 = model->addOperand(&type5);
1335 auto layout = model->addOperand(&type0);
1336 auto out1 = model->addOperand(&type51);
1337 // Phase 2, operations
1338 static int32_t param7_init[] = {0, 0, 3, 3};
1339 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1340 static int32_t param8_init[] = {2};
1341 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1342 static int32_t param9_init[] = {3};
1343 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1344 static float param10_init[] = {4.0f};
1345 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1346 static float param11_init[] = {4.0f};
1347 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1348 static int32_t param12_init[] = {4};
1349 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1350 static int32_t param13_init[] = {4};
1351 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1352 static bool8 layout_init[] = {false};
1353 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1354 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1355 // Phase 3, inputs and outputs
1356 model->identifyInputsAndOutputs(
1357 {in1, roi1},
1358 {out1});
1359 assert(model->isValid());
1360 }
1361
is_ignored_dynamic_output_shape_nhwc_quant8_2(int i)1362 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_2(int i) {
1363 static std::set<int> ignore = {};
1364 return ignore.find(i) != ignore.end();
1365 }
1366
CreateModel_dynamic_output_shape_nhwc_float16_2(Model * model)1367 void CreateModel_dynamic_output_shape_nhwc_float16_2(Model *model) {
1368 OperandType type0(Type::BOOL, {});
1369 OperandType type30(Type::FLOAT16, {});
1370 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
1371 OperandType type4(Type::TENSOR_INT32, {4});
1372 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
1373 OperandType type43(Type::TENSOR_FLOAT16, {4, 4, 8, 2});
1374 OperandType type5(Type::INT32, {});
1375 // Phase 1, operands
1376 auto in1 = model->addOperand(&type43);
1377 auto roi1 = model->addOperand(&type31);
1378 auto param7 = model->addOperand(&type4);
1379 auto param8 = model->addOperand(&type5);
1380 auto param9 = model->addOperand(&type5);
1381 auto param10 = model->addOperand(&type30);
1382 auto param11 = model->addOperand(&type30);
1383 auto param12 = model->addOperand(&type5);
1384 auto param13 = model->addOperand(&type5);
1385 auto layout = model->addOperand(&type0);
1386 auto out1 = model->addOperand(&type40);
1387 // Phase 2, operations
1388 static int32_t param7_init[] = {0, 0, 3, 3};
1389 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1390 static int32_t param8_init[] = {2};
1391 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1392 static int32_t param9_init[] = {3};
1393 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1394 static _Float16 param10_init[] = {4.0f};
1395 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
1396 static _Float16 param11_init[] = {4.0f};
1397 model->setOperandValue(param11, param11_init, sizeof(_Float16) * 1);
1398 static int32_t param12_init[] = {4};
1399 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1400 static int32_t param13_init[] = {4};
1401 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1402 static bool8 layout_init[] = {false};
1403 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1404 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1405 // Phase 3, inputs and outputs
1406 model->identifyInputsAndOutputs(
1407 {in1, roi1},
1408 {out1});
1409 assert(model->isValid());
1410 }
1411
is_ignored_dynamic_output_shape_nhwc_float16_2(int i)1412 inline bool is_ignored_dynamic_output_shape_nhwc_float16_2(int i) {
1413 static std::set<int> ignore = {};
1414 return ignore.find(i) != ignore.end();
1415 }
1416
CreateModel_dynamic_output_shape_nchw_2(Model * model)1417 void CreateModel_dynamic_output_shape_nchw_2(Model *model) {
1418 OperandType type0(Type::BOOL, {});
1419 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1420 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1421 OperandType type4(Type::TENSOR_INT32, {4});
1422 OperandType type45(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
1423 OperandType type5(Type::INT32, {});
1424 OperandType type6(Type::FLOAT32, {});
1425 // Phase 1, operands
1426 auto in1 = model->addOperand(&type45);
1427 auto roi1 = model->addOperand(&type2);
1428 auto param7 = model->addOperand(&type4);
1429 auto param8 = model->addOperand(&type5);
1430 auto param9 = model->addOperand(&type5);
1431 auto param10 = model->addOperand(&type6);
1432 auto param11 = model->addOperand(&type6);
1433 auto param12 = model->addOperand(&type5);
1434 auto param13 = model->addOperand(&type5);
1435 auto layout = model->addOperand(&type0);
1436 auto out1 = model->addOperand(&type38);
1437 // Phase 2, operations
1438 static int32_t param7_init[] = {0, 0, 3, 3};
1439 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1440 static int32_t param8_init[] = {2};
1441 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1442 static int32_t param9_init[] = {3};
1443 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1444 static float param10_init[] = {4.0f};
1445 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1446 static float param11_init[] = {4.0f};
1447 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1448 static int32_t param12_init[] = {4};
1449 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1450 static int32_t param13_init[] = {4};
1451 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1452 static bool8 layout_init[] = {true};
1453 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1454 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1455 // Phase 3, inputs and outputs
1456 model->identifyInputsAndOutputs(
1457 {in1, roi1},
1458 {out1});
1459 assert(model->isValid());
1460 }
1461
is_ignored_dynamic_output_shape_nchw_2(int i)1462 inline bool is_ignored_dynamic_output_shape_nchw_2(int i) {
1463 static std::set<int> ignore = {};
1464 return ignore.find(i) != ignore.end();
1465 }
1466
CreateModel_dynamic_output_shape_nchw_relaxed_2(Model * model)1467 void CreateModel_dynamic_output_shape_nchw_relaxed_2(Model *model) {
1468 OperandType type0(Type::BOOL, {});
1469 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1470 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1471 OperandType type4(Type::TENSOR_INT32, {4});
1472 OperandType type45(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
1473 OperandType type5(Type::INT32, {});
1474 OperandType type6(Type::FLOAT32, {});
1475 // Phase 1, operands
1476 auto in1 = model->addOperand(&type45);
1477 auto roi1 = model->addOperand(&type2);
1478 auto param7 = model->addOperand(&type4);
1479 auto param8 = model->addOperand(&type5);
1480 auto param9 = model->addOperand(&type5);
1481 auto param10 = model->addOperand(&type6);
1482 auto param11 = model->addOperand(&type6);
1483 auto param12 = model->addOperand(&type5);
1484 auto param13 = model->addOperand(&type5);
1485 auto layout = model->addOperand(&type0);
1486 auto out1 = model->addOperand(&type38);
1487 // Phase 2, operations
1488 static int32_t param7_init[] = {0, 0, 3, 3};
1489 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1490 static int32_t param8_init[] = {2};
1491 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1492 static int32_t param9_init[] = {3};
1493 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1494 static float param10_init[] = {4.0f};
1495 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1496 static float param11_init[] = {4.0f};
1497 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1498 static int32_t param12_init[] = {4};
1499 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1500 static int32_t param13_init[] = {4};
1501 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1502 static bool8 layout_init[] = {true};
1503 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1504 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1505 // Phase 3, inputs and outputs
1506 model->identifyInputsAndOutputs(
1507 {in1, roi1},
1508 {out1});
1509 // Phase 4: set relaxed execution
1510 model->relaxComputationFloat32toFloat16(true);
1511 assert(model->isValid());
1512 }
1513
is_ignored_dynamic_output_shape_nchw_relaxed_2(int i)1514 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_2(int i) {
1515 static std::set<int> ignore = {};
1516 return ignore.find(i) != ignore.end();
1517 }
1518
CreateModel_dynamic_output_shape_nchw_quant8_2(Model * model)1519 void CreateModel_dynamic_output_shape_nchw_quant8_2(Model *model) {
1520 OperandType type0(Type::BOOL, {});
1521 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1522 OperandType type4(Type::TENSOR_INT32, {4});
1523 OperandType type47(Type::TENSOR_QUANT8_ASYMM, {4, 2, 4, 8}, 0.04f, 0);
1524 OperandType type5(Type::INT32, {});
1525 OperandType type51(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.03125f, 10);
1526 OperandType type6(Type::FLOAT32, {});
1527 // Phase 1, operands
1528 auto in1 = model->addOperand(&type47);
1529 auto roi1 = model->addOperand(&type27);
1530 auto param7 = model->addOperand(&type4);
1531 auto param8 = model->addOperand(&type5);
1532 auto param9 = model->addOperand(&type5);
1533 auto param10 = model->addOperand(&type6);
1534 auto param11 = model->addOperand(&type6);
1535 auto param12 = model->addOperand(&type5);
1536 auto param13 = model->addOperand(&type5);
1537 auto layout = model->addOperand(&type0);
1538 auto out1 = model->addOperand(&type51);
1539 // Phase 2, operations
1540 static int32_t param7_init[] = {0, 0, 3, 3};
1541 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1542 static int32_t param8_init[] = {2};
1543 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1544 static int32_t param9_init[] = {3};
1545 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1546 static float param10_init[] = {4.0f};
1547 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
1548 static float param11_init[] = {4.0f};
1549 model->setOperandValue(param11, param11_init, sizeof(float) * 1);
1550 static int32_t param12_init[] = {4};
1551 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1552 static int32_t param13_init[] = {4};
1553 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1554 static bool8 layout_init[] = {true};
1555 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1556 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1557 // Phase 3, inputs and outputs
1558 model->identifyInputsAndOutputs(
1559 {in1, roi1},
1560 {out1});
1561 assert(model->isValid());
1562 }
1563
is_ignored_dynamic_output_shape_nchw_quant8_2(int i)1564 inline bool is_ignored_dynamic_output_shape_nchw_quant8_2(int i) {
1565 static std::set<int> ignore = {};
1566 return ignore.find(i) != ignore.end();
1567 }
1568
CreateModel_dynamic_output_shape_nchw_float16_2(Model * model)1569 void CreateModel_dynamic_output_shape_nchw_float16_2(Model *model) {
1570 OperandType type0(Type::BOOL, {});
1571 OperandType type30(Type::FLOAT16, {});
1572 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
1573 OperandType type4(Type::TENSOR_INT32, {4});
1574 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
1575 OperandType type49(Type::TENSOR_FLOAT16, {4, 2, 4, 8});
1576 OperandType type5(Type::INT32, {});
1577 // Phase 1, operands
1578 auto in1 = model->addOperand(&type49);
1579 auto roi1 = model->addOperand(&type31);
1580 auto param7 = model->addOperand(&type4);
1581 auto param8 = model->addOperand(&type5);
1582 auto param9 = model->addOperand(&type5);
1583 auto param10 = model->addOperand(&type30);
1584 auto param11 = model->addOperand(&type30);
1585 auto param12 = model->addOperand(&type5);
1586 auto param13 = model->addOperand(&type5);
1587 auto layout = model->addOperand(&type0);
1588 auto out1 = model->addOperand(&type40);
1589 // Phase 2, operations
1590 static int32_t param7_init[] = {0, 0, 3, 3};
1591 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 4);
1592 static int32_t param8_init[] = {2};
1593 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
1594 static int32_t param9_init[] = {3};
1595 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
1596 static _Float16 param10_init[] = {4.0f};
1597 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
1598 static _Float16 param11_init[] = {4.0f};
1599 model->setOperandValue(param11, param11_init, sizeof(_Float16) * 1);
1600 static int32_t param12_init[] = {4};
1601 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1602 static int32_t param13_init[] = {4};
1603 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
1604 static bool8 layout_init[] = {true};
1605 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1606 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in1, roi1, param7, param8, param9, param10, param11, param12, param13, layout}, {out1});
1607 // Phase 3, inputs and outputs
1608 model->identifyInputsAndOutputs(
1609 {in1, roi1},
1610 {out1});
1611 assert(model->isValid());
1612 }
1613
is_ignored_dynamic_output_shape_nchw_float16_2(int i)1614 inline bool is_ignored_dynamic_output_shape_nchw_float16_2(int i) {
1615 static std::set<int> ignore = {};
1616 return ignore.find(i) != ignore.end();
1617 }
1618
CreateModel_nhwc_3(Model * model)1619 void CreateModel_nhwc_3(Model *model) {
1620 OperandType type0(Type::BOOL, {});
1621 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1622 OperandType type4(Type::TENSOR_INT32, {4});
1623 OperandType type5(Type::INT32, {});
1624 OperandType type6(Type::FLOAT32, {});
1625 OperandType type8(Type::TENSOR_FLOAT32, {4, 2, 3, 2});
1626 OperandType type9(Type::TENSOR_FLOAT32, {2, 4, 8, 2});
1627 // Phase 1, operands
1628 auto in2 = model->addOperand(&type9);
1629 auto roi2 = model->addOperand(&type2);
1630 auto param14 = model->addOperand(&type4);
1631 auto param15 = model->addOperand(&type5);
1632 auto param16 = model->addOperand(&type5);
1633 auto param17 = model->addOperand(&type6);
1634 auto param18 = model->addOperand(&type6);
1635 auto param19 = model->addOperand(&type5);
1636 auto param20 = model->addOperand(&type5);
1637 auto layout = model->addOperand(&type0);
1638 auto out2 = model->addOperand(&type8);
1639 // Phase 2, operations
1640 static int32_t param14_init[] = {0, 0, 1, 1};
1641 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1642 static int32_t param15_init[] = {2};
1643 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1644 static int32_t param16_init[] = {3};
1645 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1646 static float param17_init[] = {4.0f};
1647 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
1648 static float param18_init[] = {4.0f};
1649 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1650 static int32_t param19_init[] = {0};
1651 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1652 static int32_t param20_init[] = {0};
1653 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1654 static bool8 layout_init[] = {false};
1655 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1656 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1657 // Phase 3, inputs and outputs
1658 model->identifyInputsAndOutputs(
1659 {in2, roi2},
1660 {out2});
1661 assert(model->isValid());
1662 }
1663
is_ignored_nhwc_3(int i)1664 inline bool is_ignored_nhwc_3(int i) {
1665 static std::set<int> ignore = {};
1666 return ignore.find(i) != ignore.end();
1667 }
1668
CreateModel_nhwc_relaxed_3(Model * model)1669 void CreateModel_nhwc_relaxed_3(Model *model) {
1670 OperandType type0(Type::BOOL, {});
1671 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1672 OperandType type4(Type::TENSOR_INT32, {4});
1673 OperandType type5(Type::INT32, {});
1674 OperandType type6(Type::FLOAT32, {});
1675 OperandType type8(Type::TENSOR_FLOAT32, {4, 2, 3, 2});
1676 OperandType type9(Type::TENSOR_FLOAT32, {2, 4, 8, 2});
1677 // Phase 1, operands
1678 auto in2 = model->addOperand(&type9);
1679 auto roi2 = model->addOperand(&type2);
1680 auto param14 = model->addOperand(&type4);
1681 auto param15 = model->addOperand(&type5);
1682 auto param16 = model->addOperand(&type5);
1683 auto param17 = model->addOperand(&type6);
1684 auto param18 = model->addOperand(&type6);
1685 auto param19 = model->addOperand(&type5);
1686 auto param20 = model->addOperand(&type5);
1687 auto layout = model->addOperand(&type0);
1688 auto out2 = model->addOperand(&type8);
1689 // Phase 2, operations
1690 static int32_t param14_init[] = {0, 0, 1, 1};
1691 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1692 static int32_t param15_init[] = {2};
1693 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1694 static int32_t param16_init[] = {3};
1695 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1696 static float param17_init[] = {4.0f};
1697 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
1698 static float param18_init[] = {4.0f};
1699 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1700 static int32_t param19_init[] = {0};
1701 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1702 static int32_t param20_init[] = {0};
1703 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1704 static bool8 layout_init[] = {false};
1705 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1706 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1707 // Phase 3, inputs and outputs
1708 model->identifyInputsAndOutputs(
1709 {in2, roi2},
1710 {out2});
1711 // Phase 4: set relaxed execution
1712 model->relaxComputationFloat32toFloat16(true);
1713 assert(model->isValid());
1714 }
1715
is_ignored_nhwc_relaxed_3(int i)1716 inline bool is_ignored_nhwc_relaxed_3(int i) {
1717 static std::set<int> ignore = {};
1718 return ignore.find(i) != ignore.end();
1719 }
1720
CreateModel_nhwc_quant8_3(Model * model)1721 void CreateModel_nhwc_quant8_3(Model *model) {
1722 OperandType type0(Type::BOOL, {});
1723 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1724 OperandType type4(Type::TENSOR_INT32, {4});
1725 OperandType type42(Type::TENSOR_QUANT8_ASYMM, {4, 2, 3, 2}, 0.03125f, 10);
1726 OperandType type5(Type::INT32, {});
1727 OperandType type52(Type::TENSOR_QUANT8_ASYMM, {2, 4, 8, 2}, 0.04f, 0);
1728 OperandType type6(Type::FLOAT32, {});
1729 // Phase 1, operands
1730 auto in2 = model->addOperand(&type52);
1731 auto roi2 = model->addOperand(&type27);
1732 auto param14 = model->addOperand(&type4);
1733 auto param15 = model->addOperand(&type5);
1734 auto param16 = model->addOperand(&type5);
1735 auto param17 = model->addOperand(&type6);
1736 auto param18 = model->addOperand(&type6);
1737 auto param19 = model->addOperand(&type5);
1738 auto param20 = model->addOperand(&type5);
1739 auto layout = model->addOperand(&type0);
1740 auto out2 = model->addOperand(&type42);
1741 // Phase 2, operations
1742 static int32_t param14_init[] = {0, 0, 1, 1};
1743 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1744 static int32_t param15_init[] = {2};
1745 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1746 static int32_t param16_init[] = {3};
1747 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1748 static float param17_init[] = {4.0f};
1749 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
1750 static float param18_init[] = {4.0f};
1751 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1752 static int32_t param19_init[] = {0};
1753 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1754 static int32_t param20_init[] = {0};
1755 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1756 static bool8 layout_init[] = {false};
1757 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1758 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1759 // Phase 3, inputs and outputs
1760 model->identifyInputsAndOutputs(
1761 {in2, roi2},
1762 {out2});
1763 assert(model->isValid());
1764 }
1765
is_ignored_nhwc_quant8_3(int i)1766 inline bool is_ignored_nhwc_quant8_3(int i) {
1767 static std::set<int> ignore = {};
1768 return ignore.find(i) != ignore.end();
1769 }
1770
CreateModel_nhwc_float16_3(Model * model)1771 void CreateModel_nhwc_float16_3(Model *model) {
1772 OperandType type0(Type::BOOL, {});
1773 OperandType type30(Type::FLOAT16, {});
1774 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
1775 OperandType type4(Type::TENSOR_INT32, {4});
1776 OperandType type44(Type::TENSOR_FLOAT16, {4, 2, 3, 2});
1777 OperandType type5(Type::INT32, {});
1778 OperandType type53(Type::TENSOR_FLOAT16, {2, 4, 8, 2});
1779 // Phase 1, operands
1780 auto in2 = model->addOperand(&type53);
1781 auto roi2 = model->addOperand(&type31);
1782 auto param14 = model->addOperand(&type4);
1783 auto param15 = model->addOperand(&type5);
1784 auto param16 = model->addOperand(&type5);
1785 auto param17 = model->addOperand(&type30);
1786 auto param18 = model->addOperand(&type30);
1787 auto param19 = model->addOperand(&type5);
1788 auto param20 = model->addOperand(&type5);
1789 auto layout = model->addOperand(&type0);
1790 auto out2 = model->addOperand(&type44);
1791 // Phase 2, operations
1792 static int32_t param14_init[] = {0, 0, 1, 1};
1793 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1794 static int32_t param15_init[] = {2};
1795 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1796 static int32_t param16_init[] = {3};
1797 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1798 static _Float16 param17_init[] = {4.0f};
1799 model->setOperandValue(param17, param17_init, sizeof(_Float16) * 1);
1800 static _Float16 param18_init[] = {4.0f};
1801 model->setOperandValue(param18, param18_init, sizeof(_Float16) * 1);
1802 static int32_t param19_init[] = {0};
1803 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1804 static int32_t param20_init[] = {0};
1805 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1806 static bool8 layout_init[] = {false};
1807 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1808 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1809 // Phase 3, inputs and outputs
1810 model->identifyInputsAndOutputs(
1811 {in2, roi2},
1812 {out2});
1813 assert(model->isValid());
1814 }
1815
is_ignored_nhwc_float16_3(int i)1816 inline bool is_ignored_nhwc_float16_3(int i) {
1817 static std::set<int> ignore = {};
1818 return ignore.find(i) != ignore.end();
1819 }
1820
CreateModel_nchw_3(Model * model)1821 void CreateModel_nchw_3(Model *model) {
1822 OperandType type0(Type::BOOL, {});
1823 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1824 OperandType type4(Type::TENSOR_INT32, {4});
1825 OperandType type46(Type::TENSOR_FLOAT32, {4, 2, 2, 3});
1826 OperandType type5(Type::INT32, {});
1827 OperandType type54(Type::TENSOR_FLOAT32, {2, 2, 4, 8});
1828 OperandType type6(Type::FLOAT32, {});
1829 // Phase 1, operands
1830 auto in2 = model->addOperand(&type54);
1831 auto roi2 = model->addOperand(&type2);
1832 auto param14 = model->addOperand(&type4);
1833 auto param15 = model->addOperand(&type5);
1834 auto param16 = model->addOperand(&type5);
1835 auto param17 = model->addOperand(&type6);
1836 auto param18 = model->addOperand(&type6);
1837 auto param19 = model->addOperand(&type5);
1838 auto param20 = model->addOperand(&type5);
1839 auto layout = model->addOperand(&type0);
1840 auto out2 = model->addOperand(&type46);
1841 // Phase 2, operations
1842 static int32_t param14_init[] = {0, 0, 1, 1};
1843 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1844 static int32_t param15_init[] = {2};
1845 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1846 static int32_t param16_init[] = {3};
1847 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1848 static float param17_init[] = {4.0f};
1849 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
1850 static float param18_init[] = {4.0f};
1851 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1852 static int32_t param19_init[] = {0};
1853 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1854 static int32_t param20_init[] = {0};
1855 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1856 static bool8 layout_init[] = {true};
1857 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1858 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1859 // Phase 3, inputs and outputs
1860 model->identifyInputsAndOutputs(
1861 {in2, roi2},
1862 {out2});
1863 assert(model->isValid());
1864 }
1865
is_ignored_nchw_3(int i)1866 inline bool is_ignored_nchw_3(int i) {
1867 static std::set<int> ignore = {};
1868 return ignore.find(i) != ignore.end();
1869 }
1870
CreateModel_nchw_relaxed_3(Model * model)1871 void CreateModel_nchw_relaxed_3(Model *model) {
1872 OperandType type0(Type::BOOL, {});
1873 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
1874 OperandType type4(Type::TENSOR_INT32, {4});
1875 OperandType type46(Type::TENSOR_FLOAT32, {4, 2, 2, 3});
1876 OperandType type5(Type::INT32, {});
1877 OperandType type54(Type::TENSOR_FLOAT32, {2, 2, 4, 8});
1878 OperandType type6(Type::FLOAT32, {});
1879 // Phase 1, operands
1880 auto in2 = model->addOperand(&type54);
1881 auto roi2 = model->addOperand(&type2);
1882 auto param14 = model->addOperand(&type4);
1883 auto param15 = model->addOperand(&type5);
1884 auto param16 = model->addOperand(&type5);
1885 auto param17 = model->addOperand(&type6);
1886 auto param18 = model->addOperand(&type6);
1887 auto param19 = model->addOperand(&type5);
1888 auto param20 = model->addOperand(&type5);
1889 auto layout = model->addOperand(&type0);
1890 auto out2 = model->addOperand(&type46);
1891 // Phase 2, operations
1892 static int32_t param14_init[] = {0, 0, 1, 1};
1893 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1894 static int32_t param15_init[] = {2};
1895 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1896 static int32_t param16_init[] = {3};
1897 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1898 static float param17_init[] = {4.0f};
1899 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
1900 static float param18_init[] = {4.0f};
1901 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1902 static int32_t param19_init[] = {0};
1903 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1904 static int32_t param20_init[] = {0};
1905 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1906 static bool8 layout_init[] = {true};
1907 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1908 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1909 // Phase 3, inputs and outputs
1910 model->identifyInputsAndOutputs(
1911 {in2, roi2},
1912 {out2});
1913 // Phase 4: set relaxed execution
1914 model->relaxComputationFloat32toFloat16(true);
1915 assert(model->isValid());
1916 }
1917
is_ignored_nchw_relaxed_3(int i)1918 inline bool is_ignored_nchw_relaxed_3(int i) {
1919 static std::set<int> ignore = {};
1920 return ignore.find(i) != ignore.end();
1921 }
1922
CreateModel_nchw_quant8_3(Model * model)1923 void CreateModel_nchw_quant8_3(Model *model) {
1924 OperandType type0(Type::BOOL, {});
1925 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1926 OperandType type4(Type::TENSOR_INT32, {4});
1927 OperandType type48(Type::TENSOR_QUANT8_ASYMM, {4, 2, 2, 3}, 0.03125f, 10);
1928 OperandType type5(Type::INT32, {});
1929 OperandType type55(Type::TENSOR_QUANT8_ASYMM, {2, 2, 4, 8}, 0.04f, 0);
1930 OperandType type6(Type::FLOAT32, {});
1931 // Phase 1, operands
1932 auto in2 = model->addOperand(&type55);
1933 auto roi2 = model->addOperand(&type27);
1934 auto param14 = model->addOperand(&type4);
1935 auto param15 = model->addOperand(&type5);
1936 auto param16 = model->addOperand(&type5);
1937 auto param17 = model->addOperand(&type6);
1938 auto param18 = model->addOperand(&type6);
1939 auto param19 = model->addOperand(&type5);
1940 auto param20 = model->addOperand(&type5);
1941 auto layout = model->addOperand(&type0);
1942 auto out2 = model->addOperand(&type48);
1943 // Phase 2, operations
1944 static int32_t param14_init[] = {0, 0, 1, 1};
1945 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1946 static int32_t param15_init[] = {2};
1947 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1948 static int32_t param16_init[] = {3};
1949 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
1950 static float param17_init[] = {4.0f};
1951 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
1952 static float param18_init[] = {4.0f};
1953 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
1954 static int32_t param19_init[] = {0};
1955 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1956 static int32_t param20_init[] = {0};
1957 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1958 static bool8 layout_init[] = {true};
1959 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1960 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
1961 // Phase 3, inputs and outputs
1962 model->identifyInputsAndOutputs(
1963 {in2, roi2},
1964 {out2});
1965 assert(model->isValid());
1966 }
1967
is_ignored_nchw_quant8_3(int i)1968 inline bool is_ignored_nchw_quant8_3(int i) {
1969 static std::set<int> ignore = {};
1970 return ignore.find(i) != ignore.end();
1971 }
1972
CreateModel_nchw_float16_3(Model * model)1973 void CreateModel_nchw_float16_3(Model *model) {
1974 OperandType type0(Type::BOOL, {});
1975 OperandType type30(Type::FLOAT16, {});
1976 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
1977 OperandType type4(Type::TENSOR_INT32, {4});
1978 OperandType type5(Type::INT32, {});
1979 OperandType type50(Type::TENSOR_FLOAT16, {4, 2, 2, 3});
1980 OperandType type56(Type::TENSOR_FLOAT16, {2, 2, 4, 8});
1981 // Phase 1, operands
1982 auto in2 = model->addOperand(&type56);
1983 auto roi2 = model->addOperand(&type31);
1984 auto param14 = model->addOperand(&type4);
1985 auto param15 = model->addOperand(&type5);
1986 auto param16 = model->addOperand(&type5);
1987 auto param17 = model->addOperand(&type30);
1988 auto param18 = model->addOperand(&type30);
1989 auto param19 = model->addOperand(&type5);
1990 auto param20 = model->addOperand(&type5);
1991 auto layout = model->addOperand(&type0);
1992 auto out2 = model->addOperand(&type50);
1993 // Phase 2, operations
1994 static int32_t param14_init[] = {0, 0, 1, 1};
1995 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
1996 static int32_t param15_init[] = {2};
1997 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
1998 static int32_t param16_init[] = {3};
1999 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2000 static _Float16 param17_init[] = {4.0f};
2001 model->setOperandValue(param17, param17_init, sizeof(_Float16) * 1);
2002 static _Float16 param18_init[] = {4.0f};
2003 model->setOperandValue(param18, param18_init, sizeof(_Float16) * 1);
2004 static int32_t param19_init[] = {0};
2005 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2006 static int32_t param20_init[] = {0};
2007 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2008 static bool8 layout_init[] = {true};
2009 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2010 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2011 // Phase 3, inputs and outputs
2012 model->identifyInputsAndOutputs(
2013 {in2, roi2},
2014 {out2});
2015 assert(model->isValid());
2016 }
2017
is_ignored_nchw_float16_3(int i)2018 inline bool is_ignored_nchw_float16_3(int i) {
2019 static std::set<int> ignore = {};
2020 return ignore.find(i) != ignore.end();
2021 }
2022
CreateModel_dynamic_output_shape_nhwc_3(Model * model)2023 void CreateModel_dynamic_output_shape_nhwc_3(Model *model) {
2024 OperandType type0(Type::BOOL, {});
2025 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
2026 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2027 OperandType type4(Type::TENSOR_INT32, {4});
2028 OperandType type5(Type::INT32, {});
2029 OperandType type6(Type::FLOAT32, {});
2030 OperandType type9(Type::TENSOR_FLOAT32, {2, 4, 8, 2});
2031 // Phase 1, operands
2032 auto in2 = model->addOperand(&type9);
2033 auto roi2 = model->addOperand(&type2);
2034 auto param14 = model->addOperand(&type4);
2035 auto param15 = model->addOperand(&type5);
2036 auto param16 = model->addOperand(&type5);
2037 auto param17 = model->addOperand(&type6);
2038 auto param18 = model->addOperand(&type6);
2039 auto param19 = model->addOperand(&type5);
2040 auto param20 = model->addOperand(&type5);
2041 auto layout = model->addOperand(&type0);
2042 auto out2 = model->addOperand(&type38);
2043 // Phase 2, operations
2044 static int32_t param14_init[] = {0, 0, 1, 1};
2045 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2046 static int32_t param15_init[] = {2};
2047 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2048 static int32_t param16_init[] = {3};
2049 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2050 static float param17_init[] = {4.0f};
2051 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
2052 static float param18_init[] = {4.0f};
2053 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
2054 static int32_t param19_init[] = {0};
2055 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2056 static int32_t param20_init[] = {0};
2057 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2058 static bool8 layout_init[] = {false};
2059 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2060 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2061 // Phase 3, inputs and outputs
2062 model->identifyInputsAndOutputs(
2063 {in2, roi2},
2064 {out2});
2065 assert(model->isValid());
2066 }
2067
is_ignored_dynamic_output_shape_nhwc_3(int i)2068 inline bool is_ignored_dynamic_output_shape_nhwc_3(int i) {
2069 static std::set<int> ignore = {};
2070 return ignore.find(i) != ignore.end();
2071 }
2072
CreateModel_dynamic_output_shape_nhwc_relaxed_3(Model * model)2073 void CreateModel_dynamic_output_shape_nhwc_relaxed_3(Model *model) {
2074 OperandType type0(Type::BOOL, {});
2075 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
2076 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2077 OperandType type4(Type::TENSOR_INT32, {4});
2078 OperandType type5(Type::INT32, {});
2079 OperandType type6(Type::FLOAT32, {});
2080 OperandType type9(Type::TENSOR_FLOAT32, {2, 4, 8, 2});
2081 // Phase 1, operands
2082 auto in2 = model->addOperand(&type9);
2083 auto roi2 = model->addOperand(&type2);
2084 auto param14 = model->addOperand(&type4);
2085 auto param15 = model->addOperand(&type5);
2086 auto param16 = model->addOperand(&type5);
2087 auto param17 = model->addOperand(&type6);
2088 auto param18 = model->addOperand(&type6);
2089 auto param19 = model->addOperand(&type5);
2090 auto param20 = model->addOperand(&type5);
2091 auto layout = model->addOperand(&type0);
2092 auto out2 = model->addOperand(&type38);
2093 // Phase 2, operations
2094 static int32_t param14_init[] = {0, 0, 1, 1};
2095 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2096 static int32_t param15_init[] = {2};
2097 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2098 static int32_t param16_init[] = {3};
2099 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2100 static float param17_init[] = {4.0f};
2101 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
2102 static float param18_init[] = {4.0f};
2103 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
2104 static int32_t param19_init[] = {0};
2105 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2106 static int32_t param20_init[] = {0};
2107 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2108 static bool8 layout_init[] = {false};
2109 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2110 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2111 // Phase 3, inputs and outputs
2112 model->identifyInputsAndOutputs(
2113 {in2, roi2},
2114 {out2});
2115 // Phase 4: set relaxed execution
2116 model->relaxComputationFloat32toFloat16(true);
2117 assert(model->isValid());
2118 }
2119
is_ignored_dynamic_output_shape_nhwc_relaxed_3(int i)2120 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_3(int i) {
2121 static std::set<int> ignore = {};
2122 return ignore.find(i) != ignore.end();
2123 }
2124
CreateModel_dynamic_output_shape_nhwc_quant8_3(Model * model)2125 void CreateModel_dynamic_output_shape_nhwc_quant8_3(Model *model) {
2126 OperandType type0(Type::BOOL, {});
2127 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
2128 OperandType type4(Type::TENSOR_INT32, {4});
2129 OperandType type5(Type::INT32, {});
2130 OperandType type51(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.03125f, 10);
2131 OperandType type52(Type::TENSOR_QUANT8_ASYMM, {2, 4, 8, 2}, 0.04f, 0);
2132 OperandType type6(Type::FLOAT32, {});
2133 // Phase 1, operands
2134 auto in2 = model->addOperand(&type52);
2135 auto roi2 = model->addOperand(&type27);
2136 auto param14 = model->addOperand(&type4);
2137 auto param15 = model->addOperand(&type5);
2138 auto param16 = model->addOperand(&type5);
2139 auto param17 = model->addOperand(&type6);
2140 auto param18 = model->addOperand(&type6);
2141 auto param19 = model->addOperand(&type5);
2142 auto param20 = model->addOperand(&type5);
2143 auto layout = model->addOperand(&type0);
2144 auto out2 = model->addOperand(&type51);
2145 // Phase 2, operations
2146 static int32_t param14_init[] = {0, 0, 1, 1};
2147 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2148 static int32_t param15_init[] = {2};
2149 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2150 static int32_t param16_init[] = {3};
2151 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2152 static float param17_init[] = {4.0f};
2153 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
2154 static float param18_init[] = {4.0f};
2155 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
2156 static int32_t param19_init[] = {0};
2157 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2158 static int32_t param20_init[] = {0};
2159 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2160 static bool8 layout_init[] = {false};
2161 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2162 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2163 // Phase 3, inputs and outputs
2164 model->identifyInputsAndOutputs(
2165 {in2, roi2},
2166 {out2});
2167 assert(model->isValid());
2168 }
2169
is_ignored_dynamic_output_shape_nhwc_quant8_3(int i)2170 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_3(int i) {
2171 static std::set<int> ignore = {};
2172 return ignore.find(i) != ignore.end();
2173 }
2174
CreateModel_dynamic_output_shape_nhwc_float16_3(Model * model)2175 void CreateModel_dynamic_output_shape_nhwc_float16_3(Model *model) {
2176 OperandType type0(Type::BOOL, {});
2177 OperandType type30(Type::FLOAT16, {});
2178 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
2179 OperandType type4(Type::TENSOR_INT32, {4});
2180 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
2181 OperandType type5(Type::INT32, {});
2182 OperandType type53(Type::TENSOR_FLOAT16, {2, 4, 8, 2});
2183 // Phase 1, operands
2184 auto in2 = model->addOperand(&type53);
2185 auto roi2 = model->addOperand(&type31);
2186 auto param14 = model->addOperand(&type4);
2187 auto param15 = model->addOperand(&type5);
2188 auto param16 = model->addOperand(&type5);
2189 auto param17 = model->addOperand(&type30);
2190 auto param18 = model->addOperand(&type30);
2191 auto param19 = model->addOperand(&type5);
2192 auto param20 = model->addOperand(&type5);
2193 auto layout = model->addOperand(&type0);
2194 auto out2 = model->addOperand(&type40);
2195 // Phase 2, operations
2196 static int32_t param14_init[] = {0, 0, 1, 1};
2197 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2198 static int32_t param15_init[] = {2};
2199 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2200 static int32_t param16_init[] = {3};
2201 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2202 static _Float16 param17_init[] = {4.0f};
2203 model->setOperandValue(param17, param17_init, sizeof(_Float16) * 1);
2204 static _Float16 param18_init[] = {4.0f};
2205 model->setOperandValue(param18, param18_init, sizeof(_Float16) * 1);
2206 static int32_t param19_init[] = {0};
2207 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2208 static int32_t param20_init[] = {0};
2209 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2210 static bool8 layout_init[] = {false};
2211 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2212 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2213 // Phase 3, inputs and outputs
2214 model->identifyInputsAndOutputs(
2215 {in2, roi2},
2216 {out2});
2217 assert(model->isValid());
2218 }
2219
is_ignored_dynamic_output_shape_nhwc_float16_3(int i)2220 inline bool is_ignored_dynamic_output_shape_nhwc_float16_3(int i) {
2221 static std::set<int> ignore = {};
2222 return ignore.find(i) != ignore.end();
2223 }
2224
CreateModel_dynamic_output_shape_nchw_3(Model * model)2225 void CreateModel_dynamic_output_shape_nchw_3(Model *model) {
2226 OperandType type0(Type::BOOL, {});
2227 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
2228 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2229 OperandType type4(Type::TENSOR_INT32, {4});
2230 OperandType type5(Type::INT32, {});
2231 OperandType type54(Type::TENSOR_FLOAT32, {2, 2, 4, 8});
2232 OperandType type6(Type::FLOAT32, {});
2233 // Phase 1, operands
2234 auto in2 = model->addOperand(&type54);
2235 auto roi2 = model->addOperand(&type2);
2236 auto param14 = model->addOperand(&type4);
2237 auto param15 = model->addOperand(&type5);
2238 auto param16 = model->addOperand(&type5);
2239 auto param17 = model->addOperand(&type6);
2240 auto param18 = model->addOperand(&type6);
2241 auto param19 = model->addOperand(&type5);
2242 auto param20 = model->addOperand(&type5);
2243 auto layout = model->addOperand(&type0);
2244 auto out2 = model->addOperand(&type38);
2245 // Phase 2, operations
2246 static int32_t param14_init[] = {0, 0, 1, 1};
2247 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2248 static int32_t param15_init[] = {2};
2249 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2250 static int32_t param16_init[] = {3};
2251 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2252 static float param17_init[] = {4.0f};
2253 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
2254 static float param18_init[] = {4.0f};
2255 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
2256 static int32_t param19_init[] = {0};
2257 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2258 static int32_t param20_init[] = {0};
2259 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2260 static bool8 layout_init[] = {true};
2261 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2262 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2263 // Phase 3, inputs and outputs
2264 model->identifyInputsAndOutputs(
2265 {in2, roi2},
2266 {out2});
2267 assert(model->isValid());
2268 }
2269
is_ignored_dynamic_output_shape_nchw_3(int i)2270 inline bool is_ignored_dynamic_output_shape_nchw_3(int i) {
2271 static std::set<int> ignore = {};
2272 return ignore.find(i) != ignore.end();
2273 }
2274
CreateModel_dynamic_output_shape_nchw_relaxed_3(Model * model)2275 void CreateModel_dynamic_output_shape_nchw_relaxed_3(Model *model) {
2276 OperandType type0(Type::BOOL, {});
2277 OperandType type2(Type::TENSOR_FLOAT32, {4, 4});
2278 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2279 OperandType type4(Type::TENSOR_INT32, {4});
2280 OperandType type5(Type::INT32, {});
2281 OperandType type54(Type::TENSOR_FLOAT32, {2, 2, 4, 8});
2282 OperandType type6(Type::FLOAT32, {});
2283 // Phase 1, operands
2284 auto in2 = model->addOperand(&type54);
2285 auto roi2 = model->addOperand(&type2);
2286 auto param14 = model->addOperand(&type4);
2287 auto param15 = model->addOperand(&type5);
2288 auto param16 = model->addOperand(&type5);
2289 auto param17 = model->addOperand(&type6);
2290 auto param18 = model->addOperand(&type6);
2291 auto param19 = model->addOperand(&type5);
2292 auto param20 = model->addOperand(&type5);
2293 auto layout = model->addOperand(&type0);
2294 auto out2 = model->addOperand(&type38);
2295 // Phase 2, operations
2296 static int32_t param14_init[] = {0, 0, 1, 1};
2297 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2298 static int32_t param15_init[] = {2};
2299 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2300 static int32_t param16_init[] = {3};
2301 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2302 static float param17_init[] = {4.0f};
2303 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
2304 static float param18_init[] = {4.0f};
2305 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
2306 static int32_t param19_init[] = {0};
2307 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2308 static int32_t param20_init[] = {0};
2309 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2310 static bool8 layout_init[] = {true};
2311 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2312 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2313 // Phase 3, inputs and outputs
2314 model->identifyInputsAndOutputs(
2315 {in2, roi2},
2316 {out2});
2317 // Phase 4: set relaxed execution
2318 model->relaxComputationFloat32toFloat16(true);
2319 assert(model->isValid());
2320 }
2321
is_ignored_dynamic_output_shape_nchw_relaxed_3(int i)2322 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_3(int i) {
2323 static std::set<int> ignore = {};
2324 return ignore.find(i) != ignore.end();
2325 }
2326
CreateModel_dynamic_output_shape_nchw_quant8_3(Model * model)2327 void CreateModel_dynamic_output_shape_nchw_quant8_3(Model *model) {
2328 OperandType type0(Type::BOOL, {});
2329 OperandType type27(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
2330 OperandType type4(Type::TENSOR_INT32, {4});
2331 OperandType type5(Type::INT32, {});
2332 OperandType type51(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.03125f, 10);
2333 OperandType type55(Type::TENSOR_QUANT8_ASYMM, {2, 2, 4, 8}, 0.04f, 0);
2334 OperandType type6(Type::FLOAT32, {});
2335 // Phase 1, operands
2336 auto in2 = model->addOperand(&type55);
2337 auto roi2 = model->addOperand(&type27);
2338 auto param14 = model->addOperand(&type4);
2339 auto param15 = model->addOperand(&type5);
2340 auto param16 = model->addOperand(&type5);
2341 auto param17 = model->addOperand(&type6);
2342 auto param18 = model->addOperand(&type6);
2343 auto param19 = model->addOperand(&type5);
2344 auto param20 = model->addOperand(&type5);
2345 auto layout = model->addOperand(&type0);
2346 auto out2 = model->addOperand(&type51);
2347 // Phase 2, operations
2348 static int32_t param14_init[] = {0, 0, 1, 1};
2349 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2350 static int32_t param15_init[] = {2};
2351 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2352 static int32_t param16_init[] = {3};
2353 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2354 static float param17_init[] = {4.0f};
2355 model->setOperandValue(param17, param17_init, sizeof(float) * 1);
2356 static float param18_init[] = {4.0f};
2357 model->setOperandValue(param18, param18_init, sizeof(float) * 1);
2358 static int32_t param19_init[] = {0};
2359 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2360 static int32_t param20_init[] = {0};
2361 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2362 static bool8 layout_init[] = {true};
2363 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2364 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2365 // Phase 3, inputs and outputs
2366 model->identifyInputsAndOutputs(
2367 {in2, roi2},
2368 {out2});
2369 assert(model->isValid());
2370 }
2371
is_ignored_dynamic_output_shape_nchw_quant8_3(int i)2372 inline bool is_ignored_dynamic_output_shape_nchw_quant8_3(int i) {
2373 static std::set<int> ignore = {};
2374 return ignore.find(i) != ignore.end();
2375 }
2376
CreateModel_dynamic_output_shape_nchw_float16_3(Model * model)2377 void CreateModel_dynamic_output_shape_nchw_float16_3(Model *model) {
2378 OperandType type0(Type::BOOL, {});
2379 OperandType type30(Type::FLOAT16, {});
2380 OperandType type31(Type::TENSOR_FLOAT16, {4, 4});
2381 OperandType type4(Type::TENSOR_INT32, {4});
2382 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
2383 OperandType type5(Type::INT32, {});
2384 OperandType type56(Type::TENSOR_FLOAT16, {2, 2, 4, 8});
2385 // Phase 1, operands
2386 auto in2 = model->addOperand(&type56);
2387 auto roi2 = model->addOperand(&type31);
2388 auto param14 = model->addOperand(&type4);
2389 auto param15 = model->addOperand(&type5);
2390 auto param16 = model->addOperand(&type5);
2391 auto param17 = model->addOperand(&type30);
2392 auto param18 = model->addOperand(&type30);
2393 auto param19 = model->addOperand(&type5);
2394 auto param20 = model->addOperand(&type5);
2395 auto layout = model->addOperand(&type0);
2396 auto out2 = model->addOperand(&type40);
2397 // Phase 2, operations
2398 static int32_t param14_init[] = {0, 0, 1, 1};
2399 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 4);
2400 static int32_t param15_init[] = {2};
2401 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
2402 static int32_t param16_init[] = {3};
2403 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
2404 static _Float16 param17_init[] = {4.0f};
2405 model->setOperandValue(param17, param17_init, sizeof(_Float16) * 1);
2406 static _Float16 param18_init[] = {4.0f};
2407 model->setOperandValue(param18, param18_init, sizeof(_Float16) * 1);
2408 static int32_t param19_init[] = {0};
2409 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
2410 static int32_t param20_init[] = {0};
2411 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
2412 static bool8 layout_init[] = {true};
2413 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2414 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in2, roi2, param14, param15, param16, param17, param18, param19, param20, layout}, {out2});
2415 // Phase 3, inputs and outputs
2416 model->identifyInputsAndOutputs(
2417 {in2, roi2},
2418 {out2});
2419 assert(model->isValid());
2420 }
2421
is_ignored_dynamic_output_shape_nchw_float16_3(int i)2422 inline bool is_ignored_dynamic_output_shape_nchw_float16_3(int i) {
2423 static std::set<int> ignore = {};
2424 return ignore.find(i) != ignore.end();
2425 }
2426
CreateModel_nhwc_4(Model * model)2427 void CreateModel_nhwc_4(Model *model) {
2428 OperandType type0(Type::BOOL, {});
2429 OperandType type10(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
2430 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
2431 OperandType type12(Type::TENSOR_FLOAT32, {5, 2, 2, 1});
2432 OperandType type13(Type::TENSOR_INT32, {5});
2433 OperandType type5(Type::INT32, {});
2434 OperandType type6(Type::FLOAT32, {});
2435 // Phase 1, operands
2436 auto in3 = model->addOperand(&type10);
2437 auto roi3 = model->addOperand(&type11);
2438 auto param21 = model->addOperand(&type13);
2439 auto param22 = model->addOperand(&type5);
2440 auto param23 = model->addOperand(&type5);
2441 auto param24 = model->addOperand(&type6);
2442 auto param25 = model->addOperand(&type6);
2443 auto param26 = model->addOperand(&type5);
2444 auto param27 = model->addOperand(&type5);
2445 auto layout = model->addOperand(&type0);
2446 auto out3 = model->addOperand(&type12);
2447 // Phase 2, operations
2448 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2449 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2450 static int32_t param22_init[] = {2};
2451 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2452 static int32_t param23_init[] = {2};
2453 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2454 static float param24_init[] = {2.0f};
2455 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2456 static float param25_init[] = {1.0f};
2457 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2458 static int32_t param26_init[] = {0};
2459 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2460 static int32_t param27_init[] = {4};
2461 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2462 static bool8 layout_init[] = {false};
2463 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2464 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2465 // Phase 3, inputs and outputs
2466 model->identifyInputsAndOutputs(
2467 {in3, roi3},
2468 {out3});
2469 assert(model->isValid());
2470 }
2471
is_ignored_nhwc_4(int i)2472 inline bool is_ignored_nhwc_4(int i) {
2473 static std::set<int> ignore = {};
2474 return ignore.find(i) != ignore.end();
2475 }
2476
CreateModel_nhwc_relaxed_4(Model * model)2477 void CreateModel_nhwc_relaxed_4(Model *model) {
2478 OperandType type0(Type::BOOL, {});
2479 OperandType type10(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
2480 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
2481 OperandType type12(Type::TENSOR_FLOAT32, {5, 2, 2, 1});
2482 OperandType type13(Type::TENSOR_INT32, {5});
2483 OperandType type5(Type::INT32, {});
2484 OperandType type6(Type::FLOAT32, {});
2485 // Phase 1, operands
2486 auto in3 = model->addOperand(&type10);
2487 auto roi3 = model->addOperand(&type11);
2488 auto param21 = model->addOperand(&type13);
2489 auto param22 = model->addOperand(&type5);
2490 auto param23 = model->addOperand(&type5);
2491 auto param24 = model->addOperand(&type6);
2492 auto param25 = model->addOperand(&type6);
2493 auto param26 = model->addOperand(&type5);
2494 auto param27 = model->addOperand(&type5);
2495 auto layout = model->addOperand(&type0);
2496 auto out3 = model->addOperand(&type12);
2497 // Phase 2, operations
2498 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2499 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2500 static int32_t param22_init[] = {2};
2501 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2502 static int32_t param23_init[] = {2};
2503 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2504 static float param24_init[] = {2.0f};
2505 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2506 static float param25_init[] = {1.0f};
2507 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2508 static int32_t param26_init[] = {0};
2509 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2510 static int32_t param27_init[] = {4};
2511 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2512 static bool8 layout_init[] = {false};
2513 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2514 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2515 // Phase 3, inputs and outputs
2516 model->identifyInputsAndOutputs(
2517 {in3, roi3},
2518 {out3});
2519 // Phase 4: set relaxed execution
2520 model->relaxComputationFloat32toFloat16(true);
2521 assert(model->isValid());
2522 }
2523
is_ignored_nhwc_relaxed_4(int i)2524 inline bool is_ignored_nhwc_relaxed_4(int i) {
2525 static std::set<int> ignore = {};
2526 return ignore.find(i) != ignore.end();
2527 }
2528
CreateModel_nhwc_quant8_4(Model * model)2529 void CreateModel_nhwc_quant8_4(Model *model) {
2530 OperandType type0(Type::BOOL, {});
2531 OperandType type13(Type::TENSOR_INT32, {5});
2532 OperandType type5(Type::INT32, {});
2533 OperandType type57(Type::TENSOR_QUANT8_ASYMM, {4, 4, 4, 1}, 0.25f, 128);
2534 OperandType type58(Type::TENSOR_QUANT8_ASYMM, {5, 2, 2, 1}, 0.0625f, 128);
2535 OperandType type59(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
2536 OperandType type6(Type::FLOAT32, {});
2537 // Phase 1, operands
2538 auto in3 = model->addOperand(&type57);
2539 auto roi3 = model->addOperand(&type59);
2540 auto param21 = model->addOperand(&type13);
2541 auto param22 = model->addOperand(&type5);
2542 auto param23 = model->addOperand(&type5);
2543 auto param24 = model->addOperand(&type6);
2544 auto param25 = model->addOperand(&type6);
2545 auto param26 = model->addOperand(&type5);
2546 auto param27 = model->addOperand(&type5);
2547 auto layout = model->addOperand(&type0);
2548 auto out3 = model->addOperand(&type58);
2549 // Phase 2, operations
2550 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2551 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2552 static int32_t param22_init[] = {2};
2553 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2554 static int32_t param23_init[] = {2};
2555 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2556 static float param24_init[] = {2.0f};
2557 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2558 static float param25_init[] = {1.0f};
2559 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2560 static int32_t param26_init[] = {0};
2561 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2562 static int32_t param27_init[] = {4};
2563 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2564 static bool8 layout_init[] = {false};
2565 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2566 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2567 // Phase 3, inputs and outputs
2568 model->identifyInputsAndOutputs(
2569 {in3, roi3},
2570 {out3});
2571 assert(model->isValid());
2572 }
2573
is_ignored_nhwc_quant8_4(int i)2574 inline bool is_ignored_nhwc_quant8_4(int i) {
2575 static std::set<int> ignore = {};
2576 return ignore.find(i) != ignore.end();
2577 }
2578
CreateModel_nhwc_float16_4(Model * model)2579 void CreateModel_nhwc_float16_4(Model *model) {
2580 OperandType type0(Type::BOOL, {});
2581 OperandType type13(Type::TENSOR_INT32, {5});
2582 OperandType type30(Type::FLOAT16, {});
2583 OperandType type5(Type::INT32, {});
2584 OperandType type60(Type::TENSOR_FLOAT16, {4, 4, 4, 1});
2585 OperandType type61(Type::TENSOR_FLOAT16, {5, 2, 2, 1});
2586 OperandType type62(Type::TENSOR_FLOAT16, {5, 4});
2587 // Phase 1, operands
2588 auto in3 = model->addOperand(&type60);
2589 auto roi3 = model->addOperand(&type62);
2590 auto param21 = model->addOperand(&type13);
2591 auto param22 = model->addOperand(&type5);
2592 auto param23 = model->addOperand(&type5);
2593 auto param24 = model->addOperand(&type30);
2594 auto param25 = model->addOperand(&type30);
2595 auto param26 = model->addOperand(&type5);
2596 auto param27 = model->addOperand(&type5);
2597 auto layout = model->addOperand(&type0);
2598 auto out3 = model->addOperand(&type61);
2599 // Phase 2, operations
2600 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2601 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2602 static int32_t param22_init[] = {2};
2603 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2604 static int32_t param23_init[] = {2};
2605 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2606 static _Float16 param24_init[] = {2.0f};
2607 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1);
2608 static _Float16 param25_init[] = {1.0f};
2609 model->setOperandValue(param25, param25_init, sizeof(_Float16) * 1);
2610 static int32_t param26_init[] = {0};
2611 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2612 static int32_t param27_init[] = {4};
2613 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2614 static bool8 layout_init[] = {false};
2615 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2616 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2617 // Phase 3, inputs and outputs
2618 model->identifyInputsAndOutputs(
2619 {in3, roi3},
2620 {out3});
2621 assert(model->isValid());
2622 }
2623
is_ignored_nhwc_float16_4(int i)2624 inline bool is_ignored_nhwc_float16_4(int i) {
2625 static std::set<int> ignore = {};
2626 return ignore.find(i) != ignore.end();
2627 }
2628
CreateModel_nchw_4(Model * model)2629 void CreateModel_nchw_4(Model *model) {
2630 OperandType type0(Type::BOOL, {});
2631 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
2632 OperandType type13(Type::TENSOR_INT32, {5});
2633 OperandType type5(Type::INT32, {});
2634 OperandType type6(Type::FLOAT32, {});
2635 OperandType type63(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
2636 OperandType type64(Type::TENSOR_FLOAT32, {5, 1, 2, 2});
2637 // Phase 1, operands
2638 auto in3 = model->addOperand(&type63);
2639 auto roi3 = model->addOperand(&type11);
2640 auto param21 = model->addOperand(&type13);
2641 auto param22 = model->addOperand(&type5);
2642 auto param23 = model->addOperand(&type5);
2643 auto param24 = model->addOperand(&type6);
2644 auto param25 = model->addOperand(&type6);
2645 auto param26 = model->addOperand(&type5);
2646 auto param27 = model->addOperand(&type5);
2647 auto layout = model->addOperand(&type0);
2648 auto out3 = model->addOperand(&type64);
2649 // Phase 2, operations
2650 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2651 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2652 static int32_t param22_init[] = {2};
2653 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2654 static int32_t param23_init[] = {2};
2655 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2656 static float param24_init[] = {2.0f};
2657 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2658 static float param25_init[] = {1.0f};
2659 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2660 static int32_t param26_init[] = {0};
2661 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2662 static int32_t param27_init[] = {4};
2663 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2664 static bool8 layout_init[] = {true};
2665 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2666 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2667 // Phase 3, inputs and outputs
2668 model->identifyInputsAndOutputs(
2669 {in3, roi3},
2670 {out3});
2671 assert(model->isValid());
2672 }
2673
is_ignored_nchw_4(int i)2674 inline bool is_ignored_nchw_4(int i) {
2675 static std::set<int> ignore = {};
2676 return ignore.find(i) != ignore.end();
2677 }
2678
CreateModel_nchw_relaxed_4(Model * model)2679 void CreateModel_nchw_relaxed_4(Model *model) {
2680 OperandType type0(Type::BOOL, {});
2681 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
2682 OperandType type13(Type::TENSOR_INT32, {5});
2683 OperandType type5(Type::INT32, {});
2684 OperandType type6(Type::FLOAT32, {});
2685 OperandType type63(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
2686 OperandType type64(Type::TENSOR_FLOAT32, {5, 1, 2, 2});
2687 // Phase 1, operands
2688 auto in3 = model->addOperand(&type63);
2689 auto roi3 = model->addOperand(&type11);
2690 auto param21 = model->addOperand(&type13);
2691 auto param22 = model->addOperand(&type5);
2692 auto param23 = model->addOperand(&type5);
2693 auto param24 = model->addOperand(&type6);
2694 auto param25 = model->addOperand(&type6);
2695 auto param26 = model->addOperand(&type5);
2696 auto param27 = model->addOperand(&type5);
2697 auto layout = model->addOperand(&type0);
2698 auto out3 = model->addOperand(&type64);
2699 // Phase 2, operations
2700 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2701 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2702 static int32_t param22_init[] = {2};
2703 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2704 static int32_t param23_init[] = {2};
2705 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2706 static float param24_init[] = {2.0f};
2707 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2708 static float param25_init[] = {1.0f};
2709 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2710 static int32_t param26_init[] = {0};
2711 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2712 static int32_t param27_init[] = {4};
2713 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2714 static bool8 layout_init[] = {true};
2715 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2716 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2717 // Phase 3, inputs and outputs
2718 model->identifyInputsAndOutputs(
2719 {in3, roi3},
2720 {out3});
2721 // Phase 4: set relaxed execution
2722 model->relaxComputationFloat32toFloat16(true);
2723 assert(model->isValid());
2724 }
2725
is_ignored_nchw_relaxed_4(int i)2726 inline bool is_ignored_nchw_relaxed_4(int i) {
2727 static std::set<int> ignore = {};
2728 return ignore.find(i) != ignore.end();
2729 }
2730
CreateModel_nchw_quant8_4(Model * model)2731 void CreateModel_nchw_quant8_4(Model *model) {
2732 OperandType type0(Type::BOOL, {});
2733 OperandType type13(Type::TENSOR_INT32, {5});
2734 OperandType type5(Type::INT32, {});
2735 OperandType type59(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
2736 OperandType type6(Type::FLOAT32, {});
2737 OperandType type65(Type::TENSOR_QUANT8_ASYMM, {4, 1, 4, 4}, 0.25f, 128);
2738 OperandType type66(Type::TENSOR_QUANT8_ASYMM, {5, 1, 2, 2}, 0.0625f, 128);
2739 // Phase 1, operands
2740 auto in3 = model->addOperand(&type65);
2741 auto roi3 = model->addOperand(&type59);
2742 auto param21 = model->addOperand(&type13);
2743 auto param22 = model->addOperand(&type5);
2744 auto param23 = model->addOperand(&type5);
2745 auto param24 = model->addOperand(&type6);
2746 auto param25 = model->addOperand(&type6);
2747 auto param26 = model->addOperand(&type5);
2748 auto param27 = model->addOperand(&type5);
2749 auto layout = model->addOperand(&type0);
2750 auto out3 = model->addOperand(&type66);
2751 // Phase 2, operations
2752 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2753 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2754 static int32_t param22_init[] = {2};
2755 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2756 static int32_t param23_init[] = {2};
2757 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2758 static float param24_init[] = {2.0f};
2759 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2760 static float param25_init[] = {1.0f};
2761 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2762 static int32_t param26_init[] = {0};
2763 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2764 static int32_t param27_init[] = {4};
2765 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2766 static bool8 layout_init[] = {true};
2767 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2768 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2769 // Phase 3, inputs and outputs
2770 model->identifyInputsAndOutputs(
2771 {in3, roi3},
2772 {out3});
2773 assert(model->isValid());
2774 }
2775
is_ignored_nchw_quant8_4(int i)2776 inline bool is_ignored_nchw_quant8_4(int i) {
2777 static std::set<int> ignore = {};
2778 return ignore.find(i) != ignore.end();
2779 }
2780
CreateModel_nchw_float16_4(Model * model)2781 void CreateModel_nchw_float16_4(Model *model) {
2782 OperandType type0(Type::BOOL, {});
2783 OperandType type13(Type::TENSOR_INT32, {5});
2784 OperandType type30(Type::FLOAT16, {});
2785 OperandType type5(Type::INT32, {});
2786 OperandType type62(Type::TENSOR_FLOAT16, {5, 4});
2787 OperandType type67(Type::TENSOR_FLOAT16, {4, 1, 4, 4});
2788 OperandType type68(Type::TENSOR_FLOAT16, {5, 1, 2, 2});
2789 // Phase 1, operands
2790 auto in3 = model->addOperand(&type67);
2791 auto roi3 = model->addOperand(&type62);
2792 auto param21 = model->addOperand(&type13);
2793 auto param22 = model->addOperand(&type5);
2794 auto param23 = model->addOperand(&type5);
2795 auto param24 = model->addOperand(&type30);
2796 auto param25 = model->addOperand(&type30);
2797 auto param26 = model->addOperand(&type5);
2798 auto param27 = model->addOperand(&type5);
2799 auto layout = model->addOperand(&type0);
2800 auto out3 = model->addOperand(&type68);
2801 // Phase 2, operations
2802 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2803 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2804 static int32_t param22_init[] = {2};
2805 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2806 static int32_t param23_init[] = {2};
2807 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2808 static _Float16 param24_init[] = {2.0f};
2809 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1);
2810 static _Float16 param25_init[] = {1.0f};
2811 model->setOperandValue(param25, param25_init, sizeof(_Float16) * 1);
2812 static int32_t param26_init[] = {0};
2813 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2814 static int32_t param27_init[] = {4};
2815 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2816 static bool8 layout_init[] = {true};
2817 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2818 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2819 // Phase 3, inputs and outputs
2820 model->identifyInputsAndOutputs(
2821 {in3, roi3},
2822 {out3});
2823 assert(model->isValid());
2824 }
2825
is_ignored_nchw_float16_4(int i)2826 inline bool is_ignored_nchw_float16_4(int i) {
2827 static std::set<int> ignore = {};
2828 return ignore.find(i) != ignore.end();
2829 }
2830
CreateModel_dynamic_output_shape_nhwc_4(Model * model)2831 void CreateModel_dynamic_output_shape_nhwc_4(Model *model) {
2832 OperandType type0(Type::BOOL, {});
2833 OperandType type10(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
2834 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
2835 OperandType type13(Type::TENSOR_INT32, {5});
2836 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2837 OperandType type5(Type::INT32, {});
2838 OperandType type6(Type::FLOAT32, {});
2839 // Phase 1, operands
2840 auto in3 = model->addOperand(&type10);
2841 auto roi3 = model->addOperand(&type11);
2842 auto param21 = model->addOperand(&type13);
2843 auto param22 = model->addOperand(&type5);
2844 auto param23 = model->addOperand(&type5);
2845 auto param24 = model->addOperand(&type6);
2846 auto param25 = model->addOperand(&type6);
2847 auto param26 = model->addOperand(&type5);
2848 auto param27 = model->addOperand(&type5);
2849 auto layout = model->addOperand(&type0);
2850 auto out3 = model->addOperand(&type38);
2851 // Phase 2, operations
2852 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2853 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2854 static int32_t param22_init[] = {2};
2855 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2856 static int32_t param23_init[] = {2};
2857 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2858 static float param24_init[] = {2.0f};
2859 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2860 static float param25_init[] = {1.0f};
2861 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2862 static int32_t param26_init[] = {0};
2863 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2864 static int32_t param27_init[] = {4};
2865 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2866 static bool8 layout_init[] = {false};
2867 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2868 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2869 // Phase 3, inputs and outputs
2870 model->identifyInputsAndOutputs(
2871 {in3, roi3},
2872 {out3});
2873 assert(model->isValid());
2874 }
2875
is_ignored_dynamic_output_shape_nhwc_4(int i)2876 inline bool is_ignored_dynamic_output_shape_nhwc_4(int i) {
2877 static std::set<int> ignore = {};
2878 return ignore.find(i) != ignore.end();
2879 }
2880
CreateModel_dynamic_output_shape_nhwc_relaxed_4(Model * model)2881 void CreateModel_dynamic_output_shape_nhwc_relaxed_4(Model *model) {
2882 OperandType type0(Type::BOOL, {});
2883 OperandType type10(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
2884 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
2885 OperandType type13(Type::TENSOR_INT32, {5});
2886 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2887 OperandType type5(Type::INT32, {});
2888 OperandType type6(Type::FLOAT32, {});
2889 // Phase 1, operands
2890 auto in3 = model->addOperand(&type10);
2891 auto roi3 = model->addOperand(&type11);
2892 auto param21 = model->addOperand(&type13);
2893 auto param22 = model->addOperand(&type5);
2894 auto param23 = model->addOperand(&type5);
2895 auto param24 = model->addOperand(&type6);
2896 auto param25 = model->addOperand(&type6);
2897 auto param26 = model->addOperand(&type5);
2898 auto param27 = model->addOperand(&type5);
2899 auto layout = model->addOperand(&type0);
2900 auto out3 = model->addOperand(&type38);
2901 // Phase 2, operations
2902 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2903 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2904 static int32_t param22_init[] = {2};
2905 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2906 static int32_t param23_init[] = {2};
2907 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2908 static float param24_init[] = {2.0f};
2909 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2910 static float param25_init[] = {1.0f};
2911 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2912 static int32_t param26_init[] = {0};
2913 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2914 static int32_t param27_init[] = {4};
2915 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2916 static bool8 layout_init[] = {false};
2917 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2918 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2919 // Phase 3, inputs and outputs
2920 model->identifyInputsAndOutputs(
2921 {in3, roi3},
2922 {out3});
2923 // Phase 4: set relaxed execution
2924 model->relaxComputationFloat32toFloat16(true);
2925 assert(model->isValid());
2926 }
2927
is_ignored_dynamic_output_shape_nhwc_relaxed_4(int i)2928 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_4(int i) {
2929 static std::set<int> ignore = {};
2930 return ignore.find(i) != ignore.end();
2931 }
2932
CreateModel_dynamic_output_shape_nhwc_quant8_4(Model * model)2933 void CreateModel_dynamic_output_shape_nhwc_quant8_4(Model *model) {
2934 OperandType type0(Type::BOOL, {});
2935 OperandType type13(Type::TENSOR_INT32, {5});
2936 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0625f, 128);
2937 OperandType type5(Type::INT32, {});
2938 OperandType type57(Type::TENSOR_QUANT8_ASYMM, {4, 4, 4, 1}, 0.25f, 128);
2939 OperandType type59(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
2940 OperandType type6(Type::FLOAT32, {});
2941 // Phase 1, operands
2942 auto in3 = model->addOperand(&type57);
2943 auto roi3 = model->addOperand(&type59);
2944 auto param21 = model->addOperand(&type13);
2945 auto param22 = model->addOperand(&type5);
2946 auto param23 = model->addOperand(&type5);
2947 auto param24 = model->addOperand(&type6);
2948 auto param25 = model->addOperand(&type6);
2949 auto param26 = model->addOperand(&type5);
2950 auto param27 = model->addOperand(&type5);
2951 auto layout = model->addOperand(&type0);
2952 auto out3 = model->addOperand(&type39);
2953 // Phase 2, operations
2954 static int32_t param21_init[] = {2, 2, 2, 2, 2};
2955 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
2956 static int32_t param22_init[] = {2};
2957 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
2958 static int32_t param23_init[] = {2};
2959 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
2960 static float param24_init[] = {2.0f};
2961 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
2962 static float param25_init[] = {1.0f};
2963 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
2964 static int32_t param26_init[] = {0};
2965 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
2966 static int32_t param27_init[] = {4};
2967 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
2968 static bool8 layout_init[] = {false};
2969 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2970 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
2971 // Phase 3, inputs and outputs
2972 model->identifyInputsAndOutputs(
2973 {in3, roi3},
2974 {out3});
2975 assert(model->isValid());
2976 }
2977
is_ignored_dynamic_output_shape_nhwc_quant8_4(int i)2978 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_4(int i) {
2979 static std::set<int> ignore = {};
2980 return ignore.find(i) != ignore.end();
2981 }
2982
CreateModel_dynamic_output_shape_nhwc_float16_4(Model * model)2983 void CreateModel_dynamic_output_shape_nhwc_float16_4(Model *model) {
2984 OperandType type0(Type::BOOL, {});
2985 OperandType type13(Type::TENSOR_INT32, {5});
2986 OperandType type30(Type::FLOAT16, {});
2987 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
2988 OperandType type5(Type::INT32, {});
2989 OperandType type60(Type::TENSOR_FLOAT16, {4, 4, 4, 1});
2990 OperandType type62(Type::TENSOR_FLOAT16, {5, 4});
2991 // Phase 1, operands
2992 auto in3 = model->addOperand(&type60);
2993 auto roi3 = model->addOperand(&type62);
2994 auto param21 = model->addOperand(&type13);
2995 auto param22 = model->addOperand(&type5);
2996 auto param23 = model->addOperand(&type5);
2997 auto param24 = model->addOperand(&type30);
2998 auto param25 = model->addOperand(&type30);
2999 auto param26 = model->addOperand(&type5);
3000 auto param27 = model->addOperand(&type5);
3001 auto layout = model->addOperand(&type0);
3002 auto out3 = model->addOperand(&type40);
3003 // Phase 2, operations
3004 static int32_t param21_init[] = {2, 2, 2, 2, 2};
3005 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
3006 static int32_t param22_init[] = {2};
3007 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
3008 static int32_t param23_init[] = {2};
3009 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
3010 static _Float16 param24_init[] = {2.0f};
3011 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1);
3012 static _Float16 param25_init[] = {1.0f};
3013 model->setOperandValue(param25, param25_init, sizeof(_Float16) * 1);
3014 static int32_t param26_init[] = {0};
3015 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
3016 static int32_t param27_init[] = {4};
3017 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
3018 static bool8 layout_init[] = {false};
3019 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3020 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
3021 // Phase 3, inputs and outputs
3022 model->identifyInputsAndOutputs(
3023 {in3, roi3},
3024 {out3});
3025 assert(model->isValid());
3026 }
3027
is_ignored_dynamic_output_shape_nhwc_float16_4(int i)3028 inline bool is_ignored_dynamic_output_shape_nhwc_float16_4(int i) {
3029 static std::set<int> ignore = {};
3030 return ignore.find(i) != ignore.end();
3031 }
3032
CreateModel_dynamic_output_shape_nchw_4(Model * model)3033 void CreateModel_dynamic_output_shape_nchw_4(Model *model) {
3034 OperandType type0(Type::BOOL, {});
3035 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
3036 OperandType type13(Type::TENSOR_INT32, {5});
3037 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
3038 OperandType type5(Type::INT32, {});
3039 OperandType type6(Type::FLOAT32, {});
3040 OperandType type63(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
3041 // Phase 1, operands
3042 auto in3 = model->addOperand(&type63);
3043 auto roi3 = model->addOperand(&type11);
3044 auto param21 = model->addOperand(&type13);
3045 auto param22 = model->addOperand(&type5);
3046 auto param23 = model->addOperand(&type5);
3047 auto param24 = model->addOperand(&type6);
3048 auto param25 = model->addOperand(&type6);
3049 auto param26 = model->addOperand(&type5);
3050 auto param27 = model->addOperand(&type5);
3051 auto layout = model->addOperand(&type0);
3052 auto out3 = model->addOperand(&type38);
3053 // Phase 2, operations
3054 static int32_t param21_init[] = {2, 2, 2, 2, 2};
3055 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
3056 static int32_t param22_init[] = {2};
3057 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
3058 static int32_t param23_init[] = {2};
3059 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
3060 static float param24_init[] = {2.0f};
3061 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
3062 static float param25_init[] = {1.0f};
3063 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
3064 static int32_t param26_init[] = {0};
3065 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
3066 static int32_t param27_init[] = {4};
3067 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
3068 static bool8 layout_init[] = {true};
3069 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3070 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
3071 // Phase 3, inputs and outputs
3072 model->identifyInputsAndOutputs(
3073 {in3, roi3},
3074 {out3});
3075 assert(model->isValid());
3076 }
3077
is_ignored_dynamic_output_shape_nchw_4(int i)3078 inline bool is_ignored_dynamic_output_shape_nchw_4(int i) {
3079 static std::set<int> ignore = {};
3080 return ignore.find(i) != ignore.end();
3081 }
3082
CreateModel_dynamic_output_shape_nchw_relaxed_4(Model * model)3083 void CreateModel_dynamic_output_shape_nchw_relaxed_4(Model *model) {
3084 OperandType type0(Type::BOOL, {});
3085 OperandType type11(Type::TENSOR_FLOAT32, {5, 4});
3086 OperandType type13(Type::TENSOR_INT32, {5});
3087 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
3088 OperandType type5(Type::INT32, {});
3089 OperandType type6(Type::FLOAT32, {});
3090 OperandType type63(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
3091 // Phase 1, operands
3092 auto in3 = model->addOperand(&type63);
3093 auto roi3 = model->addOperand(&type11);
3094 auto param21 = model->addOperand(&type13);
3095 auto param22 = model->addOperand(&type5);
3096 auto param23 = model->addOperand(&type5);
3097 auto param24 = model->addOperand(&type6);
3098 auto param25 = model->addOperand(&type6);
3099 auto param26 = model->addOperand(&type5);
3100 auto param27 = model->addOperand(&type5);
3101 auto layout = model->addOperand(&type0);
3102 auto out3 = model->addOperand(&type38);
3103 // Phase 2, operations
3104 static int32_t param21_init[] = {2, 2, 2, 2, 2};
3105 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
3106 static int32_t param22_init[] = {2};
3107 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
3108 static int32_t param23_init[] = {2};
3109 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
3110 static float param24_init[] = {2.0f};
3111 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
3112 static float param25_init[] = {1.0f};
3113 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
3114 static int32_t param26_init[] = {0};
3115 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
3116 static int32_t param27_init[] = {4};
3117 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
3118 static bool8 layout_init[] = {true};
3119 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3120 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
3121 // Phase 3, inputs and outputs
3122 model->identifyInputsAndOutputs(
3123 {in3, roi3},
3124 {out3});
3125 // Phase 4: set relaxed execution
3126 model->relaxComputationFloat32toFloat16(true);
3127 assert(model->isValid());
3128 }
3129
is_ignored_dynamic_output_shape_nchw_relaxed_4(int i)3130 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_4(int i) {
3131 static std::set<int> ignore = {};
3132 return ignore.find(i) != ignore.end();
3133 }
3134
CreateModel_dynamic_output_shape_nchw_quant8_4(Model * model)3135 void CreateModel_dynamic_output_shape_nchw_quant8_4(Model *model) {
3136 OperandType type0(Type::BOOL, {});
3137 OperandType type13(Type::TENSOR_INT32, {5});
3138 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0625f, 128);
3139 OperandType type5(Type::INT32, {});
3140 OperandType type59(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
3141 OperandType type6(Type::FLOAT32, {});
3142 OperandType type65(Type::TENSOR_QUANT8_ASYMM, {4, 1, 4, 4}, 0.25f, 128);
3143 // Phase 1, operands
3144 auto in3 = model->addOperand(&type65);
3145 auto roi3 = model->addOperand(&type59);
3146 auto param21 = model->addOperand(&type13);
3147 auto param22 = model->addOperand(&type5);
3148 auto param23 = model->addOperand(&type5);
3149 auto param24 = model->addOperand(&type6);
3150 auto param25 = model->addOperand(&type6);
3151 auto param26 = model->addOperand(&type5);
3152 auto param27 = model->addOperand(&type5);
3153 auto layout = model->addOperand(&type0);
3154 auto out3 = model->addOperand(&type39);
3155 // Phase 2, operations
3156 static int32_t param21_init[] = {2, 2, 2, 2, 2};
3157 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
3158 static int32_t param22_init[] = {2};
3159 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
3160 static int32_t param23_init[] = {2};
3161 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
3162 static float param24_init[] = {2.0f};
3163 model->setOperandValue(param24, param24_init, sizeof(float) * 1);
3164 static float param25_init[] = {1.0f};
3165 model->setOperandValue(param25, param25_init, sizeof(float) * 1);
3166 static int32_t param26_init[] = {0};
3167 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
3168 static int32_t param27_init[] = {4};
3169 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
3170 static bool8 layout_init[] = {true};
3171 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3172 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
3173 // Phase 3, inputs and outputs
3174 model->identifyInputsAndOutputs(
3175 {in3, roi3},
3176 {out3});
3177 assert(model->isValid());
3178 }
3179
is_ignored_dynamic_output_shape_nchw_quant8_4(int i)3180 inline bool is_ignored_dynamic_output_shape_nchw_quant8_4(int i) {
3181 static std::set<int> ignore = {};
3182 return ignore.find(i) != ignore.end();
3183 }
3184
CreateModel_dynamic_output_shape_nchw_float16_4(Model * model)3185 void CreateModel_dynamic_output_shape_nchw_float16_4(Model *model) {
3186 OperandType type0(Type::BOOL, {});
3187 OperandType type13(Type::TENSOR_INT32, {5});
3188 OperandType type30(Type::FLOAT16, {});
3189 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3190 OperandType type5(Type::INT32, {});
3191 OperandType type62(Type::TENSOR_FLOAT16, {5, 4});
3192 OperandType type67(Type::TENSOR_FLOAT16, {4, 1, 4, 4});
3193 // Phase 1, operands
3194 auto in3 = model->addOperand(&type67);
3195 auto roi3 = model->addOperand(&type62);
3196 auto param21 = model->addOperand(&type13);
3197 auto param22 = model->addOperand(&type5);
3198 auto param23 = model->addOperand(&type5);
3199 auto param24 = model->addOperand(&type30);
3200 auto param25 = model->addOperand(&type30);
3201 auto param26 = model->addOperand(&type5);
3202 auto param27 = model->addOperand(&type5);
3203 auto layout = model->addOperand(&type0);
3204 auto out3 = model->addOperand(&type40);
3205 // Phase 2, operations
3206 static int32_t param21_init[] = {2, 2, 2, 2, 2};
3207 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 5);
3208 static int32_t param22_init[] = {2};
3209 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
3210 static int32_t param23_init[] = {2};
3211 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
3212 static _Float16 param24_init[] = {2.0f};
3213 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1);
3214 static _Float16 param25_init[] = {1.0f};
3215 model->setOperandValue(param25, param25_init, sizeof(_Float16) * 1);
3216 static int32_t param26_init[] = {0};
3217 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
3218 static int32_t param27_init[] = {4};
3219 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
3220 static bool8 layout_init[] = {true};
3221 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3222 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in3, roi3, param21, param22, param23, param24, param25, param26, param27, layout}, {out3});
3223 // Phase 3, inputs and outputs
3224 model->identifyInputsAndOutputs(
3225 {in3, roi3},
3226 {out3});
3227 assert(model->isValid());
3228 }
3229
is_ignored_dynamic_output_shape_nchw_float16_4(int i)3230 inline bool is_ignored_dynamic_output_shape_nchw_float16_4(int i) {
3231 static std::set<int> ignore = {};
3232 return ignore.find(i) != ignore.end();
3233 }
3234
CreateModel_zero_sized_nhwc(Model * model)3235 void CreateModel_zero_sized_nhwc(Model *model) {
3236 OperandType type0(Type::BOOL, {});
3237 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
3238 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
3239 OperandType type16(Type::TENSOR_FLOAT32, {0});
3240 OperandType type17(Type::TENSOR_INT32, {0});
3241 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
3242 OperandType type19(Type::TENSOR_INT32, {1});
3243 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
3244 OperandType type21(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
3245 OperandType type5(Type::INT32, {});
3246 OperandType type6(Type::FLOAT32, {});
3247 // Phase 1, operands
3248 auto scores = model->addOperand(&type14);
3249 auto roi4 = model->addOperand(&type15);
3250 auto param28 = model->addOperand(&type19);
3251 auto param29 = model->addOperand(&type6);
3252 auto param30 = model->addOperand(&type5);
3253 auto param31 = model->addOperand(&type5);
3254 auto param32 = model->addOperand(&type6);
3255 auto param33 = model->addOperand(&type6);
3256 auto param34 = model->addOperand(&type6);
3257 auto scoresOut = model->addOperand(&type16);
3258 auto roiOut = model->addOperand(&type18);
3259 auto classesOut = model->addOperand(&type17);
3260 auto batchSplitOut = model->addOperand(&type17);
3261 auto in4 = model->addOperand(&type20);
3262 auto param35 = model->addOperand(&type5);
3263 auto param36 = model->addOperand(&type5);
3264 auto param37 = model->addOperand(&type6);
3265 auto param38 = model->addOperand(&type6);
3266 auto param39 = model->addOperand(&type5);
3267 auto param40 = model->addOperand(&type5);
3268 auto layout = model->addOperand(&type0);
3269 auto featureMap = model->addOperand(&type21);
3270 // Phase 2, operations
3271 static float scores_init[] = {0.9f, 0.1f};
3272 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
3273 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3274 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
3275 static int32_t param28_init[] = {0};
3276 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3277 static float param29_init[] = {0.3f};
3278 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3279 static int32_t param30_init[] = {-1};
3280 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3281 static int32_t param31_init[] = {0};
3282 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3283 static float param32_init[] = {0.4f};
3284 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3285 static float param33_init[] = {1.0f};
3286 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3287 static float param34_init[] = {0.3f};
3288 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3289 static int32_t param35_init[] = {2};
3290 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3291 static int32_t param36_init[] = {2};
3292 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3293 static float param37_init[] = {2.0f};
3294 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3295 static float param38_init[] = {2.0f};
3296 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3297 static int32_t param39_init[] = {4};
3298 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3299 static int32_t param40_init[] = {4};
3300 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3301 static bool8 layout_init[] = {false};
3302 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3303 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3304 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3305 // Phase 3, inputs and outputs
3306 model->identifyInputsAndOutputs(
3307 {in4},
3308 {scoresOut, classesOut, featureMap});
3309 assert(model->isValid());
3310 }
3311
is_ignored_zero_sized_nhwc(int i)3312 inline bool is_ignored_zero_sized_nhwc(int i) {
3313 static std::set<int> ignore = {};
3314 return ignore.find(i) != ignore.end();
3315 }
3316
CreateModel_zero_sized_nhwc_relaxed(Model * model)3317 void CreateModel_zero_sized_nhwc_relaxed(Model *model) {
3318 OperandType type0(Type::BOOL, {});
3319 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
3320 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
3321 OperandType type16(Type::TENSOR_FLOAT32, {0});
3322 OperandType type17(Type::TENSOR_INT32, {0});
3323 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
3324 OperandType type19(Type::TENSOR_INT32, {1});
3325 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
3326 OperandType type21(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
3327 OperandType type5(Type::INT32, {});
3328 OperandType type6(Type::FLOAT32, {});
3329 // Phase 1, operands
3330 auto scores = model->addOperand(&type14);
3331 auto roi4 = model->addOperand(&type15);
3332 auto param28 = model->addOperand(&type19);
3333 auto param29 = model->addOperand(&type6);
3334 auto param30 = model->addOperand(&type5);
3335 auto param31 = model->addOperand(&type5);
3336 auto param32 = model->addOperand(&type6);
3337 auto param33 = model->addOperand(&type6);
3338 auto param34 = model->addOperand(&type6);
3339 auto scoresOut = model->addOperand(&type16);
3340 auto roiOut = model->addOperand(&type18);
3341 auto classesOut = model->addOperand(&type17);
3342 auto batchSplitOut = model->addOperand(&type17);
3343 auto in4 = model->addOperand(&type20);
3344 auto param35 = model->addOperand(&type5);
3345 auto param36 = model->addOperand(&type5);
3346 auto param37 = model->addOperand(&type6);
3347 auto param38 = model->addOperand(&type6);
3348 auto param39 = model->addOperand(&type5);
3349 auto param40 = model->addOperand(&type5);
3350 auto layout = model->addOperand(&type0);
3351 auto featureMap = model->addOperand(&type21);
3352 // Phase 2, operations
3353 static float scores_init[] = {0.9f, 0.1f};
3354 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
3355 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3356 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
3357 static int32_t param28_init[] = {0};
3358 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3359 static float param29_init[] = {0.3f};
3360 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3361 static int32_t param30_init[] = {-1};
3362 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3363 static int32_t param31_init[] = {0};
3364 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3365 static float param32_init[] = {0.4f};
3366 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3367 static float param33_init[] = {1.0f};
3368 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3369 static float param34_init[] = {0.3f};
3370 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3371 static int32_t param35_init[] = {2};
3372 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3373 static int32_t param36_init[] = {2};
3374 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3375 static float param37_init[] = {2.0f};
3376 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3377 static float param38_init[] = {2.0f};
3378 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3379 static int32_t param39_init[] = {4};
3380 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3381 static int32_t param40_init[] = {4};
3382 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3383 static bool8 layout_init[] = {false};
3384 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3385 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3386 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3387 // Phase 3, inputs and outputs
3388 model->identifyInputsAndOutputs(
3389 {in4},
3390 {scoresOut, classesOut, featureMap});
3391 // Phase 4: set relaxed execution
3392 model->relaxComputationFloat32toFloat16(true);
3393 assert(model->isValid());
3394 }
3395
is_ignored_zero_sized_nhwc_relaxed(int i)3396 inline bool is_ignored_zero_sized_nhwc_relaxed(int i) {
3397 static std::set<int> ignore = {};
3398 return ignore.find(i) != ignore.end();
3399 }
3400
CreateModel_zero_sized_nhwc_quant8(Model * model)3401 void CreateModel_zero_sized_nhwc_quant8(Model *model) {
3402 OperandType type0(Type::BOOL, {});
3403 OperandType type17(Type::TENSOR_INT32, {0});
3404 OperandType type19(Type::TENSOR_INT32, {1});
3405 OperandType type5(Type::INT32, {});
3406 OperandType type6(Type::FLOAT32, {});
3407 OperandType type69(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
3408 OperandType type70(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
3409 OperandType type71(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
3410 OperandType type72(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
3411 OperandType type73(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
3412 OperandType type74(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
3413 // Phase 1, operands
3414 auto scores = model->addOperand(&type73);
3415 auto roi4 = model->addOperand(&type71);
3416 auto param28 = model->addOperand(&type19);
3417 auto param29 = model->addOperand(&type6);
3418 auto param30 = model->addOperand(&type5);
3419 auto param31 = model->addOperand(&type5);
3420 auto param32 = model->addOperand(&type6);
3421 auto param33 = model->addOperand(&type6);
3422 auto param34 = model->addOperand(&type6);
3423 auto scoresOut = model->addOperand(&type74);
3424 auto roiOut = model->addOperand(&type72);
3425 auto classesOut = model->addOperand(&type17);
3426 auto batchSplitOut = model->addOperand(&type17);
3427 auto in4 = model->addOperand(&type70);
3428 auto param35 = model->addOperand(&type5);
3429 auto param36 = model->addOperand(&type5);
3430 auto param37 = model->addOperand(&type6);
3431 auto param38 = model->addOperand(&type6);
3432 auto param39 = model->addOperand(&type5);
3433 auto param40 = model->addOperand(&type5);
3434 auto layout = model->addOperand(&type0);
3435 auto featureMap = model->addOperand(&type69);
3436 // Phase 2, operations
3437 static uint8_t scores_init[] = {137, 129};
3438 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
3439 static uint16_t roi4_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
3440 model->setOperandValue(roi4, roi4_init, sizeof(uint16_t) * 8);
3441 static int32_t param28_init[] = {0};
3442 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3443 static float param29_init[] = {0.3f};
3444 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3445 static int32_t param30_init[] = {-1};
3446 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3447 static int32_t param31_init[] = {0};
3448 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3449 static float param32_init[] = {0.4f};
3450 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3451 static float param33_init[] = {1.0f};
3452 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3453 static float param34_init[] = {0.3f};
3454 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3455 static int32_t param35_init[] = {2};
3456 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3457 static int32_t param36_init[] = {2};
3458 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3459 static float param37_init[] = {2.0f};
3460 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3461 static float param38_init[] = {2.0f};
3462 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3463 static int32_t param39_init[] = {4};
3464 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3465 static int32_t param40_init[] = {4};
3466 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3467 static bool8 layout_init[] = {false};
3468 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3469 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3470 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3471 // Phase 3, inputs and outputs
3472 model->identifyInputsAndOutputs(
3473 {in4},
3474 {scoresOut, classesOut, featureMap});
3475 assert(model->isValid());
3476 }
3477
is_ignored_zero_sized_nhwc_quant8(int i)3478 inline bool is_ignored_zero_sized_nhwc_quant8(int i) {
3479 static std::set<int> ignore = {};
3480 return ignore.find(i) != ignore.end();
3481 }
3482
CreateModel_zero_sized_nhwc_float16(Model * model)3483 void CreateModel_zero_sized_nhwc_float16(Model *model) {
3484 OperandType type0(Type::BOOL, {});
3485 OperandType type17(Type::TENSOR_INT32, {0});
3486 OperandType type19(Type::TENSOR_INT32, {1});
3487 OperandType type30(Type::FLOAT16, {});
3488 OperandType type5(Type::INT32, {});
3489 OperandType type75(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
3490 OperandType type76(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
3491 OperandType type77(Type::TENSOR_FLOAT16, {1, 8});
3492 OperandType type78(Type::TENSOR_FLOAT16, {0, 4});
3493 OperandType type79(Type::TENSOR_FLOAT16, {1, 2});
3494 OperandType type80(Type::TENSOR_FLOAT16, {0});
3495 // Phase 1, operands
3496 auto scores = model->addOperand(&type79);
3497 auto roi4 = model->addOperand(&type77);
3498 auto param28 = model->addOperand(&type19);
3499 auto param29 = model->addOperand(&type30);
3500 auto param30 = model->addOperand(&type5);
3501 auto param31 = model->addOperand(&type5);
3502 auto param32 = model->addOperand(&type30);
3503 auto param33 = model->addOperand(&type30);
3504 auto param34 = model->addOperand(&type30);
3505 auto scoresOut = model->addOperand(&type80);
3506 auto roiOut = model->addOperand(&type78);
3507 auto classesOut = model->addOperand(&type17);
3508 auto batchSplitOut = model->addOperand(&type17);
3509 auto in4 = model->addOperand(&type76);
3510 auto param35 = model->addOperand(&type5);
3511 auto param36 = model->addOperand(&type5);
3512 auto param37 = model->addOperand(&type30);
3513 auto param38 = model->addOperand(&type30);
3514 auto param39 = model->addOperand(&type5);
3515 auto param40 = model->addOperand(&type5);
3516 auto layout = model->addOperand(&type0);
3517 auto featureMap = model->addOperand(&type75);
3518 // Phase 2, operations
3519 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
3520 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
3521 static _Float16 roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3522 model->setOperandValue(roi4, roi4_init, sizeof(_Float16) * 8);
3523 static int32_t param28_init[] = {0};
3524 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3525 static _Float16 param29_init[] = {0.30000001192092896f};
3526 model->setOperandValue(param29, param29_init, sizeof(_Float16) * 1);
3527 static int32_t param30_init[] = {-1};
3528 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3529 static int32_t param31_init[] = {0};
3530 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3531 static _Float16 param32_init[] = {0.4000000059604645f};
3532 model->setOperandValue(param32, param32_init, sizeof(_Float16) * 1);
3533 static _Float16 param33_init[] = {1.0f};
3534 model->setOperandValue(param33, param33_init, sizeof(_Float16) * 1);
3535 static _Float16 param34_init[] = {0.30000001192092896f};
3536 model->setOperandValue(param34, param34_init, sizeof(_Float16) * 1);
3537 static int32_t param35_init[] = {2};
3538 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3539 static int32_t param36_init[] = {2};
3540 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3541 static _Float16 param37_init[] = {2.0f};
3542 model->setOperandValue(param37, param37_init, sizeof(_Float16) * 1);
3543 static _Float16 param38_init[] = {2.0f};
3544 model->setOperandValue(param38, param38_init, sizeof(_Float16) * 1);
3545 static int32_t param39_init[] = {4};
3546 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3547 static int32_t param40_init[] = {4};
3548 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3549 static bool8 layout_init[] = {false};
3550 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3551 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3552 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3553 // Phase 3, inputs and outputs
3554 model->identifyInputsAndOutputs(
3555 {in4},
3556 {scoresOut, classesOut, featureMap});
3557 assert(model->isValid());
3558 }
3559
is_ignored_zero_sized_nhwc_float16(int i)3560 inline bool is_ignored_zero_sized_nhwc_float16(int i) {
3561 static std::set<int> ignore = {};
3562 return ignore.find(i) != ignore.end();
3563 }
3564
CreateModel_zero_sized_nchw(Model * model)3565 void CreateModel_zero_sized_nchw(Model *model) {
3566 OperandType type0(Type::BOOL, {});
3567 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
3568 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
3569 OperandType type16(Type::TENSOR_FLOAT32, {0});
3570 OperandType type17(Type::TENSOR_INT32, {0});
3571 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
3572 OperandType type19(Type::TENSOR_INT32, {1});
3573 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
3574 OperandType type5(Type::INT32, {});
3575 OperandType type6(Type::FLOAT32, {});
3576 OperandType type81(Type::TENSOR_FLOAT32, {0, 1, 2, 2});
3577 // Phase 1, operands
3578 auto scores = model->addOperand(&type14);
3579 auto roi4 = model->addOperand(&type15);
3580 auto param28 = model->addOperand(&type19);
3581 auto param29 = model->addOperand(&type6);
3582 auto param30 = model->addOperand(&type5);
3583 auto param31 = model->addOperand(&type5);
3584 auto param32 = model->addOperand(&type6);
3585 auto param33 = model->addOperand(&type6);
3586 auto param34 = model->addOperand(&type6);
3587 auto scoresOut = model->addOperand(&type16);
3588 auto roiOut = model->addOperand(&type18);
3589 auto classesOut = model->addOperand(&type17);
3590 auto batchSplitOut = model->addOperand(&type17);
3591 auto in4 = model->addOperand(&type20);
3592 auto param35 = model->addOperand(&type5);
3593 auto param36 = model->addOperand(&type5);
3594 auto param37 = model->addOperand(&type6);
3595 auto param38 = model->addOperand(&type6);
3596 auto param39 = model->addOperand(&type5);
3597 auto param40 = model->addOperand(&type5);
3598 auto layout = model->addOperand(&type0);
3599 auto featureMap = model->addOperand(&type81);
3600 // Phase 2, operations
3601 static float scores_init[] = {0.9f, 0.1f};
3602 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
3603 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3604 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
3605 static int32_t param28_init[] = {0};
3606 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3607 static float param29_init[] = {0.3f};
3608 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3609 static int32_t param30_init[] = {-1};
3610 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3611 static int32_t param31_init[] = {0};
3612 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3613 static float param32_init[] = {0.4f};
3614 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3615 static float param33_init[] = {1.0f};
3616 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3617 static float param34_init[] = {0.3f};
3618 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3619 static int32_t param35_init[] = {2};
3620 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3621 static int32_t param36_init[] = {2};
3622 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3623 static float param37_init[] = {2.0f};
3624 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3625 static float param38_init[] = {2.0f};
3626 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3627 static int32_t param39_init[] = {4};
3628 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3629 static int32_t param40_init[] = {4};
3630 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3631 static bool8 layout_init[] = {true};
3632 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3633 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3634 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3635 // Phase 3, inputs and outputs
3636 model->identifyInputsAndOutputs(
3637 {in4},
3638 {scoresOut, classesOut, featureMap});
3639 assert(model->isValid());
3640 }
3641
is_ignored_zero_sized_nchw(int i)3642 inline bool is_ignored_zero_sized_nchw(int i) {
3643 static std::set<int> ignore = {};
3644 return ignore.find(i) != ignore.end();
3645 }
3646
CreateModel_zero_sized_nchw_relaxed(Model * model)3647 void CreateModel_zero_sized_nchw_relaxed(Model *model) {
3648 OperandType type0(Type::BOOL, {});
3649 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
3650 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
3651 OperandType type16(Type::TENSOR_FLOAT32, {0});
3652 OperandType type17(Type::TENSOR_INT32, {0});
3653 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
3654 OperandType type19(Type::TENSOR_INT32, {1});
3655 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
3656 OperandType type5(Type::INT32, {});
3657 OperandType type6(Type::FLOAT32, {});
3658 OperandType type81(Type::TENSOR_FLOAT32, {0, 1, 2, 2});
3659 // Phase 1, operands
3660 auto scores = model->addOperand(&type14);
3661 auto roi4 = model->addOperand(&type15);
3662 auto param28 = model->addOperand(&type19);
3663 auto param29 = model->addOperand(&type6);
3664 auto param30 = model->addOperand(&type5);
3665 auto param31 = model->addOperand(&type5);
3666 auto param32 = model->addOperand(&type6);
3667 auto param33 = model->addOperand(&type6);
3668 auto param34 = model->addOperand(&type6);
3669 auto scoresOut = model->addOperand(&type16);
3670 auto roiOut = model->addOperand(&type18);
3671 auto classesOut = model->addOperand(&type17);
3672 auto batchSplitOut = model->addOperand(&type17);
3673 auto in4 = model->addOperand(&type20);
3674 auto param35 = model->addOperand(&type5);
3675 auto param36 = model->addOperand(&type5);
3676 auto param37 = model->addOperand(&type6);
3677 auto param38 = model->addOperand(&type6);
3678 auto param39 = model->addOperand(&type5);
3679 auto param40 = model->addOperand(&type5);
3680 auto layout = model->addOperand(&type0);
3681 auto featureMap = model->addOperand(&type81);
3682 // Phase 2, operations
3683 static float scores_init[] = {0.9f, 0.1f};
3684 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
3685 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3686 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
3687 static int32_t param28_init[] = {0};
3688 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3689 static float param29_init[] = {0.3f};
3690 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3691 static int32_t param30_init[] = {-1};
3692 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3693 static int32_t param31_init[] = {0};
3694 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3695 static float param32_init[] = {0.4f};
3696 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3697 static float param33_init[] = {1.0f};
3698 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3699 static float param34_init[] = {0.3f};
3700 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3701 static int32_t param35_init[] = {2};
3702 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3703 static int32_t param36_init[] = {2};
3704 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3705 static float param37_init[] = {2.0f};
3706 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3707 static float param38_init[] = {2.0f};
3708 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3709 static int32_t param39_init[] = {4};
3710 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3711 static int32_t param40_init[] = {4};
3712 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3713 static bool8 layout_init[] = {true};
3714 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3715 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3716 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3717 // Phase 3, inputs and outputs
3718 model->identifyInputsAndOutputs(
3719 {in4},
3720 {scoresOut, classesOut, featureMap});
3721 // Phase 4: set relaxed execution
3722 model->relaxComputationFloat32toFloat16(true);
3723 assert(model->isValid());
3724 }
3725
is_ignored_zero_sized_nchw_relaxed(int i)3726 inline bool is_ignored_zero_sized_nchw_relaxed(int i) {
3727 static std::set<int> ignore = {};
3728 return ignore.find(i) != ignore.end();
3729 }
3730
CreateModel_zero_sized_nchw_quant8(Model * model)3731 void CreateModel_zero_sized_nchw_quant8(Model *model) {
3732 OperandType type0(Type::BOOL, {});
3733 OperandType type17(Type::TENSOR_INT32, {0});
3734 OperandType type19(Type::TENSOR_INT32, {1});
3735 OperandType type5(Type::INT32, {});
3736 OperandType type6(Type::FLOAT32, {});
3737 OperandType type70(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
3738 OperandType type71(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
3739 OperandType type72(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
3740 OperandType type73(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
3741 OperandType type74(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
3742 OperandType type82(Type::TENSOR_QUANT8_ASYMM, {0, 1, 2, 2}, 0.1f, 128);
3743 // Phase 1, operands
3744 auto scores = model->addOperand(&type73);
3745 auto roi4 = model->addOperand(&type71);
3746 auto param28 = model->addOperand(&type19);
3747 auto param29 = model->addOperand(&type6);
3748 auto param30 = model->addOperand(&type5);
3749 auto param31 = model->addOperand(&type5);
3750 auto param32 = model->addOperand(&type6);
3751 auto param33 = model->addOperand(&type6);
3752 auto param34 = model->addOperand(&type6);
3753 auto scoresOut = model->addOperand(&type74);
3754 auto roiOut = model->addOperand(&type72);
3755 auto classesOut = model->addOperand(&type17);
3756 auto batchSplitOut = model->addOperand(&type17);
3757 auto in4 = model->addOperand(&type70);
3758 auto param35 = model->addOperand(&type5);
3759 auto param36 = model->addOperand(&type5);
3760 auto param37 = model->addOperand(&type6);
3761 auto param38 = model->addOperand(&type6);
3762 auto param39 = model->addOperand(&type5);
3763 auto param40 = model->addOperand(&type5);
3764 auto layout = model->addOperand(&type0);
3765 auto featureMap = model->addOperand(&type82);
3766 // Phase 2, operations
3767 static uint8_t scores_init[] = {137, 129};
3768 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
3769 static uint16_t roi4_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
3770 model->setOperandValue(roi4, roi4_init, sizeof(uint16_t) * 8);
3771 static int32_t param28_init[] = {0};
3772 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3773 static float param29_init[] = {0.3f};
3774 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3775 static int32_t param30_init[] = {-1};
3776 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3777 static int32_t param31_init[] = {0};
3778 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3779 static float param32_init[] = {0.4f};
3780 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3781 static float param33_init[] = {1.0f};
3782 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3783 static float param34_init[] = {0.3f};
3784 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3785 static int32_t param35_init[] = {2};
3786 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3787 static int32_t param36_init[] = {2};
3788 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3789 static float param37_init[] = {2.0f};
3790 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3791 static float param38_init[] = {2.0f};
3792 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3793 static int32_t param39_init[] = {4};
3794 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3795 static int32_t param40_init[] = {4};
3796 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3797 static bool8 layout_init[] = {true};
3798 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3799 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3800 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3801 // Phase 3, inputs and outputs
3802 model->identifyInputsAndOutputs(
3803 {in4},
3804 {scoresOut, classesOut, featureMap});
3805 assert(model->isValid());
3806 }
3807
is_ignored_zero_sized_nchw_quant8(int i)3808 inline bool is_ignored_zero_sized_nchw_quant8(int i) {
3809 static std::set<int> ignore = {};
3810 return ignore.find(i) != ignore.end();
3811 }
3812
CreateModel_zero_sized_nchw_float16(Model * model)3813 void CreateModel_zero_sized_nchw_float16(Model *model) {
3814 OperandType type0(Type::BOOL, {});
3815 OperandType type17(Type::TENSOR_INT32, {0});
3816 OperandType type19(Type::TENSOR_INT32, {1});
3817 OperandType type30(Type::FLOAT16, {});
3818 OperandType type5(Type::INT32, {});
3819 OperandType type76(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
3820 OperandType type77(Type::TENSOR_FLOAT16, {1, 8});
3821 OperandType type78(Type::TENSOR_FLOAT16, {0, 4});
3822 OperandType type79(Type::TENSOR_FLOAT16, {1, 2});
3823 OperandType type80(Type::TENSOR_FLOAT16, {0});
3824 OperandType type83(Type::TENSOR_FLOAT16, {0, 1, 2, 2});
3825 // Phase 1, operands
3826 auto scores = model->addOperand(&type79);
3827 auto roi4 = model->addOperand(&type77);
3828 auto param28 = model->addOperand(&type19);
3829 auto param29 = model->addOperand(&type30);
3830 auto param30 = model->addOperand(&type5);
3831 auto param31 = model->addOperand(&type5);
3832 auto param32 = model->addOperand(&type30);
3833 auto param33 = model->addOperand(&type30);
3834 auto param34 = model->addOperand(&type30);
3835 auto scoresOut = model->addOperand(&type80);
3836 auto roiOut = model->addOperand(&type78);
3837 auto classesOut = model->addOperand(&type17);
3838 auto batchSplitOut = model->addOperand(&type17);
3839 auto in4 = model->addOperand(&type76);
3840 auto param35 = model->addOperand(&type5);
3841 auto param36 = model->addOperand(&type5);
3842 auto param37 = model->addOperand(&type30);
3843 auto param38 = model->addOperand(&type30);
3844 auto param39 = model->addOperand(&type5);
3845 auto param40 = model->addOperand(&type5);
3846 auto layout = model->addOperand(&type0);
3847 auto featureMap = model->addOperand(&type83);
3848 // Phase 2, operations
3849 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
3850 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
3851 static _Float16 roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3852 model->setOperandValue(roi4, roi4_init, sizeof(_Float16) * 8);
3853 static int32_t param28_init[] = {0};
3854 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3855 static _Float16 param29_init[] = {0.30000001192092896f};
3856 model->setOperandValue(param29, param29_init, sizeof(_Float16) * 1);
3857 static int32_t param30_init[] = {-1};
3858 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3859 static int32_t param31_init[] = {0};
3860 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3861 static _Float16 param32_init[] = {0.4000000059604645f};
3862 model->setOperandValue(param32, param32_init, sizeof(_Float16) * 1);
3863 static _Float16 param33_init[] = {1.0f};
3864 model->setOperandValue(param33, param33_init, sizeof(_Float16) * 1);
3865 static _Float16 param34_init[] = {0.30000001192092896f};
3866 model->setOperandValue(param34, param34_init, sizeof(_Float16) * 1);
3867 static int32_t param35_init[] = {2};
3868 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3869 static int32_t param36_init[] = {2};
3870 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3871 static _Float16 param37_init[] = {2.0f};
3872 model->setOperandValue(param37, param37_init, sizeof(_Float16) * 1);
3873 static _Float16 param38_init[] = {2.0f};
3874 model->setOperandValue(param38, param38_init, sizeof(_Float16) * 1);
3875 static int32_t param39_init[] = {4};
3876 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3877 static int32_t param40_init[] = {4};
3878 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3879 static bool8 layout_init[] = {true};
3880 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3881 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3882 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3883 // Phase 3, inputs and outputs
3884 model->identifyInputsAndOutputs(
3885 {in4},
3886 {scoresOut, classesOut, featureMap});
3887 assert(model->isValid());
3888 }
3889
is_ignored_zero_sized_nchw_float16(int i)3890 inline bool is_ignored_zero_sized_nchw_float16(int i) {
3891 static std::set<int> ignore = {};
3892 return ignore.find(i) != ignore.end();
3893 }
3894
CreateModel_zero_sized_dynamic_output_shape_nhwc(Model * model)3895 void CreateModel_zero_sized_dynamic_output_shape_nhwc(Model *model) {
3896 OperandType type0(Type::BOOL, {});
3897 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
3898 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
3899 OperandType type16(Type::TENSOR_FLOAT32, {0});
3900 OperandType type17(Type::TENSOR_INT32, {0});
3901 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
3902 OperandType type19(Type::TENSOR_INT32, {1});
3903 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
3904 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
3905 OperandType type5(Type::INT32, {});
3906 OperandType type6(Type::FLOAT32, {});
3907 // Phase 1, operands
3908 auto scores = model->addOperand(&type14);
3909 auto roi4 = model->addOperand(&type15);
3910 auto param28 = model->addOperand(&type19);
3911 auto param29 = model->addOperand(&type6);
3912 auto param30 = model->addOperand(&type5);
3913 auto param31 = model->addOperand(&type5);
3914 auto param32 = model->addOperand(&type6);
3915 auto param33 = model->addOperand(&type6);
3916 auto param34 = model->addOperand(&type6);
3917 auto scoresOut = model->addOperand(&type16);
3918 auto roiOut = model->addOperand(&type18);
3919 auto classesOut = model->addOperand(&type17);
3920 auto batchSplitOut = model->addOperand(&type17);
3921 auto in4 = model->addOperand(&type20);
3922 auto param35 = model->addOperand(&type5);
3923 auto param36 = model->addOperand(&type5);
3924 auto param37 = model->addOperand(&type6);
3925 auto param38 = model->addOperand(&type6);
3926 auto param39 = model->addOperand(&type5);
3927 auto param40 = model->addOperand(&type5);
3928 auto layout = model->addOperand(&type0);
3929 auto featureMap = model->addOperand(&type38);
3930 // Phase 2, operations
3931 static float scores_init[] = {0.9f, 0.1f};
3932 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
3933 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
3934 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
3935 static int32_t param28_init[] = {0};
3936 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
3937 static float param29_init[] = {0.3f};
3938 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
3939 static int32_t param30_init[] = {-1};
3940 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
3941 static int32_t param31_init[] = {0};
3942 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
3943 static float param32_init[] = {0.4f};
3944 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
3945 static float param33_init[] = {1.0f};
3946 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
3947 static float param34_init[] = {0.3f};
3948 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
3949 static int32_t param35_init[] = {2};
3950 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
3951 static int32_t param36_init[] = {2};
3952 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
3953 static float param37_init[] = {2.0f};
3954 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
3955 static float param38_init[] = {2.0f};
3956 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
3957 static int32_t param39_init[] = {4};
3958 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
3959 static int32_t param40_init[] = {4};
3960 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
3961 static bool8 layout_init[] = {false};
3962 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
3963 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
3964 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
3965 // Phase 3, inputs and outputs
3966 model->identifyInputsAndOutputs(
3967 {in4},
3968 {scoresOut, classesOut, featureMap});
3969 assert(model->isValid());
3970 }
3971
is_ignored_zero_sized_dynamic_output_shape_nhwc(int i)3972 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc(int i) {
3973 static std::set<int> ignore = {};
3974 return ignore.find(i) != ignore.end();
3975 }
3976
CreateModel_zero_sized_dynamic_output_shape_nhwc_relaxed(Model * model)3977 void CreateModel_zero_sized_dynamic_output_shape_nhwc_relaxed(Model *model) {
3978 OperandType type0(Type::BOOL, {});
3979 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
3980 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
3981 OperandType type16(Type::TENSOR_FLOAT32, {0});
3982 OperandType type17(Type::TENSOR_INT32, {0});
3983 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
3984 OperandType type19(Type::TENSOR_INT32, {1});
3985 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
3986 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
3987 OperandType type5(Type::INT32, {});
3988 OperandType type6(Type::FLOAT32, {});
3989 // Phase 1, operands
3990 auto scores = model->addOperand(&type14);
3991 auto roi4 = model->addOperand(&type15);
3992 auto param28 = model->addOperand(&type19);
3993 auto param29 = model->addOperand(&type6);
3994 auto param30 = model->addOperand(&type5);
3995 auto param31 = model->addOperand(&type5);
3996 auto param32 = model->addOperand(&type6);
3997 auto param33 = model->addOperand(&type6);
3998 auto param34 = model->addOperand(&type6);
3999 auto scoresOut = model->addOperand(&type16);
4000 auto roiOut = model->addOperand(&type18);
4001 auto classesOut = model->addOperand(&type17);
4002 auto batchSplitOut = model->addOperand(&type17);
4003 auto in4 = model->addOperand(&type20);
4004 auto param35 = model->addOperand(&type5);
4005 auto param36 = model->addOperand(&type5);
4006 auto param37 = model->addOperand(&type6);
4007 auto param38 = model->addOperand(&type6);
4008 auto param39 = model->addOperand(&type5);
4009 auto param40 = model->addOperand(&type5);
4010 auto layout = model->addOperand(&type0);
4011 auto featureMap = model->addOperand(&type38);
4012 // Phase 2, operations
4013 static float scores_init[] = {0.9f, 0.1f};
4014 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
4015 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
4016 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
4017 static int32_t param28_init[] = {0};
4018 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4019 static float param29_init[] = {0.3f};
4020 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
4021 static int32_t param30_init[] = {-1};
4022 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4023 static int32_t param31_init[] = {0};
4024 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4025 static float param32_init[] = {0.4f};
4026 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
4027 static float param33_init[] = {1.0f};
4028 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
4029 static float param34_init[] = {0.3f};
4030 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
4031 static int32_t param35_init[] = {2};
4032 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4033 static int32_t param36_init[] = {2};
4034 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4035 static float param37_init[] = {2.0f};
4036 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
4037 static float param38_init[] = {2.0f};
4038 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
4039 static int32_t param39_init[] = {4};
4040 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4041 static int32_t param40_init[] = {4};
4042 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4043 static bool8 layout_init[] = {false};
4044 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4045 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4046 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4047 // Phase 3, inputs and outputs
4048 model->identifyInputsAndOutputs(
4049 {in4},
4050 {scoresOut, classesOut, featureMap});
4051 // Phase 4: set relaxed execution
4052 model->relaxComputationFloat32toFloat16(true);
4053 assert(model->isValid());
4054 }
4055
is_ignored_zero_sized_dynamic_output_shape_nhwc_relaxed(int i)4056 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc_relaxed(int i) {
4057 static std::set<int> ignore = {};
4058 return ignore.find(i) != ignore.end();
4059 }
4060
CreateModel_zero_sized_dynamic_output_shape_nhwc_quant8(Model * model)4061 void CreateModel_zero_sized_dynamic_output_shape_nhwc_quant8(Model *model) {
4062 OperandType type0(Type::BOOL, {});
4063 OperandType type17(Type::TENSOR_INT32, {0});
4064 OperandType type19(Type::TENSOR_INT32, {1});
4065 OperandType type5(Type::INT32, {});
4066 OperandType type6(Type::FLOAT32, {});
4067 OperandType type70(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
4068 OperandType type71(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
4069 OperandType type72(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
4070 OperandType type73(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
4071 OperandType type74(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
4072 OperandType type84(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.1f, 128);
4073 // Phase 1, operands
4074 auto scores = model->addOperand(&type73);
4075 auto roi4 = model->addOperand(&type71);
4076 auto param28 = model->addOperand(&type19);
4077 auto param29 = model->addOperand(&type6);
4078 auto param30 = model->addOperand(&type5);
4079 auto param31 = model->addOperand(&type5);
4080 auto param32 = model->addOperand(&type6);
4081 auto param33 = model->addOperand(&type6);
4082 auto param34 = model->addOperand(&type6);
4083 auto scoresOut = model->addOperand(&type74);
4084 auto roiOut = model->addOperand(&type72);
4085 auto classesOut = model->addOperand(&type17);
4086 auto batchSplitOut = model->addOperand(&type17);
4087 auto in4 = model->addOperand(&type70);
4088 auto param35 = model->addOperand(&type5);
4089 auto param36 = model->addOperand(&type5);
4090 auto param37 = model->addOperand(&type6);
4091 auto param38 = model->addOperand(&type6);
4092 auto param39 = model->addOperand(&type5);
4093 auto param40 = model->addOperand(&type5);
4094 auto layout = model->addOperand(&type0);
4095 auto featureMap = model->addOperand(&type84);
4096 // Phase 2, operations
4097 static uint8_t scores_init[] = {137, 129};
4098 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
4099 static uint16_t roi4_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
4100 model->setOperandValue(roi4, roi4_init, sizeof(uint16_t) * 8);
4101 static int32_t param28_init[] = {0};
4102 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4103 static float param29_init[] = {0.3f};
4104 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
4105 static int32_t param30_init[] = {-1};
4106 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4107 static int32_t param31_init[] = {0};
4108 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4109 static float param32_init[] = {0.4f};
4110 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
4111 static float param33_init[] = {1.0f};
4112 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
4113 static float param34_init[] = {0.3f};
4114 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
4115 static int32_t param35_init[] = {2};
4116 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4117 static int32_t param36_init[] = {2};
4118 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4119 static float param37_init[] = {2.0f};
4120 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
4121 static float param38_init[] = {2.0f};
4122 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
4123 static int32_t param39_init[] = {4};
4124 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4125 static int32_t param40_init[] = {4};
4126 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4127 static bool8 layout_init[] = {false};
4128 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4129 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4130 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4131 // Phase 3, inputs and outputs
4132 model->identifyInputsAndOutputs(
4133 {in4},
4134 {scoresOut, classesOut, featureMap});
4135 assert(model->isValid());
4136 }
4137
is_ignored_zero_sized_dynamic_output_shape_nhwc_quant8(int i)4138 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc_quant8(int i) {
4139 static std::set<int> ignore = {};
4140 return ignore.find(i) != ignore.end();
4141 }
4142
CreateModel_zero_sized_dynamic_output_shape_nhwc_float16(Model * model)4143 void CreateModel_zero_sized_dynamic_output_shape_nhwc_float16(Model *model) {
4144 OperandType type0(Type::BOOL, {});
4145 OperandType type17(Type::TENSOR_INT32, {0});
4146 OperandType type19(Type::TENSOR_INT32, {1});
4147 OperandType type30(Type::FLOAT16, {});
4148 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
4149 OperandType type5(Type::INT32, {});
4150 OperandType type76(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
4151 OperandType type77(Type::TENSOR_FLOAT16, {1, 8});
4152 OperandType type78(Type::TENSOR_FLOAT16, {0, 4});
4153 OperandType type79(Type::TENSOR_FLOAT16, {1, 2});
4154 OperandType type85(Type::TENSOR_FLOAT16, {0});
4155 // Phase 1, operands
4156 auto scores = model->addOperand(&type79);
4157 auto roi4 = model->addOperand(&type77);
4158 auto param28 = model->addOperand(&type19);
4159 auto param29 = model->addOperand(&type30);
4160 auto param30 = model->addOperand(&type5);
4161 auto param31 = model->addOperand(&type5);
4162 auto param32 = model->addOperand(&type30);
4163 auto param33 = model->addOperand(&type30);
4164 auto param34 = model->addOperand(&type30);
4165 auto scoresOut = model->addOperand(&type85);
4166 auto roiOut = model->addOperand(&type78);
4167 auto classesOut = model->addOperand(&type17);
4168 auto batchSplitOut = model->addOperand(&type17);
4169 auto in4 = model->addOperand(&type76);
4170 auto param35 = model->addOperand(&type5);
4171 auto param36 = model->addOperand(&type5);
4172 auto param37 = model->addOperand(&type30);
4173 auto param38 = model->addOperand(&type30);
4174 auto param39 = model->addOperand(&type5);
4175 auto param40 = model->addOperand(&type5);
4176 auto layout = model->addOperand(&type0);
4177 auto featureMap = model->addOperand(&type40);
4178 // Phase 2, operations
4179 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
4180 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
4181 static _Float16 roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
4182 model->setOperandValue(roi4, roi4_init, sizeof(_Float16) * 8);
4183 static int32_t param28_init[] = {0};
4184 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4185 static _Float16 param29_init[] = {0.30000001192092896f};
4186 model->setOperandValue(param29, param29_init, sizeof(_Float16) * 1);
4187 static int32_t param30_init[] = {-1};
4188 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4189 static int32_t param31_init[] = {0};
4190 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4191 static _Float16 param32_init[] = {0.4000000059604645f};
4192 model->setOperandValue(param32, param32_init, sizeof(_Float16) * 1);
4193 static _Float16 param33_init[] = {1.0f};
4194 model->setOperandValue(param33, param33_init, sizeof(_Float16) * 1);
4195 static _Float16 param34_init[] = {0.30000001192092896f};
4196 model->setOperandValue(param34, param34_init, sizeof(_Float16) * 1);
4197 static int32_t param35_init[] = {2};
4198 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4199 static int32_t param36_init[] = {2};
4200 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4201 static _Float16 param37_init[] = {2.0f};
4202 model->setOperandValue(param37, param37_init, sizeof(_Float16) * 1);
4203 static _Float16 param38_init[] = {2.0f};
4204 model->setOperandValue(param38, param38_init, sizeof(_Float16) * 1);
4205 static int32_t param39_init[] = {4};
4206 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4207 static int32_t param40_init[] = {4};
4208 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4209 static bool8 layout_init[] = {false};
4210 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4211 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4212 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4213 // Phase 3, inputs and outputs
4214 model->identifyInputsAndOutputs(
4215 {in4},
4216 {scoresOut, classesOut, featureMap});
4217 assert(model->isValid());
4218 }
4219
is_ignored_zero_sized_dynamic_output_shape_nhwc_float16(int i)4220 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc_float16(int i) {
4221 static std::set<int> ignore = {};
4222 return ignore.find(i) != ignore.end();
4223 }
4224
CreateModel_zero_sized_dynamic_output_shape_nchw(Model * model)4225 void CreateModel_zero_sized_dynamic_output_shape_nchw(Model *model) {
4226 OperandType type0(Type::BOOL, {});
4227 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
4228 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
4229 OperandType type16(Type::TENSOR_FLOAT32, {0});
4230 OperandType type17(Type::TENSOR_INT32, {0});
4231 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
4232 OperandType type19(Type::TENSOR_INT32, {1});
4233 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
4234 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
4235 OperandType type5(Type::INT32, {});
4236 OperandType type6(Type::FLOAT32, {});
4237 // Phase 1, operands
4238 auto scores = model->addOperand(&type14);
4239 auto roi4 = model->addOperand(&type15);
4240 auto param28 = model->addOperand(&type19);
4241 auto param29 = model->addOperand(&type6);
4242 auto param30 = model->addOperand(&type5);
4243 auto param31 = model->addOperand(&type5);
4244 auto param32 = model->addOperand(&type6);
4245 auto param33 = model->addOperand(&type6);
4246 auto param34 = model->addOperand(&type6);
4247 auto scoresOut = model->addOperand(&type16);
4248 auto roiOut = model->addOperand(&type18);
4249 auto classesOut = model->addOperand(&type17);
4250 auto batchSplitOut = model->addOperand(&type17);
4251 auto in4 = model->addOperand(&type20);
4252 auto param35 = model->addOperand(&type5);
4253 auto param36 = model->addOperand(&type5);
4254 auto param37 = model->addOperand(&type6);
4255 auto param38 = model->addOperand(&type6);
4256 auto param39 = model->addOperand(&type5);
4257 auto param40 = model->addOperand(&type5);
4258 auto layout = model->addOperand(&type0);
4259 auto featureMap = model->addOperand(&type38);
4260 // Phase 2, operations
4261 static float scores_init[] = {0.9f, 0.1f};
4262 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
4263 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
4264 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
4265 static int32_t param28_init[] = {0};
4266 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4267 static float param29_init[] = {0.3f};
4268 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
4269 static int32_t param30_init[] = {-1};
4270 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4271 static int32_t param31_init[] = {0};
4272 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4273 static float param32_init[] = {0.4f};
4274 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
4275 static float param33_init[] = {1.0f};
4276 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
4277 static float param34_init[] = {0.3f};
4278 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
4279 static int32_t param35_init[] = {2};
4280 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4281 static int32_t param36_init[] = {2};
4282 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4283 static float param37_init[] = {2.0f};
4284 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
4285 static float param38_init[] = {2.0f};
4286 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
4287 static int32_t param39_init[] = {4};
4288 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4289 static int32_t param40_init[] = {4};
4290 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4291 static bool8 layout_init[] = {true};
4292 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4293 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4294 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4295 // Phase 3, inputs and outputs
4296 model->identifyInputsAndOutputs(
4297 {in4},
4298 {scoresOut, classesOut, featureMap});
4299 assert(model->isValid());
4300 }
4301
is_ignored_zero_sized_dynamic_output_shape_nchw(int i)4302 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw(int i) {
4303 static std::set<int> ignore = {};
4304 return ignore.find(i) != ignore.end();
4305 }
4306
CreateModel_zero_sized_dynamic_output_shape_nchw_relaxed(Model * model)4307 void CreateModel_zero_sized_dynamic_output_shape_nchw_relaxed(Model *model) {
4308 OperandType type0(Type::BOOL, {});
4309 OperandType type14(Type::TENSOR_FLOAT32, {1, 2});
4310 OperandType type15(Type::TENSOR_FLOAT32, {1, 8});
4311 OperandType type16(Type::TENSOR_FLOAT32, {0});
4312 OperandType type17(Type::TENSOR_INT32, {0});
4313 OperandType type18(Type::TENSOR_FLOAT32, {0, 4});
4314 OperandType type19(Type::TENSOR_INT32, {1});
4315 OperandType type20(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
4316 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
4317 OperandType type5(Type::INT32, {});
4318 OperandType type6(Type::FLOAT32, {});
4319 // Phase 1, operands
4320 auto scores = model->addOperand(&type14);
4321 auto roi4 = model->addOperand(&type15);
4322 auto param28 = model->addOperand(&type19);
4323 auto param29 = model->addOperand(&type6);
4324 auto param30 = model->addOperand(&type5);
4325 auto param31 = model->addOperand(&type5);
4326 auto param32 = model->addOperand(&type6);
4327 auto param33 = model->addOperand(&type6);
4328 auto param34 = model->addOperand(&type6);
4329 auto scoresOut = model->addOperand(&type16);
4330 auto roiOut = model->addOperand(&type18);
4331 auto classesOut = model->addOperand(&type17);
4332 auto batchSplitOut = model->addOperand(&type17);
4333 auto in4 = model->addOperand(&type20);
4334 auto param35 = model->addOperand(&type5);
4335 auto param36 = model->addOperand(&type5);
4336 auto param37 = model->addOperand(&type6);
4337 auto param38 = model->addOperand(&type6);
4338 auto param39 = model->addOperand(&type5);
4339 auto param40 = model->addOperand(&type5);
4340 auto layout = model->addOperand(&type0);
4341 auto featureMap = model->addOperand(&type38);
4342 // Phase 2, operations
4343 static float scores_init[] = {0.9f, 0.1f};
4344 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
4345 static float roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
4346 model->setOperandValue(roi4, roi4_init, sizeof(float) * 8);
4347 static int32_t param28_init[] = {0};
4348 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4349 static float param29_init[] = {0.3f};
4350 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
4351 static int32_t param30_init[] = {-1};
4352 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4353 static int32_t param31_init[] = {0};
4354 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4355 static float param32_init[] = {0.4f};
4356 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
4357 static float param33_init[] = {1.0f};
4358 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
4359 static float param34_init[] = {0.3f};
4360 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
4361 static int32_t param35_init[] = {2};
4362 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4363 static int32_t param36_init[] = {2};
4364 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4365 static float param37_init[] = {2.0f};
4366 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
4367 static float param38_init[] = {2.0f};
4368 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
4369 static int32_t param39_init[] = {4};
4370 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4371 static int32_t param40_init[] = {4};
4372 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4373 static bool8 layout_init[] = {true};
4374 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4375 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4376 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4377 // Phase 3, inputs and outputs
4378 model->identifyInputsAndOutputs(
4379 {in4},
4380 {scoresOut, classesOut, featureMap});
4381 // Phase 4: set relaxed execution
4382 model->relaxComputationFloat32toFloat16(true);
4383 assert(model->isValid());
4384 }
4385
is_ignored_zero_sized_dynamic_output_shape_nchw_relaxed(int i)4386 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw_relaxed(int i) {
4387 static std::set<int> ignore = {};
4388 return ignore.find(i) != ignore.end();
4389 }
4390
CreateModel_zero_sized_dynamic_output_shape_nchw_quant8(Model * model)4391 void CreateModel_zero_sized_dynamic_output_shape_nchw_quant8(Model *model) {
4392 OperandType type0(Type::BOOL, {});
4393 OperandType type17(Type::TENSOR_INT32, {0});
4394 OperandType type19(Type::TENSOR_INT32, {1});
4395 OperandType type5(Type::INT32, {});
4396 OperandType type6(Type::FLOAT32, {});
4397 OperandType type70(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
4398 OperandType type71(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
4399 OperandType type72(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
4400 OperandType type73(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
4401 OperandType type74(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
4402 OperandType type84(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.1f, 128);
4403 // Phase 1, operands
4404 auto scores = model->addOperand(&type73);
4405 auto roi4 = model->addOperand(&type71);
4406 auto param28 = model->addOperand(&type19);
4407 auto param29 = model->addOperand(&type6);
4408 auto param30 = model->addOperand(&type5);
4409 auto param31 = model->addOperand(&type5);
4410 auto param32 = model->addOperand(&type6);
4411 auto param33 = model->addOperand(&type6);
4412 auto param34 = model->addOperand(&type6);
4413 auto scoresOut = model->addOperand(&type74);
4414 auto roiOut = model->addOperand(&type72);
4415 auto classesOut = model->addOperand(&type17);
4416 auto batchSplitOut = model->addOperand(&type17);
4417 auto in4 = model->addOperand(&type70);
4418 auto param35 = model->addOperand(&type5);
4419 auto param36 = model->addOperand(&type5);
4420 auto param37 = model->addOperand(&type6);
4421 auto param38 = model->addOperand(&type6);
4422 auto param39 = model->addOperand(&type5);
4423 auto param40 = model->addOperand(&type5);
4424 auto layout = model->addOperand(&type0);
4425 auto featureMap = model->addOperand(&type84);
4426 // Phase 2, operations
4427 static uint8_t scores_init[] = {137, 129};
4428 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
4429 static uint16_t roi4_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
4430 model->setOperandValue(roi4, roi4_init, sizeof(uint16_t) * 8);
4431 static int32_t param28_init[] = {0};
4432 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4433 static float param29_init[] = {0.3f};
4434 model->setOperandValue(param29, param29_init, sizeof(float) * 1);
4435 static int32_t param30_init[] = {-1};
4436 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4437 static int32_t param31_init[] = {0};
4438 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4439 static float param32_init[] = {0.4f};
4440 model->setOperandValue(param32, param32_init, sizeof(float) * 1);
4441 static float param33_init[] = {1.0f};
4442 model->setOperandValue(param33, param33_init, sizeof(float) * 1);
4443 static float param34_init[] = {0.3f};
4444 model->setOperandValue(param34, param34_init, sizeof(float) * 1);
4445 static int32_t param35_init[] = {2};
4446 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4447 static int32_t param36_init[] = {2};
4448 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4449 static float param37_init[] = {2.0f};
4450 model->setOperandValue(param37, param37_init, sizeof(float) * 1);
4451 static float param38_init[] = {2.0f};
4452 model->setOperandValue(param38, param38_init, sizeof(float) * 1);
4453 static int32_t param39_init[] = {4};
4454 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4455 static int32_t param40_init[] = {4};
4456 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4457 static bool8 layout_init[] = {true};
4458 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4459 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4460 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4461 // Phase 3, inputs and outputs
4462 model->identifyInputsAndOutputs(
4463 {in4},
4464 {scoresOut, classesOut, featureMap});
4465 assert(model->isValid());
4466 }
4467
is_ignored_zero_sized_dynamic_output_shape_nchw_quant8(int i)4468 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw_quant8(int i) {
4469 static std::set<int> ignore = {};
4470 return ignore.find(i) != ignore.end();
4471 }
4472
CreateModel_zero_sized_dynamic_output_shape_nchw_float16(Model * model)4473 void CreateModel_zero_sized_dynamic_output_shape_nchw_float16(Model *model) {
4474 OperandType type0(Type::BOOL, {});
4475 OperandType type17(Type::TENSOR_INT32, {0});
4476 OperandType type19(Type::TENSOR_INT32, {1});
4477 OperandType type30(Type::FLOAT16, {});
4478 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
4479 OperandType type5(Type::INT32, {});
4480 OperandType type76(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
4481 OperandType type77(Type::TENSOR_FLOAT16, {1, 8});
4482 OperandType type78(Type::TENSOR_FLOAT16, {0, 4});
4483 OperandType type79(Type::TENSOR_FLOAT16, {1, 2});
4484 OperandType type85(Type::TENSOR_FLOAT16, {0});
4485 // Phase 1, operands
4486 auto scores = model->addOperand(&type79);
4487 auto roi4 = model->addOperand(&type77);
4488 auto param28 = model->addOperand(&type19);
4489 auto param29 = model->addOperand(&type30);
4490 auto param30 = model->addOperand(&type5);
4491 auto param31 = model->addOperand(&type5);
4492 auto param32 = model->addOperand(&type30);
4493 auto param33 = model->addOperand(&type30);
4494 auto param34 = model->addOperand(&type30);
4495 auto scoresOut = model->addOperand(&type85);
4496 auto roiOut = model->addOperand(&type78);
4497 auto classesOut = model->addOperand(&type17);
4498 auto batchSplitOut = model->addOperand(&type17);
4499 auto in4 = model->addOperand(&type76);
4500 auto param35 = model->addOperand(&type5);
4501 auto param36 = model->addOperand(&type5);
4502 auto param37 = model->addOperand(&type30);
4503 auto param38 = model->addOperand(&type30);
4504 auto param39 = model->addOperand(&type5);
4505 auto param40 = model->addOperand(&type5);
4506 auto layout = model->addOperand(&type0);
4507 auto featureMap = model->addOperand(&type40);
4508 // Phase 2, operations
4509 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
4510 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
4511 static _Float16 roi4_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
4512 model->setOperandValue(roi4, roi4_init, sizeof(_Float16) * 8);
4513 static int32_t param28_init[] = {0};
4514 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
4515 static _Float16 param29_init[] = {0.30000001192092896f};
4516 model->setOperandValue(param29, param29_init, sizeof(_Float16) * 1);
4517 static int32_t param30_init[] = {-1};
4518 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
4519 static int32_t param31_init[] = {0};
4520 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
4521 static _Float16 param32_init[] = {0.4000000059604645f};
4522 model->setOperandValue(param32, param32_init, sizeof(_Float16) * 1);
4523 static _Float16 param33_init[] = {1.0f};
4524 model->setOperandValue(param33, param33_init, sizeof(_Float16) * 1);
4525 static _Float16 param34_init[] = {0.30000001192092896f};
4526 model->setOperandValue(param34, param34_init, sizeof(_Float16) * 1);
4527 static int32_t param35_init[] = {2};
4528 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
4529 static int32_t param36_init[] = {2};
4530 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
4531 static _Float16 param37_init[] = {2.0f};
4532 model->setOperandValue(param37, param37_init, sizeof(_Float16) * 1);
4533 static _Float16 param38_init[] = {2.0f};
4534 model->setOperandValue(param38, param38_init, sizeof(_Float16) * 1);
4535 static int32_t param39_init[] = {4};
4536 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
4537 static int32_t param40_init[] = {4};
4538 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
4539 static bool8 layout_init[] = {true};
4540 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4541 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi4, param28, param29, param30, param31, param32, param33, param34}, {scoresOut, roiOut, classesOut, batchSplitOut});
4542 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in4, roiOut, batchSplitOut, param35, param36, param37, param38, param39, param40, layout}, {featureMap});
4543 // Phase 3, inputs and outputs
4544 model->identifyInputsAndOutputs(
4545 {in4},
4546 {scoresOut, classesOut, featureMap});
4547 assert(model->isValid());
4548 }
4549
is_ignored_zero_sized_dynamic_output_shape_nchw_float16(int i)4550 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw_float16(int i) {
4551 static std::set<int> ignore = {};
4552 return ignore.find(i) != ignore.end();
4553 }
4554
CreateModel_nhwc_5(Model * model)4555 void CreateModel_nhwc_5(Model *model) {
4556 OperandType type0(Type::BOOL, {});
4557 OperandType type19(Type::TENSOR_INT32, {1});
4558 OperandType type22(Type::TENSOR_FLOAT32, {1, 512, 8, 1});
4559 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
4560 OperandType type24(Type::TENSOR_FLOAT32, {1, 128, 4, 1});
4561 OperandType type5(Type::INT32, {});
4562 OperandType type6(Type::FLOAT32, {});
4563 // Phase 1, operands
4564 auto in5 = model->addOperand(&type22);
4565 auto roi5 = model->addOperand(&type23);
4566 auto param41 = model->addOperand(&type19);
4567 auto param42 = model->addOperand(&type5);
4568 auto param43 = model->addOperand(&type5);
4569 auto param44 = model->addOperand(&type6);
4570 auto param45 = model->addOperand(&type6);
4571 auto param46 = model->addOperand(&type5);
4572 auto param47 = model->addOperand(&type5);
4573 auto layout = model->addOperand(&type0);
4574 auto out4 = model->addOperand(&type24);
4575 // Phase 2, operations
4576 static int32_t param41_init[] = {0};
4577 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4578 static int32_t param42_init[] = {128};
4579 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4580 static int32_t param43_init[] = {4};
4581 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4582 static float param44_init[] = {1.0f};
4583 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4584 static float param45_init[] = {64.0f};
4585 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4586 static int32_t param46_init[] = {10};
4587 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4588 static int32_t param47_init[] = {10};
4589 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4590 static bool8 layout_init[] = {false};
4591 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4592 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4593 // Phase 3, inputs and outputs
4594 model->identifyInputsAndOutputs(
4595 {in5, roi5},
4596 {out4});
4597 assert(model->isValid());
4598 }
4599
is_ignored_nhwc_5(int i)4600 inline bool is_ignored_nhwc_5(int i) {
4601 static std::set<int> ignore = {};
4602 return ignore.find(i) != ignore.end();
4603 }
4604
CreateModel_nhwc_relaxed_5(Model * model)4605 void CreateModel_nhwc_relaxed_5(Model *model) {
4606 OperandType type0(Type::BOOL, {});
4607 OperandType type19(Type::TENSOR_INT32, {1});
4608 OperandType type22(Type::TENSOR_FLOAT32, {1, 512, 8, 1});
4609 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
4610 OperandType type24(Type::TENSOR_FLOAT32, {1, 128, 4, 1});
4611 OperandType type5(Type::INT32, {});
4612 OperandType type6(Type::FLOAT32, {});
4613 // Phase 1, operands
4614 auto in5 = model->addOperand(&type22);
4615 auto roi5 = model->addOperand(&type23);
4616 auto param41 = model->addOperand(&type19);
4617 auto param42 = model->addOperand(&type5);
4618 auto param43 = model->addOperand(&type5);
4619 auto param44 = model->addOperand(&type6);
4620 auto param45 = model->addOperand(&type6);
4621 auto param46 = model->addOperand(&type5);
4622 auto param47 = model->addOperand(&type5);
4623 auto layout = model->addOperand(&type0);
4624 auto out4 = model->addOperand(&type24);
4625 // Phase 2, operations
4626 static int32_t param41_init[] = {0};
4627 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4628 static int32_t param42_init[] = {128};
4629 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4630 static int32_t param43_init[] = {4};
4631 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4632 static float param44_init[] = {1.0f};
4633 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4634 static float param45_init[] = {64.0f};
4635 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4636 static int32_t param46_init[] = {10};
4637 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4638 static int32_t param47_init[] = {10};
4639 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4640 static bool8 layout_init[] = {false};
4641 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4642 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4643 // Phase 3, inputs and outputs
4644 model->identifyInputsAndOutputs(
4645 {in5, roi5},
4646 {out4});
4647 // Phase 4: set relaxed execution
4648 model->relaxComputationFloat32toFloat16(true);
4649 assert(model->isValid());
4650 }
4651
is_ignored_nhwc_relaxed_5(int i)4652 inline bool is_ignored_nhwc_relaxed_5(int i) {
4653 static std::set<int> ignore = {};
4654 return ignore.find(i) != ignore.end();
4655 }
4656
CreateModel_nhwc_quant8_5(Model * model)4657 void CreateModel_nhwc_quant8_5(Model *model) {
4658 OperandType type0(Type::BOOL, {});
4659 OperandType type19(Type::TENSOR_INT32, {1});
4660 OperandType type5(Type::INT32, {});
4661 OperandType type6(Type::FLOAT32, {});
4662 OperandType type86(Type::TENSOR_QUANT8_ASYMM, {1, 512, 8, 1}, 0.25f, 128);
4663 OperandType type87(Type::TENSOR_QUANT8_ASYMM, {1, 128, 4, 1}, 0.0625f, 128);
4664 OperandType type88(Type::TENSOR_QUANT16_ASYMM, {1, 4}, 0.125f, 0);
4665 // Phase 1, operands
4666 auto in5 = model->addOperand(&type86);
4667 auto roi5 = model->addOperand(&type88);
4668 auto param41 = model->addOperand(&type19);
4669 auto param42 = model->addOperand(&type5);
4670 auto param43 = model->addOperand(&type5);
4671 auto param44 = model->addOperand(&type6);
4672 auto param45 = model->addOperand(&type6);
4673 auto param46 = model->addOperand(&type5);
4674 auto param47 = model->addOperand(&type5);
4675 auto layout = model->addOperand(&type0);
4676 auto out4 = model->addOperand(&type87);
4677 // Phase 2, operations
4678 static int32_t param41_init[] = {0};
4679 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4680 static int32_t param42_init[] = {128};
4681 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4682 static int32_t param43_init[] = {4};
4683 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4684 static float param44_init[] = {1.0f};
4685 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4686 static float param45_init[] = {64.0f};
4687 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4688 static int32_t param46_init[] = {10};
4689 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4690 static int32_t param47_init[] = {10};
4691 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4692 static bool8 layout_init[] = {false};
4693 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4694 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4695 // Phase 3, inputs and outputs
4696 model->identifyInputsAndOutputs(
4697 {in5, roi5},
4698 {out4});
4699 assert(model->isValid());
4700 }
4701
is_ignored_nhwc_quant8_5(int i)4702 inline bool is_ignored_nhwc_quant8_5(int i) {
4703 static std::set<int> ignore = {};
4704 return ignore.find(i) != ignore.end();
4705 }
4706
CreateModel_nhwc_float16_5(Model * model)4707 void CreateModel_nhwc_float16_5(Model *model) {
4708 OperandType type0(Type::BOOL, {});
4709 OperandType type19(Type::TENSOR_INT32, {1});
4710 OperandType type30(Type::FLOAT16, {});
4711 OperandType type5(Type::INT32, {});
4712 OperandType type89(Type::TENSOR_FLOAT16, {1, 512, 8, 1});
4713 OperandType type90(Type::TENSOR_FLOAT16, {1, 128, 4, 1});
4714 OperandType type91(Type::TENSOR_FLOAT16, {1, 4});
4715 // Phase 1, operands
4716 auto in5 = model->addOperand(&type89);
4717 auto roi5 = model->addOperand(&type91);
4718 auto param41 = model->addOperand(&type19);
4719 auto param42 = model->addOperand(&type5);
4720 auto param43 = model->addOperand(&type5);
4721 auto param44 = model->addOperand(&type30);
4722 auto param45 = model->addOperand(&type30);
4723 auto param46 = model->addOperand(&type5);
4724 auto param47 = model->addOperand(&type5);
4725 auto layout = model->addOperand(&type0);
4726 auto out4 = model->addOperand(&type90);
4727 // Phase 2, operations
4728 static int32_t param41_init[] = {0};
4729 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4730 static int32_t param42_init[] = {128};
4731 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4732 static int32_t param43_init[] = {4};
4733 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4734 static _Float16 param44_init[] = {1.0f};
4735 model->setOperandValue(param44, param44_init, sizeof(_Float16) * 1);
4736 static _Float16 param45_init[] = {64.0f};
4737 model->setOperandValue(param45, param45_init, sizeof(_Float16) * 1);
4738 static int32_t param46_init[] = {10};
4739 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4740 static int32_t param47_init[] = {10};
4741 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4742 static bool8 layout_init[] = {false};
4743 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4744 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4745 // Phase 3, inputs and outputs
4746 model->identifyInputsAndOutputs(
4747 {in5, roi5},
4748 {out4});
4749 assert(model->isValid());
4750 }
4751
is_ignored_nhwc_float16_5(int i)4752 inline bool is_ignored_nhwc_float16_5(int i) {
4753 static std::set<int> ignore = {};
4754 return ignore.find(i) != ignore.end();
4755 }
4756
CreateModel_nchw_5(Model * model)4757 void CreateModel_nchw_5(Model *model) {
4758 OperandType type0(Type::BOOL, {});
4759 OperandType type19(Type::TENSOR_INT32, {1});
4760 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
4761 OperandType type5(Type::INT32, {});
4762 OperandType type6(Type::FLOAT32, {});
4763 OperandType type92(Type::TENSOR_FLOAT32, {1, 1, 512, 8});
4764 OperandType type93(Type::TENSOR_FLOAT32, {1, 1, 128, 4});
4765 // Phase 1, operands
4766 auto in5 = model->addOperand(&type92);
4767 auto roi5 = model->addOperand(&type23);
4768 auto param41 = model->addOperand(&type19);
4769 auto param42 = model->addOperand(&type5);
4770 auto param43 = model->addOperand(&type5);
4771 auto param44 = model->addOperand(&type6);
4772 auto param45 = model->addOperand(&type6);
4773 auto param46 = model->addOperand(&type5);
4774 auto param47 = model->addOperand(&type5);
4775 auto layout = model->addOperand(&type0);
4776 auto out4 = model->addOperand(&type93);
4777 // Phase 2, operations
4778 static int32_t param41_init[] = {0};
4779 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4780 static int32_t param42_init[] = {128};
4781 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4782 static int32_t param43_init[] = {4};
4783 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4784 static float param44_init[] = {1.0f};
4785 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4786 static float param45_init[] = {64.0f};
4787 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4788 static int32_t param46_init[] = {10};
4789 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4790 static int32_t param47_init[] = {10};
4791 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4792 static bool8 layout_init[] = {true};
4793 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4794 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4795 // Phase 3, inputs and outputs
4796 model->identifyInputsAndOutputs(
4797 {in5, roi5},
4798 {out4});
4799 assert(model->isValid());
4800 }
4801
is_ignored_nchw_5(int i)4802 inline bool is_ignored_nchw_5(int i) {
4803 static std::set<int> ignore = {};
4804 return ignore.find(i) != ignore.end();
4805 }
4806
CreateModel_nchw_relaxed_5(Model * model)4807 void CreateModel_nchw_relaxed_5(Model *model) {
4808 OperandType type0(Type::BOOL, {});
4809 OperandType type19(Type::TENSOR_INT32, {1});
4810 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
4811 OperandType type5(Type::INT32, {});
4812 OperandType type6(Type::FLOAT32, {});
4813 OperandType type92(Type::TENSOR_FLOAT32, {1, 1, 512, 8});
4814 OperandType type93(Type::TENSOR_FLOAT32, {1, 1, 128, 4});
4815 // Phase 1, operands
4816 auto in5 = model->addOperand(&type92);
4817 auto roi5 = model->addOperand(&type23);
4818 auto param41 = model->addOperand(&type19);
4819 auto param42 = model->addOperand(&type5);
4820 auto param43 = model->addOperand(&type5);
4821 auto param44 = model->addOperand(&type6);
4822 auto param45 = model->addOperand(&type6);
4823 auto param46 = model->addOperand(&type5);
4824 auto param47 = model->addOperand(&type5);
4825 auto layout = model->addOperand(&type0);
4826 auto out4 = model->addOperand(&type93);
4827 // Phase 2, operations
4828 static int32_t param41_init[] = {0};
4829 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4830 static int32_t param42_init[] = {128};
4831 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4832 static int32_t param43_init[] = {4};
4833 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4834 static float param44_init[] = {1.0f};
4835 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4836 static float param45_init[] = {64.0f};
4837 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4838 static int32_t param46_init[] = {10};
4839 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4840 static int32_t param47_init[] = {10};
4841 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4842 static bool8 layout_init[] = {true};
4843 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4844 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4845 // Phase 3, inputs and outputs
4846 model->identifyInputsAndOutputs(
4847 {in5, roi5},
4848 {out4});
4849 // Phase 4: set relaxed execution
4850 model->relaxComputationFloat32toFloat16(true);
4851 assert(model->isValid());
4852 }
4853
is_ignored_nchw_relaxed_5(int i)4854 inline bool is_ignored_nchw_relaxed_5(int i) {
4855 static std::set<int> ignore = {};
4856 return ignore.find(i) != ignore.end();
4857 }
4858
CreateModel_nchw_quant8_5(Model * model)4859 void CreateModel_nchw_quant8_5(Model *model) {
4860 OperandType type0(Type::BOOL, {});
4861 OperandType type19(Type::TENSOR_INT32, {1});
4862 OperandType type5(Type::INT32, {});
4863 OperandType type6(Type::FLOAT32, {});
4864 OperandType type88(Type::TENSOR_QUANT16_ASYMM, {1, 4}, 0.125f, 0);
4865 OperandType type94(Type::TENSOR_QUANT8_ASYMM, {1, 1, 512, 8}, 0.25f, 128);
4866 OperandType type95(Type::TENSOR_QUANT8_ASYMM, {1, 1, 128, 4}, 0.0625f, 128);
4867 // Phase 1, operands
4868 auto in5 = model->addOperand(&type94);
4869 auto roi5 = model->addOperand(&type88);
4870 auto param41 = model->addOperand(&type19);
4871 auto param42 = model->addOperand(&type5);
4872 auto param43 = model->addOperand(&type5);
4873 auto param44 = model->addOperand(&type6);
4874 auto param45 = model->addOperand(&type6);
4875 auto param46 = model->addOperand(&type5);
4876 auto param47 = model->addOperand(&type5);
4877 auto layout = model->addOperand(&type0);
4878 auto out4 = model->addOperand(&type95);
4879 // Phase 2, operations
4880 static int32_t param41_init[] = {0};
4881 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4882 static int32_t param42_init[] = {128};
4883 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4884 static int32_t param43_init[] = {4};
4885 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4886 static float param44_init[] = {1.0f};
4887 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4888 static float param45_init[] = {64.0f};
4889 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4890 static int32_t param46_init[] = {10};
4891 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4892 static int32_t param47_init[] = {10};
4893 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4894 static bool8 layout_init[] = {true};
4895 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4896 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4897 // Phase 3, inputs and outputs
4898 model->identifyInputsAndOutputs(
4899 {in5, roi5},
4900 {out4});
4901 assert(model->isValid());
4902 }
4903
is_ignored_nchw_quant8_5(int i)4904 inline bool is_ignored_nchw_quant8_5(int i) {
4905 static std::set<int> ignore = {};
4906 return ignore.find(i) != ignore.end();
4907 }
4908
CreateModel_nchw_float16_5(Model * model)4909 void CreateModel_nchw_float16_5(Model *model) {
4910 OperandType type0(Type::BOOL, {});
4911 OperandType type19(Type::TENSOR_INT32, {1});
4912 OperandType type30(Type::FLOAT16, {});
4913 OperandType type5(Type::INT32, {});
4914 OperandType type91(Type::TENSOR_FLOAT16, {1, 4});
4915 OperandType type96(Type::TENSOR_FLOAT16, {1, 1, 512, 8});
4916 OperandType type97(Type::TENSOR_FLOAT16, {1, 1, 128, 4});
4917 // Phase 1, operands
4918 auto in5 = model->addOperand(&type96);
4919 auto roi5 = model->addOperand(&type91);
4920 auto param41 = model->addOperand(&type19);
4921 auto param42 = model->addOperand(&type5);
4922 auto param43 = model->addOperand(&type5);
4923 auto param44 = model->addOperand(&type30);
4924 auto param45 = model->addOperand(&type30);
4925 auto param46 = model->addOperand(&type5);
4926 auto param47 = model->addOperand(&type5);
4927 auto layout = model->addOperand(&type0);
4928 auto out4 = model->addOperand(&type97);
4929 // Phase 2, operations
4930 static int32_t param41_init[] = {0};
4931 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4932 static int32_t param42_init[] = {128};
4933 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4934 static int32_t param43_init[] = {4};
4935 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4936 static _Float16 param44_init[] = {1.0f};
4937 model->setOperandValue(param44, param44_init, sizeof(_Float16) * 1);
4938 static _Float16 param45_init[] = {64.0f};
4939 model->setOperandValue(param45, param45_init, sizeof(_Float16) * 1);
4940 static int32_t param46_init[] = {10};
4941 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4942 static int32_t param47_init[] = {10};
4943 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4944 static bool8 layout_init[] = {true};
4945 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4946 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4947 // Phase 3, inputs and outputs
4948 model->identifyInputsAndOutputs(
4949 {in5, roi5},
4950 {out4});
4951 assert(model->isValid());
4952 }
4953
is_ignored_nchw_float16_5(int i)4954 inline bool is_ignored_nchw_float16_5(int i) {
4955 static std::set<int> ignore = {};
4956 return ignore.find(i) != ignore.end();
4957 }
4958
CreateModel_dynamic_output_shape_nhwc_5(Model * model)4959 void CreateModel_dynamic_output_shape_nhwc_5(Model *model) {
4960 OperandType type0(Type::BOOL, {});
4961 OperandType type19(Type::TENSOR_INT32, {1});
4962 OperandType type22(Type::TENSOR_FLOAT32, {1, 512, 8, 1});
4963 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
4964 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
4965 OperandType type5(Type::INT32, {});
4966 OperandType type6(Type::FLOAT32, {});
4967 // Phase 1, operands
4968 auto in5 = model->addOperand(&type22);
4969 auto roi5 = model->addOperand(&type23);
4970 auto param41 = model->addOperand(&type19);
4971 auto param42 = model->addOperand(&type5);
4972 auto param43 = model->addOperand(&type5);
4973 auto param44 = model->addOperand(&type6);
4974 auto param45 = model->addOperand(&type6);
4975 auto param46 = model->addOperand(&type5);
4976 auto param47 = model->addOperand(&type5);
4977 auto layout = model->addOperand(&type0);
4978 auto out4 = model->addOperand(&type38);
4979 // Phase 2, operations
4980 static int32_t param41_init[] = {0};
4981 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
4982 static int32_t param42_init[] = {128};
4983 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
4984 static int32_t param43_init[] = {4};
4985 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
4986 static float param44_init[] = {1.0f};
4987 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
4988 static float param45_init[] = {64.0f};
4989 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
4990 static int32_t param46_init[] = {10};
4991 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
4992 static int32_t param47_init[] = {10};
4993 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
4994 static bool8 layout_init[] = {false};
4995 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
4996 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
4997 // Phase 3, inputs and outputs
4998 model->identifyInputsAndOutputs(
4999 {in5, roi5},
5000 {out4});
5001 assert(model->isValid());
5002 }
5003
is_ignored_dynamic_output_shape_nhwc_5(int i)5004 inline bool is_ignored_dynamic_output_shape_nhwc_5(int i) {
5005 static std::set<int> ignore = {};
5006 return ignore.find(i) != ignore.end();
5007 }
5008
CreateModel_dynamic_output_shape_nhwc_relaxed_5(Model * model)5009 void CreateModel_dynamic_output_shape_nhwc_relaxed_5(Model *model) {
5010 OperandType type0(Type::BOOL, {});
5011 OperandType type19(Type::TENSOR_INT32, {1});
5012 OperandType type22(Type::TENSOR_FLOAT32, {1, 512, 8, 1});
5013 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
5014 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
5015 OperandType type5(Type::INT32, {});
5016 OperandType type6(Type::FLOAT32, {});
5017 // Phase 1, operands
5018 auto in5 = model->addOperand(&type22);
5019 auto roi5 = model->addOperand(&type23);
5020 auto param41 = model->addOperand(&type19);
5021 auto param42 = model->addOperand(&type5);
5022 auto param43 = model->addOperand(&type5);
5023 auto param44 = model->addOperand(&type6);
5024 auto param45 = model->addOperand(&type6);
5025 auto param46 = model->addOperand(&type5);
5026 auto param47 = model->addOperand(&type5);
5027 auto layout = model->addOperand(&type0);
5028 auto out4 = model->addOperand(&type38);
5029 // Phase 2, operations
5030 static int32_t param41_init[] = {0};
5031 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5032 static int32_t param42_init[] = {128};
5033 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5034 static int32_t param43_init[] = {4};
5035 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5036 static float param44_init[] = {1.0f};
5037 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
5038 static float param45_init[] = {64.0f};
5039 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
5040 static int32_t param46_init[] = {10};
5041 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5042 static int32_t param47_init[] = {10};
5043 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5044 static bool8 layout_init[] = {false};
5045 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5046 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5047 // Phase 3, inputs and outputs
5048 model->identifyInputsAndOutputs(
5049 {in5, roi5},
5050 {out4});
5051 // Phase 4: set relaxed execution
5052 model->relaxComputationFloat32toFloat16(true);
5053 assert(model->isValid());
5054 }
5055
is_ignored_dynamic_output_shape_nhwc_relaxed_5(int i)5056 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_5(int i) {
5057 static std::set<int> ignore = {};
5058 return ignore.find(i) != ignore.end();
5059 }
5060
CreateModel_dynamic_output_shape_nhwc_quant8_5(Model * model)5061 void CreateModel_dynamic_output_shape_nhwc_quant8_5(Model *model) {
5062 OperandType type0(Type::BOOL, {});
5063 OperandType type19(Type::TENSOR_INT32, {1});
5064 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0625f, 128);
5065 OperandType type5(Type::INT32, {});
5066 OperandType type6(Type::FLOAT32, {});
5067 OperandType type86(Type::TENSOR_QUANT8_ASYMM, {1, 512, 8, 1}, 0.25f, 128);
5068 OperandType type88(Type::TENSOR_QUANT16_ASYMM, {1, 4}, 0.125f, 0);
5069 // Phase 1, operands
5070 auto in5 = model->addOperand(&type86);
5071 auto roi5 = model->addOperand(&type88);
5072 auto param41 = model->addOperand(&type19);
5073 auto param42 = model->addOperand(&type5);
5074 auto param43 = model->addOperand(&type5);
5075 auto param44 = model->addOperand(&type6);
5076 auto param45 = model->addOperand(&type6);
5077 auto param46 = model->addOperand(&type5);
5078 auto param47 = model->addOperand(&type5);
5079 auto layout = model->addOperand(&type0);
5080 auto out4 = model->addOperand(&type39);
5081 // Phase 2, operations
5082 static int32_t param41_init[] = {0};
5083 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5084 static int32_t param42_init[] = {128};
5085 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5086 static int32_t param43_init[] = {4};
5087 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5088 static float param44_init[] = {1.0f};
5089 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
5090 static float param45_init[] = {64.0f};
5091 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
5092 static int32_t param46_init[] = {10};
5093 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5094 static int32_t param47_init[] = {10};
5095 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5096 static bool8 layout_init[] = {false};
5097 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5098 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5099 // Phase 3, inputs and outputs
5100 model->identifyInputsAndOutputs(
5101 {in5, roi5},
5102 {out4});
5103 assert(model->isValid());
5104 }
5105
is_ignored_dynamic_output_shape_nhwc_quant8_5(int i)5106 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_5(int i) {
5107 static std::set<int> ignore = {};
5108 return ignore.find(i) != ignore.end();
5109 }
5110
CreateModel_dynamic_output_shape_nhwc_float16_5(Model * model)5111 void CreateModel_dynamic_output_shape_nhwc_float16_5(Model *model) {
5112 OperandType type0(Type::BOOL, {});
5113 OperandType type19(Type::TENSOR_INT32, {1});
5114 OperandType type30(Type::FLOAT16, {});
5115 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
5116 OperandType type5(Type::INT32, {});
5117 OperandType type89(Type::TENSOR_FLOAT16, {1, 512, 8, 1});
5118 OperandType type91(Type::TENSOR_FLOAT16, {1, 4});
5119 // Phase 1, operands
5120 auto in5 = model->addOperand(&type89);
5121 auto roi5 = model->addOperand(&type91);
5122 auto param41 = model->addOperand(&type19);
5123 auto param42 = model->addOperand(&type5);
5124 auto param43 = model->addOperand(&type5);
5125 auto param44 = model->addOperand(&type30);
5126 auto param45 = model->addOperand(&type30);
5127 auto param46 = model->addOperand(&type5);
5128 auto param47 = model->addOperand(&type5);
5129 auto layout = model->addOperand(&type0);
5130 auto out4 = model->addOperand(&type40);
5131 // Phase 2, operations
5132 static int32_t param41_init[] = {0};
5133 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5134 static int32_t param42_init[] = {128};
5135 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5136 static int32_t param43_init[] = {4};
5137 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5138 static _Float16 param44_init[] = {1.0f};
5139 model->setOperandValue(param44, param44_init, sizeof(_Float16) * 1);
5140 static _Float16 param45_init[] = {64.0f};
5141 model->setOperandValue(param45, param45_init, sizeof(_Float16) * 1);
5142 static int32_t param46_init[] = {10};
5143 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5144 static int32_t param47_init[] = {10};
5145 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5146 static bool8 layout_init[] = {false};
5147 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5148 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5149 // Phase 3, inputs and outputs
5150 model->identifyInputsAndOutputs(
5151 {in5, roi5},
5152 {out4});
5153 assert(model->isValid());
5154 }
5155
is_ignored_dynamic_output_shape_nhwc_float16_5(int i)5156 inline bool is_ignored_dynamic_output_shape_nhwc_float16_5(int i) {
5157 static std::set<int> ignore = {};
5158 return ignore.find(i) != ignore.end();
5159 }
5160
CreateModel_dynamic_output_shape_nchw_5(Model * model)5161 void CreateModel_dynamic_output_shape_nchw_5(Model *model) {
5162 OperandType type0(Type::BOOL, {});
5163 OperandType type19(Type::TENSOR_INT32, {1});
5164 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
5165 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
5166 OperandType type5(Type::INT32, {});
5167 OperandType type6(Type::FLOAT32, {});
5168 OperandType type92(Type::TENSOR_FLOAT32, {1, 1, 512, 8});
5169 // Phase 1, operands
5170 auto in5 = model->addOperand(&type92);
5171 auto roi5 = model->addOperand(&type23);
5172 auto param41 = model->addOperand(&type19);
5173 auto param42 = model->addOperand(&type5);
5174 auto param43 = model->addOperand(&type5);
5175 auto param44 = model->addOperand(&type6);
5176 auto param45 = model->addOperand(&type6);
5177 auto param46 = model->addOperand(&type5);
5178 auto param47 = model->addOperand(&type5);
5179 auto layout = model->addOperand(&type0);
5180 auto out4 = model->addOperand(&type38);
5181 // Phase 2, operations
5182 static int32_t param41_init[] = {0};
5183 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5184 static int32_t param42_init[] = {128};
5185 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5186 static int32_t param43_init[] = {4};
5187 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5188 static float param44_init[] = {1.0f};
5189 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
5190 static float param45_init[] = {64.0f};
5191 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
5192 static int32_t param46_init[] = {10};
5193 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5194 static int32_t param47_init[] = {10};
5195 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5196 static bool8 layout_init[] = {true};
5197 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5198 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5199 // Phase 3, inputs and outputs
5200 model->identifyInputsAndOutputs(
5201 {in5, roi5},
5202 {out4});
5203 assert(model->isValid());
5204 }
5205
is_ignored_dynamic_output_shape_nchw_5(int i)5206 inline bool is_ignored_dynamic_output_shape_nchw_5(int i) {
5207 static std::set<int> ignore = {};
5208 return ignore.find(i) != ignore.end();
5209 }
5210
CreateModel_dynamic_output_shape_nchw_relaxed_5(Model * model)5211 void CreateModel_dynamic_output_shape_nchw_relaxed_5(Model *model) {
5212 OperandType type0(Type::BOOL, {});
5213 OperandType type19(Type::TENSOR_INT32, {1});
5214 OperandType type23(Type::TENSOR_FLOAT32, {1, 4});
5215 OperandType type38(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
5216 OperandType type5(Type::INT32, {});
5217 OperandType type6(Type::FLOAT32, {});
5218 OperandType type92(Type::TENSOR_FLOAT32, {1, 1, 512, 8});
5219 // Phase 1, operands
5220 auto in5 = model->addOperand(&type92);
5221 auto roi5 = model->addOperand(&type23);
5222 auto param41 = model->addOperand(&type19);
5223 auto param42 = model->addOperand(&type5);
5224 auto param43 = model->addOperand(&type5);
5225 auto param44 = model->addOperand(&type6);
5226 auto param45 = model->addOperand(&type6);
5227 auto param46 = model->addOperand(&type5);
5228 auto param47 = model->addOperand(&type5);
5229 auto layout = model->addOperand(&type0);
5230 auto out4 = model->addOperand(&type38);
5231 // Phase 2, operations
5232 static int32_t param41_init[] = {0};
5233 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5234 static int32_t param42_init[] = {128};
5235 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5236 static int32_t param43_init[] = {4};
5237 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5238 static float param44_init[] = {1.0f};
5239 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
5240 static float param45_init[] = {64.0f};
5241 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
5242 static int32_t param46_init[] = {10};
5243 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5244 static int32_t param47_init[] = {10};
5245 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5246 static bool8 layout_init[] = {true};
5247 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5248 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5249 // Phase 3, inputs and outputs
5250 model->identifyInputsAndOutputs(
5251 {in5, roi5},
5252 {out4});
5253 // Phase 4: set relaxed execution
5254 model->relaxComputationFloat32toFloat16(true);
5255 assert(model->isValid());
5256 }
5257
is_ignored_dynamic_output_shape_nchw_relaxed_5(int i)5258 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_5(int i) {
5259 static std::set<int> ignore = {};
5260 return ignore.find(i) != ignore.end();
5261 }
5262
CreateModel_dynamic_output_shape_nchw_quant8_5(Model * model)5263 void CreateModel_dynamic_output_shape_nchw_quant8_5(Model *model) {
5264 OperandType type0(Type::BOOL, {});
5265 OperandType type19(Type::TENSOR_INT32, {1});
5266 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0625f, 128);
5267 OperandType type5(Type::INT32, {});
5268 OperandType type6(Type::FLOAT32, {});
5269 OperandType type88(Type::TENSOR_QUANT16_ASYMM, {1, 4}, 0.125f, 0);
5270 OperandType type94(Type::TENSOR_QUANT8_ASYMM, {1, 1, 512, 8}, 0.25f, 128);
5271 // Phase 1, operands
5272 auto in5 = model->addOperand(&type94);
5273 auto roi5 = model->addOperand(&type88);
5274 auto param41 = model->addOperand(&type19);
5275 auto param42 = model->addOperand(&type5);
5276 auto param43 = model->addOperand(&type5);
5277 auto param44 = model->addOperand(&type6);
5278 auto param45 = model->addOperand(&type6);
5279 auto param46 = model->addOperand(&type5);
5280 auto param47 = model->addOperand(&type5);
5281 auto layout = model->addOperand(&type0);
5282 auto out4 = model->addOperand(&type39);
5283 // Phase 2, operations
5284 static int32_t param41_init[] = {0};
5285 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5286 static int32_t param42_init[] = {128};
5287 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5288 static int32_t param43_init[] = {4};
5289 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5290 static float param44_init[] = {1.0f};
5291 model->setOperandValue(param44, param44_init, sizeof(float) * 1);
5292 static float param45_init[] = {64.0f};
5293 model->setOperandValue(param45, param45_init, sizeof(float) * 1);
5294 static int32_t param46_init[] = {10};
5295 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5296 static int32_t param47_init[] = {10};
5297 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5298 static bool8 layout_init[] = {true};
5299 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5300 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5301 // Phase 3, inputs and outputs
5302 model->identifyInputsAndOutputs(
5303 {in5, roi5},
5304 {out4});
5305 assert(model->isValid());
5306 }
5307
is_ignored_dynamic_output_shape_nchw_quant8_5(int i)5308 inline bool is_ignored_dynamic_output_shape_nchw_quant8_5(int i) {
5309 static std::set<int> ignore = {};
5310 return ignore.find(i) != ignore.end();
5311 }
5312
CreateModel_dynamic_output_shape_nchw_float16_5(Model * model)5313 void CreateModel_dynamic_output_shape_nchw_float16_5(Model *model) {
5314 OperandType type0(Type::BOOL, {});
5315 OperandType type19(Type::TENSOR_INT32, {1});
5316 OperandType type30(Type::FLOAT16, {});
5317 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
5318 OperandType type5(Type::INT32, {});
5319 OperandType type91(Type::TENSOR_FLOAT16, {1, 4});
5320 OperandType type96(Type::TENSOR_FLOAT16, {1, 1, 512, 8});
5321 // Phase 1, operands
5322 auto in5 = model->addOperand(&type96);
5323 auto roi5 = model->addOperand(&type91);
5324 auto param41 = model->addOperand(&type19);
5325 auto param42 = model->addOperand(&type5);
5326 auto param43 = model->addOperand(&type5);
5327 auto param44 = model->addOperand(&type30);
5328 auto param45 = model->addOperand(&type30);
5329 auto param46 = model->addOperand(&type5);
5330 auto param47 = model->addOperand(&type5);
5331 auto layout = model->addOperand(&type0);
5332 auto out4 = model->addOperand(&type40);
5333 // Phase 2, operations
5334 static int32_t param41_init[] = {0};
5335 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
5336 static int32_t param42_init[] = {128};
5337 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
5338 static int32_t param43_init[] = {4};
5339 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
5340 static _Float16 param44_init[] = {1.0f};
5341 model->setOperandValue(param44, param44_init, sizeof(_Float16) * 1);
5342 static _Float16 param45_init[] = {64.0f};
5343 model->setOperandValue(param45, param45_init, sizeof(_Float16) * 1);
5344 static int32_t param46_init[] = {10};
5345 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
5346 static int32_t param47_init[] = {10};
5347 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
5348 static bool8 layout_init[] = {true};
5349 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
5350 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in5, roi5, param41, param42, param43, param44, param45, param46, param47, layout}, {out4});
5351 // Phase 3, inputs and outputs
5352 model->identifyInputsAndOutputs(
5353 {in5, roi5},
5354 {out4});
5355 assert(model->isValid());
5356 }
5357
is_ignored_dynamic_output_shape_nchw_float16_5(int i)5358 inline bool is_ignored_dynamic_output_shape_nchw_float16_5(int i) {
5359 static std::set<int> ignore = {};
5360 return ignore.find(i) != ignore.end();
5361 }
5362
5363