1 // clang-format off
2 // Generated file (from: grouped_conv2d.mod.py). Do not edit
get_examples_nhwc_none()3 std::vector<MixedTypedExample>& get_examples_nhwc_none() {
4 static std::vector<MixedTypedExample> examples_nhwc_none = {
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, 3, 3, 2}}},
12 // int -> FLOAT32 map
13 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.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, 2, 2, 2}}},
35 // int -> FLOAT32 map
36 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
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_nhwc_none;
58 };
59
get_examples_nhwc_none_weight_as_input()60 std::vector<MixedTypedExample>& get_examples_nhwc_none_weight_as_input() {
61 static std::vector<MixedTypedExample> examples_nhwc_none_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
69 // int -> FLOAT32 map
70 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
92 // int -> FLOAT32 map
93 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
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_nhwc_none_weight_as_input;
115 };
116
get_examples_nhwc_none_relaxed()117 std::vector<MixedTypedExample>& get_examples_nhwc_none_relaxed() {
118 static std::vector<MixedTypedExample> examples_nhwc_none_relaxed = {
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, 3, 3, 2}}},
126 // int -> FLOAT32 map
127 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
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 = {},
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, 2, 2, 2}}},
149 // int -> FLOAT32 map
150 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
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 = {},
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_nhwc_none_relaxed;
172 };
173
get_examples_nhwc_none_relaxed_weight_as_input()174 std::vector<MixedTypedExample>& get_examples_nhwc_none_relaxed_weight_as_input() {
175 static std::vector<MixedTypedExample> examples_nhwc_none_relaxed_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
183 // int -> FLOAT32 map
184 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
185 // int -> INT32 map
186 .int32Operands = {},
187 // int -> QUANT8_ASYMM map
188 .quant8AsymmOperands = {},
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, 2, 2, 2}}},
206 // int -> FLOAT32 map
207 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
208 // int -> INT32 map
209 .int32Operands = {},
210 // int -> QUANT8_ASYMM map
211 .quant8AsymmOperands = {},
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_nhwc_none_relaxed_weight_as_input;
229 };
230
get_examples_nhwc_none_quant8()231 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8() {
232 static std::vector<MixedTypedExample> examples_nhwc_none_quant8 = {
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, 3, 3, 2}}},
240 // int -> FLOAT32 map
241 .float32Operands = {},
242 // int -> INT32 map
243 .int32Operands = {},
244 // int -> QUANT8_ASYMM map
245 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2, 2}}},
263 // int -> FLOAT32 map
264 .float32Operands = {},
265 // int -> INT32 map
266 .int32Operands = {},
267 // int -> QUANT8_ASYMM map
268 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
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_nhwc_none_quant8;
286 };
287
get_examples_nhwc_none_quant8_weight_as_input()288 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8_weight_as_input() {
289 static std::vector<MixedTypedExample> examples_nhwc_none_quant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
297 // int -> FLOAT32 map
298 .float32Operands = {},
299 // int -> INT32 map
300 .int32Operands = {{2, {160, -536}}},
301 // int -> QUANT8_ASYMM map
302 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
320 // int -> FLOAT32 map
321 .float32Operands = {},
322 // int -> INT32 map
323 .int32Operands = {},
324 // int -> QUANT8_ASYMM map
325 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
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_nhwc_none_quant8_weight_as_input;
343 };
344
get_examples_nhwc_none_quant8_2()345 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8_2() {
346 static std::vector<MixedTypedExample> examples_nhwc_none_quant8_2 = {
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, 3, 3, 2}}},
354 // int -> FLOAT32 map
355 .float32Operands = {},
356 // int -> INT32 map
357 .int32Operands = {},
358 // int -> QUANT8_ASYMM map
359 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
360 // int -> QUANT16_SYMM map
361 .quant16SymmOperands = {},
362 // int -> FLOAT16 map
363 .float16Operands = {},
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, 2, 2, 2}}},
377 // int -> FLOAT32 map
378 .float32Operands = {},
379 // int -> INT32 map
380 .int32Operands = {},
381 // int -> QUANT8_ASYMM map
382 .quant8AsymmOperands = {{0, {255, 70, 255, 230, 255, 170, 255, 0}}},
383 // int -> QUANT16_SYMM map
384 .quant16SymmOperands = {},
385 // int -> FLOAT16 map
386 .float16Operands = {},
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_nhwc_none_quant8_2;
400 };
401
get_examples_nhwc_none_quant8_weight_as_input_2()402 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8_weight_as_input_2() {
403 static std::vector<MixedTypedExample> examples_nhwc_none_quant8_weight_as_input_2 = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
411 // int -> FLOAT32 map
412 .float32Operands = {},
413 // int -> INT32 map
414 .int32Operands = {{2, {160, -536}}},
415 // int -> QUANT8_ASYMM map
416 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
434 // int -> FLOAT32 map
435 .float32Operands = {},
436 // int -> INT32 map
437 .int32Operands = {},
438 // int -> QUANT8_ASYMM map
439 .quant8AsymmOperands = {{0, {255, 70, 255, 230, 255, 170, 255, 0}}},
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_nhwc_none_quant8_weight_as_input_2;
457 };
458
get_examples_nhwc_none_channelQuant8()459 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8() {
460 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8 = {
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, 3, 3, 2}}},
468 // int -> FLOAT32 map
469 .float32Operands = {},
470 // int -> INT32 map
471 .int32Operands = {},
472 // int -> QUANT8_ASYMM map
473 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2, 2}}},
491 // int -> FLOAT32 map
492 .float32Operands = {},
493 // int -> INT32 map
494 .int32Operands = {},
495 // int -> QUANT8_ASYMM map
496 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
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_nhwc_none_channelQuant8;
514 };
515
get_examples_nhwc_none_channelQuant8_weight_as_input()516 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8_weight_as_input() {
517 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
525 // int -> FLOAT32 map
526 .float32Operands = {},
527 // int -> INT32 map
528 .int32Operands = {{2, {160, -268}}},
529 // int -> QUANT8_ASYMM map
530 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
548 // int -> FLOAT32 map
549 .float32Operands = {},
550 // int -> INT32 map
551 .int32Operands = {},
552 // int -> QUANT8_ASYMM map
553 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
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_nhwc_none_channelQuant8_weight_as_input;
571 };
572
get_examples_nhwc_none_channelQuant8_2()573 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8_2() {
574 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8_2 = {
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, 3, 3, 2}}},
582 // int -> FLOAT32 map
583 .float32Operands = {},
584 // int -> INT32 map
585 .int32Operands = {},
586 // int -> QUANT8_ASYMM map
587 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
588 // int -> QUANT16_SYMM map
589 .quant16SymmOperands = {},
590 // int -> FLOAT16 map
591 .float16Operands = {},
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, 2, 2, 2}}},
605 // int -> FLOAT32 map
606 .float32Operands = {},
607 // int -> INT32 map
608 .int32Operands = {},
609 // int -> QUANT8_ASYMM map
610 .quant8AsymmOperands = {{0, {255, 75, 255, 155, 255, 125, 255, 0}}},
611 // int -> QUANT16_SYMM map
612 .quant16SymmOperands = {},
613 // int -> FLOAT16 map
614 .float16Operands = {},
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_nhwc_none_channelQuant8_2;
628 };
629
get_examples_nhwc_none_channelQuant8_weight_as_input_2()630 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8_weight_as_input_2() {
631 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8_weight_as_input_2 = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
639 // int -> FLOAT32 map
640 .float32Operands = {},
641 // int -> INT32 map
642 .int32Operands = {{2, {160, -268}}},
643 // int -> QUANT8_ASYMM map
644 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
662 // int -> FLOAT32 map
663 .float32Operands = {},
664 // int -> INT32 map
665 .int32Operands = {},
666 // int -> QUANT8_ASYMM map
667 .quant8AsymmOperands = {{0, {255, 75, 255, 155, 255, 125, 255, 0}}},
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_nhwc_none_channelQuant8_weight_as_input_2;
685 };
686
get_examples_nhwc_none_float16()687 std::vector<MixedTypedExample>& get_examples_nhwc_none_float16() {
688 static std::vector<MixedTypedExample> examples_nhwc_none_float16 = {
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, 3, 3, 2}}},
696 // int -> FLOAT32 map
697 .float32Operands = {},
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 = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
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, 2, 2, 2}}},
719 // int -> FLOAT32 map
720 .float32Operands = {},
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 = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
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_nhwc_none_float16;
742 };
743
get_examples_nhwc_none_float16_weight_as_input()744 std::vector<MixedTypedExample>& get_examples_nhwc_none_float16_weight_as_input() {
745 static std::vector<MixedTypedExample> examples_nhwc_none_float16_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
753 // int -> FLOAT32 map
754 .float32Operands = {},
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 = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
776 // int -> FLOAT32 map
777 .float32Operands = {},
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 = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
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_nhwc_none_float16_weight_as_input;
799 };
800
get_examples_nhwc_relu()801 std::vector<MixedTypedExample>& get_examples_nhwc_relu() {
802 static std::vector<MixedTypedExample> examples_nhwc_relu = {
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, 3, 3, 2}}},
810 // int -> FLOAT32 map
811 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
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 = {},
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, 2, 2, 2}}},
833 // int -> FLOAT32 map
834 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
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 = {},
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_nhwc_relu;
856 };
857
get_examples_nhwc_relu_weight_as_input()858 std::vector<MixedTypedExample>& get_examples_nhwc_relu_weight_as_input() {
859 static std::vector<MixedTypedExample> examples_nhwc_relu_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
867 // int -> FLOAT32 map
868 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
869 // int -> INT32 map
870 .int32Operands = {},
871 // int -> QUANT8_ASYMM map
872 .quant8AsymmOperands = {},
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, 2, 2, 2}}},
890 // int -> FLOAT32 map
891 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
892 // int -> INT32 map
893 .int32Operands = {},
894 // int -> QUANT8_ASYMM map
895 .quant8AsymmOperands = {},
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_nhwc_relu_weight_as_input;
913 };
914
get_examples_nhwc_relu_relaxed()915 std::vector<MixedTypedExample>& get_examples_nhwc_relu_relaxed() {
916 static std::vector<MixedTypedExample> examples_nhwc_relu_relaxed = {
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, 3, 3, 2}}},
924 // int -> FLOAT32 map
925 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.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, 2, 2, 2}}},
947 // int -> FLOAT32 map
948 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.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_nhwc_relu_relaxed;
970 };
971
get_examples_nhwc_relu_relaxed_weight_as_input()972 std::vector<MixedTypedExample>& get_examples_nhwc_relu_relaxed_weight_as_input() {
973 static std::vector<MixedTypedExample> examples_nhwc_relu_relaxed_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
981 // int -> FLOAT32 map
982 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
1004 // int -> FLOAT32 map
1005 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.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_nhwc_relu_relaxed_weight_as_input;
1027 };
1028
get_examples_nhwc_relu_quant8()1029 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8() {
1030 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8 = {
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, 3, 3, 2}}},
1038 // int -> FLOAT32 map
1039 .float32Operands = {},
1040 // int -> INT32 map
1041 .int32Operands = {},
1042 // int -> QUANT8_ASYMM map
1043 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
1044 // int -> QUANT16_SYMM map
1045 .quant16SymmOperands = {},
1046 // int -> FLOAT16 map
1047 .float16Operands = {},
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, 2, 2, 2}}},
1061 // int -> FLOAT32 map
1062 .float32Operands = {},
1063 // int -> INT32 map
1064 .int32Operands = {},
1065 // int -> QUANT8_ASYMM map
1066 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
1067 // int -> QUANT16_SYMM map
1068 .quant16SymmOperands = {},
1069 // int -> FLOAT16 map
1070 .float16Operands = {},
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_nhwc_relu_quant8;
1084 };
1085
get_examples_nhwc_relu_quant8_weight_as_input()1086 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8_weight_as_input() {
1087 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1095 // int -> FLOAT32 map
1096 .float32Operands = {},
1097 // int -> INT32 map
1098 .int32Operands = {{2, {160, -536}}},
1099 // int -> QUANT8_ASYMM map
1100 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
1118 // int -> FLOAT32 map
1119 .float32Operands = {},
1120 // int -> INT32 map
1121 .int32Operands = {},
1122 // int -> QUANT8_ASYMM map
1123 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
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_nhwc_relu_quant8_weight_as_input;
1141 };
1142
get_examples_nhwc_relu_quant8_2()1143 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8_2() {
1144 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8_2 = {
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, 3, 3, 2}}},
1152 // int -> FLOAT32 map
1153 .float32Operands = {},
1154 // int -> INT32 map
1155 .int32Operands = {},
1156 // int -> QUANT8_ASYMM map
1157 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2, 2}}},
1175 // int -> FLOAT32 map
1176 .float32Operands = {},
1177 // int -> INT32 map
1178 .int32Operands = {},
1179 // int -> QUANT8_ASYMM map
1180 .quant8AsymmOperands = {{0, {255, 80, 255, 230, 255, 170, 255, 80}}},
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_nhwc_relu_quant8_2;
1198 };
1199
get_examples_nhwc_relu_quant8_weight_as_input_2()1200 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8_weight_as_input_2() {
1201 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8_weight_as_input_2 = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1209 // int -> FLOAT32 map
1210 .float32Operands = {},
1211 // int -> INT32 map
1212 .int32Operands = {{2, {160, -536}}},
1213 // int -> QUANT8_ASYMM map
1214 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
1232 // int -> FLOAT32 map
1233 .float32Operands = {},
1234 // int -> INT32 map
1235 .int32Operands = {},
1236 // int -> QUANT8_ASYMM map
1237 .quant8AsymmOperands = {{0, {255, 80, 255, 230, 255, 170, 255, 80}}},
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_nhwc_relu_quant8_weight_as_input_2;
1255 };
1256
get_examples_nhwc_relu_channelQuant8()1257 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8() {
1258 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8 = {
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, 3, 3, 2}}},
1266 // int -> FLOAT32 map
1267 .float32Operands = {},
1268 // int -> INT32 map
1269 .int32Operands = {},
1270 // int -> QUANT8_ASYMM map
1271 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
1272 // int -> QUANT16_SYMM map
1273 .quant16SymmOperands = {},
1274 // int -> FLOAT16 map
1275 .float16Operands = {},
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, 2, 2, 2}}},
1289 // int -> FLOAT32 map
1290 .float32Operands = {},
1291 // int -> INT32 map
1292 .int32Operands = {},
1293 // int -> QUANT8_ASYMM map
1294 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
1295 // int -> QUANT16_SYMM map
1296 .quant16SymmOperands = {},
1297 // int -> FLOAT16 map
1298 .float16Operands = {},
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_nhwc_relu_channelQuant8;
1312 };
1313
get_examples_nhwc_relu_channelQuant8_weight_as_input()1314 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8_weight_as_input() {
1315 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1323 // int -> FLOAT32 map
1324 .float32Operands = {},
1325 // int -> INT32 map
1326 .int32Operands = {{2, {160, -268}}},
1327 // int -> QUANT8_ASYMM map
1328 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
1346 // int -> FLOAT32 map
1347 .float32Operands = {},
1348 // int -> INT32 map
1349 .int32Operands = {},
1350 // int -> QUANT8_ASYMM map
1351 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
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_nhwc_relu_channelQuant8_weight_as_input;
1369 };
1370
get_examples_nhwc_relu_channelQuant8_2()1371 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8_2() {
1372 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8_2 = {
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, 3, 3, 2}}},
1380 // int -> FLOAT32 map
1381 .float32Operands = {},
1382 // int -> INT32 map
1383 .int32Operands = {},
1384 // int -> QUANT8_ASYMM map
1385 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2, 2}}},
1403 // int -> FLOAT32 map
1404 .float32Operands = {},
1405 // int -> INT32 map
1406 .int32Operands = {},
1407 // int -> QUANT8_ASYMM map
1408 .quant8AsymmOperands = {{0, {255, 80, 255, 155, 255, 125, 255, 80}}},
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_nhwc_relu_channelQuant8_2;
1426 };
1427
get_examples_nhwc_relu_channelQuant8_weight_as_input_2()1428 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8_weight_as_input_2() {
1429 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8_weight_as_input_2 = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1437 // int -> FLOAT32 map
1438 .float32Operands = {},
1439 // int -> INT32 map
1440 .int32Operands = {{2, {160, -268}}},
1441 // int -> QUANT8_ASYMM map
1442 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
1460 // int -> FLOAT32 map
1461 .float32Operands = {},
1462 // int -> INT32 map
1463 .int32Operands = {},
1464 // int -> QUANT8_ASYMM map
1465 .quant8AsymmOperands = {{0, {255, 80, 255, 155, 255, 125, 255, 80}}},
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_nhwc_relu_channelQuant8_weight_as_input_2;
1483 };
1484
get_examples_nhwc_relu_float16()1485 std::vector<MixedTypedExample>& get_examples_nhwc_relu_float16() {
1486 static std::vector<MixedTypedExample> examples_nhwc_relu_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, 3, 3, 2}}},
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, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.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, 2, 2, 2}}},
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, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.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_nhwc_relu_float16;
1540 };
1541
get_examples_nhwc_relu_float16_weight_as_input()1542 std::vector<MixedTypedExample>& get_examples_nhwc_relu_float16_weight_as_input() {
1543 static std::vector<MixedTypedExample> examples_nhwc_relu_float16_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1551 // int -> FLOAT32 map
1552 .float32Operands = {},
1553 // int -> INT32 map
1554 .int32Operands = {},
1555 // int -> QUANT8_ASYMM map
1556 .quant8AsymmOperands = {},
1557 // int -> QUANT16_SYMM map
1558 .quant16SymmOperands = {},
1559 // int -> FLOAT16 map
1560 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
1574 // int -> FLOAT32 map
1575 .float32Operands = {},
1576 // int -> INT32 map
1577 .int32Operands = {},
1578 // int -> QUANT8_ASYMM map
1579 .quant8AsymmOperands = {},
1580 // int -> QUANT16_SYMM map
1581 .quant16SymmOperands = {},
1582 // int -> FLOAT16 map
1583 .float16Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
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_nhwc_relu_float16_weight_as_input;
1597 };
1598
get_examples_nhwc_relu1()1599 std::vector<MixedTypedExample>& get_examples_nhwc_relu1() {
1600 static std::vector<MixedTypedExample> examples_nhwc_relu1 = {
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, 3, 3, 2}}},
1608 // int -> FLOAT32 map
1609 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.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, 2, 2, 2}}},
1631 // int -> FLOAT32 map
1632 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.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_nhwc_relu1;
1654 };
1655
get_examples_nhwc_relu1_weight_as_input()1656 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_weight_as_input() {
1657 static std::vector<MixedTypedExample> examples_nhwc_relu1_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1665 // int -> FLOAT32 map
1666 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
1688 // int -> FLOAT32 map
1689 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.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_nhwc_relu1_weight_as_input;
1711 };
1712
get_examples_nhwc_relu1_relaxed()1713 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_relaxed() {
1714 static std::vector<MixedTypedExample> examples_nhwc_relu1_relaxed = {
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, 3, 3, 2}}},
1722 // int -> FLOAT32 map
1723 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
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 = {},
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, 2, 2, 2}}},
1745 // int -> FLOAT32 map
1746 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
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 = {},
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_nhwc_relu1_relaxed;
1768 };
1769
get_examples_nhwc_relu1_relaxed_weight_as_input()1770 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_relaxed_weight_as_input() {
1771 static std::vector<MixedTypedExample> examples_nhwc_relu1_relaxed_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1779 // int -> FLOAT32 map
1780 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
1781 // int -> INT32 map
1782 .int32Operands = {},
1783 // int -> QUANT8_ASYMM map
1784 .quant8AsymmOperands = {},
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, 2, 2, 2}}},
1802 // int -> FLOAT32 map
1803 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
1804 // int -> INT32 map
1805 .int32Operands = {},
1806 // int -> QUANT8_ASYMM map
1807 .quant8AsymmOperands = {},
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_nhwc_relu1_relaxed_weight_as_input;
1825 };
1826
get_examples_nhwc_relu1_quant8()1827 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8() {
1828 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8 = {
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, 3, 3, 2}}},
1836 // int -> FLOAT32 map
1837 .float32Operands = {},
1838 // int -> INT32 map
1839 .int32Operands = {},
1840 // int -> QUANT8_ASYMM map
1841 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2, 2}}},
1859 // int -> FLOAT32 map
1860 .float32Operands = {},
1861 // int -> INT32 map
1862 .int32Operands = {},
1863 // int -> QUANT8_ASYMM map
1864 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
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_nhwc_relu1_quant8;
1882 };
1883
get_examples_nhwc_relu1_quant8_weight_as_input()1884 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8_weight_as_input() {
1885 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
1893 // int -> FLOAT32 map
1894 .float32Operands = {},
1895 // int -> INT32 map
1896 .int32Operands = {{2, {160, -536}}},
1897 // int -> QUANT8_ASYMM map
1898 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
1916 // int -> FLOAT32 map
1917 .float32Operands = {},
1918 // int -> INT32 map
1919 .int32Operands = {},
1920 // int -> QUANT8_ASYMM map
1921 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
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_nhwc_relu1_quant8_weight_as_input;
1939 };
1940
get_examples_nhwc_relu1_quant8_2()1941 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8_2() {
1942 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8_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, 3, 3, 2}}},
1950 // int -> FLOAT32 map
1951 .float32Operands = {},
1952 // int -> INT32 map
1953 .int32Operands = {},
1954 // int -> QUANT8_ASYMM map
1955 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
1956 // int -> QUANT16_SYMM map
1957 .quant16SymmOperands = {},
1958 // int -> FLOAT16 map
1959 .float16Operands = {},
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, 2, 2, 2}}},
1973 // int -> FLOAT32 map
1974 .float32Operands = {},
1975 // int -> INT32 map
1976 .int32Operands = {},
1977 // int -> QUANT8_ASYMM map
1978 .quant8AsymmOperands = {{0, {100, 70, 100, 100, 100, 100, 100, 60}}},
1979 // int -> QUANT16_SYMM map
1980 .quant16SymmOperands = {},
1981 // int -> FLOAT16 map
1982 .float16Operands = {},
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_nhwc_relu1_quant8_2;
1996 };
1997
get_examples_nhwc_relu1_quant8_weight_as_input_2()1998 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8_weight_as_input_2() {
1999 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8_weight_as_input_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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2007 // int -> FLOAT32 map
2008 .float32Operands = {},
2009 // int -> INT32 map
2010 .int32Operands = {{2, {160, -536}}},
2011 // int -> QUANT8_ASYMM map
2012 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
2030 // int -> FLOAT32 map
2031 .float32Operands = {},
2032 // int -> INT32 map
2033 .int32Operands = {},
2034 // int -> QUANT8_ASYMM map
2035 .quant8AsymmOperands = {{0, {100, 70, 100, 100, 100, 100, 100, 60}}},
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_nhwc_relu1_quant8_weight_as_input_2;
2053 };
2054
get_examples_nhwc_relu1_channelQuant8()2055 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8() {
2056 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8 = {
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, 3, 3, 2}}},
2064 // int -> FLOAT32 map
2065 .float32Operands = {},
2066 // int -> INT32 map
2067 .int32Operands = {},
2068 // int -> QUANT8_ASYMM map
2069 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2}}},
2087 // int -> FLOAT32 map
2088 .float32Operands = {},
2089 // int -> INT32 map
2090 .int32Operands = {},
2091 // int -> QUANT8_ASYMM map
2092 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
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_nhwc_relu1_channelQuant8;
2110 };
2111
get_examples_nhwc_relu1_channelQuant8_weight_as_input()2112 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8_weight_as_input() {
2113 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2121 // int -> FLOAT32 map
2122 .float32Operands = {},
2123 // int -> INT32 map
2124 .int32Operands = {{2, {160, -268}}},
2125 // int -> QUANT8_ASYMM map
2126 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2}}},
2144 // int -> FLOAT32 map
2145 .float32Operands = {},
2146 // int -> INT32 map
2147 .int32Operands = {},
2148 // int -> QUANT8_ASYMM map
2149 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
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_nhwc_relu1_channelQuant8_weight_as_input;
2167 };
2168
get_examples_nhwc_relu1_channelQuant8_2()2169 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8_2() {
2170 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8_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, 3, 3, 2}}},
2178 // int -> FLOAT32 map
2179 .float32Operands = {},
2180 // int -> INT32 map
2181 .int32Operands = {},
2182 // int -> QUANT8_ASYMM map
2183 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
2184 // int -> QUANT16_SYMM map
2185 .quant16SymmOperands = {},
2186 // int -> FLOAT16 map
2187 .float16Operands = {},
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, 2, 2}}},
2201 // int -> FLOAT32 map
2202 .float32Operands = {},
2203 // int -> INT32 map
2204 .int32Operands = {},
2205 // int -> QUANT8_ASYMM map
2206 .quant8AsymmOperands = {{0, {90, 75, 90, 90, 90, 90, 90, 70}}},
2207 // int -> QUANT16_SYMM map
2208 .quant16SymmOperands = {},
2209 // int -> FLOAT16 map
2210 .float16Operands = {},
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_nhwc_relu1_channelQuant8_2;
2224 };
2225
get_examples_nhwc_relu1_channelQuant8_weight_as_input_2()2226 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8_weight_as_input_2() {
2227 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8_weight_as_input_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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2235 // int -> FLOAT32 map
2236 .float32Operands = {},
2237 // int -> INT32 map
2238 .int32Operands = {{2, {160, -268}}},
2239 // int -> QUANT8_ASYMM map
2240 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2}}},
2258 // int -> FLOAT32 map
2259 .float32Operands = {},
2260 // int -> INT32 map
2261 .int32Operands = {},
2262 // int -> QUANT8_ASYMM map
2263 .quant8AsymmOperands = {{0, {90, 75, 90, 90, 90, 90, 90, 70}}},
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_nhwc_relu1_channelQuant8_weight_as_input_2;
2281 };
2282
get_examples_nhwc_relu1_float16()2283 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_float16() {
2284 static std::vector<MixedTypedExample> examples_nhwc_relu1_float16 = {
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, 3, 3, 2}}},
2292 // int -> FLOAT32 map
2293 .float32Operands = {},
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 = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
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, 2, 2, 2}}},
2315 // int -> FLOAT32 map
2316 .float32Operands = {},
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 = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
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_nhwc_relu1_float16;
2338 };
2339
get_examples_nhwc_relu1_float16_weight_as_input()2340 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_float16_weight_as_input() {
2341 static std::vector<MixedTypedExample> examples_nhwc_relu1_float16_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2349 // int -> FLOAT32 map
2350 .float32Operands = {},
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 = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
2372 // int -> FLOAT32 map
2373 .float32Operands = {},
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 = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
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_nhwc_relu1_float16_weight_as_input;
2395 };
2396
get_examples_nhwc_relu6()2397 std::vector<MixedTypedExample>& get_examples_nhwc_relu6() {
2398 static std::vector<MixedTypedExample> examples_nhwc_relu6 = {
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, 3, 3, 2}}},
2406 // int -> FLOAT32 map
2407 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
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 = {},
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, 2, 2, 2}}},
2429 // int -> FLOAT32 map
2430 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
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 = {},
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_nhwc_relu6;
2452 };
2453
get_examples_nhwc_relu6_weight_as_input()2454 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_weight_as_input() {
2455 static std::vector<MixedTypedExample> examples_nhwc_relu6_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2463 // int -> FLOAT32 map
2464 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
2465 // int -> INT32 map
2466 .int32Operands = {},
2467 // int -> QUANT8_ASYMM map
2468 .quant8AsymmOperands = {},
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, 2, 2, 2}}},
2486 // int -> FLOAT32 map
2487 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
2488 // int -> INT32 map
2489 .int32Operands = {},
2490 // int -> QUANT8_ASYMM map
2491 .quant8AsymmOperands = {},
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_nhwc_relu6_weight_as_input;
2509 };
2510
get_examples_nhwc_relu6_relaxed()2511 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_relaxed() {
2512 static std::vector<MixedTypedExample> examples_nhwc_relu6_relaxed = {
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, 3, 3, 2}}},
2520 // int -> FLOAT32 map
2521 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.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, 2, 2}}},
2543 // int -> FLOAT32 map
2544 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.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_nhwc_relu6_relaxed;
2566 };
2567
get_examples_nhwc_relu6_relaxed_weight_as_input()2568 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_relaxed_weight_as_input() {
2569 static std::vector<MixedTypedExample> examples_nhwc_relu6_relaxed_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2577 // int -> FLOAT32 map
2578 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2}}},
2600 // int -> FLOAT32 map
2601 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.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_nhwc_relu6_relaxed_weight_as_input;
2623 };
2624
get_examples_nhwc_relu6_quant8()2625 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8() {
2626 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8 = {
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, 3, 3, 2}}},
2634 // int -> FLOAT32 map
2635 .float32Operands = {},
2636 // int -> INT32 map
2637 .int32Operands = {},
2638 // int -> QUANT8_ASYMM map
2639 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
2640 // int -> QUANT16_SYMM map
2641 .quant16SymmOperands = {},
2642 // int -> FLOAT16 map
2643 .float16Operands = {},
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, 2, 2}}},
2657 // int -> FLOAT32 map
2658 .float32Operands = {},
2659 // int -> INT32 map
2660 .int32Operands = {},
2661 // int -> QUANT8_ASYMM map
2662 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
2663 // int -> QUANT16_SYMM map
2664 .quant16SymmOperands = {},
2665 // int -> FLOAT16 map
2666 .float16Operands = {},
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_nhwc_relu6_quant8;
2680 };
2681
get_examples_nhwc_relu6_quant8_weight_as_input()2682 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8_weight_as_input() {
2683 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2691 // int -> FLOAT32 map
2692 .float32Operands = {},
2693 // int -> INT32 map
2694 .int32Operands = {{2, {160, -536}}},
2695 // int -> QUANT8_ASYMM map
2696 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2}}},
2714 // int -> FLOAT32 map
2715 .float32Operands = {},
2716 // int -> INT32 map
2717 .int32Operands = {},
2718 // int -> QUANT8_ASYMM map
2719 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
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_nhwc_relu6_quant8_weight_as_input;
2737 };
2738
get_examples_nhwc_relu6_quant8_2()2739 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8_2() {
2740 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8_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, 3, 3, 2}}},
2748 // int -> FLOAT32 map
2749 .float32Operands = {},
2750 // int -> INT32 map
2751 .int32Operands = {},
2752 // int -> QUANT8_ASYMM map
2753 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2, 2}}},
2771 // int -> FLOAT32 map
2772 .float32Operands = {},
2773 // int -> INT32 map
2774 .int32Operands = {},
2775 // int -> QUANT8_ASYMM map
2776 .quant8AsymmOperands = {{0, {200, 80, 200, 200, 200, 170, 200, 80}}},
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_nhwc_relu6_quant8_2;
2794 };
2795
get_examples_nhwc_relu6_quant8_weight_as_input_2()2796 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8_weight_as_input_2() {
2797 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8_weight_as_input_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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2805 // int -> FLOAT32 map
2806 .float32Operands = {},
2807 // int -> INT32 map
2808 .int32Operands = {{2, {160, -536}}},
2809 // int -> QUANT8_ASYMM map
2810 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2, 2}}},
2828 // int -> FLOAT32 map
2829 .float32Operands = {},
2830 // int -> INT32 map
2831 .int32Operands = {},
2832 // int -> QUANT8_ASYMM map
2833 .quant8AsymmOperands = {{0, {200, 80, 200, 200, 200, 170, 200, 80}}},
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_nhwc_relu6_quant8_weight_as_input_2;
2851 };
2852
get_examples_nhwc_relu6_channelQuant8()2853 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8() {
2854 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8 = {
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, 3, 3, 2}}},
2862 // int -> FLOAT32 map
2863 .float32Operands = {},
2864 // int -> INT32 map
2865 .int32Operands = {},
2866 // int -> QUANT8_ASYMM map
2867 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
2868 // int -> QUANT16_SYMM map
2869 .quant16SymmOperands = {},
2870 // int -> FLOAT16 map
2871 .float16Operands = {},
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, 2, 2, 2}}},
2885 // int -> FLOAT32 map
2886 .float32Operands = {},
2887 // int -> INT32 map
2888 .int32Operands = {},
2889 // int -> QUANT8_ASYMM map
2890 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
2891 // int -> QUANT16_SYMM map
2892 .quant16SymmOperands = {},
2893 // int -> FLOAT16 map
2894 .float16Operands = {},
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_nhwc_relu6_channelQuant8;
2908 };
2909
get_examples_nhwc_relu6_channelQuant8_weight_as_input()2910 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8_weight_as_input() {
2911 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
2919 // int -> FLOAT32 map
2920 .float32Operands = {},
2921 // int -> INT32 map
2922 .int32Operands = {{2, {160, -268}}},
2923 // int -> QUANT8_ASYMM map
2924 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
2942 // int -> FLOAT32 map
2943 .float32Operands = {},
2944 // int -> INT32 map
2945 .int32Operands = {},
2946 // int -> QUANT8_ASYMM map
2947 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
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_nhwc_relu6_channelQuant8_weight_as_input;
2965 };
2966
get_examples_nhwc_relu6_channelQuant8_2()2967 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8_2() {
2968 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8_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, 3, 3, 2}}},
2976 // int -> FLOAT32 map
2977 .float32Operands = {},
2978 // int -> INT32 map
2979 .int32Operands = {},
2980 // int -> QUANT8_ASYMM map
2981 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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, 2, 2}}},
2999 // int -> FLOAT32 map
3000 .float32Operands = {},
3001 // int -> INT32 map
3002 .int32Operands = {},
3003 // int -> QUANT8_ASYMM map
3004 .quant8AsymmOperands = {{0, {140, 80, 140, 140, 140, 125, 140, 80}}},
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_nhwc_relu6_channelQuant8_2;
3022 };
3023
get_examples_nhwc_relu6_channelQuant8_weight_as_input_2()3024 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8_weight_as_input_2() {
3025 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8_weight_as_input_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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3033 // int -> FLOAT32 map
3034 .float32Operands = {},
3035 // int -> INT32 map
3036 .int32Operands = {{2, {160, -268}}},
3037 // int -> QUANT8_ASYMM map
3038 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2}}},
3056 // int -> FLOAT32 map
3057 .float32Operands = {},
3058 // int -> INT32 map
3059 .int32Operands = {},
3060 // int -> QUANT8_ASYMM map
3061 .quant8AsymmOperands = {{0, {140, 80, 140, 140, 140, 125, 140, 80}}},
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_nhwc_relu6_channelQuant8_weight_as_input_2;
3079 };
3080
get_examples_nhwc_relu6_float16()3081 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_float16() {
3082 static std::vector<MixedTypedExample> examples_nhwc_relu6_float16 = {
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, 3, 3, 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, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.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, 2, 2}}},
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, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.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_nhwc_relu6_float16;
3136 };
3137
get_examples_nhwc_relu6_float16_weight_as_input()3138 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_float16_weight_as_input() {
3139 static std::vector<MixedTypedExample> examples_nhwc_relu6_float16_weight_as_input = {
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, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3147 // int -> FLOAT32 map
3148 .float32Operands = {},
3149 // int -> INT32 map
3150 .int32Operands = {},
3151 // int -> QUANT8_ASYMM map
3152 .quant8AsymmOperands = {},
3153 // int -> QUANT16_SYMM map
3154 .quant16SymmOperands = {},
3155 // int -> FLOAT16 map
3156 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2}}},
3170 // int -> FLOAT32 map
3171 .float32Operands = {},
3172 // int -> INT32 map
3173 .int32Operands = {},
3174 // int -> QUANT8_ASYMM map
3175 .quant8AsymmOperands = {},
3176 // int -> QUANT16_SYMM map
3177 .quant16SymmOperands = {},
3178 // int -> FLOAT16 map
3179 .float16Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
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_nhwc_relu6_float16_weight_as_input;
3193 };
3194
get_examples_nchw_none()3195 std::vector<MixedTypedExample>& get_examples_nchw_none() {
3196 static std::vector<MixedTypedExample> examples_nchw_none = {
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, 3, 3}}},
3204 // int -> FLOAT32 map
3205 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.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, 2, 2, 2}}},
3227 // int -> FLOAT32 map
3228 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
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_nchw_none;
3250 };
3251
get_examples_nchw_none_weight_as_input()3252 std::vector<MixedTypedExample>& get_examples_nchw_none_weight_as_input() {
3253 static std::vector<MixedTypedExample> examples_nchw_none_weight_as_input = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3261 // int -> FLOAT32 map
3262 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
3284 // int -> FLOAT32 map
3285 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
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_nchw_none_weight_as_input;
3307 };
3308
get_examples_nchw_none_relaxed()3309 std::vector<MixedTypedExample>& get_examples_nchw_none_relaxed() {
3310 static std::vector<MixedTypedExample> examples_nchw_none_relaxed = {
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, 3, 3}}},
3318 // int -> FLOAT32 map
3319 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
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 = {},
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, 2, 2, 2}}},
3341 // int -> FLOAT32 map
3342 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
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 = {},
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_nchw_none_relaxed;
3364 };
3365
get_examples_nchw_none_relaxed_weight_as_input()3366 std::vector<MixedTypedExample>& get_examples_nchw_none_relaxed_weight_as_input() {
3367 static std::vector<MixedTypedExample> examples_nchw_none_relaxed_weight_as_input = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3375 // int -> FLOAT32 map
3376 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
3377 // int -> INT32 map
3378 .int32Operands = {},
3379 // int -> QUANT8_ASYMM map
3380 .quant8AsymmOperands = {},
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, 2, 2, 2}}},
3398 // int -> FLOAT32 map
3399 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
3400 // int -> INT32 map
3401 .int32Operands = {},
3402 // int -> QUANT8_ASYMM map
3403 .quant8AsymmOperands = {},
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_nchw_none_relaxed_weight_as_input;
3421 };
3422
get_examples_nchw_none_quant8()3423 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8() {
3424 static std::vector<MixedTypedExample> examples_nchw_none_quant8 = {
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, 3, 3}}},
3432 // int -> FLOAT32 map
3433 .float32Operands = {},
3434 // int -> INT32 map
3435 .int32Operands = {},
3436 // int -> QUANT8_ASYMM map
3437 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, 2, 2}}},
3455 // int -> FLOAT32 map
3456 .float32Operands = {},
3457 // int -> INT32 map
3458 .int32Operands = {},
3459 // int -> QUANT8_ASYMM map
3460 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
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_nchw_none_quant8;
3478 };
3479
get_examples_nchw_none_quant8_weight_as_input()3480 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8_weight_as_input() {
3481 static std::vector<MixedTypedExample> examples_nchw_none_quant8_weight_as_input = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3489 // int -> FLOAT32 map
3490 .float32Operands = {},
3491 // int -> INT32 map
3492 .int32Operands = {{2, {160, -536}}},
3493 // int -> QUANT8_ASYMM map
3494 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2}}},
3512 // int -> FLOAT32 map
3513 .float32Operands = {},
3514 // int -> INT32 map
3515 .int32Operands = {},
3516 // int -> QUANT8_ASYMM map
3517 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
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_nchw_none_quant8_weight_as_input;
3535 };
3536
get_examples_nchw_none_quant8_2()3537 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8_2() {
3538 static std::vector<MixedTypedExample> examples_nchw_none_quant8_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, 3, 3}}},
3546 // int -> FLOAT32 map
3547 .float32Operands = {},
3548 // int -> INT32 map
3549 .int32Operands = {},
3550 // int -> QUANT8_ASYMM map
3551 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
3552 // int -> QUANT16_SYMM map
3553 .quant16SymmOperands = {},
3554 // int -> FLOAT16 map
3555 .float16Operands = {},
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, 2, 2}}},
3569 // int -> FLOAT32 map
3570 .float32Operands = {},
3571 // int -> INT32 map
3572 .int32Operands = {},
3573 // int -> QUANT8_ASYMM map
3574 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 70, 230, 170, 0}}},
3575 // int -> QUANT16_SYMM map
3576 .quant16SymmOperands = {},
3577 // int -> FLOAT16 map
3578 .float16Operands = {},
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_nchw_none_quant8_2;
3592 };
3593
get_examples_nchw_none_quant8_weight_as_input_2()3594 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8_weight_as_input_2() {
3595 static std::vector<MixedTypedExample> examples_nchw_none_quant8_weight_as_input_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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3603 // int -> FLOAT32 map
3604 .float32Operands = {},
3605 // int -> INT32 map
3606 .int32Operands = {{2, {160, -536}}},
3607 // int -> QUANT8_ASYMM map
3608 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, 2, 2}}},
3626 // int -> FLOAT32 map
3627 .float32Operands = {},
3628 // int -> INT32 map
3629 .int32Operands = {},
3630 // int -> QUANT8_ASYMM map
3631 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 70, 230, 170, 0}}},
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_nchw_none_quant8_weight_as_input_2;
3649 };
3650
get_examples_nchw_none_channelQuant8()3651 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8() {
3652 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8 = {
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, 3, 3}}},
3660 // int -> FLOAT32 map
3661 .float32Operands = {},
3662 // int -> INT32 map
3663 .int32Operands = {},
3664 // int -> QUANT8_ASYMM map
3665 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
3666 // int -> QUANT16_SYMM map
3667 .quant16SymmOperands = {},
3668 // int -> FLOAT16 map
3669 .float16Operands = {},
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, 2, 2, 2}}},
3683 // int -> FLOAT32 map
3684 .float32Operands = {},
3685 // int -> INT32 map
3686 .int32Operands = {},
3687 // int -> QUANT8_ASYMM map
3688 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
3689 // int -> QUANT16_SYMM map
3690 .quant16SymmOperands = {},
3691 // int -> FLOAT16 map
3692 .float16Operands = {},
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_nchw_none_channelQuant8;
3706 };
3707
get_examples_nchw_none_channelQuant8_weight_as_input()3708 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8_weight_as_input() {
3709 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8_weight_as_input = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3717 // int -> FLOAT32 map
3718 .float32Operands = {},
3719 // int -> INT32 map
3720 .int32Operands = {{2, {160, -268}}},
3721 // int -> QUANT8_ASYMM map
3722 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
3740 // int -> FLOAT32 map
3741 .float32Operands = {},
3742 // int -> INT32 map
3743 .int32Operands = {},
3744 // int -> QUANT8_ASYMM map
3745 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
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_nchw_none_channelQuant8_weight_as_input;
3763 };
3764
get_examples_nchw_none_channelQuant8_2()3765 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8_2() {
3766 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8_2 = {
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, 3, 3}}},
3774 // int -> FLOAT32 map
3775 .float32Operands = {},
3776 // int -> INT32 map
3777 .int32Operands = {},
3778 // int -> QUANT8_ASYMM map
3779 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
3780 // int -> QUANT16_SYMM map
3781 .quant16SymmOperands = {},
3782 // int -> FLOAT16 map
3783 .float16Operands = {},
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, 2, 2, 2}}},
3797 // int -> FLOAT32 map
3798 .float32Operands = {},
3799 // int -> INT32 map
3800 .int32Operands = {},
3801 // int -> QUANT8_ASYMM map
3802 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 75, 155, 125, 0}}},
3803 // int -> QUANT16_SYMM map
3804 .quant16SymmOperands = {},
3805 // int -> FLOAT16 map
3806 .float16Operands = {},
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_nchw_none_channelQuant8_2;
3820 };
3821
get_examples_nchw_none_channelQuant8_weight_as_input_2()3822 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8_weight_as_input_2() {
3823 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8_weight_as_input_2 = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3831 // int -> FLOAT32 map
3832 .float32Operands = {},
3833 // int -> INT32 map
3834 .int32Operands = {{2, {160, -268}}},
3835 // int -> QUANT8_ASYMM map
3836 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, 2, 2, 2}}},
3854 // int -> FLOAT32 map
3855 .float32Operands = {},
3856 // int -> INT32 map
3857 .int32Operands = {},
3858 // int -> QUANT8_ASYMM map
3859 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 75, 155, 125, 0}}},
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_nchw_none_channelQuant8_weight_as_input_2;
3877 };
3878
get_examples_nchw_none_float16()3879 std::vector<MixedTypedExample>& get_examples_nchw_none_float16() {
3880 static std::vector<MixedTypedExample> examples_nchw_none_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, 3, 3}}},
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, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.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, 2, 2, 2}}},
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, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
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_nchw_none_float16;
3934 };
3935
get_examples_nchw_none_float16_weight_as_input()3936 std::vector<MixedTypedExample>& get_examples_nchw_none_float16_weight_as_input() {
3937 static std::vector<MixedTypedExample> examples_nchw_none_float16_weight_as_input = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
3945 // int -> FLOAT32 map
3946 .float32Operands = {},
3947 // int -> INT32 map
3948 .int32Operands = {},
3949 // int -> QUANT8_ASYMM map
3950 .quant8AsymmOperands = {},
3951 // int -> QUANT16_SYMM map
3952 .quant16SymmOperands = {},
3953 // int -> FLOAT16 map
3954 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, 2, 2, 2}}},
3968 // int -> FLOAT32 map
3969 .float32Operands = {},
3970 // int -> INT32 map
3971 .int32Operands = {},
3972 // int -> QUANT8_ASYMM map
3973 .quant8AsymmOperands = {},
3974 // int -> QUANT16_SYMM map
3975 .quant16SymmOperands = {},
3976 // int -> FLOAT16 map
3977 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
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_nchw_none_float16_weight_as_input;
3991 };
3992
get_examples_nchw_relu()3993 std::vector<MixedTypedExample>& get_examples_nchw_relu() {
3994 static std::vector<MixedTypedExample> examples_nchw_relu = {
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, 3, 3}}},
4002 // int -> FLOAT32 map
4003 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
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 = {},
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, 2, 2, 2}}},
4025 // int -> FLOAT32 map
4026 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
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 = {},
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_nchw_relu;
4048 };
4049
get_examples_nchw_relu_weight_as_input()4050 std::vector<MixedTypedExample>& get_examples_nchw_relu_weight_as_input() {
4051 static std::vector<MixedTypedExample> examples_nchw_relu_weight_as_input = {
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, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4059 // int -> FLOAT32 map
4060 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
4061 // int -> INT32 map
4062 .int32Operands = {},
4063 // int -> QUANT8_ASYMM map
4064 .quant8AsymmOperands = {},
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, 2, 2, 2}}},
4082 // int -> FLOAT32 map
4083 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
4084 // int -> INT32 map
4085 .int32Operands = {},
4086 // int -> QUANT8_ASYMM map
4087 .quant8AsymmOperands = {},
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_nchw_relu_weight_as_input;
4105 };
4106
get_examples_nchw_relu_relaxed()4107 std::vector<MixedTypedExample>& get_examples_nchw_relu_relaxed() {
4108 static std::vector<MixedTypedExample> examples_nchw_relu_relaxed = {
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, 2, 3, 3}}},
4116 // int -> FLOAT32 map
4117 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.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, {1, 2, 2, 2}}},
4139 // int -> FLOAT32 map
4140 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
4141 // int -> INT32 map
4142 .int32Operands = {},
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_nchw_relu_relaxed;
4162 };
4163
get_examples_nchw_relu_relaxed_weight_as_input()4164 std::vector<MixedTypedExample>& get_examples_nchw_relu_relaxed_weight_as_input() {
4165 static std::vector<MixedTypedExample> examples_nchw_relu_relaxed_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4173 // int -> FLOAT32 map
4174 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, {1, 2, 2, 2}}},
4196 // int -> FLOAT32 map
4197 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
4198 // int -> INT32 map
4199 .int32Operands = {},
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_nchw_relu_relaxed_weight_as_input;
4219 };
4220
get_examples_nchw_relu_quant8()4221 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8() {
4222 static std::vector<MixedTypedExample> examples_nchw_relu_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, 2, 3, 3}}},
4230 // int -> FLOAT32 map
4231 .float32Operands = {},
4232 // int -> INT32 map
4233 .int32Operands = {},
4234 // int -> QUANT8_ASYMM map
4235 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
4253 // int -> FLOAT32 map
4254 .float32Operands = {},
4255 // int -> INT32 map
4256 .int32Operands = {},
4257 // int -> QUANT8_ASYMM map
4258 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
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_nchw_relu_quant8;
4276 };
4277
get_examples_nchw_relu_quant8_weight_as_input()4278 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8_weight_as_input() {
4279 static std::vector<MixedTypedExample> examples_nchw_relu_quant8_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4287 // int -> FLOAT32 map
4288 .float32Operands = {},
4289 // int -> INT32 map
4290 .int32Operands = {{2, {160, -536}}},
4291 // int -> QUANT8_ASYMM map
4292 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
4293 // int -> QUANT16_SYMM map
4294 .quant16SymmOperands = {},
4295 // int -> FLOAT16 map
4296 .float16Operands = {},
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, {1, 2, 2, 2}}},
4310 // int -> FLOAT32 map
4311 .float32Operands = {},
4312 // int -> INT32 map
4313 .int32Operands = {},
4314 // int -> QUANT8_ASYMM map
4315 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
4316 // int -> QUANT16_SYMM map
4317 .quant16SymmOperands = {},
4318 // int -> FLOAT16 map
4319 .float16Operands = {},
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_nchw_relu_quant8_weight_as_input;
4333 };
4334
get_examples_nchw_relu_quant8_2()4335 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8_2() {
4336 static std::vector<MixedTypedExample> examples_nchw_relu_quant8_2 = {
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, 2, 3, 3}}},
4344 // int -> FLOAT32 map
4345 .float32Operands = {},
4346 // int -> INT32 map
4347 .int32Operands = {},
4348 // int -> QUANT8_ASYMM map
4349 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
4367 // int -> FLOAT32 map
4368 .float32Operands = {},
4369 // int -> INT32 map
4370 .int32Operands = {},
4371 // int -> QUANT8_ASYMM map
4372 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 230, 170, 80}}},
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_nchw_relu_quant8_2;
4390 };
4391
get_examples_nchw_relu_quant8_weight_as_input_2()4392 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8_weight_as_input_2() {
4393 static std::vector<MixedTypedExample> examples_nchw_relu_quant8_weight_as_input_2 = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4401 // int -> FLOAT32 map
4402 .float32Operands = {},
4403 // int -> INT32 map
4404 .int32Operands = {{2, {160, -536}}},
4405 // int -> QUANT8_ASYMM map
4406 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, {1, 2, 2, 2}}},
4424 // int -> FLOAT32 map
4425 .float32Operands = {},
4426 // int -> INT32 map
4427 .int32Operands = {},
4428 // int -> QUANT8_ASYMM map
4429 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 230, 170, 80}}},
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_nchw_relu_quant8_weight_as_input_2;
4447 };
4448
get_examples_nchw_relu_channelQuant8()4449 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8() {
4450 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8 = {
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, 2, 3, 3}}},
4458 // int -> FLOAT32 map
4459 .float32Operands = {},
4460 // int -> INT32 map
4461 .int32Operands = {},
4462 // int -> QUANT8_ASYMM map
4463 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
4481 // int -> FLOAT32 map
4482 .float32Operands = {},
4483 // int -> INT32 map
4484 .int32Operands = {},
4485 // int -> QUANT8_ASYMM map
4486 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
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_nchw_relu_channelQuant8;
4504 };
4505
get_examples_nchw_relu_channelQuant8_weight_as_input()4506 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8_weight_as_input() {
4507 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4515 // int -> FLOAT32 map
4516 .float32Operands = {},
4517 // int -> INT32 map
4518 .int32Operands = {{2, {160, -268}}},
4519 // int -> QUANT8_ASYMM map
4520 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
4521 // int -> QUANT16_SYMM map
4522 .quant16SymmOperands = {},
4523 // int -> FLOAT16 map
4524 .float16Operands = {},
4525 // int -> BOOL8 map
4526 .bool8Operands = {},
4527 // int -> QUANT8_SYMM_PER_CHANNEL map
4528 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, {1, 2, 2, 2}}},
4538 // int -> FLOAT32 map
4539 .float32Operands = {},
4540 // int -> INT32 map
4541 .int32Operands = {},
4542 // int -> QUANT8_ASYMM map
4543 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
4544 // int -> QUANT16_SYMM map
4545 .quant16SymmOperands = {},
4546 // int -> FLOAT16 map
4547 .float16Operands = {},
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_nchw_relu_channelQuant8_weight_as_input;
4561 };
4562
get_examples_nchw_relu_channelQuant8_2()4563 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8_2() {
4564 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8_2 = {
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, 2, 3, 3}}},
4572 // int -> FLOAT32 map
4573 .float32Operands = {},
4574 // int -> INT32 map
4575 .int32Operands = {},
4576 // int -> QUANT8_ASYMM map
4577 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
4595 // int -> FLOAT32 map
4596 .float32Operands = {},
4597 // int -> INT32 map
4598 .int32Operands = {},
4599 // int -> QUANT8_ASYMM map
4600 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 155, 125, 80}}},
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_nchw_relu_channelQuant8_2;
4618 };
4619
get_examples_nchw_relu_channelQuant8_weight_as_input_2()4620 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8_weight_as_input_2() {
4621 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8_weight_as_input_2 = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4629 // int -> FLOAT32 map
4630 .float32Operands = {},
4631 // int -> INT32 map
4632 .int32Operands = {{2, {160, -268}}},
4633 // int -> QUANT8_ASYMM map
4634 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, {1, 2, 2, 2}}},
4652 // int -> FLOAT32 map
4653 .float32Operands = {},
4654 // int -> INT32 map
4655 .int32Operands = {},
4656 // int -> QUANT8_ASYMM map
4657 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 155, 125, 80}}},
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_nchw_relu_channelQuant8_weight_as_input_2;
4675 };
4676
get_examples_nchw_relu_float16()4677 std::vector<MixedTypedExample>& get_examples_nchw_relu_float16() {
4678 static std::vector<MixedTypedExample> examples_nchw_relu_float16 = {
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, 2, 3, 3}}},
4686 // int -> FLOAT32 map
4687 .float32Operands = {},
4688 // int -> INT32 map
4689 .int32Operands = {},
4690 // int -> QUANT8_ASYMM map
4691 .quant8AsymmOperands = {},
4692 // int -> QUANT16_SYMM map
4693 .quant16SymmOperands = {},
4694 // int -> FLOAT16 map
4695 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
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, {1, 2, 2, 2}}},
4709 // int -> FLOAT32 map
4710 .float32Operands = {},
4711 // int -> INT32 map
4712 .int32Operands = {},
4713 // int -> QUANT8_ASYMM map
4714 .quant8AsymmOperands = {},
4715 // int -> QUANT16_SYMM map
4716 .quant16SymmOperands = {},
4717 // int -> FLOAT16 map
4718 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
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_nchw_relu_float16;
4732 };
4733
get_examples_nchw_relu_float16_weight_as_input()4734 std::vector<MixedTypedExample>& get_examples_nchw_relu_float16_weight_as_input() {
4735 static std::vector<MixedTypedExample> examples_nchw_relu_float16_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
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, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, {1, 2, 2, 2}}},
4766 // int -> FLOAT32 map
4767 .float32Operands = {},
4768 // int -> INT32 map
4769 .int32Operands = {},
4770 // int -> QUANT8_ASYMM map
4771 .quant8AsymmOperands = {},
4772 // int -> QUANT16_SYMM map
4773 .quant16SymmOperands = {},
4774 // int -> FLOAT16 map
4775 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 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_nchw_relu_float16_weight_as_input;
4789 };
4790
get_examples_nchw_relu1()4791 std::vector<MixedTypedExample>& get_examples_nchw_relu1() {
4792 static std::vector<MixedTypedExample> examples_nchw_relu1 = {
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, 2, 3, 3}}},
4800 // int -> FLOAT32 map
4801 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.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, {1, 2, 2, 2}}},
4823 // int -> FLOAT32 map
4824 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
4825 // int -> INT32 map
4826 .int32Operands = {},
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_nchw_relu1;
4846 };
4847
get_examples_nchw_relu1_weight_as_input()4848 std::vector<MixedTypedExample>& get_examples_nchw_relu1_weight_as_input() {
4849 static std::vector<MixedTypedExample> examples_nchw_relu1_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4857 // int -> FLOAT32 map
4858 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, {1, 2, 2, 2}}},
4880 // int -> FLOAT32 map
4881 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
4882 // int -> INT32 map
4883 .int32Operands = {},
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_nchw_relu1_weight_as_input;
4903 };
4904
get_examples_nchw_relu1_relaxed()4905 std::vector<MixedTypedExample>& get_examples_nchw_relu1_relaxed() {
4906 static std::vector<MixedTypedExample> examples_nchw_relu1_relaxed = {
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, 2, 3, 3}}},
4914 // int -> FLOAT32 map
4915 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
4916 // int -> INT32 map
4917 .int32Operands = {},
4918 // int -> QUANT8_ASYMM map
4919 .quant8AsymmOperands = {},
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, {1, 2, 2, 2}}},
4937 // int -> FLOAT32 map
4938 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
4939 // int -> INT32 map
4940 .int32Operands = {},
4941 // int -> QUANT8_ASYMM map
4942 .quant8AsymmOperands = {},
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_nchw_relu1_relaxed;
4960 };
4961
get_examples_nchw_relu1_relaxed_weight_as_input()4962 std::vector<MixedTypedExample>& get_examples_nchw_relu1_relaxed_weight_as_input() {
4963 static std::vector<MixedTypedExample> examples_nchw_relu1_relaxed_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
4971 // int -> FLOAT32 map
4972 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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 = {},
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, {1, 2, 2, 2}}},
4994 // int -> FLOAT32 map
4995 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
4996 // int -> INT32 map
4997 .int32Operands = {},
4998 // int -> QUANT8_ASYMM map
4999 .quant8AsymmOperands = {},
5000 // int -> QUANT16_SYMM map
5001 .quant16SymmOperands = {},
5002 // int -> FLOAT16 map
5003 .float16Operands = {},
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_nchw_relu1_relaxed_weight_as_input;
5017 };
5018
get_examples_nchw_relu1_quant8()5019 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8() {
5020 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8 = {
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, 2, 3, 3}}},
5028 // int -> FLOAT32 map
5029 .float32Operands = {},
5030 // int -> INT32 map
5031 .int32Operands = {},
5032 // int -> QUANT8_ASYMM map
5033 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
5051 // int -> FLOAT32 map
5052 .float32Operands = {},
5053 // int -> INT32 map
5054 .int32Operands = {},
5055 // int -> QUANT8_ASYMM map
5056 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
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_nchw_relu1_quant8;
5074 };
5075
get_examples_nchw_relu1_quant8_weight_as_input()5076 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8_weight_as_input() {
5077 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5085 // int -> FLOAT32 map
5086 .float32Operands = {},
5087 // int -> INT32 map
5088 .int32Operands = {{2, {160, -536}}},
5089 // int -> QUANT8_ASYMM map
5090 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
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, {1, 2, 2, 2}}},
5108 // int -> FLOAT32 map
5109 .float32Operands = {},
5110 // int -> INT32 map
5111 .int32Operands = {},
5112 // int -> QUANT8_ASYMM map
5113 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
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_nchw_relu1_quant8_weight_as_input;
5131 };
5132
get_examples_nchw_relu1_quant8_2()5133 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8_2() {
5134 static std::vector<MixedTypedExample> examples_nchw_relu1_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, 2, 3, 3}}},
5142 // int -> FLOAT32 map
5143 .float32Operands = {},
5144 // int -> INT32 map
5145 .int32Operands = {},
5146 // int -> QUANT8_ASYMM map
5147 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
5165 // int -> FLOAT32 map
5166 .float32Operands = {},
5167 // int -> INT32 map
5168 .int32Operands = {},
5169 // int -> QUANT8_ASYMM map
5170 .quant8AsymmOperands = {{0, {100, 100, 100, 100, 70, 100, 100, 60}}},
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_nchw_relu1_quant8_2;
5188 };
5189
get_examples_nchw_relu1_quant8_weight_as_input_2()5190 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8_weight_as_input_2() {
5191 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8_weight_as_input_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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5199 // int -> FLOAT32 map
5200 .float32Operands = {},
5201 // int -> INT32 map
5202 .int32Operands = {{2, {160, -536}}},
5203 // int -> QUANT8_ASYMM map
5204 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
5205 // int -> QUANT16_SYMM map
5206 .quant16SymmOperands = {},
5207 // int -> FLOAT16 map
5208 .float16Operands = {},
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, {1, 2, 2, 2}}},
5222 // int -> FLOAT32 map
5223 .float32Operands = {},
5224 // int -> INT32 map
5225 .int32Operands = {},
5226 // int -> QUANT8_ASYMM map
5227 .quant8AsymmOperands = {{0, {100, 100, 100, 100, 70, 100, 100, 60}}},
5228 // int -> QUANT16_SYMM map
5229 .quant16SymmOperands = {},
5230 // int -> FLOAT16 map
5231 .float16Operands = {},
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_nchw_relu1_quant8_weight_as_input_2;
5245 };
5246
get_examples_nchw_relu1_channelQuant8()5247 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8() {
5248 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8 = {
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, 2, 3, 3}}},
5256 // int -> FLOAT32 map
5257 .float32Operands = {},
5258 // int -> INT32 map
5259 .int32Operands = {},
5260 // int -> QUANT8_ASYMM map
5261 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
5279 // int -> FLOAT32 map
5280 .float32Operands = {},
5281 // int -> INT32 map
5282 .int32Operands = {},
5283 // int -> QUANT8_ASYMM map
5284 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
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_nchw_relu1_channelQuant8;
5302 };
5303
get_examples_nchw_relu1_channelQuant8_weight_as_input()5304 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8_weight_as_input() {
5305 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5313 // int -> FLOAT32 map
5314 .float32Operands = {},
5315 // int -> INT32 map
5316 .int32Operands = {{2, {160, -268}}},
5317 // int -> QUANT8_ASYMM map
5318 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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 = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, {1, 2, 2, 2}}},
5336 // int -> FLOAT32 map
5337 .float32Operands = {},
5338 // int -> INT32 map
5339 .int32Operands = {},
5340 // int -> QUANT8_ASYMM map
5341 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
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_nchw_relu1_channelQuant8_weight_as_input;
5359 };
5360
get_examples_nchw_relu1_channelQuant8_2()5361 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8_2() {
5362 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8_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, 2, 3, 3}}},
5370 // int -> FLOAT32 map
5371 .float32Operands = {},
5372 // int -> INT32 map
5373 .int32Operands = {},
5374 // int -> QUANT8_ASYMM map
5375 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
5393 // int -> FLOAT32 map
5394 .float32Operands = {},
5395 // int -> INT32 map
5396 .int32Operands = {},
5397 // int -> QUANT8_ASYMM map
5398 .quant8AsymmOperands = {{0, {90, 90, 90, 90, 75, 90, 90, 70}}},
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_nchw_relu1_channelQuant8_2;
5416 };
5417
get_examples_nchw_relu1_channelQuant8_weight_as_input_2()5418 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8_weight_as_input_2() {
5419 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8_weight_as_input_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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5427 // int -> FLOAT32 map
5428 .float32Operands = {},
5429 // int -> INT32 map
5430 .int32Operands = {{2, {160, -268}}},
5431 // int -> QUANT8_ASYMM map
5432 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
5433 // int -> QUANT16_SYMM map
5434 .quant16SymmOperands = {},
5435 // int -> FLOAT16 map
5436 .float16Operands = {},
5437 // int -> BOOL8 map
5438 .bool8Operands = {},
5439 // int -> QUANT8_SYMM_PER_CHANNEL map
5440 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
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, {1, 2, 2, 2}}},
5450 // int -> FLOAT32 map
5451 .float32Operands = {},
5452 // int -> INT32 map
5453 .int32Operands = {},
5454 // int -> QUANT8_ASYMM map
5455 .quant8AsymmOperands = {{0, {90, 90, 90, 90, 75, 90, 90, 70}}},
5456 // int -> QUANT16_SYMM map
5457 .quant16SymmOperands = {},
5458 // int -> FLOAT16 map
5459 .float16Operands = {},
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_nchw_relu1_channelQuant8_weight_as_input_2;
5473 };
5474
get_examples_nchw_relu1_float16()5475 std::vector<MixedTypedExample>& get_examples_nchw_relu1_float16() {
5476 static std::vector<MixedTypedExample> examples_nchw_relu1_float16 = {
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, 2, 3, 3}}},
5484 // int -> FLOAT32 map
5485 .float32Operands = {},
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 = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
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, {1, 2, 2, 2}}},
5507 // int -> FLOAT32 map
5508 .float32Operands = {},
5509 // int -> INT32 map
5510 .int32Operands = {},
5511 // int -> QUANT8_ASYMM map
5512 .quant8AsymmOperands = {},
5513 // int -> QUANT16_SYMM map
5514 .quant16SymmOperands = {},
5515 // int -> FLOAT16 map
5516 .float16Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
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_nchw_relu1_float16;
5530 };
5531
get_examples_nchw_relu1_float16_weight_as_input()5532 std::vector<MixedTypedExample>& get_examples_nchw_relu1_float16_weight_as_input() {
5533 static std::vector<MixedTypedExample> examples_nchw_relu1_float16_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5541 // int -> FLOAT32 map
5542 .float32Operands = {},
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 = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, {1, 2, 2, 2}}},
5564 // int -> FLOAT32 map
5565 .float32Operands = {},
5566 // int -> INT32 map
5567 .int32Operands = {},
5568 // int -> QUANT8_ASYMM map
5569 .quant8AsymmOperands = {},
5570 // int -> QUANT16_SYMM map
5571 .quant16SymmOperands = {},
5572 // int -> FLOAT16 map
5573 .float16Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
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_nchw_relu1_float16_weight_as_input;
5587 };
5588
get_examples_nchw_relu6()5589 std::vector<MixedTypedExample>& get_examples_nchw_relu6() {
5590 static std::vector<MixedTypedExample> examples_nchw_relu6 = {
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, 2, 3, 3}}},
5598 // int -> FLOAT32 map
5599 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
5600 // int -> INT32 map
5601 .int32Operands = {},
5602 // int -> QUANT8_ASYMM map
5603 .quant8AsymmOperands = {},
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, {1, 2, 2, 2}}},
5621 // int -> FLOAT32 map
5622 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
5623 // int -> INT32 map
5624 .int32Operands = {},
5625 // int -> QUANT8_ASYMM map
5626 .quant8AsymmOperands = {},
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_nchw_relu6;
5644 };
5645
get_examples_nchw_relu6_weight_as_input()5646 std::vector<MixedTypedExample>& get_examples_nchw_relu6_weight_as_input() {
5647 static std::vector<MixedTypedExample> examples_nchw_relu6_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5655 // int -> FLOAT32 map
5656 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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 = {},
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, {1, 2, 2, 2}}},
5678 // int -> FLOAT32 map
5679 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
5680 // int -> INT32 map
5681 .int32Operands = {},
5682 // int -> QUANT8_ASYMM map
5683 .quant8AsymmOperands = {},
5684 // int -> QUANT16_SYMM map
5685 .quant16SymmOperands = {},
5686 // int -> FLOAT16 map
5687 .float16Operands = {},
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_nchw_relu6_weight_as_input;
5701 };
5702
get_examples_nchw_relu6_relaxed()5703 std::vector<MixedTypedExample>& get_examples_nchw_relu6_relaxed() {
5704 static std::vector<MixedTypedExample> examples_nchw_relu6_relaxed = {
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, 2, 3, 3}}},
5712 // int -> FLOAT32 map
5713 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.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, {1, 2, 2, 2}}},
5735 // int -> FLOAT32 map
5736 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
5737 // int -> INT32 map
5738 .int32Operands = {},
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_nchw_relu6_relaxed;
5758 };
5759
get_examples_nchw_relu6_relaxed_weight_as_input()5760 std::vector<MixedTypedExample>& get_examples_nchw_relu6_relaxed_weight_as_input() {
5761 static std::vector<MixedTypedExample> examples_nchw_relu6_relaxed_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5769 // int -> FLOAT32 map
5770 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
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, {1, 2, 2, 2}}},
5792 // int -> FLOAT32 map
5793 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
5794 // int -> INT32 map
5795 .int32Operands = {},
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_nchw_relu6_relaxed_weight_as_input;
5815 };
5816
get_examples_nchw_relu6_quant8()5817 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8() {
5818 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8 = {
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, 2, 3, 3}}},
5826 // int -> FLOAT32 map
5827 .float32Operands = {},
5828 // int -> INT32 map
5829 .int32Operands = {},
5830 // int -> QUANT8_ASYMM map
5831 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
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, {1, 2, 2, 2}}},
5849 // int -> FLOAT32 map
5850 .float32Operands = {},
5851 // int -> INT32 map
5852 .int32Operands = {},
5853 // int -> QUANT8_ASYMM map
5854 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
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_nchw_relu6_quant8;
5872 };
5873
get_examples_nchw_relu6_quant8_weight_as_input()5874 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8_weight_as_input() {
5875 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8_weight_as_input = {
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, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5883 // int -> FLOAT32 map
5884 .float32Operands = {},
5885 // int -> INT32 map
5886 .int32Operands = {{2, {160, -536}}},
5887 // int -> QUANT8_ASYMM map
5888 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
5889 // int -> QUANT16_SYMM map
5890 .quant16SymmOperands = {},
5891 // int -> FLOAT16 map
5892 .float16Operands = {},
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, {1, 2, 2, 2}}},
5906 // int -> FLOAT32 map
5907 .float32Operands = {},
5908 // int -> INT32 map
5909 .int32Operands = {},
5910 // int -> QUANT8_ASYMM map
5911 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
5912 // int -> QUANT16_SYMM map
5913 .quant16SymmOperands = {},
5914 // int -> FLOAT16 map
5915 .float16Operands = {},
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_nchw_relu6_quant8_weight_as_input;
5929 };
5930
get_examples_nchw_relu6_quant8_2()5931 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8_2() {
5932 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8_2 = {
5933 // Begin of an example
5934 {
5935 .operands = {
5936 //Input(s)
5937 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5938 // int -> Dimensions map
5939 .operandDimensions = {{0, {1, 2, 3, 3}}},
5940 // int -> FLOAT32 map
5941 .float32Operands = {},
5942 // int -> INT32 map
5943 .int32Operands = {},
5944 // int -> QUANT8_ASYMM map
5945 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
5946 // int -> QUANT16_SYMM map
5947 .quant16SymmOperands = {},
5948 // int -> FLOAT16 map
5949 .float16Operands = {},
5950 // int -> BOOL8 map
5951 .bool8Operands = {},
5952 // int -> QUANT8_SYMM_PER_CHANNEL map
5953 .quant8ChannelOperands = {},
5954 // int -> QUANT16_ASYMM map
5955 .quant16AsymmOperands = {},
5956 // int -> QUANT8_SYMM map
5957 .quant8SymmOperands = {},
5958 },
5959 //Output(s)
5960 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5961 // int -> Dimensions map
5962 .operandDimensions = {{0, {1, 2, 2, 2}}},
5963 // int -> FLOAT32 map
5964 .float32Operands = {},
5965 // int -> INT32 map
5966 .int32Operands = {},
5967 // int -> QUANT8_ASYMM map
5968 .quant8AsymmOperands = {{0, {200, 200, 200, 200, 80, 200, 170, 80}}},
5969 // int -> QUANT16_SYMM map
5970 .quant16SymmOperands = {},
5971 // int -> FLOAT16 map
5972 .float16Operands = {},
5973 // int -> BOOL8 map
5974 .bool8Operands = {},
5975 // int -> QUANT8_SYMM_PER_CHANNEL map
5976 .quant8ChannelOperands = {},
5977 // int -> QUANT16_ASYMM map
5978 .quant16AsymmOperands = {},
5979 // int -> QUANT8_SYMM map
5980 .quant8SymmOperands = {},
5981 }
5982 },
5983 }, // End of an example
5984 };
5985 return examples_nchw_relu6_quant8_2;
5986 };
5987
get_examples_nchw_relu6_quant8_weight_as_input_2()5988 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8_weight_as_input_2() {
5989 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8_weight_as_input_2 = {
5990 // Begin of an example
5991 {
5992 .operands = {
5993 //Input(s)
5994 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5995 // int -> Dimensions map
5996 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
5997 // int -> FLOAT32 map
5998 .float32Operands = {},
5999 // int -> INT32 map
6000 .int32Operands = {{2, {160, -536}}},
6001 // int -> QUANT8_ASYMM map
6002 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
6003 // int -> QUANT16_SYMM map
6004 .quant16SymmOperands = {},
6005 // int -> FLOAT16 map
6006 .float16Operands = {},
6007 // int -> BOOL8 map
6008 .bool8Operands = {},
6009 // int -> QUANT8_SYMM_PER_CHANNEL map
6010 .quant8ChannelOperands = {},
6011 // int -> QUANT16_ASYMM map
6012 .quant16AsymmOperands = {},
6013 // int -> QUANT8_SYMM map
6014 .quant8SymmOperands = {},
6015 },
6016 //Output(s)
6017 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6018 // int -> Dimensions map
6019 .operandDimensions = {{0, {1, 2, 2, 2}}},
6020 // int -> FLOAT32 map
6021 .float32Operands = {},
6022 // int -> INT32 map
6023 .int32Operands = {},
6024 // int -> QUANT8_ASYMM map
6025 .quant8AsymmOperands = {{0, {200, 200, 200, 200, 80, 200, 170, 80}}},
6026 // int -> QUANT16_SYMM map
6027 .quant16SymmOperands = {},
6028 // int -> FLOAT16 map
6029 .float16Operands = {},
6030 // int -> BOOL8 map
6031 .bool8Operands = {},
6032 // int -> QUANT8_SYMM_PER_CHANNEL map
6033 .quant8ChannelOperands = {},
6034 // int -> QUANT16_ASYMM map
6035 .quant16AsymmOperands = {},
6036 // int -> QUANT8_SYMM map
6037 .quant8SymmOperands = {},
6038 }
6039 },
6040 }, // End of an example
6041 };
6042 return examples_nchw_relu6_quant8_weight_as_input_2;
6043 };
6044
get_examples_nchw_relu6_channelQuant8()6045 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8() {
6046 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8 = {
6047 // Begin of an example
6048 {
6049 .operands = {
6050 //Input(s)
6051 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6052 // int -> Dimensions map
6053 .operandDimensions = {{0, {1, 2, 3, 3}}},
6054 // int -> FLOAT32 map
6055 .float32Operands = {},
6056 // int -> INT32 map
6057 .int32Operands = {},
6058 // int -> QUANT8_ASYMM map
6059 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
6060 // int -> QUANT16_SYMM map
6061 .quant16SymmOperands = {},
6062 // int -> FLOAT16 map
6063 .float16Operands = {},
6064 // int -> BOOL8 map
6065 .bool8Operands = {},
6066 // int -> QUANT8_SYMM_PER_CHANNEL map
6067 .quant8ChannelOperands = {},
6068 // int -> QUANT16_ASYMM map
6069 .quant16AsymmOperands = {},
6070 // int -> QUANT8_SYMM map
6071 .quant8SymmOperands = {},
6072 },
6073 //Output(s)
6074 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6075 // int -> Dimensions map
6076 .operandDimensions = {{0, {1, 2, 2, 2}}},
6077 // int -> FLOAT32 map
6078 .float32Operands = {},
6079 // int -> INT32 map
6080 .int32Operands = {},
6081 // int -> QUANT8_ASYMM map
6082 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
6083 // int -> QUANT16_SYMM map
6084 .quant16SymmOperands = {},
6085 // int -> FLOAT16 map
6086 .float16Operands = {},
6087 // int -> BOOL8 map
6088 .bool8Operands = {},
6089 // int -> QUANT8_SYMM_PER_CHANNEL map
6090 .quant8ChannelOperands = {},
6091 // int -> QUANT16_ASYMM map
6092 .quant16AsymmOperands = {},
6093 // int -> QUANT8_SYMM map
6094 .quant8SymmOperands = {},
6095 }
6096 },
6097 }, // End of an example
6098 };
6099 return examples_nchw_relu6_channelQuant8;
6100 };
6101
get_examples_nchw_relu6_channelQuant8_weight_as_input()6102 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8_weight_as_input() {
6103 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8_weight_as_input = {
6104 // Begin of an example
6105 {
6106 .operands = {
6107 //Input(s)
6108 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6109 // int -> Dimensions map
6110 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6111 // int -> FLOAT32 map
6112 .float32Operands = {},
6113 // int -> INT32 map
6114 .int32Operands = {{2, {160, -268}}},
6115 // int -> QUANT8_ASYMM map
6116 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
6117 // int -> QUANT16_SYMM map
6118 .quant16SymmOperands = {},
6119 // int -> FLOAT16 map
6120 .float16Operands = {},
6121 // int -> BOOL8 map
6122 .bool8Operands = {},
6123 // int -> QUANT8_SYMM_PER_CHANNEL map
6124 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
6125 // int -> QUANT16_ASYMM map
6126 .quant16AsymmOperands = {},
6127 // int -> QUANT8_SYMM map
6128 .quant8SymmOperands = {},
6129 },
6130 //Output(s)
6131 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6132 // int -> Dimensions map
6133 .operandDimensions = {{0, {1, 2, 2, 2}}},
6134 // int -> FLOAT32 map
6135 .float32Operands = {},
6136 // int -> INT32 map
6137 .int32Operands = {},
6138 // int -> QUANT8_ASYMM map
6139 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
6140 // int -> QUANT16_SYMM map
6141 .quant16SymmOperands = {},
6142 // int -> FLOAT16 map
6143 .float16Operands = {},
6144 // int -> BOOL8 map
6145 .bool8Operands = {},
6146 // int -> QUANT8_SYMM_PER_CHANNEL map
6147 .quant8ChannelOperands = {},
6148 // int -> QUANT16_ASYMM map
6149 .quant16AsymmOperands = {},
6150 // int -> QUANT8_SYMM map
6151 .quant8SymmOperands = {},
6152 }
6153 },
6154 }, // End of an example
6155 };
6156 return examples_nchw_relu6_channelQuant8_weight_as_input;
6157 };
6158
get_examples_nchw_relu6_channelQuant8_2()6159 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8_2() {
6160 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8_2 = {
6161 // Begin of an example
6162 {
6163 .operands = {
6164 //Input(s)
6165 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6166 // int -> Dimensions map
6167 .operandDimensions = {{0, {1, 2, 3, 3}}},
6168 // int -> FLOAT32 map
6169 .float32Operands = {},
6170 // int -> INT32 map
6171 .int32Operands = {},
6172 // int -> QUANT8_ASYMM map
6173 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
6174 // int -> QUANT16_SYMM map
6175 .quant16SymmOperands = {},
6176 // int -> FLOAT16 map
6177 .float16Operands = {},
6178 // int -> BOOL8 map
6179 .bool8Operands = {},
6180 // int -> QUANT8_SYMM_PER_CHANNEL map
6181 .quant8ChannelOperands = {},
6182 // int -> QUANT16_ASYMM map
6183 .quant16AsymmOperands = {},
6184 // int -> QUANT8_SYMM map
6185 .quant8SymmOperands = {},
6186 },
6187 //Output(s)
6188 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6189 // int -> Dimensions map
6190 .operandDimensions = {{0, {1, 2, 2, 2}}},
6191 // int -> FLOAT32 map
6192 .float32Operands = {},
6193 // int -> INT32 map
6194 .int32Operands = {},
6195 // int -> QUANT8_ASYMM map
6196 .quant8AsymmOperands = {{0, {140, 140, 140, 140, 80, 140, 125, 80}}},
6197 // int -> QUANT16_SYMM map
6198 .quant16SymmOperands = {},
6199 // int -> FLOAT16 map
6200 .float16Operands = {},
6201 // int -> BOOL8 map
6202 .bool8Operands = {},
6203 // int -> QUANT8_SYMM_PER_CHANNEL map
6204 .quant8ChannelOperands = {},
6205 // int -> QUANT16_ASYMM map
6206 .quant16AsymmOperands = {},
6207 // int -> QUANT8_SYMM map
6208 .quant8SymmOperands = {},
6209 }
6210 },
6211 }, // End of an example
6212 };
6213 return examples_nchw_relu6_channelQuant8_2;
6214 };
6215
get_examples_nchw_relu6_channelQuant8_weight_as_input_2()6216 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8_weight_as_input_2() {
6217 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8_weight_as_input_2 = {
6218 // Begin of an example
6219 {
6220 .operands = {
6221 //Input(s)
6222 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6223 // int -> Dimensions map
6224 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6225 // int -> FLOAT32 map
6226 .float32Operands = {},
6227 // int -> INT32 map
6228 .int32Operands = {{2, {160, -268}}},
6229 // int -> QUANT8_ASYMM map
6230 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
6231 // int -> QUANT16_SYMM map
6232 .quant16SymmOperands = {},
6233 // int -> FLOAT16 map
6234 .float16Operands = {},
6235 // int -> BOOL8 map
6236 .bool8Operands = {},
6237 // int -> QUANT8_SYMM_PER_CHANNEL map
6238 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
6239 // int -> QUANT16_ASYMM map
6240 .quant16AsymmOperands = {},
6241 // int -> QUANT8_SYMM map
6242 .quant8SymmOperands = {},
6243 },
6244 //Output(s)
6245 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6246 // int -> Dimensions map
6247 .operandDimensions = {{0, {1, 2, 2, 2}}},
6248 // int -> FLOAT32 map
6249 .float32Operands = {},
6250 // int -> INT32 map
6251 .int32Operands = {},
6252 // int -> QUANT8_ASYMM map
6253 .quant8AsymmOperands = {{0, {140, 140, 140, 140, 80, 140, 125, 80}}},
6254 // int -> QUANT16_SYMM map
6255 .quant16SymmOperands = {},
6256 // int -> FLOAT16 map
6257 .float16Operands = {},
6258 // int -> BOOL8 map
6259 .bool8Operands = {},
6260 // int -> QUANT8_SYMM_PER_CHANNEL map
6261 .quant8ChannelOperands = {},
6262 // int -> QUANT16_ASYMM map
6263 .quant16AsymmOperands = {},
6264 // int -> QUANT8_SYMM map
6265 .quant8SymmOperands = {},
6266 }
6267 },
6268 }, // End of an example
6269 };
6270 return examples_nchw_relu6_channelQuant8_weight_as_input_2;
6271 };
6272
get_examples_nchw_relu6_float16()6273 std::vector<MixedTypedExample>& get_examples_nchw_relu6_float16() {
6274 static std::vector<MixedTypedExample> examples_nchw_relu6_float16 = {
6275 // Begin of an example
6276 {
6277 .operands = {
6278 //Input(s)
6279 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6280 // int -> Dimensions map
6281 .operandDimensions = {{0, {1, 2, 3, 3}}},
6282 // int -> FLOAT32 map
6283 .float32Operands = {},
6284 // int -> INT32 map
6285 .int32Operands = {},
6286 // int -> QUANT8_ASYMM map
6287 .quant8AsymmOperands = {},
6288 // int -> QUANT16_SYMM map
6289 .quant16SymmOperands = {},
6290 // int -> FLOAT16 map
6291 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
6292 // int -> BOOL8 map
6293 .bool8Operands = {},
6294 // int -> QUANT8_SYMM_PER_CHANNEL map
6295 .quant8ChannelOperands = {},
6296 // int -> QUANT16_ASYMM map
6297 .quant16AsymmOperands = {},
6298 // int -> QUANT8_SYMM map
6299 .quant8SymmOperands = {},
6300 },
6301 //Output(s)
6302 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6303 // int -> Dimensions map
6304 .operandDimensions = {{0, {1, 2, 2, 2}}},
6305 // int -> FLOAT32 map
6306 .float32Operands = {},
6307 // int -> INT32 map
6308 .int32Operands = {},
6309 // int -> QUANT8_ASYMM map
6310 .quant8AsymmOperands = {},
6311 // int -> QUANT16_SYMM map
6312 .quant16SymmOperands = {},
6313 // int -> FLOAT16 map
6314 .float16Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
6315 // int -> BOOL8 map
6316 .bool8Operands = {},
6317 // int -> QUANT8_SYMM_PER_CHANNEL map
6318 .quant8ChannelOperands = {},
6319 // int -> QUANT16_ASYMM map
6320 .quant16AsymmOperands = {},
6321 // int -> QUANT8_SYMM map
6322 .quant8SymmOperands = {},
6323 }
6324 },
6325 }, // End of an example
6326 };
6327 return examples_nchw_relu6_float16;
6328 };
6329
get_examples_nchw_relu6_float16_weight_as_input()6330 std::vector<MixedTypedExample>& get_examples_nchw_relu6_float16_weight_as_input() {
6331 static std::vector<MixedTypedExample> examples_nchw_relu6_float16_weight_as_input = {
6332 // Begin of an example
6333 {
6334 .operands = {
6335 //Input(s)
6336 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6337 // int -> Dimensions map
6338 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6339 // int -> FLOAT32 map
6340 .float32Operands = {},
6341 // int -> INT32 map
6342 .int32Operands = {},
6343 // int -> QUANT8_ASYMM map
6344 .quant8AsymmOperands = {},
6345 // int -> QUANT16_SYMM map
6346 .quant16SymmOperands = {},
6347 // int -> FLOAT16 map
6348 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
6349 // int -> BOOL8 map
6350 .bool8Operands = {},
6351 // int -> QUANT8_SYMM_PER_CHANNEL map
6352 .quant8ChannelOperands = {},
6353 // int -> QUANT16_ASYMM map
6354 .quant16AsymmOperands = {},
6355 // int -> QUANT8_SYMM map
6356 .quant8SymmOperands = {},
6357 },
6358 //Output(s)
6359 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6360 // int -> Dimensions map
6361 .operandDimensions = {{0, {1, 2, 2, 2}}},
6362 // int -> FLOAT32 map
6363 .float32Operands = {},
6364 // int -> INT32 map
6365 .int32Operands = {},
6366 // int -> QUANT8_ASYMM map
6367 .quant8AsymmOperands = {},
6368 // int -> QUANT16_SYMM map
6369 .quant16SymmOperands = {},
6370 // int -> FLOAT16 map
6371 .float16Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
6372 // int -> BOOL8 map
6373 .bool8Operands = {},
6374 // int -> QUANT8_SYMM_PER_CHANNEL map
6375 .quant8ChannelOperands = {},
6376 // int -> QUANT16_ASYMM map
6377 .quant16AsymmOperands = {},
6378 // int -> QUANT8_SYMM map
6379 .quant8SymmOperands = {},
6380 }
6381 },
6382 }, // End of an example
6383 };
6384 return examples_nchw_relu6_float16_weight_as_input;
6385 };
6386
get_examples_dynamic_output_shape_nhwc_none()6387 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none() {
6388 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none = {
6389 // Begin of an example
6390 {
6391 .operands = {
6392 //Input(s)
6393 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6394 // int -> Dimensions map
6395 .operandDimensions = {{0, {1, 3, 3, 2}}},
6396 // int -> FLOAT32 map
6397 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
6398 // int -> INT32 map
6399 .int32Operands = {},
6400 // int -> QUANT8_ASYMM map
6401 .quant8AsymmOperands = {},
6402 // int -> QUANT16_SYMM map
6403 .quant16SymmOperands = {},
6404 // int -> FLOAT16 map
6405 .float16Operands = {},
6406 // int -> BOOL8 map
6407 .bool8Operands = {},
6408 // int -> QUANT8_SYMM_PER_CHANNEL map
6409 .quant8ChannelOperands = {},
6410 // int -> QUANT16_ASYMM map
6411 .quant16AsymmOperands = {},
6412 // int -> QUANT8_SYMM map
6413 .quant8SymmOperands = {},
6414 },
6415 //Output(s)
6416 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6417 // int -> Dimensions map
6418 .operandDimensions = {{0, {1, 2, 2, 2}}},
6419 // int -> FLOAT32 map
6420 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
6421 // int -> INT32 map
6422 .int32Operands = {},
6423 // int -> QUANT8_ASYMM map
6424 .quant8AsymmOperands = {},
6425 // int -> QUANT16_SYMM map
6426 .quant16SymmOperands = {},
6427 // int -> FLOAT16 map
6428 .float16Operands = {},
6429 // int -> BOOL8 map
6430 .bool8Operands = {},
6431 // int -> QUANT8_SYMM_PER_CHANNEL map
6432 .quant8ChannelOperands = {},
6433 // int -> QUANT16_ASYMM map
6434 .quant16AsymmOperands = {},
6435 // int -> QUANT8_SYMM map
6436 .quant8SymmOperands = {},
6437 }
6438 },
6439 }, // End of an example
6440 };
6441 return examples_dynamic_output_shape_nhwc_none;
6442 };
6443
get_examples_dynamic_output_shape_nhwc_none_weight_as_input()6444 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_weight_as_input() {
6445 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_weight_as_input = {
6446 // Begin of an example
6447 {
6448 .operands = {
6449 //Input(s)
6450 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6451 // int -> Dimensions map
6452 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6453 // int -> FLOAT32 map
6454 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
6455 // int -> INT32 map
6456 .int32Operands = {},
6457 // int -> QUANT8_ASYMM map
6458 .quant8AsymmOperands = {},
6459 // int -> QUANT16_SYMM map
6460 .quant16SymmOperands = {},
6461 // int -> FLOAT16 map
6462 .float16Operands = {},
6463 // int -> BOOL8 map
6464 .bool8Operands = {},
6465 // int -> QUANT8_SYMM_PER_CHANNEL map
6466 .quant8ChannelOperands = {},
6467 // int -> QUANT16_ASYMM map
6468 .quant16AsymmOperands = {},
6469 // int -> QUANT8_SYMM map
6470 .quant8SymmOperands = {},
6471 },
6472 //Output(s)
6473 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6474 // int -> Dimensions map
6475 .operandDimensions = {{0, {1, 2, 2, 2}}},
6476 // int -> FLOAT32 map
6477 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
6478 // int -> INT32 map
6479 .int32Operands = {},
6480 // int -> QUANT8_ASYMM map
6481 .quant8AsymmOperands = {},
6482 // int -> QUANT16_SYMM map
6483 .quant16SymmOperands = {},
6484 // int -> FLOAT16 map
6485 .float16Operands = {},
6486 // int -> BOOL8 map
6487 .bool8Operands = {},
6488 // int -> QUANT8_SYMM_PER_CHANNEL map
6489 .quant8ChannelOperands = {},
6490 // int -> QUANT16_ASYMM map
6491 .quant16AsymmOperands = {},
6492 // int -> QUANT8_SYMM map
6493 .quant8SymmOperands = {},
6494 }
6495 },
6496 }, // End of an example
6497 };
6498 return examples_dynamic_output_shape_nhwc_none_weight_as_input;
6499 };
6500
get_examples_dynamic_output_shape_nhwc_none_relaxed()6501 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_relaxed() {
6502 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_relaxed = {
6503 // Begin of an example
6504 {
6505 .operands = {
6506 //Input(s)
6507 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6508 // int -> Dimensions map
6509 .operandDimensions = {{0, {1, 3, 3, 2}}},
6510 // int -> FLOAT32 map
6511 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
6512 // int -> INT32 map
6513 .int32Operands = {},
6514 // int -> QUANT8_ASYMM map
6515 .quant8AsymmOperands = {},
6516 // int -> QUANT16_SYMM map
6517 .quant16SymmOperands = {},
6518 // int -> FLOAT16 map
6519 .float16Operands = {},
6520 // int -> BOOL8 map
6521 .bool8Operands = {},
6522 // int -> QUANT8_SYMM_PER_CHANNEL map
6523 .quant8ChannelOperands = {},
6524 // int -> QUANT16_ASYMM map
6525 .quant16AsymmOperands = {},
6526 // int -> QUANT8_SYMM map
6527 .quant8SymmOperands = {},
6528 },
6529 //Output(s)
6530 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6531 // int -> Dimensions map
6532 .operandDimensions = {{0, {1, 2, 2, 2}}},
6533 // int -> FLOAT32 map
6534 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
6535 // int -> INT32 map
6536 .int32Operands = {},
6537 // int -> QUANT8_ASYMM map
6538 .quant8AsymmOperands = {},
6539 // int -> QUANT16_SYMM map
6540 .quant16SymmOperands = {},
6541 // int -> FLOAT16 map
6542 .float16Operands = {},
6543 // int -> BOOL8 map
6544 .bool8Operands = {},
6545 // int -> QUANT8_SYMM_PER_CHANNEL map
6546 .quant8ChannelOperands = {},
6547 // int -> QUANT16_ASYMM map
6548 .quant16AsymmOperands = {},
6549 // int -> QUANT8_SYMM map
6550 .quant8SymmOperands = {},
6551 }
6552 },
6553 }, // End of an example
6554 };
6555 return examples_dynamic_output_shape_nhwc_none_relaxed;
6556 };
6557
get_examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input()6558 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input() {
6559 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input = {
6560 // Begin of an example
6561 {
6562 .operands = {
6563 //Input(s)
6564 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6565 // int -> Dimensions map
6566 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6567 // int -> FLOAT32 map
6568 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
6569 // int -> INT32 map
6570 .int32Operands = {},
6571 // int -> QUANT8_ASYMM map
6572 .quant8AsymmOperands = {},
6573 // int -> QUANT16_SYMM map
6574 .quant16SymmOperands = {},
6575 // int -> FLOAT16 map
6576 .float16Operands = {},
6577 // int -> BOOL8 map
6578 .bool8Operands = {},
6579 // int -> QUANT8_SYMM_PER_CHANNEL map
6580 .quant8ChannelOperands = {},
6581 // int -> QUANT16_ASYMM map
6582 .quant16AsymmOperands = {},
6583 // int -> QUANT8_SYMM map
6584 .quant8SymmOperands = {},
6585 },
6586 //Output(s)
6587 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6588 // int -> Dimensions map
6589 .operandDimensions = {{0, {1, 2, 2, 2}}},
6590 // int -> FLOAT32 map
6591 .float32Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
6592 // int -> INT32 map
6593 .int32Operands = {},
6594 // int -> QUANT8_ASYMM map
6595 .quant8AsymmOperands = {},
6596 // int -> QUANT16_SYMM map
6597 .quant16SymmOperands = {},
6598 // int -> FLOAT16 map
6599 .float16Operands = {},
6600 // int -> BOOL8 map
6601 .bool8Operands = {},
6602 // int -> QUANT8_SYMM_PER_CHANNEL map
6603 .quant8ChannelOperands = {},
6604 // int -> QUANT16_ASYMM map
6605 .quant16AsymmOperands = {},
6606 // int -> QUANT8_SYMM map
6607 .quant8SymmOperands = {},
6608 }
6609 },
6610 }, // End of an example
6611 };
6612 return examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input;
6613 };
6614
get_examples_dynamic_output_shape_nhwc_none_quant8()6615 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8() {
6616 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8 = {
6617 // Begin of an example
6618 {
6619 .operands = {
6620 //Input(s)
6621 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6622 // int -> Dimensions map
6623 .operandDimensions = {{0, {1, 3, 3, 2}}},
6624 // int -> FLOAT32 map
6625 .float32Operands = {},
6626 // int -> INT32 map
6627 .int32Operands = {},
6628 // int -> QUANT8_ASYMM map
6629 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
6630 // int -> QUANT16_SYMM map
6631 .quant16SymmOperands = {},
6632 // int -> FLOAT16 map
6633 .float16Operands = {},
6634 // int -> BOOL8 map
6635 .bool8Operands = {},
6636 // int -> QUANT8_SYMM_PER_CHANNEL map
6637 .quant8ChannelOperands = {},
6638 // int -> QUANT16_ASYMM map
6639 .quant16AsymmOperands = {},
6640 // int -> QUANT8_SYMM map
6641 .quant8SymmOperands = {},
6642 },
6643 //Output(s)
6644 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6645 // int -> Dimensions map
6646 .operandDimensions = {{0, {1, 2, 2, 2}}},
6647 // int -> FLOAT32 map
6648 .float32Operands = {},
6649 // int -> INT32 map
6650 .int32Operands = {},
6651 // int -> QUANT8_ASYMM map
6652 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
6653 // int -> QUANT16_SYMM map
6654 .quant16SymmOperands = {},
6655 // int -> FLOAT16 map
6656 .float16Operands = {},
6657 // int -> BOOL8 map
6658 .bool8Operands = {},
6659 // int -> QUANT8_SYMM_PER_CHANNEL map
6660 .quant8ChannelOperands = {},
6661 // int -> QUANT16_ASYMM map
6662 .quant16AsymmOperands = {},
6663 // int -> QUANT8_SYMM map
6664 .quant8SymmOperands = {},
6665 }
6666 },
6667 }, // End of an example
6668 };
6669 return examples_dynamic_output_shape_nhwc_none_quant8;
6670 };
6671
get_examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input()6672 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input() {
6673 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input = {
6674 // Begin of an example
6675 {
6676 .operands = {
6677 //Input(s)
6678 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6679 // int -> Dimensions map
6680 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6681 // int -> FLOAT32 map
6682 .float32Operands = {},
6683 // int -> INT32 map
6684 .int32Operands = {{2, {160, -536}}},
6685 // int -> QUANT8_ASYMM map
6686 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
6687 // int -> QUANT16_SYMM map
6688 .quant16SymmOperands = {},
6689 // int -> FLOAT16 map
6690 .float16Operands = {},
6691 // int -> BOOL8 map
6692 .bool8Operands = {},
6693 // int -> QUANT8_SYMM_PER_CHANNEL map
6694 .quant8ChannelOperands = {},
6695 // int -> QUANT16_ASYMM map
6696 .quant16AsymmOperands = {},
6697 // int -> QUANT8_SYMM map
6698 .quant8SymmOperands = {},
6699 },
6700 //Output(s)
6701 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6702 // int -> Dimensions map
6703 .operandDimensions = {{0, {1, 2, 2, 2}}},
6704 // int -> FLOAT32 map
6705 .float32Operands = {},
6706 // int -> INT32 map
6707 .int32Operands = {},
6708 // int -> QUANT8_ASYMM map
6709 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
6710 // int -> QUANT16_SYMM map
6711 .quant16SymmOperands = {},
6712 // int -> FLOAT16 map
6713 .float16Operands = {},
6714 // int -> BOOL8 map
6715 .bool8Operands = {},
6716 // int -> QUANT8_SYMM_PER_CHANNEL map
6717 .quant8ChannelOperands = {},
6718 // int -> QUANT16_ASYMM map
6719 .quant16AsymmOperands = {},
6720 // int -> QUANT8_SYMM map
6721 .quant8SymmOperands = {},
6722 }
6723 },
6724 }, // End of an example
6725 };
6726 return examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input;
6727 };
6728
get_examples_dynamic_output_shape_nhwc_none_quant8_2()6729 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8_2() {
6730 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8_2 = {
6731 // Begin of an example
6732 {
6733 .operands = {
6734 //Input(s)
6735 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6736 // int -> Dimensions map
6737 .operandDimensions = {{0, {1, 3, 3, 2}}},
6738 // int -> FLOAT32 map
6739 .float32Operands = {},
6740 // int -> INT32 map
6741 .int32Operands = {},
6742 // int -> QUANT8_ASYMM map
6743 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
6744 // int -> QUANT16_SYMM map
6745 .quant16SymmOperands = {},
6746 // int -> FLOAT16 map
6747 .float16Operands = {},
6748 // int -> BOOL8 map
6749 .bool8Operands = {},
6750 // int -> QUANT8_SYMM_PER_CHANNEL map
6751 .quant8ChannelOperands = {},
6752 // int -> QUANT16_ASYMM map
6753 .quant16AsymmOperands = {},
6754 // int -> QUANT8_SYMM map
6755 .quant8SymmOperands = {},
6756 },
6757 //Output(s)
6758 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6759 // int -> Dimensions map
6760 .operandDimensions = {{0, {1, 2, 2, 2}}},
6761 // int -> FLOAT32 map
6762 .float32Operands = {},
6763 // int -> INT32 map
6764 .int32Operands = {},
6765 // int -> QUANT8_ASYMM map
6766 .quant8AsymmOperands = {{0, {255, 70, 255, 230, 255, 170, 255, 0}}},
6767 // int -> QUANT16_SYMM map
6768 .quant16SymmOperands = {},
6769 // int -> FLOAT16 map
6770 .float16Operands = {},
6771 // int -> BOOL8 map
6772 .bool8Operands = {},
6773 // int -> QUANT8_SYMM_PER_CHANNEL map
6774 .quant8ChannelOperands = {},
6775 // int -> QUANT16_ASYMM map
6776 .quant16AsymmOperands = {},
6777 // int -> QUANT8_SYMM map
6778 .quant8SymmOperands = {},
6779 }
6780 },
6781 }, // End of an example
6782 };
6783 return examples_dynamic_output_shape_nhwc_none_quant8_2;
6784 };
6785
get_examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2()6786 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2() {
6787 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2 = {
6788 // Begin of an example
6789 {
6790 .operands = {
6791 //Input(s)
6792 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6793 // int -> Dimensions map
6794 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6795 // int -> FLOAT32 map
6796 .float32Operands = {},
6797 // int -> INT32 map
6798 .int32Operands = {{2, {160, -536}}},
6799 // int -> QUANT8_ASYMM map
6800 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
6801 // int -> QUANT16_SYMM map
6802 .quant16SymmOperands = {},
6803 // int -> FLOAT16 map
6804 .float16Operands = {},
6805 // int -> BOOL8 map
6806 .bool8Operands = {},
6807 // int -> QUANT8_SYMM_PER_CHANNEL map
6808 .quant8ChannelOperands = {},
6809 // int -> QUANT16_ASYMM map
6810 .quant16AsymmOperands = {},
6811 // int -> QUANT8_SYMM map
6812 .quant8SymmOperands = {},
6813 },
6814 //Output(s)
6815 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6816 // int -> Dimensions map
6817 .operandDimensions = {{0, {1, 2, 2, 2}}},
6818 // int -> FLOAT32 map
6819 .float32Operands = {},
6820 // int -> INT32 map
6821 .int32Operands = {},
6822 // int -> QUANT8_ASYMM map
6823 .quant8AsymmOperands = {{0, {255, 70, 255, 230, 255, 170, 255, 0}}},
6824 // int -> QUANT16_SYMM map
6825 .quant16SymmOperands = {},
6826 // int -> FLOAT16 map
6827 .float16Operands = {},
6828 // int -> BOOL8 map
6829 .bool8Operands = {},
6830 // int -> QUANT8_SYMM_PER_CHANNEL map
6831 .quant8ChannelOperands = {},
6832 // int -> QUANT16_ASYMM map
6833 .quant16AsymmOperands = {},
6834 // int -> QUANT8_SYMM map
6835 .quant8SymmOperands = {},
6836 }
6837 },
6838 }, // End of an example
6839 };
6840 return examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2;
6841 };
6842
get_examples_dynamic_output_shape_nhwc_none_channelQuant8()6843 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8() {
6844 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8 = {
6845 // Begin of an example
6846 {
6847 .operands = {
6848 //Input(s)
6849 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6850 // int -> Dimensions map
6851 .operandDimensions = {{0, {1, 3, 3, 2}}},
6852 // int -> FLOAT32 map
6853 .float32Operands = {},
6854 // int -> INT32 map
6855 .int32Operands = {},
6856 // int -> QUANT8_ASYMM map
6857 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
6858 // int -> QUANT16_SYMM map
6859 .quant16SymmOperands = {},
6860 // int -> FLOAT16 map
6861 .float16Operands = {},
6862 // int -> BOOL8 map
6863 .bool8Operands = {},
6864 // int -> QUANT8_SYMM_PER_CHANNEL map
6865 .quant8ChannelOperands = {},
6866 // int -> QUANT16_ASYMM map
6867 .quant16AsymmOperands = {},
6868 // int -> QUANT8_SYMM map
6869 .quant8SymmOperands = {},
6870 },
6871 //Output(s)
6872 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6873 // int -> Dimensions map
6874 .operandDimensions = {{0, {1, 2, 2, 2}}},
6875 // int -> FLOAT32 map
6876 .float32Operands = {},
6877 // int -> INT32 map
6878 .int32Operands = {},
6879 // int -> QUANT8_ASYMM map
6880 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
6881 // int -> QUANT16_SYMM map
6882 .quant16SymmOperands = {},
6883 // int -> FLOAT16 map
6884 .float16Operands = {},
6885 // int -> BOOL8 map
6886 .bool8Operands = {},
6887 // int -> QUANT8_SYMM_PER_CHANNEL map
6888 .quant8ChannelOperands = {},
6889 // int -> QUANT16_ASYMM map
6890 .quant16AsymmOperands = {},
6891 // int -> QUANT8_SYMM map
6892 .quant8SymmOperands = {},
6893 }
6894 },
6895 }, // End of an example
6896 };
6897 return examples_dynamic_output_shape_nhwc_none_channelQuant8;
6898 };
6899
get_examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input()6900 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input() {
6901 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input = {
6902 // Begin of an example
6903 {
6904 .operands = {
6905 //Input(s)
6906 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6907 // int -> Dimensions map
6908 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
6909 // int -> FLOAT32 map
6910 .float32Operands = {},
6911 // int -> INT32 map
6912 .int32Operands = {{2, {160, -268}}},
6913 // int -> QUANT8_ASYMM map
6914 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
6915 // int -> QUANT16_SYMM map
6916 .quant16SymmOperands = {},
6917 // int -> FLOAT16 map
6918 .float16Operands = {},
6919 // int -> BOOL8 map
6920 .bool8Operands = {},
6921 // int -> QUANT8_SYMM_PER_CHANNEL map
6922 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
6923 // int -> QUANT16_ASYMM map
6924 .quant16AsymmOperands = {},
6925 // int -> QUANT8_SYMM map
6926 .quant8SymmOperands = {},
6927 },
6928 //Output(s)
6929 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6930 // int -> Dimensions map
6931 .operandDimensions = {{0, {1, 2, 2, 2}}},
6932 // int -> FLOAT32 map
6933 .float32Operands = {},
6934 // int -> INT32 map
6935 .int32Operands = {},
6936 // int -> QUANT8_ASYMM map
6937 .quant8AsymmOperands = {{0, {146, 79, 146, 95, 142, 89, 134, 61}}},
6938 // int -> QUANT16_SYMM map
6939 .quant16SymmOperands = {},
6940 // int -> FLOAT16 map
6941 .float16Operands = {},
6942 // int -> BOOL8 map
6943 .bool8Operands = {},
6944 // int -> QUANT8_SYMM_PER_CHANNEL map
6945 .quant8ChannelOperands = {},
6946 // int -> QUANT16_ASYMM map
6947 .quant16AsymmOperands = {},
6948 // int -> QUANT8_SYMM map
6949 .quant8SymmOperands = {},
6950 }
6951 },
6952 }, // End of an example
6953 };
6954 return examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input;
6955 };
6956
get_examples_dynamic_output_shape_nhwc_none_channelQuant8_2()6957 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8_2() {
6958 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8_2 = {
6959 // Begin of an example
6960 {
6961 .operands = {
6962 //Input(s)
6963 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6964 // int -> Dimensions map
6965 .operandDimensions = {{0, {1, 3, 3, 2}}},
6966 // int -> FLOAT32 map
6967 .float32Operands = {},
6968 // int -> INT32 map
6969 .int32Operands = {},
6970 // int -> QUANT8_ASYMM map
6971 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
6972 // int -> QUANT16_SYMM map
6973 .quant16SymmOperands = {},
6974 // int -> FLOAT16 map
6975 .float16Operands = {},
6976 // int -> BOOL8 map
6977 .bool8Operands = {},
6978 // int -> QUANT8_SYMM_PER_CHANNEL map
6979 .quant8ChannelOperands = {},
6980 // int -> QUANT16_ASYMM map
6981 .quant16AsymmOperands = {},
6982 // int -> QUANT8_SYMM map
6983 .quant8SymmOperands = {},
6984 },
6985 //Output(s)
6986 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6987 // int -> Dimensions map
6988 .operandDimensions = {{0, {1, 2, 2, 2}}},
6989 // int -> FLOAT32 map
6990 .float32Operands = {},
6991 // int -> INT32 map
6992 .int32Operands = {},
6993 // int -> QUANT8_ASYMM map
6994 .quant8AsymmOperands = {{0, {255, 75, 255, 155, 255, 125, 255, 0}}},
6995 // int -> QUANT16_SYMM map
6996 .quant16SymmOperands = {},
6997 // int -> FLOAT16 map
6998 .float16Operands = {},
6999 // int -> BOOL8 map
7000 .bool8Operands = {},
7001 // int -> QUANT8_SYMM_PER_CHANNEL map
7002 .quant8ChannelOperands = {},
7003 // int -> QUANT16_ASYMM map
7004 .quant16AsymmOperands = {},
7005 // int -> QUANT8_SYMM map
7006 .quant8SymmOperands = {},
7007 }
7008 },
7009 }, // End of an example
7010 };
7011 return examples_dynamic_output_shape_nhwc_none_channelQuant8_2;
7012 };
7013
get_examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2()7014 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2() {
7015 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2 = {
7016 // Begin of an example
7017 {
7018 .operands = {
7019 //Input(s)
7020 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7021 // int -> Dimensions map
7022 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7023 // int -> FLOAT32 map
7024 .float32Operands = {},
7025 // int -> INT32 map
7026 .int32Operands = {{2, {160, -268}}},
7027 // int -> QUANT8_ASYMM map
7028 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7029 // int -> QUANT16_SYMM map
7030 .quant16SymmOperands = {},
7031 // int -> FLOAT16 map
7032 .float16Operands = {},
7033 // int -> BOOL8 map
7034 .bool8Operands = {},
7035 // int -> QUANT8_SYMM_PER_CHANNEL map
7036 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
7037 // int -> QUANT16_ASYMM map
7038 .quant16AsymmOperands = {},
7039 // int -> QUANT8_SYMM map
7040 .quant8SymmOperands = {},
7041 },
7042 //Output(s)
7043 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7044 // int -> Dimensions map
7045 .operandDimensions = {{0, {1, 2, 2, 2}}},
7046 // int -> FLOAT32 map
7047 .float32Operands = {},
7048 // int -> INT32 map
7049 .int32Operands = {},
7050 // int -> QUANT8_ASYMM map
7051 .quant8AsymmOperands = {{0, {255, 75, 255, 155, 255, 125, 255, 0}}},
7052 // int -> QUANT16_SYMM map
7053 .quant16SymmOperands = {},
7054 // int -> FLOAT16 map
7055 .float16Operands = {},
7056 // int -> BOOL8 map
7057 .bool8Operands = {},
7058 // int -> QUANT8_SYMM_PER_CHANNEL map
7059 .quant8ChannelOperands = {},
7060 // int -> QUANT16_ASYMM map
7061 .quant16AsymmOperands = {},
7062 // int -> QUANT8_SYMM map
7063 .quant8SymmOperands = {},
7064 }
7065 },
7066 }, // End of an example
7067 };
7068 return examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2;
7069 };
7070
get_examples_dynamic_output_shape_nhwc_none_float16()7071 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_float16() {
7072 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_float16 = {
7073 // Begin of an example
7074 {
7075 .operands = {
7076 //Input(s)
7077 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7078 // int -> Dimensions map
7079 .operandDimensions = {{0, {1, 3, 3, 2}}},
7080 // int -> FLOAT32 map
7081 .float32Operands = {},
7082 // int -> INT32 map
7083 .int32Operands = {},
7084 // int -> QUANT8_ASYMM map
7085 .quant8AsymmOperands = {},
7086 // int -> QUANT16_SYMM map
7087 .quant16SymmOperands = {},
7088 // int -> FLOAT16 map
7089 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
7090 // int -> BOOL8 map
7091 .bool8Operands = {},
7092 // int -> QUANT8_SYMM_PER_CHANNEL map
7093 .quant8ChannelOperands = {},
7094 // int -> QUANT16_ASYMM map
7095 .quant16AsymmOperands = {},
7096 // int -> QUANT8_SYMM map
7097 .quant8SymmOperands = {},
7098 },
7099 //Output(s)
7100 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7101 // int -> Dimensions map
7102 .operandDimensions = {{0, {1, 2, 2, 2}}},
7103 // int -> FLOAT32 map
7104 .float32Operands = {},
7105 // int -> INT32 map
7106 .int32Operands = {},
7107 // int -> QUANT8_ASYMM map
7108 .quant8AsymmOperands = {},
7109 // int -> QUANT16_SYMM map
7110 .quant16SymmOperands = {},
7111 // int -> FLOAT16 map
7112 .float16Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
7113 // int -> BOOL8 map
7114 .bool8Operands = {},
7115 // int -> QUANT8_SYMM_PER_CHANNEL map
7116 .quant8ChannelOperands = {},
7117 // int -> QUANT16_ASYMM map
7118 .quant16AsymmOperands = {},
7119 // int -> QUANT8_SYMM map
7120 .quant8SymmOperands = {},
7121 }
7122 },
7123 }, // End of an example
7124 };
7125 return examples_dynamic_output_shape_nhwc_none_float16;
7126 };
7127
get_examples_dynamic_output_shape_nhwc_none_float16_weight_as_input()7128 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_float16_weight_as_input() {
7129 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_float16_weight_as_input = {
7130 // Begin of an example
7131 {
7132 .operands = {
7133 //Input(s)
7134 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7135 // int -> Dimensions map
7136 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7137 // int -> FLOAT32 map
7138 .float32Operands = {},
7139 // int -> INT32 map
7140 .int32Operands = {},
7141 // int -> QUANT8_ASYMM map
7142 .quant8AsymmOperands = {},
7143 // int -> QUANT16_SYMM map
7144 .quant16SymmOperands = {},
7145 // int -> FLOAT16 map
7146 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
7147 // int -> BOOL8 map
7148 .bool8Operands = {},
7149 // int -> QUANT8_SYMM_PER_CHANNEL map
7150 .quant8ChannelOperands = {},
7151 // int -> QUANT16_ASYMM map
7152 .quant16AsymmOperands = {},
7153 // int -> QUANT8_SYMM map
7154 .quant8SymmOperands = {},
7155 },
7156 //Output(s)
7157 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7158 // int -> Dimensions map
7159 .operandDimensions = {{0, {1, 2, 2, 2}}},
7160 // int -> FLOAT32 map
7161 .float32Operands = {},
7162 // int -> INT32 map
7163 .int32Operands = {},
7164 // int -> QUANT8_ASYMM map
7165 .quant8AsymmOperands = {},
7166 // int -> QUANT16_SYMM map
7167 .quant16SymmOperands = {},
7168 // int -> FLOAT16 map
7169 .float16Operands = {{0, {33.0f, -0.5f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, -9.5f}}},
7170 // int -> BOOL8 map
7171 .bool8Operands = {},
7172 // int -> QUANT8_SYMM_PER_CHANNEL map
7173 .quant8ChannelOperands = {},
7174 // int -> QUANT16_ASYMM map
7175 .quant16AsymmOperands = {},
7176 // int -> QUANT8_SYMM map
7177 .quant8SymmOperands = {},
7178 }
7179 },
7180 }, // End of an example
7181 };
7182 return examples_dynamic_output_shape_nhwc_none_float16_weight_as_input;
7183 };
7184
get_examples_dynamic_output_shape_nhwc_relu()7185 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu() {
7186 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu = {
7187 // Begin of an example
7188 {
7189 .operands = {
7190 //Input(s)
7191 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7192 // int -> Dimensions map
7193 .operandDimensions = {{0, {1, 3, 3, 2}}},
7194 // int -> FLOAT32 map
7195 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
7196 // int -> INT32 map
7197 .int32Operands = {},
7198 // int -> QUANT8_ASYMM map
7199 .quant8AsymmOperands = {},
7200 // int -> QUANT16_SYMM map
7201 .quant16SymmOperands = {},
7202 // int -> FLOAT16 map
7203 .float16Operands = {},
7204 // int -> BOOL8 map
7205 .bool8Operands = {},
7206 // int -> QUANT8_SYMM_PER_CHANNEL map
7207 .quant8ChannelOperands = {},
7208 // int -> QUANT16_ASYMM map
7209 .quant16AsymmOperands = {},
7210 // int -> QUANT8_SYMM map
7211 .quant8SymmOperands = {},
7212 },
7213 //Output(s)
7214 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7215 // int -> Dimensions map
7216 .operandDimensions = {{0, {1, 2, 2, 2}}},
7217 // int -> FLOAT32 map
7218 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
7219 // int -> INT32 map
7220 .int32Operands = {},
7221 // int -> QUANT8_ASYMM map
7222 .quant8AsymmOperands = {},
7223 // int -> QUANT16_SYMM map
7224 .quant16SymmOperands = {},
7225 // int -> FLOAT16 map
7226 .float16Operands = {},
7227 // int -> BOOL8 map
7228 .bool8Operands = {},
7229 // int -> QUANT8_SYMM_PER_CHANNEL map
7230 .quant8ChannelOperands = {},
7231 // int -> QUANT16_ASYMM map
7232 .quant16AsymmOperands = {},
7233 // int -> QUANT8_SYMM map
7234 .quant8SymmOperands = {},
7235 }
7236 },
7237 }, // End of an example
7238 };
7239 return examples_dynamic_output_shape_nhwc_relu;
7240 };
7241
get_examples_dynamic_output_shape_nhwc_relu_weight_as_input()7242 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_weight_as_input() {
7243 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_weight_as_input = {
7244 // Begin of an example
7245 {
7246 .operands = {
7247 //Input(s)
7248 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7249 // int -> Dimensions map
7250 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7251 // int -> FLOAT32 map
7252 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
7253 // int -> INT32 map
7254 .int32Operands = {},
7255 // int -> QUANT8_ASYMM map
7256 .quant8AsymmOperands = {},
7257 // int -> QUANT16_SYMM map
7258 .quant16SymmOperands = {},
7259 // int -> FLOAT16 map
7260 .float16Operands = {},
7261 // int -> BOOL8 map
7262 .bool8Operands = {},
7263 // int -> QUANT8_SYMM_PER_CHANNEL map
7264 .quant8ChannelOperands = {},
7265 // int -> QUANT16_ASYMM map
7266 .quant16AsymmOperands = {},
7267 // int -> QUANT8_SYMM map
7268 .quant8SymmOperands = {},
7269 },
7270 //Output(s)
7271 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7272 // int -> Dimensions map
7273 .operandDimensions = {{0, {1, 2, 2, 2}}},
7274 // int -> FLOAT32 map
7275 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
7276 // int -> INT32 map
7277 .int32Operands = {},
7278 // int -> QUANT8_ASYMM map
7279 .quant8AsymmOperands = {},
7280 // int -> QUANT16_SYMM map
7281 .quant16SymmOperands = {},
7282 // int -> FLOAT16 map
7283 .float16Operands = {},
7284 // int -> BOOL8 map
7285 .bool8Operands = {},
7286 // int -> QUANT8_SYMM_PER_CHANNEL map
7287 .quant8ChannelOperands = {},
7288 // int -> QUANT16_ASYMM map
7289 .quant16AsymmOperands = {},
7290 // int -> QUANT8_SYMM map
7291 .quant8SymmOperands = {},
7292 }
7293 },
7294 }, // End of an example
7295 };
7296 return examples_dynamic_output_shape_nhwc_relu_weight_as_input;
7297 };
7298
get_examples_dynamic_output_shape_nhwc_relu_relaxed()7299 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_relaxed() {
7300 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_relaxed = {
7301 // Begin of an example
7302 {
7303 .operands = {
7304 //Input(s)
7305 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7306 // int -> Dimensions map
7307 .operandDimensions = {{0, {1, 3, 3, 2}}},
7308 // int -> FLOAT32 map
7309 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
7310 // int -> INT32 map
7311 .int32Operands = {},
7312 // int -> QUANT8_ASYMM map
7313 .quant8AsymmOperands = {},
7314 // int -> QUANT16_SYMM map
7315 .quant16SymmOperands = {},
7316 // int -> FLOAT16 map
7317 .float16Operands = {},
7318 // int -> BOOL8 map
7319 .bool8Operands = {},
7320 // int -> QUANT8_SYMM_PER_CHANNEL map
7321 .quant8ChannelOperands = {},
7322 // int -> QUANT16_ASYMM map
7323 .quant16AsymmOperands = {},
7324 // int -> QUANT8_SYMM map
7325 .quant8SymmOperands = {},
7326 },
7327 //Output(s)
7328 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7329 // int -> Dimensions map
7330 .operandDimensions = {{0, {1, 2, 2, 2}}},
7331 // int -> FLOAT32 map
7332 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
7333 // int -> INT32 map
7334 .int32Operands = {},
7335 // int -> QUANT8_ASYMM map
7336 .quant8AsymmOperands = {},
7337 // int -> QUANT16_SYMM map
7338 .quant16SymmOperands = {},
7339 // int -> FLOAT16 map
7340 .float16Operands = {},
7341 // int -> BOOL8 map
7342 .bool8Operands = {},
7343 // int -> QUANT8_SYMM_PER_CHANNEL map
7344 .quant8ChannelOperands = {},
7345 // int -> QUANT16_ASYMM map
7346 .quant16AsymmOperands = {},
7347 // int -> QUANT8_SYMM map
7348 .quant8SymmOperands = {},
7349 }
7350 },
7351 }, // End of an example
7352 };
7353 return examples_dynamic_output_shape_nhwc_relu_relaxed;
7354 };
7355
get_examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input()7356 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input() {
7357 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input = {
7358 // Begin of an example
7359 {
7360 .operands = {
7361 //Input(s)
7362 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7363 // int -> Dimensions map
7364 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7365 // int -> FLOAT32 map
7366 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
7367 // int -> INT32 map
7368 .int32Operands = {},
7369 // int -> QUANT8_ASYMM map
7370 .quant8AsymmOperands = {},
7371 // int -> QUANT16_SYMM map
7372 .quant16SymmOperands = {},
7373 // int -> FLOAT16 map
7374 .float16Operands = {},
7375 // int -> BOOL8 map
7376 .bool8Operands = {},
7377 // int -> QUANT8_SYMM_PER_CHANNEL map
7378 .quant8ChannelOperands = {},
7379 // int -> QUANT16_ASYMM map
7380 .quant16AsymmOperands = {},
7381 // int -> QUANT8_SYMM map
7382 .quant8SymmOperands = {},
7383 },
7384 //Output(s)
7385 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7386 // int -> Dimensions map
7387 .operandDimensions = {{0, {1, 2, 2, 2}}},
7388 // int -> FLOAT32 map
7389 .float32Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
7390 // int -> INT32 map
7391 .int32Operands = {},
7392 // int -> QUANT8_ASYMM map
7393 .quant8AsymmOperands = {},
7394 // int -> QUANT16_SYMM map
7395 .quant16SymmOperands = {},
7396 // int -> FLOAT16 map
7397 .float16Operands = {},
7398 // int -> BOOL8 map
7399 .bool8Operands = {},
7400 // int -> QUANT8_SYMM_PER_CHANNEL map
7401 .quant8ChannelOperands = {},
7402 // int -> QUANT16_ASYMM map
7403 .quant16AsymmOperands = {},
7404 // int -> QUANT8_SYMM map
7405 .quant8SymmOperands = {},
7406 }
7407 },
7408 }, // End of an example
7409 };
7410 return examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input;
7411 };
7412
get_examples_dynamic_output_shape_nhwc_relu_quant8()7413 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8() {
7414 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8 = {
7415 // Begin of an example
7416 {
7417 .operands = {
7418 //Input(s)
7419 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7420 // int -> Dimensions map
7421 .operandDimensions = {{0, {1, 3, 3, 2}}},
7422 // int -> FLOAT32 map
7423 .float32Operands = {},
7424 // int -> INT32 map
7425 .int32Operands = {},
7426 // int -> QUANT8_ASYMM map
7427 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7428 // int -> QUANT16_SYMM map
7429 .quant16SymmOperands = {},
7430 // int -> FLOAT16 map
7431 .float16Operands = {},
7432 // int -> BOOL8 map
7433 .bool8Operands = {},
7434 // int -> QUANT8_SYMM_PER_CHANNEL map
7435 .quant8ChannelOperands = {},
7436 // int -> QUANT16_ASYMM map
7437 .quant16AsymmOperands = {},
7438 // int -> QUANT8_SYMM map
7439 .quant8SymmOperands = {},
7440 },
7441 //Output(s)
7442 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7443 // int -> Dimensions map
7444 .operandDimensions = {{0, {1, 2, 2, 2}}},
7445 // int -> FLOAT32 map
7446 .float32Operands = {},
7447 // int -> INT32 map
7448 .int32Operands = {},
7449 // int -> QUANT8_ASYMM map
7450 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
7451 // int -> QUANT16_SYMM map
7452 .quant16SymmOperands = {},
7453 // int -> FLOAT16 map
7454 .float16Operands = {},
7455 // int -> BOOL8 map
7456 .bool8Operands = {},
7457 // int -> QUANT8_SYMM_PER_CHANNEL map
7458 .quant8ChannelOperands = {},
7459 // int -> QUANT16_ASYMM map
7460 .quant16AsymmOperands = {},
7461 // int -> QUANT8_SYMM map
7462 .quant8SymmOperands = {},
7463 }
7464 },
7465 }, // End of an example
7466 };
7467 return examples_dynamic_output_shape_nhwc_relu_quant8;
7468 };
7469
get_examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input()7470 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input() {
7471 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input = {
7472 // Begin of an example
7473 {
7474 .operands = {
7475 //Input(s)
7476 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7477 // int -> Dimensions map
7478 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7479 // int -> FLOAT32 map
7480 .float32Operands = {},
7481 // int -> INT32 map
7482 .int32Operands = {{2, {160, -536}}},
7483 // int -> QUANT8_ASYMM map
7484 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
7485 // int -> QUANT16_SYMM map
7486 .quant16SymmOperands = {},
7487 // int -> FLOAT16 map
7488 .float16Operands = {},
7489 // int -> BOOL8 map
7490 .bool8Operands = {},
7491 // int -> QUANT8_SYMM_PER_CHANNEL map
7492 .quant8ChannelOperands = {},
7493 // int -> QUANT16_ASYMM map
7494 .quant16AsymmOperands = {},
7495 // int -> QUANT8_SYMM map
7496 .quant8SymmOperands = {},
7497 },
7498 //Output(s)
7499 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7500 // int -> Dimensions map
7501 .operandDimensions = {{0, {1, 2, 2, 2}}},
7502 // int -> FLOAT32 map
7503 .float32Operands = {},
7504 // int -> INT32 map
7505 .int32Operands = {},
7506 // int -> QUANT8_ASYMM map
7507 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
7508 // int -> QUANT16_SYMM map
7509 .quant16SymmOperands = {},
7510 // int -> FLOAT16 map
7511 .float16Operands = {},
7512 // int -> BOOL8 map
7513 .bool8Operands = {},
7514 // int -> QUANT8_SYMM_PER_CHANNEL map
7515 .quant8ChannelOperands = {},
7516 // int -> QUANT16_ASYMM map
7517 .quant16AsymmOperands = {},
7518 // int -> QUANT8_SYMM map
7519 .quant8SymmOperands = {},
7520 }
7521 },
7522 }, // End of an example
7523 };
7524 return examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input;
7525 };
7526
get_examples_dynamic_output_shape_nhwc_relu_quant8_2()7527 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8_2() {
7528 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8_2 = {
7529 // Begin of an example
7530 {
7531 .operands = {
7532 //Input(s)
7533 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7534 // int -> Dimensions map
7535 .operandDimensions = {{0, {1, 3, 3, 2}}},
7536 // int -> FLOAT32 map
7537 .float32Operands = {},
7538 // int -> INT32 map
7539 .int32Operands = {},
7540 // int -> QUANT8_ASYMM map
7541 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7542 // int -> QUANT16_SYMM map
7543 .quant16SymmOperands = {},
7544 // int -> FLOAT16 map
7545 .float16Operands = {},
7546 // int -> BOOL8 map
7547 .bool8Operands = {},
7548 // int -> QUANT8_SYMM_PER_CHANNEL map
7549 .quant8ChannelOperands = {},
7550 // int -> QUANT16_ASYMM map
7551 .quant16AsymmOperands = {},
7552 // int -> QUANT8_SYMM map
7553 .quant8SymmOperands = {},
7554 },
7555 //Output(s)
7556 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7557 // int -> Dimensions map
7558 .operandDimensions = {{0, {1, 2, 2, 2}}},
7559 // int -> FLOAT32 map
7560 .float32Operands = {},
7561 // int -> INT32 map
7562 .int32Operands = {},
7563 // int -> QUANT8_ASYMM map
7564 .quant8AsymmOperands = {{0, {255, 80, 255, 230, 255, 170, 255, 80}}},
7565 // int -> QUANT16_SYMM map
7566 .quant16SymmOperands = {},
7567 // int -> FLOAT16 map
7568 .float16Operands = {},
7569 // int -> BOOL8 map
7570 .bool8Operands = {},
7571 // int -> QUANT8_SYMM_PER_CHANNEL map
7572 .quant8ChannelOperands = {},
7573 // int -> QUANT16_ASYMM map
7574 .quant16AsymmOperands = {},
7575 // int -> QUANT8_SYMM map
7576 .quant8SymmOperands = {},
7577 }
7578 },
7579 }, // End of an example
7580 };
7581 return examples_dynamic_output_shape_nhwc_relu_quant8_2;
7582 };
7583
get_examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2()7584 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2() {
7585 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2 = {
7586 // Begin of an example
7587 {
7588 .operands = {
7589 //Input(s)
7590 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7591 // int -> Dimensions map
7592 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7593 // int -> FLOAT32 map
7594 .float32Operands = {},
7595 // int -> INT32 map
7596 .int32Operands = {{2, {160, -536}}},
7597 // int -> QUANT8_ASYMM map
7598 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
7599 // int -> QUANT16_SYMM map
7600 .quant16SymmOperands = {},
7601 // int -> FLOAT16 map
7602 .float16Operands = {},
7603 // int -> BOOL8 map
7604 .bool8Operands = {},
7605 // int -> QUANT8_SYMM_PER_CHANNEL map
7606 .quant8ChannelOperands = {},
7607 // int -> QUANT16_ASYMM map
7608 .quant16AsymmOperands = {},
7609 // int -> QUANT8_SYMM map
7610 .quant8SymmOperands = {},
7611 },
7612 //Output(s)
7613 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7614 // int -> Dimensions map
7615 .operandDimensions = {{0, {1, 2, 2, 2}}},
7616 // int -> FLOAT32 map
7617 .float32Operands = {},
7618 // int -> INT32 map
7619 .int32Operands = {},
7620 // int -> QUANT8_ASYMM map
7621 .quant8AsymmOperands = {{0, {255, 80, 255, 230, 255, 170, 255, 80}}},
7622 // int -> QUANT16_SYMM map
7623 .quant16SymmOperands = {},
7624 // int -> FLOAT16 map
7625 .float16Operands = {},
7626 // int -> BOOL8 map
7627 .bool8Operands = {},
7628 // int -> QUANT8_SYMM_PER_CHANNEL map
7629 .quant8ChannelOperands = {},
7630 // int -> QUANT16_ASYMM map
7631 .quant16AsymmOperands = {},
7632 // int -> QUANT8_SYMM map
7633 .quant8SymmOperands = {},
7634 }
7635 },
7636 }, // End of an example
7637 };
7638 return examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2;
7639 };
7640
get_examples_dynamic_output_shape_nhwc_relu_channelQuant8()7641 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8() {
7642 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8 = {
7643 // Begin of an example
7644 {
7645 .operands = {
7646 //Input(s)
7647 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7648 // int -> Dimensions map
7649 .operandDimensions = {{0, {1, 3, 3, 2}}},
7650 // int -> FLOAT32 map
7651 .float32Operands = {},
7652 // int -> INT32 map
7653 .int32Operands = {},
7654 // int -> QUANT8_ASYMM map
7655 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7656 // int -> QUANT16_SYMM map
7657 .quant16SymmOperands = {},
7658 // int -> FLOAT16 map
7659 .float16Operands = {},
7660 // int -> BOOL8 map
7661 .bool8Operands = {},
7662 // int -> QUANT8_SYMM_PER_CHANNEL map
7663 .quant8ChannelOperands = {},
7664 // int -> QUANT16_ASYMM map
7665 .quant16AsymmOperands = {},
7666 // int -> QUANT8_SYMM map
7667 .quant8SymmOperands = {},
7668 },
7669 //Output(s)
7670 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7671 // int -> Dimensions map
7672 .operandDimensions = {{0, {1, 2, 2, 2}}},
7673 // int -> FLOAT32 map
7674 .float32Operands = {},
7675 // int -> INT32 map
7676 .int32Operands = {},
7677 // int -> QUANT8_ASYMM map
7678 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
7679 // int -> QUANT16_SYMM map
7680 .quant16SymmOperands = {},
7681 // int -> FLOAT16 map
7682 .float16Operands = {},
7683 // int -> BOOL8 map
7684 .bool8Operands = {},
7685 // int -> QUANT8_SYMM_PER_CHANNEL map
7686 .quant8ChannelOperands = {},
7687 // int -> QUANT16_ASYMM map
7688 .quant16AsymmOperands = {},
7689 // int -> QUANT8_SYMM map
7690 .quant8SymmOperands = {},
7691 }
7692 },
7693 }, // End of an example
7694 };
7695 return examples_dynamic_output_shape_nhwc_relu_channelQuant8;
7696 };
7697
get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input()7698 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input() {
7699 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input = {
7700 // Begin of an example
7701 {
7702 .operands = {
7703 //Input(s)
7704 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7705 // int -> Dimensions map
7706 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7707 // int -> FLOAT32 map
7708 .float32Operands = {},
7709 // int -> INT32 map
7710 .int32Operands = {{2, {160, -268}}},
7711 // int -> QUANT8_ASYMM map
7712 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7713 // int -> QUANT16_SYMM map
7714 .quant16SymmOperands = {},
7715 // int -> FLOAT16 map
7716 .float16Operands = {},
7717 // int -> BOOL8 map
7718 .bool8Operands = {},
7719 // int -> QUANT8_SYMM_PER_CHANNEL map
7720 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
7721 // int -> QUANT16_ASYMM map
7722 .quant16AsymmOperands = {},
7723 // int -> QUANT8_SYMM map
7724 .quant8SymmOperands = {},
7725 },
7726 //Output(s)
7727 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7728 // int -> Dimensions map
7729 .operandDimensions = {{0, {1, 2, 2, 2}}},
7730 // int -> FLOAT32 map
7731 .float32Operands = {},
7732 // int -> INT32 map
7733 .int32Operands = {},
7734 // int -> QUANT8_ASYMM map
7735 .quant8AsymmOperands = {{0, {146, 80, 146, 95, 142, 89, 134, 80}}},
7736 // int -> QUANT16_SYMM map
7737 .quant16SymmOperands = {},
7738 // int -> FLOAT16 map
7739 .float16Operands = {},
7740 // int -> BOOL8 map
7741 .bool8Operands = {},
7742 // int -> QUANT8_SYMM_PER_CHANNEL map
7743 .quant8ChannelOperands = {},
7744 // int -> QUANT16_ASYMM map
7745 .quant16AsymmOperands = {},
7746 // int -> QUANT8_SYMM map
7747 .quant8SymmOperands = {},
7748 }
7749 },
7750 }, // End of an example
7751 };
7752 return examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input;
7753 };
7754
get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_2()7755 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_2() {
7756 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8_2 = {
7757 // Begin of an example
7758 {
7759 .operands = {
7760 //Input(s)
7761 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7762 // int -> Dimensions map
7763 .operandDimensions = {{0, {1, 3, 3, 2}}},
7764 // int -> FLOAT32 map
7765 .float32Operands = {},
7766 // int -> INT32 map
7767 .int32Operands = {},
7768 // int -> QUANT8_ASYMM map
7769 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7770 // int -> QUANT16_SYMM map
7771 .quant16SymmOperands = {},
7772 // int -> FLOAT16 map
7773 .float16Operands = {},
7774 // int -> BOOL8 map
7775 .bool8Operands = {},
7776 // int -> QUANT8_SYMM_PER_CHANNEL map
7777 .quant8ChannelOperands = {},
7778 // int -> QUANT16_ASYMM map
7779 .quant16AsymmOperands = {},
7780 // int -> QUANT8_SYMM map
7781 .quant8SymmOperands = {},
7782 },
7783 //Output(s)
7784 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7785 // int -> Dimensions map
7786 .operandDimensions = {{0, {1, 2, 2, 2}}},
7787 // int -> FLOAT32 map
7788 .float32Operands = {},
7789 // int -> INT32 map
7790 .int32Operands = {},
7791 // int -> QUANT8_ASYMM map
7792 .quant8AsymmOperands = {{0, {255, 80, 255, 155, 255, 125, 255, 80}}},
7793 // int -> QUANT16_SYMM map
7794 .quant16SymmOperands = {},
7795 // int -> FLOAT16 map
7796 .float16Operands = {},
7797 // int -> BOOL8 map
7798 .bool8Operands = {},
7799 // int -> QUANT8_SYMM_PER_CHANNEL map
7800 .quant8ChannelOperands = {},
7801 // int -> QUANT16_ASYMM map
7802 .quant16AsymmOperands = {},
7803 // int -> QUANT8_SYMM map
7804 .quant8SymmOperands = {},
7805 }
7806 },
7807 }, // End of an example
7808 };
7809 return examples_dynamic_output_shape_nhwc_relu_channelQuant8_2;
7810 };
7811
get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2()7812 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2() {
7813 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2 = {
7814 // Begin of an example
7815 {
7816 .operands = {
7817 //Input(s)
7818 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7819 // int -> Dimensions map
7820 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7821 // int -> FLOAT32 map
7822 .float32Operands = {},
7823 // int -> INT32 map
7824 .int32Operands = {{2, {160, -268}}},
7825 // int -> QUANT8_ASYMM map
7826 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
7827 // int -> QUANT16_SYMM map
7828 .quant16SymmOperands = {},
7829 // int -> FLOAT16 map
7830 .float16Operands = {},
7831 // int -> BOOL8 map
7832 .bool8Operands = {},
7833 // int -> QUANT8_SYMM_PER_CHANNEL map
7834 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
7835 // int -> QUANT16_ASYMM map
7836 .quant16AsymmOperands = {},
7837 // int -> QUANT8_SYMM map
7838 .quant8SymmOperands = {},
7839 },
7840 //Output(s)
7841 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7842 // int -> Dimensions map
7843 .operandDimensions = {{0, {1, 2, 2, 2}}},
7844 // int -> FLOAT32 map
7845 .float32Operands = {},
7846 // int -> INT32 map
7847 .int32Operands = {},
7848 // int -> QUANT8_ASYMM map
7849 .quant8AsymmOperands = {{0, {255, 80, 255, 155, 255, 125, 255, 80}}},
7850 // int -> QUANT16_SYMM map
7851 .quant16SymmOperands = {},
7852 // int -> FLOAT16 map
7853 .float16Operands = {},
7854 // int -> BOOL8 map
7855 .bool8Operands = {},
7856 // int -> QUANT8_SYMM_PER_CHANNEL map
7857 .quant8ChannelOperands = {},
7858 // int -> QUANT16_ASYMM map
7859 .quant16AsymmOperands = {},
7860 // int -> QUANT8_SYMM map
7861 .quant8SymmOperands = {},
7862 }
7863 },
7864 }, // End of an example
7865 };
7866 return examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2;
7867 };
7868
get_examples_dynamic_output_shape_nhwc_relu_float16()7869 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_float16() {
7870 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_float16 = {
7871 // Begin of an example
7872 {
7873 .operands = {
7874 //Input(s)
7875 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7876 // int -> Dimensions map
7877 .operandDimensions = {{0, {1, 3, 3, 2}}},
7878 // int -> FLOAT32 map
7879 .float32Operands = {},
7880 // int -> INT32 map
7881 .int32Operands = {},
7882 // int -> QUANT8_ASYMM map
7883 .quant8AsymmOperands = {},
7884 // int -> QUANT16_SYMM map
7885 .quant16SymmOperands = {},
7886 // int -> FLOAT16 map
7887 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
7888 // int -> BOOL8 map
7889 .bool8Operands = {},
7890 // int -> QUANT8_SYMM_PER_CHANNEL map
7891 .quant8ChannelOperands = {},
7892 // int -> QUANT16_ASYMM map
7893 .quant16AsymmOperands = {},
7894 // int -> QUANT8_SYMM map
7895 .quant8SymmOperands = {},
7896 },
7897 //Output(s)
7898 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7899 // int -> Dimensions map
7900 .operandDimensions = {{0, {1, 2, 2, 2}}},
7901 // int -> FLOAT32 map
7902 .float32Operands = {},
7903 // int -> INT32 map
7904 .int32Operands = {},
7905 // int -> QUANT8_ASYMM map
7906 .quant8AsymmOperands = {},
7907 // int -> QUANT16_SYMM map
7908 .quant16SymmOperands = {},
7909 // int -> FLOAT16 map
7910 .float16Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
7911 // int -> BOOL8 map
7912 .bool8Operands = {},
7913 // int -> QUANT8_SYMM_PER_CHANNEL map
7914 .quant8ChannelOperands = {},
7915 // int -> QUANT16_ASYMM map
7916 .quant16AsymmOperands = {},
7917 // int -> QUANT8_SYMM map
7918 .quant8SymmOperands = {},
7919 }
7920 },
7921 }, // End of an example
7922 };
7923 return examples_dynamic_output_shape_nhwc_relu_float16;
7924 };
7925
get_examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input()7926 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input() {
7927 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input = {
7928 // Begin of an example
7929 {
7930 .operands = {
7931 //Input(s)
7932 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7933 // int -> Dimensions map
7934 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
7935 // int -> FLOAT32 map
7936 .float32Operands = {},
7937 // int -> INT32 map
7938 .int32Operands = {},
7939 // int -> QUANT8_ASYMM map
7940 .quant8AsymmOperands = {},
7941 // int -> QUANT16_SYMM map
7942 .quant16SymmOperands = {},
7943 // int -> FLOAT16 map
7944 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
7945 // int -> BOOL8 map
7946 .bool8Operands = {},
7947 // int -> QUANT8_SYMM_PER_CHANNEL map
7948 .quant8ChannelOperands = {},
7949 // int -> QUANT16_ASYMM map
7950 .quant16AsymmOperands = {},
7951 // int -> QUANT8_SYMM map
7952 .quant8SymmOperands = {},
7953 },
7954 //Output(s)
7955 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7956 // int -> Dimensions map
7957 .operandDimensions = {{0, {1, 2, 2, 2}}},
7958 // int -> FLOAT32 map
7959 .float32Operands = {},
7960 // int -> INT32 map
7961 .int32Operands = {},
7962 // int -> QUANT8_ASYMM map
7963 .quant8AsymmOperands = {},
7964 // int -> QUANT16_SYMM map
7965 .quant16SymmOperands = {},
7966 // int -> FLOAT16 map
7967 .float16Operands = {{0, {33.0f, 0.0f, 33.0f, 7.5f, 31.0f, 4.5f, 27.0f, 0.0f}}},
7968 // int -> BOOL8 map
7969 .bool8Operands = {},
7970 // int -> QUANT8_SYMM_PER_CHANNEL map
7971 .quant8ChannelOperands = {},
7972 // int -> QUANT16_ASYMM map
7973 .quant16AsymmOperands = {},
7974 // int -> QUANT8_SYMM map
7975 .quant8SymmOperands = {},
7976 }
7977 },
7978 }, // End of an example
7979 };
7980 return examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input;
7981 };
7982
get_examples_dynamic_output_shape_nhwc_relu1()7983 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1() {
7984 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1 = {
7985 // Begin of an example
7986 {
7987 .operands = {
7988 //Input(s)
7989 { // See tools/test_generator/include/TestHarness.h:MixedTyped
7990 // int -> Dimensions map
7991 .operandDimensions = {{0, {1, 3, 3, 2}}},
7992 // int -> FLOAT32 map
7993 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
7994 // int -> INT32 map
7995 .int32Operands = {},
7996 // int -> QUANT8_ASYMM map
7997 .quant8AsymmOperands = {},
7998 // int -> QUANT16_SYMM map
7999 .quant16SymmOperands = {},
8000 // int -> FLOAT16 map
8001 .float16Operands = {},
8002 // int -> BOOL8 map
8003 .bool8Operands = {},
8004 // int -> QUANT8_SYMM_PER_CHANNEL map
8005 .quant8ChannelOperands = {},
8006 // int -> QUANT16_ASYMM map
8007 .quant16AsymmOperands = {},
8008 // int -> QUANT8_SYMM map
8009 .quant8SymmOperands = {},
8010 },
8011 //Output(s)
8012 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8013 // int -> Dimensions map
8014 .operandDimensions = {{0, {1, 2, 2, 2}}},
8015 // int -> FLOAT32 map
8016 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
8017 // int -> INT32 map
8018 .int32Operands = {},
8019 // int -> QUANT8_ASYMM map
8020 .quant8AsymmOperands = {},
8021 // int -> QUANT16_SYMM map
8022 .quant16SymmOperands = {},
8023 // int -> FLOAT16 map
8024 .float16Operands = {},
8025 // int -> BOOL8 map
8026 .bool8Operands = {},
8027 // int -> QUANT8_SYMM_PER_CHANNEL map
8028 .quant8ChannelOperands = {},
8029 // int -> QUANT16_ASYMM map
8030 .quant16AsymmOperands = {},
8031 // int -> QUANT8_SYMM map
8032 .quant8SymmOperands = {},
8033 }
8034 },
8035 }, // End of an example
8036 };
8037 return examples_dynamic_output_shape_nhwc_relu1;
8038 };
8039
get_examples_dynamic_output_shape_nhwc_relu1_weight_as_input()8040 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_weight_as_input() {
8041 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_weight_as_input = {
8042 // Begin of an example
8043 {
8044 .operands = {
8045 //Input(s)
8046 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8047 // int -> Dimensions map
8048 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8049 // int -> FLOAT32 map
8050 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
8051 // int -> INT32 map
8052 .int32Operands = {},
8053 // int -> QUANT8_ASYMM map
8054 .quant8AsymmOperands = {},
8055 // int -> QUANT16_SYMM map
8056 .quant16SymmOperands = {},
8057 // int -> FLOAT16 map
8058 .float16Operands = {},
8059 // int -> BOOL8 map
8060 .bool8Operands = {},
8061 // int -> QUANT8_SYMM_PER_CHANNEL map
8062 .quant8ChannelOperands = {},
8063 // int -> QUANT16_ASYMM map
8064 .quant16AsymmOperands = {},
8065 // int -> QUANT8_SYMM map
8066 .quant8SymmOperands = {},
8067 },
8068 //Output(s)
8069 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8070 // int -> Dimensions map
8071 .operandDimensions = {{0, {1, 2, 2, 2}}},
8072 // int -> FLOAT32 map
8073 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
8074 // int -> INT32 map
8075 .int32Operands = {},
8076 // int -> QUANT8_ASYMM map
8077 .quant8AsymmOperands = {},
8078 // int -> QUANT16_SYMM map
8079 .quant16SymmOperands = {},
8080 // int -> FLOAT16 map
8081 .float16Operands = {},
8082 // int -> BOOL8 map
8083 .bool8Operands = {},
8084 // int -> QUANT8_SYMM_PER_CHANNEL map
8085 .quant8ChannelOperands = {},
8086 // int -> QUANT16_ASYMM map
8087 .quant16AsymmOperands = {},
8088 // int -> QUANT8_SYMM map
8089 .quant8SymmOperands = {},
8090 }
8091 },
8092 }, // End of an example
8093 };
8094 return examples_dynamic_output_shape_nhwc_relu1_weight_as_input;
8095 };
8096
get_examples_dynamic_output_shape_nhwc_relu1_relaxed()8097 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_relaxed() {
8098 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_relaxed = {
8099 // Begin of an example
8100 {
8101 .operands = {
8102 //Input(s)
8103 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8104 // int -> Dimensions map
8105 .operandDimensions = {{0, {1, 3, 3, 2}}},
8106 // int -> FLOAT32 map
8107 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
8108 // int -> INT32 map
8109 .int32Operands = {},
8110 // int -> QUANT8_ASYMM map
8111 .quant8AsymmOperands = {},
8112 // int -> QUANT16_SYMM map
8113 .quant16SymmOperands = {},
8114 // int -> FLOAT16 map
8115 .float16Operands = {},
8116 // int -> BOOL8 map
8117 .bool8Operands = {},
8118 // int -> QUANT8_SYMM_PER_CHANNEL map
8119 .quant8ChannelOperands = {},
8120 // int -> QUANT16_ASYMM map
8121 .quant16AsymmOperands = {},
8122 // int -> QUANT8_SYMM map
8123 .quant8SymmOperands = {},
8124 },
8125 //Output(s)
8126 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8127 // int -> Dimensions map
8128 .operandDimensions = {{0, {1, 2, 2, 2}}},
8129 // int -> FLOAT32 map
8130 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
8131 // int -> INT32 map
8132 .int32Operands = {},
8133 // int -> QUANT8_ASYMM map
8134 .quant8AsymmOperands = {},
8135 // int -> QUANT16_SYMM map
8136 .quant16SymmOperands = {},
8137 // int -> FLOAT16 map
8138 .float16Operands = {},
8139 // int -> BOOL8 map
8140 .bool8Operands = {},
8141 // int -> QUANT8_SYMM_PER_CHANNEL map
8142 .quant8ChannelOperands = {},
8143 // int -> QUANT16_ASYMM map
8144 .quant16AsymmOperands = {},
8145 // int -> QUANT8_SYMM map
8146 .quant8SymmOperands = {},
8147 }
8148 },
8149 }, // End of an example
8150 };
8151 return examples_dynamic_output_shape_nhwc_relu1_relaxed;
8152 };
8153
get_examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input()8154 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input() {
8155 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input = {
8156 // Begin of an example
8157 {
8158 .operands = {
8159 //Input(s)
8160 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8161 // int -> Dimensions map
8162 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8163 // int -> FLOAT32 map
8164 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
8165 // int -> INT32 map
8166 .int32Operands = {},
8167 // int -> QUANT8_ASYMM map
8168 .quant8AsymmOperands = {},
8169 // int -> QUANT16_SYMM map
8170 .quant16SymmOperands = {},
8171 // int -> FLOAT16 map
8172 .float16Operands = {},
8173 // int -> BOOL8 map
8174 .bool8Operands = {},
8175 // int -> QUANT8_SYMM_PER_CHANNEL map
8176 .quant8ChannelOperands = {},
8177 // int -> QUANT16_ASYMM map
8178 .quant16AsymmOperands = {},
8179 // int -> QUANT8_SYMM map
8180 .quant8SymmOperands = {},
8181 },
8182 //Output(s)
8183 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8184 // int -> Dimensions map
8185 .operandDimensions = {{0, {1, 2, 2, 2}}},
8186 // int -> FLOAT32 map
8187 .float32Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
8188 // int -> INT32 map
8189 .int32Operands = {},
8190 // int -> QUANT8_ASYMM map
8191 .quant8AsymmOperands = {},
8192 // int -> QUANT16_SYMM map
8193 .quant16SymmOperands = {},
8194 // int -> FLOAT16 map
8195 .float16Operands = {},
8196 // int -> BOOL8 map
8197 .bool8Operands = {},
8198 // int -> QUANT8_SYMM_PER_CHANNEL map
8199 .quant8ChannelOperands = {},
8200 // int -> QUANT16_ASYMM map
8201 .quant16AsymmOperands = {},
8202 // int -> QUANT8_SYMM map
8203 .quant8SymmOperands = {},
8204 }
8205 },
8206 }, // End of an example
8207 };
8208 return examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input;
8209 };
8210
get_examples_dynamic_output_shape_nhwc_relu1_quant8()8211 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8() {
8212 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8 = {
8213 // Begin of an example
8214 {
8215 .operands = {
8216 //Input(s)
8217 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8218 // int -> Dimensions map
8219 .operandDimensions = {{0, {1, 3, 3, 2}}},
8220 // int -> FLOAT32 map
8221 .float32Operands = {},
8222 // int -> INT32 map
8223 .int32Operands = {},
8224 // int -> QUANT8_ASYMM map
8225 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
8226 // int -> QUANT16_SYMM map
8227 .quant16SymmOperands = {},
8228 // int -> FLOAT16 map
8229 .float16Operands = {},
8230 // int -> BOOL8 map
8231 .bool8Operands = {},
8232 // int -> QUANT8_SYMM_PER_CHANNEL map
8233 .quant8ChannelOperands = {},
8234 // int -> QUANT16_ASYMM map
8235 .quant16AsymmOperands = {},
8236 // int -> QUANT8_SYMM map
8237 .quant8SymmOperands = {},
8238 },
8239 //Output(s)
8240 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8241 // int -> Dimensions map
8242 .operandDimensions = {{0, {1, 2, 2, 2}}},
8243 // int -> FLOAT32 map
8244 .float32Operands = {},
8245 // int -> INT32 map
8246 .int32Operands = {},
8247 // int -> QUANT8_ASYMM map
8248 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
8249 // int -> QUANT16_SYMM map
8250 .quant16SymmOperands = {},
8251 // int -> FLOAT16 map
8252 .float16Operands = {},
8253 // int -> BOOL8 map
8254 .bool8Operands = {},
8255 // int -> QUANT8_SYMM_PER_CHANNEL map
8256 .quant8ChannelOperands = {},
8257 // int -> QUANT16_ASYMM map
8258 .quant16AsymmOperands = {},
8259 // int -> QUANT8_SYMM map
8260 .quant8SymmOperands = {},
8261 }
8262 },
8263 }, // End of an example
8264 };
8265 return examples_dynamic_output_shape_nhwc_relu1_quant8;
8266 };
8267
get_examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input()8268 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input() {
8269 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input = {
8270 // Begin of an example
8271 {
8272 .operands = {
8273 //Input(s)
8274 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8275 // int -> Dimensions map
8276 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8277 // int -> FLOAT32 map
8278 .float32Operands = {},
8279 // int -> INT32 map
8280 .int32Operands = {{2, {160, -536}}},
8281 // int -> QUANT8_ASYMM map
8282 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
8283 // int -> QUANT16_SYMM map
8284 .quant16SymmOperands = {},
8285 // int -> FLOAT16 map
8286 .float16Operands = {},
8287 // int -> BOOL8 map
8288 .bool8Operands = {},
8289 // int -> QUANT8_SYMM_PER_CHANNEL map
8290 .quant8ChannelOperands = {},
8291 // int -> QUANT16_ASYMM map
8292 .quant16AsymmOperands = {},
8293 // int -> QUANT8_SYMM map
8294 .quant8SymmOperands = {},
8295 },
8296 //Output(s)
8297 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8298 // int -> Dimensions map
8299 .operandDimensions = {{0, {1, 2, 2, 2}}},
8300 // int -> FLOAT32 map
8301 .float32Operands = {},
8302 // int -> INT32 map
8303 .int32Operands = {},
8304 // int -> QUANT8_ASYMM map
8305 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
8306 // int -> QUANT16_SYMM map
8307 .quant16SymmOperands = {},
8308 // int -> FLOAT16 map
8309 .float16Operands = {},
8310 // int -> BOOL8 map
8311 .bool8Operands = {},
8312 // int -> QUANT8_SYMM_PER_CHANNEL map
8313 .quant8ChannelOperands = {},
8314 // int -> QUANT16_ASYMM map
8315 .quant16AsymmOperands = {},
8316 // int -> QUANT8_SYMM map
8317 .quant8SymmOperands = {},
8318 }
8319 },
8320 }, // End of an example
8321 };
8322 return examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input;
8323 };
8324
get_examples_dynamic_output_shape_nhwc_relu1_quant8_2()8325 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8_2() {
8326 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8_2 = {
8327 // Begin of an example
8328 {
8329 .operands = {
8330 //Input(s)
8331 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8332 // int -> Dimensions map
8333 .operandDimensions = {{0, {1, 3, 3, 2}}},
8334 // int -> FLOAT32 map
8335 .float32Operands = {},
8336 // int -> INT32 map
8337 .int32Operands = {},
8338 // int -> QUANT8_ASYMM map
8339 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
8340 // int -> QUANT16_SYMM map
8341 .quant16SymmOperands = {},
8342 // int -> FLOAT16 map
8343 .float16Operands = {},
8344 // int -> BOOL8 map
8345 .bool8Operands = {},
8346 // int -> QUANT8_SYMM_PER_CHANNEL map
8347 .quant8ChannelOperands = {},
8348 // int -> QUANT16_ASYMM map
8349 .quant16AsymmOperands = {},
8350 // int -> QUANT8_SYMM map
8351 .quant8SymmOperands = {},
8352 },
8353 //Output(s)
8354 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8355 // int -> Dimensions map
8356 .operandDimensions = {{0, {1, 2, 2, 2}}},
8357 // int -> FLOAT32 map
8358 .float32Operands = {},
8359 // int -> INT32 map
8360 .int32Operands = {},
8361 // int -> QUANT8_ASYMM map
8362 .quant8AsymmOperands = {{0, {100, 70, 100, 100, 100, 100, 100, 60}}},
8363 // int -> QUANT16_SYMM map
8364 .quant16SymmOperands = {},
8365 // int -> FLOAT16 map
8366 .float16Operands = {},
8367 // int -> BOOL8 map
8368 .bool8Operands = {},
8369 // int -> QUANT8_SYMM_PER_CHANNEL map
8370 .quant8ChannelOperands = {},
8371 // int -> QUANT16_ASYMM map
8372 .quant16AsymmOperands = {},
8373 // int -> QUANT8_SYMM map
8374 .quant8SymmOperands = {},
8375 }
8376 },
8377 }, // End of an example
8378 };
8379 return examples_dynamic_output_shape_nhwc_relu1_quant8_2;
8380 };
8381
get_examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2()8382 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2() {
8383 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2 = {
8384 // Begin of an example
8385 {
8386 .operands = {
8387 //Input(s)
8388 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8389 // int -> Dimensions map
8390 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8391 // int -> FLOAT32 map
8392 .float32Operands = {},
8393 // int -> INT32 map
8394 .int32Operands = {{2, {160, -536}}},
8395 // int -> QUANT8_ASYMM map
8396 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
8397 // int -> QUANT16_SYMM map
8398 .quant16SymmOperands = {},
8399 // int -> FLOAT16 map
8400 .float16Operands = {},
8401 // int -> BOOL8 map
8402 .bool8Operands = {},
8403 // int -> QUANT8_SYMM_PER_CHANNEL map
8404 .quant8ChannelOperands = {},
8405 // int -> QUANT16_ASYMM map
8406 .quant16AsymmOperands = {},
8407 // int -> QUANT8_SYMM map
8408 .quant8SymmOperands = {},
8409 },
8410 //Output(s)
8411 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8412 // int -> Dimensions map
8413 .operandDimensions = {{0, {1, 2, 2, 2}}},
8414 // int -> FLOAT32 map
8415 .float32Operands = {},
8416 // int -> INT32 map
8417 .int32Operands = {},
8418 // int -> QUANT8_ASYMM map
8419 .quant8AsymmOperands = {{0, {100, 70, 100, 100, 100, 100, 100, 60}}},
8420 // int -> QUANT16_SYMM map
8421 .quant16SymmOperands = {},
8422 // int -> FLOAT16 map
8423 .float16Operands = {},
8424 // int -> BOOL8 map
8425 .bool8Operands = {},
8426 // int -> QUANT8_SYMM_PER_CHANNEL map
8427 .quant8ChannelOperands = {},
8428 // int -> QUANT16_ASYMM map
8429 .quant16AsymmOperands = {},
8430 // int -> QUANT8_SYMM map
8431 .quant8SymmOperands = {},
8432 }
8433 },
8434 }, // End of an example
8435 };
8436 return examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2;
8437 };
8438
get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8()8439 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8() {
8440 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8 = {
8441 // Begin of an example
8442 {
8443 .operands = {
8444 //Input(s)
8445 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8446 // int -> Dimensions map
8447 .operandDimensions = {{0, {1, 3, 3, 2}}},
8448 // int -> FLOAT32 map
8449 .float32Operands = {},
8450 // int -> INT32 map
8451 .int32Operands = {},
8452 // int -> QUANT8_ASYMM map
8453 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
8454 // int -> QUANT16_SYMM map
8455 .quant16SymmOperands = {},
8456 // int -> FLOAT16 map
8457 .float16Operands = {},
8458 // int -> BOOL8 map
8459 .bool8Operands = {},
8460 // int -> QUANT8_SYMM_PER_CHANNEL map
8461 .quant8ChannelOperands = {},
8462 // int -> QUANT16_ASYMM map
8463 .quant16AsymmOperands = {},
8464 // int -> QUANT8_SYMM map
8465 .quant8SymmOperands = {},
8466 },
8467 //Output(s)
8468 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8469 // int -> Dimensions map
8470 .operandDimensions = {{0, {1, 2, 2, 2}}},
8471 // int -> FLOAT32 map
8472 .float32Operands = {},
8473 // int -> INT32 map
8474 .int32Operands = {},
8475 // int -> QUANT8_ASYMM map
8476 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
8477 // int -> QUANT16_SYMM map
8478 .quant16SymmOperands = {},
8479 // int -> FLOAT16 map
8480 .float16Operands = {},
8481 // int -> BOOL8 map
8482 .bool8Operands = {},
8483 // int -> QUANT8_SYMM_PER_CHANNEL map
8484 .quant8ChannelOperands = {},
8485 // int -> QUANT16_ASYMM map
8486 .quant16AsymmOperands = {},
8487 // int -> QUANT8_SYMM map
8488 .quant8SymmOperands = {},
8489 }
8490 },
8491 }, // End of an example
8492 };
8493 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8;
8494 };
8495
get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input()8496 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input() {
8497 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input = {
8498 // Begin of an example
8499 {
8500 .operands = {
8501 //Input(s)
8502 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8503 // int -> Dimensions map
8504 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8505 // int -> FLOAT32 map
8506 .float32Operands = {},
8507 // int -> INT32 map
8508 .int32Operands = {{2, {160, -268}}},
8509 // int -> QUANT8_ASYMM map
8510 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
8511 // int -> QUANT16_SYMM map
8512 .quant16SymmOperands = {},
8513 // int -> FLOAT16 map
8514 .float16Operands = {},
8515 // int -> BOOL8 map
8516 .bool8Operands = {},
8517 // int -> QUANT8_SYMM_PER_CHANNEL map
8518 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
8519 // int -> QUANT16_ASYMM map
8520 .quant16AsymmOperands = {},
8521 // int -> QUANT8_SYMM map
8522 .quant8SymmOperands = {},
8523 },
8524 //Output(s)
8525 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8526 // int -> Dimensions map
8527 .operandDimensions = {{0, {1, 2, 2, 2}}},
8528 // int -> FLOAT32 map
8529 .float32Operands = {},
8530 // int -> INT32 map
8531 .int32Operands = {},
8532 // int -> QUANT8_ASYMM map
8533 .quant8AsymmOperands = {{0, {82, 79, 82, 82, 82, 82, 82, 78}}},
8534 // int -> QUANT16_SYMM map
8535 .quant16SymmOperands = {},
8536 // int -> FLOAT16 map
8537 .float16Operands = {},
8538 // int -> BOOL8 map
8539 .bool8Operands = {},
8540 // int -> QUANT8_SYMM_PER_CHANNEL map
8541 .quant8ChannelOperands = {},
8542 // int -> QUANT16_ASYMM map
8543 .quant16AsymmOperands = {},
8544 // int -> QUANT8_SYMM map
8545 .quant8SymmOperands = {},
8546 }
8547 },
8548 }, // End of an example
8549 };
8550 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input;
8551 };
8552
get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2()8553 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2() {
8554 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2 = {
8555 // Begin of an example
8556 {
8557 .operands = {
8558 //Input(s)
8559 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8560 // int -> Dimensions map
8561 .operandDimensions = {{0, {1, 3, 3, 2}}},
8562 // int -> FLOAT32 map
8563 .float32Operands = {},
8564 // int -> INT32 map
8565 .int32Operands = {},
8566 // int -> QUANT8_ASYMM map
8567 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
8568 // int -> QUANT16_SYMM map
8569 .quant16SymmOperands = {},
8570 // int -> FLOAT16 map
8571 .float16Operands = {},
8572 // int -> BOOL8 map
8573 .bool8Operands = {},
8574 // int -> QUANT8_SYMM_PER_CHANNEL map
8575 .quant8ChannelOperands = {},
8576 // int -> QUANT16_ASYMM map
8577 .quant16AsymmOperands = {},
8578 // int -> QUANT8_SYMM map
8579 .quant8SymmOperands = {},
8580 },
8581 //Output(s)
8582 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8583 // int -> Dimensions map
8584 .operandDimensions = {{0, {1, 2, 2, 2}}},
8585 // int -> FLOAT32 map
8586 .float32Operands = {},
8587 // int -> INT32 map
8588 .int32Operands = {},
8589 // int -> QUANT8_ASYMM map
8590 .quant8AsymmOperands = {{0, {90, 75, 90, 90, 90, 90, 90, 70}}},
8591 // int -> QUANT16_SYMM map
8592 .quant16SymmOperands = {},
8593 // int -> FLOAT16 map
8594 .float16Operands = {},
8595 // int -> BOOL8 map
8596 .bool8Operands = {},
8597 // int -> QUANT8_SYMM_PER_CHANNEL map
8598 .quant8ChannelOperands = {},
8599 // int -> QUANT16_ASYMM map
8600 .quant16AsymmOperands = {},
8601 // int -> QUANT8_SYMM map
8602 .quant8SymmOperands = {},
8603 }
8604 },
8605 }, // End of an example
8606 };
8607 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2;
8608 };
8609
get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2()8610 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2() {
8611 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2 = {
8612 // Begin of an example
8613 {
8614 .operands = {
8615 //Input(s)
8616 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8617 // int -> Dimensions map
8618 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8619 // int -> FLOAT32 map
8620 .float32Operands = {},
8621 // int -> INT32 map
8622 .int32Operands = {{2, {160, -268}}},
8623 // int -> QUANT8_ASYMM map
8624 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
8625 // int -> QUANT16_SYMM map
8626 .quant16SymmOperands = {},
8627 // int -> FLOAT16 map
8628 .float16Operands = {},
8629 // int -> BOOL8 map
8630 .bool8Operands = {},
8631 // int -> QUANT8_SYMM_PER_CHANNEL map
8632 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
8633 // int -> QUANT16_ASYMM map
8634 .quant16AsymmOperands = {},
8635 // int -> QUANT8_SYMM map
8636 .quant8SymmOperands = {},
8637 },
8638 //Output(s)
8639 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8640 // int -> Dimensions map
8641 .operandDimensions = {{0, {1, 2, 2, 2}}},
8642 // int -> FLOAT32 map
8643 .float32Operands = {},
8644 // int -> INT32 map
8645 .int32Operands = {},
8646 // int -> QUANT8_ASYMM map
8647 .quant8AsymmOperands = {{0, {90, 75, 90, 90, 90, 90, 90, 70}}},
8648 // int -> QUANT16_SYMM map
8649 .quant16SymmOperands = {},
8650 // int -> FLOAT16 map
8651 .float16Operands = {},
8652 // int -> BOOL8 map
8653 .bool8Operands = {},
8654 // int -> QUANT8_SYMM_PER_CHANNEL map
8655 .quant8ChannelOperands = {},
8656 // int -> QUANT16_ASYMM map
8657 .quant16AsymmOperands = {},
8658 // int -> QUANT8_SYMM map
8659 .quant8SymmOperands = {},
8660 }
8661 },
8662 }, // End of an example
8663 };
8664 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2;
8665 };
8666
get_examples_dynamic_output_shape_nhwc_relu1_float16()8667 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_float16() {
8668 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_float16 = {
8669 // Begin of an example
8670 {
8671 .operands = {
8672 //Input(s)
8673 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8674 // int -> Dimensions map
8675 .operandDimensions = {{0, {1, 3, 3, 2}}},
8676 // int -> FLOAT32 map
8677 .float32Operands = {},
8678 // int -> INT32 map
8679 .int32Operands = {},
8680 // int -> QUANT8_ASYMM map
8681 .quant8AsymmOperands = {},
8682 // int -> QUANT16_SYMM map
8683 .quant16SymmOperands = {},
8684 // int -> FLOAT16 map
8685 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
8686 // int -> BOOL8 map
8687 .bool8Operands = {},
8688 // int -> QUANT8_SYMM_PER_CHANNEL map
8689 .quant8ChannelOperands = {},
8690 // int -> QUANT16_ASYMM map
8691 .quant16AsymmOperands = {},
8692 // int -> QUANT8_SYMM map
8693 .quant8SymmOperands = {},
8694 },
8695 //Output(s)
8696 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8697 // int -> Dimensions map
8698 .operandDimensions = {{0, {1, 2, 2, 2}}},
8699 // int -> FLOAT32 map
8700 .float32Operands = {},
8701 // int -> INT32 map
8702 .int32Operands = {},
8703 // int -> QUANT8_ASYMM map
8704 .quant8AsymmOperands = {},
8705 // int -> QUANT16_SYMM map
8706 .quant16SymmOperands = {},
8707 // int -> FLOAT16 map
8708 .float16Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
8709 // int -> BOOL8 map
8710 .bool8Operands = {},
8711 // int -> QUANT8_SYMM_PER_CHANNEL map
8712 .quant8ChannelOperands = {},
8713 // int -> QUANT16_ASYMM map
8714 .quant16AsymmOperands = {},
8715 // int -> QUANT8_SYMM map
8716 .quant8SymmOperands = {},
8717 }
8718 },
8719 }, // End of an example
8720 };
8721 return examples_dynamic_output_shape_nhwc_relu1_float16;
8722 };
8723
get_examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input()8724 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input() {
8725 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input = {
8726 // Begin of an example
8727 {
8728 .operands = {
8729 //Input(s)
8730 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8731 // int -> Dimensions map
8732 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8733 // int -> FLOAT32 map
8734 .float32Operands = {},
8735 // int -> INT32 map
8736 .int32Operands = {},
8737 // int -> QUANT8_ASYMM map
8738 .quant8AsymmOperands = {},
8739 // int -> QUANT16_SYMM map
8740 .quant16SymmOperands = {},
8741 // int -> FLOAT16 map
8742 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
8743 // int -> BOOL8 map
8744 .bool8Operands = {},
8745 // int -> QUANT8_SYMM_PER_CHANNEL map
8746 .quant8ChannelOperands = {},
8747 // int -> QUANT16_ASYMM map
8748 .quant16AsymmOperands = {},
8749 // int -> QUANT8_SYMM map
8750 .quant8SymmOperands = {},
8751 },
8752 //Output(s)
8753 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8754 // int -> Dimensions map
8755 .operandDimensions = {{0, {1, 2, 2, 2}}},
8756 // int -> FLOAT32 map
8757 .float32Operands = {},
8758 // int -> INT32 map
8759 .int32Operands = {},
8760 // int -> QUANT8_ASYMM map
8761 .quant8AsymmOperands = {},
8762 // int -> QUANT16_SYMM map
8763 .quant16SymmOperands = {},
8764 // int -> FLOAT16 map
8765 .float16Operands = {{0, {1.0f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f}}},
8766 // int -> BOOL8 map
8767 .bool8Operands = {},
8768 // int -> QUANT8_SYMM_PER_CHANNEL map
8769 .quant8ChannelOperands = {},
8770 // int -> QUANT16_ASYMM map
8771 .quant16AsymmOperands = {},
8772 // int -> QUANT8_SYMM map
8773 .quant8SymmOperands = {},
8774 }
8775 },
8776 }, // End of an example
8777 };
8778 return examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input;
8779 };
8780
get_examples_dynamic_output_shape_nhwc_relu6()8781 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6() {
8782 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6 = {
8783 // Begin of an example
8784 {
8785 .operands = {
8786 //Input(s)
8787 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8788 // int -> Dimensions map
8789 .operandDimensions = {{0, {1, 3, 3, 2}}},
8790 // int -> FLOAT32 map
8791 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
8792 // int -> INT32 map
8793 .int32Operands = {},
8794 // int -> QUANT8_ASYMM map
8795 .quant8AsymmOperands = {},
8796 // int -> QUANT16_SYMM map
8797 .quant16SymmOperands = {},
8798 // int -> FLOAT16 map
8799 .float16Operands = {},
8800 // int -> BOOL8 map
8801 .bool8Operands = {},
8802 // int -> QUANT8_SYMM_PER_CHANNEL map
8803 .quant8ChannelOperands = {},
8804 // int -> QUANT16_ASYMM map
8805 .quant16AsymmOperands = {},
8806 // int -> QUANT8_SYMM map
8807 .quant8SymmOperands = {},
8808 },
8809 //Output(s)
8810 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8811 // int -> Dimensions map
8812 .operandDimensions = {{0, {1, 2, 2, 2}}},
8813 // int -> FLOAT32 map
8814 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
8815 // int -> INT32 map
8816 .int32Operands = {},
8817 // int -> QUANT8_ASYMM map
8818 .quant8AsymmOperands = {},
8819 // int -> QUANT16_SYMM map
8820 .quant16SymmOperands = {},
8821 // int -> FLOAT16 map
8822 .float16Operands = {},
8823 // int -> BOOL8 map
8824 .bool8Operands = {},
8825 // int -> QUANT8_SYMM_PER_CHANNEL map
8826 .quant8ChannelOperands = {},
8827 // int -> QUANT16_ASYMM map
8828 .quant16AsymmOperands = {},
8829 // int -> QUANT8_SYMM map
8830 .quant8SymmOperands = {},
8831 }
8832 },
8833 }, // End of an example
8834 };
8835 return examples_dynamic_output_shape_nhwc_relu6;
8836 };
8837
get_examples_dynamic_output_shape_nhwc_relu6_weight_as_input()8838 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_weight_as_input() {
8839 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_weight_as_input = {
8840 // Begin of an example
8841 {
8842 .operands = {
8843 //Input(s)
8844 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8845 // int -> Dimensions map
8846 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8847 // int -> FLOAT32 map
8848 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
8849 // int -> INT32 map
8850 .int32Operands = {},
8851 // int -> QUANT8_ASYMM map
8852 .quant8AsymmOperands = {},
8853 // int -> QUANT16_SYMM map
8854 .quant16SymmOperands = {},
8855 // int -> FLOAT16 map
8856 .float16Operands = {},
8857 // int -> BOOL8 map
8858 .bool8Operands = {},
8859 // int -> QUANT8_SYMM_PER_CHANNEL map
8860 .quant8ChannelOperands = {},
8861 // int -> QUANT16_ASYMM map
8862 .quant16AsymmOperands = {},
8863 // int -> QUANT8_SYMM map
8864 .quant8SymmOperands = {},
8865 },
8866 //Output(s)
8867 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8868 // int -> Dimensions map
8869 .operandDimensions = {{0, {1, 2, 2, 2}}},
8870 // int -> FLOAT32 map
8871 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
8872 // int -> INT32 map
8873 .int32Operands = {},
8874 // int -> QUANT8_ASYMM map
8875 .quant8AsymmOperands = {},
8876 // int -> QUANT16_SYMM map
8877 .quant16SymmOperands = {},
8878 // int -> FLOAT16 map
8879 .float16Operands = {},
8880 // int -> BOOL8 map
8881 .bool8Operands = {},
8882 // int -> QUANT8_SYMM_PER_CHANNEL map
8883 .quant8ChannelOperands = {},
8884 // int -> QUANT16_ASYMM map
8885 .quant16AsymmOperands = {},
8886 // int -> QUANT8_SYMM map
8887 .quant8SymmOperands = {},
8888 }
8889 },
8890 }, // End of an example
8891 };
8892 return examples_dynamic_output_shape_nhwc_relu6_weight_as_input;
8893 };
8894
get_examples_dynamic_output_shape_nhwc_relu6_relaxed()8895 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_relaxed() {
8896 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_relaxed = {
8897 // Begin of an example
8898 {
8899 .operands = {
8900 //Input(s)
8901 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8902 // int -> Dimensions map
8903 .operandDimensions = {{0, {1, 3, 3, 2}}},
8904 // int -> FLOAT32 map
8905 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
8906 // int -> INT32 map
8907 .int32Operands = {},
8908 // int -> QUANT8_ASYMM map
8909 .quant8AsymmOperands = {},
8910 // int -> QUANT16_SYMM map
8911 .quant16SymmOperands = {},
8912 // int -> FLOAT16 map
8913 .float16Operands = {},
8914 // int -> BOOL8 map
8915 .bool8Operands = {},
8916 // int -> QUANT8_SYMM_PER_CHANNEL map
8917 .quant8ChannelOperands = {},
8918 // int -> QUANT16_ASYMM map
8919 .quant16AsymmOperands = {},
8920 // int -> QUANT8_SYMM map
8921 .quant8SymmOperands = {},
8922 },
8923 //Output(s)
8924 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8925 // int -> Dimensions map
8926 .operandDimensions = {{0, {1, 2, 2, 2}}},
8927 // int -> FLOAT32 map
8928 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
8929 // int -> INT32 map
8930 .int32Operands = {},
8931 // int -> QUANT8_ASYMM map
8932 .quant8AsymmOperands = {},
8933 // int -> QUANT16_SYMM map
8934 .quant16SymmOperands = {},
8935 // int -> FLOAT16 map
8936 .float16Operands = {},
8937 // int -> BOOL8 map
8938 .bool8Operands = {},
8939 // int -> QUANT8_SYMM_PER_CHANNEL map
8940 .quant8ChannelOperands = {},
8941 // int -> QUANT16_ASYMM map
8942 .quant16AsymmOperands = {},
8943 // int -> QUANT8_SYMM map
8944 .quant8SymmOperands = {},
8945 }
8946 },
8947 }, // End of an example
8948 };
8949 return examples_dynamic_output_shape_nhwc_relu6_relaxed;
8950 };
8951
get_examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input()8952 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input() {
8953 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input = {
8954 // Begin of an example
8955 {
8956 .operands = {
8957 //Input(s)
8958 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8959 // int -> Dimensions map
8960 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
8961 // int -> FLOAT32 map
8962 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
8963 // int -> INT32 map
8964 .int32Operands = {},
8965 // int -> QUANT8_ASYMM map
8966 .quant8AsymmOperands = {},
8967 // int -> QUANT16_SYMM map
8968 .quant16SymmOperands = {},
8969 // int -> FLOAT16 map
8970 .float16Operands = {},
8971 // int -> BOOL8 map
8972 .bool8Operands = {},
8973 // int -> QUANT8_SYMM_PER_CHANNEL map
8974 .quant8ChannelOperands = {},
8975 // int -> QUANT16_ASYMM map
8976 .quant16AsymmOperands = {},
8977 // int -> QUANT8_SYMM map
8978 .quant8SymmOperands = {},
8979 },
8980 //Output(s)
8981 { // See tools/test_generator/include/TestHarness.h:MixedTyped
8982 // int -> Dimensions map
8983 .operandDimensions = {{0, {1, 2, 2, 2}}},
8984 // int -> FLOAT32 map
8985 .float32Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
8986 // int -> INT32 map
8987 .int32Operands = {},
8988 // int -> QUANT8_ASYMM map
8989 .quant8AsymmOperands = {},
8990 // int -> QUANT16_SYMM map
8991 .quant16SymmOperands = {},
8992 // int -> FLOAT16 map
8993 .float16Operands = {},
8994 // int -> BOOL8 map
8995 .bool8Operands = {},
8996 // int -> QUANT8_SYMM_PER_CHANNEL map
8997 .quant8ChannelOperands = {},
8998 // int -> QUANT16_ASYMM map
8999 .quant16AsymmOperands = {},
9000 // int -> QUANT8_SYMM map
9001 .quant8SymmOperands = {},
9002 }
9003 },
9004 }, // End of an example
9005 };
9006 return examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input;
9007 };
9008
get_examples_dynamic_output_shape_nhwc_relu6_quant8()9009 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8() {
9010 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8 = {
9011 // Begin of an example
9012 {
9013 .operands = {
9014 //Input(s)
9015 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9016 // int -> Dimensions map
9017 .operandDimensions = {{0, {1, 3, 3, 2}}},
9018 // int -> FLOAT32 map
9019 .float32Operands = {},
9020 // int -> INT32 map
9021 .int32Operands = {},
9022 // int -> QUANT8_ASYMM map
9023 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
9024 // int -> QUANT16_SYMM map
9025 .quant16SymmOperands = {},
9026 // int -> FLOAT16 map
9027 .float16Operands = {},
9028 // int -> BOOL8 map
9029 .bool8Operands = {},
9030 // int -> QUANT8_SYMM_PER_CHANNEL map
9031 .quant8ChannelOperands = {},
9032 // int -> QUANT16_ASYMM map
9033 .quant16AsymmOperands = {},
9034 // int -> QUANT8_SYMM map
9035 .quant8SymmOperands = {},
9036 },
9037 //Output(s)
9038 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9039 // int -> Dimensions map
9040 .operandDimensions = {{0, {1, 2, 2, 2}}},
9041 // int -> FLOAT32 map
9042 .float32Operands = {},
9043 // int -> INT32 map
9044 .int32Operands = {},
9045 // int -> QUANT8_ASYMM map
9046 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
9047 // int -> QUANT16_SYMM map
9048 .quant16SymmOperands = {},
9049 // int -> FLOAT16 map
9050 .float16Operands = {},
9051 // int -> BOOL8 map
9052 .bool8Operands = {},
9053 // int -> QUANT8_SYMM_PER_CHANNEL map
9054 .quant8ChannelOperands = {},
9055 // int -> QUANT16_ASYMM map
9056 .quant16AsymmOperands = {},
9057 // int -> QUANT8_SYMM map
9058 .quant8SymmOperands = {},
9059 }
9060 },
9061 }, // End of an example
9062 };
9063 return examples_dynamic_output_shape_nhwc_relu6_quant8;
9064 };
9065
get_examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input()9066 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input() {
9067 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input = {
9068 // Begin of an example
9069 {
9070 .operands = {
9071 //Input(s)
9072 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9073 // int -> Dimensions map
9074 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9075 // int -> FLOAT32 map
9076 .float32Operands = {},
9077 // int -> INT32 map
9078 .int32Operands = {{2, {160, -536}}},
9079 // int -> QUANT8_ASYMM map
9080 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
9081 // int -> QUANT16_SYMM map
9082 .quant16SymmOperands = {},
9083 // int -> FLOAT16 map
9084 .float16Operands = {},
9085 // int -> BOOL8 map
9086 .bool8Operands = {},
9087 // int -> QUANT8_SYMM_PER_CHANNEL map
9088 .quant8ChannelOperands = {},
9089 // int -> QUANT16_ASYMM map
9090 .quant16AsymmOperands = {},
9091 // int -> QUANT8_SYMM map
9092 .quant8SymmOperands = {},
9093 },
9094 //Output(s)
9095 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9096 // int -> Dimensions map
9097 .operandDimensions = {{0, {1, 2, 2, 2}}},
9098 // int -> FLOAT32 map
9099 .float32Operands = {},
9100 // int -> INT32 map
9101 .int32Operands = {},
9102 // int -> QUANT8_ASYMM map
9103 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
9104 // int -> QUANT16_SYMM map
9105 .quant16SymmOperands = {},
9106 // int -> FLOAT16 map
9107 .float16Operands = {},
9108 // int -> BOOL8 map
9109 .bool8Operands = {},
9110 // int -> QUANT8_SYMM_PER_CHANNEL map
9111 .quant8ChannelOperands = {},
9112 // int -> QUANT16_ASYMM map
9113 .quant16AsymmOperands = {},
9114 // int -> QUANT8_SYMM map
9115 .quant8SymmOperands = {},
9116 }
9117 },
9118 }, // End of an example
9119 };
9120 return examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input;
9121 };
9122
get_examples_dynamic_output_shape_nhwc_relu6_quant8_2()9123 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8_2() {
9124 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8_2 = {
9125 // Begin of an example
9126 {
9127 .operands = {
9128 //Input(s)
9129 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9130 // int -> Dimensions map
9131 .operandDimensions = {{0, {1, 3, 3, 2}}},
9132 // int -> FLOAT32 map
9133 .float32Operands = {},
9134 // int -> INT32 map
9135 .int32Operands = {},
9136 // int -> QUANT8_ASYMM map
9137 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
9138 // int -> QUANT16_SYMM map
9139 .quant16SymmOperands = {},
9140 // int -> FLOAT16 map
9141 .float16Operands = {},
9142 // int -> BOOL8 map
9143 .bool8Operands = {},
9144 // int -> QUANT8_SYMM_PER_CHANNEL map
9145 .quant8ChannelOperands = {},
9146 // int -> QUANT16_ASYMM map
9147 .quant16AsymmOperands = {},
9148 // int -> QUANT8_SYMM map
9149 .quant8SymmOperands = {},
9150 },
9151 //Output(s)
9152 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9153 // int -> Dimensions map
9154 .operandDimensions = {{0, {1, 2, 2, 2}}},
9155 // int -> FLOAT32 map
9156 .float32Operands = {},
9157 // int -> INT32 map
9158 .int32Operands = {},
9159 // int -> QUANT8_ASYMM map
9160 .quant8AsymmOperands = {{0, {200, 80, 200, 200, 200, 170, 200, 80}}},
9161 // int -> QUANT16_SYMM map
9162 .quant16SymmOperands = {},
9163 // int -> FLOAT16 map
9164 .float16Operands = {},
9165 // int -> BOOL8 map
9166 .bool8Operands = {},
9167 // int -> QUANT8_SYMM_PER_CHANNEL map
9168 .quant8ChannelOperands = {},
9169 // int -> QUANT16_ASYMM map
9170 .quant16AsymmOperands = {},
9171 // int -> QUANT8_SYMM map
9172 .quant8SymmOperands = {},
9173 }
9174 },
9175 }, // End of an example
9176 };
9177 return examples_dynamic_output_shape_nhwc_relu6_quant8_2;
9178 };
9179
get_examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2()9180 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2() {
9181 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2 = {
9182 // Begin of an example
9183 {
9184 .operands = {
9185 //Input(s)
9186 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9187 // int -> Dimensions map
9188 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9189 // int -> FLOAT32 map
9190 .float32Operands = {},
9191 // int -> INT32 map
9192 .int32Operands = {{2, {160, -536}}},
9193 // int -> QUANT8_ASYMM map
9194 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
9195 // int -> QUANT16_SYMM map
9196 .quant16SymmOperands = {},
9197 // int -> FLOAT16 map
9198 .float16Operands = {},
9199 // int -> BOOL8 map
9200 .bool8Operands = {},
9201 // int -> QUANT8_SYMM_PER_CHANNEL map
9202 .quant8ChannelOperands = {},
9203 // int -> QUANT16_ASYMM map
9204 .quant16AsymmOperands = {},
9205 // int -> QUANT8_SYMM map
9206 .quant8SymmOperands = {},
9207 },
9208 //Output(s)
9209 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9210 // int -> Dimensions map
9211 .operandDimensions = {{0, {1, 2, 2, 2}}},
9212 // int -> FLOAT32 map
9213 .float32Operands = {},
9214 // int -> INT32 map
9215 .int32Operands = {},
9216 // int -> QUANT8_ASYMM map
9217 .quant8AsymmOperands = {{0, {200, 80, 200, 200, 200, 170, 200, 80}}},
9218 // int -> QUANT16_SYMM map
9219 .quant16SymmOperands = {},
9220 // int -> FLOAT16 map
9221 .float16Operands = {},
9222 // int -> BOOL8 map
9223 .bool8Operands = {},
9224 // int -> QUANT8_SYMM_PER_CHANNEL map
9225 .quant8ChannelOperands = {},
9226 // int -> QUANT16_ASYMM map
9227 .quant16AsymmOperands = {},
9228 // int -> QUANT8_SYMM map
9229 .quant8SymmOperands = {},
9230 }
9231 },
9232 }, // End of an example
9233 };
9234 return examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2;
9235 };
9236
get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8()9237 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8() {
9238 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8 = {
9239 // Begin of an example
9240 {
9241 .operands = {
9242 //Input(s)
9243 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9244 // int -> Dimensions map
9245 .operandDimensions = {{0, {1, 3, 3, 2}}},
9246 // int -> FLOAT32 map
9247 .float32Operands = {},
9248 // int -> INT32 map
9249 .int32Operands = {},
9250 // int -> QUANT8_ASYMM map
9251 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
9252 // int -> QUANT16_SYMM map
9253 .quant16SymmOperands = {},
9254 // int -> FLOAT16 map
9255 .float16Operands = {},
9256 // int -> BOOL8 map
9257 .bool8Operands = {},
9258 // int -> QUANT8_SYMM_PER_CHANNEL map
9259 .quant8ChannelOperands = {},
9260 // int -> QUANT16_ASYMM map
9261 .quant16AsymmOperands = {},
9262 // int -> QUANT8_SYMM map
9263 .quant8SymmOperands = {},
9264 },
9265 //Output(s)
9266 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9267 // int -> Dimensions map
9268 .operandDimensions = {{0, {1, 2, 2, 2}}},
9269 // int -> FLOAT32 map
9270 .float32Operands = {},
9271 // int -> INT32 map
9272 .int32Operands = {},
9273 // int -> QUANT8_ASYMM map
9274 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
9275 // int -> QUANT16_SYMM map
9276 .quant16SymmOperands = {},
9277 // int -> FLOAT16 map
9278 .float16Operands = {},
9279 // int -> BOOL8 map
9280 .bool8Operands = {},
9281 // int -> QUANT8_SYMM_PER_CHANNEL map
9282 .quant8ChannelOperands = {},
9283 // int -> QUANT16_ASYMM map
9284 .quant16AsymmOperands = {},
9285 // int -> QUANT8_SYMM map
9286 .quant8SymmOperands = {},
9287 }
9288 },
9289 }, // End of an example
9290 };
9291 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8;
9292 };
9293
get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input()9294 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input() {
9295 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input = {
9296 // Begin of an example
9297 {
9298 .operands = {
9299 //Input(s)
9300 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9301 // int -> Dimensions map
9302 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9303 // int -> FLOAT32 map
9304 .float32Operands = {},
9305 // int -> INT32 map
9306 .int32Operands = {{2, {160, -268}}},
9307 // int -> QUANT8_ASYMM map
9308 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
9309 // int -> QUANT16_SYMM map
9310 .quant16SymmOperands = {},
9311 // int -> FLOAT16 map
9312 .float16Operands = {},
9313 // int -> BOOL8 map
9314 .bool8Operands = {},
9315 // int -> QUANT8_SYMM_PER_CHANNEL map
9316 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
9317 // int -> QUANT16_ASYMM map
9318 .quant16AsymmOperands = {},
9319 // int -> QUANT8_SYMM map
9320 .quant8SymmOperands = {},
9321 },
9322 //Output(s)
9323 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9324 // int -> Dimensions map
9325 .operandDimensions = {{0, {1, 2, 2, 2}}},
9326 // int -> FLOAT32 map
9327 .float32Operands = {},
9328 // int -> INT32 map
9329 .int32Operands = {},
9330 // int -> QUANT8_ASYMM map
9331 .quant8AsymmOperands = {{0, {92, 80, 92, 92, 92, 89, 92, 80}}},
9332 // int -> QUANT16_SYMM map
9333 .quant16SymmOperands = {},
9334 // int -> FLOAT16 map
9335 .float16Operands = {},
9336 // int -> BOOL8 map
9337 .bool8Operands = {},
9338 // int -> QUANT8_SYMM_PER_CHANNEL map
9339 .quant8ChannelOperands = {},
9340 // int -> QUANT16_ASYMM map
9341 .quant16AsymmOperands = {},
9342 // int -> QUANT8_SYMM map
9343 .quant8SymmOperands = {},
9344 }
9345 },
9346 }, // End of an example
9347 };
9348 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input;
9349 };
9350
get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2()9351 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2() {
9352 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2 = {
9353 // Begin of an example
9354 {
9355 .operands = {
9356 //Input(s)
9357 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9358 // int -> Dimensions map
9359 .operandDimensions = {{0, {1, 3, 3, 2}}},
9360 // int -> FLOAT32 map
9361 .float32Operands = {},
9362 // int -> INT32 map
9363 .int32Operands = {},
9364 // int -> QUANT8_ASYMM map
9365 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
9366 // int -> QUANT16_SYMM map
9367 .quant16SymmOperands = {},
9368 // int -> FLOAT16 map
9369 .float16Operands = {},
9370 // int -> BOOL8 map
9371 .bool8Operands = {},
9372 // int -> QUANT8_SYMM_PER_CHANNEL map
9373 .quant8ChannelOperands = {},
9374 // int -> QUANT16_ASYMM map
9375 .quant16AsymmOperands = {},
9376 // int -> QUANT8_SYMM map
9377 .quant8SymmOperands = {},
9378 },
9379 //Output(s)
9380 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9381 // int -> Dimensions map
9382 .operandDimensions = {{0, {1, 2, 2, 2}}},
9383 // int -> FLOAT32 map
9384 .float32Operands = {},
9385 // int -> INT32 map
9386 .int32Operands = {},
9387 // int -> QUANT8_ASYMM map
9388 .quant8AsymmOperands = {{0, {140, 80, 140, 140, 140, 125, 140, 80}}},
9389 // int -> QUANT16_SYMM map
9390 .quant16SymmOperands = {},
9391 // int -> FLOAT16 map
9392 .float16Operands = {},
9393 // int -> BOOL8 map
9394 .bool8Operands = {},
9395 // int -> QUANT8_SYMM_PER_CHANNEL map
9396 .quant8ChannelOperands = {},
9397 // int -> QUANT16_ASYMM map
9398 .quant16AsymmOperands = {},
9399 // int -> QUANT8_SYMM map
9400 .quant8SymmOperands = {},
9401 }
9402 },
9403 }, // End of an example
9404 };
9405 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2;
9406 };
9407
get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2()9408 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2() {
9409 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2 = {
9410 // Begin of an example
9411 {
9412 .operands = {
9413 //Input(s)
9414 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9415 // int -> Dimensions map
9416 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9417 // int -> FLOAT32 map
9418 .float32Operands = {},
9419 // int -> INT32 map
9420 .int32Operands = {{2, {160, -268}}},
9421 // int -> QUANT8_ASYMM map
9422 .quant8AsymmOperands = {{0, {104, 108, 112, 116, 120, 124, 124, 120, 116, 112, 108, 104, 108, 112, 112, 112, 112, 112}}},
9423 // int -> QUANT16_SYMM map
9424 .quant16SymmOperands = {},
9425 // int -> FLOAT16 map
9426 .float16Operands = {},
9427 // int -> BOOL8 map
9428 .bool8Operands = {},
9429 // int -> QUANT8_SYMM_PER_CHANNEL map
9430 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
9431 // int -> QUANT16_ASYMM map
9432 .quant16AsymmOperands = {},
9433 // int -> QUANT8_SYMM map
9434 .quant8SymmOperands = {},
9435 },
9436 //Output(s)
9437 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9438 // int -> Dimensions map
9439 .operandDimensions = {{0, {1, 2, 2, 2}}},
9440 // int -> FLOAT32 map
9441 .float32Operands = {},
9442 // int -> INT32 map
9443 .int32Operands = {},
9444 // int -> QUANT8_ASYMM map
9445 .quant8AsymmOperands = {{0, {140, 80, 140, 140, 140, 125, 140, 80}}},
9446 // int -> QUANT16_SYMM map
9447 .quant16SymmOperands = {},
9448 // int -> FLOAT16 map
9449 .float16Operands = {},
9450 // int -> BOOL8 map
9451 .bool8Operands = {},
9452 // int -> QUANT8_SYMM_PER_CHANNEL map
9453 .quant8ChannelOperands = {},
9454 // int -> QUANT16_ASYMM map
9455 .quant16AsymmOperands = {},
9456 // int -> QUANT8_SYMM map
9457 .quant8SymmOperands = {},
9458 }
9459 },
9460 }, // End of an example
9461 };
9462 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2;
9463 };
9464
get_examples_dynamic_output_shape_nhwc_relu6_float16()9465 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_float16() {
9466 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_float16 = {
9467 // Begin of an example
9468 {
9469 .operands = {
9470 //Input(s)
9471 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9472 // int -> Dimensions map
9473 .operandDimensions = {{0, {1, 3, 3, 2}}},
9474 // int -> FLOAT32 map
9475 .float32Operands = {},
9476 // int -> INT32 map
9477 .int32Operands = {},
9478 // int -> QUANT8_ASYMM map
9479 .quant8AsymmOperands = {},
9480 // int -> QUANT16_SYMM map
9481 .quant16SymmOperands = {},
9482 // int -> FLOAT16 map
9483 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}},
9484 // int -> BOOL8 map
9485 .bool8Operands = {},
9486 // int -> QUANT8_SYMM_PER_CHANNEL map
9487 .quant8ChannelOperands = {},
9488 // int -> QUANT16_ASYMM map
9489 .quant16AsymmOperands = {},
9490 // int -> QUANT8_SYMM map
9491 .quant8SymmOperands = {},
9492 },
9493 //Output(s)
9494 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9495 // int -> Dimensions map
9496 .operandDimensions = {{0, {1, 2, 2, 2}}},
9497 // int -> FLOAT32 map
9498 .float32Operands = {},
9499 // int -> INT32 map
9500 .int32Operands = {},
9501 // int -> QUANT8_ASYMM map
9502 .quant8AsymmOperands = {},
9503 // int -> QUANT16_SYMM map
9504 .quant16SymmOperands = {},
9505 // int -> FLOAT16 map
9506 .float16Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
9507 // int -> BOOL8 map
9508 .bool8Operands = {},
9509 // int -> QUANT8_SYMM_PER_CHANNEL map
9510 .quant8ChannelOperands = {},
9511 // int -> QUANT16_ASYMM map
9512 .quant16AsymmOperands = {},
9513 // int -> QUANT8_SYMM map
9514 .quant8SymmOperands = {},
9515 }
9516 },
9517 }, // End of an example
9518 };
9519 return examples_dynamic_output_shape_nhwc_relu6_float16;
9520 };
9521
get_examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input()9522 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input() {
9523 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input = {
9524 // Begin of an example
9525 {
9526 .operands = {
9527 //Input(s)
9528 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9529 // int -> Dimensions map
9530 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9531 // int -> FLOAT32 map
9532 .float32Operands = {},
9533 // int -> INT32 map
9534 .int32Operands = {},
9535 // int -> QUANT8_ASYMM map
9536 .quant8AsymmOperands = {},
9537 // int -> QUANT16_SYMM map
9538 .quant16SymmOperands = {},
9539 // int -> FLOAT16 map
9540 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
9541 // int -> BOOL8 map
9542 .bool8Operands = {},
9543 // int -> QUANT8_SYMM_PER_CHANNEL map
9544 .quant8ChannelOperands = {},
9545 // int -> QUANT16_ASYMM map
9546 .quant16AsymmOperands = {},
9547 // int -> QUANT8_SYMM map
9548 .quant8SymmOperands = {},
9549 },
9550 //Output(s)
9551 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9552 // int -> Dimensions map
9553 .operandDimensions = {{0, {1, 2, 2, 2}}},
9554 // int -> FLOAT32 map
9555 .float32Operands = {},
9556 // int -> INT32 map
9557 .int32Operands = {},
9558 // int -> QUANT8_ASYMM map
9559 .quant8AsymmOperands = {},
9560 // int -> QUANT16_SYMM map
9561 .quant16SymmOperands = {},
9562 // int -> FLOAT16 map
9563 .float16Operands = {{0, {6.0f, 0.0f, 6.0f, 6.0f, 6.0f, 4.5f, 6.0f, 0.0f}}},
9564 // int -> BOOL8 map
9565 .bool8Operands = {},
9566 // int -> QUANT8_SYMM_PER_CHANNEL map
9567 .quant8ChannelOperands = {},
9568 // int -> QUANT16_ASYMM map
9569 .quant16AsymmOperands = {},
9570 // int -> QUANT8_SYMM map
9571 .quant8SymmOperands = {},
9572 }
9573 },
9574 }, // End of an example
9575 };
9576 return examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input;
9577 };
9578
get_examples_dynamic_output_shape_nchw_none()9579 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none() {
9580 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none = {
9581 // Begin of an example
9582 {
9583 .operands = {
9584 //Input(s)
9585 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9586 // int -> Dimensions map
9587 .operandDimensions = {{0, {1, 2, 3, 3}}},
9588 // int -> FLOAT32 map
9589 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
9590 // int -> INT32 map
9591 .int32Operands = {},
9592 // int -> QUANT8_ASYMM map
9593 .quant8AsymmOperands = {},
9594 // int -> QUANT16_SYMM map
9595 .quant16SymmOperands = {},
9596 // int -> FLOAT16 map
9597 .float16Operands = {},
9598 // int -> BOOL8 map
9599 .bool8Operands = {},
9600 // int -> QUANT8_SYMM_PER_CHANNEL map
9601 .quant8ChannelOperands = {},
9602 // int -> QUANT16_ASYMM map
9603 .quant16AsymmOperands = {},
9604 // int -> QUANT8_SYMM map
9605 .quant8SymmOperands = {},
9606 },
9607 //Output(s)
9608 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9609 // int -> Dimensions map
9610 .operandDimensions = {{0, {1, 2, 2, 2}}},
9611 // int -> FLOAT32 map
9612 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
9613 // int -> INT32 map
9614 .int32Operands = {},
9615 // int -> QUANT8_ASYMM map
9616 .quant8AsymmOperands = {},
9617 // int -> QUANT16_SYMM map
9618 .quant16SymmOperands = {},
9619 // int -> FLOAT16 map
9620 .float16Operands = {},
9621 // int -> BOOL8 map
9622 .bool8Operands = {},
9623 // int -> QUANT8_SYMM_PER_CHANNEL map
9624 .quant8ChannelOperands = {},
9625 // int -> QUANT16_ASYMM map
9626 .quant16AsymmOperands = {},
9627 // int -> QUANT8_SYMM map
9628 .quant8SymmOperands = {},
9629 }
9630 },
9631 }, // End of an example
9632 };
9633 return examples_dynamic_output_shape_nchw_none;
9634 };
9635
get_examples_dynamic_output_shape_nchw_none_weight_as_input()9636 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_weight_as_input() {
9637 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_weight_as_input = {
9638 // Begin of an example
9639 {
9640 .operands = {
9641 //Input(s)
9642 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9643 // int -> Dimensions map
9644 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9645 // int -> FLOAT32 map
9646 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
9647 // int -> INT32 map
9648 .int32Operands = {},
9649 // int -> QUANT8_ASYMM map
9650 .quant8AsymmOperands = {},
9651 // int -> QUANT16_SYMM map
9652 .quant16SymmOperands = {},
9653 // int -> FLOAT16 map
9654 .float16Operands = {},
9655 // int -> BOOL8 map
9656 .bool8Operands = {},
9657 // int -> QUANT8_SYMM_PER_CHANNEL map
9658 .quant8ChannelOperands = {},
9659 // int -> QUANT16_ASYMM map
9660 .quant16AsymmOperands = {},
9661 // int -> QUANT8_SYMM map
9662 .quant8SymmOperands = {},
9663 },
9664 //Output(s)
9665 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9666 // int -> Dimensions map
9667 .operandDimensions = {{0, {1, 2, 2, 2}}},
9668 // int -> FLOAT32 map
9669 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
9670 // int -> INT32 map
9671 .int32Operands = {},
9672 // int -> QUANT8_ASYMM map
9673 .quant8AsymmOperands = {},
9674 // int -> QUANT16_SYMM map
9675 .quant16SymmOperands = {},
9676 // int -> FLOAT16 map
9677 .float16Operands = {},
9678 // int -> BOOL8 map
9679 .bool8Operands = {},
9680 // int -> QUANT8_SYMM_PER_CHANNEL map
9681 .quant8ChannelOperands = {},
9682 // int -> QUANT16_ASYMM map
9683 .quant16AsymmOperands = {},
9684 // int -> QUANT8_SYMM map
9685 .quant8SymmOperands = {},
9686 }
9687 },
9688 }, // End of an example
9689 };
9690 return examples_dynamic_output_shape_nchw_none_weight_as_input;
9691 };
9692
get_examples_dynamic_output_shape_nchw_none_relaxed()9693 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_relaxed() {
9694 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_relaxed = {
9695 // Begin of an example
9696 {
9697 .operands = {
9698 //Input(s)
9699 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9700 // int -> Dimensions map
9701 .operandDimensions = {{0, {1, 2, 3, 3}}},
9702 // int -> FLOAT32 map
9703 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
9704 // int -> INT32 map
9705 .int32Operands = {},
9706 // int -> QUANT8_ASYMM map
9707 .quant8AsymmOperands = {},
9708 // int -> QUANT16_SYMM map
9709 .quant16SymmOperands = {},
9710 // int -> FLOAT16 map
9711 .float16Operands = {},
9712 // int -> BOOL8 map
9713 .bool8Operands = {},
9714 // int -> QUANT8_SYMM_PER_CHANNEL map
9715 .quant8ChannelOperands = {},
9716 // int -> QUANT16_ASYMM map
9717 .quant16AsymmOperands = {},
9718 // int -> QUANT8_SYMM map
9719 .quant8SymmOperands = {},
9720 },
9721 //Output(s)
9722 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9723 // int -> Dimensions map
9724 .operandDimensions = {{0, {1, 2, 2, 2}}},
9725 // int -> FLOAT32 map
9726 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
9727 // int -> INT32 map
9728 .int32Operands = {},
9729 // int -> QUANT8_ASYMM map
9730 .quant8AsymmOperands = {},
9731 // int -> QUANT16_SYMM map
9732 .quant16SymmOperands = {},
9733 // int -> FLOAT16 map
9734 .float16Operands = {},
9735 // int -> BOOL8 map
9736 .bool8Operands = {},
9737 // int -> QUANT8_SYMM_PER_CHANNEL map
9738 .quant8ChannelOperands = {},
9739 // int -> QUANT16_ASYMM map
9740 .quant16AsymmOperands = {},
9741 // int -> QUANT8_SYMM map
9742 .quant8SymmOperands = {},
9743 }
9744 },
9745 }, // End of an example
9746 };
9747 return examples_dynamic_output_shape_nchw_none_relaxed;
9748 };
9749
get_examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input()9750 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input() {
9751 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input = {
9752 // Begin of an example
9753 {
9754 .operands = {
9755 //Input(s)
9756 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9757 // int -> Dimensions map
9758 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9759 // int -> FLOAT32 map
9760 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
9761 // int -> INT32 map
9762 .int32Operands = {},
9763 // int -> QUANT8_ASYMM map
9764 .quant8AsymmOperands = {},
9765 // int -> QUANT16_SYMM map
9766 .quant16SymmOperands = {},
9767 // int -> FLOAT16 map
9768 .float16Operands = {},
9769 // int -> BOOL8 map
9770 .bool8Operands = {},
9771 // int -> QUANT8_SYMM_PER_CHANNEL map
9772 .quant8ChannelOperands = {},
9773 // int -> QUANT16_ASYMM map
9774 .quant16AsymmOperands = {},
9775 // int -> QUANT8_SYMM map
9776 .quant8SymmOperands = {},
9777 },
9778 //Output(s)
9779 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9780 // int -> Dimensions map
9781 .operandDimensions = {{0, {1, 2, 2, 2}}},
9782 // int -> FLOAT32 map
9783 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
9784 // int -> INT32 map
9785 .int32Operands = {},
9786 // int -> QUANT8_ASYMM map
9787 .quant8AsymmOperands = {},
9788 // int -> QUANT16_SYMM map
9789 .quant16SymmOperands = {},
9790 // int -> FLOAT16 map
9791 .float16Operands = {},
9792 // int -> BOOL8 map
9793 .bool8Operands = {},
9794 // int -> QUANT8_SYMM_PER_CHANNEL map
9795 .quant8ChannelOperands = {},
9796 // int -> QUANT16_ASYMM map
9797 .quant16AsymmOperands = {},
9798 // int -> QUANT8_SYMM map
9799 .quant8SymmOperands = {},
9800 }
9801 },
9802 }, // End of an example
9803 };
9804 return examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input;
9805 };
9806
get_examples_dynamic_output_shape_nchw_none_quant8()9807 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8() {
9808 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8 = {
9809 // Begin of an example
9810 {
9811 .operands = {
9812 //Input(s)
9813 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9814 // int -> Dimensions map
9815 .operandDimensions = {{0, {1, 2, 3, 3}}},
9816 // int -> FLOAT32 map
9817 .float32Operands = {},
9818 // int -> INT32 map
9819 .int32Operands = {},
9820 // int -> QUANT8_ASYMM map
9821 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
9822 // int -> QUANT16_SYMM map
9823 .quant16SymmOperands = {},
9824 // int -> FLOAT16 map
9825 .float16Operands = {},
9826 // int -> BOOL8 map
9827 .bool8Operands = {},
9828 // int -> QUANT8_SYMM_PER_CHANNEL map
9829 .quant8ChannelOperands = {},
9830 // int -> QUANT16_ASYMM map
9831 .quant16AsymmOperands = {},
9832 // int -> QUANT8_SYMM map
9833 .quant8SymmOperands = {},
9834 },
9835 //Output(s)
9836 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9837 // int -> Dimensions map
9838 .operandDimensions = {{0, {1, 2, 2, 2}}},
9839 // int -> FLOAT32 map
9840 .float32Operands = {},
9841 // int -> INT32 map
9842 .int32Operands = {},
9843 // int -> QUANT8_ASYMM map
9844 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
9845 // int -> QUANT16_SYMM map
9846 .quant16SymmOperands = {},
9847 // int -> FLOAT16 map
9848 .float16Operands = {},
9849 // int -> BOOL8 map
9850 .bool8Operands = {},
9851 // int -> QUANT8_SYMM_PER_CHANNEL map
9852 .quant8ChannelOperands = {},
9853 // int -> QUANT16_ASYMM map
9854 .quant16AsymmOperands = {},
9855 // int -> QUANT8_SYMM map
9856 .quant8SymmOperands = {},
9857 }
9858 },
9859 }, // End of an example
9860 };
9861 return examples_dynamic_output_shape_nchw_none_quant8;
9862 };
9863
get_examples_dynamic_output_shape_nchw_none_quant8_weight_as_input()9864 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8_weight_as_input() {
9865 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8_weight_as_input = {
9866 // Begin of an example
9867 {
9868 .operands = {
9869 //Input(s)
9870 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9871 // int -> Dimensions map
9872 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9873 // int -> FLOAT32 map
9874 .float32Operands = {},
9875 // int -> INT32 map
9876 .int32Operands = {{2, {160, -536}}},
9877 // int -> QUANT8_ASYMM map
9878 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
9879 // int -> QUANT16_SYMM map
9880 .quant16SymmOperands = {},
9881 // int -> FLOAT16 map
9882 .float16Operands = {},
9883 // int -> BOOL8 map
9884 .bool8Operands = {},
9885 // int -> QUANT8_SYMM_PER_CHANNEL map
9886 .quant8ChannelOperands = {},
9887 // int -> QUANT16_ASYMM map
9888 .quant16AsymmOperands = {},
9889 // int -> QUANT8_SYMM map
9890 .quant8SymmOperands = {},
9891 },
9892 //Output(s)
9893 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9894 // int -> Dimensions map
9895 .operandDimensions = {{0, {1, 2, 2, 2}}},
9896 // int -> FLOAT32 map
9897 .float32Operands = {},
9898 // int -> INT32 map
9899 .int32Operands = {},
9900 // int -> QUANT8_ASYMM map
9901 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
9902 // int -> QUANT16_SYMM map
9903 .quant16SymmOperands = {},
9904 // int -> FLOAT16 map
9905 .float16Operands = {},
9906 // int -> BOOL8 map
9907 .bool8Operands = {},
9908 // int -> QUANT8_SYMM_PER_CHANNEL map
9909 .quant8ChannelOperands = {},
9910 // int -> QUANT16_ASYMM map
9911 .quant16AsymmOperands = {},
9912 // int -> QUANT8_SYMM map
9913 .quant8SymmOperands = {},
9914 }
9915 },
9916 }, // End of an example
9917 };
9918 return examples_dynamic_output_shape_nchw_none_quant8_weight_as_input;
9919 };
9920
get_examples_dynamic_output_shape_nchw_none_quant8_2()9921 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8_2() {
9922 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8_2 = {
9923 // Begin of an example
9924 {
9925 .operands = {
9926 //Input(s)
9927 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9928 // int -> Dimensions map
9929 .operandDimensions = {{0, {1, 2, 3, 3}}},
9930 // int -> FLOAT32 map
9931 .float32Operands = {},
9932 // int -> INT32 map
9933 .int32Operands = {},
9934 // int -> QUANT8_ASYMM map
9935 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
9936 // int -> QUANT16_SYMM map
9937 .quant16SymmOperands = {},
9938 // int -> FLOAT16 map
9939 .float16Operands = {},
9940 // int -> BOOL8 map
9941 .bool8Operands = {},
9942 // int -> QUANT8_SYMM_PER_CHANNEL map
9943 .quant8ChannelOperands = {},
9944 // int -> QUANT16_ASYMM map
9945 .quant16AsymmOperands = {},
9946 // int -> QUANT8_SYMM map
9947 .quant8SymmOperands = {},
9948 },
9949 //Output(s)
9950 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9951 // int -> Dimensions map
9952 .operandDimensions = {{0, {1, 2, 2, 2}}},
9953 // int -> FLOAT32 map
9954 .float32Operands = {},
9955 // int -> INT32 map
9956 .int32Operands = {},
9957 // int -> QUANT8_ASYMM map
9958 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 70, 230, 170, 0}}},
9959 // int -> QUANT16_SYMM map
9960 .quant16SymmOperands = {},
9961 // int -> FLOAT16 map
9962 .float16Operands = {},
9963 // int -> BOOL8 map
9964 .bool8Operands = {},
9965 // int -> QUANT8_SYMM_PER_CHANNEL map
9966 .quant8ChannelOperands = {},
9967 // int -> QUANT16_ASYMM map
9968 .quant16AsymmOperands = {},
9969 // int -> QUANT8_SYMM map
9970 .quant8SymmOperands = {},
9971 }
9972 },
9973 }, // End of an example
9974 };
9975 return examples_dynamic_output_shape_nchw_none_quant8_2;
9976 };
9977
get_examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2()9978 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2() {
9979 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2 = {
9980 // Begin of an example
9981 {
9982 .operands = {
9983 //Input(s)
9984 { // See tools/test_generator/include/TestHarness.h:MixedTyped
9985 // int -> Dimensions map
9986 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
9987 // int -> FLOAT32 map
9988 .float32Operands = {},
9989 // int -> INT32 map
9990 .int32Operands = {{2, {160, -536}}},
9991 // int -> QUANT8_ASYMM map
9992 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
9993 // int -> QUANT16_SYMM map
9994 .quant16SymmOperands = {},
9995 // int -> FLOAT16 map
9996 .float16Operands = {},
9997 // int -> BOOL8 map
9998 .bool8Operands = {},
9999 // int -> QUANT8_SYMM_PER_CHANNEL map
10000 .quant8ChannelOperands = {},
10001 // int -> QUANT16_ASYMM map
10002 .quant16AsymmOperands = {},
10003 // int -> QUANT8_SYMM map
10004 .quant8SymmOperands = {},
10005 },
10006 //Output(s)
10007 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10008 // int -> Dimensions map
10009 .operandDimensions = {{0, {1, 2, 2, 2}}},
10010 // int -> FLOAT32 map
10011 .float32Operands = {},
10012 // int -> INT32 map
10013 .int32Operands = {},
10014 // int -> QUANT8_ASYMM map
10015 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 70, 230, 170, 0}}},
10016 // int -> QUANT16_SYMM map
10017 .quant16SymmOperands = {},
10018 // int -> FLOAT16 map
10019 .float16Operands = {},
10020 // int -> BOOL8 map
10021 .bool8Operands = {},
10022 // int -> QUANT8_SYMM_PER_CHANNEL map
10023 .quant8ChannelOperands = {},
10024 // int -> QUANT16_ASYMM map
10025 .quant16AsymmOperands = {},
10026 // int -> QUANT8_SYMM map
10027 .quant8SymmOperands = {},
10028 }
10029 },
10030 }, // End of an example
10031 };
10032 return examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2;
10033 };
10034
get_examples_dynamic_output_shape_nchw_none_channelQuant8()10035 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8() {
10036 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8 = {
10037 // Begin of an example
10038 {
10039 .operands = {
10040 //Input(s)
10041 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10042 // int -> Dimensions map
10043 .operandDimensions = {{0, {1, 2, 3, 3}}},
10044 // int -> FLOAT32 map
10045 .float32Operands = {},
10046 // int -> INT32 map
10047 .int32Operands = {},
10048 // int -> QUANT8_ASYMM map
10049 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10050 // int -> QUANT16_SYMM map
10051 .quant16SymmOperands = {},
10052 // int -> FLOAT16 map
10053 .float16Operands = {},
10054 // int -> BOOL8 map
10055 .bool8Operands = {},
10056 // int -> QUANT8_SYMM_PER_CHANNEL map
10057 .quant8ChannelOperands = {},
10058 // int -> QUANT16_ASYMM map
10059 .quant16AsymmOperands = {},
10060 // int -> QUANT8_SYMM map
10061 .quant8SymmOperands = {},
10062 },
10063 //Output(s)
10064 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10065 // int -> Dimensions map
10066 .operandDimensions = {{0, {1, 2, 2, 2}}},
10067 // int -> FLOAT32 map
10068 .float32Operands = {},
10069 // int -> INT32 map
10070 .int32Operands = {},
10071 // int -> QUANT8_ASYMM map
10072 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
10073 // int -> QUANT16_SYMM map
10074 .quant16SymmOperands = {},
10075 // int -> FLOAT16 map
10076 .float16Operands = {},
10077 // int -> BOOL8 map
10078 .bool8Operands = {},
10079 // int -> QUANT8_SYMM_PER_CHANNEL map
10080 .quant8ChannelOperands = {},
10081 // int -> QUANT16_ASYMM map
10082 .quant16AsymmOperands = {},
10083 // int -> QUANT8_SYMM map
10084 .quant8SymmOperands = {},
10085 }
10086 },
10087 }, // End of an example
10088 };
10089 return examples_dynamic_output_shape_nchw_none_channelQuant8;
10090 };
10091
get_examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input()10092 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input() {
10093 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input = {
10094 // Begin of an example
10095 {
10096 .operands = {
10097 //Input(s)
10098 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10099 // int -> Dimensions map
10100 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10101 // int -> FLOAT32 map
10102 .float32Operands = {},
10103 // int -> INT32 map
10104 .int32Operands = {{2, {160, -268}}},
10105 // int -> QUANT8_ASYMM map
10106 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10107 // int -> QUANT16_SYMM map
10108 .quant16SymmOperands = {},
10109 // int -> FLOAT16 map
10110 .float16Operands = {},
10111 // int -> BOOL8 map
10112 .bool8Operands = {},
10113 // int -> QUANT8_SYMM_PER_CHANNEL map
10114 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
10115 // int -> QUANT16_ASYMM map
10116 .quant16AsymmOperands = {},
10117 // int -> QUANT8_SYMM map
10118 .quant8SymmOperands = {},
10119 },
10120 //Output(s)
10121 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10122 // int -> Dimensions map
10123 .operandDimensions = {{0, {1, 2, 2, 2}}},
10124 // int -> FLOAT32 map
10125 .float32Operands = {},
10126 // int -> INT32 map
10127 .int32Operands = {},
10128 // int -> QUANT8_ASYMM map
10129 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 79, 95, 89, 61}}},
10130 // int -> QUANT16_SYMM map
10131 .quant16SymmOperands = {},
10132 // int -> FLOAT16 map
10133 .float16Operands = {},
10134 // int -> BOOL8 map
10135 .bool8Operands = {},
10136 // int -> QUANT8_SYMM_PER_CHANNEL map
10137 .quant8ChannelOperands = {},
10138 // int -> QUANT16_ASYMM map
10139 .quant16AsymmOperands = {},
10140 // int -> QUANT8_SYMM map
10141 .quant8SymmOperands = {},
10142 }
10143 },
10144 }, // End of an example
10145 };
10146 return examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input;
10147 };
10148
get_examples_dynamic_output_shape_nchw_none_channelQuant8_2()10149 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8_2() {
10150 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8_2 = {
10151 // Begin of an example
10152 {
10153 .operands = {
10154 //Input(s)
10155 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10156 // int -> Dimensions map
10157 .operandDimensions = {{0, {1, 2, 3, 3}}},
10158 // int -> FLOAT32 map
10159 .float32Operands = {},
10160 // int -> INT32 map
10161 .int32Operands = {},
10162 // int -> QUANT8_ASYMM map
10163 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10164 // int -> QUANT16_SYMM map
10165 .quant16SymmOperands = {},
10166 // int -> FLOAT16 map
10167 .float16Operands = {},
10168 // int -> BOOL8 map
10169 .bool8Operands = {},
10170 // int -> QUANT8_SYMM_PER_CHANNEL map
10171 .quant8ChannelOperands = {},
10172 // int -> QUANT16_ASYMM map
10173 .quant16AsymmOperands = {},
10174 // int -> QUANT8_SYMM map
10175 .quant8SymmOperands = {},
10176 },
10177 //Output(s)
10178 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10179 // int -> Dimensions map
10180 .operandDimensions = {{0, {1, 2, 2, 2}}},
10181 // int -> FLOAT32 map
10182 .float32Operands = {},
10183 // int -> INT32 map
10184 .int32Operands = {},
10185 // int -> QUANT8_ASYMM map
10186 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 75, 155, 125, 0}}},
10187 // int -> QUANT16_SYMM map
10188 .quant16SymmOperands = {},
10189 // int -> FLOAT16 map
10190 .float16Operands = {},
10191 // int -> BOOL8 map
10192 .bool8Operands = {},
10193 // int -> QUANT8_SYMM_PER_CHANNEL map
10194 .quant8ChannelOperands = {},
10195 // int -> QUANT16_ASYMM map
10196 .quant16AsymmOperands = {},
10197 // int -> QUANT8_SYMM map
10198 .quant8SymmOperands = {},
10199 }
10200 },
10201 }, // End of an example
10202 };
10203 return examples_dynamic_output_shape_nchw_none_channelQuant8_2;
10204 };
10205
get_examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2()10206 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2() {
10207 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2 = {
10208 // Begin of an example
10209 {
10210 .operands = {
10211 //Input(s)
10212 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10213 // int -> Dimensions map
10214 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10215 // int -> FLOAT32 map
10216 .float32Operands = {},
10217 // int -> INT32 map
10218 .int32Operands = {{2, {160, -268}}},
10219 // int -> QUANT8_ASYMM map
10220 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10221 // int -> QUANT16_SYMM map
10222 .quant16SymmOperands = {},
10223 // int -> FLOAT16 map
10224 .float16Operands = {},
10225 // int -> BOOL8 map
10226 .bool8Operands = {},
10227 // int -> QUANT8_SYMM_PER_CHANNEL map
10228 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
10229 // int -> QUANT16_ASYMM map
10230 .quant16AsymmOperands = {},
10231 // int -> QUANT8_SYMM map
10232 .quant8SymmOperands = {},
10233 },
10234 //Output(s)
10235 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10236 // int -> Dimensions map
10237 .operandDimensions = {{0, {1, 2, 2, 2}}},
10238 // int -> FLOAT32 map
10239 .float32Operands = {},
10240 // int -> INT32 map
10241 .int32Operands = {},
10242 // int -> QUANT8_ASYMM map
10243 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 75, 155, 125, 0}}},
10244 // int -> QUANT16_SYMM map
10245 .quant16SymmOperands = {},
10246 // int -> FLOAT16 map
10247 .float16Operands = {},
10248 // int -> BOOL8 map
10249 .bool8Operands = {},
10250 // int -> QUANT8_SYMM_PER_CHANNEL map
10251 .quant8ChannelOperands = {},
10252 // int -> QUANT16_ASYMM map
10253 .quant16AsymmOperands = {},
10254 // int -> QUANT8_SYMM map
10255 .quant8SymmOperands = {},
10256 }
10257 },
10258 }, // End of an example
10259 };
10260 return examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2;
10261 };
10262
get_examples_dynamic_output_shape_nchw_none_float16()10263 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_float16() {
10264 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_float16 = {
10265 // Begin of an example
10266 {
10267 .operands = {
10268 //Input(s)
10269 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10270 // int -> Dimensions map
10271 .operandDimensions = {{0, {1, 2, 3, 3}}},
10272 // int -> FLOAT32 map
10273 .float32Operands = {},
10274 // int -> INT32 map
10275 .int32Operands = {},
10276 // int -> QUANT8_ASYMM map
10277 .quant8AsymmOperands = {},
10278 // int -> QUANT16_SYMM map
10279 .quant16SymmOperands = {},
10280 // int -> FLOAT16 map
10281 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
10282 // int -> BOOL8 map
10283 .bool8Operands = {},
10284 // int -> QUANT8_SYMM_PER_CHANNEL map
10285 .quant8ChannelOperands = {},
10286 // int -> QUANT16_ASYMM map
10287 .quant16AsymmOperands = {},
10288 // int -> QUANT8_SYMM map
10289 .quant8SymmOperands = {},
10290 },
10291 //Output(s)
10292 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10293 // int -> Dimensions map
10294 .operandDimensions = {{0, {1, 2, 2, 2}}},
10295 // int -> FLOAT32 map
10296 .float32Operands = {},
10297 // int -> INT32 map
10298 .int32Operands = {},
10299 // int -> QUANT8_ASYMM map
10300 .quant8AsymmOperands = {},
10301 // int -> QUANT16_SYMM map
10302 .quant16SymmOperands = {},
10303 // int -> FLOAT16 map
10304 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
10305 // int -> BOOL8 map
10306 .bool8Operands = {},
10307 // int -> QUANT8_SYMM_PER_CHANNEL map
10308 .quant8ChannelOperands = {},
10309 // int -> QUANT16_ASYMM map
10310 .quant16AsymmOperands = {},
10311 // int -> QUANT8_SYMM map
10312 .quant8SymmOperands = {},
10313 }
10314 },
10315 }, // End of an example
10316 };
10317 return examples_dynamic_output_shape_nchw_none_float16;
10318 };
10319
get_examples_dynamic_output_shape_nchw_none_float16_weight_as_input()10320 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_float16_weight_as_input() {
10321 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_float16_weight_as_input = {
10322 // Begin of an example
10323 {
10324 .operands = {
10325 //Input(s)
10326 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10327 // int -> Dimensions map
10328 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10329 // int -> FLOAT32 map
10330 .float32Operands = {},
10331 // int -> INT32 map
10332 .int32Operands = {},
10333 // int -> QUANT8_ASYMM map
10334 .quant8AsymmOperands = {},
10335 // int -> QUANT16_SYMM map
10336 .quant16SymmOperands = {},
10337 // int -> FLOAT16 map
10338 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
10339 // int -> BOOL8 map
10340 .bool8Operands = {},
10341 // int -> QUANT8_SYMM_PER_CHANNEL map
10342 .quant8ChannelOperands = {},
10343 // int -> QUANT16_ASYMM map
10344 .quant16AsymmOperands = {},
10345 // int -> QUANT8_SYMM map
10346 .quant8SymmOperands = {},
10347 },
10348 //Output(s)
10349 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10350 // int -> Dimensions map
10351 .operandDimensions = {{0, {1, 2, 2, 2}}},
10352 // int -> FLOAT32 map
10353 .float32Operands = {},
10354 // int -> INT32 map
10355 .int32Operands = {},
10356 // int -> QUANT8_ASYMM map
10357 .quant8AsymmOperands = {},
10358 // int -> QUANT16_SYMM map
10359 .quant16SymmOperands = {},
10360 // int -> FLOAT16 map
10361 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, -0.5f, 7.5f, 4.5f, -9.5f}}},
10362 // int -> BOOL8 map
10363 .bool8Operands = {},
10364 // int -> QUANT8_SYMM_PER_CHANNEL map
10365 .quant8ChannelOperands = {},
10366 // int -> QUANT16_ASYMM map
10367 .quant16AsymmOperands = {},
10368 // int -> QUANT8_SYMM map
10369 .quant8SymmOperands = {},
10370 }
10371 },
10372 }, // End of an example
10373 };
10374 return examples_dynamic_output_shape_nchw_none_float16_weight_as_input;
10375 };
10376
get_examples_dynamic_output_shape_nchw_relu()10377 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu() {
10378 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu = {
10379 // Begin of an example
10380 {
10381 .operands = {
10382 //Input(s)
10383 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10384 // int -> Dimensions map
10385 .operandDimensions = {{0, {1, 2, 3, 3}}},
10386 // int -> FLOAT32 map
10387 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
10388 // int -> INT32 map
10389 .int32Operands = {},
10390 // int -> QUANT8_ASYMM map
10391 .quant8AsymmOperands = {},
10392 // int -> QUANT16_SYMM map
10393 .quant16SymmOperands = {},
10394 // int -> FLOAT16 map
10395 .float16Operands = {},
10396 // int -> BOOL8 map
10397 .bool8Operands = {},
10398 // int -> QUANT8_SYMM_PER_CHANNEL map
10399 .quant8ChannelOperands = {},
10400 // int -> QUANT16_ASYMM map
10401 .quant16AsymmOperands = {},
10402 // int -> QUANT8_SYMM map
10403 .quant8SymmOperands = {},
10404 },
10405 //Output(s)
10406 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10407 // int -> Dimensions map
10408 .operandDimensions = {{0, {1, 2, 2, 2}}},
10409 // int -> FLOAT32 map
10410 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
10411 // int -> INT32 map
10412 .int32Operands = {},
10413 // int -> QUANT8_ASYMM map
10414 .quant8AsymmOperands = {},
10415 // int -> QUANT16_SYMM map
10416 .quant16SymmOperands = {},
10417 // int -> FLOAT16 map
10418 .float16Operands = {},
10419 // int -> BOOL8 map
10420 .bool8Operands = {},
10421 // int -> QUANT8_SYMM_PER_CHANNEL map
10422 .quant8ChannelOperands = {},
10423 // int -> QUANT16_ASYMM map
10424 .quant16AsymmOperands = {},
10425 // int -> QUANT8_SYMM map
10426 .quant8SymmOperands = {},
10427 }
10428 },
10429 }, // End of an example
10430 };
10431 return examples_dynamic_output_shape_nchw_relu;
10432 };
10433
get_examples_dynamic_output_shape_nchw_relu_weight_as_input()10434 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_weight_as_input() {
10435 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_weight_as_input = {
10436 // Begin of an example
10437 {
10438 .operands = {
10439 //Input(s)
10440 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10441 // int -> Dimensions map
10442 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10443 // int -> FLOAT32 map
10444 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
10445 // int -> INT32 map
10446 .int32Operands = {},
10447 // int -> QUANT8_ASYMM map
10448 .quant8AsymmOperands = {},
10449 // int -> QUANT16_SYMM map
10450 .quant16SymmOperands = {},
10451 // int -> FLOAT16 map
10452 .float16Operands = {},
10453 // int -> BOOL8 map
10454 .bool8Operands = {},
10455 // int -> QUANT8_SYMM_PER_CHANNEL map
10456 .quant8ChannelOperands = {},
10457 // int -> QUANT16_ASYMM map
10458 .quant16AsymmOperands = {},
10459 // int -> QUANT8_SYMM map
10460 .quant8SymmOperands = {},
10461 },
10462 //Output(s)
10463 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10464 // int -> Dimensions map
10465 .operandDimensions = {{0, {1, 2, 2, 2}}},
10466 // int -> FLOAT32 map
10467 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
10468 // int -> INT32 map
10469 .int32Operands = {},
10470 // int -> QUANT8_ASYMM map
10471 .quant8AsymmOperands = {},
10472 // int -> QUANT16_SYMM map
10473 .quant16SymmOperands = {},
10474 // int -> FLOAT16 map
10475 .float16Operands = {},
10476 // int -> BOOL8 map
10477 .bool8Operands = {},
10478 // int -> QUANT8_SYMM_PER_CHANNEL map
10479 .quant8ChannelOperands = {},
10480 // int -> QUANT16_ASYMM map
10481 .quant16AsymmOperands = {},
10482 // int -> QUANT8_SYMM map
10483 .quant8SymmOperands = {},
10484 }
10485 },
10486 }, // End of an example
10487 };
10488 return examples_dynamic_output_shape_nchw_relu_weight_as_input;
10489 };
10490
get_examples_dynamic_output_shape_nchw_relu_relaxed()10491 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_relaxed() {
10492 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_relaxed = {
10493 // Begin of an example
10494 {
10495 .operands = {
10496 //Input(s)
10497 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10498 // int -> Dimensions map
10499 .operandDimensions = {{0, {1, 2, 3, 3}}},
10500 // int -> FLOAT32 map
10501 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
10502 // int -> INT32 map
10503 .int32Operands = {},
10504 // int -> QUANT8_ASYMM map
10505 .quant8AsymmOperands = {},
10506 // int -> QUANT16_SYMM map
10507 .quant16SymmOperands = {},
10508 // int -> FLOAT16 map
10509 .float16Operands = {},
10510 // int -> BOOL8 map
10511 .bool8Operands = {},
10512 // int -> QUANT8_SYMM_PER_CHANNEL map
10513 .quant8ChannelOperands = {},
10514 // int -> QUANT16_ASYMM map
10515 .quant16AsymmOperands = {},
10516 // int -> QUANT8_SYMM map
10517 .quant8SymmOperands = {},
10518 },
10519 //Output(s)
10520 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10521 // int -> Dimensions map
10522 .operandDimensions = {{0, {1, 2, 2, 2}}},
10523 // int -> FLOAT32 map
10524 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
10525 // int -> INT32 map
10526 .int32Operands = {},
10527 // int -> QUANT8_ASYMM map
10528 .quant8AsymmOperands = {},
10529 // int -> QUANT16_SYMM map
10530 .quant16SymmOperands = {},
10531 // int -> FLOAT16 map
10532 .float16Operands = {},
10533 // int -> BOOL8 map
10534 .bool8Operands = {},
10535 // int -> QUANT8_SYMM_PER_CHANNEL map
10536 .quant8ChannelOperands = {},
10537 // int -> QUANT16_ASYMM map
10538 .quant16AsymmOperands = {},
10539 // int -> QUANT8_SYMM map
10540 .quant8SymmOperands = {},
10541 }
10542 },
10543 }, // End of an example
10544 };
10545 return examples_dynamic_output_shape_nchw_relu_relaxed;
10546 };
10547
get_examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input()10548 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input() {
10549 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input = {
10550 // Begin of an example
10551 {
10552 .operands = {
10553 //Input(s)
10554 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10555 // int -> Dimensions map
10556 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10557 // int -> FLOAT32 map
10558 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
10559 // int -> INT32 map
10560 .int32Operands = {},
10561 // int -> QUANT8_ASYMM map
10562 .quant8AsymmOperands = {},
10563 // int -> QUANT16_SYMM map
10564 .quant16SymmOperands = {},
10565 // int -> FLOAT16 map
10566 .float16Operands = {},
10567 // int -> BOOL8 map
10568 .bool8Operands = {},
10569 // int -> QUANT8_SYMM_PER_CHANNEL map
10570 .quant8ChannelOperands = {},
10571 // int -> QUANT16_ASYMM map
10572 .quant16AsymmOperands = {},
10573 // int -> QUANT8_SYMM map
10574 .quant8SymmOperands = {},
10575 },
10576 //Output(s)
10577 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10578 // int -> Dimensions map
10579 .operandDimensions = {{0, {1, 2, 2, 2}}},
10580 // int -> FLOAT32 map
10581 .float32Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
10582 // int -> INT32 map
10583 .int32Operands = {},
10584 // int -> QUANT8_ASYMM map
10585 .quant8AsymmOperands = {},
10586 // int -> QUANT16_SYMM map
10587 .quant16SymmOperands = {},
10588 // int -> FLOAT16 map
10589 .float16Operands = {},
10590 // int -> BOOL8 map
10591 .bool8Operands = {},
10592 // int -> QUANT8_SYMM_PER_CHANNEL map
10593 .quant8ChannelOperands = {},
10594 // int -> QUANT16_ASYMM map
10595 .quant16AsymmOperands = {},
10596 // int -> QUANT8_SYMM map
10597 .quant8SymmOperands = {},
10598 }
10599 },
10600 }, // End of an example
10601 };
10602 return examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input;
10603 };
10604
get_examples_dynamic_output_shape_nchw_relu_quant8()10605 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8() {
10606 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8 = {
10607 // Begin of an example
10608 {
10609 .operands = {
10610 //Input(s)
10611 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10612 // int -> Dimensions map
10613 .operandDimensions = {{0, {1, 2, 3, 3}}},
10614 // int -> FLOAT32 map
10615 .float32Operands = {},
10616 // int -> INT32 map
10617 .int32Operands = {},
10618 // int -> QUANT8_ASYMM map
10619 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10620 // int -> QUANT16_SYMM map
10621 .quant16SymmOperands = {},
10622 // int -> FLOAT16 map
10623 .float16Operands = {},
10624 // int -> BOOL8 map
10625 .bool8Operands = {},
10626 // int -> QUANT8_SYMM_PER_CHANNEL map
10627 .quant8ChannelOperands = {},
10628 // int -> QUANT16_ASYMM map
10629 .quant16AsymmOperands = {},
10630 // int -> QUANT8_SYMM map
10631 .quant8SymmOperands = {},
10632 },
10633 //Output(s)
10634 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10635 // int -> Dimensions map
10636 .operandDimensions = {{0, {1, 2, 2, 2}}},
10637 // int -> FLOAT32 map
10638 .float32Operands = {},
10639 // int -> INT32 map
10640 .int32Operands = {},
10641 // int -> QUANT8_ASYMM map
10642 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
10643 // int -> QUANT16_SYMM map
10644 .quant16SymmOperands = {},
10645 // int -> FLOAT16 map
10646 .float16Operands = {},
10647 // int -> BOOL8 map
10648 .bool8Operands = {},
10649 // int -> QUANT8_SYMM_PER_CHANNEL map
10650 .quant8ChannelOperands = {},
10651 // int -> QUANT16_ASYMM map
10652 .quant16AsymmOperands = {},
10653 // int -> QUANT8_SYMM map
10654 .quant8SymmOperands = {},
10655 }
10656 },
10657 }, // End of an example
10658 };
10659 return examples_dynamic_output_shape_nchw_relu_quant8;
10660 };
10661
get_examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input()10662 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input() {
10663 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input = {
10664 // Begin of an example
10665 {
10666 .operands = {
10667 //Input(s)
10668 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10669 // int -> Dimensions map
10670 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10671 // int -> FLOAT32 map
10672 .float32Operands = {},
10673 // int -> INT32 map
10674 .int32Operands = {{2, {160, -536}}},
10675 // int -> QUANT8_ASYMM map
10676 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
10677 // int -> QUANT16_SYMM map
10678 .quant16SymmOperands = {},
10679 // int -> FLOAT16 map
10680 .float16Operands = {},
10681 // int -> BOOL8 map
10682 .bool8Operands = {},
10683 // int -> QUANT8_SYMM_PER_CHANNEL map
10684 .quant8ChannelOperands = {},
10685 // int -> QUANT16_ASYMM map
10686 .quant16AsymmOperands = {},
10687 // int -> QUANT8_SYMM map
10688 .quant8SymmOperands = {},
10689 },
10690 //Output(s)
10691 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10692 // int -> Dimensions map
10693 .operandDimensions = {{0, {1, 2, 2, 2}}},
10694 // int -> FLOAT32 map
10695 .float32Operands = {},
10696 // int -> INT32 map
10697 .int32Operands = {},
10698 // int -> QUANT8_ASYMM map
10699 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
10700 // int -> QUANT16_SYMM map
10701 .quant16SymmOperands = {},
10702 // int -> FLOAT16 map
10703 .float16Operands = {},
10704 // int -> BOOL8 map
10705 .bool8Operands = {},
10706 // int -> QUANT8_SYMM_PER_CHANNEL map
10707 .quant8ChannelOperands = {},
10708 // int -> QUANT16_ASYMM map
10709 .quant16AsymmOperands = {},
10710 // int -> QUANT8_SYMM map
10711 .quant8SymmOperands = {},
10712 }
10713 },
10714 }, // End of an example
10715 };
10716 return examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input;
10717 };
10718
get_examples_dynamic_output_shape_nchw_relu_quant8_2()10719 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8_2() {
10720 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8_2 = {
10721 // Begin of an example
10722 {
10723 .operands = {
10724 //Input(s)
10725 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10726 // int -> Dimensions map
10727 .operandDimensions = {{0, {1, 2, 3, 3}}},
10728 // int -> FLOAT32 map
10729 .float32Operands = {},
10730 // int -> INT32 map
10731 .int32Operands = {},
10732 // int -> QUANT8_ASYMM map
10733 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10734 // int -> QUANT16_SYMM map
10735 .quant16SymmOperands = {},
10736 // int -> FLOAT16 map
10737 .float16Operands = {},
10738 // int -> BOOL8 map
10739 .bool8Operands = {},
10740 // int -> QUANT8_SYMM_PER_CHANNEL map
10741 .quant8ChannelOperands = {},
10742 // int -> QUANT16_ASYMM map
10743 .quant16AsymmOperands = {},
10744 // int -> QUANT8_SYMM map
10745 .quant8SymmOperands = {},
10746 },
10747 //Output(s)
10748 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10749 // int -> Dimensions map
10750 .operandDimensions = {{0, {1, 2, 2, 2}}},
10751 // int -> FLOAT32 map
10752 .float32Operands = {},
10753 // int -> INT32 map
10754 .int32Operands = {},
10755 // int -> QUANT8_ASYMM map
10756 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 230, 170, 80}}},
10757 // int -> QUANT16_SYMM map
10758 .quant16SymmOperands = {},
10759 // int -> FLOAT16 map
10760 .float16Operands = {},
10761 // int -> BOOL8 map
10762 .bool8Operands = {},
10763 // int -> QUANT8_SYMM_PER_CHANNEL map
10764 .quant8ChannelOperands = {},
10765 // int -> QUANT16_ASYMM map
10766 .quant16AsymmOperands = {},
10767 // int -> QUANT8_SYMM map
10768 .quant8SymmOperands = {},
10769 }
10770 },
10771 }, // End of an example
10772 };
10773 return examples_dynamic_output_shape_nchw_relu_quant8_2;
10774 };
10775
get_examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2()10776 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2() {
10777 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2 = {
10778 // Begin of an example
10779 {
10780 .operands = {
10781 //Input(s)
10782 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10783 // int -> Dimensions map
10784 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10785 // int -> FLOAT32 map
10786 .float32Operands = {},
10787 // int -> INT32 map
10788 .int32Operands = {{2, {160, -536}}},
10789 // int -> QUANT8_ASYMM map
10790 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
10791 // int -> QUANT16_SYMM map
10792 .quant16SymmOperands = {},
10793 // int -> FLOAT16 map
10794 .float16Operands = {},
10795 // int -> BOOL8 map
10796 .bool8Operands = {},
10797 // int -> QUANT8_SYMM_PER_CHANNEL map
10798 .quant8ChannelOperands = {},
10799 // int -> QUANT16_ASYMM map
10800 .quant16AsymmOperands = {},
10801 // int -> QUANT8_SYMM map
10802 .quant8SymmOperands = {},
10803 },
10804 //Output(s)
10805 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10806 // int -> Dimensions map
10807 .operandDimensions = {{0, {1, 2, 2, 2}}},
10808 // int -> FLOAT32 map
10809 .float32Operands = {},
10810 // int -> INT32 map
10811 .int32Operands = {},
10812 // int -> QUANT8_ASYMM map
10813 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 230, 170, 80}}},
10814 // int -> QUANT16_SYMM map
10815 .quant16SymmOperands = {},
10816 // int -> FLOAT16 map
10817 .float16Operands = {},
10818 // int -> BOOL8 map
10819 .bool8Operands = {},
10820 // int -> QUANT8_SYMM_PER_CHANNEL map
10821 .quant8ChannelOperands = {},
10822 // int -> QUANT16_ASYMM map
10823 .quant16AsymmOperands = {},
10824 // int -> QUANT8_SYMM map
10825 .quant8SymmOperands = {},
10826 }
10827 },
10828 }, // End of an example
10829 };
10830 return examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2;
10831 };
10832
get_examples_dynamic_output_shape_nchw_relu_channelQuant8()10833 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8() {
10834 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8 = {
10835 // Begin of an example
10836 {
10837 .operands = {
10838 //Input(s)
10839 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10840 // int -> Dimensions map
10841 .operandDimensions = {{0, {1, 2, 3, 3}}},
10842 // int -> FLOAT32 map
10843 .float32Operands = {},
10844 // int -> INT32 map
10845 .int32Operands = {},
10846 // int -> QUANT8_ASYMM map
10847 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10848 // int -> QUANT16_SYMM map
10849 .quant16SymmOperands = {},
10850 // int -> FLOAT16 map
10851 .float16Operands = {},
10852 // int -> BOOL8 map
10853 .bool8Operands = {},
10854 // int -> QUANT8_SYMM_PER_CHANNEL map
10855 .quant8ChannelOperands = {},
10856 // int -> QUANT16_ASYMM map
10857 .quant16AsymmOperands = {},
10858 // int -> QUANT8_SYMM map
10859 .quant8SymmOperands = {},
10860 },
10861 //Output(s)
10862 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10863 // int -> Dimensions map
10864 .operandDimensions = {{0, {1, 2, 2, 2}}},
10865 // int -> FLOAT32 map
10866 .float32Operands = {},
10867 // int -> INT32 map
10868 .int32Operands = {},
10869 // int -> QUANT8_ASYMM map
10870 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
10871 // int -> QUANT16_SYMM map
10872 .quant16SymmOperands = {},
10873 // int -> FLOAT16 map
10874 .float16Operands = {},
10875 // int -> BOOL8 map
10876 .bool8Operands = {},
10877 // int -> QUANT8_SYMM_PER_CHANNEL map
10878 .quant8ChannelOperands = {},
10879 // int -> QUANT16_ASYMM map
10880 .quant16AsymmOperands = {},
10881 // int -> QUANT8_SYMM map
10882 .quant8SymmOperands = {},
10883 }
10884 },
10885 }, // End of an example
10886 };
10887 return examples_dynamic_output_shape_nchw_relu_channelQuant8;
10888 };
10889
get_examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input()10890 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input() {
10891 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input = {
10892 // Begin of an example
10893 {
10894 .operands = {
10895 //Input(s)
10896 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10897 // int -> Dimensions map
10898 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
10899 // int -> FLOAT32 map
10900 .float32Operands = {},
10901 // int -> INT32 map
10902 .int32Operands = {{2, {160, -268}}},
10903 // int -> QUANT8_ASYMM map
10904 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10905 // int -> QUANT16_SYMM map
10906 .quant16SymmOperands = {},
10907 // int -> FLOAT16 map
10908 .float16Operands = {},
10909 // int -> BOOL8 map
10910 .bool8Operands = {},
10911 // int -> QUANT8_SYMM_PER_CHANNEL map
10912 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
10913 // int -> QUANT16_ASYMM map
10914 .quant16AsymmOperands = {},
10915 // int -> QUANT8_SYMM map
10916 .quant8SymmOperands = {},
10917 },
10918 //Output(s)
10919 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10920 // int -> Dimensions map
10921 .operandDimensions = {{0, {1, 2, 2, 2}}},
10922 // int -> FLOAT32 map
10923 .float32Operands = {},
10924 // int -> INT32 map
10925 .int32Operands = {},
10926 // int -> QUANT8_ASYMM map
10927 .quant8AsymmOperands = {{0, {146, 146, 142, 134, 80, 95, 89, 80}}},
10928 // int -> QUANT16_SYMM map
10929 .quant16SymmOperands = {},
10930 // int -> FLOAT16 map
10931 .float16Operands = {},
10932 // int -> BOOL8 map
10933 .bool8Operands = {},
10934 // int -> QUANT8_SYMM_PER_CHANNEL map
10935 .quant8ChannelOperands = {},
10936 // int -> QUANT16_ASYMM map
10937 .quant16AsymmOperands = {},
10938 // int -> QUANT8_SYMM map
10939 .quant8SymmOperands = {},
10940 }
10941 },
10942 }, // End of an example
10943 };
10944 return examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input;
10945 };
10946
get_examples_dynamic_output_shape_nchw_relu_channelQuant8_2()10947 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8_2() {
10948 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8_2 = {
10949 // Begin of an example
10950 {
10951 .operands = {
10952 //Input(s)
10953 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10954 // int -> Dimensions map
10955 .operandDimensions = {{0, {1, 2, 3, 3}}},
10956 // int -> FLOAT32 map
10957 .float32Operands = {},
10958 // int -> INT32 map
10959 .int32Operands = {},
10960 // int -> QUANT8_ASYMM map
10961 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
10962 // int -> QUANT16_SYMM map
10963 .quant16SymmOperands = {},
10964 // int -> FLOAT16 map
10965 .float16Operands = {},
10966 // int -> BOOL8 map
10967 .bool8Operands = {},
10968 // int -> QUANT8_SYMM_PER_CHANNEL map
10969 .quant8ChannelOperands = {},
10970 // int -> QUANT16_ASYMM map
10971 .quant16AsymmOperands = {},
10972 // int -> QUANT8_SYMM map
10973 .quant8SymmOperands = {},
10974 },
10975 //Output(s)
10976 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10977 // int -> Dimensions map
10978 .operandDimensions = {{0, {1, 2, 2, 2}}},
10979 // int -> FLOAT32 map
10980 .float32Operands = {},
10981 // int -> INT32 map
10982 .int32Operands = {},
10983 // int -> QUANT8_ASYMM map
10984 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 155, 125, 80}}},
10985 // int -> QUANT16_SYMM map
10986 .quant16SymmOperands = {},
10987 // int -> FLOAT16 map
10988 .float16Operands = {},
10989 // int -> BOOL8 map
10990 .bool8Operands = {},
10991 // int -> QUANT8_SYMM_PER_CHANNEL map
10992 .quant8ChannelOperands = {},
10993 // int -> QUANT16_ASYMM map
10994 .quant16AsymmOperands = {},
10995 // int -> QUANT8_SYMM map
10996 .quant8SymmOperands = {},
10997 }
10998 },
10999 }, // End of an example
11000 };
11001 return examples_dynamic_output_shape_nchw_relu_channelQuant8_2;
11002 };
11003
get_examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2()11004 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2() {
11005 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2 = {
11006 // Begin of an example
11007 {
11008 .operands = {
11009 //Input(s)
11010 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11011 // int -> Dimensions map
11012 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11013 // int -> FLOAT32 map
11014 .float32Operands = {},
11015 // int -> INT32 map
11016 .int32Operands = {{2, {160, -268}}},
11017 // int -> QUANT8_ASYMM map
11018 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11019 // int -> QUANT16_SYMM map
11020 .quant16SymmOperands = {},
11021 // int -> FLOAT16 map
11022 .float16Operands = {},
11023 // int -> BOOL8 map
11024 .bool8Operands = {},
11025 // int -> QUANT8_SYMM_PER_CHANNEL map
11026 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
11027 // int -> QUANT16_ASYMM map
11028 .quant16AsymmOperands = {},
11029 // int -> QUANT8_SYMM map
11030 .quant8SymmOperands = {},
11031 },
11032 //Output(s)
11033 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11034 // int -> Dimensions map
11035 .operandDimensions = {{0, {1, 2, 2, 2}}},
11036 // int -> FLOAT32 map
11037 .float32Operands = {},
11038 // int -> INT32 map
11039 .int32Operands = {},
11040 // int -> QUANT8_ASYMM map
11041 .quant8AsymmOperands = {{0, {255, 255, 255, 255, 80, 155, 125, 80}}},
11042 // int -> QUANT16_SYMM map
11043 .quant16SymmOperands = {},
11044 // int -> FLOAT16 map
11045 .float16Operands = {},
11046 // int -> BOOL8 map
11047 .bool8Operands = {},
11048 // int -> QUANT8_SYMM_PER_CHANNEL map
11049 .quant8ChannelOperands = {},
11050 // int -> QUANT16_ASYMM map
11051 .quant16AsymmOperands = {},
11052 // int -> QUANT8_SYMM map
11053 .quant8SymmOperands = {},
11054 }
11055 },
11056 }, // End of an example
11057 };
11058 return examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2;
11059 };
11060
get_examples_dynamic_output_shape_nchw_relu_float16()11061 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_float16() {
11062 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_float16 = {
11063 // Begin of an example
11064 {
11065 .operands = {
11066 //Input(s)
11067 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11068 // int -> Dimensions map
11069 .operandDimensions = {{0, {1, 2, 3, 3}}},
11070 // int -> FLOAT32 map
11071 .float32Operands = {},
11072 // int -> INT32 map
11073 .int32Operands = {},
11074 // int -> QUANT8_ASYMM map
11075 .quant8AsymmOperands = {},
11076 // int -> QUANT16_SYMM map
11077 .quant16SymmOperands = {},
11078 // int -> FLOAT16 map
11079 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
11080 // int -> BOOL8 map
11081 .bool8Operands = {},
11082 // int -> QUANT8_SYMM_PER_CHANNEL map
11083 .quant8ChannelOperands = {},
11084 // int -> QUANT16_ASYMM map
11085 .quant16AsymmOperands = {},
11086 // int -> QUANT8_SYMM map
11087 .quant8SymmOperands = {},
11088 },
11089 //Output(s)
11090 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11091 // int -> Dimensions map
11092 .operandDimensions = {{0, {1, 2, 2, 2}}},
11093 // int -> FLOAT32 map
11094 .float32Operands = {},
11095 // int -> INT32 map
11096 .int32Operands = {},
11097 // int -> QUANT8_ASYMM map
11098 .quant8AsymmOperands = {},
11099 // int -> QUANT16_SYMM map
11100 .quant16SymmOperands = {},
11101 // int -> FLOAT16 map
11102 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
11103 // int -> BOOL8 map
11104 .bool8Operands = {},
11105 // int -> QUANT8_SYMM_PER_CHANNEL map
11106 .quant8ChannelOperands = {},
11107 // int -> QUANT16_ASYMM map
11108 .quant16AsymmOperands = {},
11109 // int -> QUANT8_SYMM map
11110 .quant8SymmOperands = {},
11111 }
11112 },
11113 }, // End of an example
11114 };
11115 return examples_dynamic_output_shape_nchw_relu_float16;
11116 };
11117
get_examples_dynamic_output_shape_nchw_relu_float16_weight_as_input()11118 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_float16_weight_as_input() {
11119 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_float16_weight_as_input = {
11120 // Begin of an example
11121 {
11122 .operands = {
11123 //Input(s)
11124 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11125 // int -> Dimensions map
11126 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11127 // int -> FLOAT32 map
11128 .float32Operands = {},
11129 // int -> INT32 map
11130 .int32Operands = {},
11131 // int -> QUANT8_ASYMM map
11132 .quant8AsymmOperands = {},
11133 // int -> QUANT16_SYMM map
11134 .quant16SymmOperands = {},
11135 // int -> FLOAT16 map
11136 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
11137 // int -> BOOL8 map
11138 .bool8Operands = {},
11139 // int -> QUANT8_SYMM_PER_CHANNEL map
11140 .quant8ChannelOperands = {},
11141 // int -> QUANT16_ASYMM map
11142 .quant16AsymmOperands = {},
11143 // int -> QUANT8_SYMM map
11144 .quant8SymmOperands = {},
11145 },
11146 //Output(s)
11147 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11148 // int -> Dimensions map
11149 .operandDimensions = {{0, {1, 2, 2, 2}}},
11150 // int -> FLOAT32 map
11151 .float32Operands = {},
11152 // int -> INT32 map
11153 .int32Operands = {},
11154 // int -> QUANT8_ASYMM map
11155 .quant8AsymmOperands = {},
11156 // int -> QUANT16_SYMM map
11157 .quant16SymmOperands = {},
11158 // int -> FLOAT16 map
11159 .float16Operands = {{0, {33.0f, 33.0f, 31.0f, 27.0f, 0.0f, 7.5f, 4.5f, 0.0f}}},
11160 // int -> BOOL8 map
11161 .bool8Operands = {},
11162 // int -> QUANT8_SYMM_PER_CHANNEL map
11163 .quant8ChannelOperands = {},
11164 // int -> QUANT16_ASYMM map
11165 .quant16AsymmOperands = {},
11166 // int -> QUANT8_SYMM map
11167 .quant8SymmOperands = {},
11168 }
11169 },
11170 }, // End of an example
11171 };
11172 return examples_dynamic_output_shape_nchw_relu_float16_weight_as_input;
11173 };
11174
get_examples_dynamic_output_shape_nchw_relu1()11175 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1() {
11176 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1 = {
11177 // Begin of an example
11178 {
11179 .operands = {
11180 //Input(s)
11181 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11182 // int -> Dimensions map
11183 .operandDimensions = {{0, {1, 2, 3, 3}}},
11184 // int -> FLOAT32 map
11185 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
11186 // int -> INT32 map
11187 .int32Operands = {},
11188 // int -> QUANT8_ASYMM map
11189 .quant8AsymmOperands = {},
11190 // int -> QUANT16_SYMM map
11191 .quant16SymmOperands = {},
11192 // int -> FLOAT16 map
11193 .float16Operands = {},
11194 // int -> BOOL8 map
11195 .bool8Operands = {},
11196 // int -> QUANT8_SYMM_PER_CHANNEL map
11197 .quant8ChannelOperands = {},
11198 // int -> QUANT16_ASYMM map
11199 .quant16AsymmOperands = {},
11200 // int -> QUANT8_SYMM map
11201 .quant8SymmOperands = {},
11202 },
11203 //Output(s)
11204 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11205 // int -> Dimensions map
11206 .operandDimensions = {{0, {1, 2, 2, 2}}},
11207 // int -> FLOAT32 map
11208 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
11209 // int -> INT32 map
11210 .int32Operands = {},
11211 // int -> QUANT8_ASYMM map
11212 .quant8AsymmOperands = {},
11213 // int -> QUANT16_SYMM map
11214 .quant16SymmOperands = {},
11215 // int -> FLOAT16 map
11216 .float16Operands = {},
11217 // int -> BOOL8 map
11218 .bool8Operands = {},
11219 // int -> QUANT8_SYMM_PER_CHANNEL map
11220 .quant8ChannelOperands = {},
11221 // int -> QUANT16_ASYMM map
11222 .quant16AsymmOperands = {},
11223 // int -> QUANT8_SYMM map
11224 .quant8SymmOperands = {},
11225 }
11226 },
11227 }, // End of an example
11228 };
11229 return examples_dynamic_output_shape_nchw_relu1;
11230 };
11231
get_examples_dynamic_output_shape_nchw_relu1_weight_as_input()11232 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_weight_as_input() {
11233 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_weight_as_input = {
11234 // Begin of an example
11235 {
11236 .operands = {
11237 //Input(s)
11238 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11239 // int -> Dimensions map
11240 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11241 // int -> FLOAT32 map
11242 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
11243 // int -> INT32 map
11244 .int32Operands = {},
11245 // int -> QUANT8_ASYMM map
11246 .quant8AsymmOperands = {},
11247 // int -> QUANT16_SYMM map
11248 .quant16SymmOperands = {},
11249 // int -> FLOAT16 map
11250 .float16Operands = {},
11251 // int -> BOOL8 map
11252 .bool8Operands = {},
11253 // int -> QUANT8_SYMM_PER_CHANNEL map
11254 .quant8ChannelOperands = {},
11255 // int -> QUANT16_ASYMM map
11256 .quant16AsymmOperands = {},
11257 // int -> QUANT8_SYMM map
11258 .quant8SymmOperands = {},
11259 },
11260 //Output(s)
11261 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11262 // int -> Dimensions map
11263 .operandDimensions = {{0, {1, 2, 2, 2}}},
11264 // int -> FLOAT32 map
11265 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
11266 // int -> INT32 map
11267 .int32Operands = {},
11268 // int -> QUANT8_ASYMM map
11269 .quant8AsymmOperands = {},
11270 // int -> QUANT16_SYMM map
11271 .quant16SymmOperands = {},
11272 // int -> FLOAT16 map
11273 .float16Operands = {},
11274 // int -> BOOL8 map
11275 .bool8Operands = {},
11276 // int -> QUANT8_SYMM_PER_CHANNEL map
11277 .quant8ChannelOperands = {},
11278 // int -> QUANT16_ASYMM map
11279 .quant16AsymmOperands = {},
11280 // int -> QUANT8_SYMM map
11281 .quant8SymmOperands = {},
11282 }
11283 },
11284 }, // End of an example
11285 };
11286 return examples_dynamic_output_shape_nchw_relu1_weight_as_input;
11287 };
11288
get_examples_dynamic_output_shape_nchw_relu1_relaxed()11289 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_relaxed() {
11290 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_relaxed = {
11291 // Begin of an example
11292 {
11293 .operands = {
11294 //Input(s)
11295 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11296 // int -> Dimensions map
11297 .operandDimensions = {{0, {1, 2, 3, 3}}},
11298 // int -> FLOAT32 map
11299 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
11300 // int -> INT32 map
11301 .int32Operands = {},
11302 // int -> QUANT8_ASYMM map
11303 .quant8AsymmOperands = {},
11304 // int -> QUANT16_SYMM map
11305 .quant16SymmOperands = {},
11306 // int -> FLOAT16 map
11307 .float16Operands = {},
11308 // int -> BOOL8 map
11309 .bool8Operands = {},
11310 // int -> QUANT8_SYMM_PER_CHANNEL map
11311 .quant8ChannelOperands = {},
11312 // int -> QUANT16_ASYMM map
11313 .quant16AsymmOperands = {},
11314 // int -> QUANT8_SYMM map
11315 .quant8SymmOperands = {},
11316 },
11317 //Output(s)
11318 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11319 // int -> Dimensions map
11320 .operandDimensions = {{0, {1, 2, 2, 2}}},
11321 // int -> FLOAT32 map
11322 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
11323 // int -> INT32 map
11324 .int32Operands = {},
11325 // int -> QUANT8_ASYMM map
11326 .quant8AsymmOperands = {},
11327 // int -> QUANT16_SYMM map
11328 .quant16SymmOperands = {},
11329 // int -> FLOAT16 map
11330 .float16Operands = {},
11331 // int -> BOOL8 map
11332 .bool8Operands = {},
11333 // int -> QUANT8_SYMM_PER_CHANNEL map
11334 .quant8ChannelOperands = {},
11335 // int -> QUANT16_ASYMM map
11336 .quant16AsymmOperands = {},
11337 // int -> QUANT8_SYMM map
11338 .quant8SymmOperands = {},
11339 }
11340 },
11341 }, // End of an example
11342 };
11343 return examples_dynamic_output_shape_nchw_relu1_relaxed;
11344 };
11345
get_examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input()11346 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input() {
11347 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input = {
11348 // Begin of an example
11349 {
11350 .operands = {
11351 //Input(s)
11352 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11353 // int -> Dimensions map
11354 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11355 // int -> FLOAT32 map
11356 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
11357 // int -> INT32 map
11358 .int32Operands = {},
11359 // int -> QUANT8_ASYMM map
11360 .quant8AsymmOperands = {},
11361 // int -> QUANT16_SYMM map
11362 .quant16SymmOperands = {},
11363 // int -> FLOAT16 map
11364 .float16Operands = {},
11365 // int -> BOOL8 map
11366 .bool8Operands = {},
11367 // int -> QUANT8_SYMM_PER_CHANNEL map
11368 .quant8ChannelOperands = {},
11369 // int -> QUANT16_ASYMM map
11370 .quant16AsymmOperands = {},
11371 // int -> QUANT8_SYMM map
11372 .quant8SymmOperands = {},
11373 },
11374 //Output(s)
11375 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11376 // int -> Dimensions map
11377 .operandDimensions = {{0, {1, 2, 2, 2}}},
11378 // int -> FLOAT32 map
11379 .float32Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
11380 // int -> INT32 map
11381 .int32Operands = {},
11382 // int -> QUANT8_ASYMM map
11383 .quant8AsymmOperands = {},
11384 // int -> QUANT16_SYMM map
11385 .quant16SymmOperands = {},
11386 // int -> FLOAT16 map
11387 .float16Operands = {},
11388 // int -> BOOL8 map
11389 .bool8Operands = {},
11390 // int -> QUANT8_SYMM_PER_CHANNEL map
11391 .quant8ChannelOperands = {},
11392 // int -> QUANT16_ASYMM map
11393 .quant16AsymmOperands = {},
11394 // int -> QUANT8_SYMM map
11395 .quant8SymmOperands = {},
11396 }
11397 },
11398 }, // End of an example
11399 };
11400 return examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input;
11401 };
11402
get_examples_dynamic_output_shape_nchw_relu1_quant8()11403 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8() {
11404 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8 = {
11405 // Begin of an example
11406 {
11407 .operands = {
11408 //Input(s)
11409 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11410 // int -> Dimensions map
11411 .operandDimensions = {{0, {1, 2, 3, 3}}},
11412 // int -> FLOAT32 map
11413 .float32Operands = {},
11414 // int -> INT32 map
11415 .int32Operands = {},
11416 // int -> QUANT8_ASYMM map
11417 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11418 // int -> QUANT16_SYMM map
11419 .quant16SymmOperands = {},
11420 // int -> FLOAT16 map
11421 .float16Operands = {},
11422 // int -> BOOL8 map
11423 .bool8Operands = {},
11424 // int -> QUANT8_SYMM_PER_CHANNEL map
11425 .quant8ChannelOperands = {},
11426 // int -> QUANT16_ASYMM map
11427 .quant16AsymmOperands = {},
11428 // int -> QUANT8_SYMM map
11429 .quant8SymmOperands = {},
11430 },
11431 //Output(s)
11432 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11433 // int -> Dimensions map
11434 .operandDimensions = {{0, {1, 2, 2, 2}}},
11435 // int -> FLOAT32 map
11436 .float32Operands = {},
11437 // int -> INT32 map
11438 .int32Operands = {},
11439 // int -> QUANT8_ASYMM map
11440 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
11441 // int -> QUANT16_SYMM map
11442 .quant16SymmOperands = {},
11443 // int -> FLOAT16 map
11444 .float16Operands = {},
11445 // int -> BOOL8 map
11446 .bool8Operands = {},
11447 // int -> QUANT8_SYMM_PER_CHANNEL map
11448 .quant8ChannelOperands = {},
11449 // int -> QUANT16_ASYMM map
11450 .quant16AsymmOperands = {},
11451 // int -> QUANT8_SYMM map
11452 .quant8SymmOperands = {},
11453 }
11454 },
11455 }, // End of an example
11456 };
11457 return examples_dynamic_output_shape_nchw_relu1_quant8;
11458 };
11459
get_examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input()11460 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input() {
11461 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input = {
11462 // Begin of an example
11463 {
11464 .operands = {
11465 //Input(s)
11466 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11467 // int -> Dimensions map
11468 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11469 // int -> FLOAT32 map
11470 .float32Operands = {},
11471 // int -> INT32 map
11472 .int32Operands = {{2, {160, -536}}},
11473 // int -> QUANT8_ASYMM map
11474 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
11475 // int -> QUANT16_SYMM map
11476 .quant16SymmOperands = {},
11477 // int -> FLOAT16 map
11478 .float16Operands = {},
11479 // int -> BOOL8 map
11480 .bool8Operands = {},
11481 // int -> QUANT8_SYMM_PER_CHANNEL map
11482 .quant8ChannelOperands = {},
11483 // int -> QUANT16_ASYMM map
11484 .quant16AsymmOperands = {},
11485 // int -> QUANT8_SYMM map
11486 .quant8SymmOperands = {},
11487 },
11488 //Output(s)
11489 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11490 // int -> Dimensions map
11491 .operandDimensions = {{0, {1, 2, 2, 2}}},
11492 // int -> FLOAT32 map
11493 .float32Operands = {},
11494 // int -> INT32 map
11495 .int32Operands = {},
11496 // int -> QUANT8_ASYMM map
11497 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
11498 // int -> QUANT16_SYMM map
11499 .quant16SymmOperands = {},
11500 // int -> FLOAT16 map
11501 .float16Operands = {},
11502 // int -> BOOL8 map
11503 .bool8Operands = {},
11504 // int -> QUANT8_SYMM_PER_CHANNEL map
11505 .quant8ChannelOperands = {},
11506 // int -> QUANT16_ASYMM map
11507 .quant16AsymmOperands = {},
11508 // int -> QUANT8_SYMM map
11509 .quant8SymmOperands = {},
11510 }
11511 },
11512 }, // End of an example
11513 };
11514 return examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input;
11515 };
11516
get_examples_dynamic_output_shape_nchw_relu1_quant8_2()11517 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8_2() {
11518 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8_2 = {
11519 // Begin of an example
11520 {
11521 .operands = {
11522 //Input(s)
11523 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11524 // int -> Dimensions map
11525 .operandDimensions = {{0, {1, 2, 3, 3}}},
11526 // int -> FLOAT32 map
11527 .float32Operands = {},
11528 // int -> INT32 map
11529 .int32Operands = {},
11530 // int -> QUANT8_ASYMM map
11531 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11532 // int -> QUANT16_SYMM map
11533 .quant16SymmOperands = {},
11534 // int -> FLOAT16 map
11535 .float16Operands = {},
11536 // int -> BOOL8 map
11537 .bool8Operands = {},
11538 // int -> QUANT8_SYMM_PER_CHANNEL map
11539 .quant8ChannelOperands = {},
11540 // int -> QUANT16_ASYMM map
11541 .quant16AsymmOperands = {},
11542 // int -> QUANT8_SYMM map
11543 .quant8SymmOperands = {},
11544 },
11545 //Output(s)
11546 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11547 // int -> Dimensions map
11548 .operandDimensions = {{0, {1, 2, 2, 2}}},
11549 // int -> FLOAT32 map
11550 .float32Operands = {},
11551 // int -> INT32 map
11552 .int32Operands = {},
11553 // int -> QUANT8_ASYMM map
11554 .quant8AsymmOperands = {{0, {100, 100, 100, 100, 70, 100, 100, 60}}},
11555 // int -> QUANT16_SYMM map
11556 .quant16SymmOperands = {},
11557 // int -> FLOAT16 map
11558 .float16Operands = {},
11559 // int -> BOOL8 map
11560 .bool8Operands = {},
11561 // int -> QUANT8_SYMM_PER_CHANNEL map
11562 .quant8ChannelOperands = {},
11563 // int -> QUANT16_ASYMM map
11564 .quant16AsymmOperands = {},
11565 // int -> QUANT8_SYMM map
11566 .quant8SymmOperands = {},
11567 }
11568 },
11569 }, // End of an example
11570 };
11571 return examples_dynamic_output_shape_nchw_relu1_quant8_2;
11572 };
11573
get_examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2()11574 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2() {
11575 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2 = {
11576 // Begin of an example
11577 {
11578 .operands = {
11579 //Input(s)
11580 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11581 // int -> Dimensions map
11582 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11583 // int -> FLOAT32 map
11584 .float32Operands = {},
11585 // int -> INT32 map
11586 .int32Operands = {{2, {160, -536}}},
11587 // int -> QUANT8_ASYMM map
11588 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
11589 // int -> QUANT16_SYMM map
11590 .quant16SymmOperands = {},
11591 // int -> FLOAT16 map
11592 .float16Operands = {},
11593 // int -> BOOL8 map
11594 .bool8Operands = {},
11595 // int -> QUANT8_SYMM_PER_CHANNEL map
11596 .quant8ChannelOperands = {},
11597 // int -> QUANT16_ASYMM map
11598 .quant16AsymmOperands = {},
11599 // int -> QUANT8_SYMM map
11600 .quant8SymmOperands = {},
11601 },
11602 //Output(s)
11603 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11604 // int -> Dimensions map
11605 .operandDimensions = {{0, {1, 2, 2, 2}}},
11606 // int -> FLOAT32 map
11607 .float32Operands = {},
11608 // int -> INT32 map
11609 .int32Operands = {},
11610 // int -> QUANT8_ASYMM map
11611 .quant8AsymmOperands = {{0, {100, 100, 100, 100, 70, 100, 100, 60}}},
11612 // int -> QUANT16_SYMM map
11613 .quant16SymmOperands = {},
11614 // int -> FLOAT16 map
11615 .float16Operands = {},
11616 // int -> BOOL8 map
11617 .bool8Operands = {},
11618 // int -> QUANT8_SYMM_PER_CHANNEL map
11619 .quant8ChannelOperands = {},
11620 // int -> QUANT16_ASYMM map
11621 .quant16AsymmOperands = {},
11622 // int -> QUANT8_SYMM map
11623 .quant8SymmOperands = {},
11624 }
11625 },
11626 }, // End of an example
11627 };
11628 return examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2;
11629 };
11630
get_examples_dynamic_output_shape_nchw_relu1_channelQuant8()11631 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8() {
11632 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8 = {
11633 // Begin of an example
11634 {
11635 .operands = {
11636 //Input(s)
11637 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11638 // int -> Dimensions map
11639 .operandDimensions = {{0, {1, 2, 3, 3}}},
11640 // int -> FLOAT32 map
11641 .float32Operands = {},
11642 // int -> INT32 map
11643 .int32Operands = {},
11644 // int -> QUANT8_ASYMM map
11645 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11646 // int -> QUANT16_SYMM map
11647 .quant16SymmOperands = {},
11648 // int -> FLOAT16 map
11649 .float16Operands = {},
11650 // int -> BOOL8 map
11651 .bool8Operands = {},
11652 // int -> QUANT8_SYMM_PER_CHANNEL map
11653 .quant8ChannelOperands = {},
11654 // int -> QUANT16_ASYMM map
11655 .quant16AsymmOperands = {},
11656 // int -> QUANT8_SYMM map
11657 .quant8SymmOperands = {},
11658 },
11659 //Output(s)
11660 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11661 // int -> Dimensions map
11662 .operandDimensions = {{0, {1, 2, 2, 2}}},
11663 // int -> FLOAT32 map
11664 .float32Operands = {},
11665 // int -> INT32 map
11666 .int32Operands = {},
11667 // int -> QUANT8_ASYMM map
11668 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
11669 // int -> QUANT16_SYMM map
11670 .quant16SymmOperands = {},
11671 // int -> FLOAT16 map
11672 .float16Operands = {},
11673 // int -> BOOL8 map
11674 .bool8Operands = {},
11675 // int -> QUANT8_SYMM_PER_CHANNEL map
11676 .quant8ChannelOperands = {},
11677 // int -> QUANT16_ASYMM map
11678 .quant16AsymmOperands = {},
11679 // int -> QUANT8_SYMM map
11680 .quant8SymmOperands = {},
11681 }
11682 },
11683 }, // End of an example
11684 };
11685 return examples_dynamic_output_shape_nchw_relu1_channelQuant8;
11686 };
11687
get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input()11688 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input() {
11689 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input = {
11690 // Begin of an example
11691 {
11692 .operands = {
11693 //Input(s)
11694 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11695 // int -> Dimensions map
11696 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11697 // int -> FLOAT32 map
11698 .float32Operands = {},
11699 // int -> INT32 map
11700 .int32Operands = {{2, {160, -268}}},
11701 // int -> QUANT8_ASYMM map
11702 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11703 // int -> QUANT16_SYMM map
11704 .quant16SymmOperands = {},
11705 // int -> FLOAT16 map
11706 .float16Operands = {},
11707 // int -> BOOL8 map
11708 .bool8Operands = {},
11709 // int -> QUANT8_SYMM_PER_CHANNEL map
11710 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
11711 // int -> QUANT16_ASYMM map
11712 .quant16AsymmOperands = {},
11713 // int -> QUANT8_SYMM map
11714 .quant8SymmOperands = {},
11715 },
11716 //Output(s)
11717 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11718 // int -> Dimensions map
11719 .operandDimensions = {{0, {1, 2, 2, 2}}},
11720 // int -> FLOAT32 map
11721 .float32Operands = {},
11722 // int -> INT32 map
11723 .int32Operands = {},
11724 // int -> QUANT8_ASYMM map
11725 .quant8AsymmOperands = {{0, {82, 82, 82, 82, 79, 82, 82, 78}}},
11726 // int -> QUANT16_SYMM map
11727 .quant16SymmOperands = {},
11728 // int -> FLOAT16 map
11729 .float16Operands = {},
11730 // int -> BOOL8 map
11731 .bool8Operands = {},
11732 // int -> QUANT8_SYMM_PER_CHANNEL map
11733 .quant8ChannelOperands = {},
11734 // int -> QUANT16_ASYMM map
11735 .quant16AsymmOperands = {},
11736 // int -> QUANT8_SYMM map
11737 .quant8SymmOperands = {},
11738 }
11739 },
11740 }, // End of an example
11741 };
11742 return examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input;
11743 };
11744
get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_2()11745 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_2() {
11746 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8_2 = {
11747 // Begin of an example
11748 {
11749 .operands = {
11750 //Input(s)
11751 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11752 // int -> Dimensions map
11753 .operandDimensions = {{0, {1, 2, 3, 3}}},
11754 // int -> FLOAT32 map
11755 .float32Operands = {},
11756 // int -> INT32 map
11757 .int32Operands = {},
11758 // int -> QUANT8_ASYMM map
11759 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11760 // int -> QUANT16_SYMM map
11761 .quant16SymmOperands = {},
11762 // int -> FLOAT16 map
11763 .float16Operands = {},
11764 // int -> BOOL8 map
11765 .bool8Operands = {},
11766 // int -> QUANT8_SYMM_PER_CHANNEL map
11767 .quant8ChannelOperands = {},
11768 // int -> QUANT16_ASYMM map
11769 .quant16AsymmOperands = {},
11770 // int -> QUANT8_SYMM map
11771 .quant8SymmOperands = {},
11772 },
11773 //Output(s)
11774 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11775 // int -> Dimensions map
11776 .operandDimensions = {{0, {1, 2, 2, 2}}},
11777 // int -> FLOAT32 map
11778 .float32Operands = {},
11779 // int -> INT32 map
11780 .int32Operands = {},
11781 // int -> QUANT8_ASYMM map
11782 .quant8AsymmOperands = {{0, {90, 90, 90, 90, 75, 90, 90, 70}}},
11783 // int -> QUANT16_SYMM map
11784 .quant16SymmOperands = {},
11785 // int -> FLOAT16 map
11786 .float16Operands = {},
11787 // int -> BOOL8 map
11788 .bool8Operands = {},
11789 // int -> QUANT8_SYMM_PER_CHANNEL map
11790 .quant8ChannelOperands = {},
11791 // int -> QUANT16_ASYMM map
11792 .quant16AsymmOperands = {},
11793 // int -> QUANT8_SYMM map
11794 .quant8SymmOperands = {},
11795 }
11796 },
11797 }, // End of an example
11798 };
11799 return examples_dynamic_output_shape_nchw_relu1_channelQuant8_2;
11800 };
11801
get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2()11802 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2() {
11803 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2 = {
11804 // Begin of an example
11805 {
11806 .operands = {
11807 //Input(s)
11808 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11809 // int -> Dimensions map
11810 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11811 // int -> FLOAT32 map
11812 .float32Operands = {},
11813 // int -> INT32 map
11814 .int32Operands = {{2, {160, -268}}},
11815 // int -> QUANT8_ASYMM map
11816 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
11817 // int -> QUANT16_SYMM map
11818 .quant16SymmOperands = {},
11819 // int -> FLOAT16 map
11820 .float16Operands = {},
11821 // int -> BOOL8 map
11822 .bool8Operands = {},
11823 // int -> QUANT8_SYMM_PER_CHANNEL map
11824 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
11825 // int -> QUANT16_ASYMM map
11826 .quant16AsymmOperands = {},
11827 // int -> QUANT8_SYMM map
11828 .quant8SymmOperands = {},
11829 },
11830 //Output(s)
11831 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11832 // int -> Dimensions map
11833 .operandDimensions = {{0, {1, 2, 2, 2}}},
11834 // int -> FLOAT32 map
11835 .float32Operands = {},
11836 // int -> INT32 map
11837 .int32Operands = {},
11838 // int -> QUANT8_ASYMM map
11839 .quant8AsymmOperands = {{0, {90, 90, 90, 90, 75, 90, 90, 70}}},
11840 // int -> QUANT16_SYMM map
11841 .quant16SymmOperands = {},
11842 // int -> FLOAT16 map
11843 .float16Operands = {},
11844 // int -> BOOL8 map
11845 .bool8Operands = {},
11846 // int -> QUANT8_SYMM_PER_CHANNEL map
11847 .quant8ChannelOperands = {},
11848 // int -> QUANT16_ASYMM map
11849 .quant16AsymmOperands = {},
11850 // int -> QUANT8_SYMM map
11851 .quant8SymmOperands = {},
11852 }
11853 },
11854 }, // End of an example
11855 };
11856 return examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2;
11857 };
11858
get_examples_dynamic_output_shape_nchw_relu1_float16()11859 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_float16() {
11860 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_float16 = {
11861 // Begin of an example
11862 {
11863 .operands = {
11864 //Input(s)
11865 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11866 // int -> Dimensions map
11867 .operandDimensions = {{0, {1, 2, 3, 3}}},
11868 // int -> FLOAT32 map
11869 .float32Operands = {},
11870 // int -> INT32 map
11871 .int32Operands = {},
11872 // int -> QUANT8_ASYMM map
11873 .quant8AsymmOperands = {},
11874 // int -> QUANT16_SYMM map
11875 .quant16SymmOperands = {},
11876 // int -> FLOAT16 map
11877 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
11878 // int -> BOOL8 map
11879 .bool8Operands = {},
11880 // int -> QUANT8_SYMM_PER_CHANNEL map
11881 .quant8ChannelOperands = {},
11882 // int -> QUANT16_ASYMM map
11883 .quant16AsymmOperands = {},
11884 // int -> QUANT8_SYMM map
11885 .quant8SymmOperands = {},
11886 },
11887 //Output(s)
11888 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11889 // int -> Dimensions map
11890 .operandDimensions = {{0, {1, 2, 2, 2}}},
11891 // int -> FLOAT32 map
11892 .float32Operands = {},
11893 // int -> INT32 map
11894 .int32Operands = {},
11895 // int -> QUANT8_ASYMM map
11896 .quant8AsymmOperands = {},
11897 // int -> QUANT16_SYMM map
11898 .quant16SymmOperands = {},
11899 // int -> FLOAT16 map
11900 .float16Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
11901 // int -> BOOL8 map
11902 .bool8Operands = {},
11903 // int -> QUANT8_SYMM_PER_CHANNEL map
11904 .quant8ChannelOperands = {},
11905 // int -> QUANT16_ASYMM map
11906 .quant16AsymmOperands = {},
11907 // int -> QUANT8_SYMM map
11908 .quant8SymmOperands = {},
11909 }
11910 },
11911 }, // End of an example
11912 };
11913 return examples_dynamic_output_shape_nchw_relu1_float16;
11914 };
11915
get_examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input()11916 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input() {
11917 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input = {
11918 // Begin of an example
11919 {
11920 .operands = {
11921 //Input(s)
11922 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11923 // int -> Dimensions map
11924 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
11925 // int -> FLOAT32 map
11926 .float32Operands = {},
11927 // int -> INT32 map
11928 .int32Operands = {},
11929 // int -> QUANT8_ASYMM map
11930 .quant8AsymmOperands = {},
11931 // int -> QUANT16_SYMM map
11932 .quant16SymmOperands = {},
11933 // int -> FLOAT16 map
11934 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
11935 // int -> BOOL8 map
11936 .bool8Operands = {},
11937 // int -> QUANT8_SYMM_PER_CHANNEL map
11938 .quant8ChannelOperands = {},
11939 // int -> QUANT16_ASYMM map
11940 .quant16AsymmOperands = {},
11941 // int -> QUANT8_SYMM map
11942 .quant8SymmOperands = {},
11943 },
11944 //Output(s)
11945 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11946 // int -> Dimensions map
11947 .operandDimensions = {{0, {1, 2, 2, 2}}},
11948 // int -> FLOAT32 map
11949 .float32Operands = {},
11950 // int -> INT32 map
11951 .int32Operands = {},
11952 // int -> QUANT8_ASYMM map
11953 .quant8AsymmOperands = {},
11954 // int -> QUANT16_SYMM map
11955 .quant16SymmOperands = {},
11956 // int -> FLOAT16 map
11957 .float16Operands = {{0, {1.0f, 1.0f, 1.0f, 1.0f, -0.5f, 1.0f, 1.0f, -1.0f}}},
11958 // int -> BOOL8 map
11959 .bool8Operands = {},
11960 // int -> QUANT8_SYMM_PER_CHANNEL map
11961 .quant8ChannelOperands = {},
11962 // int -> QUANT16_ASYMM map
11963 .quant16AsymmOperands = {},
11964 // int -> QUANT8_SYMM map
11965 .quant8SymmOperands = {},
11966 }
11967 },
11968 }, // End of an example
11969 };
11970 return examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input;
11971 };
11972
get_examples_dynamic_output_shape_nchw_relu6()11973 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6() {
11974 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6 = {
11975 // Begin of an example
11976 {
11977 .operands = {
11978 //Input(s)
11979 { // See tools/test_generator/include/TestHarness.h:MixedTyped
11980 // int -> Dimensions map
11981 .operandDimensions = {{0, {1, 2, 3, 3}}},
11982 // int -> FLOAT32 map
11983 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
11984 // int -> INT32 map
11985 .int32Operands = {},
11986 // int -> QUANT8_ASYMM map
11987 .quant8AsymmOperands = {},
11988 // int -> QUANT16_SYMM map
11989 .quant16SymmOperands = {},
11990 // int -> FLOAT16 map
11991 .float16Operands = {},
11992 // int -> BOOL8 map
11993 .bool8Operands = {},
11994 // int -> QUANT8_SYMM_PER_CHANNEL map
11995 .quant8ChannelOperands = {},
11996 // int -> QUANT16_ASYMM map
11997 .quant16AsymmOperands = {},
11998 // int -> QUANT8_SYMM map
11999 .quant8SymmOperands = {},
12000 },
12001 //Output(s)
12002 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12003 // int -> Dimensions map
12004 .operandDimensions = {{0, {1, 2, 2, 2}}},
12005 // int -> FLOAT32 map
12006 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
12007 // int -> INT32 map
12008 .int32Operands = {},
12009 // int -> QUANT8_ASYMM map
12010 .quant8AsymmOperands = {},
12011 // int -> QUANT16_SYMM map
12012 .quant16SymmOperands = {},
12013 // int -> FLOAT16 map
12014 .float16Operands = {},
12015 // int -> BOOL8 map
12016 .bool8Operands = {},
12017 // int -> QUANT8_SYMM_PER_CHANNEL map
12018 .quant8ChannelOperands = {},
12019 // int -> QUANT16_ASYMM map
12020 .quant16AsymmOperands = {},
12021 // int -> QUANT8_SYMM map
12022 .quant8SymmOperands = {},
12023 }
12024 },
12025 }, // End of an example
12026 };
12027 return examples_dynamic_output_shape_nchw_relu6;
12028 };
12029
get_examples_dynamic_output_shape_nchw_relu6_weight_as_input()12030 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_weight_as_input() {
12031 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_weight_as_input = {
12032 // Begin of an example
12033 {
12034 .operands = {
12035 //Input(s)
12036 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12037 // int -> Dimensions map
12038 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12039 // int -> FLOAT32 map
12040 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
12041 // int -> INT32 map
12042 .int32Operands = {},
12043 // int -> QUANT8_ASYMM map
12044 .quant8AsymmOperands = {},
12045 // int -> QUANT16_SYMM map
12046 .quant16SymmOperands = {},
12047 // int -> FLOAT16 map
12048 .float16Operands = {},
12049 // int -> BOOL8 map
12050 .bool8Operands = {},
12051 // int -> QUANT8_SYMM_PER_CHANNEL map
12052 .quant8ChannelOperands = {},
12053 // int -> QUANT16_ASYMM map
12054 .quant16AsymmOperands = {},
12055 // int -> QUANT8_SYMM map
12056 .quant8SymmOperands = {},
12057 },
12058 //Output(s)
12059 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12060 // int -> Dimensions map
12061 .operandDimensions = {{0, {1, 2, 2, 2}}},
12062 // int -> FLOAT32 map
12063 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
12064 // int -> INT32 map
12065 .int32Operands = {},
12066 // int -> QUANT8_ASYMM map
12067 .quant8AsymmOperands = {},
12068 // int -> QUANT16_SYMM map
12069 .quant16SymmOperands = {},
12070 // int -> FLOAT16 map
12071 .float16Operands = {},
12072 // int -> BOOL8 map
12073 .bool8Operands = {},
12074 // int -> QUANT8_SYMM_PER_CHANNEL map
12075 .quant8ChannelOperands = {},
12076 // int -> QUANT16_ASYMM map
12077 .quant16AsymmOperands = {},
12078 // int -> QUANT8_SYMM map
12079 .quant8SymmOperands = {},
12080 }
12081 },
12082 }, // End of an example
12083 };
12084 return examples_dynamic_output_shape_nchw_relu6_weight_as_input;
12085 };
12086
get_examples_dynamic_output_shape_nchw_relu6_relaxed()12087 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_relaxed() {
12088 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_relaxed = {
12089 // Begin of an example
12090 {
12091 .operands = {
12092 //Input(s)
12093 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12094 // int -> Dimensions map
12095 .operandDimensions = {{0, {1, 2, 3, 3}}},
12096 // int -> FLOAT32 map
12097 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
12098 // int -> INT32 map
12099 .int32Operands = {},
12100 // int -> QUANT8_ASYMM map
12101 .quant8AsymmOperands = {},
12102 // int -> QUANT16_SYMM map
12103 .quant16SymmOperands = {},
12104 // int -> FLOAT16 map
12105 .float16Operands = {},
12106 // int -> BOOL8 map
12107 .bool8Operands = {},
12108 // int -> QUANT8_SYMM_PER_CHANNEL map
12109 .quant8ChannelOperands = {},
12110 // int -> QUANT16_ASYMM map
12111 .quant16AsymmOperands = {},
12112 // int -> QUANT8_SYMM map
12113 .quant8SymmOperands = {},
12114 },
12115 //Output(s)
12116 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12117 // int -> Dimensions map
12118 .operandDimensions = {{0, {1, 2, 2, 2}}},
12119 // int -> FLOAT32 map
12120 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
12121 // int -> INT32 map
12122 .int32Operands = {},
12123 // int -> QUANT8_ASYMM map
12124 .quant8AsymmOperands = {},
12125 // int -> QUANT16_SYMM map
12126 .quant16SymmOperands = {},
12127 // int -> FLOAT16 map
12128 .float16Operands = {},
12129 // int -> BOOL8 map
12130 .bool8Operands = {},
12131 // int -> QUANT8_SYMM_PER_CHANNEL map
12132 .quant8ChannelOperands = {},
12133 // int -> QUANT16_ASYMM map
12134 .quant16AsymmOperands = {},
12135 // int -> QUANT8_SYMM map
12136 .quant8SymmOperands = {},
12137 }
12138 },
12139 }, // End of an example
12140 };
12141 return examples_dynamic_output_shape_nchw_relu6_relaxed;
12142 };
12143
get_examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input()12144 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input() {
12145 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input = {
12146 // Begin of an example
12147 {
12148 .operands = {
12149 //Input(s)
12150 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12151 // int -> Dimensions map
12152 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12153 // int -> FLOAT32 map
12154 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
12155 // int -> INT32 map
12156 .int32Operands = {},
12157 // int -> QUANT8_ASYMM map
12158 .quant8AsymmOperands = {},
12159 // int -> QUANT16_SYMM map
12160 .quant16SymmOperands = {},
12161 // int -> FLOAT16 map
12162 .float16Operands = {},
12163 // int -> BOOL8 map
12164 .bool8Operands = {},
12165 // int -> QUANT8_SYMM_PER_CHANNEL map
12166 .quant8ChannelOperands = {},
12167 // int -> QUANT16_ASYMM map
12168 .quant16AsymmOperands = {},
12169 // int -> QUANT8_SYMM map
12170 .quant8SymmOperands = {},
12171 },
12172 //Output(s)
12173 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12174 // int -> Dimensions map
12175 .operandDimensions = {{0, {1, 2, 2, 2}}},
12176 // int -> FLOAT32 map
12177 .float32Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
12178 // int -> INT32 map
12179 .int32Operands = {},
12180 // int -> QUANT8_ASYMM map
12181 .quant8AsymmOperands = {},
12182 // int -> QUANT16_SYMM map
12183 .quant16SymmOperands = {},
12184 // int -> FLOAT16 map
12185 .float16Operands = {},
12186 // int -> BOOL8 map
12187 .bool8Operands = {},
12188 // int -> QUANT8_SYMM_PER_CHANNEL map
12189 .quant8ChannelOperands = {},
12190 // int -> QUANT16_ASYMM map
12191 .quant16AsymmOperands = {},
12192 // int -> QUANT8_SYMM map
12193 .quant8SymmOperands = {},
12194 }
12195 },
12196 }, // End of an example
12197 };
12198 return examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input;
12199 };
12200
get_examples_dynamic_output_shape_nchw_relu6_quant8()12201 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8() {
12202 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8 = {
12203 // Begin of an example
12204 {
12205 .operands = {
12206 //Input(s)
12207 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12208 // int -> Dimensions map
12209 .operandDimensions = {{0, {1, 2, 3, 3}}},
12210 // int -> FLOAT32 map
12211 .float32Operands = {},
12212 // int -> INT32 map
12213 .int32Operands = {},
12214 // int -> QUANT8_ASYMM map
12215 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
12216 // int -> QUANT16_SYMM map
12217 .quant16SymmOperands = {},
12218 // int -> FLOAT16 map
12219 .float16Operands = {},
12220 // int -> BOOL8 map
12221 .bool8Operands = {},
12222 // int -> QUANT8_SYMM_PER_CHANNEL map
12223 .quant8ChannelOperands = {},
12224 // int -> QUANT16_ASYMM map
12225 .quant16AsymmOperands = {},
12226 // int -> QUANT8_SYMM map
12227 .quant8SymmOperands = {},
12228 },
12229 //Output(s)
12230 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12231 // int -> Dimensions map
12232 .operandDimensions = {{0, {1, 2, 2, 2}}},
12233 // int -> FLOAT32 map
12234 .float32Operands = {},
12235 // int -> INT32 map
12236 .int32Operands = {},
12237 // int -> QUANT8_ASYMM map
12238 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
12239 // int -> QUANT16_SYMM map
12240 .quant16SymmOperands = {},
12241 // int -> FLOAT16 map
12242 .float16Operands = {},
12243 // int -> BOOL8 map
12244 .bool8Operands = {},
12245 // int -> QUANT8_SYMM_PER_CHANNEL map
12246 .quant8ChannelOperands = {},
12247 // int -> QUANT16_ASYMM map
12248 .quant16AsymmOperands = {},
12249 // int -> QUANT8_SYMM map
12250 .quant8SymmOperands = {},
12251 }
12252 },
12253 }, // End of an example
12254 };
12255 return examples_dynamic_output_shape_nchw_relu6_quant8;
12256 };
12257
get_examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input()12258 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input() {
12259 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input = {
12260 // Begin of an example
12261 {
12262 .operands = {
12263 //Input(s)
12264 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12265 // int -> Dimensions map
12266 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12267 // int -> FLOAT32 map
12268 .float32Operands = {},
12269 // int -> INT32 map
12270 .int32Operands = {{2, {160, -536}}},
12271 // int -> QUANT8_ASYMM map
12272 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
12273 // int -> QUANT16_SYMM map
12274 .quant16SymmOperands = {},
12275 // int -> FLOAT16 map
12276 .float16Operands = {},
12277 // int -> BOOL8 map
12278 .bool8Operands = {},
12279 // int -> QUANT8_SYMM_PER_CHANNEL map
12280 .quant8ChannelOperands = {},
12281 // int -> QUANT16_ASYMM map
12282 .quant16AsymmOperands = {},
12283 // int -> QUANT8_SYMM map
12284 .quant8SymmOperands = {},
12285 },
12286 //Output(s)
12287 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12288 // int -> Dimensions map
12289 .operandDimensions = {{0, {1, 2, 2, 2}}},
12290 // int -> FLOAT32 map
12291 .float32Operands = {},
12292 // int -> INT32 map
12293 .int32Operands = {},
12294 // int -> QUANT8_ASYMM map
12295 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
12296 // int -> QUANT16_SYMM map
12297 .quant16SymmOperands = {},
12298 // int -> FLOAT16 map
12299 .float16Operands = {},
12300 // int -> BOOL8 map
12301 .bool8Operands = {},
12302 // int -> QUANT8_SYMM_PER_CHANNEL map
12303 .quant8ChannelOperands = {},
12304 // int -> QUANT16_ASYMM map
12305 .quant16AsymmOperands = {},
12306 // int -> QUANT8_SYMM map
12307 .quant8SymmOperands = {},
12308 }
12309 },
12310 }, // End of an example
12311 };
12312 return examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input;
12313 };
12314
get_examples_dynamic_output_shape_nchw_relu6_quant8_2()12315 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8_2() {
12316 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8_2 = {
12317 // Begin of an example
12318 {
12319 .operands = {
12320 //Input(s)
12321 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12322 // int -> Dimensions map
12323 .operandDimensions = {{0, {1, 2, 3, 3}}},
12324 // int -> FLOAT32 map
12325 .float32Operands = {},
12326 // int -> INT32 map
12327 .int32Operands = {},
12328 // int -> QUANT8_ASYMM map
12329 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
12330 // int -> QUANT16_SYMM map
12331 .quant16SymmOperands = {},
12332 // int -> FLOAT16 map
12333 .float16Operands = {},
12334 // int -> BOOL8 map
12335 .bool8Operands = {},
12336 // int -> QUANT8_SYMM_PER_CHANNEL map
12337 .quant8ChannelOperands = {},
12338 // int -> QUANT16_ASYMM map
12339 .quant16AsymmOperands = {},
12340 // int -> QUANT8_SYMM map
12341 .quant8SymmOperands = {},
12342 },
12343 //Output(s)
12344 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12345 // int -> Dimensions map
12346 .operandDimensions = {{0, {1, 2, 2, 2}}},
12347 // int -> FLOAT32 map
12348 .float32Operands = {},
12349 // int -> INT32 map
12350 .int32Operands = {},
12351 // int -> QUANT8_ASYMM map
12352 .quant8AsymmOperands = {{0, {200, 200, 200, 200, 80, 200, 170, 80}}},
12353 // int -> QUANT16_SYMM map
12354 .quant16SymmOperands = {},
12355 // int -> FLOAT16 map
12356 .float16Operands = {},
12357 // int -> BOOL8 map
12358 .bool8Operands = {},
12359 // int -> QUANT8_SYMM_PER_CHANNEL map
12360 .quant8ChannelOperands = {},
12361 // int -> QUANT16_ASYMM map
12362 .quant16AsymmOperands = {},
12363 // int -> QUANT8_SYMM map
12364 .quant8SymmOperands = {},
12365 }
12366 },
12367 }, // End of an example
12368 };
12369 return examples_dynamic_output_shape_nchw_relu6_quant8_2;
12370 };
12371
get_examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2()12372 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2() {
12373 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2 = {
12374 // Begin of an example
12375 {
12376 .operands = {
12377 //Input(s)
12378 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12379 // int -> Dimensions map
12380 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12381 // int -> FLOAT32 map
12382 .float32Operands = {},
12383 // int -> INT32 map
12384 .int32Operands = {{2, {160, -536}}},
12385 // int -> QUANT8_ASYMM map
12386 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}, {1, {132, 136, 136, 132, 144, 140, 136, 132}}},
12387 // int -> QUANT16_SYMM map
12388 .quant16SymmOperands = {},
12389 // int -> FLOAT16 map
12390 .float16Operands = {},
12391 // int -> BOOL8 map
12392 .bool8Operands = {},
12393 // int -> QUANT8_SYMM_PER_CHANNEL map
12394 .quant8ChannelOperands = {},
12395 // int -> QUANT16_ASYMM map
12396 .quant16AsymmOperands = {},
12397 // int -> QUANT8_SYMM map
12398 .quant8SymmOperands = {},
12399 },
12400 //Output(s)
12401 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12402 // int -> Dimensions map
12403 .operandDimensions = {{0, {1, 2, 2, 2}}},
12404 // int -> FLOAT32 map
12405 .float32Operands = {},
12406 // int -> INT32 map
12407 .int32Operands = {},
12408 // int -> QUANT8_ASYMM map
12409 .quant8AsymmOperands = {{0, {200, 200, 200, 200, 80, 200, 170, 80}}},
12410 // int -> QUANT16_SYMM map
12411 .quant16SymmOperands = {},
12412 // int -> FLOAT16 map
12413 .float16Operands = {},
12414 // int -> BOOL8 map
12415 .bool8Operands = {},
12416 // int -> QUANT8_SYMM_PER_CHANNEL map
12417 .quant8ChannelOperands = {},
12418 // int -> QUANT16_ASYMM map
12419 .quant16AsymmOperands = {},
12420 // int -> QUANT8_SYMM map
12421 .quant8SymmOperands = {},
12422 }
12423 },
12424 }, // End of an example
12425 };
12426 return examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2;
12427 };
12428
get_examples_dynamic_output_shape_nchw_relu6_channelQuant8()12429 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8() {
12430 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8 = {
12431 // Begin of an example
12432 {
12433 .operands = {
12434 //Input(s)
12435 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12436 // int -> Dimensions map
12437 .operandDimensions = {{0, {1, 2, 3, 3}}},
12438 // int -> FLOAT32 map
12439 .float32Operands = {},
12440 // int -> INT32 map
12441 .int32Operands = {},
12442 // int -> QUANT8_ASYMM map
12443 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
12444 // int -> QUANT16_SYMM map
12445 .quant16SymmOperands = {},
12446 // int -> FLOAT16 map
12447 .float16Operands = {},
12448 // int -> BOOL8 map
12449 .bool8Operands = {},
12450 // int -> QUANT8_SYMM_PER_CHANNEL map
12451 .quant8ChannelOperands = {},
12452 // int -> QUANT16_ASYMM map
12453 .quant16AsymmOperands = {},
12454 // int -> QUANT8_SYMM map
12455 .quant8SymmOperands = {},
12456 },
12457 //Output(s)
12458 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12459 // int -> Dimensions map
12460 .operandDimensions = {{0, {1, 2, 2, 2}}},
12461 // int -> FLOAT32 map
12462 .float32Operands = {},
12463 // int -> INT32 map
12464 .int32Operands = {},
12465 // int -> QUANT8_ASYMM map
12466 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
12467 // int -> QUANT16_SYMM map
12468 .quant16SymmOperands = {},
12469 // int -> FLOAT16 map
12470 .float16Operands = {},
12471 // int -> BOOL8 map
12472 .bool8Operands = {},
12473 // int -> QUANT8_SYMM_PER_CHANNEL map
12474 .quant8ChannelOperands = {},
12475 // int -> QUANT16_ASYMM map
12476 .quant16AsymmOperands = {},
12477 // int -> QUANT8_SYMM map
12478 .quant8SymmOperands = {},
12479 }
12480 },
12481 }, // End of an example
12482 };
12483 return examples_dynamic_output_shape_nchw_relu6_channelQuant8;
12484 };
12485
get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input()12486 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input() {
12487 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input = {
12488 // Begin of an example
12489 {
12490 .operands = {
12491 //Input(s)
12492 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12493 // int -> Dimensions map
12494 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12495 // int -> FLOAT32 map
12496 .float32Operands = {},
12497 // int -> INT32 map
12498 .int32Operands = {{2, {160, -268}}},
12499 // int -> QUANT8_ASYMM map
12500 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
12501 // int -> QUANT16_SYMM map
12502 .quant16SymmOperands = {},
12503 // int -> FLOAT16 map
12504 .float16Operands = {},
12505 // int -> BOOL8 map
12506 .bool8Operands = {},
12507 // int -> QUANT8_SYMM_PER_CHANNEL map
12508 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
12509 // int -> QUANT16_ASYMM map
12510 .quant16AsymmOperands = {},
12511 // int -> QUANT8_SYMM map
12512 .quant8SymmOperands = {},
12513 },
12514 //Output(s)
12515 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12516 // int -> Dimensions map
12517 .operandDimensions = {{0, {1, 2, 2, 2}}},
12518 // int -> FLOAT32 map
12519 .float32Operands = {},
12520 // int -> INT32 map
12521 .int32Operands = {},
12522 // int -> QUANT8_ASYMM map
12523 .quant8AsymmOperands = {{0, {92, 92, 92, 92, 80, 92, 89, 80}}},
12524 // int -> QUANT16_SYMM map
12525 .quant16SymmOperands = {},
12526 // int -> FLOAT16 map
12527 .float16Operands = {},
12528 // int -> BOOL8 map
12529 .bool8Operands = {},
12530 // int -> QUANT8_SYMM_PER_CHANNEL map
12531 .quant8ChannelOperands = {},
12532 // int -> QUANT16_ASYMM map
12533 .quant16AsymmOperands = {},
12534 // int -> QUANT8_SYMM map
12535 .quant8SymmOperands = {},
12536 }
12537 },
12538 }, // End of an example
12539 };
12540 return examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input;
12541 };
12542
get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_2()12543 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_2() {
12544 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8_2 = {
12545 // Begin of an example
12546 {
12547 .operands = {
12548 //Input(s)
12549 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12550 // int -> Dimensions map
12551 .operandDimensions = {{0, {1, 2, 3, 3}}},
12552 // int -> FLOAT32 map
12553 .float32Operands = {},
12554 // int -> INT32 map
12555 .int32Operands = {},
12556 // int -> QUANT8_ASYMM map
12557 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
12558 // int -> QUANT16_SYMM map
12559 .quant16SymmOperands = {},
12560 // int -> FLOAT16 map
12561 .float16Operands = {},
12562 // int -> BOOL8 map
12563 .bool8Operands = {},
12564 // int -> QUANT8_SYMM_PER_CHANNEL map
12565 .quant8ChannelOperands = {},
12566 // int -> QUANT16_ASYMM map
12567 .quant16AsymmOperands = {},
12568 // int -> QUANT8_SYMM map
12569 .quant8SymmOperands = {},
12570 },
12571 //Output(s)
12572 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12573 // int -> Dimensions map
12574 .operandDimensions = {{0, {1, 2, 2, 2}}},
12575 // int -> FLOAT32 map
12576 .float32Operands = {},
12577 // int -> INT32 map
12578 .int32Operands = {},
12579 // int -> QUANT8_ASYMM map
12580 .quant8AsymmOperands = {{0, {140, 140, 140, 140, 80, 140, 125, 80}}},
12581 // int -> QUANT16_SYMM map
12582 .quant16SymmOperands = {},
12583 // int -> FLOAT16 map
12584 .float16Operands = {},
12585 // int -> BOOL8 map
12586 .bool8Operands = {},
12587 // int -> QUANT8_SYMM_PER_CHANNEL map
12588 .quant8ChannelOperands = {},
12589 // int -> QUANT16_ASYMM map
12590 .quant16AsymmOperands = {},
12591 // int -> QUANT8_SYMM map
12592 .quant8SymmOperands = {},
12593 }
12594 },
12595 }, // End of an example
12596 };
12597 return examples_dynamic_output_shape_nchw_relu6_channelQuant8_2;
12598 };
12599
get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2()12600 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2() {
12601 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2 = {
12602 // Begin of an example
12603 {
12604 .operands = {
12605 //Input(s)
12606 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12607 // int -> Dimensions map
12608 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12609 // int -> FLOAT32 map
12610 .float32Operands = {},
12611 // int -> INT32 map
12612 .int32Operands = {{2, {160, -268}}},
12613 // int -> QUANT8_ASYMM map
12614 .quant8AsymmOperands = {{0, {104, 112, 120, 124, 116, 108, 108, 112, 112, 108, 116, 124, 120, 112, 104, 112, 112, 112}}},
12615 // int -> QUANT16_SYMM map
12616 .quant16SymmOperands = {},
12617 // int -> FLOAT16 map
12618 .float16Operands = {},
12619 // int -> BOOL8 map
12620 .bool8Operands = {},
12621 // int -> QUANT8_SYMM_PER_CHANNEL map
12622 .quant8ChannelOperands = {{1, {4, 8, 8, 4, 8, 6, 4, 2}}},
12623 // int -> QUANT16_ASYMM map
12624 .quant16AsymmOperands = {},
12625 // int -> QUANT8_SYMM map
12626 .quant8SymmOperands = {},
12627 },
12628 //Output(s)
12629 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12630 // int -> Dimensions map
12631 .operandDimensions = {{0, {1, 2, 2, 2}}},
12632 // int -> FLOAT32 map
12633 .float32Operands = {},
12634 // int -> INT32 map
12635 .int32Operands = {},
12636 // int -> QUANT8_ASYMM map
12637 .quant8AsymmOperands = {{0, {140, 140, 140, 140, 80, 140, 125, 80}}},
12638 // int -> QUANT16_SYMM map
12639 .quant16SymmOperands = {},
12640 // int -> FLOAT16 map
12641 .float16Operands = {},
12642 // int -> BOOL8 map
12643 .bool8Operands = {},
12644 // int -> QUANT8_SYMM_PER_CHANNEL map
12645 .quant8ChannelOperands = {},
12646 // int -> QUANT16_ASYMM map
12647 .quant16AsymmOperands = {},
12648 // int -> QUANT8_SYMM map
12649 .quant8SymmOperands = {},
12650 }
12651 },
12652 }, // End of an example
12653 };
12654 return examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2;
12655 };
12656
get_examples_dynamic_output_shape_nchw_relu6_float16()12657 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_float16() {
12658 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_float16 = {
12659 // Begin of an example
12660 {
12661 .operands = {
12662 //Input(s)
12663 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12664 // int -> Dimensions map
12665 .operandDimensions = {{0, {1, 2, 3, 3}}},
12666 // int -> FLOAT32 map
12667 .float32Operands = {},
12668 // int -> INT32 map
12669 .int32Operands = {},
12670 // int -> QUANT8_ASYMM map
12671 .quant8AsymmOperands = {},
12672 // int -> QUANT16_SYMM map
12673 .quant16SymmOperands = {},
12674 // int -> FLOAT16 map
12675 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}},
12676 // int -> BOOL8 map
12677 .bool8Operands = {},
12678 // int -> QUANT8_SYMM_PER_CHANNEL map
12679 .quant8ChannelOperands = {},
12680 // int -> QUANT16_ASYMM map
12681 .quant16AsymmOperands = {},
12682 // int -> QUANT8_SYMM map
12683 .quant8SymmOperands = {},
12684 },
12685 //Output(s)
12686 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12687 // int -> Dimensions map
12688 .operandDimensions = {{0, {1, 2, 2, 2}}},
12689 // int -> FLOAT32 map
12690 .float32Operands = {},
12691 // int -> INT32 map
12692 .int32Operands = {},
12693 // int -> QUANT8_ASYMM map
12694 .quant8AsymmOperands = {},
12695 // int -> QUANT16_SYMM map
12696 .quant16SymmOperands = {},
12697 // int -> FLOAT16 map
12698 .float16Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
12699 // int -> BOOL8 map
12700 .bool8Operands = {},
12701 // int -> QUANT8_SYMM_PER_CHANNEL map
12702 .quant8ChannelOperands = {},
12703 // int -> QUANT16_ASYMM map
12704 .quant16AsymmOperands = {},
12705 // int -> QUANT8_SYMM map
12706 .quant8SymmOperands = {},
12707 }
12708 },
12709 }, // End of an example
12710 };
12711 return examples_dynamic_output_shape_nchw_relu6_float16;
12712 };
12713
get_examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input()12714 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input() {
12715 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input = {
12716 // Begin of an example
12717 {
12718 .operands = {
12719 //Input(s)
12720 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12721 // int -> Dimensions map
12722 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {2, 2, 2, 1}}, {2, {2}}},
12723 // int -> FLOAT32 map
12724 .float32Operands = {},
12725 // int -> INT32 map
12726 .int32Operands = {},
12727 // int -> QUANT8_ASYMM map
12728 .quant8AsymmOperands = {},
12729 // int -> QUANT16_SYMM map
12730 .quant16SymmOperands = {},
12731 // int -> FLOAT16 map
12732 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 6.0f, 4.0f, 2.0f, 2.0f, 3.0f, 3.0f, 2.0f, 4.0f, 6.0f, 5.0f, 3.0f, 1.0f, 3.0f, 3.0f, 3.0f}}, {1, {1.0f, 2.0f, 2.0f, 1.0f, 4.0f, 3.0f, 2.0f, 1.0f}}, {2, {10.0f, -33.5f}}},
12733 // int -> BOOL8 map
12734 .bool8Operands = {},
12735 // int -> QUANT8_SYMM_PER_CHANNEL map
12736 .quant8ChannelOperands = {},
12737 // int -> QUANT16_ASYMM map
12738 .quant16AsymmOperands = {},
12739 // int -> QUANT8_SYMM map
12740 .quant8SymmOperands = {},
12741 },
12742 //Output(s)
12743 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12744 // int -> Dimensions map
12745 .operandDimensions = {{0, {1, 2, 2, 2}}},
12746 // int -> FLOAT32 map
12747 .float32Operands = {},
12748 // int -> INT32 map
12749 .int32Operands = {},
12750 // int -> QUANT8_ASYMM map
12751 .quant8AsymmOperands = {},
12752 // int -> QUANT16_SYMM map
12753 .quant16SymmOperands = {},
12754 // int -> FLOAT16 map
12755 .float16Operands = {{0, {6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 6.0f, 4.5f, 0.0f}}},
12756 // int -> BOOL8 map
12757 .bool8Operands = {},
12758 // int -> QUANT8_SYMM_PER_CHANNEL map
12759 .quant8ChannelOperands = {},
12760 // int -> QUANT16_ASYMM map
12761 .quant16AsymmOperands = {},
12762 // int -> QUANT8_SYMM map
12763 .quant8SymmOperands = {},
12764 }
12765 },
12766 }, // End of an example
12767 };
12768 return examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input;
12769 };
12770
get_examples_large_nhwc()12771 std::vector<MixedTypedExample>& get_examples_large_nhwc() {
12772 static std::vector<MixedTypedExample> examples_large_nhwc = {
12773 // Begin of an example
12774 {
12775 .operands = {
12776 //Input(s)
12777 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12778 // int -> Dimensions map
12779 .operandDimensions = {{0, {1, 3, 2, 2}}},
12780 // int -> FLOAT32 map
12781 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}},
12782 // int -> INT32 map
12783 .int32Operands = {},
12784 // int -> QUANT8_ASYMM map
12785 .quant8AsymmOperands = {},
12786 // int -> QUANT16_SYMM map
12787 .quant16SymmOperands = {},
12788 // int -> FLOAT16 map
12789 .float16Operands = {},
12790 // int -> BOOL8 map
12791 .bool8Operands = {},
12792 // int -> QUANT8_SYMM_PER_CHANNEL map
12793 .quant8ChannelOperands = {},
12794 // int -> QUANT16_ASYMM map
12795 .quant16AsymmOperands = {},
12796 // int -> QUANT8_SYMM map
12797 .quant8SymmOperands = {},
12798 },
12799 //Output(s)
12800 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12801 // int -> Dimensions map
12802 .operandDimensions = {{0, {1, 3, 2, 2}}},
12803 // int -> FLOAT32 map
12804 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
12805 // int -> INT32 map
12806 .int32Operands = {},
12807 // int -> QUANT8_ASYMM map
12808 .quant8AsymmOperands = {},
12809 // int -> QUANT16_SYMM map
12810 .quant16SymmOperands = {},
12811 // int -> FLOAT16 map
12812 .float16Operands = {},
12813 // int -> BOOL8 map
12814 .bool8Operands = {},
12815 // int -> QUANT8_SYMM_PER_CHANNEL map
12816 .quant8ChannelOperands = {},
12817 // int -> QUANT16_ASYMM map
12818 .quant16AsymmOperands = {},
12819 // int -> QUANT8_SYMM map
12820 .quant8SymmOperands = {},
12821 }
12822 },
12823 }, // End of an example
12824 };
12825 return examples_large_nhwc;
12826 };
12827
get_examples_large_nhwc_weight_as_input()12828 std::vector<MixedTypedExample>& get_examples_large_nhwc_weight_as_input() {
12829 static std::vector<MixedTypedExample> examples_large_nhwc_weight_as_input = {
12830 // Begin of an example
12831 {
12832 .operands = {
12833 //Input(s)
12834 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12835 // int -> Dimensions map
12836 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
12837 // int -> FLOAT32 map
12838 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
12839 // int -> INT32 map
12840 .int32Operands = {},
12841 // int -> QUANT8_ASYMM map
12842 .quant8AsymmOperands = {},
12843 // int -> QUANT16_SYMM map
12844 .quant16SymmOperands = {},
12845 // int -> FLOAT16 map
12846 .float16Operands = {},
12847 // int -> BOOL8 map
12848 .bool8Operands = {},
12849 // int -> QUANT8_SYMM_PER_CHANNEL map
12850 .quant8ChannelOperands = {},
12851 // int -> QUANT16_ASYMM map
12852 .quant16AsymmOperands = {},
12853 // int -> QUANT8_SYMM map
12854 .quant8SymmOperands = {},
12855 },
12856 //Output(s)
12857 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12858 // int -> Dimensions map
12859 .operandDimensions = {{0, {1, 3, 2, 2}}},
12860 // int -> FLOAT32 map
12861 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
12862 // int -> INT32 map
12863 .int32Operands = {},
12864 // int -> QUANT8_ASYMM map
12865 .quant8AsymmOperands = {},
12866 // int -> QUANT16_SYMM map
12867 .quant16SymmOperands = {},
12868 // int -> FLOAT16 map
12869 .float16Operands = {},
12870 // int -> BOOL8 map
12871 .bool8Operands = {},
12872 // int -> QUANT8_SYMM_PER_CHANNEL map
12873 .quant8ChannelOperands = {},
12874 // int -> QUANT16_ASYMM map
12875 .quant16AsymmOperands = {},
12876 // int -> QUANT8_SYMM map
12877 .quant8SymmOperands = {},
12878 }
12879 },
12880 }, // End of an example
12881 };
12882 return examples_large_nhwc_weight_as_input;
12883 };
12884
get_examples_large_nhwc_relaxed()12885 std::vector<MixedTypedExample>& get_examples_large_nhwc_relaxed() {
12886 static std::vector<MixedTypedExample> examples_large_nhwc_relaxed = {
12887 // Begin of an example
12888 {
12889 .operands = {
12890 //Input(s)
12891 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12892 // int -> Dimensions map
12893 .operandDimensions = {{0, {1, 3, 2, 2}}},
12894 // int -> FLOAT32 map
12895 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}},
12896 // int -> INT32 map
12897 .int32Operands = {},
12898 // int -> QUANT8_ASYMM map
12899 .quant8AsymmOperands = {},
12900 // int -> QUANT16_SYMM map
12901 .quant16SymmOperands = {},
12902 // int -> FLOAT16 map
12903 .float16Operands = {},
12904 // int -> BOOL8 map
12905 .bool8Operands = {},
12906 // int -> QUANT8_SYMM_PER_CHANNEL map
12907 .quant8ChannelOperands = {},
12908 // int -> QUANT16_ASYMM map
12909 .quant16AsymmOperands = {},
12910 // int -> QUANT8_SYMM map
12911 .quant8SymmOperands = {},
12912 },
12913 //Output(s)
12914 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12915 // int -> Dimensions map
12916 .operandDimensions = {{0, {1, 3, 2, 2}}},
12917 // int -> FLOAT32 map
12918 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
12919 // int -> INT32 map
12920 .int32Operands = {},
12921 // int -> QUANT8_ASYMM map
12922 .quant8AsymmOperands = {},
12923 // int -> QUANT16_SYMM map
12924 .quant16SymmOperands = {},
12925 // int -> FLOAT16 map
12926 .float16Operands = {},
12927 // int -> BOOL8 map
12928 .bool8Operands = {},
12929 // int -> QUANT8_SYMM_PER_CHANNEL map
12930 .quant8ChannelOperands = {},
12931 // int -> QUANT16_ASYMM map
12932 .quant16AsymmOperands = {},
12933 // int -> QUANT8_SYMM map
12934 .quant8SymmOperands = {},
12935 }
12936 },
12937 }, // End of an example
12938 };
12939 return examples_large_nhwc_relaxed;
12940 };
12941
get_examples_large_nhwc_relaxed_weight_as_input()12942 std::vector<MixedTypedExample>& get_examples_large_nhwc_relaxed_weight_as_input() {
12943 static std::vector<MixedTypedExample> examples_large_nhwc_relaxed_weight_as_input = {
12944 // Begin of an example
12945 {
12946 .operands = {
12947 //Input(s)
12948 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12949 // int -> Dimensions map
12950 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
12951 // int -> FLOAT32 map
12952 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
12953 // int -> INT32 map
12954 .int32Operands = {},
12955 // int -> QUANT8_ASYMM map
12956 .quant8AsymmOperands = {},
12957 // int -> QUANT16_SYMM map
12958 .quant16SymmOperands = {},
12959 // int -> FLOAT16 map
12960 .float16Operands = {},
12961 // int -> BOOL8 map
12962 .bool8Operands = {},
12963 // int -> QUANT8_SYMM_PER_CHANNEL map
12964 .quant8ChannelOperands = {},
12965 // int -> QUANT16_ASYMM map
12966 .quant16AsymmOperands = {},
12967 // int -> QUANT8_SYMM map
12968 .quant8SymmOperands = {},
12969 },
12970 //Output(s)
12971 { // See tools/test_generator/include/TestHarness.h:MixedTyped
12972 // int -> Dimensions map
12973 .operandDimensions = {{0, {1, 3, 2, 2}}},
12974 // int -> FLOAT32 map
12975 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
12976 // int -> INT32 map
12977 .int32Operands = {},
12978 // int -> QUANT8_ASYMM map
12979 .quant8AsymmOperands = {},
12980 // int -> QUANT16_SYMM map
12981 .quant16SymmOperands = {},
12982 // int -> FLOAT16 map
12983 .float16Operands = {},
12984 // int -> BOOL8 map
12985 .bool8Operands = {},
12986 // int -> QUANT8_SYMM_PER_CHANNEL map
12987 .quant8ChannelOperands = {},
12988 // int -> QUANT16_ASYMM map
12989 .quant16AsymmOperands = {},
12990 // int -> QUANT8_SYMM map
12991 .quant8SymmOperands = {},
12992 }
12993 },
12994 }, // End of an example
12995 };
12996 return examples_large_nhwc_relaxed_weight_as_input;
12997 };
12998
get_examples_large_nhwc_quant8()12999 std::vector<MixedTypedExample>& get_examples_large_nhwc_quant8() {
13000 static std::vector<MixedTypedExample> examples_large_nhwc_quant8 = {
13001 // Begin of an example
13002 {
13003 .operands = {
13004 //Input(s)
13005 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13006 // int -> Dimensions map
13007 .operandDimensions = {{0, {1, 3, 2, 2}}},
13008 // int -> FLOAT32 map
13009 .float32Operands = {},
13010 // int -> INT32 map
13011 .int32Operands = {},
13012 // int -> QUANT8_ASYMM map
13013 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}},
13014 // int -> QUANT16_SYMM map
13015 .quant16SymmOperands = {},
13016 // int -> FLOAT16 map
13017 .float16Operands = {},
13018 // int -> BOOL8 map
13019 .bool8Operands = {},
13020 // int -> QUANT8_SYMM_PER_CHANNEL map
13021 .quant8ChannelOperands = {},
13022 // int -> QUANT16_ASYMM map
13023 .quant16AsymmOperands = {},
13024 // int -> QUANT8_SYMM map
13025 .quant8SymmOperands = {},
13026 },
13027 //Output(s)
13028 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13029 // int -> Dimensions map
13030 .operandDimensions = {{0, {1, 3, 2, 2}}},
13031 // int -> FLOAT32 map
13032 .float32Operands = {},
13033 // int -> INT32 map
13034 .int32Operands = {},
13035 // int -> QUANT8_ASYMM map
13036 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
13037 // int -> QUANT16_SYMM map
13038 .quant16SymmOperands = {},
13039 // int -> FLOAT16 map
13040 .float16Operands = {},
13041 // int -> BOOL8 map
13042 .bool8Operands = {},
13043 // int -> QUANT8_SYMM_PER_CHANNEL map
13044 .quant8ChannelOperands = {},
13045 // int -> QUANT16_ASYMM map
13046 .quant16AsymmOperands = {},
13047 // int -> QUANT8_SYMM map
13048 .quant8SymmOperands = {},
13049 }
13050 },
13051 }, // End of an example
13052 };
13053 return examples_large_nhwc_quant8;
13054 };
13055
get_examples_large_nhwc_quant8_weight_as_input()13056 std::vector<MixedTypedExample>& get_examples_large_nhwc_quant8_weight_as_input() {
13057 static std::vector<MixedTypedExample> examples_large_nhwc_quant8_weight_as_input = {
13058 // Begin of an example
13059 {
13060 .operands = {
13061 //Input(s)
13062 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13063 // int -> Dimensions map
13064 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13065 // int -> FLOAT32 map
13066 .float32Operands = {},
13067 // int -> INT32 map
13068 .int32Operands = {{2, {2000, -4000}}},
13069 // int -> QUANT8_ASYMM map
13070 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}, {1, {100, 20, 1, 200, 10, 2, 200, 30, 1, 100, 20, 3}}},
13071 // int -> QUANT16_SYMM map
13072 .quant16SymmOperands = {},
13073 // int -> FLOAT16 map
13074 .float16Operands = {},
13075 // int -> BOOL8 map
13076 .bool8Operands = {},
13077 // int -> QUANT8_SYMM_PER_CHANNEL map
13078 .quant8ChannelOperands = {},
13079 // int -> QUANT16_ASYMM map
13080 .quant16AsymmOperands = {},
13081 // int -> QUANT8_SYMM map
13082 .quant8SymmOperands = {},
13083 },
13084 //Output(s)
13085 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13086 // int -> Dimensions map
13087 .operandDimensions = {{0, {1, 3, 2, 2}}},
13088 // int -> FLOAT32 map
13089 .float32Operands = {},
13090 // int -> INT32 map
13091 .int32Operands = {},
13092 // int -> QUANT8_ASYMM map
13093 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
13094 // int -> QUANT16_SYMM map
13095 .quant16SymmOperands = {},
13096 // int -> FLOAT16 map
13097 .float16Operands = {},
13098 // int -> BOOL8 map
13099 .bool8Operands = {},
13100 // int -> QUANT8_SYMM_PER_CHANNEL map
13101 .quant8ChannelOperands = {},
13102 // int -> QUANT16_ASYMM map
13103 .quant16AsymmOperands = {},
13104 // int -> QUANT8_SYMM map
13105 .quant8SymmOperands = {},
13106 }
13107 },
13108 }, // End of an example
13109 };
13110 return examples_large_nhwc_quant8_weight_as_input;
13111 };
13112
get_examples_large_nhwc_channelQuant8()13113 std::vector<MixedTypedExample>& get_examples_large_nhwc_channelQuant8() {
13114 static std::vector<MixedTypedExample> examples_large_nhwc_channelQuant8 = {
13115 // Begin of an example
13116 {
13117 .operands = {
13118 //Input(s)
13119 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13120 // int -> Dimensions map
13121 .operandDimensions = {{0, {1, 3, 2, 2}}},
13122 // int -> FLOAT32 map
13123 .float32Operands = {},
13124 // int -> INT32 map
13125 .int32Operands = {},
13126 // int -> QUANT8_ASYMM map
13127 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}},
13128 // int -> QUANT16_SYMM map
13129 .quant16SymmOperands = {},
13130 // int -> FLOAT16 map
13131 .float16Operands = {},
13132 // int -> BOOL8 map
13133 .bool8Operands = {},
13134 // int -> QUANT8_SYMM_PER_CHANNEL map
13135 .quant8ChannelOperands = {},
13136 // int -> QUANT16_ASYMM map
13137 .quant16AsymmOperands = {},
13138 // int -> QUANT8_SYMM map
13139 .quant8SymmOperands = {},
13140 },
13141 //Output(s)
13142 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13143 // int -> Dimensions map
13144 .operandDimensions = {{0, {1, 3, 2, 2}}},
13145 // int -> FLOAT32 map
13146 .float32Operands = {},
13147 // int -> INT32 map
13148 .int32Operands = {},
13149 // int -> QUANT8_ASYMM map
13150 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
13151 // int -> QUANT16_SYMM map
13152 .quant16SymmOperands = {},
13153 // int -> FLOAT16 map
13154 .float16Operands = {},
13155 // int -> BOOL8 map
13156 .bool8Operands = {},
13157 // int -> QUANT8_SYMM_PER_CHANNEL map
13158 .quant8ChannelOperands = {},
13159 // int -> QUANT16_ASYMM map
13160 .quant16AsymmOperands = {},
13161 // int -> QUANT8_SYMM map
13162 .quant8SymmOperands = {},
13163 }
13164 },
13165 }, // End of an example
13166 };
13167 return examples_large_nhwc_channelQuant8;
13168 };
13169
get_examples_large_nhwc_channelQuant8_weight_as_input()13170 std::vector<MixedTypedExample>& get_examples_large_nhwc_channelQuant8_weight_as_input() {
13171 static std::vector<MixedTypedExample> examples_large_nhwc_channelQuant8_weight_as_input = {
13172 // Begin of an example
13173 {
13174 .operands = {
13175 //Input(s)
13176 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13177 // int -> Dimensions map
13178 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13179 // int -> FLOAT32 map
13180 .float32Operands = {},
13181 // int -> INT32 map
13182 .int32Operands = {{2, {1000, -1600}}},
13183 // int -> QUANT8_ASYMM map
13184 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}},
13185 // int -> QUANT16_SYMM map
13186 .quant16SymmOperands = {},
13187 // int -> FLOAT16 map
13188 .float16Operands = {},
13189 // int -> BOOL8 map
13190 .bool8Operands = {},
13191 // int -> QUANT8_SYMM_PER_CHANNEL map
13192 .quant8ChannelOperands = {{1, {50, 10, 0, 100, 5, 1, 80, 12, 0, 40, 8, 1}}},
13193 // int -> QUANT16_ASYMM map
13194 .quant16AsymmOperands = {},
13195 // int -> QUANT8_SYMM map
13196 .quant8SymmOperands = {},
13197 },
13198 //Output(s)
13199 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13200 // int -> Dimensions map
13201 .operandDimensions = {{0, {1, 3, 2, 2}}},
13202 // int -> FLOAT32 map
13203 .float32Operands = {},
13204 // int -> INT32 map
13205 .int32Operands = {},
13206 // int -> QUANT8_ASYMM map
13207 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
13208 // int -> QUANT16_SYMM map
13209 .quant16SymmOperands = {},
13210 // int -> FLOAT16 map
13211 .float16Operands = {},
13212 // int -> BOOL8 map
13213 .bool8Operands = {},
13214 // int -> QUANT8_SYMM_PER_CHANNEL map
13215 .quant8ChannelOperands = {},
13216 // int -> QUANT16_ASYMM map
13217 .quant16AsymmOperands = {},
13218 // int -> QUANT8_SYMM map
13219 .quant8SymmOperands = {},
13220 }
13221 },
13222 }, // End of an example
13223 };
13224 return examples_large_nhwc_channelQuant8_weight_as_input;
13225 };
13226
get_examples_large_nhwc_float16()13227 std::vector<MixedTypedExample>& get_examples_large_nhwc_float16() {
13228 static std::vector<MixedTypedExample> examples_large_nhwc_float16 = {
13229 // Begin of an example
13230 {
13231 .operands = {
13232 //Input(s)
13233 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13234 // int -> Dimensions map
13235 .operandDimensions = {{0, {1, 3, 2, 2}}},
13236 // int -> FLOAT32 map
13237 .float32Operands = {},
13238 // int -> INT32 map
13239 .int32Operands = {},
13240 // int -> QUANT8_ASYMM map
13241 .quant8AsymmOperands = {},
13242 // int -> QUANT16_SYMM map
13243 .quant16SymmOperands = {},
13244 // int -> FLOAT16 map
13245 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}},
13246 // int -> BOOL8 map
13247 .bool8Operands = {},
13248 // int -> QUANT8_SYMM_PER_CHANNEL map
13249 .quant8ChannelOperands = {},
13250 // int -> QUANT16_ASYMM map
13251 .quant16AsymmOperands = {},
13252 // int -> QUANT8_SYMM map
13253 .quant8SymmOperands = {},
13254 },
13255 //Output(s)
13256 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13257 // int -> Dimensions map
13258 .operandDimensions = {{0, {1, 3, 2, 2}}},
13259 // int -> FLOAT32 map
13260 .float32Operands = {},
13261 // int -> INT32 map
13262 .int32Operands = {},
13263 // int -> QUANT8_ASYMM map
13264 .quant8AsymmOperands = {},
13265 // int -> QUANT16_SYMM map
13266 .quant16SymmOperands = {},
13267 // int -> FLOAT16 map
13268 .float16Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
13269 // int -> BOOL8 map
13270 .bool8Operands = {},
13271 // int -> QUANT8_SYMM_PER_CHANNEL map
13272 .quant8ChannelOperands = {},
13273 // int -> QUANT16_ASYMM map
13274 .quant16AsymmOperands = {},
13275 // int -> QUANT8_SYMM map
13276 .quant8SymmOperands = {},
13277 }
13278 },
13279 }, // End of an example
13280 };
13281 return examples_large_nhwc_float16;
13282 };
13283
get_examples_large_nhwc_float16_weight_as_input()13284 std::vector<MixedTypedExample>& get_examples_large_nhwc_float16_weight_as_input() {
13285 static std::vector<MixedTypedExample> examples_large_nhwc_float16_weight_as_input = {
13286 // Begin of an example
13287 {
13288 .operands = {
13289 //Input(s)
13290 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13291 // int -> Dimensions map
13292 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13293 // int -> FLOAT32 map
13294 .float32Operands = {},
13295 // int -> INT32 map
13296 .int32Operands = {},
13297 // int -> QUANT8_ASYMM map
13298 .quant8AsymmOperands = {},
13299 // int -> QUANT16_SYMM map
13300 .quant16SymmOperands = {},
13301 // int -> FLOAT16 map
13302 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
13303 // int -> BOOL8 map
13304 .bool8Operands = {},
13305 // int -> QUANT8_SYMM_PER_CHANNEL map
13306 .quant8ChannelOperands = {},
13307 // int -> QUANT16_ASYMM map
13308 .quant16AsymmOperands = {},
13309 // int -> QUANT8_SYMM map
13310 .quant8SymmOperands = {},
13311 },
13312 //Output(s)
13313 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13314 // int -> Dimensions map
13315 .operandDimensions = {{0, {1, 3, 2, 2}}},
13316 // int -> FLOAT32 map
13317 .float32Operands = {},
13318 // int -> INT32 map
13319 .int32Operands = {},
13320 // int -> QUANT8_ASYMM map
13321 .quant8AsymmOperands = {},
13322 // int -> QUANT16_SYMM map
13323 .quant16SymmOperands = {},
13324 // int -> FLOAT16 map
13325 .float16Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
13326 // int -> BOOL8 map
13327 .bool8Operands = {},
13328 // int -> QUANT8_SYMM_PER_CHANNEL map
13329 .quant8ChannelOperands = {},
13330 // int -> QUANT16_ASYMM map
13331 .quant16AsymmOperands = {},
13332 // int -> QUANT8_SYMM map
13333 .quant8SymmOperands = {},
13334 }
13335 },
13336 }, // End of an example
13337 };
13338 return examples_large_nhwc_float16_weight_as_input;
13339 };
13340
get_examples_large_nchw()13341 std::vector<MixedTypedExample>& get_examples_large_nchw() {
13342 static std::vector<MixedTypedExample> examples_large_nchw = {
13343 // Begin of an example
13344 {
13345 .operands = {
13346 //Input(s)
13347 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13348 // int -> Dimensions map
13349 .operandDimensions = {{0, {1, 2, 3, 2}}},
13350 // int -> FLOAT32 map
13351 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}},
13352 // int -> INT32 map
13353 .int32Operands = {},
13354 // int -> QUANT8_ASYMM map
13355 .quant8AsymmOperands = {},
13356 // int -> QUANT16_SYMM map
13357 .quant16SymmOperands = {},
13358 // int -> FLOAT16 map
13359 .float16Operands = {},
13360 // int -> BOOL8 map
13361 .bool8Operands = {},
13362 // int -> QUANT8_SYMM_PER_CHANNEL map
13363 .quant8ChannelOperands = {},
13364 // int -> QUANT16_ASYMM map
13365 .quant16AsymmOperands = {},
13366 // int -> QUANT8_SYMM map
13367 .quant8SymmOperands = {},
13368 },
13369 //Output(s)
13370 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13371 // int -> Dimensions map
13372 .operandDimensions = {{0, {1, 2, 3, 2}}},
13373 // int -> FLOAT32 map
13374 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
13375 // int -> INT32 map
13376 .int32Operands = {},
13377 // int -> QUANT8_ASYMM map
13378 .quant8AsymmOperands = {},
13379 // int -> QUANT16_SYMM map
13380 .quant16SymmOperands = {},
13381 // int -> FLOAT16 map
13382 .float16Operands = {},
13383 // int -> BOOL8 map
13384 .bool8Operands = {},
13385 // int -> QUANT8_SYMM_PER_CHANNEL map
13386 .quant8ChannelOperands = {},
13387 // int -> QUANT16_ASYMM map
13388 .quant16AsymmOperands = {},
13389 // int -> QUANT8_SYMM map
13390 .quant8SymmOperands = {},
13391 }
13392 },
13393 }, // End of an example
13394 };
13395 return examples_large_nchw;
13396 };
13397
get_examples_large_nchw_weight_as_input()13398 std::vector<MixedTypedExample>& get_examples_large_nchw_weight_as_input() {
13399 static std::vector<MixedTypedExample> examples_large_nchw_weight_as_input = {
13400 // Begin of an example
13401 {
13402 .operands = {
13403 //Input(s)
13404 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13405 // int -> Dimensions map
13406 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13407 // int -> FLOAT32 map
13408 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
13409 // int -> INT32 map
13410 .int32Operands = {},
13411 // int -> QUANT8_ASYMM map
13412 .quant8AsymmOperands = {},
13413 // int -> QUANT16_SYMM map
13414 .quant16SymmOperands = {},
13415 // int -> FLOAT16 map
13416 .float16Operands = {},
13417 // int -> BOOL8 map
13418 .bool8Operands = {},
13419 // int -> QUANT8_SYMM_PER_CHANNEL map
13420 .quant8ChannelOperands = {},
13421 // int -> QUANT16_ASYMM map
13422 .quant16AsymmOperands = {},
13423 // int -> QUANT8_SYMM map
13424 .quant8SymmOperands = {},
13425 },
13426 //Output(s)
13427 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13428 // int -> Dimensions map
13429 .operandDimensions = {{0, {1, 2, 3, 2}}},
13430 // int -> FLOAT32 map
13431 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
13432 // int -> INT32 map
13433 .int32Operands = {},
13434 // int -> QUANT8_ASYMM map
13435 .quant8AsymmOperands = {},
13436 // int -> QUANT16_SYMM map
13437 .quant16SymmOperands = {},
13438 // int -> FLOAT16 map
13439 .float16Operands = {},
13440 // int -> BOOL8 map
13441 .bool8Operands = {},
13442 // int -> QUANT8_SYMM_PER_CHANNEL map
13443 .quant8ChannelOperands = {},
13444 // int -> QUANT16_ASYMM map
13445 .quant16AsymmOperands = {},
13446 // int -> QUANT8_SYMM map
13447 .quant8SymmOperands = {},
13448 }
13449 },
13450 }, // End of an example
13451 };
13452 return examples_large_nchw_weight_as_input;
13453 };
13454
get_examples_large_nchw_relaxed()13455 std::vector<MixedTypedExample>& get_examples_large_nchw_relaxed() {
13456 static std::vector<MixedTypedExample> examples_large_nchw_relaxed = {
13457 // Begin of an example
13458 {
13459 .operands = {
13460 //Input(s)
13461 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13462 // int -> Dimensions map
13463 .operandDimensions = {{0, {1, 2, 3, 2}}},
13464 // int -> FLOAT32 map
13465 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}},
13466 // int -> INT32 map
13467 .int32Operands = {},
13468 // int -> QUANT8_ASYMM map
13469 .quant8AsymmOperands = {},
13470 // int -> QUANT16_SYMM map
13471 .quant16SymmOperands = {},
13472 // int -> FLOAT16 map
13473 .float16Operands = {},
13474 // int -> BOOL8 map
13475 .bool8Operands = {},
13476 // int -> QUANT8_SYMM_PER_CHANNEL map
13477 .quant8ChannelOperands = {},
13478 // int -> QUANT16_ASYMM map
13479 .quant16AsymmOperands = {},
13480 // int -> QUANT8_SYMM map
13481 .quant8SymmOperands = {},
13482 },
13483 //Output(s)
13484 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13485 // int -> Dimensions map
13486 .operandDimensions = {{0, {1, 2, 3, 2}}},
13487 // int -> FLOAT32 map
13488 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
13489 // int -> INT32 map
13490 .int32Operands = {},
13491 // int -> QUANT8_ASYMM map
13492 .quant8AsymmOperands = {},
13493 // int -> QUANT16_SYMM map
13494 .quant16SymmOperands = {},
13495 // int -> FLOAT16 map
13496 .float16Operands = {},
13497 // int -> BOOL8 map
13498 .bool8Operands = {},
13499 // int -> QUANT8_SYMM_PER_CHANNEL map
13500 .quant8ChannelOperands = {},
13501 // int -> QUANT16_ASYMM map
13502 .quant16AsymmOperands = {},
13503 // int -> QUANT8_SYMM map
13504 .quant8SymmOperands = {},
13505 }
13506 },
13507 }, // End of an example
13508 };
13509 return examples_large_nchw_relaxed;
13510 };
13511
get_examples_large_nchw_relaxed_weight_as_input()13512 std::vector<MixedTypedExample>& get_examples_large_nchw_relaxed_weight_as_input() {
13513 static std::vector<MixedTypedExample> examples_large_nchw_relaxed_weight_as_input = {
13514 // Begin of an example
13515 {
13516 .operands = {
13517 //Input(s)
13518 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13519 // int -> Dimensions map
13520 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13521 // int -> FLOAT32 map
13522 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
13523 // int -> INT32 map
13524 .int32Operands = {},
13525 // int -> QUANT8_ASYMM map
13526 .quant8AsymmOperands = {},
13527 // int -> QUANT16_SYMM map
13528 .quant16SymmOperands = {},
13529 // int -> FLOAT16 map
13530 .float16Operands = {},
13531 // int -> BOOL8 map
13532 .bool8Operands = {},
13533 // int -> QUANT8_SYMM_PER_CHANNEL map
13534 .quant8ChannelOperands = {},
13535 // int -> QUANT16_ASYMM map
13536 .quant16AsymmOperands = {},
13537 // int -> QUANT8_SYMM map
13538 .quant8SymmOperands = {},
13539 },
13540 //Output(s)
13541 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13542 // int -> Dimensions map
13543 .operandDimensions = {{0, {1, 2, 3, 2}}},
13544 // int -> FLOAT32 map
13545 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
13546 // int -> INT32 map
13547 .int32Operands = {},
13548 // int -> QUANT8_ASYMM map
13549 .quant8AsymmOperands = {},
13550 // int -> QUANT16_SYMM map
13551 .quant16SymmOperands = {},
13552 // int -> FLOAT16 map
13553 .float16Operands = {},
13554 // int -> BOOL8 map
13555 .bool8Operands = {},
13556 // int -> QUANT8_SYMM_PER_CHANNEL map
13557 .quant8ChannelOperands = {},
13558 // int -> QUANT16_ASYMM map
13559 .quant16AsymmOperands = {},
13560 // int -> QUANT8_SYMM map
13561 .quant8SymmOperands = {},
13562 }
13563 },
13564 }, // End of an example
13565 };
13566 return examples_large_nchw_relaxed_weight_as_input;
13567 };
13568
get_examples_large_nchw_quant8()13569 std::vector<MixedTypedExample>& get_examples_large_nchw_quant8() {
13570 static std::vector<MixedTypedExample> examples_large_nchw_quant8 = {
13571 // Begin of an example
13572 {
13573 .operands = {
13574 //Input(s)
13575 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13576 // int -> Dimensions map
13577 .operandDimensions = {{0, {1, 2, 3, 2}}},
13578 // int -> FLOAT32 map
13579 .float32Operands = {},
13580 // int -> INT32 map
13581 .int32Operands = {},
13582 // int -> QUANT8_ASYMM map
13583 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}},
13584 // int -> QUANT16_SYMM map
13585 .quant16SymmOperands = {},
13586 // int -> FLOAT16 map
13587 .float16Operands = {},
13588 // int -> BOOL8 map
13589 .bool8Operands = {},
13590 // int -> QUANT8_SYMM_PER_CHANNEL map
13591 .quant8ChannelOperands = {},
13592 // int -> QUANT16_ASYMM map
13593 .quant16AsymmOperands = {},
13594 // int -> QUANT8_SYMM map
13595 .quant8SymmOperands = {},
13596 },
13597 //Output(s)
13598 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13599 // int -> Dimensions map
13600 .operandDimensions = {{0, {1, 2, 3, 2}}},
13601 // int -> FLOAT32 map
13602 .float32Operands = {},
13603 // int -> INT32 map
13604 .int32Operands = {},
13605 // int -> QUANT8_ASYMM map
13606 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
13607 // int -> QUANT16_SYMM map
13608 .quant16SymmOperands = {},
13609 // int -> FLOAT16 map
13610 .float16Operands = {},
13611 // int -> BOOL8 map
13612 .bool8Operands = {},
13613 // int -> QUANT8_SYMM_PER_CHANNEL map
13614 .quant8ChannelOperands = {},
13615 // int -> QUANT16_ASYMM map
13616 .quant16AsymmOperands = {},
13617 // int -> QUANT8_SYMM map
13618 .quant8SymmOperands = {},
13619 }
13620 },
13621 }, // End of an example
13622 };
13623 return examples_large_nchw_quant8;
13624 };
13625
get_examples_large_nchw_quant8_weight_as_input()13626 std::vector<MixedTypedExample>& get_examples_large_nchw_quant8_weight_as_input() {
13627 static std::vector<MixedTypedExample> examples_large_nchw_quant8_weight_as_input = {
13628 // Begin of an example
13629 {
13630 .operands = {
13631 //Input(s)
13632 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13633 // int -> Dimensions map
13634 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13635 // int -> FLOAT32 map
13636 .float32Operands = {},
13637 // int -> INT32 map
13638 .int32Operands = {{2, {2000, -4000}}},
13639 // int -> QUANT8_ASYMM map
13640 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}, {1, {100, 20, 1, 200, 10, 2, 200, 30, 1, 100, 20, 3}}},
13641 // int -> QUANT16_SYMM map
13642 .quant16SymmOperands = {},
13643 // int -> FLOAT16 map
13644 .float16Operands = {},
13645 // int -> BOOL8 map
13646 .bool8Operands = {},
13647 // int -> QUANT8_SYMM_PER_CHANNEL map
13648 .quant8ChannelOperands = {},
13649 // int -> QUANT16_ASYMM map
13650 .quant16AsymmOperands = {},
13651 // int -> QUANT8_SYMM map
13652 .quant8SymmOperands = {},
13653 },
13654 //Output(s)
13655 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13656 // int -> Dimensions map
13657 .operandDimensions = {{0, {1, 2, 3, 2}}},
13658 // int -> FLOAT32 map
13659 .float32Operands = {},
13660 // int -> INT32 map
13661 .int32Operands = {},
13662 // int -> QUANT8_ASYMM map
13663 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
13664 // int -> QUANT16_SYMM map
13665 .quant16SymmOperands = {},
13666 // int -> FLOAT16 map
13667 .float16Operands = {},
13668 // int -> BOOL8 map
13669 .bool8Operands = {},
13670 // int -> QUANT8_SYMM_PER_CHANNEL map
13671 .quant8ChannelOperands = {},
13672 // int -> QUANT16_ASYMM map
13673 .quant16AsymmOperands = {},
13674 // int -> QUANT8_SYMM map
13675 .quant8SymmOperands = {},
13676 }
13677 },
13678 }, // End of an example
13679 };
13680 return examples_large_nchw_quant8_weight_as_input;
13681 };
13682
get_examples_large_nchw_channelQuant8()13683 std::vector<MixedTypedExample>& get_examples_large_nchw_channelQuant8() {
13684 static std::vector<MixedTypedExample> examples_large_nchw_channelQuant8 = {
13685 // Begin of an example
13686 {
13687 .operands = {
13688 //Input(s)
13689 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13690 // int -> Dimensions map
13691 .operandDimensions = {{0, {1, 2, 3, 2}}},
13692 // int -> FLOAT32 map
13693 .float32Operands = {},
13694 // int -> INT32 map
13695 .int32Operands = {},
13696 // int -> QUANT8_ASYMM map
13697 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}},
13698 // int -> QUANT16_SYMM map
13699 .quant16SymmOperands = {},
13700 // int -> FLOAT16 map
13701 .float16Operands = {},
13702 // int -> BOOL8 map
13703 .bool8Operands = {},
13704 // int -> QUANT8_SYMM_PER_CHANNEL map
13705 .quant8ChannelOperands = {},
13706 // int -> QUANT16_ASYMM map
13707 .quant16AsymmOperands = {},
13708 // int -> QUANT8_SYMM map
13709 .quant8SymmOperands = {},
13710 },
13711 //Output(s)
13712 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13713 // int -> Dimensions map
13714 .operandDimensions = {{0, {1, 2, 3, 2}}},
13715 // int -> FLOAT32 map
13716 .float32Operands = {},
13717 // int -> INT32 map
13718 .int32Operands = {},
13719 // int -> QUANT8_ASYMM map
13720 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
13721 // int -> QUANT16_SYMM map
13722 .quant16SymmOperands = {},
13723 // int -> FLOAT16 map
13724 .float16Operands = {},
13725 // int -> BOOL8 map
13726 .bool8Operands = {},
13727 // int -> QUANT8_SYMM_PER_CHANNEL map
13728 .quant8ChannelOperands = {},
13729 // int -> QUANT16_ASYMM map
13730 .quant16AsymmOperands = {},
13731 // int -> QUANT8_SYMM map
13732 .quant8SymmOperands = {},
13733 }
13734 },
13735 }, // End of an example
13736 };
13737 return examples_large_nchw_channelQuant8;
13738 };
13739
get_examples_large_nchw_channelQuant8_weight_as_input()13740 std::vector<MixedTypedExample>& get_examples_large_nchw_channelQuant8_weight_as_input() {
13741 static std::vector<MixedTypedExample> examples_large_nchw_channelQuant8_weight_as_input = {
13742 // Begin of an example
13743 {
13744 .operands = {
13745 //Input(s)
13746 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13747 // int -> Dimensions map
13748 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13749 // int -> FLOAT32 map
13750 .float32Operands = {},
13751 // int -> INT32 map
13752 .int32Operands = {{2, {1000, -1600}}},
13753 // int -> QUANT8_ASYMM map
13754 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}},
13755 // int -> QUANT16_SYMM map
13756 .quant16SymmOperands = {},
13757 // int -> FLOAT16 map
13758 .float16Operands = {},
13759 // int -> BOOL8 map
13760 .bool8Operands = {},
13761 // int -> QUANT8_SYMM_PER_CHANNEL map
13762 .quant8ChannelOperands = {{1, {50, 10, 0, 100, 5, 1, 80, 12, 0, 40, 8, 1}}},
13763 // int -> QUANT16_ASYMM map
13764 .quant16AsymmOperands = {},
13765 // int -> QUANT8_SYMM map
13766 .quant8SymmOperands = {},
13767 },
13768 //Output(s)
13769 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13770 // int -> Dimensions map
13771 .operandDimensions = {{0, {1, 2, 3, 2}}},
13772 // int -> FLOAT32 map
13773 .float32Operands = {},
13774 // int -> INT32 map
13775 .int32Operands = {},
13776 // int -> QUANT8_ASYMM map
13777 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
13778 // int -> QUANT16_SYMM map
13779 .quant16SymmOperands = {},
13780 // int -> FLOAT16 map
13781 .float16Operands = {},
13782 // int -> BOOL8 map
13783 .bool8Operands = {},
13784 // int -> QUANT8_SYMM_PER_CHANNEL map
13785 .quant8ChannelOperands = {},
13786 // int -> QUANT16_ASYMM map
13787 .quant16AsymmOperands = {},
13788 // int -> QUANT8_SYMM map
13789 .quant8SymmOperands = {},
13790 }
13791 },
13792 }, // End of an example
13793 };
13794 return examples_large_nchw_channelQuant8_weight_as_input;
13795 };
13796
get_examples_large_nchw_float16()13797 std::vector<MixedTypedExample>& get_examples_large_nchw_float16() {
13798 static std::vector<MixedTypedExample> examples_large_nchw_float16 = {
13799 // Begin of an example
13800 {
13801 .operands = {
13802 //Input(s)
13803 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13804 // int -> Dimensions map
13805 .operandDimensions = {{0, {1, 2, 3, 2}}},
13806 // int -> FLOAT32 map
13807 .float32Operands = {},
13808 // int -> INT32 map
13809 .int32Operands = {},
13810 // int -> QUANT8_ASYMM map
13811 .quant8AsymmOperands = {},
13812 // int -> QUANT16_SYMM map
13813 .quant16SymmOperands = {},
13814 // int -> FLOAT16 map
13815 .float16Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}},
13816 // int -> BOOL8 map
13817 .bool8Operands = {},
13818 // int -> QUANT8_SYMM_PER_CHANNEL map
13819 .quant8ChannelOperands = {},
13820 // int -> QUANT16_ASYMM map
13821 .quant16AsymmOperands = {},
13822 // int -> QUANT8_SYMM map
13823 .quant8SymmOperands = {},
13824 },
13825 //Output(s)
13826 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13827 // int -> Dimensions map
13828 .operandDimensions = {{0, {1, 2, 3, 2}}},
13829 // int -> FLOAT32 map
13830 .float32Operands = {},
13831 // int -> INT32 map
13832 .int32Operands = {},
13833 // int -> QUANT8_ASYMM map
13834 .quant8AsymmOperands = {},
13835 // int -> QUANT16_SYMM map
13836 .quant16SymmOperands = {},
13837 // int -> FLOAT16 map
13838 .float16Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
13839 // int -> BOOL8 map
13840 .bool8Operands = {},
13841 // int -> QUANT8_SYMM_PER_CHANNEL map
13842 .quant8ChannelOperands = {},
13843 // int -> QUANT16_ASYMM map
13844 .quant16AsymmOperands = {},
13845 // int -> QUANT8_SYMM map
13846 .quant8SymmOperands = {},
13847 }
13848 },
13849 }, // End of an example
13850 };
13851 return examples_large_nchw_float16;
13852 };
13853
get_examples_large_nchw_float16_weight_as_input()13854 std::vector<MixedTypedExample>& get_examples_large_nchw_float16_weight_as_input() {
13855 static std::vector<MixedTypedExample> examples_large_nchw_float16_weight_as_input = {
13856 // Begin of an example
13857 {
13858 .operands = {
13859 //Input(s)
13860 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13861 // int -> Dimensions map
13862 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13863 // int -> FLOAT32 map
13864 .float32Operands = {},
13865 // int -> INT32 map
13866 .int32Operands = {},
13867 // int -> QUANT8_ASYMM map
13868 .quant8AsymmOperands = {},
13869 // int -> QUANT16_SYMM map
13870 .quant16SymmOperands = {},
13871 // int -> FLOAT16 map
13872 .float16Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
13873 // int -> BOOL8 map
13874 .bool8Operands = {},
13875 // int -> QUANT8_SYMM_PER_CHANNEL map
13876 .quant8ChannelOperands = {},
13877 // int -> QUANT16_ASYMM map
13878 .quant16AsymmOperands = {},
13879 // int -> QUANT8_SYMM map
13880 .quant8SymmOperands = {},
13881 },
13882 //Output(s)
13883 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13884 // int -> Dimensions map
13885 .operandDimensions = {{0, {1, 2, 3, 2}}},
13886 // int -> FLOAT32 map
13887 .float32Operands = {},
13888 // int -> INT32 map
13889 .int32Operands = {},
13890 // int -> QUANT8_ASYMM map
13891 .quant8AsymmOperands = {},
13892 // int -> QUANT16_SYMM map
13893 .quant16SymmOperands = {},
13894 // int -> FLOAT16 map
13895 .float16Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
13896 // int -> BOOL8 map
13897 .bool8Operands = {},
13898 // int -> QUANT8_SYMM_PER_CHANNEL map
13899 .quant8ChannelOperands = {},
13900 // int -> QUANT16_ASYMM map
13901 .quant16AsymmOperands = {},
13902 // int -> QUANT8_SYMM map
13903 .quant8SymmOperands = {},
13904 }
13905 },
13906 }, // End of an example
13907 };
13908 return examples_large_nchw_float16_weight_as_input;
13909 };
13910
get_examples_large_dynamic_output_shape_nhwc()13911 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc() {
13912 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc = {
13913 // Begin of an example
13914 {
13915 .operands = {
13916 //Input(s)
13917 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13918 // int -> Dimensions map
13919 .operandDimensions = {{0, {1, 3, 2, 2}}},
13920 // int -> FLOAT32 map
13921 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}},
13922 // int -> INT32 map
13923 .int32Operands = {},
13924 // int -> QUANT8_ASYMM map
13925 .quant8AsymmOperands = {},
13926 // int -> QUANT16_SYMM map
13927 .quant16SymmOperands = {},
13928 // int -> FLOAT16 map
13929 .float16Operands = {},
13930 // int -> BOOL8 map
13931 .bool8Operands = {},
13932 // int -> QUANT8_SYMM_PER_CHANNEL map
13933 .quant8ChannelOperands = {},
13934 // int -> QUANT16_ASYMM map
13935 .quant16AsymmOperands = {},
13936 // int -> QUANT8_SYMM map
13937 .quant8SymmOperands = {},
13938 },
13939 //Output(s)
13940 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13941 // int -> Dimensions map
13942 .operandDimensions = {{0, {1, 3, 2, 2}}},
13943 // int -> FLOAT32 map
13944 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
13945 // int -> INT32 map
13946 .int32Operands = {},
13947 // int -> QUANT8_ASYMM map
13948 .quant8AsymmOperands = {},
13949 // int -> QUANT16_SYMM map
13950 .quant16SymmOperands = {},
13951 // int -> FLOAT16 map
13952 .float16Operands = {},
13953 // int -> BOOL8 map
13954 .bool8Operands = {},
13955 // int -> QUANT8_SYMM_PER_CHANNEL map
13956 .quant8ChannelOperands = {},
13957 // int -> QUANT16_ASYMM map
13958 .quant16AsymmOperands = {},
13959 // int -> QUANT8_SYMM map
13960 .quant8SymmOperands = {},
13961 }
13962 },
13963 }, // End of an example
13964 };
13965 return examples_large_dynamic_output_shape_nhwc;
13966 };
13967
get_examples_large_dynamic_output_shape_nhwc_weight_as_input()13968 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_weight_as_input() {
13969 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_weight_as_input = {
13970 // Begin of an example
13971 {
13972 .operands = {
13973 //Input(s)
13974 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13975 // int -> Dimensions map
13976 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
13977 // int -> FLOAT32 map
13978 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
13979 // int -> INT32 map
13980 .int32Operands = {},
13981 // int -> QUANT8_ASYMM map
13982 .quant8AsymmOperands = {},
13983 // int -> QUANT16_SYMM map
13984 .quant16SymmOperands = {},
13985 // int -> FLOAT16 map
13986 .float16Operands = {},
13987 // int -> BOOL8 map
13988 .bool8Operands = {},
13989 // int -> QUANT8_SYMM_PER_CHANNEL map
13990 .quant8ChannelOperands = {},
13991 // int -> QUANT16_ASYMM map
13992 .quant16AsymmOperands = {},
13993 // int -> QUANT8_SYMM map
13994 .quant8SymmOperands = {},
13995 },
13996 //Output(s)
13997 { // See tools/test_generator/include/TestHarness.h:MixedTyped
13998 // int -> Dimensions map
13999 .operandDimensions = {{0, {1, 3, 2, 2}}},
14000 // int -> FLOAT32 map
14001 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
14002 // int -> INT32 map
14003 .int32Operands = {},
14004 // int -> QUANT8_ASYMM map
14005 .quant8AsymmOperands = {},
14006 // int -> QUANT16_SYMM map
14007 .quant16SymmOperands = {},
14008 // int -> FLOAT16 map
14009 .float16Operands = {},
14010 // int -> BOOL8 map
14011 .bool8Operands = {},
14012 // int -> QUANT8_SYMM_PER_CHANNEL map
14013 .quant8ChannelOperands = {},
14014 // int -> QUANT16_ASYMM map
14015 .quant16AsymmOperands = {},
14016 // int -> QUANT8_SYMM map
14017 .quant8SymmOperands = {},
14018 }
14019 },
14020 }, // End of an example
14021 };
14022 return examples_large_dynamic_output_shape_nhwc_weight_as_input;
14023 };
14024
get_examples_large_dynamic_output_shape_nhwc_relaxed()14025 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_relaxed() {
14026 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_relaxed = {
14027 // Begin of an example
14028 {
14029 .operands = {
14030 //Input(s)
14031 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14032 // int -> Dimensions map
14033 .operandDimensions = {{0, {1, 3, 2, 2}}},
14034 // int -> FLOAT32 map
14035 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}},
14036 // int -> INT32 map
14037 .int32Operands = {},
14038 // int -> QUANT8_ASYMM map
14039 .quant8AsymmOperands = {},
14040 // int -> QUANT16_SYMM map
14041 .quant16SymmOperands = {},
14042 // int -> FLOAT16 map
14043 .float16Operands = {},
14044 // int -> BOOL8 map
14045 .bool8Operands = {},
14046 // int -> QUANT8_SYMM_PER_CHANNEL map
14047 .quant8ChannelOperands = {},
14048 // int -> QUANT16_ASYMM map
14049 .quant16AsymmOperands = {},
14050 // int -> QUANT8_SYMM map
14051 .quant8SymmOperands = {},
14052 },
14053 //Output(s)
14054 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14055 // int -> Dimensions map
14056 .operandDimensions = {{0, {1, 3, 2, 2}}},
14057 // int -> FLOAT32 map
14058 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
14059 // int -> INT32 map
14060 .int32Operands = {},
14061 // int -> QUANT8_ASYMM map
14062 .quant8AsymmOperands = {},
14063 // int -> QUANT16_SYMM map
14064 .quant16SymmOperands = {},
14065 // int -> FLOAT16 map
14066 .float16Operands = {},
14067 // int -> BOOL8 map
14068 .bool8Operands = {},
14069 // int -> QUANT8_SYMM_PER_CHANNEL map
14070 .quant8ChannelOperands = {},
14071 // int -> QUANT16_ASYMM map
14072 .quant16AsymmOperands = {},
14073 // int -> QUANT8_SYMM map
14074 .quant8SymmOperands = {},
14075 }
14076 },
14077 }, // End of an example
14078 };
14079 return examples_large_dynamic_output_shape_nhwc_relaxed;
14080 };
14081
get_examples_large_dynamic_output_shape_nhwc_relaxed_weight_as_input()14082 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_relaxed_weight_as_input() {
14083 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_relaxed_weight_as_input = {
14084 // Begin of an example
14085 {
14086 .operands = {
14087 //Input(s)
14088 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14089 // int -> Dimensions map
14090 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14091 // int -> FLOAT32 map
14092 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
14093 // int -> INT32 map
14094 .int32Operands = {},
14095 // int -> QUANT8_ASYMM map
14096 .quant8AsymmOperands = {},
14097 // int -> QUANT16_SYMM map
14098 .quant16SymmOperands = {},
14099 // int -> FLOAT16 map
14100 .float16Operands = {},
14101 // int -> BOOL8 map
14102 .bool8Operands = {},
14103 // int -> QUANT8_SYMM_PER_CHANNEL map
14104 .quant8ChannelOperands = {},
14105 // int -> QUANT16_ASYMM map
14106 .quant16AsymmOperands = {},
14107 // int -> QUANT8_SYMM map
14108 .quant8SymmOperands = {},
14109 },
14110 //Output(s)
14111 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14112 // int -> Dimensions map
14113 .operandDimensions = {{0, {1, 3, 2, 2}}},
14114 // int -> FLOAT32 map
14115 .float32Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
14116 // int -> INT32 map
14117 .int32Operands = {},
14118 // int -> QUANT8_ASYMM map
14119 .quant8AsymmOperands = {},
14120 // int -> QUANT16_SYMM map
14121 .quant16SymmOperands = {},
14122 // int -> FLOAT16 map
14123 .float16Operands = {},
14124 // int -> BOOL8 map
14125 .bool8Operands = {},
14126 // int -> QUANT8_SYMM_PER_CHANNEL map
14127 .quant8ChannelOperands = {},
14128 // int -> QUANT16_ASYMM map
14129 .quant16AsymmOperands = {},
14130 // int -> QUANT8_SYMM map
14131 .quant8SymmOperands = {},
14132 }
14133 },
14134 }, // End of an example
14135 };
14136 return examples_large_dynamic_output_shape_nhwc_relaxed_weight_as_input;
14137 };
14138
get_examples_large_dynamic_output_shape_nhwc_quant8()14139 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_quant8() {
14140 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_quant8 = {
14141 // Begin of an example
14142 {
14143 .operands = {
14144 //Input(s)
14145 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14146 // int -> Dimensions map
14147 .operandDimensions = {{0, {1, 3, 2, 2}}},
14148 // int -> FLOAT32 map
14149 .float32Operands = {},
14150 // int -> INT32 map
14151 .int32Operands = {},
14152 // int -> QUANT8_ASYMM map
14153 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}},
14154 // int -> QUANT16_SYMM map
14155 .quant16SymmOperands = {},
14156 // int -> FLOAT16 map
14157 .float16Operands = {},
14158 // int -> BOOL8 map
14159 .bool8Operands = {},
14160 // int -> QUANT8_SYMM_PER_CHANNEL map
14161 .quant8ChannelOperands = {},
14162 // int -> QUANT16_ASYMM map
14163 .quant16AsymmOperands = {},
14164 // int -> QUANT8_SYMM map
14165 .quant8SymmOperands = {},
14166 },
14167 //Output(s)
14168 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14169 // int -> Dimensions map
14170 .operandDimensions = {{0, {1, 3, 2, 2}}},
14171 // int -> FLOAT32 map
14172 .float32Operands = {},
14173 // int -> INT32 map
14174 .int32Operands = {},
14175 // int -> QUANT8_ASYMM map
14176 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
14177 // int -> QUANT16_SYMM map
14178 .quant16SymmOperands = {},
14179 // int -> FLOAT16 map
14180 .float16Operands = {},
14181 // int -> BOOL8 map
14182 .bool8Operands = {},
14183 // int -> QUANT8_SYMM_PER_CHANNEL map
14184 .quant8ChannelOperands = {},
14185 // int -> QUANT16_ASYMM map
14186 .quant16AsymmOperands = {},
14187 // int -> QUANT8_SYMM map
14188 .quant8SymmOperands = {},
14189 }
14190 },
14191 }, // End of an example
14192 };
14193 return examples_large_dynamic_output_shape_nhwc_quant8;
14194 };
14195
get_examples_large_dynamic_output_shape_nhwc_quant8_weight_as_input()14196 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_quant8_weight_as_input() {
14197 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_quant8_weight_as_input = {
14198 // Begin of an example
14199 {
14200 .operands = {
14201 //Input(s)
14202 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14203 // int -> Dimensions map
14204 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14205 // int -> FLOAT32 map
14206 .float32Operands = {},
14207 // int -> INT32 map
14208 .int32Operands = {{2, {2000, -4000}}},
14209 // int -> QUANT8_ASYMM map
14210 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}, {1, {100, 20, 1, 200, 10, 2, 200, 30, 1, 100, 20, 3}}},
14211 // int -> QUANT16_SYMM map
14212 .quant16SymmOperands = {},
14213 // int -> FLOAT16 map
14214 .float16Operands = {},
14215 // int -> BOOL8 map
14216 .bool8Operands = {},
14217 // int -> QUANT8_SYMM_PER_CHANNEL map
14218 .quant8ChannelOperands = {},
14219 // int -> QUANT16_ASYMM map
14220 .quant16AsymmOperands = {},
14221 // int -> QUANT8_SYMM map
14222 .quant8SymmOperands = {},
14223 },
14224 //Output(s)
14225 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14226 // int -> Dimensions map
14227 .operandDimensions = {{0, {1, 3, 2, 2}}},
14228 // int -> FLOAT32 map
14229 .float32Operands = {},
14230 // int -> INT32 map
14231 .int32Operands = {},
14232 // int -> QUANT8_ASYMM map
14233 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
14234 // int -> QUANT16_SYMM map
14235 .quant16SymmOperands = {},
14236 // int -> FLOAT16 map
14237 .float16Operands = {},
14238 // int -> BOOL8 map
14239 .bool8Operands = {},
14240 // int -> QUANT8_SYMM_PER_CHANNEL map
14241 .quant8ChannelOperands = {},
14242 // int -> QUANT16_ASYMM map
14243 .quant16AsymmOperands = {},
14244 // int -> QUANT8_SYMM map
14245 .quant8SymmOperands = {},
14246 }
14247 },
14248 }, // End of an example
14249 };
14250 return examples_large_dynamic_output_shape_nhwc_quant8_weight_as_input;
14251 };
14252
get_examples_large_dynamic_output_shape_nhwc_channelQuant8()14253 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_channelQuant8() {
14254 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_channelQuant8 = {
14255 // Begin of an example
14256 {
14257 .operands = {
14258 //Input(s)
14259 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14260 // int -> Dimensions map
14261 .operandDimensions = {{0, {1, 3, 2, 2}}},
14262 // int -> FLOAT32 map
14263 .float32Operands = {},
14264 // int -> INT32 map
14265 .int32Operands = {},
14266 // int -> QUANT8_ASYMM map
14267 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}},
14268 // int -> QUANT16_SYMM map
14269 .quant16SymmOperands = {},
14270 // int -> FLOAT16 map
14271 .float16Operands = {},
14272 // int -> BOOL8 map
14273 .bool8Operands = {},
14274 // int -> QUANT8_SYMM_PER_CHANNEL map
14275 .quant8ChannelOperands = {},
14276 // int -> QUANT16_ASYMM map
14277 .quant16AsymmOperands = {},
14278 // int -> QUANT8_SYMM map
14279 .quant8SymmOperands = {},
14280 },
14281 //Output(s)
14282 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14283 // int -> Dimensions map
14284 .operandDimensions = {{0, {1, 3, 2, 2}}},
14285 // int -> FLOAT32 map
14286 .float32Operands = {},
14287 // int -> INT32 map
14288 .int32Operands = {},
14289 // int -> QUANT8_ASYMM map
14290 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
14291 // int -> QUANT16_SYMM map
14292 .quant16SymmOperands = {},
14293 // int -> FLOAT16 map
14294 .float16Operands = {},
14295 // int -> BOOL8 map
14296 .bool8Operands = {},
14297 // int -> QUANT8_SYMM_PER_CHANNEL map
14298 .quant8ChannelOperands = {},
14299 // int -> QUANT16_ASYMM map
14300 .quant16AsymmOperands = {},
14301 // int -> QUANT8_SYMM map
14302 .quant8SymmOperands = {},
14303 }
14304 },
14305 }, // End of an example
14306 };
14307 return examples_large_dynamic_output_shape_nhwc_channelQuant8;
14308 };
14309
get_examples_large_dynamic_output_shape_nhwc_channelQuant8_weight_as_input()14310 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_channelQuant8_weight_as_input() {
14311 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_channelQuant8_weight_as_input = {
14312 // Begin of an example
14313 {
14314 .operands = {
14315 //Input(s)
14316 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14317 // int -> Dimensions map
14318 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14319 // int -> FLOAT32 map
14320 .float32Operands = {},
14321 // int -> INT32 map
14322 .int32Operands = {{2, {1000, -1600}}},
14323 // int -> QUANT8_ASYMM map
14324 .quant8AsymmOperands = {{0, {132, 136, 140, 144, 144, 140, 136, 132, 136, 140, 140, 140}}},
14325 // int -> QUANT16_SYMM map
14326 .quant16SymmOperands = {},
14327 // int -> FLOAT16 map
14328 .float16Operands = {},
14329 // int -> BOOL8 map
14330 .bool8Operands = {},
14331 // int -> QUANT8_SYMM_PER_CHANNEL map
14332 .quant8ChannelOperands = {{1, {50, 10, 0, 100, 5, 1, 80, 12, 0, 40, 8, 1}}},
14333 // int -> QUANT16_ASYMM map
14334 .quant16AsymmOperands = {},
14335 // int -> QUANT8_SYMM map
14336 .quant8SymmOperands = {},
14337 },
14338 //Output(s)
14339 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14340 // int -> Dimensions map
14341 .operandDimensions = {{0, {1, 3, 2, 2}}},
14342 // int -> FLOAT32 map
14343 .float32Operands = {},
14344 // int -> INT32 map
14345 .int32Operands = {},
14346 // int -> QUANT8_ASYMM map
14347 .quant8AsymmOperands = {{0, {157, 13, 248, 84, 161, 16, 237, 99, 154, 9, 176, 69}}},
14348 // int -> QUANT16_SYMM map
14349 .quant16SymmOperands = {},
14350 // int -> FLOAT16 map
14351 .float16Operands = {},
14352 // int -> BOOL8 map
14353 .bool8Operands = {},
14354 // int -> QUANT8_SYMM_PER_CHANNEL map
14355 .quant8ChannelOperands = {},
14356 // int -> QUANT16_ASYMM map
14357 .quant16AsymmOperands = {},
14358 // int -> QUANT8_SYMM map
14359 .quant8SymmOperands = {},
14360 }
14361 },
14362 }, // End of an example
14363 };
14364 return examples_large_dynamic_output_shape_nhwc_channelQuant8_weight_as_input;
14365 };
14366
get_examples_large_dynamic_output_shape_nhwc_float16()14367 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_float16() {
14368 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_float16 = {
14369 // Begin of an example
14370 {
14371 .operands = {
14372 //Input(s)
14373 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14374 // int -> Dimensions map
14375 .operandDimensions = {{0, {1, 3, 2, 2}}},
14376 // int -> FLOAT32 map
14377 .float32Operands = {},
14378 // int -> INT32 map
14379 .int32Operands = {},
14380 // int -> QUANT8_ASYMM map
14381 .quant8AsymmOperands = {},
14382 // int -> QUANT16_SYMM map
14383 .quant16SymmOperands = {},
14384 // int -> FLOAT16 map
14385 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}},
14386 // int -> BOOL8 map
14387 .bool8Operands = {},
14388 // int -> QUANT8_SYMM_PER_CHANNEL map
14389 .quant8ChannelOperands = {},
14390 // int -> QUANT16_ASYMM map
14391 .quant16AsymmOperands = {},
14392 // int -> QUANT8_SYMM map
14393 .quant8SymmOperands = {},
14394 },
14395 //Output(s)
14396 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14397 // int -> Dimensions map
14398 .operandDimensions = {{0, {1, 3, 2, 2}}},
14399 // int -> FLOAT32 map
14400 .float32Operands = {},
14401 // int -> INT32 map
14402 .int32Operands = {},
14403 // int -> QUANT8_ASYMM map
14404 .quant8AsymmOperands = {},
14405 // int -> QUANT16_SYMM map
14406 .quant16SymmOperands = {},
14407 // int -> FLOAT16 map
14408 .float16Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
14409 // int -> BOOL8 map
14410 .bool8Operands = {},
14411 // int -> QUANT8_SYMM_PER_CHANNEL map
14412 .quant8ChannelOperands = {},
14413 // int -> QUANT16_ASYMM map
14414 .quant16AsymmOperands = {},
14415 // int -> QUANT8_SYMM map
14416 .quant8SymmOperands = {},
14417 }
14418 },
14419 }, // End of an example
14420 };
14421 return examples_large_dynamic_output_shape_nhwc_float16;
14422 };
14423
get_examples_large_dynamic_output_shape_nhwc_float16_weight_as_input()14424 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nhwc_float16_weight_as_input() {
14425 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nhwc_float16_weight_as_input = {
14426 // Begin of an example
14427 {
14428 .operands = {
14429 //Input(s)
14430 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14431 // int -> Dimensions map
14432 .operandDimensions = {{0, {1, 3, 2, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14433 // int -> FLOAT32 map
14434 .float32Operands = {},
14435 // int -> INT32 map
14436 .int32Operands = {},
14437 // int -> QUANT8_ASYMM map
14438 .quant8AsymmOperands = {},
14439 // int -> QUANT16_SYMM map
14440 .quant16SymmOperands = {},
14441 // int -> FLOAT16 map
14442 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 4.0f, 3.0f, 2.0f, 1.0f, 2.0f, 3.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
14443 // int -> BOOL8 map
14444 .bool8Operands = {},
14445 // int -> QUANT8_SYMM_PER_CHANNEL map
14446 .quant8ChannelOperands = {},
14447 // int -> QUANT16_ASYMM map
14448 .quant16AsymmOperands = {},
14449 // int -> QUANT8_SYMM map
14450 .quant8SymmOperands = {},
14451 },
14452 //Output(s)
14453 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14454 // int -> Dimensions map
14455 .operandDimensions = {{0, {1, 3, 2, 2}}},
14456 // int -> FLOAT32 map
14457 .float32Operands = {},
14458 // int -> INT32 map
14459 .int32Operands = {},
14460 // int -> QUANT8_ASYMM map
14461 .quant8AsymmOperands = {},
14462 // int -> QUANT16_SYMM map
14463 .quant16SymmOperands = {},
14464 // int -> FLOAT16 map
14465 .float16Operands = {{0, {567.0f, -873.0f, 1480.0f, -160.0f, 608.0f, -840.0f, 1370.0f, -10.0f, 543.0f, -907.0f, 760.0f, -310.0f}}},
14466 // int -> BOOL8 map
14467 .bool8Operands = {},
14468 // int -> QUANT8_SYMM_PER_CHANNEL map
14469 .quant8ChannelOperands = {},
14470 // int -> QUANT16_ASYMM map
14471 .quant16AsymmOperands = {},
14472 // int -> QUANT8_SYMM map
14473 .quant8SymmOperands = {},
14474 }
14475 },
14476 }, // End of an example
14477 };
14478 return examples_large_dynamic_output_shape_nhwc_float16_weight_as_input;
14479 };
14480
get_examples_large_dynamic_output_shape_nchw()14481 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw() {
14482 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw = {
14483 // Begin of an example
14484 {
14485 .operands = {
14486 //Input(s)
14487 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14488 // int -> Dimensions map
14489 .operandDimensions = {{0, {1, 2, 3, 2}}},
14490 // int -> FLOAT32 map
14491 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}},
14492 // int -> INT32 map
14493 .int32Operands = {},
14494 // int -> QUANT8_ASYMM map
14495 .quant8AsymmOperands = {},
14496 // int -> QUANT16_SYMM map
14497 .quant16SymmOperands = {},
14498 // int -> FLOAT16 map
14499 .float16Operands = {},
14500 // int -> BOOL8 map
14501 .bool8Operands = {},
14502 // int -> QUANT8_SYMM_PER_CHANNEL map
14503 .quant8ChannelOperands = {},
14504 // int -> QUANT16_ASYMM map
14505 .quant16AsymmOperands = {},
14506 // int -> QUANT8_SYMM map
14507 .quant8SymmOperands = {},
14508 },
14509 //Output(s)
14510 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14511 // int -> Dimensions map
14512 .operandDimensions = {{0, {1, 2, 3, 2}}},
14513 // int -> FLOAT32 map
14514 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
14515 // int -> INT32 map
14516 .int32Operands = {},
14517 // int -> QUANT8_ASYMM map
14518 .quant8AsymmOperands = {},
14519 // int -> QUANT16_SYMM map
14520 .quant16SymmOperands = {},
14521 // int -> FLOAT16 map
14522 .float16Operands = {},
14523 // int -> BOOL8 map
14524 .bool8Operands = {},
14525 // int -> QUANT8_SYMM_PER_CHANNEL map
14526 .quant8ChannelOperands = {},
14527 // int -> QUANT16_ASYMM map
14528 .quant16AsymmOperands = {},
14529 // int -> QUANT8_SYMM map
14530 .quant8SymmOperands = {},
14531 }
14532 },
14533 }, // End of an example
14534 };
14535 return examples_large_dynamic_output_shape_nchw;
14536 };
14537
get_examples_large_dynamic_output_shape_nchw_weight_as_input()14538 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_weight_as_input() {
14539 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_weight_as_input = {
14540 // Begin of an example
14541 {
14542 .operands = {
14543 //Input(s)
14544 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14545 // int -> Dimensions map
14546 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14547 // int -> FLOAT32 map
14548 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
14549 // int -> INT32 map
14550 .int32Operands = {},
14551 // int -> QUANT8_ASYMM map
14552 .quant8AsymmOperands = {},
14553 // int -> QUANT16_SYMM map
14554 .quant16SymmOperands = {},
14555 // int -> FLOAT16 map
14556 .float16Operands = {},
14557 // int -> BOOL8 map
14558 .bool8Operands = {},
14559 // int -> QUANT8_SYMM_PER_CHANNEL map
14560 .quant8ChannelOperands = {},
14561 // int -> QUANT16_ASYMM map
14562 .quant16AsymmOperands = {},
14563 // int -> QUANT8_SYMM map
14564 .quant8SymmOperands = {},
14565 },
14566 //Output(s)
14567 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14568 // int -> Dimensions map
14569 .operandDimensions = {{0, {1, 2, 3, 2}}},
14570 // int -> FLOAT32 map
14571 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
14572 // int -> INT32 map
14573 .int32Operands = {},
14574 // int -> QUANT8_ASYMM map
14575 .quant8AsymmOperands = {},
14576 // int -> QUANT16_SYMM map
14577 .quant16SymmOperands = {},
14578 // int -> FLOAT16 map
14579 .float16Operands = {},
14580 // int -> BOOL8 map
14581 .bool8Operands = {},
14582 // int -> QUANT8_SYMM_PER_CHANNEL map
14583 .quant8ChannelOperands = {},
14584 // int -> QUANT16_ASYMM map
14585 .quant16AsymmOperands = {},
14586 // int -> QUANT8_SYMM map
14587 .quant8SymmOperands = {},
14588 }
14589 },
14590 }, // End of an example
14591 };
14592 return examples_large_dynamic_output_shape_nchw_weight_as_input;
14593 };
14594
get_examples_large_dynamic_output_shape_nchw_relaxed()14595 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_relaxed() {
14596 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_relaxed = {
14597 // Begin of an example
14598 {
14599 .operands = {
14600 //Input(s)
14601 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14602 // int -> Dimensions map
14603 .operandDimensions = {{0, {1, 2, 3, 2}}},
14604 // int -> FLOAT32 map
14605 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}},
14606 // int -> INT32 map
14607 .int32Operands = {},
14608 // int -> QUANT8_ASYMM map
14609 .quant8AsymmOperands = {},
14610 // int -> QUANT16_SYMM map
14611 .quant16SymmOperands = {},
14612 // int -> FLOAT16 map
14613 .float16Operands = {},
14614 // int -> BOOL8 map
14615 .bool8Operands = {},
14616 // int -> QUANT8_SYMM_PER_CHANNEL map
14617 .quant8ChannelOperands = {},
14618 // int -> QUANT16_ASYMM map
14619 .quant16AsymmOperands = {},
14620 // int -> QUANT8_SYMM map
14621 .quant8SymmOperands = {},
14622 },
14623 //Output(s)
14624 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14625 // int -> Dimensions map
14626 .operandDimensions = {{0, {1, 2, 3, 2}}},
14627 // int -> FLOAT32 map
14628 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
14629 // int -> INT32 map
14630 .int32Operands = {},
14631 // int -> QUANT8_ASYMM map
14632 .quant8AsymmOperands = {},
14633 // int -> QUANT16_SYMM map
14634 .quant16SymmOperands = {},
14635 // int -> FLOAT16 map
14636 .float16Operands = {},
14637 // int -> BOOL8 map
14638 .bool8Operands = {},
14639 // int -> QUANT8_SYMM_PER_CHANNEL map
14640 .quant8ChannelOperands = {},
14641 // int -> QUANT16_ASYMM map
14642 .quant16AsymmOperands = {},
14643 // int -> QUANT8_SYMM map
14644 .quant8SymmOperands = {},
14645 }
14646 },
14647 }, // End of an example
14648 };
14649 return examples_large_dynamic_output_shape_nchw_relaxed;
14650 };
14651
get_examples_large_dynamic_output_shape_nchw_relaxed_weight_as_input()14652 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_relaxed_weight_as_input() {
14653 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_relaxed_weight_as_input = {
14654 // Begin of an example
14655 {
14656 .operands = {
14657 //Input(s)
14658 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14659 // int -> Dimensions map
14660 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14661 // int -> FLOAT32 map
14662 .float32Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
14663 // int -> INT32 map
14664 .int32Operands = {},
14665 // int -> QUANT8_ASYMM map
14666 .quant8AsymmOperands = {},
14667 // int -> QUANT16_SYMM map
14668 .quant16SymmOperands = {},
14669 // int -> FLOAT16 map
14670 .float16Operands = {},
14671 // int -> BOOL8 map
14672 .bool8Operands = {},
14673 // int -> QUANT8_SYMM_PER_CHANNEL map
14674 .quant8ChannelOperands = {},
14675 // int -> QUANT16_ASYMM map
14676 .quant16AsymmOperands = {},
14677 // int -> QUANT8_SYMM map
14678 .quant8SymmOperands = {},
14679 },
14680 //Output(s)
14681 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14682 // int -> Dimensions map
14683 .operandDimensions = {{0, {1, 2, 3, 2}}},
14684 // int -> FLOAT32 map
14685 .float32Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
14686 // int -> INT32 map
14687 .int32Operands = {},
14688 // int -> QUANT8_ASYMM map
14689 .quant8AsymmOperands = {},
14690 // int -> QUANT16_SYMM map
14691 .quant16SymmOperands = {},
14692 // int -> FLOAT16 map
14693 .float16Operands = {},
14694 // int -> BOOL8 map
14695 .bool8Operands = {},
14696 // int -> QUANT8_SYMM_PER_CHANNEL map
14697 .quant8ChannelOperands = {},
14698 // int -> QUANT16_ASYMM map
14699 .quant16AsymmOperands = {},
14700 // int -> QUANT8_SYMM map
14701 .quant8SymmOperands = {},
14702 }
14703 },
14704 }, // End of an example
14705 };
14706 return examples_large_dynamic_output_shape_nchw_relaxed_weight_as_input;
14707 };
14708
get_examples_large_dynamic_output_shape_nchw_quant8()14709 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_quant8() {
14710 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_quant8 = {
14711 // Begin of an example
14712 {
14713 .operands = {
14714 //Input(s)
14715 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14716 // int -> Dimensions map
14717 .operandDimensions = {{0, {1, 2, 3, 2}}},
14718 // int -> FLOAT32 map
14719 .float32Operands = {},
14720 // int -> INT32 map
14721 .int32Operands = {},
14722 // int -> QUANT8_ASYMM map
14723 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}},
14724 // int -> QUANT16_SYMM map
14725 .quant16SymmOperands = {},
14726 // int -> FLOAT16 map
14727 .float16Operands = {},
14728 // int -> BOOL8 map
14729 .bool8Operands = {},
14730 // int -> QUANT8_SYMM_PER_CHANNEL map
14731 .quant8ChannelOperands = {},
14732 // int -> QUANT16_ASYMM map
14733 .quant16AsymmOperands = {},
14734 // int -> QUANT8_SYMM map
14735 .quant8SymmOperands = {},
14736 },
14737 //Output(s)
14738 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14739 // int -> Dimensions map
14740 .operandDimensions = {{0, {1, 2, 3, 2}}},
14741 // int -> FLOAT32 map
14742 .float32Operands = {},
14743 // int -> INT32 map
14744 .int32Operands = {},
14745 // int -> QUANT8_ASYMM map
14746 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
14747 // int -> QUANT16_SYMM map
14748 .quant16SymmOperands = {},
14749 // int -> FLOAT16 map
14750 .float16Operands = {},
14751 // int -> BOOL8 map
14752 .bool8Operands = {},
14753 // int -> QUANT8_SYMM_PER_CHANNEL map
14754 .quant8ChannelOperands = {},
14755 // int -> QUANT16_ASYMM map
14756 .quant16AsymmOperands = {},
14757 // int -> QUANT8_SYMM map
14758 .quant8SymmOperands = {},
14759 }
14760 },
14761 }, // End of an example
14762 };
14763 return examples_large_dynamic_output_shape_nchw_quant8;
14764 };
14765
get_examples_large_dynamic_output_shape_nchw_quant8_weight_as_input()14766 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_quant8_weight_as_input() {
14767 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_quant8_weight_as_input = {
14768 // Begin of an example
14769 {
14770 .operands = {
14771 //Input(s)
14772 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14773 // int -> Dimensions map
14774 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14775 // int -> FLOAT32 map
14776 .float32Operands = {},
14777 // int -> INT32 map
14778 .int32Operands = {{2, {2000, -4000}}},
14779 // int -> QUANT8_ASYMM map
14780 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}, {1, {100, 20, 1, 200, 10, 2, 200, 30, 1, 100, 20, 3}}},
14781 // int -> QUANT16_SYMM map
14782 .quant16SymmOperands = {},
14783 // int -> FLOAT16 map
14784 .float16Operands = {},
14785 // int -> BOOL8 map
14786 .bool8Operands = {},
14787 // int -> QUANT8_SYMM_PER_CHANNEL map
14788 .quant8ChannelOperands = {},
14789 // int -> QUANT16_ASYMM map
14790 .quant16AsymmOperands = {},
14791 // int -> QUANT8_SYMM map
14792 .quant8SymmOperands = {},
14793 },
14794 //Output(s)
14795 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14796 // int -> Dimensions map
14797 .operandDimensions = {{0, {1, 2, 3, 2}}},
14798 // int -> FLOAT32 map
14799 .float32Operands = {},
14800 // int -> INT32 map
14801 .int32Operands = {},
14802 // int -> QUANT8_ASYMM map
14803 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
14804 // int -> QUANT16_SYMM map
14805 .quant16SymmOperands = {},
14806 // int -> FLOAT16 map
14807 .float16Operands = {},
14808 // int -> BOOL8 map
14809 .bool8Operands = {},
14810 // int -> QUANT8_SYMM_PER_CHANNEL map
14811 .quant8ChannelOperands = {},
14812 // int -> QUANT16_ASYMM map
14813 .quant16AsymmOperands = {},
14814 // int -> QUANT8_SYMM map
14815 .quant8SymmOperands = {},
14816 }
14817 },
14818 }, // End of an example
14819 };
14820 return examples_large_dynamic_output_shape_nchw_quant8_weight_as_input;
14821 };
14822
get_examples_large_dynamic_output_shape_nchw_channelQuant8()14823 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_channelQuant8() {
14824 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_channelQuant8 = {
14825 // Begin of an example
14826 {
14827 .operands = {
14828 //Input(s)
14829 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14830 // int -> Dimensions map
14831 .operandDimensions = {{0, {1, 2, 3, 2}}},
14832 // int -> FLOAT32 map
14833 .float32Operands = {},
14834 // int -> INT32 map
14835 .int32Operands = {},
14836 // int -> QUANT8_ASYMM map
14837 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}},
14838 // int -> QUANT16_SYMM map
14839 .quant16SymmOperands = {},
14840 // int -> FLOAT16 map
14841 .float16Operands = {},
14842 // int -> BOOL8 map
14843 .bool8Operands = {},
14844 // int -> QUANT8_SYMM_PER_CHANNEL map
14845 .quant8ChannelOperands = {},
14846 // int -> QUANT16_ASYMM map
14847 .quant16AsymmOperands = {},
14848 // int -> QUANT8_SYMM map
14849 .quant8SymmOperands = {},
14850 },
14851 //Output(s)
14852 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14853 // int -> Dimensions map
14854 .operandDimensions = {{0, {1, 2, 3, 2}}},
14855 // int -> FLOAT32 map
14856 .float32Operands = {},
14857 // int -> INT32 map
14858 .int32Operands = {},
14859 // int -> QUANT8_ASYMM map
14860 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
14861 // int -> QUANT16_SYMM map
14862 .quant16SymmOperands = {},
14863 // int -> FLOAT16 map
14864 .float16Operands = {},
14865 // int -> BOOL8 map
14866 .bool8Operands = {},
14867 // int -> QUANT8_SYMM_PER_CHANNEL map
14868 .quant8ChannelOperands = {},
14869 // int -> QUANT16_ASYMM map
14870 .quant16AsymmOperands = {},
14871 // int -> QUANT8_SYMM map
14872 .quant8SymmOperands = {},
14873 }
14874 },
14875 }, // End of an example
14876 };
14877 return examples_large_dynamic_output_shape_nchw_channelQuant8;
14878 };
14879
get_examples_large_dynamic_output_shape_nchw_channelQuant8_weight_as_input()14880 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_channelQuant8_weight_as_input() {
14881 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_channelQuant8_weight_as_input = {
14882 // Begin of an example
14883 {
14884 .operands = {
14885 //Input(s)
14886 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14887 // int -> Dimensions map
14888 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
14889 // int -> FLOAT32 map
14890 .float32Operands = {},
14891 // int -> INT32 map
14892 .int32Operands = {{2, {1000, -1600}}},
14893 // int -> QUANT8_ASYMM map
14894 .quant8AsymmOperands = {{0, {132, 140, 144, 136, 136, 140, 136, 144, 140, 132, 140, 140}}},
14895 // int -> QUANT16_SYMM map
14896 .quant16SymmOperands = {},
14897 // int -> FLOAT16 map
14898 .float16Operands = {},
14899 // int -> BOOL8 map
14900 .bool8Operands = {},
14901 // int -> QUANT8_SYMM_PER_CHANNEL map
14902 .quant8ChannelOperands = {{1, {50, 10, 0, 100, 5, 1, 80, 12, 0, 40, 8, 1}}},
14903 // int -> QUANT16_ASYMM map
14904 .quant16AsymmOperands = {},
14905 // int -> QUANT8_SYMM map
14906 .quant8SymmOperands = {},
14907 },
14908 //Output(s)
14909 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14910 // int -> Dimensions map
14911 .operandDimensions = {{0, {1, 2, 3, 2}}},
14912 // int -> FLOAT32 map
14913 .float32Operands = {},
14914 // int -> INT32 map
14915 .int32Operands = {},
14916 // int -> QUANT8_ASYMM map
14917 .quant8AsymmOperands = {{0, {157, 248, 161, 237, 154, 176, 13, 84, 16, 99, 9, 69}}},
14918 // int -> QUANT16_SYMM map
14919 .quant16SymmOperands = {},
14920 // int -> FLOAT16 map
14921 .float16Operands = {},
14922 // int -> BOOL8 map
14923 .bool8Operands = {},
14924 // int -> QUANT8_SYMM_PER_CHANNEL map
14925 .quant8ChannelOperands = {},
14926 // int -> QUANT16_ASYMM map
14927 .quant16AsymmOperands = {},
14928 // int -> QUANT8_SYMM map
14929 .quant8SymmOperands = {},
14930 }
14931 },
14932 }, // End of an example
14933 };
14934 return examples_large_dynamic_output_shape_nchw_channelQuant8_weight_as_input;
14935 };
14936
get_examples_large_dynamic_output_shape_nchw_float16()14937 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_float16() {
14938 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_float16 = {
14939 // Begin of an example
14940 {
14941 .operands = {
14942 //Input(s)
14943 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14944 // int -> Dimensions map
14945 .operandDimensions = {{0, {1, 2, 3, 2}}},
14946 // int -> FLOAT32 map
14947 .float32Operands = {},
14948 // int -> INT32 map
14949 .int32Operands = {},
14950 // int -> QUANT8_ASYMM map
14951 .quant8AsymmOperands = {},
14952 // int -> QUANT16_SYMM map
14953 .quant16SymmOperands = {},
14954 // int -> FLOAT16 map
14955 .float16Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}},
14956 // int -> BOOL8 map
14957 .bool8Operands = {},
14958 // int -> QUANT8_SYMM_PER_CHANNEL map
14959 .quant8ChannelOperands = {},
14960 // int -> QUANT16_ASYMM map
14961 .quant16AsymmOperands = {},
14962 // int -> QUANT8_SYMM map
14963 .quant8SymmOperands = {},
14964 },
14965 //Output(s)
14966 { // See tools/test_generator/include/TestHarness.h:MixedTyped
14967 // int -> Dimensions map
14968 .operandDimensions = {{0, {1, 2, 3, 2}}},
14969 // int -> FLOAT32 map
14970 .float32Operands = {},
14971 // int -> INT32 map
14972 .int32Operands = {},
14973 // int -> QUANT8_ASYMM map
14974 .quant8AsymmOperands = {},
14975 // int -> QUANT16_SYMM map
14976 .quant16SymmOperands = {},
14977 // int -> FLOAT16 map
14978 .float16Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
14979 // int -> BOOL8 map
14980 .bool8Operands = {},
14981 // int -> QUANT8_SYMM_PER_CHANNEL map
14982 .quant8ChannelOperands = {},
14983 // int -> QUANT16_ASYMM map
14984 .quant16AsymmOperands = {},
14985 // int -> QUANT8_SYMM map
14986 .quant8SymmOperands = {},
14987 }
14988 },
14989 }, // End of an example
14990 };
14991 return examples_large_dynamic_output_shape_nchw_float16;
14992 };
14993
get_examples_large_dynamic_output_shape_nchw_float16_weight_as_input()14994 std::vector<MixedTypedExample>& get_examples_large_dynamic_output_shape_nchw_float16_weight_as_input() {
14995 static std::vector<MixedTypedExample> examples_large_dynamic_output_shape_nchw_float16_weight_as_input = {
14996 // Begin of an example
14997 {
14998 .operands = {
14999 //Input(s)
15000 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15001 // int -> Dimensions map
15002 .operandDimensions = {{0, {1, 2, 3, 2}}, {1, {2, 2, 3, 1}}, {2, {2}}},
15003 // int -> FLOAT32 map
15004 .float32Operands = {},
15005 // int -> INT32 map
15006 .int32Operands = {},
15007 // int -> QUANT8_ASYMM map
15008 .quant8AsymmOperands = {},
15009 // int -> QUANT16_SYMM map
15010 .quant16SymmOperands = {},
15011 // int -> FLOAT16 map
15012 .float16Operands = {{0, {1.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 2.0f, 4.0f, 3.0f, 1.0f, 3.0f, 3.0f}}, {1, {100.0f, 20.0f, 1.0f, 200.0f, 10.0f, 2.0f, 200.0f, 30.0f, 1.0f, 100.0f, 20.0f, 3.0f}}, {2, {500.0f, -1000.0f}}},
15013 // int -> BOOL8 map
15014 .bool8Operands = {},
15015 // int -> QUANT8_SYMM_PER_CHANNEL map
15016 .quant8ChannelOperands = {},
15017 // int -> QUANT16_ASYMM map
15018 .quant16AsymmOperands = {},
15019 // int -> QUANT8_SYMM map
15020 .quant8SymmOperands = {},
15021 },
15022 //Output(s)
15023 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15024 // int -> Dimensions map
15025 .operandDimensions = {{0, {1, 2, 3, 2}}},
15026 // int -> FLOAT32 map
15027 .float32Operands = {},
15028 // int -> INT32 map
15029 .int32Operands = {},
15030 // int -> QUANT8_ASYMM map
15031 .quant8AsymmOperands = {},
15032 // int -> QUANT16_SYMM map
15033 .quant16SymmOperands = {},
15034 // int -> FLOAT16 map
15035 .float16Operands = {{0, {567.0f, 1480.0f, 608.0f, 1370.0f, 543.0f, 760.0f, -873.0f, -160.0f, -840.0f, -10.0f, -907.0f, -310.0f}}},
15036 // int -> BOOL8 map
15037 .bool8Operands = {},
15038 // int -> QUANT8_SYMM_PER_CHANNEL map
15039 .quant8ChannelOperands = {},
15040 // int -> QUANT16_ASYMM map
15041 .quant16AsymmOperands = {},
15042 // int -> QUANT8_SYMM map
15043 .quant8SymmOperands = {},
15044 }
15045 },
15046 }, // End of an example
15047 };
15048 return examples_large_dynamic_output_shape_nchw_float16_weight_as_input;
15049 };
15050
get_examples_channel_nhwc()15051 std::vector<MixedTypedExample>& get_examples_channel_nhwc() {
15052 static std::vector<MixedTypedExample> examples_channel_nhwc = {
15053 // Begin of an example
15054 {
15055 .operands = {
15056 //Input(s)
15057 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15058 // int -> Dimensions map
15059 .operandDimensions = {{0, {1, 2, 2, 9}}},
15060 // int -> FLOAT32 map
15061 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}},
15062 // int -> INT32 map
15063 .int32Operands = {},
15064 // int -> QUANT8_ASYMM map
15065 .quant8AsymmOperands = {},
15066 // int -> QUANT16_SYMM map
15067 .quant16SymmOperands = {},
15068 // int -> FLOAT16 map
15069 .float16Operands = {},
15070 // int -> BOOL8 map
15071 .bool8Operands = {},
15072 // int -> QUANT8_SYMM_PER_CHANNEL map
15073 .quant8ChannelOperands = {},
15074 // int -> QUANT16_ASYMM map
15075 .quant16AsymmOperands = {},
15076 // int -> QUANT8_SYMM map
15077 .quant8SymmOperands = {},
15078 },
15079 //Output(s)
15080 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15081 // int -> Dimensions map
15082 .operandDimensions = {{0, {1, 2, 2, 6}}},
15083 // int -> FLOAT32 map
15084 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
15085 // int -> INT32 map
15086 .int32Operands = {},
15087 // int -> QUANT8_ASYMM map
15088 .quant8AsymmOperands = {},
15089 // int -> QUANT16_SYMM map
15090 .quant16SymmOperands = {},
15091 // int -> FLOAT16 map
15092 .float16Operands = {},
15093 // int -> BOOL8 map
15094 .bool8Operands = {},
15095 // int -> QUANT8_SYMM_PER_CHANNEL map
15096 .quant8ChannelOperands = {},
15097 // int -> QUANT16_ASYMM map
15098 .quant16AsymmOperands = {},
15099 // int -> QUANT8_SYMM map
15100 .quant8SymmOperands = {},
15101 }
15102 },
15103 }, // End of an example
15104 };
15105 return examples_channel_nhwc;
15106 };
15107
get_examples_channel_nhwc_weight_as_input()15108 std::vector<MixedTypedExample>& get_examples_channel_nhwc_weight_as_input() {
15109 static std::vector<MixedTypedExample> examples_channel_nhwc_weight_as_input = {
15110 // Begin of an example
15111 {
15112 .operands = {
15113 //Input(s)
15114 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15115 // int -> Dimensions map
15116 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15117 // int -> FLOAT32 map
15118 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
15119 // int -> INT32 map
15120 .int32Operands = {},
15121 // int -> QUANT8_ASYMM map
15122 .quant8AsymmOperands = {},
15123 // int -> QUANT16_SYMM map
15124 .quant16SymmOperands = {},
15125 // int -> FLOAT16 map
15126 .float16Operands = {},
15127 // int -> BOOL8 map
15128 .bool8Operands = {},
15129 // int -> QUANT8_SYMM_PER_CHANNEL map
15130 .quant8ChannelOperands = {},
15131 // int -> QUANT16_ASYMM map
15132 .quant16AsymmOperands = {},
15133 // int -> QUANT8_SYMM map
15134 .quant8SymmOperands = {},
15135 },
15136 //Output(s)
15137 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15138 // int -> Dimensions map
15139 .operandDimensions = {{0, {1, 2, 2, 6}}},
15140 // int -> FLOAT32 map
15141 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
15142 // int -> INT32 map
15143 .int32Operands = {},
15144 // int -> QUANT8_ASYMM map
15145 .quant8AsymmOperands = {},
15146 // int -> QUANT16_SYMM map
15147 .quant16SymmOperands = {},
15148 // int -> FLOAT16 map
15149 .float16Operands = {},
15150 // int -> BOOL8 map
15151 .bool8Operands = {},
15152 // int -> QUANT8_SYMM_PER_CHANNEL map
15153 .quant8ChannelOperands = {},
15154 // int -> QUANT16_ASYMM map
15155 .quant16AsymmOperands = {},
15156 // int -> QUANT8_SYMM map
15157 .quant8SymmOperands = {},
15158 }
15159 },
15160 }, // End of an example
15161 };
15162 return examples_channel_nhwc_weight_as_input;
15163 };
15164
get_examples_channel_nhwc_relaxed()15165 std::vector<MixedTypedExample>& get_examples_channel_nhwc_relaxed() {
15166 static std::vector<MixedTypedExample> examples_channel_nhwc_relaxed = {
15167 // Begin of an example
15168 {
15169 .operands = {
15170 //Input(s)
15171 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15172 // int -> Dimensions map
15173 .operandDimensions = {{0, {1, 2, 2, 9}}},
15174 // int -> FLOAT32 map
15175 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}},
15176 // int -> INT32 map
15177 .int32Operands = {},
15178 // int -> QUANT8_ASYMM map
15179 .quant8AsymmOperands = {},
15180 // int -> QUANT16_SYMM map
15181 .quant16SymmOperands = {},
15182 // int -> FLOAT16 map
15183 .float16Operands = {},
15184 // int -> BOOL8 map
15185 .bool8Operands = {},
15186 // int -> QUANT8_SYMM_PER_CHANNEL map
15187 .quant8ChannelOperands = {},
15188 // int -> QUANT16_ASYMM map
15189 .quant16AsymmOperands = {},
15190 // int -> QUANT8_SYMM map
15191 .quant8SymmOperands = {},
15192 },
15193 //Output(s)
15194 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15195 // int -> Dimensions map
15196 .operandDimensions = {{0, {1, 2, 2, 6}}},
15197 // int -> FLOAT32 map
15198 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
15199 // int -> INT32 map
15200 .int32Operands = {},
15201 // int -> QUANT8_ASYMM map
15202 .quant8AsymmOperands = {},
15203 // int -> QUANT16_SYMM map
15204 .quant16SymmOperands = {},
15205 // int -> FLOAT16 map
15206 .float16Operands = {},
15207 // int -> BOOL8 map
15208 .bool8Operands = {},
15209 // int -> QUANT8_SYMM_PER_CHANNEL map
15210 .quant8ChannelOperands = {},
15211 // int -> QUANT16_ASYMM map
15212 .quant16AsymmOperands = {},
15213 // int -> QUANT8_SYMM map
15214 .quant8SymmOperands = {},
15215 }
15216 },
15217 }, // End of an example
15218 };
15219 return examples_channel_nhwc_relaxed;
15220 };
15221
get_examples_channel_nhwc_relaxed_weight_as_input()15222 std::vector<MixedTypedExample>& get_examples_channel_nhwc_relaxed_weight_as_input() {
15223 static std::vector<MixedTypedExample> examples_channel_nhwc_relaxed_weight_as_input = {
15224 // Begin of an example
15225 {
15226 .operands = {
15227 //Input(s)
15228 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15229 // int -> Dimensions map
15230 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15231 // int -> FLOAT32 map
15232 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
15233 // int -> INT32 map
15234 .int32Operands = {},
15235 // int -> QUANT8_ASYMM map
15236 .quant8AsymmOperands = {},
15237 // int -> QUANT16_SYMM map
15238 .quant16SymmOperands = {},
15239 // int -> FLOAT16 map
15240 .float16Operands = {},
15241 // int -> BOOL8 map
15242 .bool8Operands = {},
15243 // int -> QUANT8_SYMM_PER_CHANNEL map
15244 .quant8ChannelOperands = {},
15245 // int -> QUANT16_ASYMM map
15246 .quant16AsymmOperands = {},
15247 // int -> QUANT8_SYMM map
15248 .quant8SymmOperands = {},
15249 },
15250 //Output(s)
15251 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15252 // int -> Dimensions map
15253 .operandDimensions = {{0, {1, 2, 2, 6}}},
15254 // int -> FLOAT32 map
15255 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
15256 // int -> INT32 map
15257 .int32Operands = {},
15258 // int -> QUANT8_ASYMM map
15259 .quant8AsymmOperands = {},
15260 // int -> QUANT16_SYMM map
15261 .quant16SymmOperands = {},
15262 // int -> FLOAT16 map
15263 .float16Operands = {},
15264 // int -> BOOL8 map
15265 .bool8Operands = {},
15266 // int -> QUANT8_SYMM_PER_CHANNEL map
15267 .quant8ChannelOperands = {},
15268 // int -> QUANT16_ASYMM map
15269 .quant16AsymmOperands = {},
15270 // int -> QUANT8_SYMM map
15271 .quant8SymmOperands = {},
15272 }
15273 },
15274 }, // End of an example
15275 };
15276 return examples_channel_nhwc_relaxed_weight_as_input;
15277 };
15278
get_examples_channel_nhwc_quant8()15279 std::vector<MixedTypedExample>& get_examples_channel_nhwc_quant8() {
15280 static std::vector<MixedTypedExample> examples_channel_nhwc_quant8 = {
15281 // Begin of an example
15282 {
15283 .operands = {
15284 //Input(s)
15285 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15286 // int -> Dimensions map
15287 .operandDimensions = {{0, {1, 2, 2, 9}}},
15288 // int -> FLOAT32 map
15289 .float32Operands = {},
15290 // int -> INT32 map
15291 .int32Operands = {},
15292 // int -> QUANT8_ASYMM map
15293 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}},
15294 // int -> QUANT16_SYMM map
15295 .quant16SymmOperands = {},
15296 // int -> FLOAT16 map
15297 .float16Operands = {},
15298 // int -> BOOL8 map
15299 .bool8Operands = {},
15300 // int -> QUANT8_SYMM_PER_CHANNEL map
15301 .quant8ChannelOperands = {},
15302 // int -> QUANT16_ASYMM map
15303 .quant16AsymmOperands = {},
15304 // int -> QUANT8_SYMM map
15305 .quant8SymmOperands = {},
15306 },
15307 //Output(s)
15308 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15309 // int -> Dimensions map
15310 .operandDimensions = {{0, {1, 2, 2, 6}}},
15311 // int -> FLOAT32 map
15312 .float32Operands = {},
15313 // int -> INT32 map
15314 .int32Operands = {},
15315 // int -> QUANT8_ASYMM map
15316 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
15317 // int -> QUANT16_SYMM map
15318 .quant16SymmOperands = {},
15319 // int -> FLOAT16 map
15320 .float16Operands = {},
15321 // int -> BOOL8 map
15322 .bool8Operands = {},
15323 // int -> QUANT8_SYMM_PER_CHANNEL map
15324 .quant8ChannelOperands = {},
15325 // int -> QUANT16_ASYMM map
15326 .quant16AsymmOperands = {},
15327 // int -> QUANT8_SYMM map
15328 .quant8SymmOperands = {},
15329 }
15330 },
15331 }, // End of an example
15332 };
15333 return examples_channel_nhwc_quant8;
15334 };
15335
get_examples_channel_nhwc_quant8_weight_as_input()15336 std::vector<MixedTypedExample>& get_examples_channel_nhwc_quant8_weight_as_input() {
15337 static std::vector<MixedTypedExample> examples_channel_nhwc_quant8_weight_as_input = {
15338 // Begin of an example
15339 {
15340 .operands = {
15341 //Input(s)
15342 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15343 // int -> Dimensions map
15344 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15345 // int -> FLOAT32 map
15346 .float32Operands = {},
15347 // int -> INT32 map
15348 .int32Operands = {{2, {80, -160, 240, -320, 400, -480}}},
15349 // int -> QUANT8_ASYMM map
15350 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}, {1, {4, 8, 12, 8, 4, 0, 8, 12, 12, 24, 24, 24, 36, 32, 20, 8, 4, 4}}},
15351 // int -> QUANT16_SYMM map
15352 .quant16SymmOperands = {},
15353 // int -> FLOAT16 map
15354 .float16Operands = {},
15355 // int -> BOOL8 map
15356 .bool8Operands = {},
15357 // int -> QUANT8_SYMM_PER_CHANNEL map
15358 .quant8ChannelOperands = {},
15359 // int -> QUANT16_ASYMM map
15360 .quant16AsymmOperands = {},
15361 // int -> QUANT8_SYMM map
15362 .quant8SymmOperands = {},
15363 },
15364 //Output(s)
15365 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15366 // int -> Dimensions map
15367 .operandDimensions = {{0, {1, 2, 2, 6}}},
15368 // int -> FLOAT32 map
15369 .float32Operands = {},
15370 // int -> INT32 map
15371 .int32Operands = {},
15372 // int -> QUANT8_ASYMM map
15373 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
15374 // int -> QUANT16_SYMM map
15375 .quant16SymmOperands = {},
15376 // int -> FLOAT16 map
15377 .float16Operands = {},
15378 // int -> BOOL8 map
15379 .bool8Operands = {},
15380 // int -> QUANT8_SYMM_PER_CHANNEL map
15381 .quant8ChannelOperands = {},
15382 // int -> QUANT16_ASYMM map
15383 .quant16AsymmOperands = {},
15384 // int -> QUANT8_SYMM map
15385 .quant8SymmOperands = {},
15386 }
15387 },
15388 }, // End of an example
15389 };
15390 return examples_channel_nhwc_quant8_weight_as_input;
15391 };
15392
get_examples_channel_nhwc_channelQuant8()15393 std::vector<MixedTypedExample>& get_examples_channel_nhwc_channelQuant8() {
15394 static std::vector<MixedTypedExample> examples_channel_nhwc_channelQuant8 = {
15395 // Begin of an example
15396 {
15397 .operands = {
15398 //Input(s)
15399 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15400 // int -> Dimensions map
15401 .operandDimensions = {{0, {1, 2, 2, 9}}},
15402 // int -> FLOAT32 map
15403 .float32Operands = {},
15404 // int -> INT32 map
15405 .int32Operands = {},
15406 // int -> QUANT8_ASYMM map
15407 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}},
15408 // int -> QUANT16_SYMM map
15409 .quant16SymmOperands = {},
15410 // int -> FLOAT16 map
15411 .float16Operands = {},
15412 // int -> BOOL8 map
15413 .bool8Operands = {},
15414 // int -> QUANT8_SYMM_PER_CHANNEL map
15415 .quant8ChannelOperands = {},
15416 // int -> QUANT16_ASYMM map
15417 .quant16AsymmOperands = {},
15418 // int -> QUANT8_SYMM map
15419 .quant8SymmOperands = {},
15420 },
15421 //Output(s)
15422 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15423 // int -> Dimensions map
15424 .operandDimensions = {{0, {1, 2, 2, 6}}},
15425 // int -> FLOAT32 map
15426 .float32Operands = {},
15427 // int -> INT32 map
15428 .int32Operands = {},
15429 // int -> QUANT8_ASYMM map
15430 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
15431 // int -> QUANT16_SYMM map
15432 .quant16SymmOperands = {},
15433 // int -> FLOAT16 map
15434 .float16Operands = {},
15435 // int -> BOOL8 map
15436 .bool8Operands = {},
15437 // int -> QUANT8_SYMM_PER_CHANNEL map
15438 .quant8ChannelOperands = {},
15439 // int -> QUANT16_ASYMM map
15440 .quant16AsymmOperands = {},
15441 // int -> QUANT8_SYMM map
15442 .quant8SymmOperands = {},
15443 }
15444 },
15445 }, // End of an example
15446 };
15447 return examples_channel_nhwc_channelQuant8;
15448 };
15449
get_examples_channel_nhwc_channelQuant8_weight_as_input()15450 std::vector<MixedTypedExample>& get_examples_channel_nhwc_channelQuant8_weight_as_input() {
15451 static std::vector<MixedTypedExample> examples_channel_nhwc_channelQuant8_weight_as_input = {
15452 // Begin of an example
15453 {
15454 .operands = {
15455 //Input(s)
15456 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15457 // int -> Dimensions map
15458 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15459 // int -> FLOAT32 map
15460 .float32Operands = {},
15461 // int -> INT32 map
15462 .int32Operands = {{2, {80, -133, 240, -267, 400, -400}}},
15463 // int -> QUANT8_ASYMM map
15464 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}},
15465 // int -> QUANT16_SYMM map
15466 .quant16SymmOperands = {},
15467 // int -> FLOAT16 map
15468 .float16Operands = {},
15469 // int -> BOOL8 map
15470 .bool8Operands = {},
15471 // int -> QUANT8_SYMM_PER_CHANNEL map
15472 .quant8ChannelOperands = {{1, {4, 8, 12, 7, 3, 0, 8, 12, 12, 20, 20, 20, 36, 32, 20, 7, 3, 3}}},
15473 // int -> QUANT16_ASYMM map
15474 .quant16AsymmOperands = {},
15475 // int -> QUANT8_SYMM map
15476 .quant8SymmOperands = {},
15477 },
15478 //Output(s)
15479 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15480 // int -> Dimensions map
15481 .operandDimensions = {{0, {1, 2, 2, 6}}},
15482 // int -> FLOAT32 map
15483 .float32Operands = {},
15484 // int -> INT32 map
15485 .int32Operands = {},
15486 // int -> QUANT8_ASYMM map
15487 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
15488 // int -> QUANT16_SYMM map
15489 .quant16SymmOperands = {},
15490 // int -> FLOAT16 map
15491 .float16Operands = {},
15492 // int -> BOOL8 map
15493 .bool8Operands = {},
15494 // int -> QUANT8_SYMM_PER_CHANNEL map
15495 .quant8ChannelOperands = {},
15496 // int -> QUANT16_ASYMM map
15497 .quant16AsymmOperands = {},
15498 // int -> QUANT8_SYMM map
15499 .quant8SymmOperands = {},
15500 }
15501 },
15502 }, // End of an example
15503 };
15504 return examples_channel_nhwc_channelQuant8_weight_as_input;
15505 };
15506
get_examples_channel_nhwc_float16()15507 std::vector<MixedTypedExample>& get_examples_channel_nhwc_float16() {
15508 static std::vector<MixedTypedExample> examples_channel_nhwc_float16 = {
15509 // Begin of an example
15510 {
15511 .operands = {
15512 //Input(s)
15513 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15514 // int -> Dimensions map
15515 .operandDimensions = {{0, {1, 2, 2, 9}}},
15516 // int -> FLOAT32 map
15517 .float32Operands = {},
15518 // int -> INT32 map
15519 .int32Operands = {},
15520 // int -> QUANT8_ASYMM map
15521 .quant8AsymmOperands = {},
15522 // int -> QUANT16_SYMM map
15523 .quant16SymmOperands = {},
15524 // int -> FLOAT16 map
15525 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}},
15526 // int -> BOOL8 map
15527 .bool8Operands = {},
15528 // int -> QUANT8_SYMM_PER_CHANNEL map
15529 .quant8ChannelOperands = {},
15530 // int -> QUANT16_ASYMM map
15531 .quant16AsymmOperands = {},
15532 // int -> QUANT8_SYMM map
15533 .quant8SymmOperands = {},
15534 },
15535 //Output(s)
15536 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15537 // int -> Dimensions map
15538 .operandDimensions = {{0, {1, 2, 2, 6}}},
15539 // int -> FLOAT32 map
15540 .float32Operands = {},
15541 // int -> INT32 map
15542 .int32Operands = {},
15543 // int -> QUANT8_ASYMM map
15544 .quant8AsymmOperands = {},
15545 // int -> QUANT16_SYMM map
15546 .quant16SymmOperands = {},
15547 // int -> FLOAT16 map
15548 .float16Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
15549 // int -> BOOL8 map
15550 .bool8Operands = {},
15551 // int -> QUANT8_SYMM_PER_CHANNEL map
15552 .quant8ChannelOperands = {},
15553 // int -> QUANT16_ASYMM map
15554 .quant16AsymmOperands = {},
15555 // int -> QUANT8_SYMM map
15556 .quant8SymmOperands = {},
15557 }
15558 },
15559 }, // End of an example
15560 };
15561 return examples_channel_nhwc_float16;
15562 };
15563
get_examples_channel_nhwc_float16_weight_as_input()15564 std::vector<MixedTypedExample>& get_examples_channel_nhwc_float16_weight_as_input() {
15565 static std::vector<MixedTypedExample> examples_channel_nhwc_float16_weight_as_input = {
15566 // Begin of an example
15567 {
15568 .operands = {
15569 //Input(s)
15570 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15571 // int -> Dimensions map
15572 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15573 // int -> FLOAT32 map
15574 .float32Operands = {},
15575 // int -> INT32 map
15576 .int32Operands = {},
15577 // int -> QUANT8_ASYMM map
15578 .quant8AsymmOperands = {},
15579 // int -> QUANT16_SYMM map
15580 .quant16SymmOperands = {},
15581 // int -> FLOAT16 map
15582 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
15583 // int -> BOOL8 map
15584 .bool8Operands = {},
15585 // int -> QUANT8_SYMM_PER_CHANNEL map
15586 .quant8ChannelOperands = {},
15587 // int -> QUANT16_ASYMM map
15588 .quant16AsymmOperands = {},
15589 // int -> QUANT8_SYMM map
15590 .quant8SymmOperands = {},
15591 },
15592 //Output(s)
15593 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15594 // int -> Dimensions map
15595 .operandDimensions = {{0, {1, 2, 2, 6}}},
15596 // int -> FLOAT32 map
15597 .float32Operands = {},
15598 // int -> INT32 map
15599 .int32Operands = {},
15600 // int -> QUANT8_ASYMM map
15601 .quant8AsymmOperands = {},
15602 // int -> QUANT16_SYMM map
15603 .quant16SymmOperands = {},
15604 // int -> FLOAT16 map
15605 .float16Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
15606 // int -> BOOL8 map
15607 .bool8Operands = {},
15608 // int -> QUANT8_SYMM_PER_CHANNEL map
15609 .quant8ChannelOperands = {},
15610 // int -> QUANT16_ASYMM map
15611 .quant16AsymmOperands = {},
15612 // int -> QUANT8_SYMM map
15613 .quant8SymmOperands = {},
15614 }
15615 },
15616 }, // End of an example
15617 };
15618 return examples_channel_nhwc_float16_weight_as_input;
15619 };
15620
get_examples_channel_nchw()15621 std::vector<MixedTypedExample>& get_examples_channel_nchw() {
15622 static std::vector<MixedTypedExample> examples_channel_nchw = {
15623 // Begin of an example
15624 {
15625 .operands = {
15626 //Input(s)
15627 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15628 // int -> Dimensions map
15629 .operandDimensions = {{0, {1, 9, 2, 2}}},
15630 // int -> FLOAT32 map
15631 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}},
15632 // int -> INT32 map
15633 .int32Operands = {},
15634 // int -> QUANT8_ASYMM map
15635 .quant8AsymmOperands = {},
15636 // int -> QUANT16_SYMM map
15637 .quant16SymmOperands = {},
15638 // int -> FLOAT16 map
15639 .float16Operands = {},
15640 // int -> BOOL8 map
15641 .bool8Operands = {},
15642 // int -> QUANT8_SYMM_PER_CHANNEL map
15643 .quant8ChannelOperands = {},
15644 // int -> QUANT16_ASYMM map
15645 .quant16AsymmOperands = {},
15646 // int -> QUANT8_SYMM map
15647 .quant8SymmOperands = {},
15648 },
15649 //Output(s)
15650 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15651 // int -> Dimensions map
15652 .operandDimensions = {{0, {1, 6, 2, 2}}},
15653 // int -> FLOAT32 map
15654 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
15655 // int -> INT32 map
15656 .int32Operands = {},
15657 // int -> QUANT8_ASYMM map
15658 .quant8AsymmOperands = {},
15659 // int -> QUANT16_SYMM map
15660 .quant16SymmOperands = {},
15661 // int -> FLOAT16 map
15662 .float16Operands = {},
15663 // int -> BOOL8 map
15664 .bool8Operands = {},
15665 // int -> QUANT8_SYMM_PER_CHANNEL map
15666 .quant8ChannelOperands = {},
15667 // int -> QUANT16_ASYMM map
15668 .quant16AsymmOperands = {},
15669 // int -> QUANT8_SYMM map
15670 .quant8SymmOperands = {},
15671 }
15672 },
15673 }, // End of an example
15674 };
15675 return examples_channel_nchw;
15676 };
15677
get_examples_channel_nchw_weight_as_input()15678 std::vector<MixedTypedExample>& get_examples_channel_nchw_weight_as_input() {
15679 static std::vector<MixedTypedExample> examples_channel_nchw_weight_as_input = {
15680 // Begin of an example
15681 {
15682 .operands = {
15683 //Input(s)
15684 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15685 // int -> Dimensions map
15686 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15687 // int -> FLOAT32 map
15688 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
15689 // int -> INT32 map
15690 .int32Operands = {},
15691 // int -> QUANT8_ASYMM map
15692 .quant8AsymmOperands = {},
15693 // int -> QUANT16_SYMM map
15694 .quant16SymmOperands = {},
15695 // int -> FLOAT16 map
15696 .float16Operands = {},
15697 // int -> BOOL8 map
15698 .bool8Operands = {},
15699 // int -> QUANT8_SYMM_PER_CHANNEL map
15700 .quant8ChannelOperands = {},
15701 // int -> QUANT16_ASYMM map
15702 .quant16AsymmOperands = {},
15703 // int -> QUANT8_SYMM map
15704 .quant8SymmOperands = {},
15705 },
15706 //Output(s)
15707 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15708 // int -> Dimensions map
15709 .operandDimensions = {{0, {1, 6, 2, 2}}},
15710 // int -> FLOAT32 map
15711 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
15712 // int -> INT32 map
15713 .int32Operands = {},
15714 // int -> QUANT8_ASYMM map
15715 .quant8AsymmOperands = {},
15716 // int -> QUANT16_SYMM map
15717 .quant16SymmOperands = {},
15718 // int -> FLOAT16 map
15719 .float16Operands = {},
15720 // int -> BOOL8 map
15721 .bool8Operands = {},
15722 // int -> QUANT8_SYMM_PER_CHANNEL map
15723 .quant8ChannelOperands = {},
15724 // int -> QUANT16_ASYMM map
15725 .quant16AsymmOperands = {},
15726 // int -> QUANT8_SYMM map
15727 .quant8SymmOperands = {},
15728 }
15729 },
15730 }, // End of an example
15731 };
15732 return examples_channel_nchw_weight_as_input;
15733 };
15734
get_examples_channel_nchw_relaxed()15735 std::vector<MixedTypedExample>& get_examples_channel_nchw_relaxed() {
15736 static std::vector<MixedTypedExample> examples_channel_nchw_relaxed = {
15737 // Begin of an example
15738 {
15739 .operands = {
15740 //Input(s)
15741 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15742 // int -> Dimensions map
15743 .operandDimensions = {{0, {1, 9, 2, 2}}},
15744 // int -> FLOAT32 map
15745 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}},
15746 // int -> INT32 map
15747 .int32Operands = {},
15748 // int -> QUANT8_ASYMM map
15749 .quant8AsymmOperands = {},
15750 // int -> QUANT16_SYMM map
15751 .quant16SymmOperands = {},
15752 // int -> FLOAT16 map
15753 .float16Operands = {},
15754 // int -> BOOL8 map
15755 .bool8Operands = {},
15756 // int -> QUANT8_SYMM_PER_CHANNEL map
15757 .quant8ChannelOperands = {},
15758 // int -> QUANT16_ASYMM map
15759 .quant16AsymmOperands = {},
15760 // int -> QUANT8_SYMM map
15761 .quant8SymmOperands = {},
15762 },
15763 //Output(s)
15764 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15765 // int -> Dimensions map
15766 .operandDimensions = {{0, {1, 6, 2, 2}}},
15767 // int -> FLOAT32 map
15768 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
15769 // int -> INT32 map
15770 .int32Operands = {},
15771 // int -> QUANT8_ASYMM map
15772 .quant8AsymmOperands = {},
15773 // int -> QUANT16_SYMM map
15774 .quant16SymmOperands = {},
15775 // int -> FLOAT16 map
15776 .float16Operands = {},
15777 // int -> BOOL8 map
15778 .bool8Operands = {},
15779 // int -> QUANT8_SYMM_PER_CHANNEL map
15780 .quant8ChannelOperands = {},
15781 // int -> QUANT16_ASYMM map
15782 .quant16AsymmOperands = {},
15783 // int -> QUANT8_SYMM map
15784 .quant8SymmOperands = {},
15785 }
15786 },
15787 }, // End of an example
15788 };
15789 return examples_channel_nchw_relaxed;
15790 };
15791
get_examples_channel_nchw_relaxed_weight_as_input()15792 std::vector<MixedTypedExample>& get_examples_channel_nchw_relaxed_weight_as_input() {
15793 static std::vector<MixedTypedExample> examples_channel_nchw_relaxed_weight_as_input = {
15794 // Begin of an example
15795 {
15796 .operands = {
15797 //Input(s)
15798 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15799 // int -> Dimensions map
15800 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15801 // int -> FLOAT32 map
15802 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
15803 // int -> INT32 map
15804 .int32Operands = {},
15805 // int -> QUANT8_ASYMM map
15806 .quant8AsymmOperands = {},
15807 // int -> QUANT16_SYMM map
15808 .quant16SymmOperands = {},
15809 // int -> FLOAT16 map
15810 .float16Operands = {},
15811 // int -> BOOL8 map
15812 .bool8Operands = {},
15813 // int -> QUANT8_SYMM_PER_CHANNEL map
15814 .quant8ChannelOperands = {},
15815 // int -> QUANT16_ASYMM map
15816 .quant16AsymmOperands = {},
15817 // int -> QUANT8_SYMM map
15818 .quant8SymmOperands = {},
15819 },
15820 //Output(s)
15821 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15822 // int -> Dimensions map
15823 .operandDimensions = {{0, {1, 6, 2, 2}}},
15824 // int -> FLOAT32 map
15825 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
15826 // int -> INT32 map
15827 .int32Operands = {},
15828 // int -> QUANT8_ASYMM map
15829 .quant8AsymmOperands = {},
15830 // int -> QUANT16_SYMM map
15831 .quant16SymmOperands = {},
15832 // int -> FLOAT16 map
15833 .float16Operands = {},
15834 // int -> BOOL8 map
15835 .bool8Operands = {},
15836 // int -> QUANT8_SYMM_PER_CHANNEL map
15837 .quant8ChannelOperands = {},
15838 // int -> QUANT16_ASYMM map
15839 .quant16AsymmOperands = {},
15840 // int -> QUANT8_SYMM map
15841 .quant8SymmOperands = {},
15842 }
15843 },
15844 }, // End of an example
15845 };
15846 return examples_channel_nchw_relaxed_weight_as_input;
15847 };
15848
get_examples_channel_nchw_quant8()15849 std::vector<MixedTypedExample>& get_examples_channel_nchw_quant8() {
15850 static std::vector<MixedTypedExample> examples_channel_nchw_quant8 = {
15851 // Begin of an example
15852 {
15853 .operands = {
15854 //Input(s)
15855 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15856 // int -> Dimensions map
15857 .operandDimensions = {{0, {1, 9, 2, 2}}},
15858 // int -> FLOAT32 map
15859 .float32Operands = {},
15860 // int -> INT32 map
15861 .int32Operands = {},
15862 // int -> QUANT8_ASYMM map
15863 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}},
15864 // int -> QUANT16_SYMM map
15865 .quant16SymmOperands = {},
15866 // int -> FLOAT16 map
15867 .float16Operands = {},
15868 // int -> BOOL8 map
15869 .bool8Operands = {},
15870 // int -> QUANT8_SYMM_PER_CHANNEL map
15871 .quant8ChannelOperands = {},
15872 // int -> QUANT16_ASYMM map
15873 .quant16AsymmOperands = {},
15874 // int -> QUANT8_SYMM map
15875 .quant8SymmOperands = {},
15876 },
15877 //Output(s)
15878 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15879 // int -> Dimensions map
15880 .operandDimensions = {{0, {1, 6, 2, 2}}},
15881 // int -> FLOAT32 map
15882 .float32Operands = {},
15883 // int -> INT32 map
15884 .int32Operands = {},
15885 // int -> QUANT8_ASYMM map
15886 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
15887 // int -> QUANT16_SYMM map
15888 .quant16SymmOperands = {},
15889 // int -> FLOAT16 map
15890 .float16Operands = {},
15891 // int -> BOOL8 map
15892 .bool8Operands = {},
15893 // int -> QUANT8_SYMM_PER_CHANNEL map
15894 .quant8ChannelOperands = {},
15895 // int -> QUANT16_ASYMM map
15896 .quant16AsymmOperands = {},
15897 // int -> QUANT8_SYMM map
15898 .quant8SymmOperands = {},
15899 }
15900 },
15901 }, // End of an example
15902 };
15903 return examples_channel_nchw_quant8;
15904 };
15905
get_examples_channel_nchw_quant8_weight_as_input()15906 std::vector<MixedTypedExample>& get_examples_channel_nchw_quant8_weight_as_input() {
15907 static std::vector<MixedTypedExample> examples_channel_nchw_quant8_weight_as_input = {
15908 // Begin of an example
15909 {
15910 .operands = {
15911 //Input(s)
15912 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15913 // int -> Dimensions map
15914 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
15915 // int -> FLOAT32 map
15916 .float32Operands = {},
15917 // int -> INT32 map
15918 .int32Operands = {{2, {80, -160, 240, -320, 400, -480}}},
15919 // int -> QUANT8_ASYMM map
15920 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}, {1, {4, 8, 12, 8, 4, 0, 8, 12, 12, 24, 24, 24, 36, 32, 20, 8, 4, 4}}},
15921 // int -> QUANT16_SYMM map
15922 .quant16SymmOperands = {},
15923 // int -> FLOAT16 map
15924 .float16Operands = {},
15925 // int -> BOOL8 map
15926 .bool8Operands = {},
15927 // int -> QUANT8_SYMM_PER_CHANNEL map
15928 .quant8ChannelOperands = {},
15929 // int -> QUANT16_ASYMM map
15930 .quant16AsymmOperands = {},
15931 // int -> QUANT8_SYMM map
15932 .quant8SymmOperands = {},
15933 },
15934 //Output(s)
15935 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15936 // int -> Dimensions map
15937 .operandDimensions = {{0, {1, 6, 2, 2}}},
15938 // int -> FLOAT32 map
15939 .float32Operands = {},
15940 // int -> INT32 map
15941 .int32Operands = {},
15942 // int -> QUANT8_ASYMM map
15943 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
15944 // int -> QUANT16_SYMM map
15945 .quant16SymmOperands = {},
15946 // int -> FLOAT16 map
15947 .float16Operands = {},
15948 // int -> BOOL8 map
15949 .bool8Operands = {},
15950 // int -> QUANT8_SYMM_PER_CHANNEL map
15951 .quant8ChannelOperands = {},
15952 // int -> QUANT16_ASYMM map
15953 .quant16AsymmOperands = {},
15954 // int -> QUANT8_SYMM map
15955 .quant8SymmOperands = {},
15956 }
15957 },
15958 }, // End of an example
15959 };
15960 return examples_channel_nchw_quant8_weight_as_input;
15961 };
15962
get_examples_channel_nchw_channelQuant8()15963 std::vector<MixedTypedExample>& get_examples_channel_nchw_channelQuant8() {
15964 static std::vector<MixedTypedExample> examples_channel_nchw_channelQuant8 = {
15965 // Begin of an example
15966 {
15967 .operands = {
15968 //Input(s)
15969 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15970 // int -> Dimensions map
15971 .operandDimensions = {{0, {1, 9, 2, 2}}},
15972 // int -> FLOAT32 map
15973 .float32Operands = {},
15974 // int -> INT32 map
15975 .int32Operands = {},
15976 // int -> QUANT8_ASYMM map
15977 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}},
15978 // int -> QUANT16_SYMM map
15979 .quant16SymmOperands = {},
15980 // int -> FLOAT16 map
15981 .float16Operands = {},
15982 // int -> BOOL8 map
15983 .bool8Operands = {},
15984 // int -> QUANT8_SYMM_PER_CHANNEL map
15985 .quant8ChannelOperands = {},
15986 // int -> QUANT16_ASYMM map
15987 .quant16AsymmOperands = {},
15988 // int -> QUANT8_SYMM map
15989 .quant8SymmOperands = {},
15990 },
15991 //Output(s)
15992 { // See tools/test_generator/include/TestHarness.h:MixedTyped
15993 // int -> Dimensions map
15994 .operandDimensions = {{0, {1, 6, 2, 2}}},
15995 // int -> FLOAT32 map
15996 .float32Operands = {},
15997 // int -> INT32 map
15998 .int32Operands = {},
15999 // int -> QUANT8_ASYMM map
16000 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
16001 // int -> QUANT16_SYMM map
16002 .quant16SymmOperands = {},
16003 // int -> FLOAT16 map
16004 .float16Operands = {},
16005 // int -> BOOL8 map
16006 .bool8Operands = {},
16007 // int -> QUANT8_SYMM_PER_CHANNEL map
16008 .quant8ChannelOperands = {},
16009 // int -> QUANT16_ASYMM map
16010 .quant16AsymmOperands = {},
16011 // int -> QUANT8_SYMM map
16012 .quant8SymmOperands = {},
16013 }
16014 },
16015 }, // End of an example
16016 };
16017 return examples_channel_nchw_channelQuant8;
16018 };
16019
get_examples_channel_nchw_channelQuant8_weight_as_input()16020 std::vector<MixedTypedExample>& get_examples_channel_nchw_channelQuant8_weight_as_input() {
16021 static std::vector<MixedTypedExample> examples_channel_nchw_channelQuant8_weight_as_input = {
16022 // Begin of an example
16023 {
16024 .operands = {
16025 //Input(s)
16026 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16027 // int -> Dimensions map
16028 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16029 // int -> FLOAT32 map
16030 .float32Operands = {},
16031 // int -> INT32 map
16032 .int32Operands = {{2, {80, -133, 240, -267, 400, -400}}},
16033 // int -> QUANT8_ASYMM map
16034 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}},
16035 // int -> QUANT16_SYMM map
16036 .quant16SymmOperands = {},
16037 // int -> FLOAT16 map
16038 .float16Operands = {},
16039 // int -> BOOL8 map
16040 .bool8Operands = {},
16041 // int -> QUANT8_SYMM_PER_CHANNEL map
16042 .quant8ChannelOperands = {{1, {4, 8, 12, 7, 3, 0, 8, 12, 12, 20, 20, 20, 36, 32, 20, 7, 3, 3}}},
16043 // int -> QUANT16_ASYMM map
16044 .quant16AsymmOperands = {},
16045 // int -> QUANT8_SYMM map
16046 .quant8SymmOperands = {},
16047 },
16048 //Output(s)
16049 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16050 // int -> Dimensions map
16051 .operandDimensions = {{0, {1, 6, 2, 2}}},
16052 // int -> FLOAT32 map
16053 .float32Operands = {},
16054 // int -> INT32 map
16055 .int32Operands = {},
16056 // int -> QUANT8_ASYMM map
16057 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
16058 // int -> QUANT16_SYMM map
16059 .quant16SymmOperands = {},
16060 // int -> FLOAT16 map
16061 .float16Operands = {},
16062 // int -> BOOL8 map
16063 .bool8Operands = {},
16064 // int -> QUANT8_SYMM_PER_CHANNEL map
16065 .quant8ChannelOperands = {},
16066 // int -> QUANT16_ASYMM map
16067 .quant16AsymmOperands = {},
16068 // int -> QUANT8_SYMM map
16069 .quant8SymmOperands = {},
16070 }
16071 },
16072 }, // End of an example
16073 };
16074 return examples_channel_nchw_channelQuant8_weight_as_input;
16075 };
16076
get_examples_channel_nchw_float16()16077 std::vector<MixedTypedExample>& get_examples_channel_nchw_float16() {
16078 static std::vector<MixedTypedExample> examples_channel_nchw_float16 = {
16079 // Begin of an example
16080 {
16081 .operands = {
16082 //Input(s)
16083 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16084 // int -> Dimensions map
16085 .operandDimensions = {{0, {1, 9, 2, 2}}},
16086 // int -> FLOAT32 map
16087 .float32Operands = {},
16088 // int -> INT32 map
16089 .int32Operands = {},
16090 // int -> QUANT8_ASYMM map
16091 .quant8AsymmOperands = {},
16092 // int -> QUANT16_SYMM map
16093 .quant16SymmOperands = {},
16094 // int -> FLOAT16 map
16095 .float16Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}},
16096 // int -> BOOL8 map
16097 .bool8Operands = {},
16098 // int -> QUANT8_SYMM_PER_CHANNEL map
16099 .quant8ChannelOperands = {},
16100 // int -> QUANT16_ASYMM map
16101 .quant16AsymmOperands = {},
16102 // int -> QUANT8_SYMM map
16103 .quant8SymmOperands = {},
16104 },
16105 //Output(s)
16106 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16107 // int -> Dimensions map
16108 .operandDimensions = {{0, {1, 6, 2, 2}}},
16109 // int -> FLOAT32 map
16110 .float32Operands = {},
16111 // int -> INT32 map
16112 .int32Operands = {},
16113 // int -> QUANT8_ASYMM map
16114 .quant8AsymmOperands = {},
16115 // int -> QUANT16_SYMM map
16116 .quant16SymmOperands = {},
16117 // int -> FLOAT16 map
16118 .float16Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
16119 // int -> BOOL8 map
16120 .bool8Operands = {},
16121 // int -> QUANT8_SYMM_PER_CHANNEL map
16122 .quant8ChannelOperands = {},
16123 // int -> QUANT16_ASYMM map
16124 .quant16AsymmOperands = {},
16125 // int -> QUANT8_SYMM map
16126 .quant8SymmOperands = {},
16127 }
16128 },
16129 }, // End of an example
16130 };
16131 return examples_channel_nchw_float16;
16132 };
16133
get_examples_channel_nchw_float16_weight_as_input()16134 std::vector<MixedTypedExample>& get_examples_channel_nchw_float16_weight_as_input() {
16135 static std::vector<MixedTypedExample> examples_channel_nchw_float16_weight_as_input = {
16136 // Begin of an example
16137 {
16138 .operands = {
16139 //Input(s)
16140 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16141 // int -> Dimensions map
16142 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16143 // int -> FLOAT32 map
16144 .float32Operands = {},
16145 // int -> INT32 map
16146 .int32Operands = {},
16147 // int -> QUANT8_ASYMM map
16148 .quant8AsymmOperands = {},
16149 // int -> QUANT16_SYMM map
16150 .quant16SymmOperands = {},
16151 // int -> FLOAT16 map
16152 .float16Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
16153 // int -> BOOL8 map
16154 .bool8Operands = {},
16155 // int -> QUANT8_SYMM_PER_CHANNEL map
16156 .quant8ChannelOperands = {},
16157 // int -> QUANT16_ASYMM map
16158 .quant16AsymmOperands = {},
16159 // int -> QUANT8_SYMM map
16160 .quant8SymmOperands = {},
16161 },
16162 //Output(s)
16163 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16164 // int -> Dimensions map
16165 .operandDimensions = {{0, {1, 6, 2, 2}}},
16166 // int -> FLOAT32 map
16167 .float32Operands = {},
16168 // int -> INT32 map
16169 .int32Operands = {},
16170 // int -> QUANT8_ASYMM map
16171 .quant8AsymmOperands = {},
16172 // int -> QUANT16_SYMM map
16173 .quant16SymmOperands = {},
16174 // int -> FLOAT16 map
16175 .float16Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
16176 // int -> BOOL8 map
16177 .bool8Operands = {},
16178 // int -> QUANT8_SYMM_PER_CHANNEL map
16179 .quant8ChannelOperands = {},
16180 // int -> QUANT16_ASYMM map
16181 .quant16AsymmOperands = {},
16182 // int -> QUANT8_SYMM map
16183 .quant8SymmOperands = {},
16184 }
16185 },
16186 }, // End of an example
16187 };
16188 return examples_channel_nchw_float16_weight_as_input;
16189 };
16190
get_examples_channel_dynamic_output_shape_nhwc()16191 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc() {
16192 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc = {
16193 // Begin of an example
16194 {
16195 .operands = {
16196 //Input(s)
16197 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16198 // int -> Dimensions map
16199 .operandDimensions = {{0, {1, 2, 2, 9}}},
16200 // int -> FLOAT32 map
16201 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}},
16202 // int -> INT32 map
16203 .int32Operands = {},
16204 // int -> QUANT8_ASYMM map
16205 .quant8AsymmOperands = {},
16206 // int -> QUANT16_SYMM map
16207 .quant16SymmOperands = {},
16208 // int -> FLOAT16 map
16209 .float16Operands = {},
16210 // int -> BOOL8 map
16211 .bool8Operands = {},
16212 // int -> QUANT8_SYMM_PER_CHANNEL map
16213 .quant8ChannelOperands = {},
16214 // int -> QUANT16_ASYMM map
16215 .quant16AsymmOperands = {},
16216 // int -> QUANT8_SYMM map
16217 .quant8SymmOperands = {},
16218 },
16219 //Output(s)
16220 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16221 // int -> Dimensions map
16222 .operandDimensions = {{0, {1, 2, 2, 6}}},
16223 // int -> FLOAT32 map
16224 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
16225 // int -> INT32 map
16226 .int32Operands = {},
16227 // int -> QUANT8_ASYMM map
16228 .quant8AsymmOperands = {},
16229 // int -> QUANT16_SYMM map
16230 .quant16SymmOperands = {},
16231 // int -> FLOAT16 map
16232 .float16Operands = {},
16233 // int -> BOOL8 map
16234 .bool8Operands = {},
16235 // int -> QUANT8_SYMM_PER_CHANNEL map
16236 .quant8ChannelOperands = {},
16237 // int -> QUANT16_ASYMM map
16238 .quant16AsymmOperands = {},
16239 // int -> QUANT8_SYMM map
16240 .quant8SymmOperands = {},
16241 }
16242 },
16243 }, // End of an example
16244 };
16245 return examples_channel_dynamic_output_shape_nhwc;
16246 };
16247
get_examples_channel_dynamic_output_shape_nhwc_weight_as_input()16248 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_weight_as_input() {
16249 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_weight_as_input = {
16250 // Begin of an example
16251 {
16252 .operands = {
16253 //Input(s)
16254 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16255 // int -> Dimensions map
16256 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16257 // int -> FLOAT32 map
16258 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
16259 // int -> INT32 map
16260 .int32Operands = {},
16261 // int -> QUANT8_ASYMM map
16262 .quant8AsymmOperands = {},
16263 // int -> QUANT16_SYMM map
16264 .quant16SymmOperands = {},
16265 // int -> FLOAT16 map
16266 .float16Operands = {},
16267 // int -> BOOL8 map
16268 .bool8Operands = {},
16269 // int -> QUANT8_SYMM_PER_CHANNEL map
16270 .quant8ChannelOperands = {},
16271 // int -> QUANT16_ASYMM map
16272 .quant16AsymmOperands = {},
16273 // int -> QUANT8_SYMM map
16274 .quant8SymmOperands = {},
16275 },
16276 //Output(s)
16277 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16278 // int -> Dimensions map
16279 .operandDimensions = {{0, {1, 2, 2, 6}}},
16280 // int -> FLOAT32 map
16281 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
16282 // int -> INT32 map
16283 .int32Operands = {},
16284 // int -> QUANT8_ASYMM map
16285 .quant8AsymmOperands = {},
16286 // int -> QUANT16_SYMM map
16287 .quant16SymmOperands = {},
16288 // int -> FLOAT16 map
16289 .float16Operands = {},
16290 // int -> BOOL8 map
16291 .bool8Operands = {},
16292 // int -> QUANT8_SYMM_PER_CHANNEL map
16293 .quant8ChannelOperands = {},
16294 // int -> QUANT16_ASYMM map
16295 .quant16AsymmOperands = {},
16296 // int -> QUANT8_SYMM map
16297 .quant8SymmOperands = {},
16298 }
16299 },
16300 }, // End of an example
16301 };
16302 return examples_channel_dynamic_output_shape_nhwc_weight_as_input;
16303 };
16304
get_examples_channel_dynamic_output_shape_nhwc_relaxed()16305 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_relaxed() {
16306 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_relaxed = {
16307 // Begin of an example
16308 {
16309 .operands = {
16310 //Input(s)
16311 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16312 // int -> Dimensions map
16313 .operandDimensions = {{0, {1, 2, 2, 9}}},
16314 // int -> FLOAT32 map
16315 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}},
16316 // int -> INT32 map
16317 .int32Operands = {},
16318 // int -> QUANT8_ASYMM map
16319 .quant8AsymmOperands = {},
16320 // int -> QUANT16_SYMM map
16321 .quant16SymmOperands = {},
16322 // int -> FLOAT16 map
16323 .float16Operands = {},
16324 // int -> BOOL8 map
16325 .bool8Operands = {},
16326 // int -> QUANT8_SYMM_PER_CHANNEL map
16327 .quant8ChannelOperands = {},
16328 // int -> QUANT16_ASYMM map
16329 .quant16AsymmOperands = {},
16330 // int -> QUANT8_SYMM map
16331 .quant8SymmOperands = {},
16332 },
16333 //Output(s)
16334 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16335 // int -> Dimensions map
16336 .operandDimensions = {{0, {1, 2, 2, 6}}},
16337 // int -> FLOAT32 map
16338 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
16339 // int -> INT32 map
16340 .int32Operands = {},
16341 // int -> QUANT8_ASYMM map
16342 .quant8AsymmOperands = {},
16343 // int -> QUANT16_SYMM map
16344 .quant16SymmOperands = {},
16345 // int -> FLOAT16 map
16346 .float16Operands = {},
16347 // int -> BOOL8 map
16348 .bool8Operands = {},
16349 // int -> QUANT8_SYMM_PER_CHANNEL map
16350 .quant8ChannelOperands = {},
16351 // int -> QUANT16_ASYMM map
16352 .quant16AsymmOperands = {},
16353 // int -> QUANT8_SYMM map
16354 .quant8SymmOperands = {},
16355 }
16356 },
16357 }, // End of an example
16358 };
16359 return examples_channel_dynamic_output_shape_nhwc_relaxed;
16360 };
16361
get_examples_channel_dynamic_output_shape_nhwc_relaxed_weight_as_input()16362 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_relaxed_weight_as_input() {
16363 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_relaxed_weight_as_input = {
16364 // Begin of an example
16365 {
16366 .operands = {
16367 //Input(s)
16368 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16369 // int -> Dimensions map
16370 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16371 // int -> FLOAT32 map
16372 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
16373 // int -> INT32 map
16374 .int32Operands = {},
16375 // int -> QUANT8_ASYMM map
16376 .quant8AsymmOperands = {},
16377 // int -> QUANT16_SYMM map
16378 .quant16SymmOperands = {},
16379 // int -> FLOAT16 map
16380 .float16Operands = {},
16381 // int -> BOOL8 map
16382 .bool8Operands = {},
16383 // int -> QUANT8_SYMM_PER_CHANNEL map
16384 .quant8ChannelOperands = {},
16385 // int -> QUANT16_ASYMM map
16386 .quant16AsymmOperands = {},
16387 // int -> QUANT8_SYMM map
16388 .quant8SymmOperands = {},
16389 },
16390 //Output(s)
16391 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16392 // int -> Dimensions map
16393 .operandDimensions = {{0, {1, 2, 2, 6}}},
16394 // int -> FLOAT32 map
16395 .float32Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
16396 // int -> INT32 map
16397 .int32Operands = {},
16398 // int -> QUANT8_ASYMM map
16399 .quant8AsymmOperands = {},
16400 // int -> QUANT16_SYMM map
16401 .quant16SymmOperands = {},
16402 // int -> FLOAT16 map
16403 .float16Operands = {},
16404 // int -> BOOL8 map
16405 .bool8Operands = {},
16406 // int -> QUANT8_SYMM_PER_CHANNEL map
16407 .quant8ChannelOperands = {},
16408 // int -> QUANT16_ASYMM map
16409 .quant16AsymmOperands = {},
16410 // int -> QUANT8_SYMM map
16411 .quant8SymmOperands = {},
16412 }
16413 },
16414 }, // End of an example
16415 };
16416 return examples_channel_dynamic_output_shape_nhwc_relaxed_weight_as_input;
16417 };
16418
get_examples_channel_dynamic_output_shape_nhwc_quant8()16419 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_quant8() {
16420 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_quant8 = {
16421 // Begin of an example
16422 {
16423 .operands = {
16424 //Input(s)
16425 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16426 // int -> Dimensions map
16427 .operandDimensions = {{0, {1, 2, 2, 9}}},
16428 // int -> FLOAT32 map
16429 .float32Operands = {},
16430 // int -> INT32 map
16431 .int32Operands = {},
16432 // int -> QUANT8_ASYMM map
16433 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}},
16434 // int -> QUANT16_SYMM map
16435 .quant16SymmOperands = {},
16436 // int -> FLOAT16 map
16437 .float16Operands = {},
16438 // int -> BOOL8 map
16439 .bool8Operands = {},
16440 // int -> QUANT8_SYMM_PER_CHANNEL map
16441 .quant8ChannelOperands = {},
16442 // int -> QUANT16_ASYMM map
16443 .quant16AsymmOperands = {},
16444 // int -> QUANT8_SYMM map
16445 .quant8SymmOperands = {},
16446 },
16447 //Output(s)
16448 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16449 // int -> Dimensions map
16450 .operandDimensions = {{0, {1, 2, 2, 6}}},
16451 // int -> FLOAT32 map
16452 .float32Operands = {},
16453 // int -> INT32 map
16454 .int32Operands = {},
16455 // int -> QUANT8_ASYMM map
16456 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
16457 // int -> QUANT16_SYMM map
16458 .quant16SymmOperands = {},
16459 // int -> FLOAT16 map
16460 .float16Operands = {},
16461 // int -> BOOL8 map
16462 .bool8Operands = {},
16463 // int -> QUANT8_SYMM_PER_CHANNEL map
16464 .quant8ChannelOperands = {},
16465 // int -> QUANT16_ASYMM map
16466 .quant16AsymmOperands = {},
16467 // int -> QUANT8_SYMM map
16468 .quant8SymmOperands = {},
16469 }
16470 },
16471 }, // End of an example
16472 };
16473 return examples_channel_dynamic_output_shape_nhwc_quant8;
16474 };
16475
get_examples_channel_dynamic_output_shape_nhwc_quant8_weight_as_input()16476 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_quant8_weight_as_input() {
16477 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_quant8_weight_as_input = {
16478 // Begin of an example
16479 {
16480 .operands = {
16481 //Input(s)
16482 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16483 // int -> Dimensions map
16484 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16485 // int -> FLOAT32 map
16486 .float32Operands = {},
16487 // int -> INT32 map
16488 .int32Operands = {{2, {80, -160, 240, -320, 400, -480}}},
16489 // int -> QUANT8_ASYMM map
16490 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}, {1, {4, 8, 12, 8, 4, 0, 8, 12, 12, 24, 24, 24, 36, 32, 20, 8, 4, 4}}},
16491 // int -> QUANT16_SYMM map
16492 .quant16SymmOperands = {},
16493 // int -> FLOAT16 map
16494 .float16Operands = {},
16495 // int -> BOOL8 map
16496 .bool8Operands = {},
16497 // int -> QUANT8_SYMM_PER_CHANNEL map
16498 .quant8ChannelOperands = {},
16499 // int -> QUANT16_ASYMM map
16500 .quant16AsymmOperands = {},
16501 // int -> QUANT8_SYMM map
16502 .quant8SymmOperands = {},
16503 },
16504 //Output(s)
16505 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16506 // int -> Dimensions map
16507 .operandDimensions = {{0, {1, 2, 2, 6}}},
16508 // int -> FLOAT32 map
16509 .float32Operands = {},
16510 // int -> INT32 map
16511 .int32Operands = {},
16512 // int -> QUANT8_ASYMM map
16513 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
16514 // int -> QUANT16_SYMM map
16515 .quant16SymmOperands = {},
16516 // int -> FLOAT16 map
16517 .float16Operands = {},
16518 // int -> BOOL8 map
16519 .bool8Operands = {},
16520 // int -> QUANT8_SYMM_PER_CHANNEL map
16521 .quant8ChannelOperands = {},
16522 // int -> QUANT16_ASYMM map
16523 .quant16AsymmOperands = {},
16524 // int -> QUANT8_SYMM map
16525 .quant8SymmOperands = {},
16526 }
16527 },
16528 }, // End of an example
16529 };
16530 return examples_channel_dynamic_output_shape_nhwc_quant8_weight_as_input;
16531 };
16532
get_examples_channel_dynamic_output_shape_nhwc_channelQuant8()16533 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_channelQuant8() {
16534 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_channelQuant8 = {
16535 // Begin of an example
16536 {
16537 .operands = {
16538 //Input(s)
16539 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16540 // int -> Dimensions map
16541 .operandDimensions = {{0, {1, 2, 2, 9}}},
16542 // int -> FLOAT32 map
16543 .float32Operands = {},
16544 // int -> INT32 map
16545 .int32Operands = {},
16546 // int -> QUANT8_ASYMM map
16547 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}},
16548 // int -> QUANT16_SYMM map
16549 .quant16SymmOperands = {},
16550 // int -> FLOAT16 map
16551 .float16Operands = {},
16552 // int -> BOOL8 map
16553 .bool8Operands = {},
16554 // int -> QUANT8_SYMM_PER_CHANNEL map
16555 .quant8ChannelOperands = {},
16556 // int -> QUANT16_ASYMM map
16557 .quant16AsymmOperands = {},
16558 // int -> QUANT8_SYMM map
16559 .quant8SymmOperands = {},
16560 },
16561 //Output(s)
16562 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16563 // int -> Dimensions map
16564 .operandDimensions = {{0, {1, 2, 2, 6}}},
16565 // int -> FLOAT32 map
16566 .float32Operands = {},
16567 // int -> INT32 map
16568 .int32Operands = {},
16569 // int -> QUANT8_ASYMM map
16570 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
16571 // int -> QUANT16_SYMM map
16572 .quant16SymmOperands = {},
16573 // int -> FLOAT16 map
16574 .float16Operands = {},
16575 // int -> BOOL8 map
16576 .bool8Operands = {},
16577 // int -> QUANT8_SYMM_PER_CHANNEL map
16578 .quant8ChannelOperands = {},
16579 // int -> QUANT16_ASYMM map
16580 .quant16AsymmOperands = {},
16581 // int -> QUANT8_SYMM map
16582 .quant8SymmOperands = {},
16583 }
16584 },
16585 }, // End of an example
16586 };
16587 return examples_channel_dynamic_output_shape_nhwc_channelQuant8;
16588 };
16589
get_examples_channel_dynamic_output_shape_nhwc_channelQuant8_weight_as_input()16590 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_channelQuant8_weight_as_input() {
16591 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_channelQuant8_weight_as_input = {
16592 // Begin of an example
16593 {
16594 .operands = {
16595 //Input(s)
16596 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16597 // int -> Dimensions map
16598 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16599 // int -> FLOAT32 map
16600 .float32Operands = {},
16601 // int -> INT32 map
16602 .int32Operands = {{2, {80, -133, 240, -267, 400, -400}}},
16603 // int -> QUANT8_ASYMM map
16604 .quant8AsymmOperands = {{0, {2, 4, 6, 8, 110, 8, 6, 4, 2, 10, 8, 6, 4, 22, 4, 6, 8, 10, 4, 6, 4, 6, 44, 6, 4, 6, 4, 2, 0, 4, 2, 66, 2, 4, 0, 2}}},
16605 // int -> QUANT16_SYMM map
16606 .quant16SymmOperands = {},
16607 // int -> FLOAT16 map
16608 .float16Operands = {},
16609 // int -> BOOL8 map
16610 .bool8Operands = {},
16611 // int -> QUANT8_SYMM_PER_CHANNEL map
16612 .quant8ChannelOperands = {{1, {4, 8, 12, 7, 3, 0, 8, 12, 12, 20, 20, 20, 36, 32, 20, 7, 3, 3}}},
16613 // int -> QUANT16_ASYMM map
16614 .quant16AsymmOperands = {},
16615 // int -> QUANT8_SYMM map
16616 .quant8SymmOperands = {},
16617 },
16618 //Output(s)
16619 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16620 // int -> Dimensions map
16621 .operandDimensions = {{0, {1, 2, 2, 6}}},
16622 // int -> FLOAT32 map
16623 .float32Operands = {},
16624 // int -> INT32 map
16625 .int32Operands = {},
16626 // int -> QUANT8_ASYMM map
16627 .quant8AsymmOperands = {{0, {72, 52, 168, 229, 109, 34, 76, 57, 96, 85, 127, 38, 72, 54, 116, 124, 111, 34, 68, 51, 127, 145, 96, 32}}},
16628 // int -> QUANT16_SYMM map
16629 .quant16SymmOperands = {},
16630 // int -> FLOAT16 map
16631 .float16Operands = {},
16632 // int -> BOOL8 map
16633 .bool8Operands = {},
16634 // int -> QUANT8_SYMM_PER_CHANNEL map
16635 .quant8ChannelOperands = {},
16636 // int -> QUANT16_ASYMM map
16637 .quant16AsymmOperands = {},
16638 // int -> QUANT8_SYMM map
16639 .quant8SymmOperands = {},
16640 }
16641 },
16642 }, // End of an example
16643 };
16644 return examples_channel_dynamic_output_shape_nhwc_channelQuant8_weight_as_input;
16645 };
16646
get_examples_channel_dynamic_output_shape_nhwc_float16()16647 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_float16() {
16648 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_float16 = {
16649 // Begin of an example
16650 {
16651 .operands = {
16652 //Input(s)
16653 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16654 // int -> Dimensions map
16655 .operandDimensions = {{0, {1, 2, 2, 9}}},
16656 // int -> FLOAT32 map
16657 .float32Operands = {},
16658 // int -> INT32 map
16659 .int32Operands = {},
16660 // int -> QUANT8_ASYMM map
16661 .quant8AsymmOperands = {},
16662 // int -> QUANT16_SYMM map
16663 .quant16SymmOperands = {},
16664 // int -> FLOAT16 map
16665 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}},
16666 // int -> BOOL8 map
16667 .bool8Operands = {},
16668 // int -> QUANT8_SYMM_PER_CHANNEL map
16669 .quant8ChannelOperands = {},
16670 // int -> QUANT16_ASYMM map
16671 .quant16AsymmOperands = {},
16672 // int -> QUANT8_SYMM map
16673 .quant8SymmOperands = {},
16674 },
16675 //Output(s)
16676 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16677 // int -> Dimensions map
16678 .operandDimensions = {{0, {1, 2, 2, 6}}},
16679 // int -> FLOAT32 map
16680 .float32Operands = {},
16681 // int -> INT32 map
16682 .int32Operands = {},
16683 // int -> QUANT8_ASYMM map
16684 .quant8AsymmOperands = {},
16685 // int -> QUANT16_SYMM map
16686 .quant16SymmOperands = {},
16687 // int -> FLOAT16 map
16688 .float16Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
16689 // int -> BOOL8 map
16690 .bool8Operands = {},
16691 // int -> QUANT8_SYMM_PER_CHANNEL map
16692 .quant8ChannelOperands = {},
16693 // int -> QUANT16_ASYMM map
16694 .quant16AsymmOperands = {},
16695 // int -> QUANT8_SYMM map
16696 .quant8SymmOperands = {},
16697 }
16698 },
16699 }, // End of an example
16700 };
16701 return examples_channel_dynamic_output_shape_nhwc_float16;
16702 };
16703
get_examples_channel_dynamic_output_shape_nhwc_float16_weight_as_input()16704 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nhwc_float16_weight_as_input() {
16705 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nhwc_float16_weight_as_input = {
16706 // Begin of an example
16707 {
16708 .operands = {
16709 //Input(s)
16710 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16711 // int -> Dimensions map
16712 .operandDimensions = {{0, {1, 2, 2, 9}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16713 // int -> FLOAT32 map
16714 .float32Operands = {},
16715 // int -> INT32 map
16716 .int32Operands = {},
16717 // int -> QUANT8_ASYMM map
16718 .quant8AsymmOperands = {},
16719 // int -> QUANT16_SYMM map
16720 .quant16SymmOperands = {},
16721 // int -> FLOAT16 map
16722 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 55.0f, 4.0f, 3.0f, 2.0f, 1.0f, 5.0f, 4.0f, 3.0f, 2.0f, 11.0f, 2.0f, 3.0f, 4.0f, 5.0f, 2.0f, 3.0f, 2.0f, 3.0f, 22.0f, 3.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 1.0f, 33.0f, 1.0f, 2.0f, 0.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
16723 // int -> BOOL8 map
16724 .bool8Operands = {},
16725 // int -> QUANT8_SYMM_PER_CHANNEL map
16726 .quant8ChannelOperands = {},
16727 // int -> QUANT16_ASYMM map
16728 .quant16AsymmOperands = {},
16729 // int -> QUANT8_SYMM map
16730 .quant8SymmOperands = {},
16731 },
16732 //Output(s)
16733 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16734 // int -> Dimensions map
16735 .operandDimensions = {{0, {1, 2, 2, 6}}},
16736 // int -> FLOAT32 map
16737 .float32Operands = {},
16738 // int -> INT32 map
16739 .int32Operands = {},
16740 // int -> QUANT8_ASYMM map
16741 .quant8AsymmOperands = {},
16742 // int -> QUANT16_SYMM map
16743 .quant16SymmOperands = {},
16744 // int -> FLOAT16 map
16745 .float16Operands = {{0, {24.0f, -16.0f, 215.0f, 338.0f, 98.0f, -51.0f, 32.0f, -6.0f, 73.0f, 50.0f, 134.0f, -45.0f, 24.0f, -13.0f, 111.0f, 128.0f, 102.0f, -51.0f, 17.0f, -18.0f, 134.0f, 170.0f, 73.0f, -55.0f}}},
16746 // int -> BOOL8 map
16747 .bool8Operands = {},
16748 // int -> QUANT8_SYMM_PER_CHANNEL map
16749 .quant8ChannelOperands = {},
16750 // int -> QUANT16_ASYMM map
16751 .quant16AsymmOperands = {},
16752 // int -> QUANT8_SYMM map
16753 .quant8SymmOperands = {},
16754 }
16755 },
16756 }, // End of an example
16757 };
16758 return examples_channel_dynamic_output_shape_nhwc_float16_weight_as_input;
16759 };
16760
get_examples_channel_dynamic_output_shape_nchw()16761 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw() {
16762 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw = {
16763 // Begin of an example
16764 {
16765 .operands = {
16766 //Input(s)
16767 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16768 // int -> Dimensions map
16769 .operandDimensions = {{0, {1, 9, 2, 2}}},
16770 // int -> FLOAT32 map
16771 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}},
16772 // int -> INT32 map
16773 .int32Operands = {},
16774 // int -> QUANT8_ASYMM map
16775 .quant8AsymmOperands = {},
16776 // int -> QUANT16_SYMM map
16777 .quant16SymmOperands = {},
16778 // int -> FLOAT16 map
16779 .float16Operands = {},
16780 // int -> BOOL8 map
16781 .bool8Operands = {},
16782 // int -> QUANT8_SYMM_PER_CHANNEL map
16783 .quant8ChannelOperands = {},
16784 // int -> QUANT16_ASYMM map
16785 .quant16AsymmOperands = {},
16786 // int -> QUANT8_SYMM map
16787 .quant8SymmOperands = {},
16788 },
16789 //Output(s)
16790 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16791 // int -> Dimensions map
16792 .operandDimensions = {{0, {1, 6, 2, 2}}},
16793 // int -> FLOAT32 map
16794 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
16795 // int -> INT32 map
16796 .int32Operands = {},
16797 // int -> QUANT8_ASYMM map
16798 .quant8AsymmOperands = {},
16799 // int -> QUANT16_SYMM map
16800 .quant16SymmOperands = {},
16801 // int -> FLOAT16 map
16802 .float16Operands = {},
16803 // int -> BOOL8 map
16804 .bool8Operands = {},
16805 // int -> QUANT8_SYMM_PER_CHANNEL map
16806 .quant8ChannelOperands = {},
16807 // int -> QUANT16_ASYMM map
16808 .quant16AsymmOperands = {},
16809 // int -> QUANT8_SYMM map
16810 .quant8SymmOperands = {},
16811 }
16812 },
16813 }, // End of an example
16814 };
16815 return examples_channel_dynamic_output_shape_nchw;
16816 };
16817
get_examples_channel_dynamic_output_shape_nchw_weight_as_input()16818 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_weight_as_input() {
16819 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_weight_as_input = {
16820 // Begin of an example
16821 {
16822 .operands = {
16823 //Input(s)
16824 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16825 // int -> Dimensions map
16826 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16827 // int -> FLOAT32 map
16828 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
16829 // int -> INT32 map
16830 .int32Operands = {},
16831 // int -> QUANT8_ASYMM map
16832 .quant8AsymmOperands = {},
16833 // int -> QUANT16_SYMM map
16834 .quant16SymmOperands = {},
16835 // int -> FLOAT16 map
16836 .float16Operands = {},
16837 // int -> BOOL8 map
16838 .bool8Operands = {},
16839 // int -> QUANT8_SYMM_PER_CHANNEL map
16840 .quant8ChannelOperands = {},
16841 // int -> QUANT16_ASYMM map
16842 .quant16AsymmOperands = {},
16843 // int -> QUANT8_SYMM map
16844 .quant8SymmOperands = {},
16845 },
16846 //Output(s)
16847 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16848 // int -> Dimensions map
16849 .operandDimensions = {{0, {1, 6, 2, 2}}},
16850 // int -> FLOAT32 map
16851 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
16852 // int -> INT32 map
16853 .int32Operands = {},
16854 // int -> QUANT8_ASYMM map
16855 .quant8AsymmOperands = {},
16856 // int -> QUANT16_SYMM map
16857 .quant16SymmOperands = {},
16858 // int -> FLOAT16 map
16859 .float16Operands = {},
16860 // int -> BOOL8 map
16861 .bool8Operands = {},
16862 // int -> QUANT8_SYMM_PER_CHANNEL map
16863 .quant8ChannelOperands = {},
16864 // int -> QUANT16_ASYMM map
16865 .quant16AsymmOperands = {},
16866 // int -> QUANT8_SYMM map
16867 .quant8SymmOperands = {},
16868 }
16869 },
16870 }, // End of an example
16871 };
16872 return examples_channel_dynamic_output_shape_nchw_weight_as_input;
16873 };
16874
get_examples_channel_dynamic_output_shape_nchw_relaxed()16875 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_relaxed() {
16876 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_relaxed = {
16877 // Begin of an example
16878 {
16879 .operands = {
16880 //Input(s)
16881 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16882 // int -> Dimensions map
16883 .operandDimensions = {{0, {1, 9, 2, 2}}},
16884 // int -> FLOAT32 map
16885 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}},
16886 // int -> INT32 map
16887 .int32Operands = {},
16888 // int -> QUANT8_ASYMM map
16889 .quant8AsymmOperands = {},
16890 // int -> QUANT16_SYMM map
16891 .quant16SymmOperands = {},
16892 // int -> FLOAT16 map
16893 .float16Operands = {},
16894 // int -> BOOL8 map
16895 .bool8Operands = {},
16896 // int -> QUANT8_SYMM_PER_CHANNEL map
16897 .quant8ChannelOperands = {},
16898 // int -> QUANT16_ASYMM map
16899 .quant16AsymmOperands = {},
16900 // int -> QUANT8_SYMM map
16901 .quant8SymmOperands = {},
16902 },
16903 //Output(s)
16904 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16905 // int -> Dimensions map
16906 .operandDimensions = {{0, {1, 6, 2, 2}}},
16907 // int -> FLOAT32 map
16908 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
16909 // int -> INT32 map
16910 .int32Operands = {},
16911 // int -> QUANT8_ASYMM map
16912 .quant8AsymmOperands = {},
16913 // int -> QUANT16_SYMM map
16914 .quant16SymmOperands = {},
16915 // int -> FLOAT16 map
16916 .float16Operands = {},
16917 // int -> BOOL8 map
16918 .bool8Operands = {},
16919 // int -> QUANT8_SYMM_PER_CHANNEL map
16920 .quant8ChannelOperands = {},
16921 // int -> QUANT16_ASYMM map
16922 .quant16AsymmOperands = {},
16923 // int -> QUANT8_SYMM map
16924 .quant8SymmOperands = {},
16925 }
16926 },
16927 }, // End of an example
16928 };
16929 return examples_channel_dynamic_output_shape_nchw_relaxed;
16930 };
16931
get_examples_channel_dynamic_output_shape_nchw_relaxed_weight_as_input()16932 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_relaxed_weight_as_input() {
16933 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_relaxed_weight_as_input = {
16934 // Begin of an example
16935 {
16936 .operands = {
16937 //Input(s)
16938 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16939 // int -> Dimensions map
16940 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
16941 // int -> FLOAT32 map
16942 .float32Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
16943 // int -> INT32 map
16944 .int32Operands = {},
16945 // int -> QUANT8_ASYMM map
16946 .quant8AsymmOperands = {},
16947 // int -> QUANT16_SYMM map
16948 .quant16SymmOperands = {},
16949 // int -> FLOAT16 map
16950 .float16Operands = {},
16951 // int -> BOOL8 map
16952 .bool8Operands = {},
16953 // int -> QUANT8_SYMM_PER_CHANNEL map
16954 .quant8ChannelOperands = {},
16955 // int -> QUANT16_ASYMM map
16956 .quant16AsymmOperands = {},
16957 // int -> QUANT8_SYMM map
16958 .quant8SymmOperands = {},
16959 },
16960 //Output(s)
16961 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16962 // int -> Dimensions map
16963 .operandDimensions = {{0, {1, 6, 2, 2}}},
16964 // int -> FLOAT32 map
16965 .float32Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
16966 // int -> INT32 map
16967 .int32Operands = {},
16968 // int -> QUANT8_ASYMM map
16969 .quant8AsymmOperands = {},
16970 // int -> QUANT16_SYMM map
16971 .quant16SymmOperands = {},
16972 // int -> FLOAT16 map
16973 .float16Operands = {},
16974 // int -> BOOL8 map
16975 .bool8Operands = {},
16976 // int -> QUANT8_SYMM_PER_CHANNEL map
16977 .quant8ChannelOperands = {},
16978 // int -> QUANT16_ASYMM map
16979 .quant16AsymmOperands = {},
16980 // int -> QUANT8_SYMM map
16981 .quant8SymmOperands = {},
16982 }
16983 },
16984 }, // End of an example
16985 };
16986 return examples_channel_dynamic_output_shape_nchw_relaxed_weight_as_input;
16987 };
16988
get_examples_channel_dynamic_output_shape_nchw_quant8()16989 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_quant8() {
16990 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_quant8 = {
16991 // Begin of an example
16992 {
16993 .operands = {
16994 //Input(s)
16995 { // See tools/test_generator/include/TestHarness.h:MixedTyped
16996 // int -> Dimensions map
16997 .operandDimensions = {{0, {1, 9, 2, 2}}},
16998 // int -> FLOAT32 map
16999 .float32Operands = {},
17000 // int -> INT32 map
17001 .int32Operands = {},
17002 // int -> QUANT8_ASYMM map
17003 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}},
17004 // int -> QUANT16_SYMM map
17005 .quant16SymmOperands = {},
17006 // int -> FLOAT16 map
17007 .float16Operands = {},
17008 // int -> BOOL8 map
17009 .bool8Operands = {},
17010 // int -> QUANT8_SYMM_PER_CHANNEL map
17011 .quant8ChannelOperands = {},
17012 // int -> QUANT16_ASYMM map
17013 .quant16AsymmOperands = {},
17014 // int -> QUANT8_SYMM map
17015 .quant8SymmOperands = {},
17016 },
17017 //Output(s)
17018 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17019 // int -> Dimensions map
17020 .operandDimensions = {{0, {1, 6, 2, 2}}},
17021 // int -> FLOAT32 map
17022 .float32Operands = {},
17023 // int -> INT32 map
17024 .int32Operands = {},
17025 // int -> QUANT8_ASYMM map
17026 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
17027 // int -> QUANT16_SYMM map
17028 .quant16SymmOperands = {},
17029 // int -> FLOAT16 map
17030 .float16Operands = {},
17031 // int -> BOOL8 map
17032 .bool8Operands = {},
17033 // int -> QUANT8_SYMM_PER_CHANNEL map
17034 .quant8ChannelOperands = {},
17035 // int -> QUANT16_ASYMM map
17036 .quant16AsymmOperands = {},
17037 // int -> QUANT8_SYMM map
17038 .quant8SymmOperands = {},
17039 }
17040 },
17041 }, // End of an example
17042 };
17043 return examples_channel_dynamic_output_shape_nchw_quant8;
17044 };
17045
get_examples_channel_dynamic_output_shape_nchw_quant8_weight_as_input()17046 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_quant8_weight_as_input() {
17047 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_quant8_weight_as_input = {
17048 // Begin of an example
17049 {
17050 .operands = {
17051 //Input(s)
17052 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17053 // int -> Dimensions map
17054 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
17055 // int -> FLOAT32 map
17056 .float32Operands = {},
17057 // int -> INT32 map
17058 .int32Operands = {{2, {80, -160, 240, -320, 400, -480}}},
17059 // int -> QUANT8_ASYMM map
17060 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}, {1, {4, 8, 12, 8, 4, 0, 8, 12, 12, 24, 24, 24, 36, 32, 20, 8, 4, 4}}},
17061 // int -> QUANT16_SYMM map
17062 .quant16SymmOperands = {},
17063 // int -> FLOAT16 map
17064 .float16Operands = {},
17065 // int -> BOOL8 map
17066 .bool8Operands = {},
17067 // int -> QUANT8_SYMM_PER_CHANNEL map
17068 .quant8ChannelOperands = {},
17069 // int -> QUANT16_ASYMM map
17070 .quant16AsymmOperands = {},
17071 // int -> QUANT8_SYMM map
17072 .quant8SymmOperands = {},
17073 },
17074 //Output(s)
17075 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17076 // int -> Dimensions map
17077 .operandDimensions = {{0, {1, 6, 2, 2}}},
17078 // int -> FLOAT32 map
17079 .float32Operands = {},
17080 // int -> INT32 map
17081 .int32Operands = {},
17082 // int -> QUANT8_ASYMM map
17083 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
17084 // int -> QUANT16_SYMM map
17085 .quant16SymmOperands = {},
17086 // int -> FLOAT16 map
17087 .float16Operands = {},
17088 // int -> BOOL8 map
17089 .bool8Operands = {},
17090 // int -> QUANT8_SYMM_PER_CHANNEL map
17091 .quant8ChannelOperands = {},
17092 // int -> QUANT16_ASYMM map
17093 .quant16AsymmOperands = {},
17094 // int -> QUANT8_SYMM map
17095 .quant8SymmOperands = {},
17096 }
17097 },
17098 }, // End of an example
17099 };
17100 return examples_channel_dynamic_output_shape_nchw_quant8_weight_as_input;
17101 };
17102
get_examples_channel_dynamic_output_shape_nchw_channelQuant8()17103 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_channelQuant8() {
17104 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_channelQuant8 = {
17105 // Begin of an example
17106 {
17107 .operands = {
17108 //Input(s)
17109 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17110 // int -> Dimensions map
17111 .operandDimensions = {{0, {1, 9, 2, 2}}},
17112 // int -> FLOAT32 map
17113 .float32Operands = {},
17114 // int -> INT32 map
17115 .int32Operands = {},
17116 // int -> QUANT8_ASYMM map
17117 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}},
17118 // int -> QUANT16_SYMM map
17119 .quant16SymmOperands = {},
17120 // int -> FLOAT16 map
17121 .float16Operands = {},
17122 // int -> BOOL8 map
17123 .bool8Operands = {},
17124 // int -> QUANT8_SYMM_PER_CHANNEL map
17125 .quant8ChannelOperands = {},
17126 // int -> QUANT16_ASYMM map
17127 .quant16AsymmOperands = {},
17128 // int -> QUANT8_SYMM map
17129 .quant8SymmOperands = {},
17130 },
17131 //Output(s)
17132 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17133 // int -> Dimensions map
17134 .operandDimensions = {{0, {1, 6, 2, 2}}},
17135 // int -> FLOAT32 map
17136 .float32Operands = {},
17137 // int -> INT32 map
17138 .int32Operands = {},
17139 // int -> QUANT8_ASYMM map
17140 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
17141 // int -> QUANT16_SYMM map
17142 .quant16SymmOperands = {},
17143 // int -> FLOAT16 map
17144 .float16Operands = {},
17145 // int -> BOOL8 map
17146 .bool8Operands = {},
17147 // int -> QUANT8_SYMM_PER_CHANNEL map
17148 .quant8ChannelOperands = {},
17149 // int -> QUANT16_ASYMM map
17150 .quant16AsymmOperands = {},
17151 // int -> QUANT8_SYMM map
17152 .quant8SymmOperands = {},
17153 }
17154 },
17155 }, // End of an example
17156 };
17157 return examples_channel_dynamic_output_shape_nchw_channelQuant8;
17158 };
17159
get_examples_channel_dynamic_output_shape_nchw_channelQuant8_weight_as_input()17160 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_channelQuant8_weight_as_input() {
17161 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_channelQuant8_weight_as_input = {
17162 // Begin of an example
17163 {
17164 .operands = {
17165 //Input(s)
17166 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17167 // int -> Dimensions map
17168 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
17169 // int -> FLOAT32 map
17170 .float32Operands = {},
17171 // int -> INT32 map
17172 .int32Operands = {{2, {80, -133, 240, -267, 400, -400}}},
17173 // int -> QUANT8_ASYMM map
17174 .quant8AsymmOperands = {{0, {2, 10, 4, 2, 4, 8, 6, 0, 6, 6, 4, 4, 8, 4, 6, 2, 110, 22, 44, 66, 8, 4, 6, 2, 6, 6, 4, 4, 4, 8, 6, 0, 2, 10, 4, 2}}},
17175 // int -> QUANT16_SYMM map
17176 .quant16SymmOperands = {},
17177 // int -> FLOAT16 map
17178 .float16Operands = {},
17179 // int -> BOOL8 map
17180 .bool8Operands = {},
17181 // int -> QUANT8_SYMM_PER_CHANNEL map
17182 .quant8ChannelOperands = {{1, {4, 8, 12, 7, 3, 0, 8, 12, 12, 20, 20, 20, 36, 32, 20, 7, 3, 3}}},
17183 // int -> QUANT16_ASYMM map
17184 .quant16AsymmOperands = {},
17185 // int -> QUANT8_SYMM map
17186 .quant8SymmOperands = {},
17187 },
17188 //Output(s)
17189 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17190 // int -> Dimensions map
17191 .operandDimensions = {{0, {1, 6, 2, 2}}},
17192 // int -> FLOAT32 map
17193 .float32Operands = {},
17194 // int -> INT32 map
17195 .int32Operands = {},
17196 // int -> QUANT8_ASYMM map
17197 .quant8AsymmOperands = {{0, {72, 76, 72, 68, 52, 57, 54, 51, 168, 96, 116, 127, 229, 85, 124, 145, 109, 127, 111, 96, 34, 38, 34, 32}}},
17198 // int -> QUANT16_SYMM map
17199 .quant16SymmOperands = {},
17200 // int -> FLOAT16 map
17201 .float16Operands = {},
17202 // int -> BOOL8 map
17203 .bool8Operands = {},
17204 // int -> QUANT8_SYMM_PER_CHANNEL map
17205 .quant8ChannelOperands = {},
17206 // int -> QUANT16_ASYMM map
17207 .quant16AsymmOperands = {},
17208 // int -> QUANT8_SYMM map
17209 .quant8SymmOperands = {},
17210 }
17211 },
17212 }, // End of an example
17213 };
17214 return examples_channel_dynamic_output_shape_nchw_channelQuant8_weight_as_input;
17215 };
17216
get_examples_channel_dynamic_output_shape_nchw_float16()17217 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_float16() {
17218 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_float16 = {
17219 // Begin of an example
17220 {
17221 .operands = {
17222 //Input(s)
17223 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17224 // int -> Dimensions map
17225 .operandDimensions = {{0, {1, 9, 2, 2}}},
17226 // int -> FLOAT32 map
17227 .float32Operands = {},
17228 // int -> INT32 map
17229 .int32Operands = {},
17230 // int -> QUANT8_ASYMM map
17231 .quant8AsymmOperands = {},
17232 // int -> QUANT16_SYMM map
17233 .quant16SymmOperands = {},
17234 // int -> FLOAT16 map
17235 .float16Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}},
17236 // int -> BOOL8 map
17237 .bool8Operands = {},
17238 // int -> QUANT8_SYMM_PER_CHANNEL map
17239 .quant8ChannelOperands = {},
17240 // int -> QUANT16_ASYMM map
17241 .quant16AsymmOperands = {},
17242 // int -> QUANT8_SYMM map
17243 .quant8SymmOperands = {},
17244 },
17245 //Output(s)
17246 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17247 // int -> Dimensions map
17248 .operandDimensions = {{0, {1, 6, 2, 2}}},
17249 // int -> FLOAT32 map
17250 .float32Operands = {},
17251 // int -> INT32 map
17252 .int32Operands = {},
17253 // int -> QUANT8_ASYMM map
17254 .quant8AsymmOperands = {},
17255 // int -> QUANT16_SYMM map
17256 .quant16SymmOperands = {},
17257 // int -> FLOAT16 map
17258 .float16Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
17259 // int -> BOOL8 map
17260 .bool8Operands = {},
17261 // int -> QUANT8_SYMM_PER_CHANNEL map
17262 .quant8ChannelOperands = {},
17263 // int -> QUANT16_ASYMM map
17264 .quant16AsymmOperands = {},
17265 // int -> QUANT8_SYMM map
17266 .quant8SymmOperands = {},
17267 }
17268 },
17269 }, // End of an example
17270 };
17271 return examples_channel_dynamic_output_shape_nchw_float16;
17272 };
17273
get_examples_channel_dynamic_output_shape_nchw_float16_weight_as_input()17274 std::vector<MixedTypedExample>& get_examples_channel_dynamic_output_shape_nchw_float16_weight_as_input() {
17275 static std::vector<MixedTypedExample> examples_channel_dynamic_output_shape_nchw_float16_weight_as_input = {
17276 // Begin of an example
17277 {
17278 .operands = {
17279 //Input(s)
17280 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17281 // int -> Dimensions map
17282 .operandDimensions = {{0, {1, 9, 2, 2}}, {1, {6, 1, 1, 3}}, {2, {6}}},
17283 // int -> FLOAT32 map
17284 .float32Operands = {},
17285 // int -> INT32 map
17286 .int32Operands = {},
17287 // int -> QUANT8_ASYMM map
17288 .quant8AsymmOperands = {},
17289 // int -> QUANT16_SYMM map
17290 .quant16SymmOperands = {},
17291 // int -> FLOAT16 map
17292 .float16Operands = {{0, {1.0f, 5.0f, 2.0f, 1.0f, 2.0f, 4.0f, 3.0f, 0.0f, 3.0f, 3.0f, 2.0f, 2.0f, 4.0f, 2.0f, 3.0f, 1.0f, 55.0f, 11.0f, 22.0f, 33.0f, 4.0f, 2.0f, 3.0f, 1.0f, 3.0f, 3.0f, 2.0f, 2.0f, 2.0f, 4.0f, 3.0f, 0.0f, 1.0f, 5.0f, 2.0f, 1.0f}}, {1, {1.0f, 2.0f, 3.0f, 2.0f, 1.0f, 0.0f, 2.0f, 3.0f, 3.0f, 6.0f, 6.0f, 6.0f, 9.0f, 8.0f, 5.0f, 2.0f, 1.0f, 1.0f}}, {2, {10.0f, -20.0f, 30.0f, -40.0f, 50.0f, -60.0f}}},
17293 // int -> BOOL8 map
17294 .bool8Operands = {},
17295 // int -> QUANT8_SYMM_PER_CHANNEL map
17296 .quant8ChannelOperands = {},
17297 // int -> QUANT16_ASYMM map
17298 .quant16AsymmOperands = {},
17299 // int -> QUANT8_SYMM map
17300 .quant8SymmOperands = {},
17301 },
17302 //Output(s)
17303 { // See tools/test_generator/include/TestHarness.h:MixedTyped
17304 // int -> Dimensions map
17305 .operandDimensions = {{0, {1, 6, 2, 2}}},
17306 // int -> FLOAT32 map
17307 .float32Operands = {},
17308 // int -> INT32 map
17309 .int32Operands = {},
17310 // int -> QUANT8_ASYMM map
17311 .quant8AsymmOperands = {},
17312 // int -> QUANT16_SYMM map
17313 .quant16SymmOperands = {},
17314 // int -> FLOAT16 map
17315 .float16Operands = {{0, {24.0f, 32.0f, 24.0f, 17.0f, -16.0f, -6.0f, -13.0f, -18.0f, 215.0f, 73.0f, 111.0f, 134.0f, 338.0f, 50.0f, 128.0f, 170.0f, 98.0f, 134.0f, 102.0f, 73.0f, -51.0f, -45.0f, -51.0f, -55.0f}}},
17316 // int -> BOOL8 map
17317 .bool8Operands = {},
17318 // int -> QUANT8_SYMM_PER_CHANNEL map
17319 .quant8ChannelOperands = {},
17320 // int -> QUANT16_ASYMM map
17321 .quant16AsymmOperands = {},
17322 // int -> QUANT8_SYMM map
17323 .quant8SymmOperands = {},
17324 }
17325 },
17326 }, // End of an example
17327 };
17328 return examples_channel_dynamic_output_shape_nchw_float16_weight_as_input;
17329 };
17330
17331