1 // clang-format off
2 // Generated file (from: roi_pooling.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, {5, 4});
7 OperandType type3(Type::TENSOR_FLOAT32, {5, 2, 2, 1});
8 OperandType type4(Type::TENSOR_INT32, {5});
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 layout = model->addOperand(&type0);
20 auto out = model->addOperand(&type3);
21 // Phase 2, operations
22 static int32_t param_init[] = {0, 0, 0, 0, 0};
23 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
24 static int32_t param1_init[] = {2};
25 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
26 static int32_t param2_init[] = {2};
27 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
28 static float param3_init[] = {2.0f};
29 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
30 static float param4_init[] = {2.0f};
31 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
32 static bool8 layout_init[] = {false};
33 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
34 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
35 // Phase 3, inputs and outputs
36 model->identifyInputsAndOutputs(
37 {in, roi},
38 {out});
39 assert(model->isValid());
40 }
41
is_ignored_nhwc(int i)42 inline bool is_ignored_nhwc(int i) {
43 static std::set<int> ignore = {};
44 return ignore.find(i) != ignore.end();
45 }
46
CreateModel_nhwc_relaxed(Model * model)47 void CreateModel_nhwc_relaxed(Model *model) {
48 OperandType type0(Type::BOOL, {});
49 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
50 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
51 OperandType type3(Type::TENSOR_FLOAT32, {5, 2, 2, 1});
52 OperandType type4(Type::TENSOR_INT32, {5});
53 OperandType type5(Type::INT32, {});
54 OperandType type6(Type::FLOAT32, {});
55 // Phase 1, operands
56 auto in = model->addOperand(&type1);
57 auto roi = model->addOperand(&type2);
58 auto param = model->addOperand(&type4);
59 auto param1 = model->addOperand(&type5);
60 auto param2 = model->addOperand(&type5);
61 auto param3 = model->addOperand(&type6);
62 auto param4 = model->addOperand(&type6);
63 auto layout = model->addOperand(&type0);
64 auto out = model->addOperand(&type3);
65 // Phase 2, operations
66 static int32_t param_init[] = {0, 0, 0, 0, 0};
67 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
68 static int32_t param1_init[] = {2};
69 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
70 static int32_t param2_init[] = {2};
71 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
72 static float param3_init[] = {2.0f};
73 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
74 static float param4_init[] = {2.0f};
75 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
76 static bool8 layout_init[] = {false};
77 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
78 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
79 // Phase 3, inputs and outputs
80 model->identifyInputsAndOutputs(
81 {in, roi},
82 {out});
83 // Phase 4: set relaxed execution
84 model->relaxComputationFloat32toFloat16(true);
85 assert(model->isValid());
86 }
87
is_ignored_nhwc_relaxed(int i)88 inline bool is_ignored_nhwc_relaxed(int i) {
89 static std::set<int> ignore = {};
90 return ignore.find(i) != ignore.end();
91 }
92
CreateModel_nhwc_quant8(Model * model)93 void CreateModel_nhwc_quant8(Model *model) {
94 OperandType type0(Type::BOOL, {});
95 OperandType type12(Type::TENSOR_QUANT8_ASYMM, {1, 4, 4, 1}, 0.25f, 128);
96 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {5, 2, 2, 1}, 0.25f, 128);
97 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
98 OperandType type4(Type::TENSOR_INT32, {5});
99 OperandType type5(Type::INT32, {});
100 OperandType type6(Type::FLOAT32, {});
101 // Phase 1, operands
102 auto in = model->addOperand(&type12);
103 auto roi = model->addOperand(&type14);
104 auto param = model->addOperand(&type4);
105 auto param1 = model->addOperand(&type5);
106 auto param2 = model->addOperand(&type5);
107 auto param3 = model->addOperand(&type6);
108 auto param4 = model->addOperand(&type6);
109 auto layout = model->addOperand(&type0);
110 auto out = model->addOperand(&type13);
111 // Phase 2, operations
112 static int32_t param_init[] = {0, 0, 0, 0, 0};
113 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
114 static int32_t param1_init[] = {2};
115 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
116 static int32_t param2_init[] = {2};
117 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
118 static float param3_init[] = {2.0f};
119 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
120 static float param4_init[] = {2.0f};
121 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
122 static bool8 layout_init[] = {false};
123 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
124 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
125 // Phase 3, inputs and outputs
126 model->identifyInputsAndOutputs(
127 {in, roi},
128 {out});
129 assert(model->isValid());
130 }
131
is_ignored_nhwc_quant8(int i)132 inline bool is_ignored_nhwc_quant8(int i) {
133 static std::set<int> ignore = {};
134 return ignore.find(i) != ignore.end();
135 }
136
CreateModel_nhwc_float16(Model * model)137 void CreateModel_nhwc_float16(Model *model) {
138 OperandType type0(Type::BOOL, {});
139 OperandType type15(Type::TENSOR_FLOAT16, {1, 4, 4, 1});
140 OperandType type16(Type::TENSOR_FLOAT16, {5, 2, 2, 1});
141 OperandType type17(Type::FLOAT16, {});
142 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
143 OperandType type4(Type::TENSOR_INT32, {5});
144 OperandType type5(Type::INT32, {});
145 // Phase 1, operands
146 auto in = model->addOperand(&type15);
147 auto roi = model->addOperand(&type18);
148 auto param = model->addOperand(&type4);
149 auto param1 = model->addOperand(&type5);
150 auto param2 = model->addOperand(&type5);
151 auto param3 = model->addOperand(&type17);
152 auto param4 = model->addOperand(&type17);
153 auto layout = model->addOperand(&type0);
154 auto out = model->addOperand(&type16);
155 // Phase 2, operations
156 static int32_t param_init[] = {0, 0, 0, 0, 0};
157 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
158 static int32_t param1_init[] = {2};
159 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
160 static int32_t param2_init[] = {2};
161 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
162 static _Float16 param3_init[] = {2.0f};
163 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
164 static _Float16 param4_init[] = {2.0f};
165 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
166 static bool8 layout_init[] = {false};
167 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
168 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
169 // Phase 3, inputs and outputs
170 model->identifyInputsAndOutputs(
171 {in, roi},
172 {out});
173 assert(model->isValid());
174 }
175
is_ignored_nhwc_float16(int i)176 inline bool is_ignored_nhwc_float16(int i) {
177 static std::set<int> ignore = {};
178 return ignore.find(i) != ignore.end();
179 }
180
CreateModel_nchw(Model * model)181 void CreateModel_nchw(Model *model) {
182 OperandType type0(Type::BOOL, {});
183 OperandType type19(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
184 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
185 OperandType type20(Type::TENSOR_FLOAT32, {5, 1, 2, 2});
186 OperandType type4(Type::TENSOR_INT32, {5});
187 OperandType type5(Type::INT32, {});
188 OperandType type6(Type::FLOAT32, {});
189 // Phase 1, operands
190 auto in = model->addOperand(&type19);
191 auto roi = model->addOperand(&type2);
192 auto param = model->addOperand(&type4);
193 auto param1 = model->addOperand(&type5);
194 auto param2 = model->addOperand(&type5);
195 auto param3 = model->addOperand(&type6);
196 auto param4 = model->addOperand(&type6);
197 auto layout = model->addOperand(&type0);
198 auto out = model->addOperand(&type20);
199 // Phase 2, operations
200 static int32_t param_init[] = {0, 0, 0, 0, 0};
201 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
202 static int32_t param1_init[] = {2};
203 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
204 static int32_t param2_init[] = {2};
205 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
206 static float param3_init[] = {2.0f};
207 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
208 static float param4_init[] = {2.0f};
209 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
210 static bool8 layout_init[] = {true};
211 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
212 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
213 // Phase 3, inputs and outputs
214 model->identifyInputsAndOutputs(
215 {in, roi},
216 {out});
217 assert(model->isValid());
218 }
219
is_ignored_nchw(int i)220 inline bool is_ignored_nchw(int i) {
221 static std::set<int> ignore = {};
222 return ignore.find(i) != ignore.end();
223 }
224
CreateModel_nchw_relaxed(Model * model)225 void CreateModel_nchw_relaxed(Model *model) {
226 OperandType type0(Type::BOOL, {});
227 OperandType type19(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
228 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
229 OperandType type20(Type::TENSOR_FLOAT32, {5, 1, 2, 2});
230 OperandType type4(Type::TENSOR_INT32, {5});
231 OperandType type5(Type::INT32, {});
232 OperandType type6(Type::FLOAT32, {});
233 // Phase 1, operands
234 auto in = model->addOperand(&type19);
235 auto roi = model->addOperand(&type2);
236 auto param = model->addOperand(&type4);
237 auto param1 = model->addOperand(&type5);
238 auto param2 = model->addOperand(&type5);
239 auto param3 = model->addOperand(&type6);
240 auto param4 = model->addOperand(&type6);
241 auto layout = model->addOperand(&type0);
242 auto out = model->addOperand(&type20);
243 // Phase 2, operations
244 static int32_t param_init[] = {0, 0, 0, 0, 0};
245 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
246 static int32_t param1_init[] = {2};
247 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
248 static int32_t param2_init[] = {2};
249 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
250 static float param3_init[] = {2.0f};
251 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
252 static float param4_init[] = {2.0f};
253 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
254 static bool8 layout_init[] = {true};
255 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
256 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
257 // Phase 3, inputs and outputs
258 model->identifyInputsAndOutputs(
259 {in, roi},
260 {out});
261 // Phase 4: set relaxed execution
262 model->relaxComputationFloat32toFloat16(true);
263 assert(model->isValid());
264 }
265
is_ignored_nchw_relaxed(int i)266 inline bool is_ignored_nchw_relaxed(int i) {
267 static std::set<int> ignore = {};
268 return ignore.find(i) != ignore.end();
269 }
270
CreateModel_nchw_quant8(Model * model)271 void CreateModel_nchw_quant8(Model *model) {
272 OperandType type0(Type::BOOL, {});
273 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
274 OperandType type21(Type::TENSOR_QUANT8_ASYMM, {1, 1, 4, 4}, 0.25f, 128);
275 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {5, 1, 2, 2}, 0.25f, 128);
276 OperandType type4(Type::TENSOR_INT32, {5});
277 OperandType type5(Type::INT32, {});
278 OperandType type6(Type::FLOAT32, {});
279 // Phase 1, operands
280 auto in = model->addOperand(&type21);
281 auto roi = model->addOperand(&type14);
282 auto param = model->addOperand(&type4);
283 auto param1 = model->addOperand(&type5);
284 auto param2 = model->addOperand(&type5);
285 auto param3 = model->addOperand(&type6);
286 auto param4 = model->addOperand(&type6);
287 auto layout = model->addOperand(&type0);
288 auto out = model->addOperand(&type22);
289 // Phase 2, operations
290 static int32_t param_init[] = {0, 0, 0, 0, 0};
291 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
292 static int32_t param1_init[] = {2};
293 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
294 static int32_t param2_init[] = {2};
295 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
296 static float param3_init[] = {2.0f};
297 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
298 static float param4_init[] = {2.0f};
299 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
300 static bool8 layout_init[] = {true};
301 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
302 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
303 // Phase 3, inputs and outputs
304 model->identifyInputsAndOutputs(
305 {in, roi},
306 {out});
307 assert(model->isValid());
308 }
309
is_ignored_nchw_quant8(int i)310 inline bool is_ignored_nchw_quant8(int i) {
311 static std::set<int> ignore = {};
312 return ignore.find(i) != ignore.end();
313 }
314
CreateModel_nchw_float16(Model * model)315 void CreateModel_nchw_float16(Model *model) {
316 OperandType type0(Type::BOOL, {});
317 OperandType type17(Type::FLOAT16, {});
318 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
319 OperandType type23(Type::TENSOR_FLOAT16, {1, 1, 4, 4});
320 OperandType type24(Type::TENSOR_FLOAT16, {5, 1, 2, 2});
321 OperandType type4(Type::TENSOR_INT32, {5});
322 OperandType type5(Type::INT32, {});
323 // Phase 1, operands
324 auto in = model->addOperand(&type23);
325 auto roi = model->addOperand(&type18);
326 auto param = model->addOperand(&type4);
327 auto param1 = model->addOperand(&type5);
328 auto param2 = model->addOperand(&type5);
329 auto param3 = model->addOperand(&type17);
330 auto param4 = model->addOperand(&type17);
331 auto layout = model->addOperand(&type0);
332 auto out = model->addOperand(&type24);
333 // Phase 2, operations
334 static int32_t param_init[] = {0, 0, 0, 0, 0};
335 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
336 static int32_t param1_init[] = {2};
337 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
338 static int32_t param2_init[] = {2};
339 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
340 static _Float16 param3_init[] = {2.0f};
341 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
342 static _Float16 param4_init[] = {2.0f};
343 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
344 static bool8 layout_init[] = {true};
345 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
346 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
347 // Phase 3, inputs and outputs
348 model->identifyInputsAndOutputs(
349 {in, roi},
350 {out});
351 assert(model->isValid());
352 }
353
is_ignored_nchw_float16(int i)354 inline bool is_ignored_nchw_float16(int i) {
355 static std::set<int> ignore = {};
356 return ignore.find(i) != ignore.end();
357 }
358
CreateModel_dynamic_output_shape_nhwc(Model * model)359 void CreateModel_dynamic_output_shape_nhwc(Model *model) {
360 OperandType type0(Type::BOOL, {});
361 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
362 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
363 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
364 OperandType type4(Type::TENSOR_INT32, {5});
365 OperandType type5(Type::INT32, {});
366 OperandType type6(Type::FLOAT32, {});
367 // Phase 1, operands
368 auto in = model->addOperand(&type1);
369 auto roi = model->addOperand(&type2);
370 auto param = model->addOperand(&type4);
371 auto param1 = model->addOperand(&type5);
372 auto param2 = model->addOperand(&type5);
373 auto param3 = model->addOperand(&type6);
374 auto param4 = model->addOperand(&type6);
375 auto layout = model->addOperand(&type0);
376 auto out = model->addOperand(&type25);
377 // Phase 2, operations
378 static int32_t param_init[] = {0, 0, 0, 0, 0};
379 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
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 float param3_init[] = {2.0f};
385 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
386 static float param4_init[] = {2.0f};
387 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
388 static bool8 layout_init[] = {false};
389 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
390 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
391 // Phase 3, inputs and outputs
392 model->identifyInputsAndOutputs(
393 {in, roi},
394 {out});
395 assert(model->isValid());
396 }
397
is_ignored_dynamic_output_shape_nhwc(int i)398 inline bool is_ignored_dynamic_output_shape_nhwc(int i) {
399 static std::set<int> ignore = {};
400 return ignore.find(i) != ignore.end();
401 }
402
CreateModel_dynamic_output_shape_nhwc_relaxed(Model * model)403 void CreateModel_dynamic_output_shape_nhwc_relaxed(Model *model) {
404 OperandType type0(Type::BOOL, {});
405 OperandType type1(Type::TENSOR_FLOAT32, {1, 4, 4, 1});
406 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
407 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
408 OperandType type4(Type::TENSOR_INT32, {5});
409 OperandType type5(Type::INT32, {});
410 OperandType type6(Type::FLOAT32, {});
411 // Phase 1, operands
412 auto in = model->addOperand(&type1);
413 auto roi = model->addOperand(&type2);
414 auto param = model->addOperand(&type4);
415 auto param1 = model->addOperand(&type5);
416 auto param2 = model->addOperand(&type5);
417 auto param3 = model->addOperand(&type6);
418 auto param4 = model->addOperand(&type6);
419 auto layout = model->addOperand(&type0);
420 auto out = model->addOperand(&type25);
421 // Phase 2, operations
422 static int32_t param_init[] = {0, 0, 0, 0, 0};
423 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
424 static int32_t param1_init[] = {2};
425 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
426 static int32_t param2_init[] = {2};
427 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
428 static float param3_init[] = {2.0f};
429 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
430 static float param4_init[] = {2.0f};
431 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
432 static bool8 layout_init[] = {false};
433 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
434 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
435 // Phase 3, inputs and outputs
436 model->identifyInputsAndOutputs(
437 {in, roi},
438 {out});
439 // Phase 4: set relaxed execution
440 model->relaxComputationFloat32toFloat16(true);
441 assert(model->isValid());
442 }
443
is_ignored_dynamic_output_shape_nhwc_relaxed(int i)444 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed(int i) {
445 static std::set<int> ignore = {};
446 return ignore.find(i) != ignore.end();
447 }
448
CreateModel_dynamic_output_shape_nhwc_quant8(Model * model)449 void CreateModel_dynamic_output_shape_nhwc_quant8(Model *model) {
450 OperandType type0(Type::BOOL, {});
451 OperandType type12(Type::TENSOR_QUANT8_ASYMM, {1, 4, 4, 1}, 0.25f, 128);
452 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
453 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
454 OperandType type4(Type::TENSOR_INT32, {5});
455 OperandType type5(Type::INT32, {});
456 OperandType type6(Type::FLOAT32, {});
457 // Phase 1, operands
458 auto in = model->addOperand(&type12);
459 auto roi = model->addOperand(&type14);
460 auto param = model->addOperand(&type4);
461 auto param1 = model->addOperand(&type5);
462 auto param2 = model->addOperand(&type5);
463 auto param3 = model->addOperand(&type6);
464 auto param4 = model->addOperand(&type6);
465 auto layout = model->addOperand(&type0);
466 auto out = model->addOperand(&type26);
467 // Phase 2, operations
468 static int32_t param_init[] = {0, 0, 0, 0, 0};
469 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
470 static int32_t param1_init[] = {2};
471 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
472 static int32_t param2_init[] = {2};
473 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
474 static float param3_init[] = {2.0f};
475 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
476 static float param4_init[] = {2.0f};
477 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
478 static bool8 layout_init[] = {false};
479 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
480 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
481 // Phase 3, inputs and outputs
482 model->identifyInputsAndOutputs(
483 {in, roi},
484 {out});
485 assert(model->isValid());
486 }
487
is_ignored_dynamic_output_shape_nhwc_quant8(int i)488 inline bool is_ignored_dynamic_output_shape_nhwc_quant8(int i) {
489 static std::set<int> ignore = {};
490 return ignore.find(i) != ignore.end();
491 }
492
CreateModel_dynamic_output_shape_nhwc_float16(Model * model)493 void CreateModel_dynamic_output_shape_nhwc_float16(Model *model) {
494 OperandType type0(Type::BOOL, {});
495 OperandType type15(Type::TENSOR_FLOAT16, {1, 4, 4, 1});
496 OperandType type17(Type::FLOAT16, {});
497 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
498 OperandType type27(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
499 OperandType type4(Type::TENSOR_INT32, {5});
500 OperandType type5(Type::INT32, {});
501 // Phase 1, operands
502 auto in = model->addOperand(&type15);
503 auto roi = model->addOperand(&type18);
504 auto param = model->addOperand(&type4);
505 auto param1 = model->addOperand(&type5);
506 auto param2 = model->addOperand(&type5);
507 auto param3 = model->addOperand(&type17);
508 auto param4 = model->addOperand(&type17);
509 auto layout = model->addOperand(&type0);
510 auto out = model->addOperand(&type27);
511 // Phase 2, operations
512 static int32_t param_init[] = {0, 0, 0, 0, 0};
513 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
514 static int32_t param1_init[] = {2};
515 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
516 static int32_t param2_init[] = {2};
517 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
518 static _Float16 param3_init[] = {2.0f};
519 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
520 static _Float16 param4_init[] = {2.0f};
521 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
522 static bool8 layout_init[] = {false};
523 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
524 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
525 // Phase 3, inputs and outputs
526 model->identifyInputsAndOutputs(
527 {in, roi},
528 {out});
529 assert(model->isValid());
530 }
531
is_ignored_dynamic_output_shape_nhwc_float16(int i)532 inline bool is_ignored_dynamic_output_shape_nhwc_float16(int i) {
533 static std::set<int> ignore = {};
534 return ignore.find(i) != ignore.end();
535 }
536
CreateModel_dynamic_output_shape_nchw(Model * model)537 void CreateModel_dynamic_output_shape_nchw(Model *model) {
538 OperandType type0(Type::BOOL, {});
539 OperandType type19(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
540 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
541 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
542 OperandType type4(Type::TENSOR_INT32, {5});
543 OperandType type5(Type::INT32, {});
544 OperandType type6(Type::FLOAT32, {});
545 // Phase 1, operands
546 auto in = model->addOperand(&type19);
547 auto roi = model->addOperand(&type2);
548 auto param = model->addOperand(&type4);
549 auto param1 = model->addOperand(&type5);
550 auto param2 = model->addOperand(&type5);
551 auto param3 = model->addOperand(&type6);
552 auto param4 = model->addOperand(&type6);
553 auto layout = model->addOperand(&type0);
554 auto out = model->addOperand(&type25);
555 // Phase 2, operations
556 static int32_t param_init[] = {0, 0, 0, 0, 0};
557 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
558 static int32_t param1_init[] = {2};
559 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
560 static int32_t param2_init[] = {2};
561 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
562 static float param3_init[] = {2.0f};
563 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
564 static float param4_init[] = {2.0f};
565 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
566 static bool8 layout_init[] = {true};
567 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
568 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
569 // Phase 3, inputs and outputs
570 model->identifyInputsAndOutputs(
571 {in, roi},
572 {out});
573 assert(model->isValid());
574 }
575
is_ignored_dynamic_output_shape_nchw(int i)576 inline bool is_ignored_dynamic_output_shape_nchw(int i) {
577 static std::set<int> ignore = {};
578 return ignore.find(i) != ignore.end();
579 }
580
CreateModel_dynamic_output_shape_nchw_relaxed(Model * model)581 void CreateModel_dynamic_output_shape_nchw_relaxed(Model *model) {
582 OperandType type0(Type::BOOL, {});
583 OperandType type19(Type::TENSOR_FLOAT32, {1, 1, 4, 4});
584 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
585 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
586 OperandType type4(Type::TENSOR_INT32, {5});
587 OperandType type5(Type::INT32, {});
588 OperandType type6(Type::FLOAT32, {});
589 // Phase 1, operands
590 auto in = model->addOperand(&type19);
591 auto roi = model->addOperand(&type2);
592 auto param = model->addOperand(&type4);
593 auto param1 = model->addOperand(&type5);
594 auto param2 = model->addOperand(&type5);
595 auto param3 = model->addOperand(&type6);
596 auto param4 = model->addOperand(&type6);
597 auto layout = model->addOperand(&type0);
598 auto out = model->addOperand(&type25);
599 // Phase 2, operations
600 static int32_t param_init[] = {0, 0, 0, 0, 0};
601 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
602 static int32_t param1_init[] = {2};
603 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
604 static int32_t param2_init[] = {2};
605 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
606 static float param3_init[] = {2.0f};
607 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
608 static float param4_init[] = {2.0f};
609 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
610 static bool8 layout_init[] = {true};
611 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
612 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
613 // Phase 3, inputs and outputs
614 model->identifyInputsAndOutputs(
615 {in, roi},
616 {out});
617 // Phase 4: set relaxed execution
618 model->relaxComputationFloat32toFloat16(true);
619 assert(model->isValid());
620 }
621
is_ignored_dynamic_output_shape_nchw_relaxed(int i)622 inline bool is_ignored_dynamic_output_shape_nchw_relaxed(int i) {
623 static std::set<int> ignore = {};
624 return ignore.find(i) != ignore.end();
625 }
626
CreateModel_dynamic_output_shape_nchw_quant8(Model * model)627 void CreateModel_dynamic_output_shape_nchw_quant8(Model *model) {
628 OperandType type0(Type::BOOL, {});
629 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
630 OperandType type21(Type::TENSOR_QUANT8_ASYMM, {1, 1, 4, 4}, 0.25f, 128);
631 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
632 OperandType type4(Type::TENSOR_INT32, {5});
633 OperandType type5(Type::INT32, {});
634 OperandType type6(Type::FLOAT32, {});
635 // Phase 1, operands
636 auto in = model->addOperand(&type21);
637 auto roi = model->addOperand(&type14);
638 auto param = model->addOperand(&type4);
639 auto param1 = model->addOperand(&type5);
640 auto param2 = model->addOperand(&type5);
641 auto param3 = model->addOperand(&type6);
642 auto param4 = model->addOperand(&type6);
643 auto layout = model->addOperand(&type0);
644 auto out = model->addOperand(&type26);
645 // Phase 2, operations
646 static int32_t param_init[] = {0, 0, 0, 0, 0};
647 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
648 static int32_t param1_init[] = {2};
649 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
650 static int32_t param2_init[] = {2};
651 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
652 static float param3_init[] = {2.0f};
653 model->setOperandValue(param3, param3_init, sizeof(float) * 1);
654 static float param4_init[] = {2.0f};
655 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
656 static bool8 layout_init[] = {true};
657 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
658 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
659 // Phase 3, inputs and outputs
660 model->identifyInputsAndOutputs(
661 {in, roi},
662 {out});
663 assert(model->isValid());
664 }
665
is_ignored_dynamic_output_shape_nchw_quant8(int i)666 inline bool is_ignored_dynamic_output_shape_nchw_quant8(int i) {
667 static std::set<int> ignore = {};
668 return ignore.find(i) != ignore.end();
669 }
670
CreateModel_dynamic_output_shape_nchw_float16(Model * model)671 void CreateModel_dynamic_output_shape_nchw_float16(Model *model) {
672 OperandType type0(Type::BOOL, {});
673 OperandType type17(Type::FLOAT16, {});
674 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
675 OperandType type23(Type::TENSOR_FLOAT16, {1, 1, 4, 4});
676 OperandType type27(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
677 OperandType type4(Type::TENSOR_INT32, {5});
678 OperandType type5(Type::INT32, {});
679 // Phase 1, operands
680 auto in = model->addOperand(&type23);
681 auto roi = model->addOperand(&type18);
682 auto param = model->addOperand(&type4);
683 auto param1 = model->addOperand(&type5);
684 auto param2 = model->addOperand(&type5);
685 auto param3 = model->addOperand(&type17);
686 auto param4 = model->addOperand(&type17);
687 auto layout = model->addOperand(&type0);
688 auto out = model->addOperand(&type27);
689 // Phase 2, operations
690 static int32_t param_init[] = {0, 0, 0, 0, 0};
691 model->setOperandValue(param, param_init, sizeof(int32_t) * 5);
692 static int32_t param1_init[] = {2};
693 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
694 static int32_t param2_init[] = {2};
695 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
696 static _Float16 param3_init[] = {2.0f};
697 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1);
698 static _Float16 param4_init[] = {2.0f};
699 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
700 static bool8 layout_init[] = {true};
701 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
702 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in, roi, param, param1, param2, param3, param4, layout}, {out});
703 // Phase 3, inputs and outputs
704 model->identifyInputsAndOutputs(
705 {in, roi},
706 {out});
707 assert(model->isValid());
708 }
709
is_ignored_dynamic_output_shape_nchw_float16(int i)710 inline bool is_ignored_dynamic_output_shape_nchw_float16(int i) {
711 static std::set<int> ignore = {};
712 return ignore.find(i) != ignore.end();
713 }
714
CreateModel_nhwc_2(Model * model)715 void CreateModel_nhwc_2(Model *model) {
716 OperandType type0(Type::BOOL, {});
717 OperandType type10(Type::TENSOR_INT32, {4});
718 OperandType type5(Type::INT32, {});
719 OperandType type6(Type::FLOAT32, {});
720 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
721 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
722 OperandType type9(Type::TENSOR_FLOAT32, {4, 2, 3, 2});
723 // Phase 1, operands
724 auto in1 = model->addOperand(&type7);
725 auto roi1 = model->addOperand(&type8);
726 auto param5 = model->addOperand(&type10);
727 auto param6 = model->addOperand(&type5);
728 auto param7 = model->addOperand(&type5);
729 auto param8 = model->addOperand(&type6);
730 auto param9 = model->addOperand(&type6);
731 auto layout = model->addOperand(&type0);
732 auto out1 = model->addOperand(&type9);
733 // Phase 2, operations
734 static int32_t param5_init[] = {0, 0, 3, 3};
735 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
736 static int32_t param6_init[] = {2};
737 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
738 static int32_t param7_init[] = {3};
739 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
740 static float param8_init[] = {4.0f};
741 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
742 static float param9_init[] = {4.0f};
743 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
744 static bool8 layout_init[] = {false};
745 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
746 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
747 // Phase 3, inputs and outputs
748 model->identifyInputsAndOutputs(
749 {in1, roi1},
750 {out1});
751 assert(model->isValid());
752 }
753
is_ignored_nhwc_2(int i)754 inline bool is_ignored_nhwc_2(int i) {
755 static std::set<int> ignore = {};
756 return ignore.find(i) != ignore.end();
757 }
758
CreateModel_nhwc_relaxed_2(Model * model)759 void CreateModel_nhwc_relaxed_2(Model *model) {
760 OperandType type0(Type::BOOL, {});
761 OperandType type10(Type::TENSOR_INT32, {4});
762 OperandType type5(Type::INT32, {});
763 OperandType type6(Type::FLOAT32, {});
764 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
765 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
766 OperandType type9(Type::TENSOR_FLOAT32, {4, 2, 3, 2});
767 // Phase 1, operands
768 auto in1 = model->addOperand(&type7);
769 auto roi1 = model->addOperand(&type8);
770 auto param5 = model->addOperand(&type10);
771 auto param6 = model->addOperand(&type5);
772 auto param7 = model->addOperand(&type5);
773 auto param8 = model->addOperand(&type6);
774 auto param9 = model->addOperand(&type6);
775 auto layout = model->addOperand(&type0);
776 auto out1 = model->addOperand(&type9);
777 // Phase 2, operations
778 static int32_t param5_init[] = {0, 0, 3, 3};
779 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
780 static int32_t param6_init[] = {2};
781 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
782 static int32_t param7_init[] = {3};
783 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
784 static float param8_init[] = {4.0f};
785 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
786 static float param9_init[] = {4.0f};
787 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
788 static bool8 layout_init[] = {false};
789 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
790 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
791 // Phase 3, inputs and outputs
792 model->identifyInputsAndOutputs(
793 {in1, roi1},
794 {out1});
795 // Phase 4: set relaxed execution
796 model->relaxComputationFloat32toFloat16(true);
797 assert(model->isValid());
798 }
799
is_ignored_nhwc_relaxed_2(int i)800 inline bool is_ignored_nhwc_relaxed_2(int i) {
801 static std::set<int> ignore = {};
802 return ignore.find(i) != ignore.end();
803 }
804
CreateModel_nhwc_quant8_2(Model * model)805 void CreateModel_nhwc_quant8_2(Model *model) {
806 OperandType type0(Type::BOOL, {});
807 OperandType type10(Type::TENSOR_INT32, {4});
808 OperandType type28(Type::TENSOR_QUANT8_ASYMM, {4, 4, 8, 2}, 0.04f, 0);
809 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {4, 2, 3, 2}, 0.04f, 0);
810 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
811 OperandType type5(Type::INT32, {});
812 OperandType type6(Type::FLOAT32, {});
813 // Phase 1, operands
814 auto in1 = model->addOperand(&type28);
815 auto roi1 = model->addOperand(&type30);
816 auto param5 = model->addOperand(&type10);
817 auto param6 = model->addOperand(&type5);
818 auto param7 = model->addOperand(&type5);
819 auto param8 = model->addOperand(&type6);
820 auto param9 = model->addOperand(&type6);
821 auto layout = model->addOperand(&type0);
822 auto out1 = model->addOperand(&type29);
823 // Phase 2, operations
824 static int32_t param5_init[] = {0, 0, 3, 3};
825 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
826 static int32_t param6_init[] = {2};
827 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
828 static int32_t param7_init[] = {3};
829 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
830 static float param8_init[] = {4.0f};
831 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
832 static float param9_init[] = {4.0f};
833 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
834 static bool8 layout_init[] = {false};
835 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
836 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
837 // Phase 3, inputs and outputs
838 model->identifyInputsAndOutputs(
839 {in1, roi1},
840 {out1});
841 assert(model->isValid());
842 }
843
is_ignored_nhwc_quant8_2(int i)844 inline bool is_ignored_nhwc_quant8_2(int i) {
845 static std::set<int> ignore = {};
846 return ignore.find(i) != ignore.end();
847 }
848
CreateModel_nhwc_float16_2(Model * model)849 void CreateModel_nhwc_float16_2(Model *model) {
850 OperandType type0(Type::BOOL, {});
851 OperandType type10(Type::TENSOR_INT32, {4});
852 OperandType type17(Type::FLOAT16, {});
853 OperandType type31(Type::TENSOR_FLOAT16, {4, 4, 8, 2});
854 OperandType type32(Type::TENSOR_FLOAT16, {4, 2, 3, 2});
855 OperandType type33(Type::TENSOR_FLOAT16, {4, 4});
856 OperandType type5(Type::INT32, {});
857 // Phase 1, operands
858 auto in1 = model->addOperand(&type31);
859 auto roi1 = model->addOperand(&type33);
860 auto param5 = model->addOperand(&type10);
861 auto param6 = model->addOperand(&type5);
862 auto param7 = model->addOperand(&type5);
863 auto param8 = model->addOperand(&type17);
864 auto param9 = model->addOperand(&type17);
865 auto layout = model->addOperand(&type0);
866 auto out1 = model->addOperand(&type32);
867 // Phase 2, operations
868 static int32_t param5_init[] = {0, 0, 3, 3};
869 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
870 static int32_t param6_init[] = {2};
871 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
872 static int32_t param7_init[] = {3};
873 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
874 static _Float16 param8_init[] = {4.0f};
875 model->setOperandValue(param8, param8_init, sizeof(_Float16) * 1);
876 static _Float16 param9_init[] = {4.0f};
877 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
878 static bool8 layout_init[] = {false};
879 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
880 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
881 // Phase 3, inputs and outputs
882 model->identifyInputsAndOutputs(
883 {in1, roi1},
884 {out1});
885 assert(model->isValid());
886 }
887
is_ignored_nhwc_float16_2(int i)888 inline bool is_ignored_nhwc_float16_2(int i) {
889 static std::set<int> ignore = {};
890 return ignore.find(i) != ignore.end();
891 }
892
CreateModel_nchw_2(Model * model)893 void CreateModel_nchw_2(Model *model) {
894 OperandType type0(Type::BOOL, {});
895 OperandType type10(Type::TENSOR_INT32, {4});
896 OperandType type34(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
897 OperandType type35(Type::TENSOR_FLOAT32, {4, 2, 2, 3});
898 OperandType type5(Type::INT32, {});
899 OperandType type6(Type::FLOAT32, {});
900 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
901 // Phase 1, operands
902 auto in1 = model->addOperand(&type34);
903 auto roi1 = model->addOperand(&type8);
904 auto param5 = model->addOperand(&type10);
905 auto param6 = model->addOperand(&type5);
906 auto param7 = model->addOperand(&type5);
907 auto param8 = model->addOperand(&type6);
908 auto param9 = model->addOperand(&type6);
909 auto layout = model->addOperand(&type0);
910 auto out1 = model->addOperand(&type35);
911 // Phase 2, operations
912 static int32_t param5_init[] = {0, 0, 3, 3};
913 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
914 static int32_t param6_init[] = {2};
915 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
916 static int32_t param7_init[] = {3};
917 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
918 static float param8_init[] = {4.0f};
919 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
920 static float param9_init[] = {4.0f};
921 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
922 static bool8 layout_init[] = {true};
923 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
924 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
925 // Phase 3, inputs and outputs
926 model->identifyInputsAndOutputs(
927 {in1, roi1},
928 {out1});
929 assert(model->isValid());
930 }
931
is_ignored_nchw_2(int i)932 inline bool is_ignored_nchw_2(int i) {
933 static std::set<int> ignore = {};
934 return ignore.find(i) != ignore.end();
935 }
936
CreateModel_nchw_relaxed_2(Model * model)937 void CreateModel_nchw_relaxed_2(Model *model) {
938 OperandType type0(Type::BOOL, {});
939 OperandType type10(Type::TENSOR_INT32, {4});
940 OperandType type34(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
941 OperandType type35(Type::TENSOR_FLOAT32, {4, 2, 2, 3});
942 OperandType type5(Type::INT32, {});
943 OperandType type6(Type::FLOAT32, {});
944 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
945 // Phase 1, operands
946 auto in1 = model->addOperand(&type34);
947 auto roi1 = model->addOperand(&type8);
948 auto param5 = model->addOperand(&type10);
949 auto param6 = model->addOperand(&type5);
950 auto param7 = model->addOperand(&type5);
951 auto param8 = model->addOperand(&type6);
952 auto param9 = model->addOperand(&type6);
953 auto layout = model->addOperand(&type0);
954 auto out1 = model->addOperand(&type35);
955 // Phase 2, operations
956 static int32_t param5_init[] = {0, 0, 3, 3};
957 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
958 static int32_t param6_init[] = {2};
959 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
960 static int32_t param7_init[] = {3};
961 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
962 static float param8_init[] = {4.0f};
963 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
964 static float param9_init[] = {4.0f};
965 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
966 static bool8 layout_init[] = {true};
967 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
968 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
969 // Phase 3, inputs and outputs
970 model->identifyInputsAndOutputs(
971 {in1, roi1},
972 {out1});
973 // Phase 4: set relaxed execution
974 model->relaxComputationFloat32toFloat16(true);
975 assert(model->isValid());
976 }
977
is_ignored_nchw_relaxed_2(int i)978 inline bool is_ignored_nchw_relaxed_2(int i) {
979 static std::set<int> ignore = {};
980 return ignore.find(i) != ignore.end();
981 }
982
CreateModel_nchw_quant8_2(Model * model)983 void CreateModel_nchw_quant8_2(Model *model) {
984 OperandType type0(Type::BOOL, {});
985 OperandType type10(Type::TENSOR_INT32, {4});
986 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
987 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {4, 2, 4, 8}, 0.04f, 0);
988 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {4, 2, 2, 3}, 0.04f, 0);
989 OperandType type5(Type::INT32, {});
990 OperandType type6(Type::FLOAT32, {});
991 // Phase 1, operands
992 auto in1 = model->addOperand(&type36);
993 auto roi1 = model->addOperand(&type30);
994 auto param5 = model->addOperand(&type10);
995 auto param6 = model->addOperand(&type5);
996 auto param7 = model->addOperand(&type5);
997 auto param8 = model->addOperand(&type6);
998 auto param9 = model->addOperand(&type6);
999 auto layout = model->addOperand(&type0);
1000 auto out1 = model->addOperand(&type37);
1001 // Phase 2, operations
1002 static int32_t param5_init[] = {0, 0, 3, 3};
1003 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1004 static int32_t param6_init[] = {2};
1005 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1006 static int32_t param7_init[] = {3};
1007 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1008 static float param8_init[] = {4.0f};
1009 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1010 static float param9_init[] = {4.0f};
1011 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1012 static bool8 layout_init[] = {true};
1013 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1014 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1015 // Phase 3, inputs and outputs
1016 model->identifyInputsAndOutputs(
1017 {in1, roi1},
1018 {out1});
1019 assert(model->isValid());
1020 }
1021
is_ignored_nchw_quant8_2(int i)1022 inline bool is_ignored_nchw_quant8_2(int i) {
1023 static std::set<int> ignore = {};
1024 return ignore.find(i) != ignore.end();
1025 }
1026
CreateModel_nchw_float16_2(Model * model)1027 void CreateModel_nchw_float16_2(Model *model) {
1028 OperandType type0(Type::BOOL, {});
1029 OperandType type10(Type::TENSOR_INT32, {4});
1030 OperandType type17(Type::FLOAT16, {});
1031 OperandType type33(Type::TENSOR_FLOAT16, {4, 4});
1032 OperandType type38(Type::TENSOR_FLOAT16, {4, 2, 4, 8});
1033 OperandType type39(Type::TENSOR_FLOAT16, {4, 2, 2, 3});
1034 OperandType type5(Type::INT32, {});
1035 // Phase 1, operands
1036 auto in1 = model->addOperand(&type38);
1037 auto roi1 = model->addOperand(&type33);
1038 auto param5 = model->addOperand(&type10);
1039 auto param6 = model->addOperand(&type5);
1040 auto param7 = model->addOperand(&type5);
1041 auto param8 = model->addOperand(&type17);
1042 auto param9 = model->addOperand(&type17);
1043 auto layout = model->addOperand(&type0);
1044 auto out1 = model->addOperand(&type39);
1045 // Phase 2, operations
1046 static int32_t param5_init[] = {0, 0, 3, 3};
1047 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1048 static int32_t param6_init[] = {2};
1049 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1050 static int32_t param7_init[] = {3};
1051 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1052 static _Float16 param8_init[] = {4.0f};
1053 model->setOperandValue(param8, param8_init, sizeof(_Float16) * 1);
1054 static _Float16 param9_init[] = {4.0f};
1055 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
1056 static bool8 layout_init[] = {true};
1057 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1058 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1059 // Phase 3, inputs and outputs
1060 model->identifyInputsAndOutputs(
1061 {in1, roi1},
1062 {out1});
1063 assert(model->isValid());
1064 }
1065
is_ignored_nchw_float16_2(int i)1066 inline bool is_ignored_nchw_float16_2(int i) {
1067 static std::set<int> ignore = {};
1068 return ignore.find(i) != ignore.end();
1069 }
1070
CreateModel_dynamic_output_shape_nhwc_2(Model * model)1071 void CreateModel_dynamic_output_shape_nhwc_2(Model *model) {
1072 OperandType type0(Type::BOOL, {});
1073 OperandType type10(Type::TENSOR_INT32, {4});
1074 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1075 OperandType type5(Type::INT32, {});
1076 OperandType type6(Type::FLOAT32, {});
1077 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
1078 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
1079 // Phase 1, operands
1080 auto in1 = model->addOperand(&type7);
1081 auto roi1 = model->addOperand(&type8);
1082 auto param5 = model->addOperand(&type10);
1083 auto param6 = model->addOperand(&type5);
1084 auto param7 = model->addOperand(&type5);
1085 auto param8 = model->addOperand(&type6);
1086 auto param9 = model->addOperand(&type6);
1087 auto layout = model->addOperand(&type0);
1088 auto out1 = model->addOperand(&type25);
1089 // Phase 2, operations
1090 static int32_t param5_init[] = {0, 0, 3, 3};
1091 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1092 static int32_t param6_init[] = {2};
1093 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1094 static int32_t param7_init[] = {3};
1095 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1096 static float param8_init[] = {4.0f};
1097 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1098 static float param9_init[] = {4.0f};
1099 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1100 static bool8 layout_init[] = {false};
1101 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1102 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1103 // Phase 3, inputs and outputs
1104 model->identifyInputsAndOutputs(
1105 {in1, roi1},
1106 {out1});
1107 assert(model->isValid());
1108 }
1109
is_ignored_dynamic_output_shape_nhwc_2(int i)1110 inline bool is_ignored_dynamic_output_shape_nhwc_2(int i) {
1111 static std::set<int> ignore = {};
1112 return ignore.find(i) != ignore.end();
1113 }
1114
CreateModel_dynamic_output_shape_nhwc_relaxed_2(Model * model)1115 void CreateModel_dynamic_output_shape_nhwc_relaxed_2(Model *model) {
1116 OperandType type0(Type::BOOL, {});
1117 OperandType type10(Type::TENSOR_INT32, {4});
1118 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1119 OperandType type5(Type::INT32, {});
1120 OperandType type6(Type::FLOAT32, {});
1121 OperandType type7(Type::TENSOR_FLOAT32, {4, 4, 8, 2});
1122 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
1123 // Phase 1, operands
1124 auto in1 = model->addOperand(&type7);
1125 auto roi1 = model->addOperand(&type8);
1126 auto param5 = model->addOperand(&type10);
1127 auto param6 = model->addOperand(&type5);
1128 auto param7 = model->addOperand(&type5);
1129 auto param8 = model->addOperand(&type6);
1130 auto param9 = model->addOperand(&type6);
1131 auto layout = model->addOperand(&type0);
1132 auto out1 = model->addOperand(&type25);
1133 // Phase 2, operations
1134 static int32_t param5_init[] = {0, 0, 3, 3};
1135 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1136 static int32_t param6_init[] = {2};
1137 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1138 static int32_t param7_init[] = {3};
1139 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1140 static float param8_init[] = {4.0f};
1141 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1142 static float param9_init[] = {4.0f};
1143 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1144 static bool8 layout_init[] = {false};
1145 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1146 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1147 // Phase 3, inputs and outputs
1148 model->identifyInputsAndOutputs(
1149 {in1, roi1},
1150 {out1});
1151 // Phase 4: set relaxed execution
1152 model->relaxComputationFloat32toFloat16(true);
1153 assert(model->isValid());
1154 }
1155
is_ignored_dynamic_output_shape_nhwc_relaxed_2(int i)1156 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_2(int i) {
1157 static std::set<int> ignore = {};
1158 return ignore.find(i) != ignore.end();
1159 }
1160
CreateModel_dynamic_output_shape_nhwc_quant8_2(Model * model)1161 void CreateModel_dynamic_output_shape_nhwc_quant8_2(Model *model) {
1162 OperandType type0(Type::BOOL, {});
1163 OperandType type10(Type::TENSOR_INT32, {4});
1164 OperandType type28(Type::TENSOR_QUANT8_ASYMM, {4, 4, 8, 2}, 0.04f, 0);
1165 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1166 OperandType type40(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.04f, 0);
1167 OperandType type5(Type::INT32, {});
1168 OperandType type6(Type::FLOAT32, {});
1169 // Phase 1, operands
1170 auto in1 = model->addOperand(&type28);
1171 auto roi1 = model->addOperand(&type30);
1172 auto param5 = model->addOperand(&type10);
1173 auto param6 = model->addOperand(&type5);
1174 auto param7 = model->addOperand(&type5);
1175 auto param8 = model->addOperand(&type6);
1176 auto param9 = model->addOperand(&type6);
1177 auto layout = model->addOperand(&type0);
1178 auto out1 = model->addOperand(&type40);
1179 // Phase 2, operations
1180 static int32_t param5_init[] = {0, 0, 3, 3};
1181 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1182 static int32_t param6_init[] = {2};
1183 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1184 static int32_t param7_init[] = {3};
1185 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1186 static float param8_init[] = {4.0f};
1187 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1188 static float param9_init[] = {4.0f};
1189 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1190 static bool8 layout_init[] = {false};
1191 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1192 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1193 // Phase 3, inputs and outputs
1194 model->identifyInputsAndOutputs(
1195 {in1, roi1},
1196 {out1});
1197 assert(model->isValid());
1198 }
1199
is_ignored_dynamic_output_shape_nhwc_quant8_2(int i)1200 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_2(int i) {
1201 static std::set<int> ignore = {};
1202 return ignore.find(i) != ignore.end();
1203 }
1204
CreateModel_dynamic_output_shape_nhwc_float16_2(Model * model)1205 void CreateModel_dynamic_output_shape_nhwc_float16_2(Model *model) {
1206 OperandType type0(Type::BOOL, {});
1207 OperandType type10(Type::TENSOR_INT32, {4});
1208 OperandType type17(Type::FLOAT16, {});
1209 OperandType type27(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
1210 OperandType type31(Type::TENSOR_FLOAT16, {4, 4, 8, 2});
1211 OperandType type33(Type::TENSOR_FLOAT16, {4, 4});
1212 OperandType type5(Type::INT32, {});
1213 // Phase 1, operands
1214 auto in1 = model->addOperand(&type31);
1215 auto roi1 = model->addOperand(&type33);
1216 auto param5 = model->addOperand(&type10);
1217 auto param6 = model->addOperand(&type5);
1218 auto param7 = model->addOperand(&type5);
1219 auto param8 = model->addOperand(&type17);
1220 auto param9 = model->addOperand(&type17);
1221 auto layout = model->addOperand(&type0);
1222 auto out1 = model->addOperand(&type27);
1223 // Phase 2, operations
1224 static int32_t param5_init[] = {0, 0, 3, 3};
1225 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1226 static int32_t param6_init[] = {2};
1227 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1228 static int32_t param7_init[] = {3};
1229 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1230 static _Float16 param8_init[] = {4.0f};
1231 model->setOperandValue(param8, param8_init, sizeof(_Float16) * 1);
1232 static _Float16 param9_init[] = {4.0f};
1233 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
1234 static bool8 layout_init[] = {false};
1235 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1236 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1237 // Phase 3, inputs and outputs
1238 model->identifyInputsAndOutputs(
1239 {in1, roi1},
1240 {out1});
1241 assert(model->isValid());
1242 }
1243
is_ignored_dynamic_output_shape_nhwc_float16_2(int i)1244 inline bool is_ignored_dynamic_output_shape_nhwc_float16_2(int i) {
1245 static std::set<int> ignore = {};
1246 return ignore.find(i) != ignore.end();
1247 }
1248
CreateModel_dynamic_output_shape_nchw_2(Model * model)1249 void CreateModel_dynamic_output_shape_nchw_2(Model *model) {
1250 OperandType type0(Type::BOOL, {});
1251 OperandType type10(Type::TENSOR_INT32, {4});
1252 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1253 OperandType type34(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
1254 OperandType type5(Type::INT32, {});
1255 OperandType type6(Type::FLOAT32, {});
1256 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
1257 // Phase 1, operands
1258 auto in1 = model->addOperand(&type34);
1259 auto roi1 = model->addOperand(&type8);
1260 auto param5 = model->addOperand(&type10);
1261 auto param6 = model->addOperand(&type5);
1262 auto param7 = model->addOperand(&type5);
1263 auto param8 = model->addOperand(&type6);
1264 auto param9 = model->addOperand(&type6);
1265 auto layout = model->addOperand(&type0);
1266 auto out1 = model->addOperand(&type25);
1267 // Phase 2, operations
1268 static int32_t param5_init[] = {0, 0, 3, 3};
1269 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1270 static int32_t param6_init[] = {2};
1271 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1272 static int32_t param7_init[] = {3};
1273 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1274 static float param8_init[] = {4.0f};
1275 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1276 static float param9_init[] = {4.0f};
1277 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1278 static bool8 layout_init[] = {true};
1279 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1280 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1281 // Phase 3, inputs and outputs
1282 model->identifyInputsAndOutputs(
1283 {in1, roi1},
1284 {out1});
1285 assert(model->isValid());
1286 }
1287
is_ignored_dynamic_output_shape_nchw_2(int i)1288 inline bool is_ignored_dynamic_output_shape_nchw_2(int i) {
1289 static std::set<int> ignore = {};
1290 return ignore.find(i) != ignore.end();
1291 }
1292
CreateModel_dynamic_output_shape_nchw_relaxed_2(Model * model)1293 void CreateModel_dynamic_output_shape_nchw_relaxed_2(Model *model) {
1294 OperandType type0(Type::BOOL, {});
1295 OperandType type10(Type::TENSOR_INT32, {4});
1296 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1297 OperandType type34(Type::TENSOR_FLOAT32, {4, 2, 4, 8});
1298 OperandType type5(Type::INT32, {});
1299 OperandType type6(Type::FLOAT32, {});
1300 OperandType type8(Type::TENSOR_FLOAT32, {4, 4});
1301 // Phase 1, operands
1302 auto in1 = model->addOperand(&type34);
1303 auto roi1 = model->addOperand(&type8);
1304 auto param5 = model->addOperand(&type10);
1305 auto param6 = model->addOperand(&type5);
1306 auto param7 = model->addOperand(&type5);
1307 auto param8 = model->addOperand(&type6);
1308 auto param9 = model->addOperand(&type6);
1309 auto layout = model->addOperand(&type0);
1310 auto out1 = model->addOperand(&type25);
1311 // Phase 2, operations
1312 static int32_t param5_init[] = {0, 0, 3, 3};
1313 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1314 static int32_t param6_init[] = {2};
1315 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1316 static int32_t param7_init[] = {3};
1317 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1318 static float param8_init[] = {4.0f};
1319 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1320 static float param9_init[] = {4.0f};
1321 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1322 static bool8 layout_init[] = {true};
1323 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1324 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1325 // Phase 3, inputs and outputs
1326 model->identifyInputsAndOutputs(
1327 {in1, roi1},
1328 {out1});
1329 // Phase 4: set relaxed execution
1330 model->relaxComputationFloat32toFloat16(true);
1331 assert(model->isValid());
1332 }
1333
is_ignored_dynamic_output_shape_nchw_relaxed_2(int i)1334 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_2(int i) {
1335 static std::set<int> ignore = {};
1336 return ignore.find(i) != ignore.end();
1337 }
1338
CreateModel_dynamic_output_shape_nchw_quant8_2(Model * model)1339 void CreateModel_dynamic_output_shape_nchw_quant8_2(Model *model) {
1340 OperandType type0(Type::BOOL, {});
1341 OperandType type10(Type::TENSOR_INT32, {4});
1342 OperandType type30(Type::TENSOR_QUANT16_ASYMM, {4, 4}, 0.125f, 0);
1343 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {4, 2, 4, 8}, 0.04f, 0);
1344 OperandType type40(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.04f, 0);
1345 OperandType type5(Type::INT32, {});
1346 OperandType type6(Type::FLOAT32, {});
1347 // Phase 1, operands
1348 auto in1 = model->addOperand(&type36);
1349 auto roi1 = model->addOperand(&type30);
1350 auto param5 = model->addOperand(&type10);
1351 auto param6 = model->addOperand(&type5);
1352 auto param7 = model->addOperand(&type5);
1353 auto param8 = model->addOperand(&type6);
1354 auto param9 = model->addOperand(&type6);
1355 auto layout = model->addOperand(&type0);
1356 auto out1 = model->addOperand(&type40);
1357 // Phase 2, operations
1358 static int32_t param5_init[] = {0, 0, 3, 3};
1359 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1360 static int32_t param6_init[] = {2};
1361 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1362 static int32_t param7_init[] = {3};
1363 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1364 static float param8_init[] = {4.0f};
1365 model->setOperandValue(param8, param8_init, sizeof(float) * 1);
1366 static float param9_init[] = {4.0f};
1367 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
1368 static bool8 layout_init[] = {true};
1369 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1370 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1371 // Phase 3, inputs and outputs
1372 model->identifyInputsAndOutputs(
1373 {in1, roi1},
1374 {out1});
1375 assert(model->isValid());
1376 }
1377
is_ignored_dynamic_output_shape_nchw_quant8_2(int i)1378 inline bool is_ignored_dynamic_output_shape_nchw_quant8_2(int i) {
1379 static std::set<int> ignore = {};
1380 return ignore.find(i) != ignore.end();
1381 }
1382
CreateModel_dynamic_output_shape_nchw_float16_2(Model * model)1383 void CreateModel_dynamic_output_shape_nchw_float16_2(Model *model) {
1384 OperandType type0(Type::BOOL, {});
1385 OperandType type10(Type::TENSOR_INT32, {4});
1386 OperandType type17(Type::FLOAT16, {});
1387 OperandType type27(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
1388 OperandType type33(Type::TENSOR_FLOAT16, {4, 4});
1389 OperandType type38(Type::TENSOR_FLOAT16, {4, 2, 4, 8});
1390 OperandType type5(Type::INT32, {});
1391 // Phase 1, operands
1392 auto in1 = model->addOperand(&type38);
1393 auto roi1 = model->addOperand(&type33);
1394 auto param5 = model->addOperand(&type10);
1395 auto param6 = model->addOperand(&type5);
1396 auto param7 = model->addOperand(&type5);
1397 auto param8 = model->addOperand(&type17);
1398 auto param9 = model->addOperand(&type17);
1399 auto layout = model->addOperand(&type0);
1400 auto out1 = model->addOperand(&type27);
1401 // Phase 2, operations
1402 static int32_t param5_init[] = {0, 0, 3, 3};
1403 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 4);
1404 static int32_t param6_init[] = {2};
1405 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
1406 static int32_t param7_init[] = {3};
1407 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
1408 static _Float16 param8_init[] = {4.0f};
1409 model->setOperandValue(param8, param8_init, sizeof(_Float16) * 1);
1410 static _Float16 param9_init[] = {4.0f};
1411 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
1412 static bool8 layout_init[] = {true};
1413 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1414 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in1, roi1, param5, param6, param7, param8, param9, layout}, {out1});
1415 // Phase 3, inputs and outputs
1416 model->identifyInputsAndOutputs(
1417 {in1, roi1},
1418 {out1});
1419 assert(model->isValid());
1420 }
1421
is_ignored_dynamic_output_shape_nchw_float16_2(int i)1422 inline bool is_ignored_dynamic_output_shape_nchw_float16_2(int i) {
1423 static std::set<int> ignore = {};
1424 return ignore.find(i) != ignore.end();
1425 }
1426
CreateModel_nhwc_3(Model * model)1427 void CreateModel_nhwc_3(Model *model) {
1428 OperandType type0(Type::BOOL, {});
1429 OperandType type11(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
1430 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1431 OperandType type3(Type::TENSOR_FLOAT32, {5, 2, 2, 1});
1432 OperandType type4(Type::TENSOR_INT32, {5});
1433 OperandType type5(Type::INT32, {});
1434 OperandType type6(Type::FLOAT32, {});
1435 // Phase 1, operands
1436 auto in2 = model->addOperand(&type11);
1437 auto roi2 = model->addOperand(&type2);
1438 auto param10 = model->addOperand(&type4);
1439 auto param11 = model->addOperand(&type5);
1440 auto param12 = model->addOperand(&type5);
1441 auto param13 = model->addOperand(&type6);
1442 auto param14 = model->addOperand(&type6);
1443 auto layout = model->addOperand(&type0);
1444 auto out2 = model->addOperand(&type3);
1445 // Phase 2, operations
1446 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1447 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1448 static int32_t param11_init[] = {2};
1449 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1450 static int32_t param12_init[] = {2};
1451 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1452 static float param13_init[] = {2.0f};
1453 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1454 static float param14_init[] = {1.0f};
1455 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1456 static bool8 layout_init[] = {false};
1457 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1458 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1459 // Phase 3, inputs and outputs
1460 model->identifyInputsAndOutputs(
1461 {in2, roi2},
1462 {out2});
1463 assert(model->isValid());
1464 }
1465
is_ignored_nhwc_3(int i)1466 inline bool is_ignored_nhwc_3(int i) {
1467 static std::set<int> ignore = {};
1468 return ignore.find(i) != ignore.end();
1469 }
1470
CreateModel_nhwc_relaxed_3(Model * model)1471 void CreateModel_nhwc_relaxed_3(Model *model) {
1472 OperandType type0(Type::BOOL, {});
1473 OperandType type11(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
1474 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1475 OperandType type3(Type::TENSOR_FLOAT32, {5, 2, 2, 1});
1476 OperandType type4(Type::TENSOR_INT32, {5});
1477 OperandType type5(Type::INT32, {});
1478 OperandType type6(Type::FLOAT32, {});
1479 // Phase 1, operands
1480 auto in2 = model->addOperand(&type11);
1481 auto roi2 = model->addOperand(&type2);
1482 auto param10 = model->addOperand(&type4);
1483 auto param11 = model->addOperand(&type5);
1484 auto param12 = model->addOperand(&type5);
1485 auto param13 = model->addOperand(&type6);
1486 auto param14 = model->addOperand(&type6);
1487 auto layout = model->addOperand(&type0);
1488 auto out2 = model->addOperand(&type3);
1489 // Phase 2, operations
1490 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1491 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1492 static int32_t param11_init[] = {2};
1493 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1494 static int32_t param12_init[] = {2};
1495 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1496 static float param13_init[] = {2.0f};
1497 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1498 static float param14_init[] = {1.0f};
1499 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1500 static bool8 layout_init[] = {false};
1501 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1502 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1503 // Phase 3, inputs and outputs
1504 model->identifyInputsAndOutputs(
1505 {in2, roi2},
1506 {out2});
1507 // Phase 4: set relaxed execution
1508 model->relaxComputationFloat32toFloat16(true);
1509 assert(model->isValid());
1510 }
1511
is_ignored_nhwc_relaxed_3(int i)1512 inline bool is_ignored_nhwc_relaxed_3(int i) {
1513 static std::set<int> ignore = {};
1514 return ignore.find(i) != ignore.end();
1515 }
1516
CreateModel_nhwc_quant8_3(Model * model)1517 void CreateModel_nhwc_quant8_3(Model *model) {
1518 OperandType type0(Type::BOOL, {});
1519 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {5, 2, 2, 1}, 0.25f, 128);
1520 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
1521 OperandType type4(Type::TENSOR_INT32, {5});
1522 OperandType type41(Type::TENSOR_QUANT8_ASYMM, {4, 4, 4, 1}, 0.25f, 128);
1523 OperandType type5(Type::INT32, {});
1524 OperandType type6(Type::FLOAT32, {});
1525 // Phase 1, operands
1526 auto in2 = model->addOperand(&type41);
1527 auto roi2 = model->addOperand(&type14);
1528 auto param10 = model->addOperand(&type4);
1529 auto param11 = model->addOperand(&type5);
1530 auto param12 = model->addOperand(&type5);
1531 auto param13 = model->addOperand(&type6);
1532 auto param14 = model->addOperand(&type6);
1533 auto layout = model->addOperand(&type0);
1534 auto out2 = model->addOperand(&type13);
1535 // Phase 2, operations
1536 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1537 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1538 static int32_t param11_init[] = {2};
1539 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1540 static int32_t param12_init[] = {2};
1541 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1542 static float param13_init[] = {2.0f};
1543 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1544 static float param14_init[] = {1.0f};
1545 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1546 static bool8 layout_init[] = {false};
1547 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1548 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1549 // Phase 3, inputs and outputs
1550 model->identifyInputsAndOutputs(
1551 {in2, roi2},
1552 {out2});
1553 assert(model->isValid());
1554 }
1555
is_ignored_nhwc_quant8_3(int i)1556 inline bool is_ignored_nhwc_quant8_3(int i) {
1557 static std::set<int> ignore = {};
1558 return ignore.find(i) != ignore.end();
1559 }
1560
CreateModel_nhwc_float16_3(Model * model)1561 void CreateModel_nhwc_float16_3(Model *model) {
1562 OperandType type0(Type::BOOL, {});
1563 OperandType type16(Type::TENSOR_FLOAT16, {5, 2, 2, 1});
1564 OperandType type17(Type::FLOAT16, {});
1565 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
1566 OperandType type4(Type::TENSOR_INT32, {5});
1567 OperandType type42(Type::TENSOR_FLOAT16, {4, 4, 4, 1});
1568 OperandType type5(Type::INT32, {});
1569 // Phase 1, operands
1570 auto in2 = model->addOperand(&type42);
1571 auto roi2 = model->addOperand(&type18);
1572 auto param10 = model->addOperand(&type4);
1573 auto param11 = model->addOperand(&type5);
1574 auto param12 = model->addOperand(&type5);
1575 auto param13 = model->addOperand(&type17);
1576 auto param14 = model->addOperand(&type17);
1577 auto layout = model->addOperand(&type0);
1578 auto out2 = model->addOperand(&type16);
1579 // Phase 2, operations
1580 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1581 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1582 static int32_t param11_init[] = {2};
1583 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1584 static int32_t param12_init[] = {2};
1585 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1586 static _Float16 param13_init[] = {2.0f};
1587 model->setOperandValue(param13, param13_init, sizeof(_Float16) * 1);
1588 static _Float16 param14_init[] = {1.0f};
1589 model->setOperandValue(param14, param14_init, sizeof(_Float16) * 1);
1590 static bool8 layout_init[] = {false};
1591 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1592 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1593 // Phase 3, inputs and outputs
1594 model->identifyInputsAndOutputs(
1595 {in2, roi2},
1596 {out2});
1597 assert(model->isValid());
1598 }
1599
is_ignored_nhwc_float16_3(int i)1600 inline bool is_ignored_nhwc_float16_3(int i) {
1601 static std::set<int> ignore = {};
1602 return ignore.find(i) != ignore.end();
1603 }
1604
CreateModel_nchw_3(Model * model)1605 void CreateModel_nchw_3(Model *model) {
1606 OperandType type0(Type::BOOL, {});
1607 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1608 OperandType type20(Type::TENSOR_FLOAT32, {5, 1, 2, 2});
1609 OperandType type4(Type::TENSOR_INT32, {5});
1610 OperandType type43(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
1611 OperandType type5(Type::INT32, {});
1612 OperandType type6(Type::FLOAT32, {});
1613 // Phase 1, operands
1614 auto in2 = model->addOperand(&type43);
1615 auto roi2 = model->addOperand(&type2);
1616 auto param10 = model->addOperand(&type4);
1617 auto param11 = model->addOperand(&type5);
1618 auto param12 = model->addOperand(&type5);
1619 auto param13 = model->addOperand(&type6);
1620 auto param14 = model->addOperand(&type6);
1621 auto layout = model->addOperand(&type0);
1622 auto out2 = model->addOperand(&type20);
1623 // Phase 2, operations
1624 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1625 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1626 static int32_t param11_init[] = {2};
1627 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1628 static int32_t param12_init[] = {2};
1629 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1630 static float param13_init[] = {2.0f};
1631 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1632 static float param14_init[] = {1.0f};
1633 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1634 static bool8 layout_init[] = {true};
1635 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1636 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1637 // Phase 3, inputs and outputs
1638 model->identifyInputsAndOutputs(
1639 {in2, roi2},
1640 {out2});
1641 assert(model->isValid());
1642 }
1643
is_ignored_nchw_3(int i)1644 inline bool is_ignored_nchw_3(int i) {
1645 static std::set<int> ignore = {};
1646 return ignore.find(i) != ignore.end();
1647 }
1648
CreateModel_nchw_relaxed_3(Model * model)1649 void CreateModel_nchw_relaxed_3(Model *model) {
1650 OperandType type0(Type::BOOL, {});
1651 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1652 OperandType type20(Type::TENSOR_FLOAT32, {5, 1, 2, 2});
1653 OperandType type4(Type::TENSOR_INT32, {5});
1654 OperandType type43(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
1655 OperandType type5(Type::INT32, {});
1656 OperandType type6(Type::FLOAT32, {});
1657 // Phase 1, operands
1658 auto in2 = model->addOperand(&type43);
1659 auto roi2 = model->addOperand(&type2);
1660 auto param10 = model->addOperand(&type4);
1661 auto param11 = model->addOperand(&type5);
1662 auto param12 = model->addOperand(&type5);
1663 auto param13 = model->addOperand(&type6);
1664 auto param14 = model->addOperand(&type6);
1665 auto layout = model->addOperand(&type0);
1666 auto out2 = model->addOperand(&type20);
1667 // Phase 2, operations
1668 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1669 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1670 static int32_t param11_init[] = {2};
1671 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1672 static int32_t param12_init[] = {2};
1673 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1674 static float param13_init[] = {2.0f};
1675 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1676 static float param14_init[] = {1.0f};
1677 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1678 static bool8 layout_init[] = {true};
1679 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1680 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1681 // Phase 3, inputs and outputs
1682 model->identifyInputsAndOutputs(
1683 {in2, roi2},
1684 {out2});
1685 // Phase 4: set relaxed execution
1686 model->relaxComputationFloat32toFloat16(true);
1687 assert(model->isValid());
1688 }
1689
is_ignored_nchw_relaxed_3(int i)1690 inline bool is_ignored_nchw_relaxed_3(int i) {
1691 static std::set<int> ignore = {};
1692 return ignore.find(i) != ignore.end();
1693 }
1694
CreateModel_nchw_quant8_3(Model * model)1695 void CreateModel_nchw_quant8_3(Model *model) {
1696 OperandType type0(Type::BOOL, {});
1697 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
1698 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {5, 1, 2, 2}, 0.25f, 128);
1699 OperandType type4(Type::TENSOR_INT32, {5});
1700 OperandType type44(Type::TENSOR_QUANT8_ASYMM, {4, 1, 4, 4}, 0.25f, 128);
1701 OperandType type5(Type::INT32, {});
1702 OperandType type6(Type::FLOAT32, {});
1703 // Phase 1, operands
1704 auto in2 = model->addOperand(&type44);
1705 auto roi2 = model->addOperand(&type14);
1706 auto param10 = model->addOperand(&type4);
1707 auto param11 = model->addOperand(&type5);
1708 auto param12 = model->addOperand(&type5);
1709 auto param13 = model->addOperand(&type6);
1710 auto param14 = model->addOperand(&type6);
1711 auto layout = model->addOperand(&type0);
1712 auto out2 = model->addOperand(&type22);
1713 // Phase 2, operations
1714 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1715 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1716 static int32_t param11_init[] = {2};
1717 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1718 static int32_t param12_init[] = {2};
1719 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1720 static float param13_init[] = {2.0f};
1721 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1722 static float param14_init[] = {1.0f};
1723 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1724 static bool8 layout_init[] = {true};
1725 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1726 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1727 // Phase 3, inputs and outputs
1728 model->identifyInputsAndOutputs(
1729 {in2, roi2},
1730 {out2});
1731 assert(model->isValid());
1732 }
1733
is_ignored_nchw_quant8_3(int i)1734 inline bool is_ignored_nchw_quant8_3(int i) {
1735 static std::set<int> ignore = {};
1736 return ignore.find(i) != ignore.end();
1737 }
1738
CreateModel_nchw_float16_3(Model * model)1739 void CreateModel_nchw_float16_3(Model *model) {
1740 OperandType type0(Type::BOOL, {});
1741 OperandType type17(Type::FLOAT16, {});
1742 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
1743 OperandType type24(Type::TENSOR_FLOAT16, {5, 1, 2, 2});
1744 OperandType type4(Type::TENSOR_INT32, {5});
1745 OperandType type45(Type::TENSOR_FLOAT16, {4, 1, 4, 4});
1746 OperandType type5(Type::INT32, {});
1747 // Phase 1, operands
1748 auto in2 = model->addOperand(&type45);
1749 auto roi2 = model->addOperand(&type18);
1750 auto param10 = model->addOperand(&type4);
1751 auto param11 = model->addOperand(&type5);
1752 auto param12 = model->addOperand(&type5);
1753 auto param13 = model->addOperand(&type17);
1754 auto param14 = model->addOperand(&type17);
1755 auto layout = model->addOperand(&type0);
1756 auto out2 = model->addOperand(&type24);
1757 // Phase 2, operations
1758 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1759 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1760 static int32_t param11_init[] = {2};
1761 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1762 static int32_t param12_init[] = {2};
1763 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1764 static _Float16 param13_init[] = {2.0f};
1765 model->setOperandValue(param13, param13_init, sizeof(_Float16) * 1);
1766 static _Float16 param14_init[] = {1.0f};
1767 model->setOperandValue(param14, param14_init, sizeof(_Float16) * 1);
1768 static bool8 layout_init[] = {true};
1769 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1770 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1771 // Phase 3, inputs and outputs
1772 model->identifyInputsAndOutputs(
1773 {in2, roi2},
1774 {out2});
1775 assert(model->isValid());
1776 }
1777
is_ignored_nchw_float16_3(int i)1778 inline bool is_ignored_nchw_float16_3(int i) {
1779 static std::set<int> ignore = {};
1780 return ignore.find(i) != ignore.end();
1781 }
1782
CreateModel_dynamic_output_shape_nhwc_3(Model * model)1783 void CreateModel_dynamic_output_shape_nhwc_3(Model *model) {
1784 OperandType type0(Type::BOOL, {});
1785 OperandType type11(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
1786 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1787 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1788 OperandType type4(Type::TENSOR_INT32, {5});
1789 OperandType type5(Type::INT32, {});
1790 OperandType type6(Type::FLOAT32, {});
1791 // Phase 1, operands
1792 auto in2 = model->addOperand(&type11);
1793 auto roi2 = model->addOperand(&type2);
1794 auto param10 = model->addOperand(&type4);
1795 auto param11 = model->addOperand(&type5);
1796 auto param12 = model->addOperand(&type5);
1797 auto param13 = model->addOperand(&type6);
1798 auto param14 = model->addOperand(&type6);
1799 auto layout = model->addOperand(&type0);
1800 auto out2 = model->addOperand(&type25);
1801 // Phase 2, operations
1802 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1803 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1804 static int32_t param11_init[] = {2};
1805 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1806 static int32_t param12_init[] = {2};
1807 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1808 static float param13_init[] = {2.0f};
1809 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1810 static float param14_init[] = {1.0f};
1811 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1812 static bool8 layout_init[] = {false};
1813 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1814 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1815 // Phase 3, inputs and outputs
1816 model->identifyInputsAndOutputs(
1817 {in2, roi2},
1818 {out2});
1819 assert(model->isValid());
1820 }
1821
is_ignored_dynamic_output_shape_nhwc_3(int i)1822 inline bool is_ignored_dynamic_output_shape_nhwc_3(int i) {
1823 static std::set<int> ignore = {};
1824 return ignore.find(i) != ignore.end();
1825 }
1826
CreateModel_dynamic_output_shape_nhwc_relaxed_3(Model * model)1827 void CreateModel_dynamic_output_shape_nhwc_relaxed_3(Model *model) {
1828 OperandType type0(Type::BOOL, {});
1829 OperandType type11(Type::TENSOR_FLOAT32, {4, 4, 4, 1});
1830 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1831 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1832 OperandType type4(Type::TENSOR_INT32, {5});
1833 OperandType type5(Type::INT32, {});
1834 OperandType type6(Type::FLOAT32, {});
1835 // Phase 1, operands
1836 auto in2 = model->addOperand(&type11);
1837 auto roi2 = model->addOperand(&type2);
1838 auto param10 = model->addOperand(&type4);
1839 auto param11 = model->addOperand(&type5);
1840 auto param12 = model->addOperand(&type5);
1841 auto param13 = model->addOperand(&type6);
1842 auto param14 = model->addOperand(&type6);
1843 auto layout = model->addOperand(&type0);
1844 auto out2 = model->addOperand(&type25);
1845 // Phase 2, operations
1846 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1847 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1848 static int32_t param11_init[] = {2};
1849 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1850 static int32_t param12_init[] = {2};
1851 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1852 static float param13_init[] = {2.0f};
1853 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1854 static float param14_init[] = {1.0f};
1855 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1856 static bool8 layout_init[] = {false};
1857 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1858 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1859 // Phase 3, inputs and outputs
1860 model->identifyInputsAndOutputs(
1861 {in2, roi2},
1862 {out2});
1863 // Phase 4: set relaxed execution
1864 model->relaxComputationFloat32toFloat16(true);
1865 assert(model->isValid());
1866 }
1867
is_ignored_dynamic_output_shape_nhwc_relaxed_3(int i)1868 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_3(int i) {
1869 static std::set<int> ignore = {};
1870 return ignore.find(i) != ignore.end();
1871 }
1872
CreateModel_dynamic_output_shape_nhwc_quant8_3(Model * model)1873 void CreateModel_dynamic_output_shape_nhwc_quant8_3(Model *model) {
1874 OperandType type0(Type::BOOL, {});
1875 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
1876 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
1877 OperandType type4(Type::TENSOR_INT32, {5});
1878 OperandType type41(Type::TENSOR_QUANT8_ASYMM, {4, 4, 4, 1}, 0.25f, 128);
1879 OperandType type5(Type::INT32, {});
1880 OperandType type6(Type::FLOAT32, {});
1881 // Phase 1, operands
1882 auto in2 = model->addOperand(&type41);
1883 auto roi2 = model->addOperand(&type14);
1884 auto param10 = model->addOperand(&type4);
1885 auto param11 = model->addOperand(&type5);
1886 auto param12 = model->addOperand(&type5);
1887 auto param13 = model->addOperand(&type6);
1888 auto param14 = model->addOperand(&type6);
1889 auto layout = model->addOperand(&type0);
1890 auto out2 = model->addOperand(&type26);
1891 // Phase 2, operations
1892 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1893 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1894 static int32_t param11_init[] = {2};
1895 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1896 static int32_t param12_init[] = {2};
1897 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1898 static float param13_init[] = {2.0f};
1899 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1900 static float param14_init[] = {1.0f};
1901 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1902 static bool8 layout_init[] = {false};
1903 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1904 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1905 // Phase 3, inputs and outputs
1906 model->identifyInputsAndOutputs(
1907 {in2, roi2},
1908 {out2});
1909 assert(model->isValid());
1910 }
1911
is_ignored_dynamic_output_shape_nhwc_quant8_3(int i)1912 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_3(int i) {
1913 static std::set<int> ignore = {};
1914 return ignore.find(i) != ignore.end();
1915 }
1916
CreateModel_dynamic_output_shape_nhwc_float16_3(Model * model)1917 void CreateModel_dynamic_output_shape_nhwc_float16_3(Model *model) {
1918 OperandType type0(Type::BOOL, {});
1919 OperandType type17(Type::FLOAT16, {});
1920 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
1921 OperandType type27(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
1922 OperandType type4(Type::TENSOR_INT32, {5});
1923 OperandType type42(Type::TENSOR_FLOAT16, {4, 4, 4, 1});
1924 OperandType type5(Type::INT32, {});
1925 // Phase 1, operands
1926 auto in2 = model->addOperand(&type42);
1927 auto roi2 = model->addOperand(&type18);
1928 auto param10 = model->addOperand(&type4);
1929 auto param11 = model->addOperand(&type5);
1930 auto param12 = model->addOperand(&type5);
1931 auto param13 = model->addOperand(&type17);
1932 auto param14 = model->addOperand(&type17);
1933 auto layout = model->addOperand(&type0);
1934 auto out2 = model->addOperand(&type27);
1935 // Phase 2, operations
1936 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1937 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1938 static int32_t param11_init[] = {2};
1939 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1940 static int32_t param12_init[] = {2};
1941 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1942 static _Float16 param13_init[] = {2.0f};
1943 model->setOperandValue(param13, param13_init, sizeof(_Float16) * 1);
1944 static _Float16 param14_init[] = {1.0f};
1945 model->setOperandValue(param14, param14_init, sizeof(_Float16) * 1);
1946 static bool8 layout_init[] = {false};
1947 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1948 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1949 // Phase 3, inputs and outputs
1950 model->identifyInputsAndOutputs(
1951 {in2, roi2},
1952 {out2});
1953 assert(model->isValid());
1954 }
1955
is_ignored_dynamic_output_shape_nhwc_float16_3(int i)1956 inline bool is_ignored_dynamic_output_shape_nhwc_float16_3(int i) {
1957 static std::set<int> ignore = {};
1958 return ignore.find(i) != ignore.end();
1959 }
1960
CreateModel_dynamic_output_shape_nchw_3(Model * model)1961 void CreateModel_dynamic_output_shape_nchw_3(Model *model) {
1962 OperandType type0(Type::BOOL, {});
1963 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
1964 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
1965 OperandType type4(Type::TENSOR_INT32, {5});
1966 OperandType type43(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
1967 OperandType type5(Type::INT32, {});
1968 OperandType type6(Type::FLOAT32, {});
1969 // Phase 1, operands
1970 auto in2 = model->addOperand(&type43);
1971 auto roi2 = model->addOperand(&type2);
1972 auto param10 = model->addOperand(&type4);
1973 auto param11 = model->addOperand(&type5);
1974 auto param12 = model->addOperand(&type5);
1975 auto param13 = model->addOperand(&type6);
1976 auto param14 = model->addOperand(&type6);
1977 auto layout = model->addOperand(&type0);
1978 auto out2 = model->addOperand(&type25);
1979 // Phase 2, operations
1980 static int32_t param10_init[] = {2, 2, 2, 2, 2};
1981 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
1982 static int32_t param11_init[] = {2};
1983 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
1984 static int32_t param12_init[] = {2};
1985 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
1986 static float param13_init[] = {2.0f};
1987 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
1988 static float param14_init[] = {1.0f};
1989 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
1990 static bool8 layout_init[] = {true};
1991 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
1992 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
1993 // Phase 3, inputs and outputs
1994 model->identifyInputsAndOutputs(
1995 {in2, roi2},
1996 {out2});
1997 assert(model->isValid());
1998 }
1999
is_ignored_dynamic_output_shape_nchw_3(int i)2000 inline bool is_ignored_dynamic_output_shape_nchw_3(int i) {
2001 static std::set<int> ignore = {};
2002 return ignore.find(i) != ignore.end();
2003 }
2004
CreateModel_dynamic_output_shape_nchw_relaxed_3(Model * model)2005 void CreateModel_dynamic_output_shape_nchw_relaxed_3(Model *model) {
2006 OperandType type0(Type::BOOL, {});
2007 OperandType type2(Type::TENSOR_FLOAT32, {5, 4});
2008 OperandType type25(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2009 OperandType type4(Type::TENSOR_INT32, {5});
2010 OperandType type43(Type::TENSOR_FLOAT32, {4, 1, 4, 4});
2011 OperandType type5(Type::INT32, {});
2012 OperandType type6(Type::FLOAT32, {});
2013 // Phase 1, operands
2014 auto in2 = model->addOperand(&type43);
2015 auto roi2 = model->addOperand(&type2);
2016 auto param10 = model->addOperand(&type4);
2017 auto param11 = model->addOperand(&type5);
2018 auto param12 = model->addOperand(&type5);
2019 auto param13 = model->addOperand(&type6);
2020 auto param14 = model->addOperand(&type6);
2021 auto layout = model->addOperand(&type0);
2022 auto out2 = model->addOperand(&type25);
2023 // Phase 2, operations
2024 static int32_t param10_init[] = {2, 2, 2, 2, 2};
2025 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
2026 static int32_t param11_init[] = {2};
2027 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
2028 static int32_t param12_init[] = {2};
2029 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
2030 static float param13_init[] = {2.0f};
2031 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
2032 static float param14_init[] = {1.0f};
2033 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
2034 static bool8 layout_init[] = {true};
2035 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2036 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
2037 // Phase 3, inputs and outputs
2038 model->identifyInputsAndOutputs(
2039 {in2, roi2},
2040 {out2});
2041 // Phase 4: set relaxed execution
2042 model->relaxComputationFloat32toFloat16(true);
2043 assert(model->isValid());
2044 }
2045
is_ignored_dynamic_output_shape_nchw_relaxed_3(int i)2046 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_3(int i) {
2047 static std::set<int> ignore = {};
2048 return ignore.find(i) != ignore.end();
2049 }
2050
CreateModel_dynamic_output_shape_nchw_quant8_3(Model * model)2051 void CreateModel_dynamic_output_shape_nchw_quant8_3(Model *model) {
2052 OperandType type0(Type::BOOL, {});
2053 OperandType type14(Type::TENSOR_QUANT16_ASYMM, {5, 4}, 0.125f, 0);
2054 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
2055 OperandType type4(Type::TENSOR_INT32, {5});
2056 OperandType type44(Type::TENSOR_QUANT8_ASYMM, {4, 1, 4, 4}, 0.25f, 128);
2057 OperandType type5(Type::INT32, {});
2058 OperandType type6(Type::FLOAT32, {});
2059 // Phase 1, operands
2060 auto in2 = model->addOperand(&type44);
2061 auto roi2 = model->addOperand(&type14);
2062 auto param10 = model->addOperand(&type4);
2063 auto param11 = model->addOperand(&type5);
2064 auto param12 = model->addOperand(&type5);
2065 auto param13 = model->addOperand(&type6);
2066 auto param14 = model->addOperand(&type6);
2067 auto layout = model->addOperand(&type0);
2068 auto out2 = model->addOperand(&type26);
2069 // Phase 2, operations
2070 static int32_t param10_init[] = {2, 2, 2, 2, 2};
2071 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
2072 static int32_t param11_init[] = {2};
2073 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
2074 static int32_t param12_init[] = {2};
2075 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
2076 static float param13_init[] = {2.0f};
2077 model->setOperandValue(param13, param13_init, sizeof(float) * 1);
2078 static float param14_init[] = {1.0f};
2079 model->setOperandValue(param14, param14_init, sizeof(float) * 1);
2080 static bool8 layout_init[] = {true};
2081 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2082 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
2083 // Phase 3, inputs and outputs
2084 model->identifyInputsAndOutputs(
2085 {in2, roi2},
2086 {out2});
2087 assert(model->isValid());
2088 }
2089
is_ignored_dynamic_output_shape_nchw_quant8_3(int i)2090 inline bool is_ignored_dynamic_output_shape_nchw_quant8_3(int i) {
2091 static std::set<int> ignore = {};
2092 return ignore.find(i) != ignore.end();
2093 }
2094
CreateModel_dynamic_output_shape_nchw_float16_3(Model * model)2095 void CreateModel_dynamic_output_shape_nchw_float16_3(Model *model) {
2096 OperandType type0(Type::BOOL, {});
2097 OperandType type17(Type::FLOAT16, {});
2098 OperandType type18(Type::TENSOR_FLOAT16, {5, 4});
2099 OperandType type27(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
2100 OperandType type4(Type::TENSOR_INT32, {5});
2101 OperandType type45(Type::TENSOR_FLOAT16, {4, 1, 4, 4});
2102 OperandType type5(Type::INT32, {});
2103 // Phase 1, operands
2104 auto in2 = model->addOperand(&type45);
2105 auto roi2 = model->addOperand(&type18);
2106 auto param10 = model->addOperand(&type4);
2107 auto param11 = model->addOperand(&type5);
2108 auto param12 = model->addOperand(&type5);
2109 auto param13 = model->addOperand(&type17);
2110 auto param14 = model->addOperand(&type17);
2111 auto layout = model->addOperand(&type0);
2112 auto out2 = model->addOperand(&type27);
2113 // Phase 2, operations
2114 static int32_t param10_init[] = {2, 2, 2, 2, 2};
2115 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 5);
2116 static int32_t param11_init[] = {2};
2117 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
2118 static int32_t param12_init[] = {2};
2119 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
2120 static _Float16 param13_init[] = {2.0f};
2121 model->setOperandValue(param13, param13_init, sizeof(_Float16) * 1);
2122 static _Float16 param14_init[] = {1.0f};
2123 model->setOperandValue(param14, param14_init, sizeof(_Float16) * 1);
2124 static bool8 layout_init[] = {true};
2125 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
2126 model->addOperation(ANEURALNETWORKS_ROI_POOLING, {in2, roi2, param10, param11, param12, param13, param14, layout}, {out2});
2127 // Phase 3, inputs and outputs
2128 model->identifyInputsAndOutputs(
2129 {in2, roi2},
2130 {out2});
2131 assert(model->isValid());
2132 }
2133
is_ignored_dynamic_output_shape_nchw_float16_3(int i)2134 inline bool is_ignored_dynamic_output_shape_nchw_float16_3(int i) {
2135 static std::set<int> ignore = {};
2136 return ignore.find(i) != ignore.end();
2137 }
2138
2139