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