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