1 // clang-format off 2 // Generated file (from: depthwise_conv2d_dilation.mod.py). Do not edit 3 std::vector<MixedTypedExample>& get_examples_nhwc() { 4 static std::vector<MixedTypedExample> examples_nhwc = { 5 // Begin of an example 6 { 7 .operands = { 8 //Input(s) 9 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10 // int -> Dimensions map 11 .operandDimensions = {{0, {1, 3, 3, 2}}}, 12 // int -> FLOAT32 map 13 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.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, 4}}}, 35 // int -> FLOAT32 map 36 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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; 58 }; 59 60 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed() { 61 static std::vector<MixedTypedExample> examples_nhwc_relaxed = { 62 // Begin of an example 63 { 64 .operands = { 65 //Input(s) 66 { // See tools/test_generator/include/TestHarness.h:MixedTyped 67 // int -> Dimensions map 68 .operandDimensions = {{0, {1, 3, 3, 2}}}, 69 // int -> FLOAT32 map 70 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 71 // int -> INT32 map 72 .int32Operands = {}, 73 // int -> QUANT8_ASYMM map 74 .quant8AsymmOperands = {}, 75 // int -> QUANT16_SYMM map 76 .quant16SymmOperands = {}, 77 // int -> FLOAT16 map 78 .float16Operands = {}, 79 // int -> BOOL8 map 80 .bool8Operands = {}, 81 // int -> QUANT8_SYMM_PER_CHANNEL map 82 .quant8ChannelOperands = {}, 83 // int -> QUANT16_ASYMM map 84 .quant16AsymmOperands = {}, 85 // int -> QUANT8_SYMM map 86 .quant8SymmOperands = {}, 87 }, 88 //Output(s) 89 { // See tools/test_generator/include/TestHarness.h:MixedTyped 90 // int -> Dimensions map 91 .operandDimensions = {{0, {1, 2, 2, 4}}}, 92 // int -> FLOAT32 map 93 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_relaxed; 115 }; 116 117 std::vector<MixedTypedExample>& get_examples_nhwc_float16() { 118 static std::vector<MixedTypedExample> examples_nhwc_float16 = { 119 // Begin of an example 120 { 121 .operands = { 122 //Input(s) 123 { // See tools/test_generator/include/TestHarness.h:MixedTyped 124 // int -> Dimensions map 125 .operandDimensions = {{0, {1, 3, 3, 2}}}, 126 // int -> FLOAT32 map 127 .float32Operands = {}, 128 // int -> INT32 map 129 .int32Operands = {}, 130 // int -> QUANT8_ASYMM map 131 .quant8AsymmOperands = {}, 132 // int -> QUANT16_SYMM map 133 .quant16SymmOperands = {}, 134 // int -> FLOAT16 map 135 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 136 // int -> BOOL8 map 137 .bool8Operands = {}, 138 // int -> QUANT8_SYMM_PER_CHANNEL map 139 .quant8ChannelOperands = {}, 140 // int -> QUANT16_ASYMM map 141 .quant16AsymmOperands = {}, 142 // int -> QUANT8_SYMM map 143 .quant8SymmOperands = {}, 144 }, 145 //Output(s) 146 { // See tools/test_generator/include/TestHarness.h:MixedTyped 147 // int -> Dimensions map 148 .operandDimensions = {{0, {1, 2, 2, 4}}}, 149 // int -> FLOAT32 map 150 .float32Operands = {}, 151 // int -> INT32 map 152 .int32Operands = {}, 153 // int -> QUANT8_ASYMM map 154 .quant8AsymmOperands = {}, 155 // int -> QUANT16_SYMM map 156 .quant16SymmOperands = {}, 157 // int -> FLOAT16 map 158 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_float16; 172 }; 173 174 std::vector<MixedTypedExample>& get_examples_nhwc_quant8() { 175 static std::vector<MixedTypedExample> examples_nhwc_quant8 = { 176 // Begin of an example 177 { 178 .operands = { 179 //Input(s) 180 { // See tools/test_generator/include/TestHarness.h:MixedTyped 181 // int -> Dimensions map 182 .operandDimensions = {{0, {1, 3, 3, 2}}}, 183 // int -> FLOAT32 map 184 .float32Operands = {}, 185 // int -> INT32 map 186 .int32Operands = {}, 187 // int -> QUANT8_ASYMM map 188 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}}, 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, 4}}}, 206 // int -> FLOAT32 map 207 .float32Operands = {}, 208 // int -> INT32 map 209 .int32Operands = {}, 210 // int -> QUANT8_ASYMM map 211 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_quant8; 229 }; 230 231 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input() { 232 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input = { 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}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 240 // int -> FLOAT32 map 241 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 242 // int -> INT32 map 243 .int32Operands = {}, 244 // int -> QUANT8_ASYMM map 245 .quant8AsymmOperands = {}, 246 // int -> QUANT16_SYMM map 247 .quant16SymmOperands = {}, 248 // int -> FLOAT16 map 249 .float16Operands = {}, 250 // int -> BOOL8 map 251 .bool8Operands = {}, 252 // int -> QUANT8_SYMM_PER_CHANNEL map 253 .quant8ChannelOperands = {}, 254 // int -> QUANT16_ASYMM map 255 .quant16AsymmOperands = {}, 256 // int -> QUANT8_SYMM map 257 .quant8SymmOperands = {}, 258 }, 259 //Output(s) 260 { // See tools/test_generator/include/TestHarness.h:MixedTyped 261 // int -> Dimensions map 262 .operandDimensions = {{0, {1, 2, 2, 4}}}, 263 // int -> FLOAT32 map 264 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 265 // int -> INT32 map 266 .int32Operands = {}, 267 // int -> QUANT8_ASYMM map 268 .quant8AsymmOperands = {}, 269 // int -> QUANT16_SYMM map 270 .quant16SymmOperands = {}, 271 // int -> FLOAT16 map 272 .float16Operands = {}, 273 // int -> BOOL8 map 274 .bool8Operands = {}, 275 // int -> QUANT8_SYMM_PER_CHANNEL map 276 .quant8ChannelOperands = {}, 277 // int -> QUANT16_ASYMM map 278 .quant16AsymmOperands = {}, 279 // int -> QUANT8_SYMM map 280 .quant8SymmOperands = {}, 281 } 282 }, 283 }, // End of an example 284 }; 285 return examples_nhwc_weight_as_input; 286 }; 287 288 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_relaxed() { 289 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_relaxed = { 290 // Begin of an example 291 { 292 .operands = { 293 //Input(s) 294 { // See tools/test_generator/include/TestHarness.h:MixedTyped 295 // int -> Dimensions map 296 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 297 // int -> FLOAT32 map 298 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 299 // int -> INT32 map 300 .int32Operands = {}, 301 // int -> QUANT8_ASYMM map 302 .quant8AsymmOperands = {}, 303 // int -> QUANT16_SYMM map 304 .quant16SymmOperands = {}, 305 // int -> FLOAT16 map 306 .float16Operands = {}, 307 // int -> BOOL8 map 308 .bool8Operands = {}, 309 // int -> QUANT8_SYMM_PER_CHANNEL map 310 .quant8ChannelOperands = {}, 311 // int -> QUANT16_ASYMM map 312 .quant16AsymmOperands = {}, 313 // int -> QUANT8_SYMM map 314 .quant8SymmOperands = {}, 315 }, 316 //Output(s) 317 { // See tools/test_generator/include/TestHarness.h:MixedTyped 318 // int -> Dimensions map 319 .operandDimensions = {{0, {1, 2, 2, 4}}}, 320 // int -> FLOAT32 map 321 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 322 // int -> INT32 map 323 .int32Operands = {}, 324 // int -> QUANT8_ASYMM map 325 .quant8AsymmOperands = {}, 326 // int -> QUANT16_SYMM map 327 .quant16SymmOperands = {}, 328 // int -> FLOAT16 map 329 .float16Operands = {}, 330 // int -> BOOL8 map 331 .bool8Operands = {}, 332 // int -> QUANT8_SYMM_PER_CHANNEL map 333 .quant8ChannelOperands = {}, 334 // int -> QUANT16_ASYMM map 335 .quant16AsymmOperands = {}, 336 // int -> QUANT8_SYMM map 337 .quant8SymmOperands = {}, 338 } 339 }, 340 }, // End of an example 341 }; 342 return examples_nhwc_weight_as_input_relaxed; 343 }; 344 345 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_float16() { 346 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_float16 = { 347 // Begin of an example 348 { 349 .operands = { 350 //Input(s) 351 { // See tools/test_generator/include/TestHarness.h:MixedTyped 352 // int -> Dimensions map 353 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 354 // int -> FLOAT32 map 355 .float32Operands = {}, 356 // int -> INT32 map 357 .int32Operands = {}, 358 // int -> QUANT8_ASYMM map 359 .quant8AsymmOperands = {}, 360 // int -> QUANT16_SYMM map 361 .quant16SymmOperands = {}, 362 // int -> FLOAT16 map 363 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 364 // int -> BOOL8 map 365 .bool8Operands = {}, 366 // int -> QUANT8_SYMM_PER_CHANNEL map 367 .quant8ChannelOperands = {}, 368 // int -> QUANT16_ASYMM map 369 .quant16AsymmOperands = {}, 370 // int -> QUANT8_SYMM map 371 .quant8SymmOperands = {}, 372 }, 373 //Output(s) 374 { // See tools/test_generator/include/TestHarness.h:MixedTyped 375 // int -> Dimensions map 376 .operandDimensions = {{0, {1, 2, 2, 4}}}, 377 // int -> FLOAT32 map 378 .float32Operands = {}, 379 // int -> INT32 map 380 .int32Operands = {}, 381 // int -> QUANT8_ASYMM map 382 .quant8AsymmOperands = {}, 383 // int -> QUANT16_SYMM map 384 .quant16SymmOperands = {}, 385 // int -> FLOAT16 map 386 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_weight_as_input_float16; 400 }; 401 402 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_quant8() { 403 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_quant8 = { 404 // Begin of an example 405 { 406 .operands = { 407 //Input(s) 408 { // See tools/test_generator/include/TestHarness.h:MixedTyped 409 // int -> Dimensions map 410 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 411 // int -> FLOAT32 map 412 .float32Operands = {}, 413 // int -> INT32 map 414 .int32Operands = {{2, {200, 400, 600, 800}}}, 415 // int -> QUANT8_ASYMM map 416 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 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, 4}}}, 434 // int -> FLOAT32 map 435 .float32Operands = {}, 436 // int -> INT32 map 437 .int32Operands = {}, 438 // int -> QUANT8_ASYMM map 439 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_weight_as_input_quant8; 457 }; 458 459 std::vector<MixedTypedExample>& get_examples_nchw() { 460 static std::vector<MixedTypedExample> examples_nchw = { 461 // Begin of an example 462 { 463 .operands = { 464 //Input(s) 465 { // See tools/test_generator/include/TestHarness.h:MixedTyped 466 // int -> Dimensions map 467 .operandDimensions = {{0, {1, 2, 3, 3}}}, 468 // int -> FLOAT32 map 469 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 470 // int -> INT32 map 471 .int32Operands = {}, 472 // int -> QUANT8_ASYMM map 473 .quant8AsymmOperands = {}, 474 // int -> QUANT16_SYMM map 475 .quant16SymmOperands = {}, 476 // int -> FLOAT16 map 477 .float16Operands = {}, 478 // int -> BOOL8 map 479 .bool8Operands = {}, 480 // int -> QUANT8_SYMM_PER_CHANNEL map 481 .quant8ChannelOperands = {}, 482 // int -> QUANT16_ASYMM map 483 .quant16AsymmOperands = {}, 484 // int -> QUANT8_SYMM map 485 .quant8SymmOperands = {}, 486 }, 487 //Output(s) 488 { // See tools/test_generator/include/TestHarness.h:MixedTyped 489 // int -> Dimensions map 490 .operandDimensions = {{0, {1, 4, 2, 2}}}, 491 // int -> FLOAT32 map 492 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 493 // int -> INT32 map 494 .int32Operands = {}, 495 // int -> QUANT8_ASYMM map 496 .quant8AsymmOperands = {}, 497 // int -> QUANT16_SYMM map 498 .quant16SymmOperands = {}, 499 // int -> FLOAT16 map 500 .float16Operands = {}, 501 // int -> BOOL8 map 502 .bool8Operands = {}, 503 // int -> QUANT8_SYMM_PER_CHANNEL map 504 .quant8ChannelOperands = {}, 505 // int -> QUANT16_ASYMM map 506 .quant16AsymmOperands = {}, 507 // int -> QUANT8_SYMM map 508 .quant8SymmOperands = {}, 509 } 510 }, 511 }, // End of an example 512 }; 513 return examples_nchw; 514 }; 515 516 std::vector<MixedTypedExample>& get_examples_nchw_relaxed() { 517 static std::vector<MixedTypedExample> examples_nchw_relaxed = { 518 // Begin of an example 519 { 520 .operands = { 521 //Input(s) 522 { // See tools/test_generator/include/TestHarness.h:MixedTyped 523 // int -> Dimensions map 524 .operandDimensions = {{0, {1, 2, 3, 3}}}, 525 // int -> FLOAT32 map 526 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 527 // int -> INT32 map 528 .int32Operands = {}, 529 // int -> QUANT8_ASYMM map 530 .quant8AsymmOperands = {}, 531 // int -> QUANT16_SYMM map 532 .quant16SymmOperands = {}, 533 // int -> FLOAT16 map 534 .float16Operands = {}, 535 // int -> BOOL8 map 536 .bool8Operands = {}, 537 // int -> QUANT8_SYMM_PER_CHANNEL map 538 .quant8ChannelOperands = {}, 539 // int -> QUANT16_ASYMM map 540 .quant16AsymmOperands = {}, 541 // int -> QUANT8_SYMM map 542 .quant8SymmOperands = {}, 543 }, 544 //Output(s) 545 { // See tools/test_generator/include/TestHarness.h:MixedTyped 546 // int -> Dimensions map 547 .operandDimensions = {{0, {1, 4, 2, 2}}}, 548 // int -> FLOAT32 map 549 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 550 // int -> INT32 map 551 .int32Operands = {}, 552 // int -> QUANT8_ASYMM map 553 .quant8AsymmOperands = {}, 554 // int -> QUANT16_SYMM map 555 .quant16SymmOperands = {}, 556 // int -> FLOAT16 map 557 .float16Operands = {}, 558 // int -> BOOL8 map 559 .bool8Operands = {}, 560 // int -> QUANT8_SYMM_PER_CHANNEL map 561 .quant8ChannelOperands = {}, 562 // int -> QUANT16_ASYMM map 563 .quant16AsymmOperands = {}, 564 // int -> QUANT8_SYMM map 565 .quant8SymmOperands = {}, 566 } 567 }, 568 }, // End of an example 569 }; 570 return examples_nchw_relaxed; 571 }; 572 573 std::vector<MixedTypedExample>& get_examples_nchw_float16() { 574 static std::vector<MixedTypedExample> examples_nchw_float16 = { 575 // Begin of an example 576 { 577 .operands = { 578 //Input(s) 579 { // See tools/test_generator/include/TestHarness.h:MixedTyped 580 // int -> Dimensions map 581 .operandDimensions = {{0, {1, 2, 3, 3}}}, 582 // int -> FLOAT32 map 583 .float32Operands = {}, 584 // int -> INT32 map 585 .int32Operands = {}, 586 // int -> QUANT8_ASYMM map 587 .quant8AsymmOperands = {}, 588 // int -> QUANT16_SYMM map 589 .quant16SymmOperands = {}, 590 // int -> FLOAT16 map 591 .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 592 // int -> BOOL8 map 593 .bool8Operands = {}, 594 // int -> QUANT8_SYMM_PER_CHANNEL map 595 .quant8ChannelOperands = {}, 596 // int -> QUANT16_ASYMM map 597 .quant16AsymmOperands = {}, 598 // int -> QUANT8_SYMM map 599 .quant8SymmOperands = {}, 600 }, 601 //Output(s) 602 { // See tools/test_generator/include/TestHarness.h:MixedTyped 603 // int -> Dimensions map 604 .operandDimensions = {{0, {1, 4, 2, 2}}}, 605 // int -> FLOAT32 map 606 .float32Operands = {}, 607 // int -> INT32 map 608 .int32Operands = {}, 609 // int -> QUANT8_ASYMM map 610 .quant8AsymmOperands = {}, 611 // int -> QUANT16_SYMM map 612 .quant16SymmOperands = {}, 613 // int -> FLOAT16 map 614 .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_nchw_float16; 628 }; 629 630 std::vector<MixedTypedExample>& get_examples_nchw_quant8() { 631 static std::vector<MixedTypedExample> examples_nchw_quant8 = { 632 // Begin of an example 633 { 634 .operands = { 635 //Input(s) 636 { // See tools/test_generator/include/TestHarness.h:MixedTyped 637 // int -> Dimensions map 638 .operandDimensions = {{0, {1, 2, 3, 3}}}, 639 // int -> FLOAT32 map 640 .float32Operands = {}, 641 // int -> INT32 map 642 .int32Operands = {}, 643 // int -> QUANT8_ASYMM map 644 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}}, 645 // int -> QUANT16_SYMM map 646 .quant16SymmOperands = {}, 647 // int -> FLOAT16 map 648 .float16Operands = {}, 649 // int -> BOOL8 map 650 .bool8Operands = {}, 651 // int -> QUANT8_SYMM_PER_CHANNEL map 652 .quant8ChannelOperands = {}, 653 // int -> QUANT16_ASYMM map 654 .quant16AsymmOperands = {}, 655 // int -> QUANT8_SYMM map 656 .quant8SymmOperands = {}, 657 }, 658 //Output(s) 659 { // See tools/test_generator/include/TestHarness.h:MixedTyped 660 // int -> Dimensions map 661 .operandDimensions = {{0, {1, 4, 2, 2}}}, 662 // int -> FLOAT32 map 663 .float32Operands = {}, 664 // int -> INT32 map 665 .int32Operands = {}, 666 // int -> QUANT8_ASYMM map 667 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 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_nchw_quant8; 685 }; 686 687 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input() { 688 static std::vector<MixedTypedExample> examples_nchw_weight_as_input = { 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, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 696 // int -> FLOAT32 map 697 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 698 // int -> INT32 map 699 .int32Operands = {}, 700 // int -> QUANT8_ASYMM map 701 .quant8AsymmOperands = {}, 702 // int -> QUANT16_SYMM map 703 .quant16SymmOperands = {}, 704 // int -> FLOAT16 map 705 .float16Operands = {}, 706 // int -> BOOL8 map 707 .bool8Operands = {}, 708 // int -> QUANT8_SYMM_PER_CHANNEL map 709 .quant8ChannelOperands = {}, 710 // int -> QUANT16_ASYMM map 711 .quant16AsymmOperands = {}, 712 // int -> QUANT8_SYMM map 713 .quant8SymmOperands = {}, 714 }, 715 //Output(s) 716 { // See tools/test_generator/include/TestHarness.h:MixedTyped 717 // int -> Dimensions map 718 .operandDimensions = {{0, {1, 4, 2, 2}}}, 719 // int -> FLOAT32 map 720 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 721 // int -> INT32 map 722 .int32Operands = {}, 723 // int -> QUANT8_ASYMM map 724 .quant8AsymmOperands = {}, 725 // int -> QUANT16_SYMM map 726 .quant16SymmOperands = {}, 727 // int -> FLOAT16 map 728 .float16Operands = {}, 729 // int -> BOOL8 map 730 .bool8Operands = {}, 731 // int -> QUANT8_SYMM_PER_CHANNEL map 732 .quant8ChannelOperands = {}, 733 // int -> QUANT16_ASYMM map 734 .quant16AsymmOperands = {}, 735 // int -> QUANT8_SYMM map 736 .quant8SymmOperands = {}, 737 } 738 }, 739 }, // End of an example 740 }; 741 return examples_nchw_weight_as_input; 742 }; 743 744 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_relaxed() { 745 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_relaxed = { 746 // Begin of an example 747 { 748 .operands = { 749 //Input(s) 750 { // See tools/test_generator/include/TestHarness.h:MixedTyped 751 // int -> Dimensions map 752 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 753 // int -> FLOAT32 map 754 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 755 // int -> INT32 map 756 .int32Operands = {}, 757 // int -> QUANT8_ASYMM map 758 .quant8AsymmOperands = {}, 759 // int -> QUANT16_SYMM map 760 .quant16SymmOperands = {}, 761 // int -> FLOAT16 map 762 .float16Operands = {}, 763 // int -> BOOL8 map 764 .bool8Operands = {}, 765 // int -> QUANT8_SYMM_PER_CHANNEL map 766 .quant8ChannelOperands = {}, 767 // int -> QUANT16_ASYMM map 768 .quant16AsymmOperands = {}, 769 // int -> QUANT8_SYMM map 770 .quant8SymmOperands = {}, 771 }, 772 //Output(s) 773 { // See tools/test_generator/include/TestHarness.h:MixedTyped 774 // int -> Dimensions map 775 .operandDimensions = {{0, {1, 4, 2, 2}}}, 776 // int -> FLOAT32 map 777 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 778 // int -> INT32 map 779 .int32Operands = {}, 780 // int -> QUANT8_ASYMM map 781 .quant8AsymmOperands = {}, 782 // int -> QUANT16_SYMM map 783 .quant16SymmOperands = {}, 784 // int -> FLOAT16 map 785 .float16Operands = {}, 786 // int -> BOOL8 map 787 .bool8Operands = {}, 788 // int -> QUANT8_SYMM_PER_CHANNEL map 789 .quant8ChannelOperands = {}, 790 // int -> QUANT16_ASYMM map 791 .quant16AsymmOperands = {}, 792 // int -> QUANT8_SYMM map 793 .quant8SymmOperands = {}, 794 } 795 }, 796 }, // End of an example 797 }; 798 return examples_nchw_weight_as_input_relaxed; 799 }; 800 801 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_float16() { 802 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_float16 = { 803 // Begin of an example 804 { 805 .operands = { 806 //Input(s) 807 { // See tools/test_generator/include/TestHarness.h:MixedTyped 808 // int -> Dimensions map 809 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 810 // int -> FLOAT32 map 811 .float32Operands = {}, 812 // int -> INT32 map 813 .int32Operands = {}, 814 // int -> QUANT8_ASYMM map 815 .quant8AsymmOperands = {}, 816 // int -> QUANT16_SYMM map 817 .quant16SymmOperands = {}, 818 // int -> FLOAT16 map 819 .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 820 // int -> BOOL8 map 821 .bool8Operands = {}, 822 // int -> QUANT8_SYMM_PER_CHANNEL map 823 .quant8ChannelOperands = {}, 824 // int -> QUANT16_ASYMM map 825 .quant16AsymmOperands = {}, 826 // int -> QUANT8_SYMM map 827 .quant8SymmOperands = {}, 828 }, 829 //Output(s) 830 { // See tools/test_generator/include/TestHarness.h:MixedTyped 831 // int -> Dimensions map 832 .operandDimensions = {{0, {1, 4, 2, 2}}}, 833 // int -> FLOAT32 map 834 .float32Operands = {}, 835 // int -> INT32 map 836 .int32Operands = {}, 837 // int -> QUANT8_ASYMM map 838 .quant8AsymmOperands = {}, 839 // int -> QUANT16_SYMM map 840 .quant16SymmOperands = {}, 841 // int -> FLOAT16 map 842 .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_nchw_weight_as_input_float16; 856 }; 857 858 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_quant8() { 859 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_quant8 = { 860 // Begin of an example 861 { 862 .operands = { 863 //Input(s) 864 { // See tools/test_generator/include/TestHarness.h:MixedTyped 865 // int -> Dimensions map 866 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 867 // int -> FLOAT32 map 868 .float32Operands = {}, 869 // int -> INT32 map 870 .int32Operands = {{2, {200, 400, 600, 800}}}, 871 // int -> QUANT8_ASYMM map 872 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 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, 4, 2, 2}}}, 890 // int -> FLOAT32 map 891 .float32Operands = {}, 892 // int -> INT32 map 893 .int32Operands = {}, 894 // int -> QUANT8_ASYMM map 895 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 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_nchw_weight_as_input_quant8; 913 }; 914 915 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc() { 916 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc = { 917 // Begin of an example 918 { 919 .operands = { 920 //Input(s) 921 { // See tools/test_generator/include/TestHarness.h:MixedTyped 922 // int -> Dimensions map 923 .operandDimensions = {{0, {1, 3, 3, 2}}}, 924 // int -> FLOAT32 map 925 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.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, 4}}}, 947 // int -> FLOAT32 map 948 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_dynamic_output_shape_nhwc; 970 }; 971 972 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed() { 973 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed = { 974 // Begin of an example 975 { 976 .operands = { 977 //Input(s) 978 { // See tools/test_generator/include/TestHarness.h:MixedTyped 979 // int -> Dimensions map 980 .operandDimensions = {{0, {1, 3, 3, 2}}}, 981 // int -> FLOAT32 map 982 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 983 // int -> INT32 map 984 .int32Operands = {}, 985 // int -> QUANT8_ASYMM map 986 .quant8AsymmOperands = {}, 987 // int -> QUANT16_SYMM map 988 .quant16SymmOperands = {}, 989 // int -> FLOAT16 map 990 .float16Operands = {}, 991 // int -> BOOL8 map 992 .bool8Operands = {}, 993 // int -> QUANT8_SYMM_PER_CHANNEL map 994 .quant8ChannelOperands = {}, 995 // int -> QUANT16_ASYMM map 996 .quant16AsymmOperands = {}, 997 // int -> QUANT8_SYMM map 998 .quant8SymmOperands = {}, 999 }, 1000 //Output(s) 1001 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1002 // int -> Dimensions map 1003 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1004 // int -> FLOAT32 map 1005 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_dynamic_output_shape_nhwc_relaxed; 1027 }; 1028 1029 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16() { 1030 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16 = { 1031 // Begin of an example 1032 { 1033 .operands = { 1034 //Input(s) 1035 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1036 // int -> Dimensions map 1037 .operandDimensions = {{0, {1, 3, 3, 2}}}, 1038 // int -> FLOAT32 map 1039 .float32Operands = {}, 1040 // int -> INT32 map 1041 .int32Operands = {}, 1042 // int -> QUANT8_ASYMM map 1043 .quant8AsymmOperands = {}, 1044 // int -> QUANT16_SYMM map 1045 .quant16SymmOperands = {}, 1046 // int -> FLOAT16 map 1047 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 1048 // int -> BOOL8 map 1049 .bool8Operands = {}, 1050 // int -> QUANT8_SYMM_PER_CHANNEL map 1051 .quant8ChannelOperands = {}, 1052 // int -> QUANT16_ASYMM map 1053 .quant16AsymmOperands = {}, 1054 // int -> QUANT8_SYMM map 1055 .quant8SymmOperands = {}, 1056 }, 1057 //Output(s) 1058 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1059 // int -> Dimensions map 1060 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1061 // int -> FLOAT32 map 1062 .float32Operands = {}, 1063 // int -> INT32 map 1064 .int32Operands = {}, 1065 // int -> QUANT8_ASYMM map 1066 .quant8AsymmOperands = {}, 1067 // int -> QUANT16_SYMM map 1068 .quant16SymmOperands = {}, 1069 // int -> FLOAT16 map 1070 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_dynamic_output_shape_nhwc_float16; 1084 }; 1085 1086 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8() { 1087 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8 = { 1088 // Begin of an example 1089 { 1090 .operands = { 1091 //Input(s) 1092 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1093 // int -> Dimensions map 1094 .operandDimensions = {{0, {1, 3, 3, 2}}}, 1095 // int -> FLOAT32 map 1096 .float32Operands = {}, 1097 // int -> INT32 map 1098 .int32Operands = {}, 1099 // int -> QUANT8_ASYMM map 1100 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}}, 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, 4}}}, 1118 // int -> FLOAT32 map 1119 .float32Operands = {}, 1120 // int -> INT32 map 1121 .int32Operands = {}, 1122 // int -> QUANT8_ASYMM map 1123 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_dynamic_output_shape_nhwc_quant8; 1141 }; 1142 1143 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input() { 1144 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input = { 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}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1152 // int -> FLOAT32 map 1153 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 1154 // int -> INT32 map 1155 .int32Operands = {}, 1156 // int -> QUANT8_ASYMM map 1157 .quant8AsymmOperands = {}, 1158 // int -> QUANT16_SYMM map 1159 .quant16SymmOperands = {}, 1160 // int -> FLOAT16 map 1161 .float16Operands = {}, 1162 // int -> BOOL8 map 1163 .bool8Operands = {}, 1164 // int -> QUANT8_SYMM_PER_CHANNEL map 1165 .quant8ChannelOperands = {}, 1166 // int -> QUANT16_ASYMM map 1167 .quant16AsymmOperands = {}, 1168 // int -> QUANT8_SYMM map 1169 .quant8SymmOperands = {}, 1170 }, 1171 //Output(s) 1172 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1173 // int -> Dimensions map 1174 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1175 // int -> FLOAT32 map 1176 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 1177 // int -> INT32 map 1178 .int32Operands = {}, 1179 // int -> QUANT8_ASYMM map 1180 .quant8AsymmOperands = {}, 1181 // int -> QUANT16_SYMM map 1182 .quant16SymmOperands = {}, 1183 // int -> FLOAT16 map 1184 .float16Operands = {}, 1185 // int -> BOOL8 map 1186 .bool8Operands = {}, 1187 // int -> QUANT8_SYMM_PER_CHANNEL map 1188 .quant8ChannelOperands = {}, 1189 // int -> QUANT16_ASYMM map 1190 .quant16AsymmOperands = {}, 1191 // int -> QUANT8_SYMM map 1192 .quant8SymmOperands = {}, 1193 } 1194 }, 1195 }, // End of an example 1196 }; 1197 return examples_dynamic_output_shape_nhwc_weight_as_input; 1198 }; 1199 1200 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_relaxed() { 1201 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_relaxed = { 1202 // Begin of an example 1203 { 1204 .operands = { 1205 //Input(s) 1206 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1207 // int -> Dimensions map 1208 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1209 // int -> FLOAT32 map 1210 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 1211 // int -> INT32 map 1212 .int32Operands = {}, 1213 // int -> QUANT8_ASYMM map 1214 .quant8AsymmOperands = {}, 1215 // int -> QUANT16_SYMM map 1216 .quant16SymmOperands = {}, 1217 // int -> FLOAT16 map 1218 .float16Operands = {}, 1219 // int -> BOOL8 map 1220 .bool8Operands = {}, 1221 // int -> QUANT8_SYMM_PER_CHANNEL map 1222 .quant8ChannelOperands = {}, 1223 // int -> QUANT16_ASYMM map 1224 .quant16AsymmOperands = {}, 1225 // int -> QUANT8_SYMM map 1226 .quant8SymmOperands = {}, 1227 }, 1228 //Output(s) 1229 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1230 // int -> Dimensions map 1231 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1232 // int -> FLOAT32 map 1233 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 1234 // int -> INT32 map 1235 .int32Operands = {}, 1236 // int -> QUANT8_ASYMM map 1237 .quant8AsymmOperands = {}, 1238 // int -> QUANT16_SYMM map 1239 .quant16SymmOperands = {}, 1240 // int -> FLOAT16 map 1241 .float16Operands = {}, 1242 // int -> BOOL8 map 1243 .bool8Operands = {}, 1244 // int -> QUANT8_SYMM_PER_CHANNEL map 1245 .quant8ChannelOperands = {}, 1246 // int -> QUANT16_ASYMM map 1247 .quant16AsymmOperands = {}, 1248 // int -> QUANT8_SYMM map 1249 .quant8SymmOperands = {}, 1250 } 1251 }, 1252 }, // End of an example 1253 }; 1254 return examples_dynamic_output_shape_nhwc_weight_as_input_relaxed; 1255 }; 1256 1257 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_float16() { 1258 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_float16 = { 1259 // Begin of an example 1260 { 1261 .operands = { 1262 //Input(s) 1263 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1264 // int -> Dimensions map 1265 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1266 // int -> FLOAT32 map 1267 .float32Operands = {}, 1268 // int -> INT32 map 1269 .int32Operands = {}, 1270 // int -> QUANT8_ASYMM map 1271 .quant8AsymmOperands = {}, 1272 // int -> QUANT16_SYMM map 1273 .quant16SymmOperands = {}, 1274 // int -> FLOAT16 map 1275 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 1276 // int -> BOOL8 map 1277 .bool8Operands = {}, 1278 // int -> QUANT8_SYMM_PER_CHANNEL map 1279 .quant8ChannelOperands = {}, 1280 // int -> QUANT16_ASYMM map 1281 .quant16AsymmOperands = {}, 1282 // int -> QUANT8_SYMM map 1283 .quant8SymmOperands = {}, 1284 }, 1285 //Output(s) 1286 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1287 // int -> Dimensions map 1288 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1289 // int -> FLOAT32 map 1290 .float32Operands = {}, 1291 // int -> INT32 map 1292 .int32Operands = {}, 1293 // int -> QUANT8_ASYMM map 1294 .quant8AsymmOperands = {}, 1295 // int -> QUANT16_SYMM map 1296 .quant16SymmOperands = {}, 1297 // int -> FLOAT16 map 1298 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_dynamic_output_shape_nhwc_weight_as_input_float16; 1312 }; 1313 1314 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_quant8() { 1315 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_quant8 = { 1316 // Begin of an example 1317 { 1318 .operands = { 1319 //Input(s) 1320 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1321 // int -> Dimensions map 1322 .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1323 // int -> FLOAT32 map 1324 .float32Operands = {}, 1325 // int -> INT32 map 1326 .int32Operands = {{2, {200, 400, 600, 800}}}, 1327 // int -> QUANT8_ASYMM map 1328 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 1329 // int -> QUANT16_SYMM map 1330 .quant16SymmOperands = {}, 1331 // int -> FLOAT16 map 1332 .float16Operands = {}, 1333 // int -> BOOL8 map 1334 .bool8Operands = {}, 1335 // int -> QUANT8_SYMM_PER_CHANNEL map 1336 .quant8ChannelOperands = {}, 1337 // int -> QUANT16_ASYMM map 1338 .quant16AsymmOperands = {}, 1339 // int -> QUANT8_SYMM map 1340 .quant8SymmOperands = {}, 1341 }, 1342 //Output(s) 1343 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1344 // int -> Dimensions map 1345 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1346 // int -> FLOAT32 map 1347 .float32Operands = {}, 1348 // int -> INT32 map 1349 .int32Operands = {}, 1350 // int -> QUANT8_ASYMM map 1351 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_dynamic_output_shape_nhwc_weight_as_input_quant8; 1369 }; 1370 1371 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw() { 1372 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw = { 1373 // Begin of an example 1374 { 1375 .operands = { 1376 //Input(s) 1377 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1378 // int -> Dimensions map 1379 .operandDimensions = {{0, {1, 2, 3, 3}}}, 1380 // int -> FLOAT32 map 1381 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 1382 // int -> INT32 map 1383 .int32Operands = {}, 1384 // int -> QUANT8_ASYMM map 1385 .quant8AsymmOperands = {}, 1386 // int -> QUANT16_SYMM map 1387 .quant16SymmOperands = {}, 1388 // int -> FLOAT16 map 1389 .float16Operands = {}, 1390 // int -> BOOL8 map 1391 .bool8Operands = {}, 1392 // int -> QUANT8_SYMM_PER_CHANNEL map 1393 .quant8ChannelOperands = {}, 1394 // int -> QUANT16_ASYMM map 1395 .quant16AsymmOperands = {}, 1396 // int -> QUANT8_SYMM map 1397 .quant8SymmOperands = {}, 1398 }, 1399 //Output(s) 1400 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1401 // int -> Dimensions map 1402 .operandDimensions = {{0, {1, 4, 2, 2}}}, 1403 // int -> FLOAT32 map 1404 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 1405 // int -> INT32 map 1406 .int32Operands = {}, 1407 // int -> QUANT8_ASYMM map 1408 .quant8AsymmOperands = {}, 1409 // int -> QUANT16_SYMM map 1410 .quant16SymmOperands = {}, 1411 // int -> FLOAT16 map 1412 .float16Operands = {}, 1413 // int -> BOOL8 map 1414 .bool8Operands = {}, 1415 // int -> QUANT8_SYMM_PER_CHANNEL map 1416 .quant8ChannelOperands = {}, 1417 // int -> QUANT16_ASYMM map 1418 .quant16AsymmOperands = {}, 1419 // int -> QUANT8_SYMM map 1420 .quant8SymmOperands = {}, 1421 } 1422 }, 1423 }, // End of an example 1424 }; 1425 return examples_dynamic_output_shape_nchw; 1426 }; 1427 1428 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed() { 1429 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed = { 1430 // Begin of an example 1431 { 1432 .operands = { 1433 //Input(s) 1434 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1435 // int -> Dimensions map 1436 .operandDimensions = {{0, {1, 2, 3, 3}}}, 1437 // int -> FLOAT32 map 1438 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 1439 // int -> INT32 map 1440 .int32Operands = {}, 1441 // int -> QUANT8_ASYMM map 1442 .quant8AsymmOperands = {}, 1443 // int -> QUANT16_SYMM map 1444 .quant16SymmOperands = {}, 1445 // int -> FLOAT16 map 1446 .float16Operands = {}, 1447 // int -> BOOL8 map 1448 .bool8Operands = {}, 1449 // int -> QUANT8_SYMM_PER_CHANNEL map 1450 .quant8ChannelOperands = {}, 1451 // int -> QUANT16_ASYMM map 1452 .quant16AsymmOperands = {}, 1453 // int -> QUANT8_SYMM map 1454 .quant8SymmOperands = {}, 1455 }, 1456 //Output(s) 1457 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1458 // int -> Dimensions map 1459 .operandDimensions = {{0, {1, 4, 2, 2}}}, 1460 // int -> FLOAT32 map 1461 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 1462 // int -> INT32 map 1463 .int32Operands = {}, 1464 // int -> QUANT8_ASYMM map 1465 .quant8AsymmOperands = {}, 1466 // int -> QUANT16_SYMM map 1467 .quant16SymmOperands = {}, 1468 // int -> FLOAT16 map 1469 .float16Operands = {}, 1470 // int -> BOOL8 map 1471 .bool8Operands = {}, 1472 // int -> QUANT8_SYMM_PER_CHANNEL map 1473 .quant8ChannelOperands = {}, 1474 // int -> QUANT16_ASYMM map 1475 .quant16AsymmOperands = {}, 1476 // int -> QUANT8_SYMM map 1477 .quant8SymmOperands = {}, 1478 } 1479 }, 1480 }, // End of an example 1481 }; 1482 return examples_dynamic_output_shape_nchw_relaxed; 1483 }; 1484 1485 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16() { 1486 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16 = { 1487 // Begin of an example 1488 { 1489 .operands = { 1490 //Input(s) 1491 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1492 // int -> Dimensions map 1493 .operandDimensions = {{0, {1, 2, 3, 3}}}, 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, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.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, 4, 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, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_dynamic_output_shape_nchw_float16; 1540 }; 1541 1542 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8() { 1543 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8 = { 1544 // Begin of an example 1545 { 1546 .operands = { 1547 //Input(s) 1548 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1549 // int -> Dimensions map 1550 .operandDimensions = {{0, {1, 2, 3, 3}}}, 1551 // int -> FLOAT32 map 1552 .float32Operands = {}, 1553 // int -> INT32 map 1554 .int32Operands = {}, 1555 // int -> QUANT8_ASYMM map 1556 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}}, 1557 // int -> QUANT16_SYMM map 1558 .quant16SymmOperands = {}, 1559 // int -> FLOAT16 map 1560 .float16Operands = {}, 1561 // int -> BOOL8 map 1562 .bool8Operands = {}, 1563 // int -> QUANT8_SYMM_PER_CHANNEL map 1564 .quant8ChannelOperands = {}, 1565 // int -> QUANT16_ASYMM map 1566 .quant16AsymmOperands = {}, 1567 // int -> QUANT8_SYMM map 1568 .quant8SymmOperands = {}, 1569 }, 1570 //Output(s) 1571 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1572 // int -> Dimensions map 1573 .operandDimensions = {{0, {1, 4, 2, 2}}}, 1574 // int -> FLOAT32 map 1575 .float32Operands = {}, 1576 // int -> INT32 map 1577 .int32Operands = {}, 1578 // int -> QUANT8_ASYMM map 1579 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 1580 // int -> QUANT16_SYMM map 1581 .quant16SymmOperands = {}, 1582 // int -> FLOAT16 map 1583 .float16Operands = {}, 1584 // int -> BOOL8 map 1585 .bool8Operands = {}, 1586 // int -> QUANT8_SYMM_PER_CHANNEL map 1587 .quant8ChannelOperands = {}, 1588 // int -> QUANT16_ASYMM map 1589 .quant16AsymmOperands = {}, 1590 // int -> QUANT8_SYMM map 1591 .quant8SymmOperands = {}, 1592 } 1593 }, 1594 }, // End of an example 1595 }; 1596 return examples_dynamic_output_shape_nchw_quant8; 1597 }; 1598 1599 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input() { 1600 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input = { 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, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1608 // int -> FLOAT32 map 1609 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.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, 4, 2, 2}}}, 1631 // int -> FLOAT32 map 1632 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 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_dynamic_output_shape_nchw_weight_as_input; 1654 }; 1655 1656 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_relaxed() { 1657 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_relaxed = { 1658 // Begin of an example 1659 { 1660 .operands = { 1661 //Input(s) 1662 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1663 // int -> Dimensions map 1664 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1665 // int -> FLOAT32 map 1666 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 1667 // int -> INT32 map 1668 .int32Operands = {}, 1669 // int -> QUANT8_ASYMM map 1670 .quant8AsymmOperands = {}, 1671 // int -> QUANT16_SYMM map 1672 .quant16SymmOperands = {}, 1673 // int -> FLOAT16 map 1674 .float16Operands = {}, 1675 // int -> BOOL8 map 1676 .bool8Operands = {}, 1677 // int -> QUANT8_SYMM_PER_CHANNEL map 1678 .quant8ChannelOperands = {}, 1679 // int -> QUANT16_ASYMM map 1680 .quant16AsymmOperands = {}, 1681 // int -> QUANT8_SYMM map 1682 .quant8SymmOperands = {}, 1683 }, 1684 //Output(s) 1685 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1686 // int -> Dimensions map 1687 .operandDimensions = {{0, {1, 4, 2, 2}}}, 1688 // int -> FLOAT32 map 1689 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 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_dynamic_output_shape_nchw_weight_as_input_relaxed; 1711 }; 1712 1713 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_float16() { 1714 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_float16 = { 1715 // Begin of an example 1716 { 1717 .operands = { 1718 //Input(s) 1719 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1720 // int -> Dimensions map 1721 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1722 // int -> FLOAT32 map 1723 .float32Operands = {}, 1724 // int -> INT32 map 1725 .int32Operands = {}, 1726 // int -> QUANT8_ASYMM map 1727 .quant8AsymmOperands = {}, 1728 // int -> QUANT16_SYMM map 1729 .quant16SymmOperands = {}, 1730 // int -> FLOAT16 map 1731 .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 1732 // int -> BOOL8 map 1733 .bool8Operands = {}, 1734 // int -> QUANT8_SYMM_PER_CHANNEL map 1735 .quant8ChannelOperands = {}, 1736 // int -> QUANT16_ASYMM map 1737 .quant16AsymmOperands = {}, 1738 // int -> QUANT8_SYMM map 1739 .quant8SymmOperands = {}, 1740 }, 1741 //Output(s) 1742 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1743 // int -> Dimensions map 1744 .operandDimensions = {{0, {1, 4, 2, 2}}}, 1745 // int -> FLOAT32 map 1746 .float32Operands = {}, 1747 // int -> INT32 map 1748 .int32Operands = {}, 1749 // int -> QUANT8_ASYMM map 1750 .quant8AsymmOperands = {}, 1751 // int -> QUANT16_SYMM map 1752 .quant16SymmOperands = {}, 1753 // int -> FLOAT16 map 1754 .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_dynamic_output_shape_nchw_weight_as_input_float16; 1768 }; 1769 1770 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_quant8() { 1771 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_quant8 = { 1772 // Begin of an example 1773 { 1774 .operands = { 1775 //Input(s) 1776 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1777 // int -> Dimensions map 1778 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1779 // int -> FLOAT32 map 1780 .float32Operands = {}, 1781 // int -> INT32 map 1782 .int32Operands = {{2, {200, 400, 600, 800}}}, 1783 // int -> QUANT8_ASYMM map 1784 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 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, 4, 2, 2}}}, 1802 // int -> FLOAT32 map 1803 .float32Operands = {}, 1804 // int -> INT32 map 1805 .int32Operands = {}, 1806 // int -> QUANT8_ASYMM map 1807 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 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_dynamic_output_shape_nchw_weight_as_input_quant8; 1825 }; 1826 1827 std::vector<MixedTypedExample>& get_examples_nhwc_2() { 1828 static std::vector<MixedTypedExample> examples_nhwc_2 = { 1829 // Begin of an example 1830 { 1831 .operands = { 1832 //Input(s) 1833 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1834 // int -> Dimensions map 1835 .operandDimensions = {{0, {1, 4, 4, 2}}}, 1836 // int -> FLOAT32 map 1837 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 1838 // int -> INT32 map 1839 .int32Operands = {}, 1840 // int -> QUANT8_ASYMM map 1841 .quant8AsymmOperands = {}, 1842 // int -> QUANT16_SYMM map 1843 .quant16SymmOperands = {}, 1844 // int -> FLOAT16 map 1845 .float16Operands = {}, 1846 // int -> BOOL8 map 1847 .bool8Operands = {}, 1848 // int -> QUANT8_SYMM_PER_CHANNEL map 1849 .quant8ChannelOperands = {}, 1850 // int -> QUANT16_ASYMM map 1851 .quant16AsymmOperands = {}, 1852 // int -> QUANT8_SYMM map 1853 .quant8SymmOperands = {}, 1854 }, 1855 //Output(s) 1856 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1857 // int -> Dimensions map 1858 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1859 // int -> FLOAT32 map 1860 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}}, 1861 // int -> INT32 map 1862 .int32Operands = {}, 1863 // int -> QUANT8_ASYMM map 1864 .quant8AsymmOperands = {}, 1865 // int -> QUANT16_SYMM map 1866 .quant16SymmOperands = {}, 1867 // int -> FLOAT16 map 1868 .float16Operands = {}, 1869 // int -> BOOL8 map 1870 .bool8Operands = {}, 1871 // int -> QUANT8_SYMM_PER_CHANNEL map 1872 .quant8ChannelOperands = {}, 1873 // int -> QUANT16_ASYMM map 1874 .quant16AsymmOperands = {}, 1875 // int -> QUANT8_SYMM map 1876 .quant8SymmOperands = {}, 1877 } 1878 }, 1879 }, // End of an example 1880 }; 1881 return examples_nhwc_2; 1882 }; 1883 1884 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_2() { 1885 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_2 = { 1886 // Begin of an example 1887 { 1888 .operands = { 1889 //Input(s) 1890 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1891 // int -> Dimensions map 1892 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 1893 // int -> FLOAT32 map 1894 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 1895 // int -> INT32 map 1896 .int32Operands = {}, 1897 // int -> QUANT8_ASYMM map 1898 .quant8AsymmOperands = {}, 1899 // int -> QUANT16_SYMM map 1900 .quant16SymmOperands = {}, 1901 // int -> FLOAT16 map 1902 .float16Operands = {}, 1903 // int -> BOOL8 map 1904 .bool8Operands = {}, 1905 // int -> QUANT8_SYMM_PER_CHANNEL map 1906 .quant8ChannelOperands = {}, 1907 // int -> QUANT16_ASYMM map 1908 .quant16AsymmOperands = {}, 1909 // int -> QUANT8_SYMM map 1910 .quant8SymmOperands = {}, 1911 }, 1912 //Output(s) 1913 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1914 // int -> Dimensions map 1915 .operandDimensions = {{0, {1, 2, 2, 4}}}, 1916 // int -> FLOAT32 map 1917 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}}, 1918 // int -> INT32 map 1919 .int32Operands = {}, 1920 // int -> QUANT8_ASYMM map 1921 .quant8AsymmOperands = {}, 1922 // int -> QUANT16_SYMM map 1923 .quant16SymmOperands = {}, 1924 // int -> FLOAT16 map 1925 .float16Operands = {}, 1926 // int -> BOOL8 map 1927 .bool8Operands = {}, 1928 // int -> QUANT8_SYMM_PER_CHANNEL map 1929 .quant8ChannelOperands = {}, 1930 // int -> QUANT16_ASYMM map 1931 .quant16AsymmOperands = {}, 1932 // int -> QUANT8_SYMM map 1933 .quant8SymmOperands = {}, 1934 } 1935 }, 1936 }, // End of an example 1937 }; 1938 return examples_nhwc_weight_as_input_2; 1939 }; 1940 1941 std::vector<MixedTypedExample>& get_examples_nchw_2() { 1942 static std::vector<MixedTypedExample> examples_nchw_2 = { 1943 // Begin of an example 1944 { 1945 .operands = { 1946 //Input(s) 1947 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1948 // int -> Dimensions map 1949 .operandDimensions = {{0, {1, 2, 4, 4}}}, 1950 // int -> FLOAT32 map 1951 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 1952 // int -> INT32 map 1953 .int32Operands = {}, 1954 // int -> QUANT8_ASYMM map 1955 .quant8AsymmOperands = {}, 1956 // int -> QUANT16_SYMM map 1957 .quant16SymmOperands = {}, 1958 // int -> FLOAT16 map 1959 .float16Operands = {}, 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, 4, 2, 2}}}, 1973 // int -> FLOAT32 map 1974 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 1975 // int -> INT32 map 1976 .int32Operands = {}, 1977 // int -> QUANT8_ASYMM map 1978 .quant8AsymmOperands = {}, 1979 // int -> QUANT16_SYMM map 1980 .quant16SymmOperands = {}, 1981 // int -> FLOAT16 map 1982 .float16Operands = {}, 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_nchw_2; 1996 }; 1997 1998 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_2() { 1999 static std::vector<MixedTypedExample> examples_nchw_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, 2, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 2007 // int -> FLOAT32 map 2008 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 2009 // int -> INT32 map 2010 .int32Operands = {}, 2011 // int -> QUANT8_ASYMM map 2012 .quant8AsymmOperands = {}, 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, 4, 2, 2}}}, 2030 // int -> FLOAT32 map 2031 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 2032 // int -> INT32 map 2033 .int32Operands = {}, 2034 // int -> QUANT8_ASYMM map 2035 .quant8AsymmOperands = {}, 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_nchw_weight_as_input_2; 2053 }; 2054 2055 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_2() { 2056 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_2 = { 2057 // Begin of an example 2058 { 2059 .operands = { 2060 //Input(s) 2061 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2062 // int -> Dimensions map 2063 .operandDimensions = {{0, {1, 4, 4, 2}}}, 2064 // int -> FLOAT32 map 2065 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 2066 // int -> INT32 map 2067 .int32Operands = {}, 2068 // int -> QUANT8_ASYMM map 2069 .quant8AsymmOperands = {}, 2070 // int -> QUANT16_SYMM map 2071 .quant16SymmOperands = {}, 2072 // int -> FLOAT16 map 2073 .float16Operands = {}, 2074 // int -> BOOL8 map 2075 .bool8Operands = {}, 2076 // int -> QUANT8_SYMM_PER_CHANNEL map 2077 .quant8ChannelOperands = {}, 2078 // int -> QUANT16_ASYMM map 2079 .quant16AsymmOperands = {}, 2080 // int -> QUANT8_SYMM map 2081 .quant8SymmOperands = {}, 2082 }, 2083 //Output(s) 2084 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2085 // int -> Dimensions map 2086 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2087 // int -> FLOAT32 map 2088 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}}, 2089 // int -> INT32 map 2090 .int32Operands = {}, 2091 // int -> QUANT8_ASYMM map 2092 .quant8AsymmOperands = {}, 2093 // int -> QUANT16_SYMM map 2094 .quant16SymmOperands = {}, 2095 // int -> FLOAT16 map 2096 .float16Operands = {}, 2097 // int -> BOOL8 map 2098 .bool8Operands = {}, 2099 // int -> QUANT8_SYMM_PER_CHANNEL map 2100 .quant8ChannelOperands = {}, 2101 // int -> QUANT16_ASYMM map 2102 .quant16AsymmOperands = {}, 2103 // int -> QUANT8_SYMM map 2104 .quant8SymmOperands = {}, 2105 } 2106 }, 2107 }, // End of an example 2108 }; 2109 return examples_dynamic_output_shape_nhwc_2; 2110 }; 2111 2112 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_2() { 2113 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_2 = { 2114 // Begin of an example 2115 { 2116 .operands = { 2117 //Input(s) 2118 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2119 // int -> Dimensions map 2120 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 2121 // int -> FLOAT32 map 2122 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 2123 // int -> INT32 map 2124 .int32Operands = {}, 2125 // int -> QUANT8_ASYMM map 2126 .quant8AsymmOperands = {}, 2127 // int -> QUANT16_SYMM map 2128 .quant16SymmOperands = {}, 2129 // int -> FLOAT16 map 2130 .float16Operands = {}, 2131 // int -> BOOL8 map 2132 .bool8Operands = {}, 2133 // int -> QUANT8_SYMM_PER_CHANNEL map 2134 .quant8ChannelOperands = {}, 2135 // int -> QUANT16_ASYMM map 2136 .quant16AsymmOperands = {}, 2137 // int -> QUANT8_SYMM map 2138 .quant8SymmOperands = {}, 2139 }, 2140 //Output(s) 2141 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2142 // int -> Dimensions map 2143 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2144 // int -> FLOAT32 map 2145 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}}, 2146 // int -> INT32 map 2147 .int32Operands = {}, 2148 // int -> QUANT8_ASYMM map 2149 .quant8AsymmOperands = {}, 2150 // int -> QUANT16_SYMM map 2151 .quant16SymmOperands = {}, 2152 // int -> FLOAT16 map 2153 .float16Operands = {}, 2154 // int -> BOOL8 map 2155 .bool8Operands = {}, 2156 // int -> QUANT8_SYMM_PER_CHANNEL map 2157 .quant8ChannelOperands = {}, 2158 // int -> QUANT16_ASYMM map 2159 .quant16AsymmOperands = {}, 2160 // int -> QUANT8_SYMM map 2161 .quant8SymmOperands = {}, 2162 } 2163 }, 2164 }, // End of an example 2165 }; 2166 return examples_dynamic_output_shape_nhwc_weight_as_input_2; 2167 }; 2168 2169 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_2() { 2170 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_2 = { 2171 // Begin of an example 2172 { 2173 .operands = { 2174 //Input(s) 2175 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2176 // int -> Dimensions map 2177 .operandDimensions = {{0, {1, 2, 4, 4}}}, 2178 // int -> FLOAT32 map 2179 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 2180 // int -> INT32 map 2181 .int32Operands = {}, 2182 // int -> QUANT8_ASYMM map 2183 .quant8AsymmOperands = {}, 2184 // int -> QUANT16_SYMM map 2185 .quant16SymmOperands = {}, 2186 // int -> FLOAT16 map 2187 .float16Operands = {}, 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, 4, 2, 2}}}, 2201 // int -> FLOAT32 map 2202 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 2203 // int -> INT32 map 2204 .int32Operands = {}, 2205 // int -> QUANT8_ASYMM map 2206 .quant8AsymmOperands = {}, 2207 // int -> QUANT16_SYMM map 2208 .quant16SymmOperands = {}, 2209 // int -> FLOAT16 map 2210 .float16Operands = {}, 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_dynamic_output_shape_nchw_2; 2224 }; 2225 2226 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_2() { 2227 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_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, 2, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 2235 // int -> FLOAT32 map 2236 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 2237 // int -> INT32 map 2238 .int32Operands = {}, 2239 // int -> QUANT8_ASYMM map 2240 .quant8AsymmOperands = {}, 2241 // int -> QUANT16_SYMM map 2242 .quant16SymmOperands = {}, 2243 // int -> FLOAT16 map 2244 .float16Operands = {}, 2245 // int -> BOOL8 map 2246 .bool8Operands = {}, 2247 // int -> QUANT8_SYMM_PER_CHANNEL map 2248 .quant8ChannelOperands = {}, 2249 // int -> QUANT16_ASYMM map 2250 .quant16AsymmOperands = {}, 2251 // int -> QUANT8_SYMM map 2252 .quant8SymmOperands = {}, 2253 }, 2254 //Output(s) 2255 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2256 // int -> Dimensions map 2257 .operandDimensions = {{0, {1, 4, 2, 2}}}, 2258 // int -> FLOAT32 map 2259 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 2260 // int -> INT32 map 2261 .int32Operands = {}, 2262 // int -> QUANT8_ASYMM map 2263 .quant8AsymmOperands = {}, 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_dynamic_output_shape_nchw_weight_as_input_2; 2281 }; 2282 2283 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc() { 2284 static std::vector<MixedTypedExample> examples_valid_padding_nhwc = { 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 = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 2294 // int -> INT32 map 2295 .int32Operands = {}, 2296 // int -> QUANT8_ASYMM map 2297 .quant8AsymmOperands = {}, 2298 // int -> QUANT16_SYMM map 2299 .quant16SymmOperands = {}, 2300 // int -> FLOAT16 map 2301 .float16Operands = {}, 2302 // int -> BOOL8 map 2303 .bool8Operands = {}, 2304 // int -> QUANT8_SYMM_PER_CHANNEL map 2305 .quant8ChannelOperands = {}, 2306 // int -> QUANT16_ASYMM map 2307 .quant16AsymmOperands = {}, 2308 // int -> QUANT8_SYMM map 2309 .quant8SymmOperands = {}, 2310 }, 2311 //Output(s) 2312 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2313 // int -> Dimensions map 2314 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2315 // int -> FLOAT32 map 2316 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 2317 // int -> INT32 map 2318 .int32Operands = {}, 2319 // int -> QUANT8_ASYMM map 2320 .quant8AsymmOperands = {}, 2321 // int -> QUANT16_SYMM map 2322 .quant16SymmOperands = {}, 2323 // int -> FLOAT16 map 2324 .float16Operands = {}, 2325 // int -> BOOL8 map 2326 .bool8Operands = {}, 2327 // int -> QUANT8_SYMM_PER_CHANNEL map 2328 .quant8ChannelOperands = {}, 2329 // int -> QUANT16_ASYMM map 2330 .quant16AsymmOperands = {}, 2331 // int -> QUANT8_SYMM map 2332 .quant8SymmOperands = {}, 2333 } 2334 }, 2335 }, // End of an example 2336 }; 2337 return examples_valid_padding_nhwc; 2338 }; 2339 2340 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_relaxed() { 2341 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_relaxed = { 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}}}, 2349 // int -> FLOAT32 map 2350 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 2351 // int -> INT32 map 2352 .int32Operands = {}, 2353 // int -> QUANT8_ASYMM map 2354 .quant8AsymmOperands = {}, 2355 // int -> QUANT16_SYMM map 2356 .quant16SymmOperands = {}, 2357 // int -> FLOAT16 map 2358 .float16Operands = {}, 2359 // int -> BOOL8 map 2360 .bool8Operands = {}, 2361 // int -> QUANT8_SYMM_PER_CHANNEL map 2362 .quant8ChannelOperands = {}, 2363 // int -> QUANT16_ASYMM map 2364 .quant16AsymmOperands = {}, 2365 // int -> QUANT8_SYMM map 2366 .quant8SymmOperands = {}, 2367 }, 2368 //Output(s) 2369 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2370 // int -> Dimensions map 2371 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2372 // int -> FLOAT32 map 2373 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 2374 // int -> INT32 map 2375 .int32Operands = {}, 2376 // int -> QUANT8_ASYMM map 2377 .quant8AsymmOperands = {}, 2378 // int -> QUANT16_SYMM map 2379 .quant16SymmOperands = {}, 2380 // int -> FLOAT16 map 2381 .float16Operands = {}, 2382 // int -> BOOL8 map 2383 .bool8Operands = {}, 2384 // int -> QUANT8_SYMM_PER_CHANNEL map 2385 .quant8ChannelOperands = {}, 2386 // int -> QUANT16_ASYMM map 2387 .quant16AsymmOperands = {}, 2388 // int -> QUANT8_SYMM map 2389 .quant8SymmOperands = {}, 2390 } 2391 }, 2392 }, // End of an example 2393 }; 2394 return examples_valid_padding_nhwc_relaxed; 2395 }; 2396 2397 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_float16() { 2398 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_float16 = { 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 = {}, 2408 // int -> INT32 map 2409 .int32Operands = {}, 2410 // int -> QUANT8_ASYMM map 2411 .quant8AsymmOperands = {}, 2412 // int -> QUANT16_SYMM map 2413 .quant16SymmOperands = {}, 2414 // int -> FLOAT16 map 2415 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 2416 // int -> BOOL8 map 2417 .bool8Operands = {}, 2418 // int -> QUANT8_SYMM_PER_CHANNEL map 2419 .quant8ChannelOperands = {}, 2420 // int -> QUANT16_ASYMM map 2421 .quant16AsymmOperands = {}, 2422 // int -> QUANT8_SYMM map 2423 .quant8SymmOperands = {}, 2424 }, 2425 //Output(s) 2426 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2427 // int -> Dimensions map 2428 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2429 // int -> FLOAT32 map 2430 .float32Operands = {}, 2431 // int -> INT32 map 2432 .int32Operands = {}, 2433 // int -> QUANT8_ASYMM map 2434 .quant8AsymmOperands = {}, 2435 // int -> QUANT16_SYMM map 2436 .quant16SymmOperands = {}, 2437 // int -> FLOAT16 map 2438 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_valid_padding_nhwc_float16; 2452 }; 2453 2454 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_quant8() { 2455 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_quant8 = { 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}}}, 2463 // int -> FLOAT32 map 2464 .float32Operands = {}, 2465 // int -> INT32 map 2466 .int32Operands = {}, 2467 // int -> QUANT8_ASYMM map 2468 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}}, 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, 4}}}, 2486 // int -> FLOAT32 map 2487 .float32Operands = {}, 2488 // int -> INT32 map 2489 .int32Operands = {}, 2490 // int -> QUANT8_ASYMM map 2491 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_valid_padding_nhwc_quant8; 2509 }; 2510 2511 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input() { 2512 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input = { 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}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 2520 // int -> FLOAT32 map 2521 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.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, 4}}}, 2543 // int -> FLOAT32 map 2544 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_valid_padding_nhwc_weight_as_input; 2566 }; 2567 2568 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_relaxed() { 2569 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_relaxed = { 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, {1, 2, 2, 4}}, {2, {4}}}, 2577 // int -> FLOAT32 map 2578 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 2579 // int -> INT32 map 2580 .int32Operands = {}, 2581 // int -> QUANT8_ASYMM map 2582 .quant8AsymmOperands = {}, 2583 // int -> QUANT16_SYMM map 2584 .quant16SymmOperands = {}, 2585 // int -> FLOAT16 map 2586 .float16Operands = {}, 2587 // int -> BOOL8 map 2588 .bool8Operands = {}, 2589 // int -> QUANT8_SYMM_PER_CHANNEL map 2590 .quant8ChannelOperands = {}, 2591 // int -> QUANT16_ASYMM map 2592 .quant16AsymmOperands = {}, 2593 // int -> QUANT8_SYMM map 2594 .quant8SymmOperands = {}, 2595 }, 2596 //Output(s) 2597 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2598 // int -> Dimensions map 2599 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2600 // int -> FLOAT32 map 2601 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_valid_padding_nhwc_weight_as_input_relaxed; 2623 }; 2624 2625 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_float16() { 2626 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_float16 = { 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}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 2634 // int -> FLOAT32 map 2635 .float32Operands = {}, 2636 // int -> INT32 map 2637 .int32Operands = {}, 2638 // int -> QUANT8_ASYMM map 2639 .quant8AsymmOperands = {}, 2640 // int -> QUANT16_SYMM map 2641 .quant16SymmOperands = {}, 2642 // int -> FLOAT16 map 2643 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 2644 // int -> BOOL8 map 2645 .bool8Operands = {}, 2646 // int -> QUANT8_SYMM_PER_CHANNEL map 2647 .quant8ChannelOperands = {}, 2648 // int -> QUANT16_ASYMM map 2649 .quant16AsymmOperands = {}, 2650 // int -> QUANT8_SYMM map 2651 .quant8SymmOperands = {}, 2652 }, 2653 //Output(s) 2654 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2655 // int -> Dimensions map 2656 .operandDimensions = {{0, {1, 2, 2, 4}}}, 2657 // int -> FLOAT32 map 2658 .float32Operands = {}, 2659 // int -> INT32 map 2660 .int32Operands = {}, 2661 // int -> QUANT8_ASYMM map 2662 .quant8AsymmOperands = {}, 2663 // int -> QUANT16_SYMM map 2664 .quant16SymmOperands = {}, 2665 // int -> FLOAT16 map 2666 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_valid_padding_nhwc_weight_as_input_float16; 2680 }; 2681 2682 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_quant8() { 2683 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_quant8 = { 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, {1, 2, 2, 4}}, {2, {4}}}, 2691 // int -> FLOAT32 map 2692 .float32Operands = {}, 2693 // int -> INT32 map 2694 .int32Operands = {{2, {200, 400, 600, 800}}}, 2695 // int -> QUANT8_ASYMM map 2696 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 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, 4}}}, 2714 // int -> FLOAT32 map 2715 .float32Operands = {}, 2716 // int -> INT32 map 2717 .int32Operands = {}, 2718 // int -> QUANT8_ASYMM map 2719 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_valid_padding_nhwc_weight_as_input_quant8; 2737 }; 2738 2739 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw() { 2740 static std::vector<MixedTypedExample> examples_valid_padding_nchw = { 2741 // Begin of an example 2742 { 2743 .operands = { 2744 //Input(s) 2745 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2746 // int -> Dimensions map 2747 .operandDimensions = {{0, {1, 2, 3, 3}}}, 2748 // int -> FLOAT32 map 2749 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 2750 // int -> INT32 map 2751 .int32Operands = {}, 2752 // int -> QUANT8_ASYMM map 2753 .quant8AsymmOperands = {}, 2754 // int -> QUANT16_SYMM map 2755 .quant16SymmOperands = {}, 2756 // int -> FLOAT16 map 2757 .float16Operands = {}, 2758 // int -> BOOL8 map 2759 .bool8Operands = {}, 2760 // int -> QUANT8_SYMM_PER_CHANNEL map 2761 .quant8ChannelOperands = {}, 2762 // int -> QUANT16_ASYMM map 2763 .quant16AsymmOperands = {}, 2764 // int -> QUANT8_SYMM map 2765 .quant8SymmOperands = {}, 2766 }, 2767 //Output(s) 2768 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2769 // int -> Dimensions map 2770 .operandDimensions = {{0, {1, 4, 2, 2}}}, 2771 // int -> FLOAT32 map 2772 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 2773 // int -> INT32 map 2774 .int32Operands = {}, 2775 // int -> QUANT8_ASYMM map 2776 .quant8AsymmOperands = {}, 2777 // int -> QUANT16_SYMM map 2778 .quant16SymmOperands = {}, 2779 // int -> FLOAT16 map 2780 .float16Operands = {}, 2781 // int -> BOOL8 map 2782 .bool8Operands = {}, 2783 // int -> QUANT8_SYMM_PER_CHANNEL map 2784 .quant8ChannelOperands = {}, 2785 // int -> QUANT16_ASYMM map 2786 .quant16AsymmOperands = {}, 2787 // int -> QUANT8_SYMM map 2788 .quant8SymmOperands = {}, 2789 } 2790 }, 2791 }, // End of an example 2792 }; 2793 return examples_valid_padding_nchw; 2794 }; 2795 2796 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_relaxed() { 2797 static std::vector<MixedTypedExample> examples_valid_padding_nchw_relaxed = { 2798 // Begin of an example 2799 { 2800 .operands = { 2801 //Input(s) 2802 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2803 // int -> Dimensions map 2804 .operandDimensions = {{0, {1, 2, 3, 3}}}, 2805 // int -> FLOAT32 map 2806 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 2807 // int -> INT32 map 2808 .int32Operands = {}, 2809 // int -> QUANT8_ASYMM map 2810 .quant8AsymmOperands = {}, 2811 // int -> QUANT16_SYMM map 2812 .quant16SymmOperands = {}, 2813 // int -> FLOAT16 map 2814 .float16Operands = {}, 2815 // int -> BOOL8 map 2816 .bool8Operands = {}, 2817 // int -> QUANT8_SYMM_PER_CHANNEL map 2818 .quant8ChannelOperands = {}, 2819 // int -> QUANT16_ASYMM map 2820 .quant16AsymmOperands = {}, 2821 // int -> QUANT8_SYMM map 2822 .quant8SymmOperands = {}, 2823 }, 2824 //Output(s) 2825 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2826 // int -> Dimensions map 2827 .operandDimensions = {{0, {1, 4, 2, 2}}}, 2828 // int -> FLOAT32 map 2829 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 2830 // int -> INT32 map 2831 .int32Operands = {}, 2832 // int -> QUANT8_ASYMM map 2833 .quant8AsymmOperands = {}, 2834 // int -> QUANT16_SYMM map 2835 .quant16SymmOperands = {}, 2836 // int -> FLOAT16 map 2837 .float16Operands = {}, 2838 // int -> BOOL8 map 2839 .bool8Operands = {}, 2840 // int -> QUANT8_SYMM_PER_CHANNEL map 2841 .quant8ChannelOperands = {}, 2842 // int -> QUANT16_ASYMM map 2843 .quant16AsymmOperands = {}, 2844 // int -> QUANT8_SYMM map 2845 .quant8SymmOperands = {}, 2846 } 2847 }, 2848 }, // End of an example 2849 }; 2850 return examples_valid_padding_nchw_relaxed; 2851 }; 2852 2853 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_float16() { 2854 static std::vector<MixedTypedExample> examples_valid_padding_nchw_float16 = { 2855 // Begin of an example 2856 { 2857 .operands = { 2858 //Input(s) 2859 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2860 // int -> Dimensions map 2861 .operandDimensions = {{0, {1, 2, 3, 3}}}, 2862 // int -> FLOAT32 map 2863 .float32Operands = {}, 2864 // int -> INT32 map 2865 .int32Operands = {}, 2866 // int -> QUANT8_ASYMM map 2867 .quant8AsymmOperands = {}, 2868 // int -> QUANT16_SYMM map 2869 .quant16SymmOperands = {}, 2870 // int -> FLOAT16 map 2871 .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 2872 // int -> BOOL8 map 2873 .bool8Operands = {}, 2874 // int -> QUANT8_SYMM_PER_CHANNEL map 2875 .quant8ChannelOperands = {}, 2876 // int -> QUANT16_ASYMM map 2877 .quant16AsymmOperands = {}, 2878 // int -> QUANT8_SYMM map 2879 .quant8SymmOperands = {}, 2880 }, 2881 //Output(s) 2882 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2883 // int -> Dimensions map 2884 .operandDimensions = {{0, {1, 4, 2, 2}}}, 2885 // int -> FLOAT32 map 2886 .float32Operands = {}, 2887 // int -> INT32 map 2888 .int32Operands = {}, 2889 // int -> QUANT8_ASYMM map 2890 .quant8AsymmOperands = {}, 2891 // int -> QUANT16_SYMM map 2892 .quant16SymmOperands = {}, 2893 // int -> FLOAT16 map 2894 .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_valid_padding_nchw_float16; 2908 }; 2909 2910 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_quant8() { 2911 static std::vector<MixedTypedExample> examples_valid_padding_nchw_quant8 = { 2912 // Begin of an example 2913 { 2914 .operands = { 2915 //Input(s) 2916 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2917 // int -> Dimensions map 2918 .operandDimensions = {{0, {1, 2, 3, 3}}}, 2919 // int -> FLOAT32 map 2920 .float32Operands = {}, 2921 // int -> INT32 map 2922 .int32Operands = {}, 2923 // int -> QUANT8_ASYMM map 2924 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}}, 2925 // int -> QUANT16_SYMM map 2926 .quant16SymmOperands = {}, 2927 // int -> FLOAT16 map 2928 .float16Operands = {}, 2929 // int -> BOOL8 map 2930 .bool8Operands = {}, 2931 // int -> QUANT8_SYMM_PER_CHANNEL map 2932 .quant8ChannelOperands = {}, 2933 // int -> QUANT16_ASYMM map 2934 .quant16AsymmOperands = {}, 2935 // int -> QUANT8_SYMM map 2936 .quant8SymmOperands = {}, 2937 }, 2938 //Output(s) 2939 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2940 // int -> Dimensions map 2941 .operandDimensions = {{0, {1, 4, 2, 2}}}, 2942 // int -> FLOAT32 map 2943 .float32Operands = {}, 2944 // int -> INT32 map 2945 .int32Operands = {}, 2946 // int -> QUANT8_ASYMM map 2947 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 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_valid_padding_nchw_quant8; 2965 }; 2966 2967 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input() { 2968 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input = { 2969 // Begin of an example 2970 { 2971 .operands = { 2972 //Input(s) 2973 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2974 // int -> Dimensions map 2975 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 2976 // int -> FLOAT32 map 2977 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 2978 // int -> INT32 map 2979 .int32Operands = {}, 2980 // int -> QUANT8_ASYMM map 2981 .quant8AsymmOperands = {}, 2982 // int -> QUANT16_SYMM map 2983 .quant16SymmOperands = {}, 2984 // int -> FLOAT16 map 2985 .float16Operands = {}, 2986 // int -> BOOL8 map 2987 .bool8Operands = {}, 2988 // int -> QUANT8_SYMM_PER_CHANNEL map 2989 .quant8ChannelOperands = {}, 2990 // int -> QUANT16_ASYMM map 2991 .quant16AsymmOperands = {}, 2992 // int -> QUANT8_SYMM map 2993 .quant8SymmOperands = {}, 2994 }, 2995 //Output(s) 2996 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2997 // int -> Dimensions map 2998 .operandDimensions = {{0, {1, 4, 2, 2}}}, 2999 // int -> FLOAT32 map 3000 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 3001 // int -> INT32 map 3002 .int32Operands = {}, 3003 // int -> QUANT8_ASYMM map 3004 .quant8AsymmOperands = {}, 3005 // int -> QUANT16_SYMM map 3006 .quant16SymmOperands = {}, 3007 // int -> FLOAT16 map 3008 .float16Operands = {}, 3009 // int -> BOOL8 map 3010 .bool8Operands = {}, 3011 // int -> QUANT8_SYMM_PER_CHANNEL map 3012 .quant8ChannelOperands = {}, 3013 // int -> QUANT16_ASYMM map 3014 .quant16AsymmOperands = {}, 3015 // int -> QUANT8_SYMM map 3016 .quant8SymmOperands = {}, 3017 } 3018 }, 3019 }, // End of an example 3020 }; 3021 return examples_valid_padding_nchw_weight_as_input; 3022 }; 3023 3024 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_relaxed() { 3025 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_relaxed = { 3026 // Begin of an example 3027 { 3028 .operands = { 3029 //Input(s) 3030 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3031 // int -> Dimensions map 3032 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3033 // int -> FLOAT32 map 3034 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 3035 // int -> INT32 map 3036 .int32Operands = {}, 3037 // int -> QUANT8_ASYMM map 3038 .quant8AsymmOperands = {}, 3039 // int -> QUANT16_SYMM map 3040 .quant16SymmOperands = {}, 3041 // int -> FLOAT16 map 3042 .float16Operands = {}, 3043 // int -> BOOL8 map 3044 .bool8Operands = {}, 3045 // int -> QUANT8_SYMM_PER_CHANNEL map 3046 .quant8ChannelOperands = {}, 3047 // int -> QUANT16_ASYMM map 3048 .quant16AsymmOperands = {}, 3049 // int -> QUANT8_SYMM map 3050 .quant8SymmOperands = {}, 3051 }, 3052 //Output(s) 3053 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3054 // int -> Dimensions map 3055 .operandDimensions = {{0, {1, 4, 2, 2}}}, 3056 // int -> FLOAT32 map 3057 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 3058 // int -> INT32 map 3059 .int32Operands = {}, 3060 // int -> QUANT8_ASYMM map 3061 .quant8AsymmOperands = {}, 3062 // int -> QUANT16_SYMM map 3063 .quant16SymmOperands = {}, 3064 // int -> FLOAT16 map 3065 .float16Operands = {}, 3066 // int -> BOOL8 map 3067 .bool8Operands = {}, 3068 // int -> QUANT8_SYMM_PER_CHANNEL map 3069 .quant8ChannelOperands = {}, 3070 // int -> QUANT16_ASYMM map 3071 .quant16AsymmOperands = {}, 3072 // int -> QUANT8_SYMM map 3073 .quant8SymmOperands = {}, 3074 } 3075 }, 3076 }, // End of an example 3077 }; 3078 return examples_valid_padding_nchw_weight_as_input_relaxed; 3079 }; 3080 3081 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_float16() { 3082 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_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, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 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, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.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, 4, 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, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_valid_padding_nchw_weight_as_input_float16; 3136 }; 3137 3138 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_quant8() { 3139 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_quant8 = { 3140 // Begin of an example 3141 { 3142 .operands = { 3143 //Input(s) 3144 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3145 // int -> Dimensions map 3146 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3147 // int -> FLOAT32 map 3148 .float32Operands = {}, 3149 // int -> INT32 map 3150 .int32Operands = {{2, {200, 400, 600, 800}}}, 3151 // int -> QUANT8_ASYMM map 3152 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 3153 // int -> QUANT16_SYMM map 3154 .quant16SymmOperands = {}, 3155 // int -> FLOAT16 map 3156 .float16Operands = {}, 3157 // int -> BOOL8 map 3158 .bool8Operands = {}, 3159 // int -> QUANT8_SYMM_PER_CHANNEL map 3160 .quant8ChannelOperands = {}, 3161 // int -> QUANT16_ASYMM map 3162 .quant16AsymmOperands = {}, 3163 // int -> QUANT8_SYMM map 3164 .quant8SymmOperands = {}, 3165 }, 3166 //Output(s) 3167 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3168 // int -> Dimensions map 3169 .operandDimensions = {{0, {1, 4, 2, 2}}}, 3170 // int -> FLOAT32 map 3171 .float32Operands = {}, 3172 // int -> INT32 map 3173 .int32Operands = {}, 3174 // int -> QUANT8_ASYMM map 3175 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 3176 // int -> QUANT16_SYMM map 3177 .quant16SymmOperands = {}, 3178 // int -> FLOAT16 map 3179 .float16Operands = {}, 3180 // int -> BOOL8 map 3181 .bool8Operands = {}, 3182 // int -> QUANT8_SYMM_PER_CHANNEL map 3183 .quant8ChannelOperands = {}, 3184 // int -> QUANT16_ASYMM map 3185 .quant16AsymmOperands = {}, 3186 // int -> QUANT8_SYMM map 3187 .quant8SymmOperands = {}, 3188 } 3189 }, 3190 }, // End of an example 3191 }; 3192 return examples_valid_padding_nchw_weight_as_input_quant8; 3193 }; 3194 3195 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc() { 3196 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc = { 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, 3, 3, 2}}}, 3204 // int -> FLOAT32 map 3205 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.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, 4}}}, 3227 // int -> FLOAT32 map 3228 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_valid_padding_dynamic_output_shape_nhwc; 3250 }; 3251 3252 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_relaxed() { 3253 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_relaxed = { 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, 3, 3, 2}}}, 3261 // int -> FLOAT32 map 3262 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 3263 // int -> INT32 map 3264 .int32Operands = {}, 3265 // int -> QUANT8_ASYMM map 3266 .quant8AsymmOperands = {}, 3267 // int -> QUANT16_SYMM map 3268 .quant16SymmOperands = {}, 3269 // int -> FLOAT16 map 3270 .float16Operands = {}, 3271 // int -> BOOL8 map 3272 .bool8Operands = {}, 3273 // int -> QUANT8_SYMM_PER_CHANNEL map 3274 .quant8ChannelOperands = {}, 3275 // int -> QUANT16_ASYMM map 3276 .quant16AsymmOperands = {}, 3277 // int -> QUANT8_SYMM map 3278 .quant8SymmOperands = {}, 3279 }, 3280 //Output(s) 3281 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3282 // int -> Dimensions map 3283 .operandDimensions = {{0, {1, 2, 2, 4}}}, 3284 // int -> FLOAT32 map 3285 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 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_valid_padding_dynamic_output_shape_nhwc_relaxed; 3307 }; 3308 3309 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_float16() { 3310 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_float16 = { 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, 3, 3, 2}}}, 3318 // int -> FLOAT32 map 3319 .float32Operands = {}, 3320 // int -> INT32 map 3321 .int32Operands = {}, 3322 // int -> QUANT8_ASYMM map 3323 .quant8AsymmOperands = {}, 3324 // int -> QUANT16_SYMM map 3325 .quant16SymmOperands = {}, 3326 // int -> FLOAT16 map 3327 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}}, 3328 // int -> BOOL8 map 3329 .bool8Operands = {}, 3330 // int -> QUANT8_SYMM_PER_CHANNEL map 3331 .quant8ChannelOperands = {}, 3332 // int -> QUANT16_ASYMM map 3333 .quant16AsymmOperands = {}, 3334 // int -> QUANT8_SYMM map 3335 .quant8SymmOperands = {}, 3336 }, 3337 //Output(s) 3338 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3339 // int -> Dimensions map 3340 .operandDimensions = {{0, {1, 2, 2, 4}}}, 3341 // int -> FLOAT32 map 3342 .float32Operands = {}, 3343 // int -> INT32 map 3344 .int32Operands = {}, 3345 // int -> QUANT8_ASYMM map 3346 .quant8AsymmOperands = {}, 3347 // int -> QUANT16_SYMM map 3348 .quant16SymmOperands = {}, 3349 // int -> FLOAT16 map 3350 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_valid_padding_dynamic_output_shape_nhwc_float16; 3364 }; 3365 3366 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_quant8() { 3367 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_quant8 = { 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, 3, 3, 2}}}, 3375 // int -> FLOAT32 map 3376 .float32Operands = {}, 3377 // int -> INT32 map 3378 .int32Operands = {}, 3379 // int -> QUANT8_ASYMM map 3380 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}}, 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, 4}}}, 3398 // int -> FLOAT32 map 3399 .float32Operands = {}, 3400 // int -> INT32 map 3401 .int32Operands = {}, 3402 // int -> QUANT8_ASYMM map 3403 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_valid_padding_dynamic_output_shape_nhwc_quant8; 3421 }; 3422 3423 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input() { 3424 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input = { 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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3432 // int -> FLOAT32 map 3433 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 3434 // int -> INT32 map 3435 .int32Operands = {}, 3436 // int -> QUANT8_ASYMM map 3437 .quant8AsymmOperands = {}, 3438 // int -> QUANT16_SYMM map 3439 .quant16SymmOperands = {}, 3440 // int -> FLOAT16 map 3441 .float16Operands = {}, 3442 // int -> BOOL8 map 3443 .bool8Operands = {}, 3444 // int -> QUANT8_SYMM_PER_CHANNEL map 3445 .quant8ChannelOperands = {}, 3446 // int -> QUANT16_ASYMM map 3447 .quant16AsymmOperands = {}, 3448 // int -> QUANT8_SYMM map 3449 .quant8SymmOperands = {}, 3450 }, 3451 //Output(s) 3452 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3453 // int -> Dimensions map 3454 .operandDimensions = {{0, {1, 2, 2, 4}}}, 3455 // int -> FLOAT32 map 3456 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 3457 // int -> INT32 map 3458 .int32Operands = {}, 3459 // int -> QUANT8_ASYMM map 3460 .quant8AsymmOperands = {}, 3461 // int -> QUANT16_SYMM map 3462 .quant16SymmOperands = {}, 3463 // int -> FLOAT16 map 3464 .float16Operands = {}, 3465 // int -> BOOL8 map 3466 .bool8Operands = {}, 3467 // int -> QUANT8_SYMM_PER_CHANNEL map 3468 .quant8ChannelOperands = {}, 3469 // int -> QUANT16_ASYMM map 3470 .quant16AsymmOperands = {}, 3471 // int -> QUANT8_SYMM map 3472 .quant8SymmOperands = {}, 3473 } 3474 }, 3475 }, // End of an example 3476 }; 3477 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input; 3478 }; 3479 3480 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed() { 3481 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed = { 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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3489 // int -> FLOAT32 map 3490 .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 3491 // int -> INT32 map 3492 .int32Operands = {}, 3493 // int -> QUANT8_ASYMM map 3494 .quant8AsymmOperands = {}, 3495 // int -> QUANT16_SYMM map 3496 .quant16SymmOperands = {}, 3497 // int -> FLOAT16 map 3498 .float16Operands = {}, 3499 // int -> BOOL8 map 3500 .bool8Operands = {}, 3501 // int -> QUANT8_SYMM_PER_CHANNEL map 3502 .quant8ChannelOperands = {}, 3503 // int -> QUANT16_ASYMM map 3504 .quant16AsymmOperands = {}, 3505 // int -> QUANT8_SYMM map 3506 .quant8SymmOperands = {}, 3507 }, 3508 //Output(s) 3509 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3510 // int -> Dimensions map 3511 .operandDimensions = {{0, {1, 2, 2, 4}}}, 3512 // int -> FLOAT32 map 3513 .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}}, 3514 // int -> INT32 map 3515 .int32Operands = {}, 3516 // int -> QUANT8_ASYMM map 3517 .quant8AsymmOperands = {}, 3518 // int -> QUANT16_SYMM map 3519 .quant16SymmOperands = {}, 3520 // int -> FLOAT16 map 3521 .float16Operands = {}, 3522 // int -> BOOL8 map 3523 .bool8Operands = {}, 3524 // int -> QUANT8_SYMM_PER_CHANNEL map 3525 .quant8ChannelOperands = {}, 3526 // int -> QUANT16_ASYMM map 3527 .quant16AsymmOperands = {}, 3528 // int -> QUANT8_SYMM map 3529 .quant8SymmOperands = {}, 3530 } 3531 }, 3532 }, // End of an example 3533 }; 3534 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed; 3535 }; 3536 3537 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16() { 3538 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16 = { 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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3546 // int -> FLOAT32 map 3547 .float32Operands = {}, 3548 // int -> INT32 map 3549 .int32Operands = {}, 3550 // int -> QUANT8_ASYMM map 3551 .quant8AsymmOperands = {}, 3552 // int -> QUANT16_SYMM map 3553 .quant16SymmOperands = {}, 3554 // int -> FLOAT16 map 3555 .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 3556 // int -> BOOL8 map 3557 .bool8Operands = {}, 3558 // int -> QUANT8_SYMM_PER_CHANNEL map 3559 .quant8ChannelOperands = {}, 3560 // int -> QUANT16_ASYMM map 3561 .quant16AsymmOperands = {}, 3562 // int -> QUANT8_SYMM map 3563 .quant8SymmOperands = {}, 3564 }, 3565 //Output(s) 3566 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3567 // int -> Dimensions map 3568 .operandDimensions = {{0, {1, 2, 2, 4}}}, 3569 // int -> FLOAT32 map 3570 .float32Operands = {}, 3571 // int -> INT32 map 3572 .int32Operands = {}, 3573 // int -> QUANT8_ASYMM map 3574 .quant8AsymmOperands = {}, 3575 // int -> QUANT16_SYMM map 3576 .quant16SymmOperands = {}, 3577 // int -> FLOAT16 map 3578 .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}}, 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_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16; 3592 }; 3593 3594 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8() { 3595 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8 = { 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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3603 // int -> FLOAT32 map 3604 .float32Operands = {}, 3605 // int -> INT32 map 3606 .int32Operands = {{2, {200, 400, 600, 800}}}, 3607 // int -> QUANT8_ASYMM map 3608 .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 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, 4}}}, 3626 // int -> FLOAT32 map 3627 .float32Operands = {}, 3628 // int -> INT32 map 3629 .int32Operands = {}, 3630 // int -> QUANT8_ASYMM map 3631 .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}}, 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_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8; 3649 }; 3650 3651 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw() { 3652 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw = { 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 = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 3662 // int -> INT32 map 3663 .int32Operands = {}, 3664 // int -> QUANT8_ASYMM map 3665 .quant8AsymmOperands = {}, 3666 // int -> QUANT16_SYMM map 3667 .quant16SymmOperands = {}, 3668 // int -> FLOAT16 map 3669 .float16Operands = {}, 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, 4, 2, 2}}}, 3683 // int -> FLOAT32 map 3684 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 3685 // int -> INT32 map 3686 .int32Operands = {}, 3687 // int -> QUANT8_ASYMM map 3688 .quant8AsymmOperands = {}, 3689 // int -> QUANT16_SYMM map 3690 .quant16SymmOperands = {}, 3691 // int -> FLOAT16 map 3692 .float16Operands = {}, 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_valid_padding_dynamic_output_shape_nchw; 3706 }; 3707 3708 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_relaxed() { 3709 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_relaxed = { 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}}}, 3717 // int -> FLOAT32 map 3718 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 3719 // int -> INT32 map 3720 .int32Operands = {}, 3721 // int -> QUANT8_ASYMM map 3722 .quant8AsymmOperands = {}, 3723 // int -> QUANT16_SYMM map 3724 .quant16SymmOperands = {}, 3725 // int -> FLOAT16 map 3726 .float16Operands = {}, 3727 // int -> BOOL8 map 3728 .bool8Operands = {}, 3729 // int -> QUANT8_SYMM_PER_CHANNEL map 3730 .quant8ChannelOperands = {}, 3731 // int -> QUANT16_ASYMM map 3732 .quant16AsymmOperands = {}, 3733 // int -> QUANT8_SYMM map 3734 .quant8SymmOperands = {}, 3735 }, 3736 //Output(s) 3737 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3738 // int -> Dimensions map 3739 .operandDimensions = {{0, {1, 4, 2, 2}}}, 3740 // int -> FLOAT32 map 3741 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 3742 // int -> INT32 map 3743 .int32Operands = {}, 3744 // int -> QUANT8_ASYMM map 3745 .quant8AsymmOperands = {}, 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_valid_padding_dynamic_output_shape_nchw_relaxed; 3763 }; 3764 3765 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_float16() { 3766 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_float16 = { 3767 // Begin of an example 3768 { 3769 .operands = { 3770 //Input(s) 3771 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3772 // int -> Dimensions map 3773 .operandDimensions = {{0, {1, 2, 3, 3}}}, 3774 // int -> FLOAT32 map 3775 .float32Operands = {}, 3776 // int -> INT32 map 3777 .int32Operands = {}, 3778 // int -> QUANT8_ASYMM map 3779 .quant8AsymmOperands = {}, 3780 // int -> QUANT16_SYMM map 3781 .quant16SymmOperands = {}, 3782 // int -> FLOAT16 map 3783 .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}}, 3784 // int -> BOOL8 map 3785 .bool8Operands = {}, 3786 // int -> QUANT8_SYMM_PER_CHANNEL map 3787 .quant8ChannelOperands = {}, 3788 // int -> QUANT16_ASYMM map 3789 .quant16AsymmOperands = {}, 3790 // int -> QUANT8_SYMM map 3791 .quant8SymmOperands = {}, 3792 }, 3793 //Output(s) 3794 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3795 // int -> Dimensions map 3796 .operandDimensions = {{0, {1, 4, 2, 2}}}, 3797 // int -> FLOAT32 map 3798 .float32Operands = {}, 3799 // int -> INT32 map 3800 .int32Operands = {}, 3801 // int -> QUANT8_ASYMM map 3802 .quant8AsymmOperands = {}, 3803 // int -> QUANT16_SYMM map 3804 .quant16SymmOperands = {}, 3805 // int -> FLOAT16 map 3806 .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_valid_padding_dynamic_output_shape_nchw_float16; 3820 }; 3821 3822 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_quant8() { 3823 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_quant8 = { 3824 // Begin of an example 3825 { 3826 .operands = { 3827 //Input(s) 3828 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3829 // int -> Dimensions map 3830 .operandDimensions = {{0, {1, 2, 3, 3}}}, 3831 // int -> FLOAT32 map 3832 .float32Operands = {}, 3833 // int -> INT32 map 3834 .int32Operands = {}, 3835 // int -> QUANT8_ASYMM map 3836 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}}, 3837 // int -> QUANT16_SYMM map 3838 .quant16SymmOperands = {}, 3839 // int -> FLOAT16 map 3840 .float16Operands = {}, 3841 // int -> BOOL8 map 3842 .bool8Operands = {}, 3843 // int -> QUANT8_SYMM_PER_CHANNEL map 3844 .quant8ChannelOperands = {}, 3845 // int -> QUANT16_ASYMM map 3846 .quant16AsymmOperands = {}, 3847 // int -> QUANT8_SYMM map 3848 .quant8SymmOperands = {}, 3849 }, 3850 //Output(s) 3851 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3852 // int -> Dimensions map 3853 .operandDimensions = {{0, {1, 4, 2, 2}}}, 3854 // int -> FLOAT32 map 3855 .float32Operands = {}, 3856 // int -> INT32 map 3857 .int32Operands = {}, 3858 // int -> QUANT8_ASYMM map 3859 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 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_valid_padding_dynamic_output_shape_nchw_quant8; 3877 }; 3878 3879 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input() { 3880 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input = { 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}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 3888 // int -> FLOAT32 map 3889 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 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 = {}, 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, 4, 2, 2}}}, 3911 // int -> FLOAT32 map 3912 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 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 = {}, 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_valid_padding_dynamic_output_shape_nchw_weight_as_input; 3934 }; 3935 3936 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed() { 3937 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed = { 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, {1, 2, 2, 4}}, {2, {4}}}, 3945 // int -> FLOAT32 map 3946 .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 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 = {}, 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, 4, 2, 2}}}, 3968 // int -> FLOAT32 map 3969 .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}}, 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 = {}, 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_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed; 3991 }; 3992 3993 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16() { 3994 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16 = { 3995 // Begin of an example 3996 { 3997 .operands = { 3998 //Input(s) 3999 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4000 // int -> Dimensions map 4001 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 4002 // int -> FLOAT32 map 4003 .float32Operands = {}, 4004 // int -> INT32 map 4005 .int32Operands = {}, 4006 // int -> QUANT8_ASYMM map 4007 .quant8AsymmOperands = {}, 4008 // int -> QUANT16_SYMM map 4009 .quant16SymmOperands = {}, 4010 // int -> FLOAT16 map 4011 .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}}, 4012 // int -> BOOL8 map 4013 .bool8Operands = {}, 4014 // int -> QUANT8_SYMM_PER_CHANNEL map 4015 .quant8ChannelOperands = {}, 4016 // int -> QUANT16_ASYMM map 4017 .quant16AsymmOperands = {}, 4018 // int -> QUANT8_SYMM map 4019 .quant8SymmOperands = {}, 4020 }, 4021 //Output(s) 4022 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4023 // int -> Dimensions map 4024 .operandDimensions = {{0, {1, 4, 2, 2}}}, 4025 // int -> FLOAT32 map 4026 .float32Operands = {}, 4027 // int -> INT32 map 4028 .int32Operands = {}, 4029 // int -> QUANT8_ASYMM map 4030 .quant8AsymmOperands = {}, 4031 // int -> QUANT16_SYMM map 4032 .quant16SymmOperands = {}, 4033 // int -> FLOAT16 map 4034 .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}}, 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_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16; 4048 }; 4049 4050 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8() { 4051 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8 = { 4052 // Begin of an example 4053 { 4054 .operands = { 4055 //Input(s) 4056 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4057 // int -> Dimensions map 4058 .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 4059 // int -> FLOAT32 map 4060 .float32Operands = {}, 4061 // int -> INT32 map 4062 .int32Operands = {{2, {200, 400, 600, 800}}}, 4063 // int -> QUANT8_ASYMM map 4064 .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}}, 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, 4, 2, 2}}}, 4082 // int -> FLOAT32 map 4083 .float32Operands = {}, 4084 // int -> INT32 map 4085 .int32Operands = {}, 4086 // int -> QUANT8_ASYMM map 4087 .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}}, 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_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8; 4105 }; 4106 4107 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_2() { 4108 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_2 = { 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, 4, 4, 2}}}, 4116 // int -> FLOAT32 map 4117 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.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, 4}}}, 4139 // int -> FLOAT32 map 4140 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.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_valid_padding_nhwc_2; 4162 }; 4163 4164 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_2() { 4165 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_2 = { 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, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 4173 // int -> FLOAT32 map 4174 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 4175 // int -> INT32 map 4176 .int32Operands = {}, 4177 // int -> QUANT8_ASYMM map 4178 .quant8AsymmOperands = {}, 4179 // int -> QUANT16_SYMM map 4180 .quant16SymmOperands = {}, 4181 // int -> FLOAT16 map 4182 .float16Operands = {}, 4183 // int -> BOOL8 map 4184 .bool8Operands = {}, 4185 // int -> QUANT8_SYMM_PER_CHANNEL map 4186 .quant8ChannelOperands = {}, 4187 // int -> QUANT16_ASYMM map 4188 .quant16AsymmOperands = {}, 4189 // int -> QUANT8_SYMM map 4190 .quant8SymmOperands = {}, 4191 }, 4192 //Output(s) 4193 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4194 // int -> Dimensions map 4195 .operandDimensions = {{0, {1, 2, 2, 4}}}, 4196 // int -> FLOAT32 map 4197 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.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_valid_padding_nhwc_weight_as_input_2; 4219 }; 4220 4221 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_2() { 4222 static std::vector<MixedTypedExample> examples_valid_padding_nchw_2 = { 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, 4, 4}}}, 4230 // int -> FLOAT32 map 4231 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 4232 // int -> INT32 map 4233 .int32Operands = {}, 4234 // int -> QUANT8_ASYMM map 4235 .quant8AsymmOperands = {}, 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, 4, 2, 2}}}, 4253 // int -> FLOAT32 map 4254 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 4255 // int -> INT32 map 4256 .int32Operands = {}, 4257 // int -> QUANT8_ASYMM map 4258 .quant8AsymmOperands = {}, 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_valid_padding_nchw_2; 4276 }; 4277 4278 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_2() { 4279 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_2 = { 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, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 4287 // int -> FLOAT32 map 4288 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 4289 // int -> INT32 map 4290 .int32Operands = {}, 4291 // int -> QUANT8_ASYMM map 4292 .quant8AsymmOperands = {}, 4293 // int -> QUANT16_SYMM map 4294 .quant16SymmOperands = {}, 4295 // int -> FLOAT16 map 4296 .float16Operands = {}, 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, 4, 2, 2}}}, 4310 // int -> FLOAT32 map 4311 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 4312 // int -> INT32 map 4313 .int32Operands = {}, 4314 // int -> QUANT8_ASYMM map 4315 .quant8AsymmOperands = {}, 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_valid_padding_nchw_weight_as_input_2; 4333 }; 4334 4335 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_2() { 4336 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_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, 4, 4, 2}}}, 4344 // int -> FLOAT32 map 4345 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 4346 // int -> INT32 map 4347 .int32Operands = {}, 4348 // int -> QUANT8_ASYMM map 4349 .quant8AsymmOperands = {}, 4350 // int -> QUANT16_SYMM map 4351 .quant16SymmOperands = {}, 4352 // int -> FLOAT16 map 4353 .float16Operands = {}, 4354 // int -> BOOL8 map 4355 .bool8Operands = {}, 4356 // int -> QUANT8_SYMM_PER_CHANNEL map 4357 .quant8ChannelOperands = {}, 4358 // int -> QUANT16_ASYMM map 4359 .quant16AsymmOperands = {}, 4360 // int -> QUANT8_SYMM map 4361 .quant8SymmOperands = {}, 4362 }, 4363 //Output(s) 4364 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4365 // int -> Dimensions map 4366 .operandDimensions = {{0, {1, 2, 2, 4}}}, 4367 // int -> FLOAT32 map 4368 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}}, 4369 // int -> INT32 map 4370 .int32Operands = {}, 4371 // int -> QUANT8_ASYMM map 4372 .quant8AsymmOperands = {}, 4373 // int -> QUANT16_SYMM map 4374 .quant16SymmOperands = {}, 4375 // int -> FLOAT16 map 4376 .float16Operands = {}, 4377 // int -> BOOL8 map 4378 .bool8Operands = {}, 4379 // int -> QUANT8_SYMM_PER_CHANNEL map 4380 .quant8ChannelOperands = {}, 4381 // int -> QUANT16_ASYMM map 4382 .quant16AsymmOperands = {}, 4383 // int -> QUANT8_SYMM map 4384 .quant8SymmOperands = {}, 4385 } 4386 }, 4387 }, // End of an example 4388 }; 4389 return examples_valid_padding_dynamic_output_shape_nhwc_2; 4390 }; 4391 4392 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_2() { 4393 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_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, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 4401 // int -> FLOAT32 map 4402 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 4403 // int -> INT32 map 4404 .int32Operands = {}, 4405 // int -> QUANT8_ASYMM map 4406 .quant8AsymmOperands = {}, 4407 // int -> QUANT16_SYMM map 4408 .quant16SymmOperands = {}, 4409 // int -> FLOAT16 map 4410 .float16Operands = {}, 4411 // int -> BOOL8 map 4412 .bool8Operands = {}, 4413 // int -> QUANT8_SYMM_PER_CHANNEL map 4414 .quant8ChannelOperands = {}, 4415 // int -> QUANT16_ASYMM map 4416 .quant16AsymmOperands = {}, 4417 // int -> QUANT8_SYMM map 4418 .quant8SymmOperands = {}, 4419 }, 4420 //Output(s) 4421 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4422 // int -> Dimensions map 4423 .operandDimensions = {{0, {1, 2, 2, 4}}}, 4424 // int -> FLOAT32 map 4425 .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}}, 4426 // int -> INT32 map 4427 .int32Operands = {}, 4428 // int -> QUANT8_ASYMM map 4429 .quant8AsymmOperands = {}, 4430 // int -> QUANT16_SYMM map 4431 .quant16SymmOperands = {}, 4432 // int -> FLOAT16 map 4433 .float16Operands = {}, 4434 // int -> BOOL8 map 4435 .bool8Operands = {}, 4436 // int -> QUANT8_SYMM_PER_CHANNEL map 4437 .quant8ChannelOperands = {}, 4438 // int -> QUANT16_ASYMM map 4439 .quant16AsymmOperands = {}, 4440 // int -> QUANT8_SYMM map 4441 .quant8SymmOperands = {}, 4442 } 4443 }, 4444 }, // End of an example 4445 }; 4446 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_2; 4447 }; 4448 4449 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_2() { 4450 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_2 = { 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, 4, 4}}}, 4458 // int -> FLOAT32 map 4459 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 4460 // int -> INT32 map 4461 .int32Operands = {}, 4462 // int -> QUANT8_ASYMM map 4463 .quant8AsymmOperands = {}, 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, 4, 2, 2}}}, 4481 // int -> FLOAT32 map 4482 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 4483 // int -> INT32 map 4484 .int32Operands = {}, 4485 // int -> QUANT8_ASYMM map 4486 .quant8AsymmOperands = {}, 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_valid_padding_dynamic_output_shape_nchw_2; 4504 }; 4505 4506 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_2() { 4507 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_2 = { 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, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}}, 4515 // int -> FLOAT32 map 4516 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}}, 4517 // int -> INT32 map 4518 .int32Operands = {}, 4519 // int -> QUANT8_ASYMM map 4520 .quant8AsymmOperands = {}, 4521 // int -> QUANT16_SYMM map 4522 .quant16SymmOperands = {}, 4523 // int -> FLOAT16 map 4524 .float16Operands = {}, 4525 // int -> BOOL8 map 4526 .bool8Operands = {}, 4527 // int -> QUANT8_SYMM_PER_CHANNEL map 4528 .quant8ChannelOperands = {}, 4529 // int -> QUANT16_ASYMM map 4530 .quant16AsymmOperands = {}, 4531 // int -> QUANT8_SYMM map 4532 .quant8SymmOperands = {}, 4533 }, 4534 //Output(s) 4535 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4536 // int -> Dimensions map 4537 .operandDimensions = {{0, {1, 4, 2, 2}}}, 4538 // int -> FLOAT32 map 4539 .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}}, 4540 // int -> INT32 map 4541 .int32Operands = {}, 4542 // int -> QUANT8_ASYMM map 4543 .quant8AsymmOperands = {}, 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_valid_padding_dynamic_output_shape_nchw_weight_as_input_2; 4561 }; 4562 4563 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc() { 4564 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc = { 4565 // Begin of an example 4566 { 4567 .operands = { 4568 //Input(s) 4569 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4570 // int -> Dimensions map 4571 .operandDimensions = {{0, {1, 6, 6, 1}}}, 4572 // int -> FLOAT32 map 4573 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 4574 // int -> INT32 map 4575 .int32Operands = {}, 4576 // int -> QUANT8_ASYMM map 4577 .quant8AsymmOperands = {}, 4578 // int -> QUANT16_SYMM map 4579 .quant16SymmOperands = {}, 4580 // int -> FLOAT16 map 4581 .float16Operands = {}, 4582 // int -> BOOL8 map 4583 .bool8Operands = {}, 4584 // int -> QUANT8_SYMM_PER_CHANNEL map 4585 .quant8ChannelOperands = {}, 4586 // int -> QUANT16_ASYMM map 4587 .quant16AsymmOperands = {}, 4588 // int -> QUANT8_SYMM map 4589 .quant8SymmOperands = {}, 4590 }, 4591 //Output(s) 4592 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4593 // int -> Dimensions map 4594 .operandDimensions = {{0, {1, 3, 3, 1}}}, 4595 // int -> FLOAT32 map 4596 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 4597 // int -> INT32 map 4598 .int32Operands = {}, 4599 // int -> QUANT8_ASYMM map 4600 .quant8AsymmOperands = {}, 4601 // int -> QUANT16_SYMM map 4602 .quant16SymmOperands = {}, 4603 // int -> FLOAT16 map 4604 .float16Operands = {}, 4605 // int -> BOOL8 map 4606 .bool8Operands = {}, 4607 // int -> QUANT8_SYMM_PER_CHANNEL map 4608 .quant8ChannelOperands = {}, 4609 // int -> QUANT16_ASYMM map 4610 .quant16AsymmOperands = {}, 4611 // int -> QUANT8_SYMM map 4612 .quant8SymmOperands = {}, 4613 } 4614 }, 4615 }, // End of an example 4616 }; 4617 return examples_same_padding_stride_2_nhwc; 4618 }; 4619 4620 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_relaxed() { 4621 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_relaxed = { 4622 // Begin of an example 4623 { 4624 .operands = { 4625 //Input(s) 4626 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4627 // int -> Dimensions map 4628 .operandDimensions = {{0, {1, 6, 6, 1}}}, 4629 // int -> FLOAT32 map 4630 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 4631 // int -> INT32 map 4632 .int32Operands = {}, 4633 // int -> QUANT8_ASYMM map 4634 .quant8AsymmOperands = {}, 4635 // int -> QUANT16_SYMM map 4636 .quant16SymmOperands = {}, 4637 // int -> FLOAT16 map 4638 .float16Operands = {}, 4639 // int -> BOOL8 map 4640 .bool8Operands = {}, 4641 // int -> QUANT8_SYMM_PER_CHANNEL map 4642 .quant8ChannelOperands = {}, 4643 // int -> QUANT16_ASYMM map 4644 .quant16AsymmOperands = {}, 4645 // int -> QUANT8_SYMM map 4646 .quant8SymmOperands = {}, 4647 }, 4648 //Output(s) 4649 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4650 // int -> Dimensions map 4651 .operandDimensions = {{0, {1, 3, 3, 1}}}, 4652 // int -> FLOAT32 map 4653 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 4654 // int -> INT32 map 4655 .int32Operands = {}, 4656 // int -> QUANT8_ASYMM map 4657 .quant8AsymmOperands = {}, 4658 // int -> QUANT16_SYMM map 4659 .quant16SymmOperands = {}, 4660 // int -> FLOAT16 map 4661 .float16Operands = {}, 4662 // int -> BOOL8 map 4663 .bool8Operands = {}, 4664 // int -> QUANT8_SYMM_PER_CHANNEL map 4665 .quant8ChannelOperands = {}, 4666 // int -> QUANT16_ASYMM map 4667 .quant16AsymmOperands = {}, 4668 // int -> QUANT8_SYMM map 4669 .quant8SymmOperands = {}, 4670 } 4671 }, 4672 }, // End of an example 4673 }; 4674 return examples_same_padding_stride_2_nhwc_relaxed; 4675 }; 4676 4677 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_quant8() { 4678 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_quant8 = { 4679 // Begin of an example 4680 { 4681 .operands = { 4682 //Input(s) 4683 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4684 // int -> Dimensions map 4685 .operandDimensions = {{0, {1, 6, 6, 1}}}, 4686 // int -> FLOAT32 map 4687 .float32Operands = {}, 4688 // int -> INT32 map 4689 .int32Operands = {}, 4690 // int -> QUANT8_ASYMM map 4691 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 4692 // int -> QUANT16_SYMM map 4693 .quant16SymmOperands = {}, 4694 // int -> FLOAT16 map 4695 .float16Operands = {}, 4696 // int -> BOOL8 map 4697 .bool8Operands = {}, 4698 // int -> QUANT8_SYMM_PER_CHANNEL map 4699 .quant8ChannelOperands = {}, 4700 // int -> QUANT16_ASYMM map 4701 .quant16AsymmOperands = {}, 4702 // int -> QUANT8_SYMM map 4703 .quant8SymmOperands = {}, 4704 }, 4705 //Output(s) 4706 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4707 // int -> Dimensions map 4708 .operandDimensions = {{0, {1, 3, 3, 1}}}, 4709 // int -> FLOAT32 map 4710 .float32Operands = {}, 4711 // int -> INT32 map 4712 .int32Operands = {}, 4713 // int -> QUANT8_ASYMM map 4714 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 4715 // int -> QUANT16_SYMM map 4716 .quant16SymmOperands = {}, 4717 // int -> FLOAT16 map 4718 .float16Operands = {}, 4719 // int -> BOOL8 map 4720 .bool8Operands = {}, 4721 // int -> QUANT8_SYMM_PER_CHANNEL map 4722 .quant8ChannelOperands = {}, 4723 // int -> QUANT16_ASYMM map 4724 .quant16AsymmOperands = {}, 4725 // int -> QUANT8_SYMM map 4726 .quant8SymmOperands = {}, 4727 } 4728 }, 4729 }, // End of an example 4730 }; 4731 return examples_same_padding_stride_2_nhwc_quant8; 4732 }; 4733 4734 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_float16() { 4735 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_float16 = { 4736 // Begin of an example 4737 { 4738 .operands = { 4739 //Input(s) 4740 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4741 // int -> Dimensions map 4742 .operandDimensions = {{0, {1, 6, 6, 1}}}, 4743 // int -> FLOAT32 map 4744 .float32Operands = {}, 4745 // int -> INT32 map 4746 .int32Operands = {}, 4747 // int -> QUANT8_ASYMM map 4748 .quant8AsymmOperands = {}, 4749 // int -> QUANT16_SYMM map 4750 .quant16SymmOperands = {}, 4751 // int -> FLOAT16 map 4752 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 4753 // int -> BOOL8 map 4754 .bool8Operands = {}, 4755 // int -> QUANT8_SYMM_PER_CHANNEL map 4756 .quant8ChannelOperands = {}, 4757 // int -> QUANT16_ASYMM map 4758 .quant16AsymmOperands = {}, 4759 // int -> QUANT8_SYMM map 4760 .quant8SymmOperands = {}, 4761 }, 4762 //Output(s) 4763 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4764 // int -> Dimensions map 4765 .operandDimensions = {{0, {1, 3, 3, 1}}}, 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, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.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_same_padding_stride_2_nhwc_float16; 4789 }; 4790 4791 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input() { 4792 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input = { 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, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 4800 // int -> FLOAT32 map 4801 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.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, 3, 3, 1}}}, 4823 // int -> FLOAT32 map 4824 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.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_same_padding_stride_2_nhwc_weight_as_input; 4846 }; 4847 4848 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input_relaxed() { 4849 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input_relaxed = { 4850 // Begin of an example 4851 { 4852 .operands = { 4853 //Input(s) 4854 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4855 // int -> Dimensions map 4856 .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 4857 // int -> FLOAT32 map 4858 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 4859 // int -> INT32 map 4860 .int32Operands = {}, 4861 // int -> QUANT8_ASYMM map 4862 .quant8AsymmOperands = {}, 4863 // int -> QUANT16_SYMM map 4864 .quant16SymmOperands = {}, 4865 // int -> FLOAT16 map 4866 .float16Operands = {}, 4867 // int -> BOOL8 map 4868 .bool8Operands = {}, 4869 // int -> QUANT8_SYMM_PER_CHANNEL map 4870 .quant8ChannelOperands = {}, 4871 // int -> QUANT16_ASYMM map 4872 .quant16AsymmOperands = {}, 4873 // int -> QUANT8_SYMM map 4874 .quant8SymmOperands = {}, 4875 }, 4876 //Output(s) 4877 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4878 // int -> Dimensions map 4879 .operandDimensions = {{0, {1, 3, 3, 1}}}, 4880 // int -> FLOAT32 map 4881 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.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_same_padding_stride_2_nhwc_weight_as_input_relaxed; 4903 }; 4904 4905 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input_quant8() { 4906 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input_quant8 = { 4907 // Begin of an example 4908 { 4909 .operands = { 4910 //Input(s) 4911 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4912 // int -> Dimensions map 4913 .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 4914 // int -> FLOAT32 map 4915 .float32Operands = {}, 4916 // int -> INT32 map 4917 .int32Operands = {{2, {0}}}, 4918 // int -> QUANT8_ASYMM map 4919 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}}, 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, 3, 3, 1}}}, 4937 // int -> FLOAT32 map 4938 .float32Operands = {}, 4939 // int -> INT32 map 4940 .int32Operands = {}, 4941 // int -> QUANT8_ASYMM map 4942 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 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_same_padding_stride_2_nhwc_weight_as_input_quant8; 4960 }; 4961 4962 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input_float16() { 4963 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input_float16 = { 4964 // Begin of an example 4965 { 4966 .operands = { 4967 //Input(s) 4968 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4969 // int -> Dimensions map 4970 .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 4971 // int -> FLOAT32 map 4972 .float32Operands = {}, 4973 // int -> INT32 map 4974 .int32Operands = {}, 4975 // int -> QUANT8_ASYMM map 4976 .quant8AsymmOperands = {}, 4977 // int -> QUANT16_SYMM map 4978 .quant16SymmOperands = {}, 4979 // int -> FLOAT16 map 4980 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 4981 // int -> BOOL8 map 4982 .bool8Operands = {}, 4983 // int -> QUANT8_SYMM_PER_CHANNEL map 4984 .quant8ChannelOperands = {}, 4985 // int -> QUANT16_ASYMM map 4986 .quant16AsymmOperands = {}, 4987 // int -> QUANT8_SYMM map 4988 .quant8SymmOperands = {}, 4989 }, 4990 //Output(s) 4991 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4992 // int -> Dimensions map 4993 .operandDimensions = {{0, {1, 3, 3, 1}}}, 4994 // int -> FLOAT32 map 4995 .float32Operands = {}, 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 = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5004 // int -> BOOL8 map 5005 .bool8Operands = {}, 5006 // int -> QUANT8_SYMM_PER_CHANNEL map 5007 .quant8ChannelOperands = {}, 5008 // int -> QUANT16_ASYMM map 5009 .quant16AsymmOperands = {}, 5010 // int -> QUANT8_SYMM map 5011 .quant8SymmOperands = {}, 5012 } 5013 }, 5014 }, // End of an example 5015 }; 5016 return examples_same_padding_stride_2_nhwc_weight_as_input_float16; 5017 }; 5018 5019 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw() { 5020 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw = { 5021 // Begin of an example 5022 { 5023 .operands = { 5024 //Input(s) 5025 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5026 // int -> Dimensions map 5027 .operandDimensions = {{0, {1, 1, 6, 6}}}, 5028 // int -> FLOAT32 map 5029 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5030 // int -> INT32 map 5031 .int32Operands = {}, 5032 // int -> QUANT8_ASYMM map 5033 .quant8AsymmOperands = {}, 5034 // int -> QUANT16_SYMM map 5035 .quant16SymmOperands = {}, 5036 // int -> FLOAT16 map 5037 .float16Operands = {}, 5038 // int -> BOOL8 map 5039 .bool8Operands = {}, 5040 // int -> QUANT8_SYMM_PER_CHANNEL map 5041 .quant8ChannelOperands = {}, 5042 // int -> QUANT16_ASYMM map 5043 .quant16AsymmOperands = {}, 5044 // int -> QUANT8_SYMM map 5045 .quant8SymmOperands = {}, 5046 }, 5047 //Output(s) 5048 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5049 // int -> Dimensions map 5050 .operandDimensions = {{0, {1, 1, 3, 3}}}, 5051 // int -> FLOAT32 map 5052 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5053 // int -> INT32 map 5054 .int32Operands = {}, 5055 // int -> QUANT8_ASYMM map 5056 .quant8AsymmOperands = {}, 5057 // int -> QUANT16_SYMM map 5058 .quant16SymmOperands = {}, 5059 // int -> FLOAT16 map 5060 .float16Operands = {}, 5061 // int -> BOOL8 map 5062 .bool8Operands = {}, 5063 // int -> QUANT8_SYMM_PER_CHANNEL map 5064 .quant8ChannelOperands = {}, 5065 // int -> QUANT16_ASYMM map 5066 .quant16AsymmOperands = {}, 5067 // int -> QUANT8_SYMM map 5068 .quant8SymmOperands = {}, 5069 } 5070 }, 5071 }, // End of an example 5072 }; 5073 return examples_same_padding_stride_2_nchw; 5074 }; 5075 5076 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_relaxed() { 5077 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_relaxed = { 5078 // Begin of an example 5079 { 5080 .operands = { 5081 //Input(s) 5082 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5083 // int -> Dimensions map 5084 .operandDimensions = {{0, {1, 1, 6, 6}}}, 5085 // int -> FLOAT32 map 5086 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5087 // int -> INT32 map 5088 .int32Operands = {}, 5089 // int -> QUANT8_ASYMM map 5090 .quant8AsymmOperands = {}, 5091 // int -> QUANT16_SYMM map 5092 .quant16SymmOperands = {}, 5093 // int -> FLOAT16 map 5094 .float16Operands = {}, 5095 // int -> BOOL8 map 5096 .bool8Operands = {}, 5097 // int -> QUANT8_SYMM_PER_CHANNEL map 5098 .quant8ChannelOperands = {}, 5099 // int -> QUANT16_ASYMM map 5100 .quant16AsymmOperands = {}, 5101 // int -> QUANT8_SYMM map 5102 .quant8SymmOperands = {}, 5103 }, 5104 //Output(s) 5105 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5106 // int -> Dimensions map 5107 .operandDimensions = {{0, {1, 1, 3, 3}}}, 5108 // int -> FLOAT32 map 5109 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5110 // int -> INT32 map 5111 .int32Operands = {}, 5112 // int -> QUANT8_ASYMM map 5113 .quant8AsymmOperands = {}, 5114 // int -> QUANT16_SYMM map 5115 .quant16SymmOperands = {}, 5116 // int -> FLOAT16 map 5117 .float16Operands = {}, 5118 // int -> BOOL8 map 5119 .bool8Operands = {}, 5120 // int -> QUANT8_SYMM_PER_CHANNEL map 5121 .quant8ChannelOperands = {}, 5122 // int -> QUANT16_ASYMM map 5123 .quant16AsymmOperands = {}, 5124 // int -> QUANT8_SYMM map 5125 .quant8SymmOperands = {}, 5126 } 5127 }, 5128 }, // End of an example 5129 }; 5130 return examples_same_padding_stride_2_nchw_relaxed; 5131 }; 5132 5133 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_quant8() { 5134 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_quant8 = { 5135 // Begin of an example 5136 { 5137 .operands = { 5138 //Input(s) 5139 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5140 // int -> Dimensions map 5141 .operandDimensions = {{0, {1, 1, 6, 6}}}, 5142 // int -> FLOAT32 map 5143 .float32Operands = {}, 5144 // int -> INT32 map 5145 .int32Operands = {}, 5146 // int -> QUANT8_ASYMM map 5147 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 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, 1, 3, 3}}}, 5165 // int -> FLOAT32 map 5166 .float32Operands = {}, 5167 // int -> INT32 map 5168 .int32Operands = {}, 5169 // int -> QUANT8_ASYMM map 5170 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 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_same_padding_stride_2_nchw_quant8; 5188 }; 5189 5190 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_float16() { 5191 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_float16 = { 5192 // Begin of an example 5193 { 5194 .operands = { 5195 //Input(s) 5196 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5197 // int -> Dimensions map 5198 .operandDimensions = {{0, {1, 1, 6, 6}}}, 5199 // int -> FLOAT32 map 5200 .float32Operands = {}, 5201 // int -> INT32 map 5202 .int32Operands = {}, 5203 // int -> QUANT8_ASYMM map 5204 .quant8AsymmOperands = {}, 5205 // int -> QUANT16_SYMM map 5206 .quant16SymmOperands = {}, 5207 // int -> FLOAT16 map 5208 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5209 // int -> BOOL8 map 5210 .bool8Operands = {}, 5211 // int -> QUANT8_SYMM_PER_CHANNEL map 5212 .quant8ChannelOperands = {}, 5213 // int -> QUANT16_ASYMM map 5214 .quant16AsymmOperands = {}, 5215 // int -> QUANT8_SYMM map 5216 .quant8SymmOperands = {}, 5217 }, 5218 //Output(s) 5219 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5220 // int -> Dimensions map 5221 .operandDimensions = {{0, {1, 1, 3, 3}}}, 5222 // int -> FLOAT32 map 5223 .float32Operands = {}, 5224 // int -> INT32 map 5225 .int32Operands = {}, 5226 // int -> QUANT8_ASYMM map 5227 .quant8AsymmOperands = {}, 5228 // int -> QUANT16_SYMM map 5229 .quant16SymmOperands = {}, 5230 // int -> FLOAT16 map 5231 .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5232 // int -> BOOL8 map 5233 .bool8Operands = {}, 5234 // int -> QUANT8_SYMM_PER_CHANNEL map 5235 .quant8ChannelOperands = {}, 5236 // int -> QUANT16_ASYMM map 5237 .quant16AsymmOperands = {}, 5238 // int -> QUANT8_SYMM map 5239 .quant8SymmOperands = {}, 5240 } 5241 }, 5242 }, // End of an example 5243 }; 5244 return examples_same_padding_stride_2_nchw_float16; 5245 }; 5246 5247 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input() { 5248 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input = { 5249 // Begin of an example 5250 { 5251 .operands = { 5252 //Input(s) 5253 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5254 // int -> Dimensions map 5255 .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5256 // int -> FLOAT32 map 5257 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 5258 // int -> INT32 map 5259 .int32Operands = {}, 5260 // int -> QUANT8_ASYMM map 5261 .quant8AsymmOperands = {}, 5262 // int -> QUANT16_SYMM map 5263 .quant16SymmOperands = {}, 5264 // int -> FLOAT16 map 5265 .float16Operands = {}, 5266 // int -> BOOL8 map 5267 .bool8Operands = {}, 5268 // int -> QUANT8_SYMM_PER_CHANNEL map 5269 .quant8ChannelOperands = {}, 5270 // int -> QUANT16_ASYMM map 5271 .quant16AsymmOperands = {}, 5272 // int -> QUANT8_SYMM map 5273 .quant8SymmOperands = {}, 5274 }, 5275 //Output(s) 5276 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5277 // int -> Dimensions map 5278 .operandDimensions = {{0, {1, 1, 3, 3}}}, 5279 // int -> FLOAT32 map 5280 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5281 // int -> INT32 map 5282 .int32Operands = {}, 5283 // int -> QUANT8_ASYMM map 5284 .quant8AsymmOperands = {}, 5285 // int -> QUANT16_SYMM map 5286 .quant16SymmOperands = {}, 5287 // int -> FLOAT16 map 5288 .float16Operands = {}, 5289 // int -> BOOL8 map 5290 .bool8Operands = {}, 5291 // int -> QUANT8_SYMM_PER_CHANNEL map 5292 .quant8ChannelOperands = {}, 5293 // int -> QUANT16_ASYMM map 5294 .quant16AsymmOperands = {}, 5295 // int -> QUANT8_SYMM map 5296 .quant8SymmOperands = {}, 5297 } 5298 }, 5299 }, // End of an example 5300 }; 5301 return examples_same_padding_stride_2_nchw_weight_as_input; 5302 }; 5303 5304 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input_relaxed() { 5305 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input_relaxed = { 5306 // Begin of an example 5307 { 5308 .operands = { 5309 //Input(s) 5310 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5311 // int -> Dimensions map 5312 .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5313 // int -> FLOAT32 map 5314 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 5315 // int -> INT32 map 5316 .int32Operands = {}, 5317 // int -> QUANT8_ASYMM map 5318 .quant8AsymmOperands = {}, 5319 // int -> QUANT16_SYMM map 5320 .quant16SymmOperands = {}, 5321 // int -> FLOAT16 map 5322 .float16Operands = {}, 5323 // int -> BOOL8 map 5324 .bool8Operands = {}, 5325 // int -> QUANT8_SYMM_PER_CHANNEL map 5326 .quant8ChannelOperands = {}, 5327 // int -> QUANT16_ASYMM map 5328 .quant16AsymmOperands = {}, 5329 // int -> QUANT8_SYMM map 5330 .quant8SymmOperands = {}, 5331 }, 5332 //Output(s) 5333 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5334 // int -> Dimensions map 5335 .operandDimensions = {{0, {1, 1, 3, 3}}}, 5336 // int -> FLOAT32 map 5337 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5338 // int -> INT32 map 5339 .int32Operands = {}, 5340 // int -> QUANT8_ASYMM map 5341 .quant8AsymmOperands = {}, 5342 // int -> QUANT16_SYMM map 5343 .quant16SymmOperands = {}, 5344 // int -> FLOAT16 map 5345 .float16Operands = {}, 5346 // int -> BOOL8 map 5347 .bool8Operands = {}, 5348 // int -> QUANT8_SYMM_PER_CHANNEL map 5349 .quant8ChannelOperands = {}, 5350 // int -> QUANT16_ASYMM map 5351 .quant16AsymmOperands = {}, 5352 // int -> QUANT8_SYMM map 5353 .quant8SymmOperands = {}, 5354 } 5355 }, 5356 }, // End of an example 5357 }; 5358 return examples_same_padding_stride_2_nchw_weight_as_input_relaxed; 5359 }; 5360 5361 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input_quant8() { 5362 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input_quant8 = { 5363 // Begin of an example 5364 { 5365 .operands = { 5366 //Input(s) 5367 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5368 // int -> Dimensions map 5369 .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5370 // int -> FLOAT32 map 5371 .float32Operands = {}, 5372 // int -> INT32 map 5373 .int32Operands = {{2, {0}}}, 5374 // int -> QUANT8_ASYMM map 5375 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}}, 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, 1, 3, 3}}}, 5393 // int -> FLOAT32 map 5394 .float32Operands = {}, 5395 // int -> INT32 map 5396 .int32Operands = {}, 5397 // int -> QUANT8_ASYMM map 5398 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 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_same_padding_stride_2_nchw_weight_as_input_quant8; 5416 }; 5417 5418 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input_float16() { 5419 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input_float16 = { 5420 // Begin of an example 5421 { 5422 .operands = { 5423 //Input(s) 5424 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5425 // int -> Dimensions map 5426 .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5427 // int -> FLOAT32 map 5428 .float32Operands = {}, 5429 // int -> INT32 map 5430 .int32Operands = {}, 5431 // int -> QUANT8_ASYMM map 5432 .quant8AsymmOperands = {}, 5433 // int -> QUANT16_SYMM map 5434 .quant16SymmOperands = {}, 5435 // int -> FLOAT16 map 5436 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 5437 // int -> BOOL8 map 5438 .bool8Operands = {}, 5439 // int -> QUANT8_SYMM_PER_CHANNEL map 5440 .quant8ChannelOperands = {}, 5441 // int -> QUANT16_ASYMM map 5442 .quant16AsymmOperands = {}, 5443 // int -> QUANT8_SYMM map 5444 .quant8SymmOperands = {}, 5445 }, 5446 //Output(s) 5447 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5448 // int -> Dimensions map 5449 .operandDimensions = {{0, {1, 1, 3, 3}}}, 5450 // int -> FLOAT32 map 5451 .float32Operands = {}, 5452 // int -> INT32 map 5453 .int32Operands = {}, 5454 // int -> QUANT8_ASYMM map 5455 .quant8AsymmOperands = {}, 5456 // int -> QUANT16_SYMM map 5457 .quant16SymmOperands = {}, 5458 // int -> FLOAT16 map 5459 .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5460 // int -> BOOL8 map 5461 .bool8Operands = {}, 5462 // int -> QUANT8_SYMM_PER_CHANNEL map 5463 .quant8ChannelOperands = {}, 5464 // int -> QUANT16_ASYMM map 5465 .quant16AsymmOperands = {}, 5466 // int -> QUANT8_SYMM map 5467 .quant8SymmOperands = {}, 5468 } 5469 }, 5470 }, // End of an example 5471 }; 5472 return examples_same_padding_stride_2_nchw_weight_as_input_float16; 5473 }; 5474 5475 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc() { 5476 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc = { 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, 6, 6, 1}}}, 5484 // int -> FLOAT32 map 5485 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5486 // int -> INT32 map 5487 .int32Operands = {}, 5488 // int -> QUANT8_ASYMM map 5489 .quant8AsymmOperands = {}, 5490 // int -> QUANT16_SYMM map 5491 .quant16SymmOperands = {}, 5492 // int -> FLOAT16 map 5493 .float16Operands = {}, 5494 // int -> BOOL8 map 5495 .bool8Operands = {}, 5496 // int -> QUANT8_SYMM_PER_CHANNEL map 5497 .quant8ChannelOperands = {}, 5498 // int -> QUANT16_ASYMM map 5499 .quant16AsymmOperands = {}, 5500 // int -> QUANT8_SYMM map 5501 .quant8SymmOperands = {}, 5502 }, 5503 //Output(s) 5504 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5505 // int -> Dimensions map 5506 .operandDimensions = {{0, {1, 3, 3, 1}}}, 5507 // int -> FLOAT32 map 5508 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 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 = {}, 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_same_padding_stride_2_dynamic_output_shape_nhwc; 5530 }; 5531 5532 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed() { 5533 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed = { 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, 6, 6, 1}}}, 5541 // int -> FLOAT32 map 5542 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5543 // int -> INT32 map 5544 .int32Operands = {}, 5545 // int -> QUANT8_ASYMM map 5546 .quant8AsymmOperands = {}, 5547 // int -> QUANT16_SYMM map 5548 .quant16SymmOperands = {}, 5549 // int -> FLOAT16 map 5550 .float16Operands = {}, 5551 // int -> BOOL8 map 5552 .bool8Operands = {}, 5553 // int -> QUANT8_SYMM_PER_CHANNEL map 5554 .quant8ChannelOperands = {}, 5555 // int -> QUANT16_ASYMM map 5556 .quant16AsymmOperands = {}, 5557 // int -> QUANT8_SYMM map 5558 .quant8SymmOperands = {}, 5559 }, 5560 //Output(s) 5561 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5562 // int -> Dimensions map 5563 .operandDimensions = {{0, {1, 3, 3, 1}}}, 5564 // int -> FLOAT32 map 5565 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 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 = {}, 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_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed; 5587 }; 5588 5589 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_quant8() { 5590 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_quant8 = { 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, 6, 6, 1}}}, 5598 // int -> FLOAT32 map 5599 .float32Operands = {}, 5600 // int -> INT32 map 5601 .int32Operands = {}, 5602 // int -> QUANT8_ASYMM map 5603 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 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, 3, 3, 1}}}, 5621 // int -> FLOAT32 map 5622 .float32Operands = {}, 5623 // int -> INT32 map 5624 .int32Operands = {}, 5625 // int -> QUANT8_ASYMM map 5626 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 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_same_padding_stride_2_dynamic_output_shape_nhwc_quant8; 5644 }; 5645 5646 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16() { 5647 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16 = { 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, 6, 6, 1}}}, 5655 // int -> FLOAT32 map 5656 .float32Operands = {}, 5657 // int -> INT32 map 5658 .int32Operands = {}, 5659 // int -> QUANT8_ASYMM map 5660 .quant8AsymmOperands = {}, 5661 // int -> QUANT16_SYMM map 5662 .quant16SymmOperands = {}, 5663 // int -> FLOAT16 map 5664 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5665 // int -> BOOL8 map 5666 .bool8Operands = {}, 5667 // int -> QUANT8_SYMM_PER_CHANNEL map 5668 .quant8ChannelOperands = {}, 5669 // int -> QUANT16_ASYMM map 5670 .quant16AsymmOperands = {}, 5671 // int -> QUANT8_SYMM map 5672 .quant8SymmOperands = {}, 5673 }, 5674 //Output(s) 5675 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5676 // int -> Dimensions map 5677 .operandDimensions = {{0, {1, 3, 3, 1}}}, 5678 // int -> FLOAT32 map 5679 .float32Operands = {}, 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 = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5688 // int -> BOOL8 map 5689 .bool8Operands = {}, 5690 // int -> QUANT8_SYMM_PER_CHANNEL map 5691 .quant8ChannelOperands = {}, 5692 // int -> QUANT16_ASYMM map 5693 .quant16AsymmOperands = {}, 5694 // int -> QUANT8_SYMM map 5695 .quant8SymmOperands = {}, 5696 } 5697 }, 5698 }, // End of an example 5699 }; 5700 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16; 5701 }; 5702 5703 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input() { 5704 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input = { 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, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5712 // int -> FLOAT32 map 5713 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.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, 3, 3, 1}}}, 5735 // int -> FLOAT32 map 5736 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.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_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input; 5758 }; 5759 5760 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed() { 5761 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed = { 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, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5769 // int -> FLOAT32 map 5770 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 5771 // int -> INT32 map 5772 .int32Operands = {}, 5773 // int -> QUANT8_ASYMM map 5774 .quant8AsymmOperands = {}, 5775 // int -> QUANT16_SYMM map 5776 .quant16SymmOperands = {}, 5777 // int -> FLOAT16 map 5778 .float16Operands = {}, 5779 // int -> BOOL8 map 5780 .bool8Operands = {}, 5781 // int -> QUANT8_SYMM_PER_CHANNEL map 5782 .quant8ChannelOperands = {}, 5783 // int -> QUANT16_ASYMM map 5784 .quant16AsymmOperands = {}, 5785 // int -> QUANT8_SYMM map 5786 .quant8SymmOperands = {}, 5787 }, 5788 //Output(s) 5789 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5790 // int -> Dimensions map 5791 .operandDimensions = {{0, {1, 3, 3, 1}}}, 5792 // int -> FLOAT32 map 5793 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.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_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed; 5815 }; 5816 5817 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_quant8() { 5818 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_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, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5826 // int -> FLOAT32 map 5827 .float32Operands = {}, 5828 // int -> INT32 map 5829 .int32Operands = {{2, {0}}}, 5830 // int -> QUANT8_ASYMM map 5831 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}}, 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, 3, 3, 1}}}, 5849 // int -> FLOAT32 map 5850 .float32Operands = {}, 5851 // int -> INT32 map 5852 .int32Operands = {}, 5853 // int -> QUANT8_ASYMM map 5854 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 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_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_quant8; 5872 }; 5873 5874 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16() { 5875 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16 = { 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, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 5883 // int -> FLOAT32 map 5884 .float32Operands = {}, 5885 // int -> INT32 map 5886 .int32Operands = {}, 5887 // int -> QUANT8_ASYMM map 5888 .quant8AsymmOperands = {}, 5889 // int -> QUANT16_SYMM map 5890 .quant16SymmOperands = {}, 5891 // int -> FLOAT16 map 5892 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 5893 // int -> BOOL8 map 5894 .bool8Operands = {}, 5895 // int -> QUANT8_SYMM_PER_CHANNEL map 5896 .quant8ChannelOperands = {}, 5897 // int -> QUANT16_ASYMM map 5898 .quant16AsymmOperands = {}, 5899 // int -> QUANT8_SYMM map 5900 .quant8SymmOperands = {}, 5901 }, 5902 //Output(s) 5903 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5904 // int -> Dimensions map 5905 .operandDimensions = {{0, {1, 3, 3, 1}}}, 5906 // int -> FLOAT32 map 5907 .float32Operands = {}, 5908 // int -> INT32 map 5909 .int32Operands = {}, 5910 // int -> QUANT8_ASYMM map 5911 .quant8AsymmOperands = {}, 5912 // int -> QUANT16_SYMM map 5913 .quant16SymmOperands = {}, 5914 // int -> FLOAT16 map 5915 .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5916 // int -> BOOL8 map 5917 .bool8Operands = {}, 5918 // int -> QUANT8_SYMM_PER_CHANNEL map 5919 .quant8ChannelOperands = {}, 5920 // int -> QUANT16_ASYMM map 5921 .quant16AsymmOperands = {}, 5922 // int -> QUANT8_SYMM map 5923 .quant8SymmOperands = {}, 5924 } 5925 }, 5926 }, // End of an example 5927 }; 5928 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16; 5929 }; 5930 5931 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw() { 5932 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw = { 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, 1, 6, 6}}}, 5940 // int -> FLOAT32 map 5941 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5942 // int -> INT32 map 5943 .int32Operands = {}, 5944 // int -> QUANT8_ASYMM map 5945 .quant8AsymmOperands = {}, 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, 1, 3, 3}}}, 5963 // int -> FLOAT32 map 5964 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 5965 // int -> INT32 map 5966 .int32Operands = {}, 5967 // int -> QUANT8_ASYMM map 5968 .quant8AsymmOperands = {}, 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_same_padding_stride_2_dynamic_output_shape_nchw; 5986 }; 5987 5988 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_relaxed() { 5989 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_relaxed = { 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, 1, 6, 6}}}, 5997 // int -> FLOAT32 map 5998 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 5999 // int -> INT32 map 6000 .int32Operands = {}, 6001 // int -> QUANT8_ASYMM map 6002 .quant8AsymmOperands = {}, 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, 1, 3, 3}}}, 6020 // int -> FLOAT32 map 6021 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 6022 // int -> INT32 map 6023 .int32Operands = {}, 6024 // int -> QUANT8_ASYMM map 6025 .quant8AsymmOperands = {}, 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_same_padding_stride_2_dynamic_output_shape_nchw_relaxed; 6043 }; 6044 6045 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_quant8() { 6046 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_quant8 = { 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, 1, 6, 6}}}, 6054 // int -> FLOAT32 map 6055 .float32Operands = {}, 6056 // int -> INT32 map 6057 .int32Operands = {}, 6058 // int -> QUANT8_ASYMM map 6059 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 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, 1, 3, 3}}}, 6077 // int -> FLOAT32 map 6078 .float32Operands = {}, 6079 // int -> INT32 map 6080 .int32Operands = {}, 6081 // int -> QUANT8_ASYMM map 6082 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 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_same_padding_stride_2_dynamic_output_shape_nchw_quant8; 6100 }; 6101 6102 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_float16() { 6103 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_float16 = { 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, 1, 6, 6}}}, 6111 // int -> FLOAT32 map 6112 .float32Operands = {}, 6113 // int -> INT32 map 6114 .int32Operands = {}, 6115 // int -> QUANT8_ASYMM map 6116 .quant8AsymmOperands = {}, 6117 // int -> QUANT16_SYMM map 6118 .quant16SymmOperands = {}, 6119 // int -> FLOAT16 map 6120 .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 6121 // int -> BOOL8 map 6122 .bool8Operands = {}, 6123 // int -> QUANT8_SYMM_PER_CHANNEL map 6124 .quant8ChannelOperands = {}, 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, 1, 3, 3}}}, 6134 // int -> FLOAT32 map 6135 .float32Operands = {}, 6136 // int -> INT32 map 6137 .int32Operands = {}, 6138 // int -> QUANT8_ASYMM map 6139 .quant8AsymmOperands = {}, 6140 // int -> QUANT16_SYMM map 6141 .quant16SymmOperands = {}, 6142 // int -> FLOAT16 map 6143 .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 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_same_padding_stride_2_dynamic_output_shape_nchw_float16; 6157 }; 6158 6159 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input() { 6160 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input = { 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, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 6168 // int -> FLOAT32 map 6169 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 6170 // int -> INT32 map 6171 .int32Operands = {}, 6172 // int -> QUANT8_ASYMM map 6173 .quant8AsymmOperands = {}, 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, 1, 3, 3}}}, 6191 // int -> FLOAT32 map 6192 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 6193 // int -> INT32 map 6194 .int32Operands = {}, 6195 // int -> QUANT8_ASYMM map 6196 .quant8AsymmOperands = {}, 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_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input; 6214 }; 6215 6216 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed() { 6217 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed = { 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, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 6225 // int -> FLOAT32 map 6226 .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 6227 // int -> INT32 map 6228 .int32Operands = {}, 6229 // int -> QUANT8_ASYMM map 6230 .quant8AsymmOperands = {}, 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 = {}, 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, 1, 3, 3}}}, 6248 // int -> FLOAT32 map 6249 .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}}, 6250 // int -> INT32 map 6251 .int32Operands = {}, 6252 // int -> QUANT8_ASYMM map 6253 .quant8AsymmOperands = {}, 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_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed; 6271 }; 6272 6273 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8() { 6274 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8 = { 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, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 6282 // int -> FLOAT32 map 6283 .float32Operands = {}, 6284 // int -> INT32 map 6285 .int32Operands = {{2, {0}}}, 6286 // int -> QUANT8_ASYMM map 6287 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}}, 6288 // int -> QUANT16_SYMM map 6289 .quant16SymmOperands = {}, 6290 // int -> FLOAT16 map 6291 .float16Operands = {}, 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, 1, 3, 3}}}, 6305 // int -> FLOAT32 map 6306 .float32Operands = {}, 6307 // int -> INT32 map 6308 .int32Operands = {}, 6309 // int -> QUANT8_ASYMM map 6310 .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}}, 6311 // int -> QUANT16_SYMM map 6312 .quant16SymmOperands = {}, 6313 // int -> FLOAT16 map 6314 .float16Operands = {}, 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_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8; 6328 }; 6329 6330 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16() { 6331 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16 = { 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, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}}, 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, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}}, 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, 1, 3, 3}}}, 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, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.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_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16; 6385 }; 6386 6387
