1 // clang-format off
2 // Generated file (from: channel_shuffle.mod.py). Do not edit
CreateModel_dim4_axis0(Model * model)3 void CreateModel_dim4_axis0(Model *model) {
4 OperandType type1(Type::INT32, {});
5 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
6 // Phase 1, operands
7 auto op1 = model->addOperand(&type2);
8 auto param = model->addOperand(&type1);
9 auto axis = model->addOperand(&type1);
10 auto op2 = model->addOperand(&type2);
11 // Phase 2, operations
12 static int32_t param_init[] = {3};
13 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
14 static int32_t axis_init[] = {0};
15 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
16 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
17 // Phase 3, inputs and outputs
18 model->identifyInputsAndOutputs(
19 {op1},
20 {op2});
21 assert(model->isValid());
22 }
23
is_ignored_dim4_axis0(int i)24 inline bool is_ignored_dim4_axis0(int i) {
25 static std::set<int> ignore = {};
26 return ignore.find(i) != ignore.end();
27 }
28
CreateModel_dim4_axis0_neg(Model * model)29 void CreateModel_dim4_axis0_neg(Model *model) {
30 OperandType type1(Type::INT32, {});
31 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
32 // Phase 1, operands
33 auto op1 = model->addOperand(&type2);
34 auto param = model->addOperand(&type1);
35 auto axis = model->addOperand(&type1);
36 auto op2 = model->addOperand(&type2);
37 // Phase 2, operations
38 static int32_t param_init[] = {3};
39 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
40 static int32_t axis_init[] = {-4};
41 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
42 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
43 // Phase 3, inputs and outputs
44 model->identifyInputsAndOutputs(
45 {op1},
46 {op2});
47 assert(model->isValid());
48 }
49
is_ignored_dim4_axis0_neg(int i)50 inline bool is_ignored_dim4_axis0_neg(int i) {
51 static std::set<int> ignore = {};
52 return ignore.find(i) != ignore.end();
53 }
54
CreateModel_dim4_axis1(Model * model)55 void CreateModel_dim4_axis1(Model *model) {
56 OperandType type1(Type::INT32, {});
57 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
58 // Phase 1, operands
59 auto op1 = model->addOperand(&type3);
60 auto param = model->addOperand(&type1);
61 auto axis = model->addOperand(&type1);
62 auto op2 = model->addOperand(&type3);
63 // Phase 2, operations
64 static int32_t param_init[] = {3};
65 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
66 static int32_t axis_init[] = {1};
67 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
68 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
69 // Phase 3, inputs and outputs
70 model->identifyInputsAndOutputs(
71 {op1},
72 {op2});
73 assert(model->isValid());
74 }
75
is_ignored_dim4_axis1(int i)76 inline bool is_ignored_dim4_axis1(int i) {
77 static std::set<int> ignore = {};
78 return ignore.find(i) != ignore.end();
79 }
80
CreateModel_dim4_axis1_neg(Model * model)81 void CreateModel_dim4_axis1_neg(Model *model) {
82 OperandType type1(Type::INT32, {});
83 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
84 // Phase 1, operands
85 auto op1 = model->addOperand(&type3);
86 auto param = model->addOperand(&type1);
87 auto axis = model->addOperand(&type1);
88 auto op2 = model->addOperand(&type3);
89 // Phase 2, operations
90 static int32_t param_init[] = {3};
91 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
92 static int32_t axis_init[] = {-3};
93 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
94 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
95 // Phase 3, inputs and outputs
96 model->identifyInputsAndOutputs(
97 {op1},
98 {op2});
99 assert(model->isValid());
100 }
101
is_ignored_dim4_axis1_neg(int i)102 inline bool is_ignored_dim4_axis1_neg(int i) {
103 static std::set<int> ignore = {};
104 return ignore.find(i) != ignore.end();
105 }
106
CreateModel_dim4_axis2(Model * model)107 void CreateModel_dim4_axis2(Model *model) {
108 OperandType type1(Type::INT32, {});
109 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
110 // Phase 1, operands
111 auto op1 = model->addOperand(&type4);
112 auto param = model->addOperand(&type1);
113 auto axis = model->addOperand(&type1);
114 auto op2 = model->addOperand(&type4);
115 // Phase 2, operations
116 static int32_t param_init[] = {3};
117 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
118 static int32_t axis_init[] = {2};
119 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
120 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
121 // Phase 3, inputs and outputs
122 model->identifyInputsAndOutputs(
123 {op1},
124 {op2});
125 assert(model->isValid());
126 }
127
is_ignored_dim4_axis2(int i)128 inline bool is_ignored_dim4_axis2(int i) {
129 static std::set<int> ignore = {};
130 return ignore.find(i) != ignore.end();
131 }
132
CreateModel_dim4_axis2_neg(Model * model)133 void CreateModel_dim4_axis2_neg(Model *model) {
134 OperandType type1(Type::INT32, {});
135 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
136 // Phase 1, operands
137 auto op1 = model->addOperand(&type4);
138 auto param = model->addOperand(&type1);
139 auto axis = model->addOperand(&type1);
140 auto op2 = model->addOperand(&type4);
141 // Phase 2, operations
142 static int32_t param_init[] = {3};
143 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
144 static int32_t axis_init[] = {-2};
145 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
146 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
147 // Phase 3, inputs and outputs
148 model->identifyInputsAndOutputs(
149 {op1},
150 {op2});
151 assert(model->isValid());
152 }
153
is_ignored_dim4_axis2_neg(int i)154 inline bool is_ignored_dim4_axis2_neg(int i) {
155 static std::set<int> ignore = {};
156 return ignore.find(i) != ignore.end();
157 }
158
CreateModel_dim4_axis3(Model * model)159 void CreateModel_dim4_axis3(Model *model) {
160 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
161 OperandType type1(Type::INT32, {});
162 // Phase 1, operands
163 auto op1 = model->addOperand(&type0);
164 auto param = model->addOperand(&type1);
165 auto axis = model->addOperand(&type1);
166 auto op2 = model->addOperand(&type0);
167 // Phase 2, operations
168 static int32_t param_init[] = {3};
169 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
170 static int32_t axis_init[] = {3};
171 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
172 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
173 // Phase 3, inputs and outputs
174 model->identifyInputsAndOutputs(
175 {op1},
176 {op2});
177 assert(model->isValid());
178 }
179
is_ignored_dim4_axis3(int i)180 inline bool is_ignored_dim4_axis3(int i) {
181 static std::set<int> ignore = {};
182 return ignore.find(i) != ignore.end();
183 }
184
CreateModel_dim4_axis3_neg(Model * model)185 void CreateModel_dim4_axis3_neg(Model *model) {
186 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
187 OperandType type1(Type::INT32, {});
188 // Phase 1, operands
189 auto op1 = model->addOperand(&type0);
190 auto param = model->addOperand(&type1);
191 auto axis = model->addOperand(&type1);
192 auto op2 = model->addOperand(&type0);
193 // Phase 2, operations
194 static int32_t param_init[] = {3};
195 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
196 static int32_t axis_init[] = {-1};
197 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
198 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
199 // Phase 3, inputs and outputs
200 model->identifyInputsAndOutputs(
201 {op1},
202 {op2});
203 assert(model->isValid());
204 }
205
is_ignored_dim4_axis3_neg(int i)206 inline bool is_ignored_dim4_axis3_neg(int i) {
207 static std::set<int> ignore = {};
208 return ignore.find(i) != ignore.end();
209 }
210
CreateModel_dim3_axis0(Model * model)211 void CreateModel_dim3_axis0(Model *model) {
212 OperandType type1(Type::INT32, {});
213 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
214 // Phase 1, operands
215 auto op1 = model->addOperand(&type5);
216 auto param = model->addOperand(&type1);
217 auto axis = model->addOperand(&type1);
218 auto op2 = model->addOperand(&type5);
219 // Phase 2, operations
220 static int32_t param_init[] = {3};
221 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
222 static int32_t axis_init[] = {0};
223 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
224 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
225 // Phase 3, inputs and outputs
226 model->identifyInputsAndOutputs(
227 {op1},
228 {op2});
229 assert(model->isValid());
230 }
231
is_ignored_dim3_axis0(int i)232 inline bool is_ignored_dim3_axis0(int i) {
233 static std::set<int> ignore = {};
234 return ignore.find(i) != ignore.end();
235 }
236
CreateModel_dim3_axis0_neg(Model * model)237 void CreateModel_dim3_axis0_neg(Model *model) {
238 OperandType type1(Type::INT32, {});
239 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
240 // Phase 1, operands
241 auto op1 = model->addOperand(&type5);
242 auto param = model->addOperand(&type1);
243 auto axis = model->addOperand(&type1);
244 auto op2 = model->addOperand(&type5);
245 // Phase 2, operations
246 static int32_t param_init[] = {3};
247 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
248 static int32_t axis_init[] = {-3};
249 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
250 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
251 // Phase 3, inputs and outputs
252 model->identifyInputsAndOutputs(
253 {op1},
254 {op2});
255 assert(model->isValid());
256 }
257
is_ignored_dim3_axis0_neg(int i)258 inline bool is_ignored_dim3_axis0_neg(int i) {
259 static std::set<int> ignore = {};
260 return ignore.find(i) != ignore.end();
261 }
262
CreateModel_dim3_axis1(Model * model)263 void CreateModel_dim3_axis1(Model *model) {
264 OperandType type1(Type::INT32, {});
265 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
266 // Phase 1, operands
267 auto op1 = model->addOperand(&type6);
268 auto param = model->addOperand(&type1);
269 auto axis = model->addOperand(&type1);
270 auto op2 = model->addOperand(&type6);
271 // Phase 2, operations
272 static int32_t param_init[] = {3};
273 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
274 static int32_t axis_init[] = {1};
275 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
276 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
277 // Phase 3, inputs and outputs
278 model->identifyInputsAndOutputs(
279 {op1},
280 {op2});
281 assert(model->isValid());
282 }
283
is_ignored_dim3_axis1(int i)284 inline bool is_ignored_dim3_axis1(int i) {
285 static std::set<int> ignore = {};
286 return ignore.find(i) != ignore.end();
287 }
288
CreateModel_dim3_axis1_neg(Model * model)289 void CreateModel_dim3_axis1_neg(Model *model) {
290 OperandType type1(Type::INT32, {});
291 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
292 // Phase 1, operands
293 auto op1 = model->addOperand(&type6);
294 auto param = model->addOperand(&type1);
295 auto axis = model->addOperand(&type1);
296 auto op2 = model->addOperand(&type6);
297 // Phase 2, operations
298 static int32_t param_init[] = {3};
299 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
300 static int32_t axis_init[] = {-2};
301 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
302 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
303 // Phase 3, inputs and outputs
304 model->identifyInputsAndOutputs(
305 {op1},
306 {op2});
307 assert(model->isValid());
308 }
309
is_ignored_dim3_axis1_neg(int i)310 inline bool is_ignored_dim3_axis1_neg(int i) {
311 static std::set<int> ignore = {};
312 return ignore.find(i) != ignore.end();
313 }
314
CreateModel_dim3_axis2(Model * model)315 void CreateModel_dim3_axis2(Model *model) {
316 OperandType type1(Type::INT32, {});
317 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
318 // Phase 1, operands
319 auto op1 = model->addOperand(&type7);
320 auto param = model->addOperand(&type1);
321 auto axis = model->addOperand(&type1);
322 auto op2 = model->addOperand(&type7);
323 // Phase 2, operations
324 static int32_t param_init[] = {3};
325 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
326 static int32_t axis_init[] = {2};
327 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
328 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
329 // Phase 3, inputs and outputs
330 model->identifyInputsAndOutputs(
331 {op1},
332 {op2});
333 assert(model->isValid());
334 }
335
is_ignored_dim3_axis2(int i)336 inline bool is_ignored_dim3_axis2(int i) {
337 static std::set<int> ignore = {};
338 return ignore.find(i) != ignore.end();
339 }
340
CreateModel_dim3_axis2_neg(Model * model)341 void CreateModel_dim3_axis2_neg(Model *model) {
342 OperandType type1(Type::INT32, {});
343 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
344 // Phase 1, operands
345 auto op1 = model->addOperand(&type7);
346 auto param = model->addOperand(&type1);
347 auto axis = model->addOperand(&type1);
348 auto op2 = model->addOperand(&type7);
349 // Phase 2, operations
350 static int32_t param_init[] = {3};
351 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
352 static int32_t axis_init[] = {-1};
353 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
354 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
355 // Phase 3, inputs and outputs
356 model->identifyInputsAndOutputs(
357 {op1},
358 {op2});
359 assert(model->isValid());
360 }
361
is_ignored_dim3_axis2_neg(int i)362 inline bool is_ignored_dim3_axis2_neg(int i) {
363 static std::set<int> ignore = {};
364 return ignore.find(i) != ignore.end();
365 }
366
CreateModel_dim2_axis0(Model * model)367 void CreateModel_dim2_axis0(Model *model) {
368 OperandType type1(Type::INT32, {});
369 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
370 // Phase 1, operands
371 auto op1 = model->addOperand(&type8);
372 auto param = model->addOperand(&type1);
373 auto axis = model->addOperand(&type1);
374 auto op2 = model->addOperand(&type8);
375 // Phase 2, operations
376 static int32_t param_init[] = {3};
377 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
378 static int32_t axis_init[] = {0};
379 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
380 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
381 // Phase 3, inputs and outputs
382 model->identifyInputsAndOutputs(
383 {op1},
384 {op2});
385 assert(model->isValid());
386 }
387
is_ignored_dim2_axis0(int i)388 inline bool is_ignored_dim2_axis0(int i) {
389 static std::set<int> ignore = {};
390 return ignore.find(i) != ignore.end();
391 }
392
CreateModel_dim2_axis0_neg(Model * model)393 void CreateModel_dim2_axis0_neg(Model *model) {
394 OperandType type1(Type::INT32, {});
395 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
396 // Phase 1, operands
397 auto op1 = model->addOperand(&type8);
398 auto param = model->addOperand(&type1);
399 auto axis = model->addOperand(&type1);
400 auto op2 = model->addOperand(&type8);
401 // Phase 2, operations
402 static int32_t param_init[] = {3};
403 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
404 static int32_t axis_init[] = {-2};
405 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
406 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
407 // Phase 3, inputs and outputs
408 model->identifyInputsAndOutputs(
409 {op1},
410 {op2});
411 assert(model->isValid());
412 }
413
is_ignored_dim2_axis0_neg(int i)414 inline bool is_ignored_dim2_axis0_neg(int i) {
415 static std::set<int> ignore = {};
416 return ignore.find(i) != ignore.end();
417 }
418
CreateModel_dim2_axis1(Model * model)419 void CreateModel_dim2_axis1(Model *model) {
420 OperandType type1(Type::INT32, {});
421 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
422 // Phase 1, operands
423 auto op1 = model->addOperand(&type9);
424 auto param = model->addOperand(&type1);
425 auto axis = model->addOperand(&type1);
426 auto op2 = model->addOperand(&type9);
427 // Phase 2, operations
428 static int32_t param_init[] = {3};
429 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
430 static int32_t axis_init[] = {1};
431 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
432 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
433 // Phase 3, inputs and outputs
434 model->identifyInputsAndOutputs(
435 {op1},
436 {op2});
437 assert(model->isValid());
438 }
439
is_ignored_dim2_axis1(int i)440 inline bool is_ignored_dim2_axis1(int i) {
441 static std::set<int> ignore = {};
442 return ignore.find(i) != ignore.end();
443 }
444
CreateModel_dim2_axis1_neg(Model * model)445 void CreateModel_dim2_axis1_neg(Model *model) {
446 OperandType type1(Type::INT32, {});
447 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
448 // Phase 1, operands
449 auto op1 = model->addOperand(&type9);
450 auto param = model->addOperand(&type1);
451 auto axis = model->addOperand(&type1);
452 auto op2 = model->addOperand(&type9);
453 // Phase 2, operations
454 static int32_t param_init[] = {3};
455 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
456 static int32_t axis_init[] = {-1};
457 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
458 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
459 // Phase 3, inputs and outputs
460 model->identifyInputsAndOutputs(
461 {op1},
462 {op2});
463 assert(model->isValid());
464 }
465
is_ignored_dim2_axis1_neg(int i)466 inline bool is_ignored_dim2_axis1_neg(int i) {
467 static std::set<int> ignore = {};
468 return ignore.find(i) != ignore.end();
469 }
470
CreateModel_dim1_axis0(Model * model)471 void CreateModel_dim1_axis0(Model *model) {
472 OperandType type1(Type::INT32, {});
473 OperandType type10(Type::TENSOR_FLOAT32, {12});
474 // Phase 1, operands
475 auto op1 = model->addOperand(&type10);
476 auto param = model->addOperand(&type1);
477 auto axis = model->addOperand(&type1);
478 auto op2 = model->addOperand(&type10);
479 // Phase 2, operations
480 static int32_t param_init[] = {3};
481 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
482 static int32_t axis_init[] = {0};
483 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
484 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
485 // Phase 3, inputs and outputs
486 model->identifyInputsAndOutputs(
487 {op1},
488 {op2});
489 assert(model->isValid());
490 }
491
is_ignored_dim1_axis0(int i)492 inline bool is_ignored_dim1_axis0(int i) {
493 static std::set<int> ignore = {};
494 return ignore.find(i) != ignore.end();
495 }
496
CreateModel_dim1_axis0_neg(Model * model)497 void CreateModel_dim1_axis0_neg(Model *model) {
498 OperandType type1(Type::INT32, {});
499 OperandType type10(Type::TENSOR_FLOAT32, {12});
500 // Phase 1, operands
501 auto op1 = model->addOperand(&type10);
502 auto param = model->addOperand(&type1);
503 auto axis = model->addOperand(&type1);
504 auto op2 = model->addOperand(&type10);
505 // Phase 2, operations
506 static int32_t param_init[] = {3};
507 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
508 static int32_t axis_init[] = {-1};
509 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
510 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
511 // Phase 3, inputs and outputs
512 model->identifyInputsAndOutputs(
513 {op1},
514 {op2});
515 assert(model->isValid());
516 }
517
is_ignored_dim1_axis0_neg(int i)518 inline bool is_ignored_dim1_axis0_neg(int i) {
519 static std::set<int> ignore = {};
520 return ignore.find(i) != ignore.end();
521 }
522
CreateModel_relaxed_dim4_axis0(Model * model)523 void CreateModel_relaxed_dim4_axis0(Model *model) {
524 OperandType type1(Type::INT32, {});
525 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
526 // Phase 1, operands
527 auto op1 = model->addOperand(&type2);
528 auto param = model->addOperand(&type1);
529 auto axis = model->addOperand(&type1);
530 auto op2 = model->addOperand(&type2);
531 // Phase 2, operations
532 static int32_t param_init[] = {3};
533 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
534 static int32_t axis_init[] = {0};
535 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
536 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
537 // Phase 3, inputs and outputs
538 model->identifyInputsAndOutputs(
539 {op1},
540 {op2});
541 // Phase 4: set relaxed execution
542 model->relaxComputationFloat32toFloat16(true);
543 assert(model->isValid());
544 }
545
is_ignored_relaxed_dim4_axis0(int i)546 inline bool is_ignored_relaxed_dim4_axis0(int i) {
547 static std::set<int> ignore = {};
548 return ignore.find(i) != ignore.end();
549 }
550
CreateModel_relaxed_dim4_axis0_neg(Model * model)551 void CreateModel_relaxed_dim4_axis0_neg(Model *model) {
552 OperandType type1(Type::INT32, {});
553 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
554 // Phase 1, operands
555 auto op1 = model->addOperand(&type2);
556 auto param = model->addOperand(&type1);
557 auto axis = model->addOperand(&type1);
558 auto op2 = model->addOperand(&type2);
559 // Phase 2, operations
560 static int32_t param_init[] = {3};
561 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
562 static int32_t axis_init[] = {-4};
563 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
564 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
565 // Phase 3, inputs and outputs
566 model->identifyInputsAndOutputs(
567 {op1},
568 {op2});
569 // Phase 4: set relaxed execution
570 model->relaxComputationFloat32toFloat16(true);
571 assert(model->isValid());
572 }
573
is_ignored_relaxed_dim4_axis0_neg(int i)574 inline bool is_ignored_relaxed_dim4_axis0_neg(int i) {
575 static std::set<int> ignore = {};
576 return ignore.find(i) != ignore.end();
577 }
578
CreateModel_relaxed_dim4_axis1(Model * model)579 void CreateModel_relaxed_dim4_axis1(Model *model) {
580 OperandType type1(Type::INT32, {});
581 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
582 // Phase 1, operands
583 auto op1 = model->addOperand(&type3);
584 auto param = model->addOperand(&type1);
585 auto axis = model->addOperand(&type1);
586 auto op2 = model->addOperand(&type3);
587 // Phase 2, operations
588 static int32_t param_init[] = {3};
589 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
590 static int32_t axis_init[] = {1};
591 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
592 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
593 // Phase 3, inputs and outputs
594 model->identifyInputsAndOutputs(
595 {op1},
596 {op2});
597 // Phase 4: set relaxed execution
598 model->relaxComputationFloat32toFloat16(true);
599 assert(model->isValid());
600 }
601
is_ignored_relaxed_dim4_axis1(int i)602 inline bool is_ignored_relaxed_dim4_axis1(int i) {
603 static std::set<int> ignore = {};
604 return ignore.find(i) != ignore.end();
605 }
606
CreateModel_relaxed_dim4_axis1_neg(Model * model)607 void CreateModel_relaxed_dim4_axis1_neg(Model *model) {
608 OperandType type1(Type::INT32, {});
609 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
610 // Phase 1, operands
611 auto op1 = model->addOperand(&type3);
612 auto param = model->addOperand(&type1);
613 auto axis = model->addOperand(&type1);
614 auto op2 = model->addOperand(&type3);
615 // Phase 2, operations
616 static int32_t param_init[] = {3};
617 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
618 static int32_t axis_init[] = {-3};
619 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
620 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
621 // Phase 3, inputs and outputs
622 model->identifyInputsAndOutputs(
623 {op1},
624 {op2});
625 // Phase 4: set relaxed execution
626 model->relaxComputationFloat32toFloat16(true);
627 assert(model->isValid());
628 }
629
is_ignored_relaxed_dim4_axis1_neg(int i)630 inline bool is_ignored_relaxed_dim4_axis1_neg(int i) {
631 static std::set<int> ignore = {};
632 return ignore.find(i) != ignore.end();
633 }
634
CreateModel_relaxed_dim4_axis2(Model * model)635 void CreateModel_relaxed_dim4_axis2(Model *model) {
636 OperandType type1(Type::INT32, {});
637 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
638 // Phase 1, operands
639 auto op1 = model->addOperand(&type4);
640 auto param = model->addOperand(&type1);
641 auto axis = model->addOperand(&type1);
642 auto op2 = model->addOperand(&type4);
643 // Phase 2, operations
644 static int32_t param_init[] = {3};
645 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
646 static int32_t axis_init[] = {2};
647 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
648 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
649 // Phase 3, inputs and outputs
650 model->identifyInputsAndOutputs(
651 {op1},
652 {op2});
653 // Phase 4: set relaxed execution
654 model->relaxComputationFloat32toFloat16(true);
655 assert(model->isValid());
656 }
657
is_ignored_relaxed_dim4_axis2(int i)658 inline bool is_ignored_relaxed_dim4_axis2(int i) {
659 static std::set<int> ignore = {};
660 return ignore.find(i) != ignore.end();
661 }
662
CreateModel_relaxed_dim4_axis2_neg(Model * model)663 void CreateModel_relaxed_dim4_axis2_neg(Model *model) {
664 OperandType type1(Type::INT32, {});
665 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
666 // Phase 1, operands
667 auto op1 = model->addOperand(&type4);
668 auto param = model->addOperand(&type1);
669 auto axis = model->addOperand(&type1);
670 auto op2 = model->addOperand(&type4);
671 // Phase 2, operations
672 static int32_t param_init[] = {3};
673 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
674 static int32_t axis_init[] = {-2};
675 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
676 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
677 // Phase 3, inputs and outputs
678 model->identifyInputsAndOutputs(
679 {op1},
680 {op2});
681 // Phase 4: set relaxed execution
682 model->relaxComputationFloat32toFloat16(true);
683 assert(model->isValid());
684 }
685
is_ignored_relaxed_dim4_axis2_neg(int i)686 inline bool is_ignored_relaxed_dim4_axis2_neg(int i) {
687 static std::set<int> ignore = {};
688 return ignore.find(i) != ignore.end();
689 }
690
CreateModel_relaxed_dim4_axis3(Model * model)691 void CreateModel_relaxed_dim4_axis3(Model *model) {
692 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
693 OperandType type1(Type::INT32, {});
694 // Phase 1, operands
695 auto op1 = model->addOperand(&type0);
696 auto param = model->addOperand(&type1);
697 auto axis = model->addOperand(&type1);
698 auto op2 = model->addOperand(&type0);
699 // Phase 2, operations
700 static int32_t param_init[] = {3};
701 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
702 static int32_t axis_init[] = {3};
703 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
704 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
705 // Phase 3, inputs and outputs
706 model->identifyInputsAndOutputs(
707 {op1},
708 {op2});
709 // Phase 4: set relaxed execution
710 model->relaxComputationFloat32toFloat16(true);
711 assert(model->isValid());
712 }
713
is_ignored_relaxed_dim4_axis3(int i)714 inline bool is_ignored_relaxed_dim4_axis3(int i) {
715 static std::set<int> ignore = {};
716 return ignore.find(i) != ignore.end();
717 }
718
CreateModel_relaxed_dim4_axis3_neg(Model * model)719 void CreateModel_relaxed_dim4_axis3_neg(Model *model) {
720 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
721 OperandType type1(Type::INT32, {});
722 // Phase 1, operands
723 auto op1 = model->addOperand(&type0);
724 auto param = model->addOperand(&type1);
725 auto axis = model->addOperand(&type1);
726 auto op2 = model->addOperand(&type0);
727 // Phase 2, operations
728 static int32_t param_init[] = {3};
729 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
730 static int32_t axis_init[] = {-1};
731 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
732 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
733 // Phase 3, inputs and outputs
734 model->identifyInputsAndOutputs(
735 {op1},
736 {op2});
737 // Phase 4: set relaxed execution
738 model->relaxComputationFloat32toFloat16(true);
739 assert(model->isValid());
740 }
741
is_ignored_relaxed_dim4_axis3_neg(int i)742 inline bool is_ignored_relaxed_dim4_axis3_neg(int i) {
743 static std::set<int> ignore = {};
744 return ignore.find(i) != ignore.end();
745 }
746
CreateModel_relaxed_dim3_axis0(Model * model)747 void CreateModel_relaxed_dim3_axis0(Model *model) {
748 OperandType type1(Type::INT32, {});
749 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
750 // Phase 1, operands
751 auto op1 = model->addOperand(&type5);
752 auto param = model->addOperand(&type1);
753 auto axis = model->addOperand(&type1);
754 auto op2 = model->addOperand(&type5);
755 // Phase 2, operations
756 static int32_t param_init[] = {3};
757 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
758 static int32_t axis_init[] = {0};
759 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
760 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
761 // Phase 3, inputs and outputs
762 model->identifyInputsAndOutputs(
763 {op1},
764 {op2});
765 // Phase 4: set relaxed execution
766 model->relaxComputationFloat32toFloat16(true);
767 assert(model->isValid());
768 }
769
is_ignored_relaxed_dim3_axis0(int i)770 inline bool is_ignored_relaxed_dim3_axis0(int i) {
771 static std::set<int> ignore = {};
772 return ignore.find(i) != ignore.end();
773 }
774
CreateModel_relaxed_dim3_axis0_neg(Model * model)775 void CreateModel_relaxed_dim3_axis0_neg(Model *model) {
776 OperandType type1(Type::INT32, {});
777 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
778 // Phase 1, operands
779 auto op1 = model->addOperand(&type5);
780 auto param = model->addOperand(&type1);
781 auto axis = model->addOperand(&type1);
782 auto op2 = model->addOperand(&type5);
783 // Phase 2, operations
784 static int32_t param_init[] = {3};
785 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
786 static int32_t axis_init[] = {-3};
787 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
788 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
789 // Phase 3, inputs and outputs
790 model->identifyInputsAndOutputs(
791 {op1},
792 {op2});
793 // Phase 4: set relaxed execution
794 model->relaxComputationFloat32toFloat16(true);
795 assert(model->isValid());
796 }
797
is_ignored_relaxed_dim3_axis0_neg(int i)798 inline bool is_ignored_relaxed_dim3_axis0_neg(int i) {
799 static std::set<int> ignore = {};
800 return ignore.find(i) != ignore.end();
801 }
802
CreateModel_relaxed_dim3_axis1(Model * model)803 void CreateModel_relaxed_dim3_axis1(Model *model) {
804 OperandType type1(Type::INT32, {});
805 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
806 // Phase 1, operands
807 auto op1 = model->addOperand(&type6);
808 auto param = model->addOperand(&type1);
809 auto axis = model->addOperand(&type1);
810 auto op2 = model->addOperand(&type6);
811 // Phase 2, operations
812 static int32_t param_init[] = {3};
813 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
814 static int32_t axis_init[] = {1};
815 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
816 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
817 // Phase 3, inputs and outputs
818 model->identifyInputsAndOutputs(
819 {op1},
820 {op2});
821 // Phase 4: set relaxed execution
822 model->relaxComputationFloat32toFloat16(true);
823 assert(model->isValid());
824 }
825
is_ignored_relaxed_dim3_axis1(int i)826 inline bool is_ignored_relaxed_dim3_axis1(int i) {
827 static std::set<int> ignore = {};
828 return ignore.find(i) != ignore.end();
829 }
830
CreateModel_relaxed_dim3_axis1_neg(Model * model)831 void CreateModel_relaxed_dim3_axis1_neg(Model *model) {
832 OperandType type1(Type::INT32, {});
833 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
834 // Phase 1, operands
835 auto op1 = model->addOperand(&type6);
836 auto param = model->addOperand(&type1);
837 auto axis = model->addOperand(&type1);
838 auto op2 = model->addOperand(&type6);
839 // Phase 2, operations
840 static int32_t param_init[] = {3};
841 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
842 static int32_t axis_init[] = {-2};
843 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
844 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
845 // Phase 3, inputs and outputs
846 model->identifyInputsAndOutputs(
847 {op1},
848 {op2});
849 // Phase 4: set relaxed execution
850 model->relaxComputationFloat32toFloat16(true);
851 assert(model->isValid());
852 }
853
is_ignored_relaxed_dim3_axis1_neg(int i)854 inline bool is_ignored_relaxed_dim3_axis1_neg(int i) {
855 static std::set<int> ignore = {};
856 return ignore.find(i) != ignore.end();
857 }
858
CreateModel_relaxed_dim3_axis2(Model * model)859 void CreateModel_relaxed_dim3_axis2(Model *model) {
860 OperandType type1(Type::INT32, {});
861 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
862 // Phase 1, operands
863 auto op1 = model->addOperand(&type7);
864 auto param = model->addOperand(&type1);
865 auto axis = model->addOperand(&type1);
866 auto op2 = model->addOperand(&type7);
867 // Phase 2, operations
868 static int32_t param_init[] = {3};
869 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
870 static int32_t axis_init[] = {2};
871 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
872 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
873 // Phase 3, inputs and outputs
874 model->identifyInputsAndOutputs(
875 {op1},
876 {op2});
877 // Phase 4: set relaxed execution
878 model->relaxComputationFloat32toFloat16(true);
879 assert(model->isValid());
880 }
881
is_ignored_relaxed_dim3_axis2(int i)882 inline bool is_ignored_relaxed_dim3_axis2(int i) {
883 static std::set<int> ignore = {};
884 return ignore.find(i) != ignore.end();
885 }
886
CreateModel_relaxed_dim3_axis2_neg(Model * model)887 void CreateModel_relaxed_dim3_axis2_neg(Model *model) {
888 OperandType type1(Type::INT32, {});
889 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
890 // Phase 1, operands
891 auto op1 = model->addOperand(&type7);
892 auto param = model->addOperand(&type1);
893 auto axis = model->addOperand(&type1);
894 auto op2 = model->addOperand(&type7);
895 // Phase 2, operations
896 static int32_t param_init[] = {3};
897 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
898 static int32_t axis_init[] = {-1};
899 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
900 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
901 // Phase 3, inputs and outputs
902 model->identifyInputsAndOutputs(
903 {op1},
904 {op2});
905 // Phase 4: set relaxed execution
906 model->relaxComputationFloat32toFloat16(true);
907 assert(model->isValid());
908 }
909
is_ignored_relaxed_dim3_axis2_neg(int i)910 inline bool is_ignored_relaxed_dim3_axis2_neg(int i) {
911 static std::set<int> ignore = {};
912 return ignore.find(i) != ignore.end();
913 }
914
CreateModel_relaxed_dim2_axis0(Model * model)915 void CreateModel_relaxed_dim2_axis0(Model *model) {
916 OperandType type1(Type::INT32, {});
917 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
918 // Phase 1, operands
919 auto op1 = model->addOperand(&type8);
920 auto param = model->addOperand(&type1);
921 auto axis = model->addOperand(&type1);
922 auto op2 = model->addOperand(&type8);
923 // Phase 2, operations
924 static int32_t param_init[] = {3};
925 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
926 static int32_t axis_init[] = {0};
927 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
928 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
929 // Phase 3, inputs and outputs
930 model->identifyInputsAndOutputs(
931 {op1},
932 {op2});
933 // Phase 4: set relaxed execution
934 model->relaxComputationFloat32toFloat16(true);
935 assert(model->isValid());
936 }
937
is_ignored_relaxed_dim2_axis0(int i)938 inline bool is_ignored_relaxed_dim2_axis0(int i) {
939 static std::set<int> ignore = {};
940 return ignore.find(i) != ignore.end();
941 }
942
CreateModel_relaxed_dim2_axis0_neg(Model * model)943 void CreateModel_relaxed_dim2_axis0_neg(Model *model) {
944 OperandType type1(Type::INT32, {});
945 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
946 // Phase 1, operands
947 auto op1 = model->addOperand(&type8);
948 auto param = model->addOperand(&type1);
949 auto axis = model->addOperand(&type1);
950 auto op2 = model->addOperand(&type8);
951 // Phase 2, operations
952 static int32_t param_init[] = {3};
953 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
954 static int32_t axis_init[] = {-2};
955 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
956 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
957 // Phase 3, inputs and outputs
958 model->identifyInputsAndOutputs(
959 {op1},
960 {op2});
961 // Phase 4: set relaxed execution
962 model->relaxComputationFloat32toFloat16(true);
963 assert(model->isValid());
964 }
965
is_ignored_relaxed_dim2_axis0_neg(int i)966 inline bool is_ignored_relaxed_dim2_axis0_neg(int i) {
967 static std::set<int> ignore = {};
968 return ignore.find(i) != ignore.end();
969 }
970
CreateModel_relaxed_dim2_axis1(Model * model)971 void CreateModel_relaxed_dim2_axis1(Model *model) {
972 OperandType type1(Type::INT32, {});
973 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
974 // Phase 1, operands
975 auto op1 = model->addOperand(&type9);
976 auto param = model->addOperand(&type1);
977 auto axis = model->addOperand(&type1);
978 auto op2 = model->addOperand(&type9);
979 // Phase 2, operations
980 static int32_t param_init[] = {3};
981 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
982 static int32_t axis_init[] = {1};
983 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
984 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
985 // Phase 3, inputs and outputs
986 model->identifyInputsAndOutputs(
987 {op1},
988 {op2});
989 // Phase 4: set relaxed execution
990 model->relaxComputationFloat32toFloat16(true);
991 assert(model->isValid());
992 }
993
is_ignored_relaxed_dim2_axis1(int i)994 inline bool is_ignored_relaxed_dim2_axis1(int i) {
995 static std::set<int> ignore = {};
996 return ignore.find(i) != ignore.end();
997 }
998
CreateModel_relaxed_dim2_axis1_neg(Model * model)999 void CreateModel_relaxed_dim2_axis1_neg(Model *model) {
1000 OperandType type1(Type::INT32, {});
1001 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
1002 // Phase 1, operands
1003 auto op1 = model->addOperand(&type9);
1004 auto param = model->addOperand(&type1);
1005 auto axis = model->addOperand(&type1);
1006 auto op2 = model->addOperand(&type9);
1007 // Phase 2, operations
1008 static int32_t param_init[] = {3};
1009 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1010 static int32_t axis_init[] = {-1};
1011 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1012 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1013 // Phase 3, inputs and outputs
1014 model->identifyInputsAndOutputs(
1015 {op1},
1016 {op2});
1017 // Phase 4: set relaxed execution
1018 model->relaxComputationFloat32toFloat16(true);
1019 assert(model->isValid());
1020 }
1021
is_ignored_relaxed_dim2_axis1_neg(int i)1022 inline bool is_ignored_relaxed_dim2_axis1_neg(int i) {
1023 static std::set<int> ignore = {};
1024 return ignore.find(i) != ignore.end();
1025 }
1026
CreateModel_relaxed_dim1_axis0(Model * model)1027 void CreateModel_relaxed_dim1_axis0(Model *model) {
1028 OperandType type1(Type::INT32, {});
1029 OperandType type10(Type::TENSOR_FLOAT32, {12});
1030 // Phase 1, operands
1031 auto op1 = model->addOperand(&type10);
1032 auto param = model->addOperand(&type1);
1033 auto axis = model->addOperand(&type1);
1034 auto op2 = model->addOperand(&type10);
1035 // Phase 2, operations
1036 static int32_t param_init[] = {3};
1037 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1038 static int32_t axis_init[] = {0};
1039 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1040 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1041 // Phase 3, inputs and outputs
1042 model->identifyInputsAndOutputs(
1043 {op1},
1044 {op2});
1045 // Phase 4: set relaxed execution
1046 model->relaxComputationFloat32toFloat16(true);
1047 assert(model->isValid());
1048 }
1049
is_ignored_relaxed_dim1_axis0(int i)1050 inline bool is_ignored_relaxed_dim1_axis0(int i) {
1051 static std::set<int> ignore = {};
1052 return ignore.find(i) != ignore.end();
1053 }
1054
CreateModel_relaxed_dim1_axis0_neg(Model * model)1055 void CreateModel_relaxed_dim1_axis0_neg(Model *model) {
1056 OperandType type1(Type::INT32, {});
1057 OperandType type10(Type::TENSOR_FLOAT32, {12});
1058 // Phase 1, operands
1059 auto op1 = model->addOperand(&type10);
1060 auto param = model->addOperand(&type1);
1061 auto axis = model->addOperand(&type1);
1062 auto op2 = model->addOperand(&type10);
1063 // Phase 2, operations
1064 static int32_t param_init[] = {3};
1065 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1066 static int32_t axis_init[] = {-1};
1067 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1068 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1069 // Phase 3, inputs and outputs
1070 model->identifyInputsAndOutputs(
1071 {op1},
1072 {op2});
1073 // Phase 4: set relaxed execution
1074 model->relaxComputationFloat32toFloat16(true);
1075 assert(model->isValid());
1076 }
1077
is_ignored_relaxed_dim1_axis0_neg(int i)1078 inline bool is_ignored_relaxed_dim1_axis0_neg(int i) {
1079 static std::set<int> ignore = {};
1080 return ignore.find(i) != ignore.end();
1081 }
1082
CreateModel_quant8_dim4_axis0(Model * model)1083 void CreateModel_quant8_dim4_axis0(Model *model) {
1084 OperandType type1(Type::INT32, {});
1085 OperandType type12(Type::TENSOR_QUANT8_ASYMM, {12, 2, 2, 3}, 0.25f, 128);
1086 // Phase 1, operands
1087 auto op1 = model->addOperand(&type12);
1088 auto param = model->addOperand(&type1);
1089 auto axis = model->addOperand(&type1);
1090 auto op2 = model->addOperand(&type12);
1091 // Phase 2, operations
1092 static int32_t param_init[] = {3};
1093 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1094 static int32_t axis_init[] = {0};
1095 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1096 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1097 // Phase 3, inputs and outputs
1098 model->identifyInputsAndOutputs(
1099 {op1},
1100 {op2});
1101 assert(model->isValid());
1102 }
1103
is_ignored_quant8_dim4_axis0(int i)1104 inline bool is_ignored_quant8_dim4_axis0(int i) {
1105 static std::set<int> ignore = {};
1106 return ignore.find(i) != ignore.end();
1107 }
1108
CreateModel_quant8_dim4_axis0_neg(Model * model)1109 void CreateModel_quant8_dim4_axis0_neg(Model *model) {
1110 OperandType type1(Type::INT32, {});
1111 OperandType type12(Type::TENSOR_QUANT8_ASYMM, {12, 2, 2, 3}, 0.25f, 128);
1112 // Phase 1, operands
1113 auto op1 = model->addOperand(&type12);
1114 auto param = model->addOperand(&type1);
1115 auto axis = model->addOperand(&type1);
1116 auto op2 = model->addOperand(&type12);
1117 // Phase 2, operations
1118 static int32_t param_init[] = {3};
1119 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1120 static int32_t axis_init[] = {-4};
1121 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1122 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1123 // Phase 3, inputs and outputs
1124 model->identifyInputsAndOutputs(
1125 {op1},
1126 {op2});
1127 assert(model->isValid());
1128 }
1129
is_ignored_quant8_dim4_axis0_neg(int i)1130 inline bool is_ignored_quant8_dim4_axis0_neg(int i) {
1131 static std::set<int> ignore = {};
1132 return ignore.find(i) != ignore.end();
1133 }
1134
CreateModel_quant8_dim4_axis1(Model * model)1135 void CreateModel_quant8_dim4_axis1(Model *model) {
1136 OperandType type1(Type::INT32, {});
1137 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {2, 12, 2, 3}, 0.25f, 128);
1138 // Phase 1, operands
1139 auto op1 = model->addOperand(&type13);
1140 auto param = model->addOperand(&type1);
1141 auto axis = model->addOperand(&type1);
1142 auto op2 = model->addOperand(&type13);
1143 // Phase 2, operations
1144 static int32_t param_init[] = {3};
1145 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1146 static int32_t axis_init[] = {1};
1147 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1148 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1149 // Phase 3, inputs and outputs
1150 model->identifyInputsAndOutputs(
1151 {op1},
1152 {op2});
1153 assert(model->isValid());
1154 }
1155
is_ignored_quant8_dim4_axis1(int i)1156 inline bool is_ignored_quant8_dim4_axis1(int i) {
1157 static std::set<int> ignore = {};
1158 return ignore.find(i) != ignore.end();
1159 }
1160
CreateModel_quant8_dim4_axis1_neg(Model * model)1161 void CreateModel_quant8_dim4_axis1_neg(Model *model) {
1162 OperandType type1(Type::INT32, {});
1163 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {2, 12, 2, 3}, 0.25f, 128);
1164 // Phase 1, operands
1165 auto op1 = model->addOperand(&type13);
1166 auto param = model->addOperand(&type1);
1167 auto axis = model->addOperand(&type1);
1168 auto op2 = model->addOperand(&type13);
1169 // Phase 2, operations
1170 static int32_t param_init[] = {3};
1171 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1172 static int32_t axis_init[] = {-3};
1173 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1174 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1175 // Phase 3, inputs and outputs
1176 model->identifyInputsAndOutputs(
1177 {op1},
1178 {op2});
1179 assert(model->isValid());
1180 }
1181
is_ignored_quant8_dim4_axis1_neg(int i)1182 inline bool is_ignored_quant8_dim4_axis1_neg(int i) {
1183 static std::set<int> ignore = {};
1184 return ignore.find(i) != ignore.end();
1185 }
1186
CreateModel_quant8_dim4_axis2(Model * model)1187 void CreateModel_quant8_dim4_axis2(Model *model) {
1188 OperandType type1(Type::INT32, {});
1189 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {2, 2, 12, 3}, 0.25f, 128);
1190 // Phase 1, operands
1191 auto op1 = model->addOperand(&type14);
1192 auto param = model->addOperand(&type1);
1193 auto axis = model->addOperand(&type1);
1194 auto op2 = model->addOperand(&type14);
1195 // Phase 2, operations
1196 static int32_t param_init[] = {3};
1197 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1198 static int32_t axis_init[] = {2};
1199 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1200 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1201 // Phase 3, inputs and outputs
1202 model->identifyInputsAndOutputs(
1203 {op1},
1204 {op2});
1205 assert(model->isValid());
1206 }
1207
is_ignored_quant8_dim4_axis2(int i)1208 inline bool is_ignored_quant8_dim4_axis2(int i) {
1209 static std::set<int> ignore = {};
1210 return ignore.find(i) != ignore.end();
1211 }
1212
CreateModel_quant8_dim4_axis2_neg(Model * model)1213 void CreateModel_quant8_dim4_axis2_neg(Model *model) {
1214 OperandType type1(Type::INT32, {});
1215 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {2, 2, 12, 3}, 0.25f, 128);
1216 // Phase 1, operands
1217 auto op1 = model->addOperand(&type14);
1218 auto param = model->addOperand(&type1);
1219 auto axis = model->addOperand(&type1);
1220 auto op2 = model->addOperand(&type14);
1221 // Phase 2, operations
1222 static int32_t param_init[] = {3};
1223 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1224 static int32_t axis_init[] = {-2};
1225 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1226 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1227 // Phase 3, inputs and outputs
1228 model->identifyInputsAndOutputs(
1229 {op1},
1230 {op2});
1231 assert(model->isValid());
1232 }
1233
is_ignored_quant8_dim4_axis2_neg(int i)1234 inline bool is_ignored_quant8_dim4_axis2_neg(int i) {
1235 static std::set<int> ignore = {};
1236 return ignore.find(i) != ignore.end();
1237 }
1238
CreateModel_quant8_dim4_axis3(Model * model)1239 void CreateModel_quant8_dim4_axis3(Model *model) {
1240 OperandType type1(Type::INT32, {});
1241 OperandType type11(Type::TENSOR_QUANT8_ASYMM, {2, 2, 3, 12}, 0.25f, 128);
1242 // Phase 1, operands
1243 auto op1 = model->addOperand(&type11);
1244 auto param = model->addOperand(&type1);
1245 auto axis = model->addOperand(&type1);
1246 auto op2 = model->addOperand(&type11);
1247 // Phase 2, operations
1248 static int32_t param_init[] = {3};
1249 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1250 static int32_t axis_init[] = {3};
1251 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1252 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1253 // Phase 3, inputs and outputs
1254 model->identifyInputsAndOutputs(
1255 {op1},
1256 {op2});
1257 assert(model->isValid());
1258 }
1259
is_ignored_quant8_dim4_axis3(int i)1260 inline bool is_ignored_quant8_dim4_axis3(int i) {
1261 static std::set<int> ignore = {};
1262 return ignore.find(i) != ignore.end();
1263 }
1264
CreateModel_quant8_dim4_axis3_neg(Model * model)1265 void CreateModel_quant8_dim4_axis3_neg(Model *model) {
1266 OperandType type1(Type::INT32, {});
1267 OperandType type11(Type::TENSOR_QUANT8_ASYMM, {2, 2, 3, 12}, 0.25f, 128);
1268 // Phase 1, operands
1269 auto op1 = model->addOperand(&type11);
1270 auto param = model->addOperand(&type1);
1271 auto axis = model->addOperand(&type1);
1272 auto op2 = model->addOperand(&type11);
1273 // Phase 2, operations
1274 static int32_t param_init[] = {3};
1275 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1276 static int32_t axis_init[] = {-1};
1277 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1278 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1279 // Phase 3, inputs and outputs
1280 model->identifyInputsAndOutputs(
1281 {op1},
1282 {op2});
1283 assert(model->isValid());
1284 }
1285
is_ignored_quant8_dim4_axis3_neg(int i)1286 inline bool is_ignored_quant8_dim4_axis3_neg(int i) {
1287 static std::set<int> ignore = {};
1288 return ignore.find(i) != ignore.end();
1289 }
1290
CreateModel_quant8_dim3_axis0(Model * model)1291 void CreateModel_quant8_dim3_axis0(Model *model) {
1292 OperandType type1(Type::INT32, {});
1293 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {12, 2, 3}, 0.25f, 128);
1294 // Phase 1, operands
1295 auto op1 = model->addOperand(&type15);
1296 auto param = model->addOperand(&type1);
1297 auto axis = model->addOperand(&type1);
1298 auto op2 = model->addOperand(&type15);
1299 // Phase 2, operations
1300 static int32_t param_init[] = {3};
1301 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1302 static int32_t axis_init[] = {0};
1303 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1304 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1305 // Phase 3, inputs and outputs
1306 model->identifyInputsAndOutputs(
1307 {op1},
1308 {op2});
1309 assert(model->isValid());
1310 }
1311
is_ignored_quant8_dim3_axis0(int i)1312 inline bool is_ignored_quant8_dim3_axis0(int i) {
1313 static std::set<int> ignore = {};
1314 return ignore.find(i) != ignore.end();
1315 }
1316
CreateModel_quant8_dim3_axis0_neg(Model * model)1317 void CreateModel_quant8_dim3_axis0_neg(Model *model) {
1318 OperandType type1(Type::INT32, {});
1319 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {12, 2, 3}, 0.25f, 128);
1320 // Phase 1, operands
1321 auto op1 = model->addOperand(&type15);
1322 auto param = model->addOperand(&type1);
1323 auto axis = model->addOperand(&type1);
1324 auto op2 = model->addOperand(&type15);
1325 // Phase 2, operations
1326 static int32_t param_init[] = {3};
1327 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1328 static int32_t axis_init[] = {-3};
1329 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1330 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1331 // Phase 3, inputs and outputs
1332 model->identifyInputsAndOutputs(
1333 {op1},
1334 {op2});
1335 assert(model->isValid());
1336 }
1337
is_ignored_quant8_dim3_axis0_neg(int i)1338 inline bool is_ignored_quant8_dim3_axis0_neg(int i) {
1339 static std::set<int> ignore = {};
1340 return ignore.find(i) != ignore.end();
1341 }
1342
CreateModel_quant8_dim3_axis1(Model * model)1343 void CreateModel_quant8_dim3_axis1(Model *model) {
1344 OperandType type1(Type::INT32, {});
1345 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {2, 12, 3}, 0.25f, 128);
1346 // Phase 1, operands
1347 auto op1 = model->addOperand(&type16);
1348 auto param = model->addOperand(&type1);
1349 auto axis = model->addOperand(&type1);
1350 auto op2 = model->addOperand(&type16);
1351 // Phase 2, operations
1352 static int32_t param_init[] = {3};
1353 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1354 static int32_t axis_init[] = {1};
1355 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1356 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1357 // Phase 3, inputs and outputs
1358 model->identifyInputsAndOutputs(
1359 {op1},
1360 {op2});
1361 assert(model->isValid());
1362 }
1363
is_ignored_quant8_dim3_axis1(int i)1364 inline bool is_ignored_quant8_dim3_axis1(int i) {
1365 static std::set<int> ignore = {};
1366 return ignore.find(i) != ignore.end();
1367 }
1368
CreateModel_quant8_dim3_axis1_neg(Model * model)1369 void CreateModel_quant8_dim3_axis1_neg(Model *model) {
1370 OperandType type1(Type::INT32, {});
1371 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {2, 12, 3}, 0.25f, 128);
1372 // Phase 1, operands
1373 auto op1 = model->addOperand(&type16);
1374 auto param = model->addOperand(&type1);
1375 auto axis = model->addOperand(&type1);
1376 auto op2 = model->addOperand(&type16);
1377 // Phase 2, operations
1378 static int32_t param_init[] = {3};
1379 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1380 static int32_t axis_init[] = {-2};
1381 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1382 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1383 // Phase 3, inputs and outputs
1384 model->identifyInputsAndOutputs(
1385 {op1},
1386 {op2});
1387 assert(model->isValid());
1388 }
1389
is_ignored_quant8_dim3_axis1_neg(int i)1390 inline bool is_ignored_quant8_dim3_axis1_neg(int i) {
1391 static std::set<int> ignore = {};
1392 return ignore.find(i) != ignore.end();
1393 }
1394
CreateModel_quant8_dim3_axis2(Model * model)1395 void CreateModel_quant8_dim3_axis2(Model *model) {
1396 OperandType type1(Type::INT32, {});
1397 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {2, 3, 12}, 0.25f, 128);
1398 // Phase 1, operands
1399 auto op1 = model->addOperand(&type17);
1400 auto param = model->addOperand(&type1);
1401 auto axis = model->addOperand(&type1);
1402 auto op2 = model->addOperand(&type17);
1403 // Phase 2, operations
1404 static int32_t param_init[] = {3};
1405 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1406 static int32_t axis_init[] = {2};
1407 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1408 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1409 // Phase 3, inputs and outputs
1410 model->identifyInputsAndOutputs(
1411 {op1},
1412 {op2});
1413 assert(model->isValid());
1414 }
1415
is_ignored_quant8_dim3_axis2(int i)1416 inline bool is_ignored_quant8_dim3_axis2(int i) {
1417 static std::set<int> ignore = {};
1418 return ignore.find(i) != ignore.end();
1419 }
1420
CreateModel_quant8_dim3_axis2_neg(Model * model)1421 void CreateModel_quant8_dim3_axis2_neg(Model *model) {
1422 OperandType type1(Type::INT32, {});
1423 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {2, 3, 12}, 0.25f, 128);
1424 // Phase 1, operands
1425 auto op1 = model->addOperand(&type17);
1426 auto param = model->addOperand(&type1);
1427 auto axis = model->addOperand(&type1);
1428 auto op2 = model->addOperand(&type17);
1429 // Phase 2, operations
1430 static int32_t param_init[] = {3};
1431 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1432 static int32_t axis_init[] = {-1};
1433 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1434 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1435 // Phase 3, inputs and outputs
1436 model->identifyInputsAndOutputs(
1437 {op1},
1438 {op2});
1439 assert(model->isValid());
1440 }
1441
is_ignored_quant8_dim3_axis2_neg(int i)1442 inline bool is_ignored_quant8_dim3_axis2_neg(int i) {
1443 static std::set<int> ignore = {};
1444 return ignore.find(i) != ignore.end();
1445 }
1446
CreateModel_quant8_dim2_axis0(Model * model)1447 void CreateModel_quant8_dim2_axis0(Model *model) {
1448 OperandType type1(Type::INT32, {});
1449 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {12, 3}, 0.25f, 128);
1450 // Phase 1, operands
1451 auto op1 = model->addOperand(&type18);
1452 auto param = model->addOperand(&type1);
1453 auto axis = model->addOperand(&type1);
1454 auto op2 = model->addOperand(&type18);
1455 // Phase 2, operations
1456 static int32_t param_init[] = {3};
1457 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1458 static int32_t axis_init[] = {0};
1459 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1460 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1461 // Phase 3, inputs and outputs
1462 model->identifyInputsAndOutputs(
1463 {op1},
1464 {op2});
1465 assert(model->isValid());
1466 }
1467
is_ignored_quant8_dim2_axis0(int i)1468 inline bool is_ignored_quant8_dim2_axis0(int i) {
1469 static std::set<int> ignore = {};
1470 return ignore.find(i) != ignore.end();
1471 }
1472
CreateModel_quant8_dim2_axis0_neg(Model * model)1473 void CreateModel_quant8_dim2_axis0_neg(Model *model) {
1474 OperandType type1(Type::INT32, {});
1475 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {12, 3}, 0.25f, 128);
1476 // Phase 1, operands
1477 auto op1 = model->addOperand(&type18);
1478 auto param = model->addOperand(&type1);
1479 auto axis = model->addOperand(&type1);
1480 auto op2 = model->addOperand(&type18);
1481 // Phase 2, operations
1482 static int32_t param_init[] = {3};
1483 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1484 static int32_t axis_init[] = {-2};
1485 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1486 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1487 // Phase 3, inputs and outputs
1488 model->identifyInputsAndOutputs(
1489 {op1},
1490 {op2});
1491 assert(model->isValid());
1492 }
1493
is_ignored_quant8_dim2_axis0_neg(int i)1494 inline bool is_ignored_quant8_dim2_axis0_neg(int i) {
1495 static std::set<int> ignore = {};
1496 return ignore.find(i) != ignore.end();
1497 }
1498
CreateModel_quant8_dim2_axis1(Model * model)1499 void CreateModel_quant8_dim2_axis1(Model *model) {
1500 OperandType type1(Type::INT32, {});
1501 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {3, 12}, 0.25f, 128);
1502 // Phase 1, operands
1503 auto op1 = model->addOperand(&type19);
1504 auto param = model->addOperand(&type1);
1505 auto axis = model->addOperand(&type1);
1506 auto op2 = model->addOperand(&type19);
1507 // Phase 2, operations
1508 static int32_t param_init[] = {3};
1509 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1510 static int32_t axis_init[] = {1};
1511 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1512 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1513 // Phase 3, inputs and outputs
1514 model->identifyInputsAndOutputs(
1515 {op1},
1516 {op2});
1517 assert(model->isValid());
1518 }
1519
is_ignored_quant8_dim2_axis1(int i)1520 inline bool is_ignored_quant8_dim2_axis1(int i) {
1521 static std::set<int> ignore = {};
1522 return ignore.find(i) != ignore.end();
1523 }
1524
CreateModel_quant8_dim2_axis1_neg(Model * model)1525 void CreateModel_quant8_dim2_axis1_neg(Model *model) {
1526 OperandType type1(Type::INT32, {});
1527 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {3, 12}, 0.25f, 128);
1528 // Phase 1, operands
1529 auto op1 = model->addOperand(&type19);
1530 auto param = model->addOperand(&type1);
1531 auto axis = model->addOperand(&type1);
1532 auto op2 = model->addOperand(&type19);
1533 // Phase 2, operations
1534 static int32_t param_init[] = {3};
1535 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1536 static int32_t axis_init[] = {-1};
1537 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1538 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1539 // Phase 3, inputs and outputs
1540 model->identifyInputsAndOutputs(
1541 {op1},
1542 {op2});
1543 assert(model->isValid());
1544 }
1545
is_ignored_quant8_dim2_axis1_neg(int i)1546 inline bool is_ignored_quant8_dim2_axis1_neg(int i) {
1547 static std::set<int> ignore = {};
1548 return ignore.find(i) != ignore.end();
1549 }
1550
CreateModel_quant8_dim1_axis0(Model * model)1551 void CreateModel_quant8_dim1_axis0(Model *model) {
1552 OperandType type1(Type::INT32, {});
1553 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {12}, 0.25f, 128);
1554 // Phase 1, operands
1555 auto op1 = model->addOperand(&type20);
1556 auto param = model->addOperand(&type1);
1557 auto axis = model->addOperand(&type1);
1558 auto op2 = model->addOperand(&type20);
1559 // Phase 2, operations
1560 static int32_t param_init[] = {3};
1561 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1562 static int32_t axis_init[] = {0};
1563 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1564 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1565 // Phase 3, inputs and outputs
1566 model->identifyInputsAndOutputs(
1567 {op1},
1568 {op2});
1569 assert(model->isValid());
1570 }
1571
is_ignored_quant8_dim1_axis0(int i)1572 inline bool is_ignored_quant8_dim1_axis0(int i) {
1573 static std::set<int> ignore = {};
1574 return ignore.find(i) != ignore.end();
1575 }
1576
CreateModel_quant8_dim1_axis0_neg(Model * model)1577 void CreateModel_quant8_dim1_axis0_neg(Model *model) {
1578 OperandType type1(Type::INT32, {});
1579 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {12}, 0.25f, 128);
1580 // Phase 1, operands
1581 auto op1 = model->addOperand(&type20);
1582 auto param = model->addOperand(&type1);
1583 auto axis = model->addOperand(&type1);
1584 auto op2 = model->addOperand(&type20);
1585 // Phase 2, operations
1586 static int32_t param_init[] = {3};
1587 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1588 static int32_t axis_init[] = {-1};
1589 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1590 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1591 // Phase 3, inputs and outputs
1592 model->identifyInputsAndOutputs(
1593 {op1},
1594 {op2});
1595 assert(model->isValid());
1596 }
1597
is_ignored_quant8_dim1_axis0_neg(int i)1598 inline bool is_ignored_quant8_dim1_axis0_neg(int i) {
1599 static std::set<int> ignore = {};
1600 return ignore.find(i) != ignore.end();
1601 }
1602
CreateModel_float16_dim4_axis0(Model * model)1603 void CreateModel_float16_dim4_axis0(Model *model) {
1604 OperandType type1(Type::INT32, {});
1605 OperandType type22(Type::TENSOR_FLOAT16, {12, 2, 2, 3});
1606 // Phase 1, operands
1607 auto op1 = model->addOperand(&type22);
1608 auto param = model->addOperand(&type1);
1609 auto axis = model->addOperand(&type1);
1610 auto op2 = model->addOperand(&type22);
1611 // Phase 2, operations
1612 static int32_t param_init[] = {3};
1613 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1614 static int32_t axis_init[] = {0};
1615 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1616 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1617 // Phase 3, inputs and outputs
1618 model->identifyInputsAndOutputs(
1619 {op1},
1620 {op2});
1621 assert(model->isValid());
1622 }
1623
is_ignored_float16_dim4_axis0(int i)1624 inline bool is_ignored_float16_dim4_axis0(int i) {
1625 static std::set<int> ignore = {};
1626 return ignore.find(i) != ignore.end();
1627 }
1628
CreateModel_float16_dim4_axis0_neg(Model * model)1629 void CreateModel_float16_dim4_axis0_neg(Model *model) {
1630 OperandType type1(Type::INT32, {});
1631 OperandType type22(Type::TENSOR_FLOAT16, {12, 2, 2, 3});
1632 // Phase 1, operands
1633 auto op1 = model->addOperand(&type22);
1634 auto param = model->addOperand(&type1);
1635 auto axis = model->addOperand(&type1);
1636 auto op2 = model->addOperand(&type22);
1637 // Phase 2, operations
1638 static int32_t param_init[] = {3};
1639 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1640 static int32_t axis_init[] = {-4};
1641 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1642 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1643 // Phase 3, inputs and outputs
1644 model->identifyInputsAndOutputs(
1645 {op1},
1646 {op2});
1647 assert(model->isValid());
1648 }
1649
is_ignored_float16_dim4_axis0_neg(int i)1650 inline bool is_ignored_float16_dim4_axis0_neg(int i) {
1651 static std::set<int> ignore = {};
1652 return ignore.find(i) != ignore.end();
1653 }
1654
CreateModel_float16_dim4_axis1(Model * model)1655 void CreateModel_float16_dim4_axis1(Model *model) {
1656 OperandType type1(Type::INT32, {});
1657 OperandType type23(Type::TENSOR_FLOAT16, {2, 12, 2, 3});
1658 // Phase 1, operands
1659 auto op1 = model->addOperand(&type23);
1660 auto param = model->addOperand(&type1);
1661 auto axis = model->addOperand(&type1);
1662 auto op2 = model->addOperand(&type23);
1663 // Phase 2, operations
1664 static int32_t param_init[] = {3};
1665 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1666 static int32_t axis_init[] = {1};
1667 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1668 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1669 // Phase 3, inputs and outputs
1670 model->identifyInputsAndOutputs(
1671 {op1},
1672 {op2});
1673 assert(model->isValid());
1674 }
1675
is_ignored_float16_dim4_axis1(int i)1676 inline bool is_ignored_float16_dim4_axis1(int i) {
1677 static std::set<int> ignore = {};
1678 return ignore.find(i) != ignore.end();
1679 }
1680
CreateModel_float16_dim4_axis1_neg(Model * model)1681 void CreateModel_float16_dim4_axis1_neg(Model *model) {
1682 OperandType type1(Type::INT32, {});
1683 OperandType type23(Type::TENSOR_FLOAT16, {2, 12, 2, 3});
1684 // Phase 1, operands
1685 auto op1 = model->addOperand(&type23);
1686 auto param = model->addOperand(&type1);
1687 auto axis = model->addOperand(&type1);
1688 auto op2 = model->addOperand(&type23);
1689 // Phase 2, operations
1690 static int32_t param_init[] = {3};
1691 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1692 static int32_t axis_init[] = {-3};
1693 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1694 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1695 // Phase 3, inputs and outputs
1696 model->identifyInputsAndOutputs(
1697 {op1},
1698 {op2});
1699 assert(model->isValid());
1700 }
1701
is_ignored_float16_dim4_axis1_neg(int i)1702 inline bool is_ignored_float16_dim4_axis1_neg(int i) {
1703 static std::set<int> ignore = {};
1704 return ignore.find(i) != ignore.end();
1705 }
1706
CreateModel_float16_dim4_axis2(Model * model)1707 void CreateModel_float16_dim4_axis2(Model *model) {
1708 OperandType type1(Type::INT32, {});
1709 OperandType type24(Type::TENSOR_FLOAT16, {2, 2, 12, 3});
1710 // Phase 1, operands
1711 auto op1 = model->addOperand(&type24);
1712 auto param = model->addOperand(&type1);
1713 auto axis = model->addOperand(&type1);
1714 auto op2 = model->addOperand(&type24);
1715 // Phase 2, operations
1716 static int32_t param_init[] = {3};
1717 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1718 static int32_t axis_init[] = {2};
1719 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1720 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1721 // Phase 3, inputs and outputs
1722 model->identifyInputsAndOutputs(
1723 {op1},
1724 {op2});
1725 assert(model->isValid());
1726 }
1727
is_ignored_float16_dim4_axis2(int i)1728 inline bool is_ignored_float16_dim4_axis2(int i) {
1729 static std::set<int> ignore = {};
1730 return ignore.find(i) != ignore.end();
1731 }
1732
CreateModel_float16_dim4_axis2_neg(Model * model)1733 void CreateModel_float16_dim4_axis2_neg(Model *model) {
1734 OperandType type1(Type::INT32, {});
1735 OperandType type24(Type::TENSOR_FLOAT16, {2, 2, 12, 3});
1736 // Phase 1, operands
1737 auto op1 = model->addOperand(&type24);
1738 auto param = model->addOperand(&type1);
1739 auto axis = model->addOperand(&type1);
1740 auto op2 = model->addOperand(&type24);
1741 // Phase 2, operations
1742 static int32_t param_init[] = {3};
1743 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1744 static int32_t axis_init[] = {-2};
1745 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1746 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1747 // Phase 3, inputs and outputs
1748 model->identifyInputsAndOutputs(
1749 {op1},
1750 {op2});
1751 assert(model->isValid());
1752 }
1753
is_ignored_float16_dim4_axis2_neg(int i)1754 inline bool is_ignored_float16_dim4_axis2_neg(int i) {
1755 static std::set<int> ignore = {};
1756 return ignore.find(i) != ignore.end();
1757 }
1758
CreateModel_float16_dim4_axis3(Model * model)1759 void CreateModel_float16_dim4_axis3(Model *model) {
1760 OperandType type1(Type::INT32, {});
1761 OperandType type25(Type::TENSOR_FLOAT16, {2, 2, 3, 12});
1762 // Phase 1, operands
1763 auto op1 = model->addOperand(&type25);
1764 auto param = model->addOperand(&type1);
1765 auto axis = model->addOperand(&type1);
1766 auto op2 = model->addOperand(&type25);
1767 // Phase 2, operations
1768 static int32_t param_init[] = {3};
1769 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1770 static int32_t axis_init[] = {3};
1771 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1772 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1773 // Phase 3, inputs and outputs
1774 model->identifyInputsAndOutputs(
1775 {op1},
1776 {op2});
1777 assert(model->isValid());
1778 }
1779
is_ignored_float16_dim4_axis3(int i)1780 inline bool is_ignored_float16_dim4_axis3(int i) {
1781 static std::set<int> ignore = {};
1782 return ignore.find(i) != ignore.end();
1783 }
1784
CreateModel_float16_dim4_axis3_neg(Model * model)1785 void CreateModel_float16_dim4_axis3_neg(Model *model) {
1786 OperandType type1(Type::INT32, {});
1787 OperandType type25(Type::TENSOR_FLOAT16, {2, 2, 3, 12});
1788 // Phase 1, operands
1789 auto op1 = model->addOperand(&type25);
1790 auto param = model->addOperand(&type1);
1791 auto axis = model->addOperand(&type1);
1792 auto op2 = model->addOperand(&type25);
1793 // Phase 2, operations
1794 static int32_t param_init[] = {3};
1795 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1796 static int32_t axis_init[] = {-1};
1797 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1798 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1799 // Phase 3, inputs and outputs
1800 model->identifyInputsAndOutputs(
1801 {op1},
1802 {op2});
1803 assert(model->isValid());
1804 }
1805
is_ignored_float16_dim4_axis3_neg(int i)1806 inline bool is_ignored_float16_dim4_axis3_neg(int i) {
1807 static std::set<int> ignore = {};
1808 return ignore.find(i) != ignore.end();
1809 }
1810
CreateModel_float16_dim3_axis0(Model * model)1811 void CreateModel_float16_dim3_axis0(Model *model) {
1812 OperandType type1(Type::INT32, {});
1813 OperandType type26(Type::TENSOR_FLOAT16, {12, 2, 3});
1814 // Phase 1, operands
1815 auto op1 = model->addOperand(&type26);
1816 auto param = model->addOperand(&type1);
1817 auto axis = model->addOperand(&type1);
1818 auto op2 = model->addOperand(&type26);
1819 // Phase 2, operations
1820 static int32_t param_init[] = {3};
1821 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1822 static int32_t axis_init[] = {0};
1823 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1824 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1825 // Phase 3, inputs and outputs
1826 model->identifyInputsAndOutputs(
1827 {op1},
1828 {op2});
1829 assert(model->isValid());
1830 }
1831
is_ignored_float16_dim3_axis0(int i)1832 inline bool is_ignored_float16_dim3_axis0(int i) {
1833 static std::set<int> ignore = {};
1834 return ignore.find(i) != ignore.end();
1835 }
1836
CreateModel_float16_dim3_axis0_neg(Model * model)1837 void CreateModel_float16_dim3_axis0_neg(Model *model) {
1838 OperandType type1(Type::INT32, {});
1839 OperandType type26(Type::TENSOR_FLOAT16, {12, 2, 3});
1840 // Phase 1, operands
1841 auto op1 = model->addOperand(&type26);
1842 auto param = model->addOperand(&type1);
1843 auto axis = model->addOperand(&type1);
1844 auto op2 = model->addOperand(&type26);
1845 // Phase 2, operations
1846 static int32_t param_init[] = {3};
1847 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1848 static int32_t axis_init[] = {-3};
1849 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1850 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1851 // Phase 3, inputs and outputs
1852 model->identifyInputsAndOutputs(
1853 {op1},
1854 {op2});
1855 assert(model->isValid());
1856 }
1857
is_ignored_float16_dim3_axis0_neg(int i)1858 inline bool is_ignored_float16_dim3_axis0_neg(int i) {
1859 static std::set<int> ignore = {};
1860 return ignore.find(i) != ignore.end();
1861 }
1862
CreateModel_float16_dim3_axis1(Model * model)1863 void CreateModel_float16_dim3_axis1(Model *model) {
1864 OperandType type1(Type::INT32, {});
1865 OperandType type27(Type::TENSOR_FLOAT16, {2, 12, 3});
1866 // Phase 1, operands
1867 auto op1 = model->addOperand(&type27);
1868 auto param = model->addOperand(&type1);
1869 auto axis = model->addOperand(&type1);
1870 auto op2 = model->addOperand(&type27);
1871 // Phase 2, operations
1872 static int32_t param_init[] = {3};
1873 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1874 static int32_t axis_init[] = {1};
1875 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1876 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1877 // Phase 3, inputs and outputs
1878 model->identifyInputsAndOutputs(
1879 {op1},
1880 {op2});
1881 assert(model->isValid());
1882 }
1883
is_ignored_float16_dim3_axis1(int i)1884 inline bool is_ignored_float16_dim3_axis1(int i) {
1885 static std::set<int> ignore = {};
1886 return ignore.find(i) != ignore.end();
1887 }
1888
CreateModel_float16_dim3_axis1_neg(Model * model)1889 void CreateModel_float16_dim3_axis1_neg(Model *model) {
1890 OperandType type1(Type::INT32, {});
1891 OperandType type27(Type::TENSOR_FLOAT16, {2, 12, 3});
1892 // Phase 1, operands
1893 auto op1 = model->addOperand(&type27);
1894 auto param = model->addOperand(&type1);
1895 auto axis = model->addOperand(&type1);
1896 auto op2 = model->addOperand(&type27);
1897 // Phase 2, operations
1898 static int32_t param_init[] = {3};
1899 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1900 static int32_t axis_init[] = {-2};
1901 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1902 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1903 // Phase 3, inputs and outputs
1904 model->identifyInputsAndOutputs(
1905 {op1},
1906 {op2});
1907 assert(model->isValid());
1908 }
1909
is_ignored_float16_dim3_axis1_neg(int i)1910 inline bool is_ignored_float16_dim3_axis1_neg(int i) {
1911 static std::set<int> ignore = {};
1912 return ignore.find(i) != ignore.end();
1913 }
1914
CreateModel_float16_dim3_axis2(Model * model)1915 void CreateModel_float16_dim3_axis2(Model *model) {
1916 OperandType type1(Type::INT32, {});
1917 OperandType type28(Type::TENSOR_FLOAT16, {2, 3, 12});
1918 // Phase 1, operands
1919 auto op1 = model->addOperand(&type28);
1920 auto param = model->addOperand(&type1);
1921 auto axis = model->addOperand(&type1);
1922 auto op2 = model->addOperand(&type28);
1923 // Phase 2, operations
1924 static int32_t param_init[] = {3};
1925 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1926 static int32_t axis_init[] = {2};
1927 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1928 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1929 // Phase 3, inputs and outputs
1930 model->identifyInputsAndOutputs(
1931 {op1},
1932 {op2});
1933 assert(model->isValid());
1934 }
1935
is_ignored_float16_dim3_axis2(int i)1936 inline bool is_ignored_float16_dim3_axis2(int i) {
1937 static std::set<int> ignore = {};
1938 return ignore.find(i) != ignore.end();
1939 }
1940
CreateModel_float16_dim3_axis2_neg(Model * model)1941 void CreateModel_float16_dim3_axis2_neg(Model *model) {
1942 OperandType type1(Type::INT32, {});
1943 OperandType type28(Type::TENSOR_FLOAT16, {2, 3, 12});
1944 // Phase 1, operands
1945 auto op1 = model->addOperand(&type28);
1946 auto param = model->addOperand(&type1);
1947 auto axis = model->addOperand(&type1);
1948 auto op2 = model->addOperand(&type28);
1949 // Phase 2, operations
1950 static int32_t param_init[] = {3};
1951 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1952 static int32_t axis_init[] = {-1};
1953 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1954 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1955 // Phase 3, inputs and outputs
1956 model->identifyInputsAndOutputs(
1957 {op1},
1958 {op2});
1959 assert(model->isValid());
1960 }
1961
is_ignored_float16_dim3_axis2_neg(int i)1962 inline bool is_ignored_float16_dim3_axis2_neg(int i) {
1963 static std::set<int> ignore = {};
1964 return ignore.find(i) != ignore.end();
1965 }
1966
CreateModel_float16_dim2_axis0(Model * model)1967 void CreateModel_float16_dim2_axis0(Model *model) {
1968 OperandType type1(Type::INT32, {});
1969 OperandType type29(Type::TENSOR_FLOAT16, {12, 3});
1970 // Phase 1, operands
1971 auto op1 = model->addOperand(&type29);
1972 auto param = model->addOperand(&type1);
1973 auto axis = model->addOperand(&type1);
1974 auto op2 = model->addOperand(&type29);
1975 // Phase 2, operations
1976 static int32_t param_init[] = {3};
1977 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
1978 static int32_t axis_init[] = {0};
1979 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
1980 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
1981 // Phase 3, inputs and outputs
1982 model->identifyInputsAndOutputs(
1983 {op1},
1984 {op2});
1985 assert(model->isValid());
1986 }
1987
is_ignored_float16_dim2_axis0(int i)1988 inline bool is_ignored_float16_dim2_axis0(int i) {
1989 static std::set<int> ignore = {};
1990 return ignore.find(i) != ignore.end();
1991 }
1992
CreateModel_float16_dim2_axis0_neg(Model * model)1993 void CreateModel_float16_dim2_axis0_neg(Model *model) {
1994 OperandType type1(Type::INT32, {});
1995 OperandType type29(Type::TENSOR_FLOAT16, {12, 3});
1996 // Phase 1, operands
1997 auto op1 = model->addOperand(&type29);
1998 auto param = model->addOperand(&type1);
1999 auto axis = model->addOperand(&type1);
2000 auto op2 = model->addOperand(&type29);
2001 // Phase 2, operations
2002 static int32_t param_init[] = {3};
2003 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2004 static int32_t axis_init[] = {-2};
2005 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2006 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2007 // Phase 3, inputs and outputs
2008 model->identifyInputsAndOutputs(
2009 {op1},
2010 {op2});
2011 assert(model->isValid());
2012 }
2013
is_ignored_float16_dim2_axis0_neg(int i)2014 inline bool is_ignored_float16_dim2_axis0_neg(int i) {
2015 static std::set<int> ignore = {};
2016 return ignore.find(i) != ignore.end();
2017 }
2018
CreateModel_float16_dim2_axis1(Model * model)2019 void CreateModel_float16_dim2_axis1(Model *model) {
2020 OperandType type1(Type::INT32, {});
2021 OperandType type30(Type::TENSOR_FLOAT16, {3, 12});
2022 // Phase 1, operands
2023 auto op1 = model->addOperand(&type30);
2024 auto param = model->addOperand(&type1);
2025 auto axis = model->addOperand(&type1);
2026 auto op2 = model->addOperand(&type30);
2027 // Phase 2, operations
2028 static int32_t param_init[] = {3};
2029 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2030 static int32_t axis_init[] = {1};
2031 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2032 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2033 // Phase 3, inputs and outputs
2034 model->identifyInputsAndOutputs(
2035 {op1},
2036 {op2});
2037 assert(model->isValid());
2038 }
2039
is_ignored_float16_dim2_axis1(int i)2040 inline bool is_ignored_float16_dim2_axis1(int i) {
2041 static std::set<int> ignore = {};
2042 return ignore.find(i) != ignore.end();
2043 }
2044
CreateModel_float16_dim2_axis1_neg(Model * model)2045 void CreateModel_float16_dim2_axis1_neg(Model *model) {
2046 OperandType type1(Type::INT32, {});
2047 OperandType type30(Type::TENSOR_FLOAT16, {3, 12});
2048 // Phase 1, operands
2049 auto op1 = model->addOperand(&type30);
2050 auto param = model->addOperand(&type1);
2051 auto axis = model->addOperand(&type1);
2052 auto op2 = model->addOperand(&type30);
2053 // Phase 2, operations
2054 static int32_t param_init[] = {3};
2055 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2056 static int32_t axis_init[] = {-1};
2057 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2058 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2059 // Phase 3, inputs and outputs
2060 model->identifyInputsAndOutputs(
2061 {op1},
2062 {op2});
2063 assert(model->isValid());
2064 }
2065
is_ignored_float16_dim2_axis1_neg(int i)2066 inline bool is_ignored_float16_dim2_axis1_neg(int i) {
2067 static std::set<int> ignore = {};
2068 return ignore.find(i) != ignore.end();
2069 }
2070
CreateModel_float16_dim1_axis0(Model * model)2071 void CreateModel_float16_dim1_axis0(Model *model) {
2072 OperandType type1(Type::INT32, {});
2073 OperandType type31(Type::TENSOR_FLOAT16, {12});
2074 // Phase 1, operands
2075 auto op1 = model->addOperand(&type31);
2076 auto param = model->addOperand(&type1);
2077 auto axis = model->addOperand(&type1);
2078 auto op2 = model->addOperand(&type31);
2079 // Phase 2, operations
2080 static int32_t param_init[] = {3};
2081 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2082 static int32_t axis_init[] = {0};
2083 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2084 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2085 // Phase 3, inputs and outputs
2086 model->identifyInputsAndOutputs(
2087 {op1},
2088 {op2});
2089 assert(model->isValid());
2090 }
2091
is_ignored_float16_dim1_axis0(int i)2092 inline bool is_ignored_float16_dim1_axis0(int i) {
2093 static std::set<int> ignore = {};
2094 return ignore.find(i) != ignore.end();
2095 }
2096
CreateModel_float16_dim1_axis0_neg(Model * model)2097 void CreateModel_float16_dim1_axis0_neg(Model *model) {
2098 OperandType type1(Type::INT32, {});
2099 OperandType type31(Type::TENSOR_FLOAT16, {12});
2100 // Phase 1, operands
2101 auto op1 = model->addOperand(&type31);
2102 auto param = model->addOperand(&type1);
2103 auto axis = model->addOperand(&type1);
2104 auto op2 = model->addOperand(&type31);
2105 // Phase 2, operations
2106 static int32_t param_init[] = {3};
2107 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2108 static int32_t axis_init[] = {-1};
2109 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2110 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2111 // Phase 3, inputs and outputs
2112 model->identifyInputsAndOutputs(
2113 {op1},
2114 {op2});
2115 assert(model->isValid());
2116 }
2117
is_ignored_float16_dim1_axis0_neg(int i)2118 inline bool is_ignored_float16_dim1_axis0_neg(int i) {
2119 static std::set<int> ignore = {};
2120 return ignore.find(i) != ignore.end();
2121 }
2122
CreateModel_dynamic_output_shape_dim4_axis0(Model * model)2123 void CreateModel_dynamic_output_shape_dim4_axis0(Model *model) {
2124 OperandType type1(Type::INT32, {});
2125 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
2126 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2127 // Phase 1, operands
2128 auto op1 = model->addOperand(&type2);
2129 auto param = model->addOperand(&type1);
2130 auto axis = model->addOperand(&type1);
2131 auto op2 = model->addOperand(&type32);
2132 // Phase 2, operations
2133 static int32_t param_init[] = {3};
2134 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2135 static int32_t axis_init[] = {0};
2136 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2137 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2138 // Phase 3, inputs and outputs
2139 model->identifyInputsAndOutputs(
2140 {op1},
2141 {op2});
2142 assert(model->isValid());
2143 }
2144
is_ignored_dynamic_output_shape_dim4_axis0(int i)2145 inline bool is_ignored_dynamic_output_shape_dim4_axis0(int i) {
2146 static std::set<int> ignore = {};
2147 return ignore.find(i) != ignore.end();
2148 }
2149
CreateModel_dynamic_output_shape_dim4_axis0_neg(Model * model)2150 void CreateModel_dynamic_output_shape_dim4_axis0_neg(Model *model) {
2151 OperandType type1(Type::INT32, {});
2152 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
2153 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2154 // Phase 1, operands
2155 auto op1 = model->addOperand(&type2);
2156 auto param = model->addOperand(&type1);
2157 auto axis = model->addOperand(&type1);
2158 auto op2 = model->addOperand(&type32);
2159 // Phase 2, operations
2160 static int32_t param_init[] = {3};
2161 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2162 static int32_t axis_init[] = {-4};
2163 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2164 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2165 // Phase 3, inputs and outputs
2166 model->identifyInputsAndOutputs(
2167 {op1},
2168 {op2});
2169 assert(model->isValid());
2170 }
2171
is_ignored_dynamic_output_shape_dim4_axis0_neg(int i)2172 inline bool is_ignored_dynamic_output_shape_dim4_axis0_neg(int i) {
2173 static std::set<int> ignore = {};
2174 return ignore.find(i) != ignore.end();
2175 }
2176
CreateModel_dynamic_output_shape_dim4_axis1(Model * model)2177 void CreateModel_dynamic_output_shape_dim4_axis1(Model *model) {
2178 OperandType type1(Type::INT32, {});
2179 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
2180 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2181 // Phase 1, operands
2182 auto op1 = model->addOperand(&type3);
2183 auto param = model->addOperand(&type1);
2184 auto axis = model->addOperand(&type1);
2185 auto op2 = model->addOperand(&type32);
2186 // Phase 2, operations
2187 static int32_t param_init[] = {3};
2188 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2189 static int32_t axis_init[] = {1};
2190 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2191 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2192 // Phase 3, inputs and outputs
2193 model->identifyInputsAndOutputs(
2194 {op1},
2195 {op2});
2196 assert(model->isValid());
2197 }
2198
is_ignored_dynamic_output_shape_dim4_axis1(int i)2199 inline bool is_ignored_dynamic_output_shape_dim4_axis1(int i) {
2200 static std::set<int> ignore = {};
2201 return ignore.find(i) != ignore.end();
2202 }
2203
CreateModel_dynamic_output_shape_dim4_axis1_neg(Model * model)2204 void CreateModel_dynamic_output_shape_dim4_axis1_neg(Model *model) {
2205 OperandType type1(Type::INT32, {});
2206 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
2207 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2208 // Phase 1, operands
2209 auto op1 = model->addOperand(&type3);
2210 auto param = model->addOperand(&type1);
2211 auto axis = model->addOperand(&type1);
2212 auto op2 = model->addOperand(&type32);
2213 // Phase 2, operations
2214 static int32_t param_init[] = {3};
2215 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2216 static int32_t axis_init[] = {-3};
2217 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2218 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2219 // Phase 3, inputs and outputs
2220 model->identifyInputsAndOutputs(
2221 {op1},
2222 {op2});
2223 assert(model->isValid());
2224 }
2225
is_ignored_dynamic_output_shape_dim4_axis1_neg(int i)2226 inline bool is_ignored_dynamic_output_shape_dim4_axis1_neg(int i) {
2227 static std::set<int> ignore = {};
2228 return ignore.find(i) != ignore.end();
2229 }
2230
CreateModel_dynamic_output_shape_dim4_axis2(Model * model)2231 void CreateModel_dynamic_output_shape_dim4_axis2(Model *model) {
2232 OperandType type1(Type::INT32, {});
2233 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2234 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
2235 // Phase 1, operands
2236 auto op1 = model->addOperand(&type4);
2237 auto param = model->addOperand(&type1);
2238 auto axis = model->addOperand(&type1);
2239 auto op2 = model->addOperand(&type32);
2240 // Phase 2, operations
2241 static int32_t param_init[] = {3};
2242 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2243 static int32_t axis_init[] = {2};
2244 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2245 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2246 // Phase 3, inputs and outputs
2247 model->identifyInputsAndOutputs(
2248 {op1},
2249 {op2});
2250 assert(model->isValid());
2251 }
2252
is_ignored_dynamic_output_shape_dim4_axis2(int i)2253 inline bool is_ignored_dynamic_output_shape_dim4_axis2(int i) {
2254 static std::set<int> ignore = {};
2255 return ignore.find(i) != ignore.end();
2256 }
2257
CreateModel_dynamic_output_shape_dim4_axis2_neg(Model * model)2258 void CreateModel_dynamic_output_shape_dim4_axis2_neg(Model *model) {
2259 OperandType type1(Type::INT32, {});
2260 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2261 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
2262 // Phase 1, operands
2263 auto op1 = model->addOperand(&type4);
2264 auto param = model->addOperand(&type1);
2265 auto axis = model->addOperand(&type1);
2266 auto op2 = model->addOperand(&type32);
2267 // Phase 2, operations
2268 static int32_t param_init[] = {3};
2269 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2270 static int32_t axis_init[] = {-2};
2271 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2272 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2273 // Phase 3, inputs and outputs
2274 model->identifyInputsAndOutputs(
2275 {op1},
2276 {op2});
2277 assert(model->isValid());
2278 }
2279
is_ignored_dynamic_output_shape_dim4_axis2_neg(int i)2280 inline bool is_ignored_dynamic_output_shape_dim4_axis2_neg(int i) {
2281 static std::set<int> ignore = {};
2282 return ignore.find(i) != ignore.end();
2283 }
2284
CreateModel_dynamic_output_shape_dim4_axis3(Model * model)2285 void CreateModel_dynamic_output_shape_dim4_axis3(Model *model) {
2286 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
2287 OperandType type1(Type::INT32, {});
2288 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2289 // Phase 1, operands
2290 auto op1 = model->addOperand(&type0);
2291 auto param = model->addOperand(&type1);
2292 auto axis = model->addOperand(&type1);
2293 auto op2 = model->addOperand(&type32);
2294 // Phase 2, operations
2295 static int32_t param_init[] = {3};
2296 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2297 static int32_t axis_init[] = {3};
2298 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2299 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2300 // Phase 3, inputs and outputs
2301 model->identifyInputsAndOutputs(
2302 {op1},
2303 {op2});
2304 assert(model->isValid());
2305 }
2306
is_ignored_dynamic_output_shape_dim4_axis3(int i)2307 inline bool is_ignored_dynamic_output_shape_dim4_axis3(int i) {
2308 static std::set<int> ignore = {};
2309 return ignore.find(i) != ignore.end();
2310 }
2311
CreateModel_dynamic_output_shape_dim4_axis3_neg(Model * model)2312 void CreateModel_dynamic_output_shape_dim4_axis3_neg(Model *model) {
2313 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
2314 OperandType type1(Type::INT32, {});
2315 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2316 // Phase 1, operands
2317 auto op1 = model->addOperand(&type0);
2318 auto param = model->addOperand(&type1);
2319 auto axis = model->addOperand(&type1);
2320 auto op2 = model->addOperand(&type32);
2321 // Phase 2, operations
2322 static int32_t param_init[] = {3};
2323 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2324 static int32_t axis_init[] = {-1};
2325 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2326 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2327 // Phase 3, inputs and outputs
2328 model->identifyInputsAndOutputs(
2329 {op1},
2330 {op2});
2331 assert(model->isValid());
2332 }
2333
is_ignored_dynamic_output_shape_dim4_axis3_neg(int i)2334 inline bool is_ignored_dynamic_output_shape_dim4_axis3_neg(int i) {
2335 static std::set<int> ignore = {};
2336 return ignore.find(i) != ignore.end();
2337 }
2338
CreateModel_dynamic_output_shape_dim3_axis0(Model * model)2339 void CreateModel_dynamic_output_shape_dim3_axis0(Model *model) {
2340 OperandType type1(Type::INT32, {});
2341 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2342 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
2343 // Phase 1, operands
2344 auto op1 = model->addOperand(&type5);
2345 auto param = model->addOperand(&type1);
2346 auto axis = model->addOperand(&type1);
2347 auto op2 = model->addOperand(&type33);
2348 // Phase 2, operations
2349 static int32_t param_init[] = {3};
2350 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2351 static int32_t axis_init[] = {0};
2352 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2353 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2354 // Phase 3, inputs and outputs
2355 model->identifyInputsAndOutputs(
2356 {op1},
2357 {op2});
2358 assert(model->isValid());
2359 }
2360
is_ignored_dynamic_output_shape_dim3_axis0(int i)2361 inline bool is_ignored_dynamic_output_shape_dim3_axis0(int i) {
2362 static std::set<int> ignore = {};
2363 return ignore.find(i) != ignore.end();
2364 }
2365
CreateModel_dynamic_output_shape_dim3_axis0_neg(Model * model)2366 void CreateModel_dynamic_output_shape_dim3_axis0_neg(Model *model) {
2367 OperandType type1(Type::INT32, {});
2368 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2369 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
2370 // Phase 1, operands
2371 auto op1 = model->addOperand(&type5);
2372 auto param = model->addOperand(&type1);
2373 auto axis = model->addOperand(&type1);
2374 auto op2 = model->addOperand(&type33);
2375 // Phase 2, operations
2376 static int32_t param_init[] = {3};
2377 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2378 static int32_t axis_init[] = {-3};
2379 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2380 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2381 // Phase 3, inputs and outputs
2382 model->identifyInputsAndOutputs(
2383 {op1},
2384 {op2});
2385 assert(model->isValid());
2386 }
2387
is_ignored_dynamic_output_shape_dim3_axis0_neg(int i)2388 inline bool is_ignored_dynamic_output_shape_dim3_axis0_neg(int i) {
2389 static std::set<int> ignore = {};
2390 return ignore.find(i) != ignore.end();
2391 }
2392
CreateModel_dynamic_output_shape_dim3_axis1(Model * model)2393 void CreateModel_dynamic_output_shape_dim3_axis1(Model *model) {
2394 OperandType type1(Type::INT32, {});
2395 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2396 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
2397 // Phase 1, operands
2398 auto op1 = model->addOperand(&type6);
2399 auto param = model->addOperand(&type1);
2400 auto axis = model->addOperand(&type1);
2401 auto op2 = model->addOperand(&type33);
2402 // Phase 2, operations
2403 static int32_t param_init[] = {3};
2404 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2405 static int32_t axis_init[] = {1};
2406 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2407 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2408 // Phase 3, inputs and outputs
2409 model->identifyInputsAndOutputs(
2410 {op1},
2411 {op2});
2412 assert(model->isValid());
2413 }
2414
is_ignored_dynamic_output_shape_dim3_axis1(int i)2415 inline bool is_ignored_dynamic_output_shape_dim3_axis1(int i) {
2416 static std::set<int> ignore = {};
2417 return ignore.find(i) != ignore.end();
2418 }
2419
CreateModel_dynamic_output_shape_dim3_axis1_neg(Model * model)2420 void CreateModel_dynamic_output_shape_dim3_axis1_neg(Model *model) {
2421 OperandType type1(Type::INT32, {});
2422 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2423 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
2424 // Phase 1, operands
2425 auto op1 = model->addOperand(&type6);
2426 auto param = model->addOperand(&type1);
2427 auto axis = model->addOperand(&type1);
2428 auto op2 = model->addOperand(&type33);
2429 // Phase 2, operations
2430 static int32_t param_init[] = {3};
2431 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2432 static int32_t axis_init[] = {-2};
2433 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2434 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2435 // Phase 3, inputs and outputs
2436 model->identifyInputsAndOutputs(
2437 {op1},
2438 {op2});
2439 assert(model->isValid());
2440 }
2441
is_ignored_dynamic_output_shape_dim3_axis1_neg(int i)2442 inline bool is_ignored_dynamic_output_shape_dim3_axis1_neg(int i) {
2443 static std::set<int> ignore = {};
2444 return ignore.find(i) != ignore.end();
2445 }
2446
CreateModel_dynamic_output_shape_dim3_axis2(Model * model)2447 void CreateModel_dynamic_output_shape_dim3_axis2(Model *model) {
2448 OperandType type1(Type::INT32, {});
2449 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2450 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
2451 // Phase 1, operands
2452 auto op1 = model->addOperand(&type7);
2453 auto param = model->addOperand(&type1);
2454 auto axis = model->addOperand(&type1);
2455 auto op2 = model->addOperand(&type33);
2456 // Phase 2, operations
2457 static int32_t param_init[] = {3};
2458 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2459 static int32_t axis_init[] = {2};
2460 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2461 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2462 // Phase 3, inputs and outputs
2463 model->identifyInputsAndOutputs(
2464 {op1},
2465 {op2});
2466 assert(model->isValid());
2467 }
2468
is_ignored_dynamic_output_shape_dim3_axis2(int i)2469 inline bool is_ignored_dynamic_output_shape_dim3_axis2(int i) {
2470 static std::set<int> ignore = {};
2471 return ignore.find(i) != ignore.end();
2472 }
2473
CreateModel_dynamic_output_shape_dim3_axis2_neg(Model * model)2474 void CreateModel_dynamic_output_shape_dim3_axis2_neg(Model *model) {
2475 OperandType type1(Type::INT32, {});
2476 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2477 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
2478 // Phase 1, operands
2479 auto op1 = model->addOperand(&type7);
2480 auto param = model->addOperand(&type1);
2481 auto axis = model->addOperand(&type1);
2482 auto op2 = model->addOperand(&type33);
2483 // Phase 2, operations
2484 static int32_t param_init[] = {3};
2485 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2486 static int32_t axis_init[] = {-1};
2487 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2488 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2489 // Phase 3, inputs and outputs
2490 model->identifyInputsAndOutputs(
2491 {op1},
2492 {op2});
2493 assert(model->isValid());
2494 }
2495
is_ignored_dynamic_output_shape_dim3_axis2_neg(int i)2496 inline bool is_ignored_dynamic_output_shape_dim3_axis2_neg(int i) {
2497 static std::set<int> ignore = {};
2498 return ignore.find(i) != ignore.end();
2499 }
2500
CreateModel_dynamic_output_shape_dim2_axis0(Model * model)2501 void CreateModel_dynamic_output_shape_dim2_axis0(Model *model) {
2502 OperandType type1(Type::INT32, {});
2503 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
2504 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
2505 // Phase 1, operands
2506 auto op1 = model->addOperand(&type8);
2507 auto param = model->addOperand(&type1);
2508 auto axis = model->addOperand(&type1);
2509 auto op2 = model->addOperand(&type34);
2510 // Phase 2, operations
2511 static int32_t param_init[] = {3};
2512 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2513 static int32_t axis_init[] = {0};
2514 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2515 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2516 // Phase 3, inputs and outputs
2517 model->identifyInputsAndOutputs(
2518 {op1},
2519 {op2});
2520 assert(model->isValid());
2521 }
2522
is_ignored_dynamic_output_shape_dim2_axis0(int i)2523 inline bool is_ignored_dynamic_output_shape_dim2_axis0(int i) {
2524 static std::set<int> ignore = {};
2525 return ignore.find(i) != ignore.end();
2526 }
2527
CreateModel_dynamic_output_shape_dim2_axis0_neg(Model * model)2528 void CreateModel_dynamic_output_shape_dim2_axis0_neg(Model *model) {
2529 OperandType type1(Type::INT32, {});
2530 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
2531 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
2532 // Phase 1, operands
2533 auto op1 = model->addOperand(&type8);
2534 auto param = model->addOperand(&type1);
2535 auto axis = model->addOperand(&type1);
2536 auto op2 = model->addOperand(&type34);
2537 // Phase 2, operations
2538 static int32_t param_init[] = {3};
2539 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2540 static int32_t axis_init[] = {-2};
2541 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2542 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2543 // Phase 3, inputs and outputs
2544 model->identifyInputsAndOutputs(
2545 {op1},
2546 {op2});
2547 assert(model->isValid());
2548 }
2549
is_ignored_dynamic_output_shape_dim2_axis0_neg(int i)2550 inline bool is_ignored_dynamic_output_shape_dim2_axis0_neg(int i) {
2551 static std::set<int> ignore = {};
2552 return ignore.find(i) != ignore.end();
2553 }
2554
CreateModel_dynamic_output_shape_dim2_axis1(Model * model)2555 void CreateModel_dynamic_output_shape_dim2_axis1(Model *model) {
2556 OperandType type1(Type::INT32, {});
2557 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
2558 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
2559 // Phase 1, operands
2560 auto op1 = model->addOperand(&type9);
2561 auto param = model->addOperand(&type1);
2562 auto axis = model->addOperand(&type1);
2563 auto op2 = model->addOperand(&type34);
2564 // Phase 2, operations
2565 static int32_t param_init[] = {3};
2566 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2567 static int32_t axis_init[] = {1};
2568 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2569 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2570 // Phase 3, inputs and outputs
2571 model->identifyInputsAndOutputs(
2572 {op1},
2573 {op2});
2574 assert(model->isValid());
2575 }
2576
is_ignored_dynamic_output_shape_dim2_axis1(int i)2577 inline bool is_ignored_dynamic_output_shape_dim2_axis1(int i) {
2578 static std::set<int> ignore = {};
2579 return ignore.find(i) != ignore.end();
2580 }
2581
CreateModel_dynamic_output_shape_dim2_axis1_neg(Model * model)2582 void CreateModel_dynamic_output_shape_dim2_axis1_neg(Model *model) {
2583 OperandType type1(Type::INT32, {});
2584 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
2585 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
2586 // Phase 1, operands
2587 auto op1 = model->addOperand(&type9);
2588 auto param = model->addOperand(&type1);
2589 auto axis = model->addOperand(&type1);
2590 auto op2 = model->addOperand(&type34);
2591 // Phase 2, operations
2592 static int32_t param_init[] = {3};
2593 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2594 static int32_t axis_init[] = {-1};
2595 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2596 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2597 // Phase 3, inputs and outputs
2598 model->identifyInputsAndOutputs(
2599 {op1},
2600 {op2});
2601 assert(model->isValid());
2602 }
2603
is_ignored_dynamic_output_shape_dim2_axis1_neg(int i)2604 inline bool is_ignored_dynamic_output_shape_dim2_axis1_neg(int i) {
2605 static std::set<int> ignore = {};
2606 return ignore.find(i) != ignore.end();
2607 }
2608
CreateModel_dynamic_output_shape_dim1_axis0(Model * model)2609 void CreateModel_dynamic_output_shape_dim1_axis0(Model *model) {
2610 OperandType type1(Type::INT32, {});
2611 OperandType type10(Type::TENSOR_FLOAT32, {12});
2612 OperandType type35(Type::TENSOR_FLOAT32, {0});
2613 // Phase 1, operands
2614 auto op1 = model->addOperand(&type10);
2615 auto param = model->addOperand(&type1);
2616 auto axis = model->addOperand(&type1);
2617 auto op2 = model->addOperand(&type35);
2618 // Phase 2, operations
2619 static int32_t param_init[] = {3};
2620 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2621 static int32_t axis_init[] = {0};
2622 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2623 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2624 // Phase 3, inputs and outputs
2625 model->identifyInputsAndOutputs(
2626 {op1},
2627 {op2});
2628 assert(model->isValid());
2629 }
2630
is_ignored_dynamic_output_shape_dim1_axis0(int i)2631 inline bool is_ignored_dynamic_output_shape_dim1_axis0(int i) {
2632 static std::set<int> ignore = {};
2633 return ignore.find(i) != ignore.end();
2634 }
2635
CreateModel_dynamic_output_shape_dim1_axis0_neg(Model * model)2636 void CreateModel_dynamic_output_shape_dim1_axis0_neg(Model *model) {
2637 OperandType type1(Type::INT32, {});
2638 OperandType type10(Type::TENSOR_FLOAT32, {12});
2639 OperandType type35(Type::TENSOR_FLOAT32, {0});
2640 // Phase 1, operands
2641 auto op1 = model->addOperand(&type10);
2642 auto param = model->addOperand(&type1);
2643 auto axis = model->addOperand(&type1);
2644 auto op2 = model->addOperand(&type35);
2645 // Phase 2, operations
2646 static int32_t param_init[] = {3};
2647 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2648 static int32_t axis_init[] = {-1};
2649 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2650 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2651 // Phase 3, inputs and outputs
2652 model->identifyInputsAndOutputs(
2653 {op1},
2654 {op2});
2655 assert(model->isValid());
2656 }
2657
is_ignored_dynamic_output_shape_dim1_axis0_neg(int i)2658 inline bool is_ignored_dynamic_output_shape_dim1_axis0_neg(int i) {
2659 static std::set<int> ignore = {};
2660 return ignore.find(i) != ignore.end();
2661 }
2662
CreateModel_dynamic_output_shape_relaxed_dim4_axis0(Model * model)2663 void CreateModel_dynamic_output_shape_relaxed_dim4_axis0(Model *model) {
2664 OperandType type1(Type::INT32, {});
2665 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
2666 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2667 // Phase 1, operands
2668 auto op1 = model->addOperand(&type2);
2669 auto param = model->addOperand(&type1);
2670 auto axis = model->addOperand(&type1);
2671 auto op2 = model->addOperand(&type32);
2672 // Phase 2, operations
2673 static int32_t param_init[] = {3};
2674 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2675 static int32_t axis_init[] = {0};
2676 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2677 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2678 // Phase 3, inputs and outputs
2679 model->identifyInputsAndOutputs(
2680 {op1},
2681 {op2});
2682 // Phase 4: set relaxed execution
2683 model->relaxComputationFloat32toFloat16(true);
2684 assert(model->isValid());
2685 }
2686
is_ignored_dynamic_output_shape_relaxed_dim4_axis0(int i)2687 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis0(int i) {
2688 static std::set<int> ignore = {};
2689 return ignore.find(i) != ignore.end();
2690 }
2691
CreateModel_dynamic_output_shape_relaxed_dim4_axis0_neg(Model * model)2692 void CreateModel_dynamic_output_shape_relaxed_dim4_axis0_neg(Model *model) {
2693 OperandType type1(Type::INT32, {});
2694 OperandType type2(Type::TENSOR_FLOAT32, {12, 2, 2, 3});
2695 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2696 // Phase 1, operands
2697 auto op1 = model->addOperand(&type2);
2698 auto param = model->addOperand(&type1);
2699 auto axis = model->addOperand(&type1);
2700 auto op2 = model->addOperand(&type32);
2701 // Phase 2, operations
2702 static int32_t param_init[] = {3};
2703 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2704 static int32_t axis_init[] = {-4};
2705 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2706 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2707 // Phase 3, inputs and outputs
2708 model->identifyInputsAndOutputs(
2709 {op1},
2710 {op2});
2711 // Phase 4: set relaxed execution
2712 model->relaxComputationFloat32toFloat16(true);
2713 assert(model->isValid());
2714 }
2715
is_ignored_dynamic_output_shape_relaxed_dim4_axis0_neg(int i)2716 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis0_neg(int i) {
2717 static std::set<int> ignore = {};
2718 return ignore.find(i) != ignore.end();
2719 }
2720
CreateModel_dynamic_output_shape_relaxed_dim4_axis1(Model * model)2721 void CreateModel_dynamic_output_shape_relaxed_dim4_axis1(Model *model) {
2722 OperandType type1(Type::INT32, {});
2723 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
2724 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2725 // Phase 1, operands
2726 auto op1 = model->addOperand(&type3);
2727 auto param = model->addOperand(&type1);
2728 auto axis = model->addOperand(&type1);
2729 auto op2 = model->addOperand(&type32);
2730 // Phase 2, operations
2731 static int32_t param_init[] = {3};
2732 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2733 static int32_t axis_init[] = {1};
2734 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2735 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2736 // Phase 3, inputs and outputs
2737 model->identifyInputsAndOutputs(
2738 {op1},
2739 {op2});
2740 // Phase 4: set relaxed execution
2741 model->relaxComputationFloat32toFloat16(true);
2742 assert(model->isValid());
2743 }
2744
is_ignored_dynamic_output_shape_relaxed_dim4_axis1(int i)2745 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis1(int i) {
2746 static std::set<int> ignore = {};
2747 return ignore.find(i) != ignore.end();
2748 }
2749
CreateModel_dynamic_output_shape_relaxed_dim4_axis1_neg(Model * model)2750 void CreateModel_dynamic_output_shape_relaxed_dim4_axis1_neg(Model *model) {
2751 OperandType type1(Type::INT32, {});
2752 OperandType type3(Type::TENSOR_FLOAT32, {2, 12, 2, 3});
2753 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2754 // Phase 1, operands
2755 auto op1 = model->addOperand(&type3);
2756 auto param = model->addOperand(&type1);
2757 auto axis = model->addOperand(&type1);
2758 auto op2 = model->addOperand(&type32);
2759 // Phase 2, operations
2760 static int32_t param_init[] = {3};
2761 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2762 static int32_t axis_init[] = {-3};
2763 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2764 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2765 // Phase 3, inputs and outputs
2766 model->identifyInputsAndOutputs(
2767 {op1},
2768 {op2});
2769 // Phase 4: set relaxed execution
2770 model->relaxComputationFloat32toFloat16(true);
2771 assert(model->isValid());
2772 }
2773
is_ignored_dynamic_output_shape_relaxed_dim4_axis1_neg(int i)2774 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis1_neg(int i) {
2775 static std::set<int> ignore = {};
2776 return ignore.find(i) != ignore.end();
2777 }
2778
CreateModel_dynamic_output_shape_relaxed_dim4_axis2(Model * model)2779 void CreateModel_dynamic_output_shape_relaxed_dim4_axis2(Model *model) {
2780 OperandType type1(Type::INT32, {});
2781 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2782 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
2783 // Phase 1, operands
2784 auto op1 = model->addOperand(&type4);
2785 auto param = model->addOperand(&type1);
2786 auto axis = model->addOperand(&type1);
2787 auto op2 = model->addOperand(&type32);
2788 // Phase 2, operations
2789 static int32_t param_init[] = {3};
2790 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2791 static int32_t axis_init[] = {2};
2792 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2793 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2794 // Phase 3, inputs and outputs
2795 model->identifyInputsAndOutputs(
2796 {op1},
2797 {op2});
2798 // Phase 4: set relaxed execution
2799 model->relaxComputationFloat32toFloat16(true);
2800 assert(model->isValid());
2801 }
2802
is_ignored_dynamic_output_shape_relaxed_dim4_axis2(int i)2803 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis2(int i) {
2804 static std::set<int> ignore = {};
2805 return ignore.find(i) != ignore.end();
2806 }
2807
CreateModel_dynamic_output_shape_relaxed_dim4_axis2_neg(Model * model)2808 void CreateModel_dynamic_output_shape_relaxed_dim4_axis2_neg(Model *model) {
2809 OperandType type1(Type::INT32, {});
2810 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2811 OperandType type4(Type::TENSOR_FLOAT32, {2, 2, 12, 3});
2812 // Phase 1, operands
2813 auto op1 = model->addOperand(&type4);
2814 auto param = model->addOperand(&type1);
2815 auto axis = model->addOperand(&type1);
2816 auto op2 = model->addOperand(&type32);
2817 // Phase 2, operations
2818 static int32_t param_init[] = {3};
2819 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2820 static int32_t axis_init[] = {-2};
2821 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2822 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2823 // Phase 3, inputs and outputs
2824 model->identifyInputsAndOutputs(
2825 {op1},
2826 {op2});
2827 // Phase 4: set relaxed execution
2828 model->relaxComputationFloat32toFloat16(true);
2829 assert(model->isValid());
2830 }
2831
is_ignored_dynamic_output_shape_relaxed_dim4_axis2_neg(int i)2832 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis2_neg(int i) {
2833 static std::set<int> ignore = {};
2834 return ignore.find(i) != ignore.end();
2835 }
2836
CreateModel_dynamic_output_shape_relaxed_dim4_axis3(Model * model)2837 void CreateModel_dynamic_output_shape_relaxed_dim4_axis3(Model *model) {
2838 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
2839 OperandType type1(Type::INT32, {});
2840 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2841 // Phase 1, operands
2842 auto op1 = model->addOperand(&type0);
2843 auto param = model->addOperand(&type1);
2844 auto axis = model->addOperand(&type1);
2845 auto op2 = model->addOperand(&type32);
2846 // Phase 2, operations
2847 static int32_t param_init[] = {3};
2848 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2849 static int32_t axis_init[] = {3};
2850 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2851 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2852 // Phase 3, inputs and outputs
2853 model->identifyInputsAndOutputs(
2854 {op1},
2855 {op2});
2856 // Phase 4: set relaxed execution
2857 model->relaxComputationFloat32toFloat16(true);
2858 assert(model->isValid());
2859 }
2860
is_ignored_dynamic_output_shape_relaxed_dim4_axis3(int i)2861 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis3(int i) {
2862 static std::set<int> ignore = {};
2863 return ignore.find(i) != ignore.end();
2864 }
2865
CreateModel_dynamic_output_shape_relaxed_dim4_axis3_neg(Model * model)2866 void CreateModel_dynamic_output_shape_relaxed_dim4_axis3_neg(Model *model) {
2867 OperandType type0(Type::TENSOR_FLOAT32, {2, 2, 3, 12});
2868 OperandType type1(Type::INT32, {});
2869 OperandType type32(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
2870 // Phase 1, operands
2871 auto op1 = model->addOperand(&type0);
2872 auto param = model->addOperand(&type1);
2873 auto axis = model->addOperand(&type1);
2874 auto op2 = model->addOperand(&type32);
2875 // Phase 2, operations
2876 static int32_t param_init[] = {3};
2877 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2878 static int32_t axis_init[] = {-1};
2879 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2880 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2881 // Phase 3, inputs and outputs
2882 model->identifyInputsAndOutputs(
2883 {op1},
2884 {op2});
2885 // Phase 4: set relaxed execution
2886 model->relaxComputationFloat32toFloat16(true);
2887 assert(model->isValid());
2888 }
2889
is_ignored_dynamic_output_shape_relaxed_dim4_axis3_neg(int i)2890 inline bool is_ignored_dynamic_output_shape_relaxed_dim4_axis3_neg(int i) {
2891 static std::set<int> ignore = {};
2892 return ignore.find(i) != ignore.end();
2893 }
2894
CreateModel_dynamic_output_shape_relaxed_dim3_axis0(Model * model)2895 void CreateModel_dynamic_output_shape_relaxed_dim3_axis0(Model *model) {
2896 OperandType type1(Type::INT32, {});
2897 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2898 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
2899 // Phase 1, operands
2900 auto op1 = model->addOperand(&type5);
2901 auto param = model->addOperand(&type1);
2902 auto axis = model->addOperand(&type1);
2903 auto op2 = model->addOperand(&type33);
2904 // Phase 2, operations
2905 static int32_t param_init[] = {3};
2906 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2907 static int32_t axis_init[] = {0};
2908 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2909 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2910 // Phase 3, inputs and outputs
2911 model->identifyInputsAndOutputs(
2912 {op1},
2913 {op2});
2914 // Phase 4: set relaxed execution
2915 model->relaxComputationFloat32toFloat16(true);
2916 assert(model->isValid());
2917 }
2918
is_ignored_dynamic_output_shape_relaxed_dim3_axis0(int i)2919 inline bool is_ignored_dynamic_output_shape_relaxed_dim3_axis0(int i) {
2920 static std::set<int> ignore = {};
2921 return ignore.find(i) != ignore.end();
2922 }
2923
CreateModel_dynamic_output_shape_relaxed_dim3_axis0_neg(Model * model)2924 void CreateModel_dynamic_output_shape_relaxed_dim3_axis0_neg(Model *model) {
2925 OperandType type1(Type::INT32, {});
2926 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2927 OperandType type5(Type::TENSOR_FLOAT32, {12, 2, 3});
2928 // Phase 1, operands
2929 auto op1 = model->addOperand(&type5);
2930 auto param = model->addOperand(&type1);
2931 auto axis = model->addOperand(&type1);
2932 auto op2 = model->addOperand(&type33);
2933 // Phase 2, operations
2934 static int32_t param_init[] = {3};
2935 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2936 static int32_t axis_init[] = {-3};
2937 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2938 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2939 // Phase 3, inputs and outputs
2940 model->identifyInputsAndOutputs(
2941 {op1},
2942 {op2});
2943 // Phase 4: set relaxed execution
2944 model->relaxComputationFloat32toFloat16(true);
2945 assert(model->isValid());
2946 }
2947
is_ignored_dynamic_output_shape_relaxed_dim3_axis0_neg(int i)2948 inline bool is_ignored_dynamic_output_shape_relaxed_dim3_axis0_neg(int i) {
2949 static std::set<int> ignore = {};
2950 return ignore.find(i) != ignore.end();
2951 }
2952
CreateModel_dynamic_output_shape_relaxed_dim3_axis1(Model * model)2953 void CreateModel_dynamic_output_shape_relaxed_dim3_axis1(Model *model) {
2954 OperandType type1(Type::INT32, {});
2955 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2956 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
2957 // Phase 1, operands
2958 auto op1 = model->addOperand(&type6);
2959 auto param = model->addOperand(&type1);
2960 auto axis = model->addOperand(&type1);
2961 auto op2 = model->addOperand(&type33);
2962 // Phase 2, operations
2963 static int32_t param_init[] = {3};
2964 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2965 static int32_t axis_init[] = {1};
2966 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2967 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2968 // Phase 3, inputs and outputs
2969 model->identifyInputsAndOutputs(
2970 {op1},
2971 {op2});
2972 // Phase 4: set relaxed execution
2973 model->relaxComputationFloat32toFloat16(true);
2974 assert(model->isValid());
2975 }
2976
is_ignored_dynamic_output_shape_relaxed_dim3_axis1(int i)2977 inline bool is_ignored_dynamic_output_shape_relaxed_dim3_axis1(int i) {
2978 static std::set<int> ignore = {};
2979 return ignore.find(i) != ignore.end();
2980 }
2981
CreateModel_dynamic_output_shape_relaxed_dim3_axis1_neg(Model * model)2982 void CreateModel_dynamic_output_shape_relaxed_dim3_axis1_neg(Model *model) {
2983 OperandType type1(Type::INT32, {});
2984 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
2985 OperandType type6(Type::TENSOR_FLOAT32, {2, 12, 3});
2986 // Phase 1, operands
2987 auto op1 = model->addOperand(&type6);
2988 auto param = model->addOperand(&type1);
2989 auto axis = model->addOperand(&type1);
2990 auto op2 = model->addOperand(&type33);
2991 // Phase 2, operations
2992 static int32_t param_init[] = {3};
2993 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
2994 static int32_t axis_init[] = {-2};
2995 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
2996 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
2997 // Phase 3, inputs and outputs
2998 model->identifyInputsAndOutputs(
2999 {op1},
3000 {op2});
3001 // Phase 4: set relaxed execution
3002 model->relaxComputationFloat32toFloat16(true);
3003 assert(model->isValid());
3004 }
3005
is_ignored_dynamic_output_shape_relaxed_dim3_axis1_neg(int i)3006 inline bool is_ignored_dynamic_output_shape_relaxed_dim3_axis1_neg(int i) {
3007 static std::set<int> ignore = {};
3008 return ignore.find(i) != ignore.end();
3009 }
3010
CreateModel_dynamic_output_shape_relaxed_dim3_axis2(Model * model)3011 void CreateModel_dynamic_output_shape_relaxed_dim3_axis2(Model *model) {
3012 OperandType type1(Type::INT32, {});
3013 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
3014 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
3015 // Phase 1, operands
3016 auto op1 = model->addOperand(&type7);
3017 auto param = model->addOperand(&type1);
3018 auto axis = model->addOperand(&type1);
3019 auto op2 = model->addOperand(&type33);
3020 // Phase 2, operations
3021 static int32_t param_init[] = {3};
3022 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3023 static int32_t axis_init[] = {2};
3024 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3025 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3026 // Phase 3, inputs and outputs
3027 model->identifyInputsAndOutputs(
3028 {op1},
3029 {op2});
3030 // Phase 4: set relaxed execution
3031 model->relaxComputationFloat32toFloat16(true);
3032 assert(model->isValid());
3033 }
3034
is_ignored_dynamic_output_shape_relaxed_dim3_axis2(int i)3035 inline bool is_ignored_dynamic_output_shape_relaxed_dim3_axis2(int i) {
3036 static std::set<int> ignore = {};
3037 return ignore.find(i) != ignore.end();
3038 }
3039
CreateModel_dynamic_output_shape_relaxed_dim3_axis2_neg(Model * model)3040 void CreateModel_dynamic_output_shape_relaxed_dim3_axis2_neg(Model *model) {
3041 OperandType type1(Type::INT32, {});
3042 OperandType type33(Type::TENSOR_FLOAT32, {0, 0, 0});
3043 OperandType type7(Type::TENSOR_FLOAT32, {2, 3, 12});
3044 // Phase 1, operands
3045 auto op1 = model->addOperand(&type7);
3046 auto param = model->addOperand(&type1);
3047 auto axis = model->addOperand(&type1);
3048 auto op2 = model->addOperand(&type33);
3049 // Phase 2, operations
3050 static int32_t param_init[] = {3};
3051 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3052 static int32_t axis_init[] = {-1};
3053 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3054 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3055 // Phase 3, inputs and outputs
3056 model->identifyInputsAndOutputs(
3057 {op1},
3058 {op2});
3059 // Phase 4: set relaxed execution
3060 model->relaxComputationFloat32toFloat16(true);
3061 assert(model->isValid());
3062 }
3063
is_ignored_dynamic_output_shape_relaxed_dim3_axis2_neg(int i)3064 inline bool is_ignored_dynamic_output_shape_relaxed_dim3_axis2_neg(int i) {
3065 static std::set<int> ignore = {};
3066 return ignore.find(i) != ignore.end();
3067 }
3068
CreateModel_dynamic_output_shape_relaxed_dim2_axis0(Model * model)3069 void CreateModel_dynamic_output_shape_relaxed_dim2_axis0(Model *model) {
3070 OperandType type1(Type::INT32, {});
3071 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
3072 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
3073 // Phase 1, operands
3074 auto op1 = model->addOperand(&type8);
3075 auto param = model->addOperand(&type1);
3076 auto axis = model->addOperand(&type1);
3077 auto op2 = model->addOperand(&type34);
3078 // Phase 2, operations
3079 static int32_t param_init[] = {3};
3080 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3081 static int32_t axis_init[] = {0};
3082 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3083 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3084 // Phase 3, inputs and outputs
3085 model->identifyInputsAndOutputs(
3086 {op1},
3087 {op2});
3088 // Phase 4: set relaxed execution
3089 model->relaxComputationFloat32toFloat16(true);
3090 assert(model->isValid());
3091 }
3092
is_ignored_dynamic_output_shape_relaxed_dim2_axis0(int i)3093 inline bool is_ignored_dynamic_output_shape_relaxed_dim2_axis0(int i) {
3094 static std::set<int> ignore = {};
3095 return ignore.find(i) != ignore.end();
3096 }
3097
CreateModel_dynamic_output_shape_relaxed_dim2_axis0_neg(Model * model)3098 void CreateModel_dynamic_output_shape_relaxed_dim2_axis0_neg(Model *model) {
3099 OperandType type1(Type::INT32, {});
3100 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
3101 OperandType type8(Type::TENSOR_FLOAT32, {12, 3});
3102 // Phase 1, operands
3103 auto op1 = model->addOperand(&type8);
3104 auto param = model->addOperand(&type1);
3105 auto axis = model->addOperand(&type1);
3106 auto op2 = model->addOperand(&type34);
3107 // Phase 2, operations
3108 static int32_t param_init[] = {3};
3109 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3110 static int32_t axis_init[] = {-2};
3111 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3112 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3113 // Phase 3, inputs and outputs
3114 model->identifyInputsAndOutputs(
3115 {op1},
3116 {op2});
3117 // Phase 4: set relaxed execution
3118 model->relaxComputationFloat32toFloat16(true);
3119 assert(model->isValid());
3120 }
3121
is_ignored_dynamic_output_shape_relaxed_dim2_axis0_neg(int i)3122 inline bool is_ignored_dynamic_output_shape_relaxed_dim2_axis0_neg(int i) {
3123 static std::set<int> ignore = {};
3124 return ignore.find(i) != ignore.end();
3125 }
3126
CreateModel_dynamic_output_shape_relaxed_dim2_axis1(Model * model)3127 void CreateModel_dynamic_output_shape_relaxed_dim2_axis1(Model *model) {
3128 OperandType type1(Type::INT32, {});
3129 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
3130 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
3131 // Phase 1, operands
3132 auto op1 = model->addOperand(&type9);
3133 auto param = model->addOperand(&type1);
3134 auto axis = model->addOperand(&type1);
3135 auto op2 = model->addOperand(&type34);
3136 // Phase 2, operations
3137 static int32_t param_init[] = {3};
3138 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3139 static int32_t axis_init[] = {1};
3140 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3141 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3142 // Phase 3, inputs and outputs
3143 model->identifyInputsAndOutputs(
3144 {op1},
3145 {op2});
3146 // Phase 4: set relaxed execution
3147 model->relaxComputationFloat32toFloat16(true);
3148 assert(model->isValid());
3149 }
3150
is_ignored_dynamic_output_shape_relaxed_dim2_axis1(int i)3151 inline bool is_ignored_dynamic_output_shape_relaxed_dim2_axis1(int i) {
3152 static std::set<int> ignore = {};
3153 return ignore.find(i) != ignore.end();
3154 }
3155
CreateModel_dynamic_output_shape_relaxed_dim2_axis1_neg(Model * model)3156 void CreateModel_dynamic_output_shape_relaxed_dim2_axis1_neg(Model *model) {
3157 OperandType type1(Type::INT32, {});
3158 OperandType type34(Type::TENSOR_FLOAT32, {0, 0});
3159 OperandType type9(Type::TENSOR_FLOAT32, {3, 12});
3160 // Phase 1, operands
3161 auto op1 = model->addOperand(&type9);
3162 auto param = model->addOperand(&type1);
3163 auto axis = model->addOperand(&type1);
3164 auto op2 = model->addOperand(&type34);
3165 // Phase 2, operations
3166 static int32_t param_init[] = {3};
3167 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3168 static int32_t axis_init[] = {-1};
3169 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3170 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3171 // Phase 3, inputs and outputs
3172 model->identifyInputsAndOutputs(
3173 {op1},
3174 {op2});
3175 // Phase 4: set relaxed execution
3176 model->relaxComputationFloat32toFloat16(true);
3177 assert(model->isValid());
3178 }
3179
is_ignored_dynamic_output_shape_relaxed_dim2_axis1_neg(int i)3180 inline bool is_ignored_dynamic_output_shape_relaxed_dim2_axis1_neg(int i) {
3181 static std::set<int> ignore = {};
3182 return ignore.find(i) != ignore.end();
3183 }
3184
CreateModel_dynamic_output_shape_relaxed_dim1_axis0(Model * model)3185 void CreateModel_dynamic_output_shape_relaxed_dim1_axis0(Model *model) {
3186 OperandType type1(Type::INT32, {});
3187 OperandType type10(Type::TENSOR_FLOAT32, {12});
3188 OperandType type35(Type::TENSOR_FLOAT32, {0});
3189 // Phase 1, operands
3190 auto op1 = model->addOperand(&type10);
3191 auto param = model->addOperand(&type1);
3192 auto axis = model->addOperand(&type1);
3193 auto op2 = model->addOperand(&type35);
3194 // Phase 2, operations
3195 static int32_t param_init[] = {3};
3196 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3197 static int32_t axis_init[] = {0};
3198 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3199 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3200 // Phase 3, inputs and outputs
3201 model->identifyInputsAndOutputs(
3202 {op1},
3203 {op2});
3204 // Phase 4: set relaxed execution
3205 model->relaxComputationFloat32toFloat16(true);
3206 assert(model->isValid());
3207 }
3208
is_ignored_dynamic_output_shape_relaxed_dim1_axis0(int i)3209 inline bool is_ignored_dynamic_output_shape_relaxed_dim1_axis0(int i) {
3210 static std::set<int> ignore = {};
3211 return ignore.find(i) != ignore.end();
3212 }
3213
CreateModel_dynamic_output_shape_relaxed_dim1_axis0_neg(Model * model)3214 void CreateModel_dynamic_output_shape_relaxed_dim1_axis0_neg(Model *model) {
3215 OperandType type1(Type::INT32, {});
3216 OperandType type10(Type::TENSOR_FLOAT32, {12});
3217 OperandType type35(Type::TENSOR_FLOAT32, {0});
3218 // Phase 1, operands
3219 auto op1 = model->addOperand(&type10);
3220 auto param = model->addOperand(&type1);
3221 auto axis = model->addOperand(&type1);
3222 auto op2 = model->addOperand(&type35);
3223 // Phase 2, operations
3224 static int32_t param_init[] = {3};
3225 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3226 static int32_t axis_init[] = {-1};
3227 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3228 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3229 // Phase 3, inputs and outputs
3230 model->identifyInputsAndOutputs(
3231 {op1},
3232 {op2});
3233 // Phase 4: set relaxed execution
3234 model->relaxComputationFloat32toFloat16(true);
3235 assert(model->isValid());
3236 }
3237
is_ignored_dynamic_output_shape_relaxed_dim1_axis0_neg(int i)3238 inline bool is_ignored_dynamic_output_shape_relaxed_dim1_axis0_neg(int i) {
3239 static std::set<int> ignore = {};
3240 return ignore.find(i) != ignore.end();
3241 }
3242
CreateModel_dynamic_output_shape_quant8_dim4_axis0(Model * model)3243 void CreateModel_dynamic_output_shape_quant8_dim4_axis0(Model *model) {
3244 OperandType type1(Type::INT32, {});
3245 OperandType type12(Type::TENSOR_QUANT8_ASYMM, {12, 2, 2, 3}, 0.25f, 128);
3246 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3247 // Phase 1, operands
3248 auto op1 = model->addOperand(&type12);
3249 auto param = model->addOperand(&type1);
3250 auto axis = model->addOperand(&type1);
3251 auto op2 = model->addOperand(&type36);
3252 // Phase 2, operations
3253 static int32_t param_init[] = {3};
3254 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3255 static int32_t axis_init[] = {0};
3256 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3257 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3258 // Phase 3, inputs and outputs
3259 model->identifyInputsAndOutputs(
3260 {op1},
3261 {op2});
3262 assert(model->isValid());
3263 }
3264
is_ignored_dynamic_output_shape_quant8_dim4_axis0(int i)3265 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis0(int i) {
3266 static std::set<int> ignore = {};
3267 return ignore.find(i) != ignore.end();
3268 }
3269
CreateModel_dynamic_output_shape_quant8_dim4_axis0_neg(Model * model)3270 void CreateModel_dynamic_output_shape_quant8_dim4_axis0_neg(Model *model) {
3271 OperandType type1(Type::INT32, {});
3272 OperandType type12(Type::TENSOR_QUANT8_ASYMM, {12, 2, 2, 3}, 0.25f, 128);
3273 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3274 // Phase 1, operands
3275 auto op1 = model->addOperand(&type12);
3276 auto param = model->addOperand(&type1);
3277 auto axis = model->addOperand(&type1);
3278 auto op2 = model->addOperand(&type36);
3279 // Phase 2, operations
3280 static int32_t param_init[] = {3};
3281 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3282 static int32_t axis_init[] = {-4};
3283 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3284 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3285 // Phase 3, inputs and outputs
3286 model->identifyInputsAndOutputs(
3287 {op1},
3288 {op2});
3289 assert(model->isValid());
3290 }
3291
is_ignored_dynamic_output_shape_quant8_dim4_axis0_neg(int i)3292 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis0_neg(int i) {
3293 static std::set<int> ignore = {};
3294 return ignore.find(i) != ignore.end();
3295 }
3296
CreateModel_dynamic_output_shape_quant8_dim4_axis1(Model * model)3297 void CreateModel_dynamic_output_shape_quant8_dim4_axis1(Model *model) {
3298 OperandType type1(Type::INT32, {});
3299 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {2, 12, 2, 3}, 0.25f, 128);
3300 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3301 // Phase 1, operands
3302 auto op1 = model->addOperand(&type13);
3303 auto param = model->addOperand(&type1);
3304 auto axis = model->addOperand(&type1);
3305 auto op2 = model->addOperand(&type36);
3306 // Phase 2, operations
3307 static int32_t param_init[] = {3};
3308 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3309 static int32_t axis_init[] = {1};
3310 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3311 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3312 // Phase 3, inputs and outputs
3313 model->identifyInputsAndOutputs(
3314 {op1},
3315 {op2});
3316 assert(model->isValid());
3317 }
3318
is_ignored_dynamic_output_shape_quant8_dim4_axis1(int i)3319 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis1(int i) {
3320 static std::set<int> ignore = {};
3321 return ignore.find(i) != ignore.end();
3322 }
3323
CreateModel_dynamic_output_shape_quant8_dim4_axis1_neg(Model * model)3324 void CreateModel_dynamic_output_shape_quant8_dim4_axis1_neg(Model *model) {
3325 OperandType type1(Type::INT32, {});
3326 OperandType type13(Type::TENSOR_QUANT8_ASYMM, {2, 12, 2, 3}, 0.25f, 128);
3327 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3328 // Phase 1, operands
3329 auto op1 = model->addOperand(&type13);
3330 auto param = model->addOperand(&type1);
3331 auto axis = model->addOperand(&type1);
3332 auto op2 = model->addOperand(&type36);
3333 // Phase 2, operations
3334 static int32_t param_init[] = {3};
3335 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3336 static int32_t axis_init[] = {-3};
3337 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3338 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3339 // Phase 3, inputs and outputs
3340 model->identifyInputsAndOutputs(
3341 {op1},
3342 {op2});
3343 assert(model->isValid());
3344 }
3345
is_ignored_dynamic_output_shape_quant8_dim4_axis1_neg(int i)3346 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis1_neg(int i) {
3347 static std::set<int> ignore = {};
3348 return ignore.find(i) != ignore.end();
3349 }
3350
CreateModel_dynamic_output_shape_quant8_dim4_axis2(Model * model)3351 void CreateModel_dynamic_output_shape_quant8_dim4_axis2(Model *model) {
3352 OperandType type1(Type::INT32, {});
3353 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {2, 2, 12, 3}, 0.25f, 128);
3354 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3355 // Phase 1, operands
3356 auto op1 = model->addOperand(&type14);
3357 auto param = model->addOperand(&type1);
3358 auto axis = model->addOperand(&type1);
3359 auto op2 = model->addOperand(&type36);
3360 // Phase 2, operations
3361 static int32_t param_init[] = {3};
3362 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3363 static int32_t axis_init[] = {2};
3364 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3365 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3366 // Phase 3, inputs and outputs
3367 model->identifyInputsAndOutputs(
3368 {op1},
3369 {op2});
3370 assert(model->isValid());
3371 }
3372
is_ignored_dynamic_output_shape_quant8_dim4_axis2(int i)3373 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis2(int i) {
3374 static std::set<int> ignore = {};
3375 return ignore.find(i) != ignore.end();
3376 }
3377
CreateModel_dynamic_output_shape_quant8_dim4_axis2_neg(Model * model)3378 void CreateModel_dynamic_output_shape_quant8_dim4_axis2_neg(Model *model) {
3379 OperandType type1(Type::INT32, {});
3380 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {2, 2, 12, 3}, 0.25f, 128);
3381 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3382 // Phase 1, operands
3383 auto op1 = model->addOperand(&type14);
3384 auto param = model->addOperand(&type1);
3385 auto axis = model->addOperand(&type1);
3386 auto op2 = model->addOperand(&type36);
3387 // Phase 2, operations
3388 static int32_t param_init[] = {3};
3389 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3390 static int32_t axis_init[] = {-2};
3391 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3392 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3393 // Phase 3, inputs and outputs
3394 model->identifyInputsAndOutputs(
3395 {op1},
3396 {op2});
3397 assert(model->isValid());
3398 }
3399
is_ignored_dynamic_output_shape_quant8_dim4_axis2_neg(int i)3400 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis2_neg(int i) {
3401 static std::set<int> ignore = {};
3402 return ignore.find(i) != ignore.end();
3403 }
3404
CreateModel_dynamic_output_shape_quant8_dim4_axis3(Model * model)3405 void CreateModel_dynamic_output_shape_quant8_dim4_axis3(Model *model) {
3406 OperandType type1(Type::INT32, {});
3407 OperandType type11(Type::TENSOR_QUANT8_ASYMM, {2, 2, 3, 12}, 0.25f, 128);
3408 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3409 // Phase 1, operands
3410 auto op1 = model->addOperand(&type11);
3411 auto param = model->addOperand(&type1);
3412 auto axis = model->addOperand(&type1);
3413 auto op2 = model->addOperand(&type36);
3414 // Phase 2, operations
3415 static int32_t param_init[] = {3};
3416 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3417 static int32_t axis_init[] = {3};
3418 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3419 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3420 // Phase 3, inputs and outputs
3421 model->identifyInputsAndOutputs(
3422 {op1},
3423 {op2});
3424 assert(model->isValid());
3425 }
3426
is_ignored_dynamic_output_shape_quant8_dim4_axis3(int i)3427 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis3(int i) {
3428 static std::set<int> ignore = {};
3429 return ignore.find(i) != ignore.end();
3430 }
3431
CreateModel_dynamic_output_shape_quant8_dim4_axis3_neg(Model * model)3432 void CreateModel_dynamic_output_shape_quant8_dim4_axis3_neg(Model *model) {
3433 OperandType type1(Type::INT32, {});
3434 OperandType type11(Type::TENSOR_QUANT8_ASYMM, {2, 2, 3, 12}, 0.25f, 128);
3435 OperandType type36(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.25f, 128);
3436 // Phase 1, operands
3437 auto op1 = model->addOperand(&type11);
3438 auto param = model->addOperand(&type1);
3439 auto axis = model->addOperand(&type1);
3440 auto op2 = model->addOperand(&type36);
3441 // Phase 2, operations
3442 static int32_t param_init[] = {3};
3443 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3444 static int32_t axis_init[] = {-1};
3445 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3446 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3447 // Phase 3, inputs and outputs
3448 model->identifyInputsAndOutputs(
3449 {op1},
3450 {op2});
3451 assert(model->isValid());
3452 }
3453
is_ignored_dynamic_output_shape_quant8_dim4_axis3_neg(int i)3454 inline bool is_ignored_dynamic_output_shape_quant8_dim4_axis3_neg(int i) {
3455 static std::set<int> ignore = {};
3456 return ignore.find(i) != ignore.end();
3457 }
3458
CreateModel_dynamic_output_shape_quant8_dim3_axis0(Model * model)3459 void CreateModel_dynamic_output_shape_quant8_dim3_axis0(Model *model) {
3460 OperandType type1(Type::INT32, {});
3461 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {12, 2, 3}, 0.25f, 128);
3462 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0}, 0.25f, 128);
3463 // Phase 1, operands
3464 auto op1 = model->addOperand(&type15);
3465 auto param = model->addOperand(&type1);
3466 auto axis = model->addOperand(&type1);
3467 auto op2 = model->addOperand(&type37);
3468 // Phase 2, operations
3469 static int32_t param_init[] = {3};
3470 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3471 static int32_t axis_init[] = {0};
3472 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3473 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3474 // Phase 3, inputs and outputs
3475 model->identifyInputsAndOutputs(
3476 {op1},
3477 {op2});
3478 assert(model->isValid());
3479 }
3480
is_ignored_dynamic_output_shape_quant8_dim3_axis0(int i)3481 inline bool is_ignored_dynamic_output_shape_quant8_dim3_axis0(int i) {
3482 static std::set<int> ignore = {};
3483 return ignore.find(i) != ignore.end();
3484 }
3485
CreateModel_dynamic_output_shape_quant8_dim3_axis0_neg(Model * model)3486 void CreateModel_dynamic_output_shape_quant8_dim3_axis0_neg(Model *model) {
3487 OperandType type1(Type::INT32, {});
3488 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {12, 2, 3}, 0.25f, 128);
3489 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0}, 0.25f, 128);
3490 // Phase 1, operands
3491 auto op1 = model->addOperand(&type15);
3492 auto param = model->addOperand(&type1);
3493 auto axis = model->addOperand(&type1);
3494 auto op2 = model->addOperand(&type37);
3495 // Phase 2, operations
3496 static int32_t param_init[] = {3};
3497 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3498 static int32_t axis_init[] = {-3};
3499 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3500 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3501 // Phase 3, inputs and outputs
3502 model->identifyInputsAndOutputs(
3503 {op1},
3504 {op2});
3505 assert(model->isValid());
3506 }
3507
is_ignored_dynamic_output_shape_quant8_dim3_axis0_neg(int i)3508 inline bool is_ignored_dynamic_output_shape_quant8_dim3_axis0_neg(int i) {
3509 static std::set<int> ignore = {};
3510 return ignore.find(i) != ignore.end();
3511 }
3512
CreateModel_dynamic_output_shape_quant8_dim3_axis1(Model * model)3513 void CreateModel_dynamic_output_shape_quant8_dim3_axis1(Model *model) {
3514 OperandType type1(Type::INT32, {});
3515 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {2, 12, 3}, 0.25f, 128);
3516 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0}, 0.25f, 128);
3517 // Phase 1, operands
3518 auto op1 = model->addOperand(&type16);
3519 auto param = model->addOperand(&type1);
3520 auto axis = model->addOperand(&type1);
3521 auto op2 = model->addOperand(&type37);
3522 // Phase 2, operations
3523 static int32_t param_init[] = {3};
3524 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3525 static int32_t axis_init[] = {1};
3526 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3527 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3528 // Phase 3, inputs and outputs
3529 model->identifyInputsAndOutputs(
3530 {op1},
3531 {op2});
3532 assert(model->isValid());
3533 }
3534
is_ignored_dynamic_output_shape_quant8_dim3_axis1(int i)3535 inline bool is_ignored_dynamic_output_shape_quant8_dim3_axis1(int i) {
3536 static std::set<int> ignore = {};
3537 return ignore.find(i) != ignore.end();
3538 }
3539
CreateModel_dynamic_output_shape_quant8_dim3_axis1_neg(Model * model)3540 void CreateModel_dynamic_output_shape_quant8_dim3_axis1_neg(Model *model) {
3541 OperandType type1(Type::INT32, {});
3542 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {2, 12, 3}, 0.25f, 128);
3543 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0}, 0.25f, 128);
3544 // Phase 1, operands
3545 auto op1 = model->addOperand(&type16);
3546 auto param = model->addOperand(&type1);
3547 auto axis = model->addOperand(&type1);
3548 auto op2 = model->addOperand(&type37);
3549 // Phase 2, operations
3550 static int32_t param_init[] = {3};
3551 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3552 static int32_t axis_init[] = {-2};
3553 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3554 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3555 // Phase 3, inputs and outputs
3556 model->identifyInputsAndOutputs(
3557 {op1},
3558 {op2});
3559 assert(model->isValid());
3560 }
3561
is_ignored_dynamic_output_shape_quant8_dim3_axis1_neg(int i)3562 inline bool is_ignored_dynamic_output_shape_quant8_dim3_axis1_neg(int i) {
3563 static std::set<int> ignore = {};
3564 return ignore.find(i) != ignore.end();
3565 }
3566
CreateModel_dynamic_output_shape_quant8_dim3_axis2(Model * model)3567 void CreateModel_dynamic_output_shape_quant8_dim3_axis2(Model *model) {
3568 OperandType type1(Type::INT32, {});
3569 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {2, 3, 12}, 0.25f, 128);
3570 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0}, 0.25f, 128);
3571 // Phase 1, operands
3572 auto op1 = model->addOperand(&type17);
3573 auto param = model->addOperand(&type1);
3574 auto axis = model->addOperand(&type1);
3575 auto op2 = model->addOperand(&type37);
3576 // Phase 2, operations
3577 static int32_t param_init[] = {3};
3578 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3579 static int32_t axis_init[] = {2};
3580 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3581 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3582 // Phase 3, inputs and outputs
3583 model->identifyInputsAndOutputs(
3584 {op1},
3585 {op2});
3586 assert(model->isValid());
3587 }
3588
is_ignored_dynamic_output_shape_quant8_dim3_axis2(int i)3589 inline bool is_ignored_dynamic_output_shape_quant8_dim3_axis2(int i) {
3590 static std::set<int> ignore = {};
3591 return ignore.find(i) != ignore.end();
3592 }
3593
CreateModel_dynamic_output_shape_quant8_dim3_axis2_neg(Model * model)3594 void CreateModel_dynamic_output_shape_quant8_dim3_axis2_neg(Model *model) {
3595 OperandType type1(Type::INT32, {});
3596 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {2, 3, 12}, 0.25f, 128);
3597 OperandType type37(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0}, 0.25f, 128);
3598 // Phase 1, operands
3599 auto op1 = model->addOperand(&type17);
3600 auto param = model->addOperand(&type1);
3601 auto axis = model->addOperand(&type1);
3602 auto op2 = model->addOperand(&type37);
3603 // Phase 2, operations
3604 static int32_t param_init[] = {3};
3605 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3606 static int32_t axis_init[] = {-1};
3607 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3608 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3609 // Phase 3, inputs and outputs
3610 model->identifyInputsAndOutputs(
3611 {op1},
3612 {op2});
3613 assert(model->isValid());
3614 }
3615
is_ignored_dynamic_output_shape_quant8_dim3_axis2_neg(int i)3616 inline bool is_ignored_dynamic_output_shape_quant8_dim3_axis2_neg(int i) {
3617 static std::set<int> ignore = {};
3618 return ignore.find(i) != ignore.end();
3619 }
3620
CreateModel_dynamic_output_shape_quant8_dim2_axis0(Model * model)3621 void CreateModel_dynamic_output_shape_quant8_dim2_axis0(Model *model) {
3622 OperandType type1(Type::INT32, {});
3623 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {12, 3}, 0.25f, 128);
3624 OperandType type38(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.25f, 128);
3625 // Phase 1, operands
3626 auto op1 = model->addOperand(&type18);
3627 auto param = model->addOperand(&type1);
3628 auto axis = model->addOperand(&type1);
3629 auto op2 = model->addOperand(&type38);
3630 // Phase 2, operations
3631 static int32_t param_init[] = {3};
3632 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3633 static int32_t axis_init[] = {0};
3634 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3635 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3636 // Phase 3, inputs and outputs
3637 model->identifyInputsAndOutputs(
3638 {op1},
3639 {op2});
3640 assert(model->isValid());
3641 }
3642
is_ignored_dynamic_output_shape_quant8_dim2_axis0(int i)3643 inline bool is_ignored_dynamic_output_shape_quant8_dim2_axis0(int i) {
3644 static std::set<int> ignore = {};
3645 return ignore.find(i) != ignore.end();
3646 }
3647
CreateModel_dynamic_output_shape_quant8_dim2_axis0_neg(Model * model)3648 void CreateModel_dynamic_output_shape_quant8_dim2_axis0_neg(Model *model) {
3649 OperandType type1(Type::INT32, {});
3650 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {12, 3}, 0.25f, 128);
3651 OperandType type38(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.25f, 128);
3652 // Phase 1, operands
3653 auto op1 = model->addOperand(&type18);
3654 auto param = model->addOperand(&type1);
3655 auto axis = model->addOperand(&type1);
3656 auto op2 = model->addOperand(&type38);
3657 // Phase 2, operations
3658 static int32_t param_init[] = {3};
3659 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3660 static int32_t axis_init[] = {-2};
3661 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3662 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3663 // Phase 3, inputs and outputs
3664 model->identifyInputsAndOutputs(
3665 {op1},
3666 {op2});
3667 assert(model->isValid());
3668 }
3669
is_ignored_dynamic_output_shape_quant8_dim2_axis0_neg(int i)3670 inline bool is_ignored_dynamic_output_shape_quant8_dim2_axis0_neg(int i) {
3671 static std::set<int> ignore = {};
3672 return ignore.find(i) != ignore.end();
3673 }
3674
CreateModel_dynamic_output_shape_quant8_dim2_axis1(Model * model)3675 void CreateModel_dynamic_output_shape_quant8_dim2_axis1(Model *model) {
3676 OperandType type1(Type::INT32, {});
3677 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {3, 12}, 0.25f, 128);
3678 OperandType type38(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.25f, 128);
3679 // Phase 1, operands
3680 auto op1 = model->addOperand(&type19);
3681 auto param = model->addOperand(&type1);
3682 auto axis = model->addOperand(&type1);
3683 auto op2 = model->addOperand(&type38);
3684 // Phase 2, operations
3685 static int32_t param_init[] = {3};
3686 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3687 static int32_t axis_init[] = {1};
3688 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3689 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3690 // Phase 3, inputs and outputs
3691 model->identifyInputsAndOutputs(
3692 {op1},
3693 {op2});
3694 assert(model->isValid());
3695 }
3696
is_ignored_dynamic_output_shape_quant8_dim2_axis1(int i)3697 inline bool is_ignored_dynamic_output_shape_quant8_dim2_axis1(int i) {
3698 static std::set<int> ignore = {};
3699 return ignore.find(i) != ignore.end();
3700 }
3701
CreateModel_dynamic_output_shape_quant8_dim2_axis1_neg(Model * model)3702 void CreateModel_dynamic_output_shape_quant8_dim2_axis1_neg(Model *model) {
3703 OperandType type1(Type::INT32, {});
3704 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {3, 12}, 0.25f, 128);
3705 OperandType type38(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 0.25f, 128);
3706 // Phase 1, operands
3707 auto op1 = model->addOperand(&type19);
3708 auto param = model->addOperand(&type1);
3709 auto axis = model->addOperand(&type1);
3710 auto op2 = model->addOperand(&type38);
3711 // Phase 2, operations
3712 static int32_t param_init[] = {3};
3713 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3714 static int32_t axis_init[] = {-1};
3715 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3716 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3717 // Phase 3, inputs and outputs
3718 model->identifyInputsAndOutputs(
3719 {op1},
3720 {op2});
3721 assert(model->isValid());
3722 }
3723
is_ignored_dynamic_output_shape_quant8_dim2_axis1_neg(int i)3724 inline bool is_ignored_dynamic_output_shape_quant8_dim2_axis1_neg(int i) {
3725 static std::set<int> ignore = {};
3726 return ignore.find(i) != ignore.end();
3727 }
3728
CreateModel_dynamic_output_shape_quant8_dim1_axis0(Model * model)3729 void CreateModel_dynamic_output_shape_quant8_dim1_axis0(Model *model) {
3730 OperandType type1(Type::INT32, {});
3731 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {12}, 0.25f, 128);
3732 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0}, 0.25f, 128);
3733 // Phase 1, operands
3734 auto op1 = model->addOperand(&type20);
3735 auto param = model->addOperand(&type1);
3736 auto axis = model->addOperand(&type1);
3737 auto op2 = model->addOperand(&type39);
3738 // Phase 2, operations
3739 static int32_t param_init[] = {3};
3740 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3741 static int32_t axis_init[] = {0};
3742 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3743 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3744 // Phase 3, inputs and outputs
3745 model->identifyInputsAndOutputs(
3746 {op1},
3747 {op2});
3748 assert(model->isValid());
3749 }
3750
is_ignored_dynamic_output_shape_quant8_dim1_axis0(int i)3751 inline bool is_ignored_dynamic_output_shape_quant8_dim1_axis0(int i) {
3752 static std::set<int> ignore = {};
3753 return ignore.find(i) != ignore.end();
3754 }
3755
CreateModel_dynamic_output_shape_quant8_dim1_axis0_neg(Model * model)3756 void CreateModel_dynamic_output_shape_quant8_dim1_axis0_neg(Model *model) {
3757 OperandType type1(Type::INT32, {});
3758 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {12}, 0.25f, 128);
3759 OperandType type39(Type::TENSOR_QUANT8_ASYMM, {0}, 0.25f, 128);
3760 // Phase 1, operands
3761 auto op1 = model->addOperand(&type20);
3762 auto param = model->addOperand(&type1);
3763 auto axis = model->addOperand(&type1);
3764 auto op2 = model->addOperand(&type39);
3765 // Phase 2, operations
3766 static int32_t param_init[] = {3};
3767 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3768 static int32_t axis_init[] = {-1};
3769 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3770 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3771 // Phase 3, inputs and outputs
3772 model->identifyInputsAndOutputs(
3773 {op1},
3774 {op2});
3775 assert(model->isValid());
3776 }
3777
is_ignored_dynamic_output_shape_quant8_dim1_axis0_neg(int i)3778 inline bool is_ignored_dynamic_output_shape_quant8_dim1_axis0_neg(int i) {
3779 static std::set<int> ignore = {};
3780 return ignore.find(i) != ignore.end();
3781 }
3782
CreateModel_dynamic_output_shape_float16_dim4_axis0(Model * model)3783 void CreateModel_dynamic_output_shape_float16_dim4_axis0(Model *model) {
3784 OperandType type1(Type::INT32, {});
3785 OperandType type22(Type::TENSOR_FLOAT16, {12, 2, 2, 3});
3786 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3787 // Phase 1, operands
3788 auto op1 = model->addOperand(&type22);
3789 auto param = model->addOperand(&type1);
3790 auto axis = model->addOperand(&type1);
3791 auto op2 = model->addOperand(&type40);
3792 // Phase 2, operations
3793 static int32_t param_init[] = {3};
3794 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3795 static int32_t axis_init[] = {0};
3796 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3797 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3798 // Phase 3, inputs and outputs
3799 model->identifyInputsAndOutputs(
3800 {op1},
3801 {op2});
3802 assert(model->isValid());
3803 }
3804
is_ignored_dynamic_output_shape_float16_dim4_axis0(int i)3805 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis0(int i) {
3806 static std::set<int> ignore = {};
3807 return ignore.find(i) != ignore.end();
3808 }
3809
CreateModel_dynamic_output_shape_float16_dim4_axis0_neg(Model * model)3810 void CreateModel_dynamic_output_shape_float16_dim4_axis0_neg(Model *model) {
3811 OperandType type1(Type::INT32, {});
3812 OperandType type22(Type::TENSOR_FLOAT16, {12, 2, 2, 3});
3813 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3814 // Phase 1, operands
3815 auto op1 = model->addOperand(&type22);
3816 auto param = model->addOperand(&type1);
3817 auto axis = model->addOperand(&type1);
3818 auto op2 = model->addOperand(&type40);
3819 // Phase 2, operations
3820 static int32_t param_init[] = {3};
3821 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3822 static int32_t axis_init[] = {-4};
3823 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3824 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3825 // Phase 3, inputs and outputs
3826 model->identifyInputsAndOutputs(
3827 {op1},
3828 {op2});
3829 assert(model->isValid());
3830 }
3831
is_ignored_dynamic_output_shape_float16_dim4_axis0_neg(int i)3832 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis0_neg(int i) {
3833 static std::set<int> ignore = {};
3834 return ignore.find(i) != ignore.end();
3835 }
3836
CreateModel_dynamic_output_shape_float16_dim4_axis1(Model * model)3837 void CreateModel_dynamic_output_shape_float16_dim4_axis1(Model *model) {
3838 OperandType type1(Type::INT32, {});
3839 OperandType type23(Type::TENSOR_FLOAT16, {2, 12, 2, 3});
3840 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3841 // Phase 1, operands
3842 auto op1 = model->addOperand(&type23);
3843 auto param = model->addOperand(&type1);
3844 auto axis = model->addOperand(&type1);
3845 auto op2 = model->addOperand(&type40);
3846 // Phase 2, operations
3847 static int32_t param_init[] = {3};
3848 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3849 static int32_t axis_init[] = {1};
3850 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3851 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3852 // Phase 3, inputs and outputs
3853 model->identifyInputsAndOutputs(
3854 {op1},
3855 {op2});
3856 assert(model->isValid());
3857 }
3858
is_ignored_dynamic_output_shape_float16_dim4_axis1(int i)3859 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis1(int i) {
3860 static std::set<int> ignore = {};
3861 return ignore.find(i) != ignore.end();
3862 }
3863
CreateModel_dynamic_output_shape_float16_dim4_axis1_neg(Model * model)3864 void CreateModel_dynamic_output_shape_float16_dim4_axis1_neg(Model *model) {
3865 OperandType type1(Type::INT32, {});
3866 OperandType type23(Type::TENSOR_FLOAT16, {2, 12, 2, 3});
3867 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3868 // Phase 1, operands
3869 auto op1 = model->addOperand(&type23);
3870 auto param = model->addOperand(&type1);
3871 auto axis = model->addOperand(&type1);
3872 auto op2 = model->addOperand(&type40);
3873 // Phase 2, operations
3874 static int32_t param_init[] = {3};
3875 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3876 static int32_t axis_init[] = {-3};
3877 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3878 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3879 // Phase 3, inputs and outputs
3880 model->identifyInputsAndOutputs(
3881 {op1},
3882 {op2});
3883 assert(model->isValid());
3884 }
3885
is_ignored_dynamic_output_shape_float16_dim4_axis1_neg(int i)3886 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis1_neg(int i) {
3887 static std::set<int> ignore = {};
3888 return ignore.find(i) != ignore.end();
3889 }
3890
CreateModel_dynamic_output_shape_float16_dim4_axis2(Model * model)3891 void CreateModel_dynamic_output_shape_float16_dim4_axis2(Model *model) {
3892 OperandType type1(Type::INT32, {});
3893 OperandType type24(Type::TENSOR_FLOAT16, {2, 2, 12, 3});
3894 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3895 // Phase 1, operands
3896 auto op1 = model->addOperand(&type24);
3897 auto param = model->addOperand(&type1);
3898 auto axis = model->addOperand(&type1);
3899 auto op2 = model->addOperand(&type40);
3900 // Phase 2, operations
3901 static int32_t param_init[] = {3};
3902 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3903 static int32_t axis_init[] = {2};
3904 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3905 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3906 // Phase 3, inputs and outputs
3907 model->identifyInputsAndOutputs(
3908 {op1},
3909 {op2});
3910 assert(model->isValid());
3911 }
3912
is_ignored_dynamic_output_shape_float16_dim4_axis2(int i)3913 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis2(int i) {
3914 static std::set<int> ignore = {};
3915 return ignore.find(i) != ignore.end();
3916 }
3917
CreateModel_dynamic_output_shape_float16_dim4_axis2_neg(Model * model)3918 void CreateModel_dynamic_output_shape_float16_dim4_axis2_neg(Model *model) {
3919 OperandType type1(Type::INT32, {});
3920 OperandType type24(Type::TENSOR_FLOAT16, {2, 2, 12, 3});
3921 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3922 // Phase 1, operands
3923 auto op1 = model->addOperand(&type24);
3924 auto param = model->addOperand(&type1);
3925 auto axis = model->addOperand(&type1);
3926 auto op2 = model->addOperand(&type40);
3927 // Phase 2, operations
3928 static int32_t param_init[] = {3};
3929 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3930 static int32_t axis_init[] = {-2};
3931 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3932 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3933 // Phase 3, inputs and outputs
3934 model->identifyInputsAndOutputs(
3935 {op1},
3936 {op2});
3937 assert(model->isValid());
3938 }
3939
is_ignored_dynamic_output_shape_float16_dim4_axis2_neg(int i)3940 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis2_neg(int i) {
3941 static std::set<int> ignore = {};
3942 return ignore.find(i) != ignore.end();
3943 }
3944
CreateModel_dynamic_output_shape_float16_dim4_axis3(Model * model)3945 void CreateModel_dynamic_output_shape_float16_dim4_axis3(Model *model) {
3946 OperandType type1(Type::INT32, {});
3947 OperandType type25(Type::TENSOR_FLOAT16, {2, 2, 3, 12});
3948 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3949 // Phase 1, operands
3950 auto op1 = model->addOperand(&type25);
3951 auto param = model->addOperand(&type1);
3952 auto axis = model->addOperand(&type1);
3953 auto op2 = model->addOperand(&type40);
3954 // Phase 2, operations
3955 static int32_t param_init[] = {3};
3956 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3957 static int32_t axis_init[] = {3};
3958 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3959 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3960 // Phase 3, inputs and outputs
3961 model->identifyInputsAndOutputs(
3962 {op1},
3963 {op2});
3964 assert(model->isValid());
3965 }
3966
is_ignored_dynamic_output_shape_float16_dim4_axis3(int i)3967 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis3(int i) {
3968 static std::set<int> ignore = {};
3969 return ignore.find(i) != ignore.end();
3970 }
3971
CreateModel_dynamic_output_shape_float16_dim4_axis3_neg(Model * model)3972 void CreateModel_dynamic_output_shape_float16_dim4_axis3_neg(Model *model) {
3973 OperandType type1(Type::INT32, {});
3974 OperandType type25(Type::TENSOR_FLOAT16, {2, 2, 3, 12});
3975 OperandType type40(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
3976 // Phase 1, operands
3977 auto op1 = model->addOperand(&type25);
3978 auto param = model->addOperand(&type1);
3979 auto axis = model->addOperand(&type1);
3980 auto op2 = model->addOperand(&type40);
3981 // Phase 2, operations
3982 static int32_t param_init[] = {3};
3983 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
3984 static int32_t axis_init[] = {-1};
3985 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
3986 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
3987 // Phase 3, inputs and outputs
3988 model->identifyInputsAndOutputs(
3989 {op1},
3990 {op2});
3991 assert(model->isValid());
3992 }
3993
is_ignored_dynamic_output_shape_float16_dim4_axis3_neg(int i)3994 inline bool is_ignored_dynamic_output_shape_float16_dim4_axis3_neg(int i) {
3995 static std::set<int> ignore = {};
3996 return ignore.find(i) != ignore.end();
3997 }
3998
CreateModel_dynamic_output_shape_float16_dim3_axis0(Model * model)3999 void CreateModel_dynamic_output_shape_float16_dim3_axis0(Model *model) {
4000 OperandType type1(Type::INT32, {});
4001 OperandType type26(Type::TENSOR_FLOAT16, {12, 2, 3});
4002 OperandType type41(Type::TENSOR_FLOAT16, {0, 0, 0});
4003 // Phase 1, operands
4004 auto op1 = model->addOperand(&type26);
4005 auto param = model->addOperand(&type1);
4006 auto axis = model->addOperand(&type1);
4007 auto op2 = model->addOperand(&type41);
4008 // Phase 2, operations
4009 static int32_t param_init[] = {3};
4010 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4011 static int32_t axis_init[] = {0};
4012 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4013 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4014 // Phase 3, inputs and outputs
4015 model->identifyInputsAndOutputs(
4016 {op1},
4017 {op2});
4018 assert(model->isValid());
4019 }
4020
is_ignored_dynamic_output_shape_float16_dim3_axis0(int i)4021 inline bool is_ignored_dynamic_output_shape_float16_dim3_axis0(int i) {
4022 static std::set<int> ignore = {};
4023 return ignore.find(i) != ignore.end();
4024 }
4025
CreateModel_dynamic_output_shape_float16_dim3_axis0_neg(Model * model)4026 void CreateModel_dynamic_output_shape_float16_dim3_axis0_neg(Model *model) {
4027 OperandType type1(Type::INT32, {});
4028 OperandType type26(Type::TENSOR_FLOAT16, {12, 2, 3});
4029 OperandType type41(Type::TENSOR_FLOAT16, {0, 0, 0});
4030 // Phase 1, operands
4031 auto op1 = model->addOperand(&type26);
4032 auto param = model->addOperand(&type1);
4033 auto axis = model->addOperand(&type1);
4034 auto op2 = model->addOperand(&type41);
4035 // Phase 2, operations
4036 static int32_t param_init[] = {3};
4037 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4038 static int32_t axis_init[] = {-3};
4039 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4040 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4041 // Phase 3, inputs and outputs
4042 model->identifyInputsAndOutputs(
4043 {op1},
4044 {op2});
4045 assert(model->isValid());
4046 }
4047
is_ignored_dynamic_output_shape_float16_dim3_axis0_neg(int i)4048 inline bool is_ignored_dynamic_output_shape_float16_dim3_axis0_neg(int i) {
4049 static std::set<int> ignore = {};
4050 return ignore.find(i) != ignore.end();
4051 }
4052
CreateModel_dynamic_output_shape_float16_dim3_axis1(Model * model)4053 void CreateModel_dynamic_output_shape_float16_dim3_axis1(Model *model) {
4054 OperandType type1(Type::INT32, {});
4055 OperandType type27(Type::TENSOR_FLOAT16, {2, 12, 3});
4056 OperandType type41(Type::TENSOR_FLOAT16, {0, 0, 0});
4057 // Phase 1, operands
4058 auto op1 = model->addOperand(&type27);
4059 auto param = model->addOperand(&type1);
4060 auto axis = model->addOperand(&type1);
4061 auto op2 = model->addOperand(&type41);
4062 // Phase 2, operations
4063 static int32_t param_init[] = {3};
4064 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4065 static int32_t axis_init[] = {1};
4066 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4067 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4068 // Phase 3, inputs and outputs
4069 model->identifyInputsAndOutputs(
4070 {op1},
4071 {op2});
4072 assert(model->isValid());
4073 }
4074
is_ignored_dynamic_output_shape_float16_dim3_axis1(int i)4075 inline bool is_ignored_dynamic_output_shape_float16_dim3_axis1(int i) {
4076 static std::set<int> ignore = {};
4077 return ignore.find(i) != ignore.end();
4078 }
4079
CreateModel_dynamic_output_shape_float16_dim3_axis1_neg(Model * model)4080 void CreateModel_dynamic_output_shape_float16_dim3_axis1_neg(Model *model) {
4081 OperandType type1(Type::INT32, {});
4082 OperandType type27(Type::TENSOR_FLOAT16, {2, 12, 3});
4083 OperandType type41(Type::TENSOR_FLOAT16, {0, 0, 0});
4084 // Phase 1, operands
4085 auto op1 = model->addOperand(&type27);
4086 auto param = model->addOperand(&type1);
4087 auto axis = model->addOperand(&type1);
4088 auto op2 = model->addOperand(&type41);
4089 // Phase 2, operations
4090 static int32_t param_init[] = {3};
4091 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4092 static int32_t axis_init[] = {-2};
4093 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4094 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4095 // Phase 3, inputs and outputs
4096 model->identifyInputsAndOutputs(
4097 {op1},
4098 {op2});
4099 assert(model->isValid());
4100 }
4101
is_ignored_dynamic_output_shape_float16_dim3_axis1_neg(int i)4102 inline bool is_ignored_dynamic_output_shape_float16_dim3_axis1_neg(int i) {
4103 static std::set<int> ignore = {};
4104 return ignore.find(i) != ignore.end();
4105 }
4106
CreateModel_dynamic_output_shape_float16_dim3_axis2(Model * model)4107 void CreateModel_dynamic_output_shape_float16_dim3_axis2(Model *model) {
4108 OperandType type1(Type::INT32, {});
4109 OperandType type28(Type::TENSOR_FLOAT16, {2, 3, 12});
4110 OperandType type41(Type::TENSOR_FLOAT16, {0, 0, 0});
4111 // Phase 1, operands
4112 auto op1 = model->addOperand(&type28);
4113 auto param = model->addOperand(&type1);
4114 auto axis = model->addOperand(&type1);
4115 auto op2 = model->addOperand(&type41);
4116 // Phase 2, operations
4117 static int32_t param_init[] = {3};
4118 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4119 static int32_t axis_init[] = {2};
4120 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4121 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4122 // Phase 3, inputs and outputs
4123 model->identifyInputsAndOutputs(
4124 {op1},
4125 {op2});
4126 assert(model->isValid());
4127 }
4128
is_ignored_dynamic_output_shape_float16_dim3_axis2(int i)4129 inline bool is_ignored_dynamic_output_shape_float16_dim3_axis2(int i) {
4130 static std::set<int> ignore = {};
4131 return ignore.find(i) != ignore.end();
4132 }
4133
CreateModel_dynamic_output_shape_float16_dim3_axis2_neg(Model * model)4134 void CreateModel_dynamic_output_shape_float16_dim3_axis2_neg(Model *model) {
4135 OperandType type1(Type::INT32, {});
4136 OperandType type28(Type::TENSOR_FLOAT16, {2, 3, 12});
4137 OperandType type41(Type::TENSOR_FLOAT16, {0, 0, 0});
4138 // Phase 1, operands
4139 auto op1 = model->addOperand(&type28);
4140 auto param = model->addOperand(&type1);
4141 auto axis = model->addOperand(&type1);
4142 auto op2 = model->addOperand(&type41);
4143 // Phase 2, operations
4144 static int32_t param_init[] = {3};
4145 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4146 static int32_t axis_init[] = {-1};
4147 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4148 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4149 // Phase 3, inputs and outputs
4150 model->identifyInputsAndOutputs(
4151 {op1},
4152 {op2});
4153 assert(model->isValid());
4154 }
4155
is_ignored_dynamic_output_shape_float16_dim3_axis2_neg(int i)4156 inline bool is_ignored_dynamic_output_shape_float16_dim3_axis2_neg(int i) {
4157 static std::set<int> ignore = {};
4158 return ignore.find(i) != ignore.end();
4159 }
4160
CreateModel_dynamic_output_shape_float16_dim2_axis0(Model * model)4161 void CreateModel_dynamic_output_shape_float16_dim2_axis0(Model *model) {
4162 OperandType type1(Type::INT32, {});
4163 OperandType type29(Type::TENSOR_FLOAT16, {12, 3});
4164 OperandType type42(Type::TENSOR_FLOAT16, {0, 0});
4165 // Phase 1, operands
4166 auto op1 = model->addOperand(&type29);
4167 auto param = model->addOperand(&type1);
4168 auto axis = model->addOperand(&type1);
4169 auto op2 = model->addOperand(&type42);
4170 // Phase 2, operations
4171 static int32_t param_init[] = {3};
4172 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4173 static int32_t axis_init[] = {0};
4174 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4175 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4176 // Phase 3, inputs and outputs
4177 model->identifyInputsAndOutputs(
4178 {op1},
4179 {op2});
4180 assert(model->isValid());
4181 }
4182
is_ignored_dynamic_output_shape_float16_dim2_axis0(int i)4183 inline bool is_ignored_dynamic_output_shape_float16_dim2_axis0(int i) {
4184 static std::set<int> ignore = {};
4185 return ignore.find(i) != ignore.end();
4186 }
4187
CreateModel_dynamic_output_shape_float16_dim2_axis0_neg(Model * model)4188 void CreateModel_dynamic_output_shape_float16_dim2_axis0_neg(Model *model) {
4189 OperandType type1(Type::INT32, {});
4190 OperandType type29(Type::TENSOR_FLOAT16, {12, 3});
4191 OperandType type42(Type::TENSOR_FLOAT16, {0, 0});
4192 // Phase 1, operands
4193 auto op1 = model->addOperand(&type29);
4194 auto param = model->addOperand(&type1);
4195 auto axis = model->addOperand(&type1);
4196 auto op2 = model->addOperand(&type42);
4197 // Phase 2, operations
4198 static int32_t param_init[] = {3};
4199 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4200 static int32_t axis_init[] = {-2};
4201 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4202 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4203 // Phase 3, inputs and outputs
4204 model->identifyInputsAndOutputs(
4205 {op1},
4206 {op2});
4207 assert(model->isValid());
4208 }
4209
is_ignored_dynamic_output_shape_float16_dim2_axis0_neg(int i)4210 inline bool is_ignored_dynamic_output_shape_float16_dim2_axis0_neg(int i) {
4211 static std::set<int> ignore = {};
4212 return ignore.find(i) != ignore.end();
4213 }
4214
CreateModel_dynamic_output_shape_float16_dim2_axis1(Model * model)4215 void CreateModel_dynamic_output_shape_float16_dim2_axis1(Model *model) {
4216 OperandType type1(Type::INT32, {});
4217 OperandType type30(Type::TENSOR_FLOAT16, {3, 12});
4218 OperandType type42(Type::TENSOR_FLOAT16, {0, 0});
4219 // Phase 1, operands
4220 auto op1 = model->addOperand(&type30);
4221 auto param = model->addOperand(&type1);
4222 auto axis = model->addOperand(&type1);
4223 auto op2 = model->addOperand(&type42);
4224 // Phase 2, operations
4225 static int32_t param_init[] = {3};
4226 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4227 static int32_t axis_init[] = {1};
4228 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4229 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4230 // Phase 3, inputs and outputs
4231 model->identifyInputsAndOutputs(
4232 {op1},
4233 {op2});
4234 assert(model->isValid());
4235 }
4236
is_ignored_dynamic_output_shape_float16_dim2_axis1(int i)4237 inline bool is_ignored_dynamic_output_shape_float16_dim2_axis1(int i) {
4238 static std::set<int> ignore = {};
4239 return ignore.find(i) != ignore.end();
4240 }
4241
CreateModel_dynamic_output_shape_float16_dim2_axis1_neg(Model * model)4242 void CreateModel_dynamic_output_shape_float16_dim2_axis1_neg(Model *model) {
4243 OperandType type1(Type::INT32, {});
4244 OperandType type30(Type::TENSOR_FLOAT16, {3, 12});
4245 OperandType type42(Type::TENSOR_FLOAT16, {0, 0});
4246 // Phase 1, operands
4247 auto op1 = model->addOperand(&type30);
4248 auto param = model->addOperand(&type1);
4249 auto axis = model->addOperand(&type1);
4250 auto op2 = model->addOperand(&type42);
4251 // Phase 2, operations
4252 static int32_t param_init[] = {3};
4253 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4254 static int32_t axis_init[] = {-1};
4255 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4256 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4257 // Phase 3, inputs and outputs
4258 model->identifyInputsAndOutputs(
4259 {op1},
4260 {op2});
4261 assert(model->isValid());
4262 }
4263
is_ignored_dynamic_output_shape_float16_dim2_axis1_neg(int i)4264 inline bool is_ignored_dynamic_output_shape_float16_dim2_axis1_neg(int i) {
4265 static std::set<int> ignore = {};
4266 return ignore.find(i) != ignore.end();
4267 }
4268
CreateModel_dynamic_output_shape_float16_dim1_axis0(Model * model)4269 void CreateModel_dynamic_output_shape_float16_dim1_axis0(Model *model) {
4270 OperandType type1(Type::INT32, {});
4271 OperandType type31(Type::TENSOR_FLOAT16, {12});
4272 OperandType type43(Type::TENSOR_FLOAT16, {0});
4273 // Phase 1, operands
4274 auto op1 = model->addOperand(&type31);
4275 auto param = model->addOperand(&type1);
4276 auto axis = model->addOperand(&type1);
4277 auto op2 = model->addOperand(&type43);
4278 // Phase 2, operations
4279 static int32_t param_init[] = {3};
4280 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4281 static int32_t axis_init[] = {0};
4282 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4283 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4284 // Phase 3, inputs and outputs
4285 model->identifyInputsAndOutputs(
4286 {op1},
4287 {op2});
4288 assert(model->isValid());
4289 }
4290
is_ignored_dynamic_output_shape_float16_dim1_axis0(int i)4291 inline bool is_ignored_dynamic_output_shape_float16_dim1_axis0(int i) {
4292 static std::set<int> ignore = {};
4293 return ignore.find(i) != ignore.end();
4294 }
4295
CreateModel_dynamic_output_shape_float16_dim1_axis0_neg(Model * model)4296 void CreateModel_dynamic_output_shape_float16_dim1_axis0_neg(Model *model) {
4297 OperandType type1(Type::INT32, {});
4298 OperandType type31(Type::TENSOR_FLOAT16, {12});
4299 OperandType type43(Type::TENSOR_FLOAT16, {0});
4300 // Phase 1, operands
4301 auto op1 = model->addOperand(&type31);
4302 auto param = model->addOperand(&type1);
4303 auto axis = model->addOperand(&type1);
4304 auto op2 = model->addOperand(&type43);
4305 // Phase 2, operations
4306 static int32_t param_init[] = {3};
4307 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
4308 static int32_t axis_init[] = {-1};
4309 model->setOperandValue(axis, axis_init, sizeof(int32_t) * 1);
4310 model->addOperation(ANEURALNETWORKS_CHANNEL_SHUFFLE, {op1, param, axis}, {op2});
4311 // Phase 3, inputs and outputs
4312 model->identifyInputsAndOutputs(
4313 {op1},
4314 {op2});
4315 assert(model->isValid());
4316 }
4317
is_ignored_dynamic_output_shape_float16_dim1_axis0_neg(int i)4318 inline bool is_ignored_dynamic_output_shape_float16_dim1_axis0_neg(int i) {
4319 static std::set<int> ignore = {};
4320 return ignore.find(i) != ignore.end();
4321 }
4322
4323